aboutsummaryrefslogtreecommitdiff
AgeCommit message (Collapse)Author
2014-06-27Updated README.md and added "write-file" test caseAdrian Kummerlaender
* slightly improved FunctionTransform test case utility templates
2014-06-26Implemented basic external "write-file" functionAdrian Kummerlaender
* accepts a path parameter and the content to be written * removed target parameter form FunctionTransform ** transformation result is now returned as a string *** nodeset return value is planned ** e.g. writing the result to the fs is optional and has to be achieved using FunctionWriteFile * changed "transform" test case accordingly * this marks a paradigm shift and is the continuation of the changes described in 741a70f ** InputXSLT now also implements a output function * added basic io error handling to FunctionReadFile
2014-06-25Added support for resolving non-existing pathsAdrian Kummerlaender
* previous logic for resolving boost::filesystem::path parameters in the XObjectValue class actively tried to resolve existing files ** this contradicts the planned introduction of e.g. a external "write-file" function * callers of external functions with path arguments now have to enclose them in square brackets if include path resolution is required ** analog to the usage of the "xsl:import" tag * moved "getPathFromSystemId" from compilation local method into static method of IncludeEntityResolver * changed test cases accordingly
2014-06-17Added context awareness to XObjectValue casting logicAdrian Kummerlaender
* added support for defining boost::filesystem::path as a external function parameter ** boost::filesystem::path parameters are resolved against the appropriate FilesystemContext and IncludeEntityResolver instances * xalan::XSLTInputSource parameter source paths are also resolved * removed need for passing a reference FilesystemContext to "constructDocument" methods ** they now only accept the parameters of the external function implemented by them ** all path resolution logic is wrapped by the newly created XObjectValue class * converted XObjectValue namespace into class ** the "get" template method is now a template member method ** this was needed to enable value casting logic to access the appropriate FilesystemContext and IncludeEntityResolver instances * this commit marks the next step towards the goals defined in 741a70f
2014-06-16Prepared TransformationFacade and FunctionTransform for parameter changeAdrian Kummerlaender
* FunctionTransform was adapted to support passing the transformation as either a string path or directly as a node-set / result-tree ** this in turn required changes to the TransformationFacade ** the implementation of a xalan::XSLTInputSource specialization for the XObjectValue::get template method was also required * changed ixslt executable to match TransformationFacade constructor changes * these changes were implemented in preparation for a restructuring of how the separate external functions provided by InputXSLT operate and work together ** the approach up until now was to provide non-combinable external functions for distinct task such as "read a file" and "transform that transformation using these parameters into that file" ** if you think about the areas of operations of these functions are overlapping quite a bit *** e.g. FunctionTransform reads files, transforms DOM structures and writes files instead of only transforming things ** the new approach will be to limit the feature set of each function in the attempt of making the clearer and increasing their combinability *** e.g. FunctionTransform won't read or write files but expect both the input-DOM and the transformation-DOM as node-sets or result trees and return the transformed document as a node-set to be written using FunctionWriteFile (to be implemented)
2014-06-15Merged "read-xml-file" and "read-file" into "read-file"Adrian Kummerlaender
* FunctionReadFile is now able to distinguish between XML files and plain text files ** it selects the appropriate course of action automatically ** reading the file as XML into the DOM or reading it as a string * the current selection criteria is the file extension ** I am thinking about trying to import every file into the DOM and using the result state of that action as selection criteria * Updated README.md and test cases accordingly
2014-06-14Changed Base::callConstructDocument sequence parameter to std::size_tAdrian Kummerlaender
* "unsigned" type led to a compiler error on 64bit systems ** the Sequence template uses std::size_t which resolves to "unsigned long" instead of "unsigned int" on 64bit systems ** as "unsigned" is resolved to "unsigned int" by the compiler this situation produced a type conflict * added recommendation for using a xalan library version built with ICU flags to README.md ** otherwise e.g. the "format-number" function is not fully supported
2014-06-11Fixed include entity resolution logicAdrian Kummerländer
* if a square bracket enclosed path can be extracted but not resolved against the include path vector we should return at least the extracted path and not the raw path * otherwise the system has no chance of correctly resolving things ** additionally error messages were showing the square bracket syntax instead of the actual path
2014-06-10Added input file support to ixsltAdrian Kummerländer
* a single file may be passed to the XSLT processor as input ** the file is read once and stored within a xalan::XalanParsedSource to be reused by all calls to "TransformationFacade::generate" * added appropriate TranformationFacade constructor overload ** this new constructor overload which is taking a path to both the transformation and the input file is the main constructor *** the old constructor is now only a alias for this new constructor * adapted static "try_create" TransformationFacade factory method into variadic template factory method * added optional "--input" argument to ixslt ** expanded option handling accordingly
2014-06-09Added include path resolution to FilesystemContext constructorAdrian Kummerländer
* extracted system id handling into separate "resolve" method overload of "IncludeEntityResolver" class * paths to be resolved against the include path vector are enclosed by square brackets ** FilesystemContext for external functions was instantiated using the unmodified systemId provided by xalan::Locator ** this commit adds include path resolution to that step *** exceptions were thrown as the program tried to instantiate a FilesystemContext instance without resolving the square bracket syntax * changed FunctionTransform "target" attribute content to the target path filename instead of the full path
2014-06-08Handling xercesc::DOMException in "read-xml-file" and "external-text-formatter"Adrian Kummerländer
* external DOM may cause xercesc::DOMException's to be thrown instead of passing all errors to the custom error handlers ** these exceptions are handled by this commit by setting the "result" attribute to "error" and adding "error" value nodes with further information
2014-06-07Provided previously missing Sequence template implementationAdrian Kummerländer
* implemented for commit 5f6fc45 but not included into that commit
2014-06-07Improved FunctionBase constructDocument parameter propagationAdrian Kummerländer
* replaced std::tuple constructing Mapper template methods with direct XObjectArgVectorType unpacking ** XObjectValue::get template method is applied directly using parameter pack unpacking * implemented custom IndexSequence / Sequence type to provide vector indexes * modified all external functions to provide matching constructDocument overloads
2014-06-06Implemented WarningCapacitor as a counterpart to ErrorCapacitorAdrian Kummerländer
* in difference to ErrorCapacitor this class doesn't throw an exception on "discharge" but returns the gathered warnings * adapted FunctionTransform and frontend error handling to include warnings * added static "try_create" method to TransformationFacade ** wraps construction error handling ** custom logic may be embedded using the std::function argument *** this was implemented to prevent unneccessary code duplication for handling both construction and generation errors * adapted FunctionTransform to return warning as "warning" nodes in the result tree ** added functional lambda expression factory method "handleErrors" *** returns a error handling lambda expression for a given ResultNodeFacade * implemented WarningGuard class in frontend executable ** guarantees warnings to be printed to std::cerr independent of any exceptions
2014-06-05Implemented ErrorMultiplexer as primary error handlerAdrian Kummerländer
* ErrorMultiplexer is derived from both xercesc::ErrorHandler and xalan::ProblemListener * registers itself as XalanTransformer's ErrorHandler and ProblemListener * distributes captured errors and warnings to all registered ErrorMultiplexer::Receiver instances ** ErrorCapacitor implements the ErrorMultiplexer::Receiver interface and as such registers itself in a given ErrorMultiplexer instance ** ErrorMultiplexer reduces the different xalan and xercesc internal error classifications into either warnings or errors * this was implemented to make it possible to easily differentiate between warnings and errors ** previously warnings were treated as errors ** ErrorCapacitor ignores warnings and only captures errors ** WarningCapacitor will be implemented to handle warnings during XSLT processing
2014-06-04Renamed "test" executable to "ixslt"Adrian Kummerländer
* improved "ixslt" frontend code structure ** extracted input, process and output logic into separate methods ** removed manual "--transformation" parameter check as it is defined as required
2014-06-03Updated README.md to include test casesAdrian Kummerländer
2014-06-03Replaced XSLTInputSource with LocalFileInputSource in "read-xml-file"Adrian Kummerländer
* removes xalan and boost::filesystem::fstream dependencies from FunctionReadXmlFile * xercesc provides a solution for loading files into it's XercesDOMParser class ** this should be used instead of building a custom replacement using boost's fstream and xalan::XSLTInputSource
2014-06-02Expanded ErrorCapacitor error message generationAdrian Kummerländer
* added entity, line and column information * formatting analog to ErrorCapacitor warning messages ** i.e. this commit implements functionality similar to "xalanc::ProblemListenerBase::defaultFormat" for "xercesc::ErrorHandler" exceptions
2014-06-01Simplified test case result variable definitionsAdrian Kummerländer
* variables containing the output of a external function can be defined using the "select" attribute ** tree-like definition is only needed when helper templates such as "transformer" are used ** queries on variables that are instantiated in this fashion need the "self::" prefix before base nodes * changed includes of the "testcase.xsl" base template to imports ** this signifies that the importing template is based on the imported template ** ... and this is exactly what we want to define
2014-05-31Revamped external function result treesAdrian Kummerländer
* the root node of the result tree of each function is a domain element ** i.e. the root node of "read-xml-file" is "file", the root node of "read-directory" is "directory" * the root node contains the result state of the function call encoded in a "result" attribute ** possible values are "success" and "error" ** the root node may contain additional attributes such as the target path of a called transformation * the actual function result is contained within the child nodes of the function root node ** i.e. the XML file tree returned by "read-xml-file" is a child of the function root node ** if specific errors occured they are also returned as child nodes of the function root node *** this is currently only the case for "transform" where transformation errors are returned as "error" value node childs of the function root node * updated test cases accordingly
2014-05-31Using xalan::ProblemListenerBase formatting functionality in ErrorCapacitorAdrian Kummerländer
* xalan::ProblemListenerBase provides a static member method called "defaultFormat" ** this method provides formatting of problem messages into xalan::XalanDOMString instances when combined with xalan::DOMStringPrintWriter * there is no need for implementing custom message formatting ** the only reason why ErrorCapacitor exists is so we are able to capture and print messages at our own volition
2014-05-30Rewrote error handling based on exceptionsAdrian Kummerländer
* ErrorHandler is replaced by ErrorCapacitor ** temporarily registers itself as both the ProblemListener and ErrorHandler of a given XalanTransformer instance ** deregisters itself on destruction ** collects all problems and errors during its lifetime inside a internal std::vector<std::string> instance ** if this instance is not empty it is thrown contained within a ErrorCapacitor::exception by the member method ErrorCapacitor::discharge * this enables using the same code for handling transformation compilation and generation errors and problems * updated test frontend accordingly
2014-05-30Removed custom XSLException patch as it is solved in XALANC-744Adrian Kummerländer
* the problem is described and solved in issue XALANC-744 ** https://issues.apache.org/jira/browse/XALANC-744 ** so there is no reason for providing a custom patch
2014-05-29Fixed error handling of invalid XSL transformationsAdrian Kummerländer
* xalan is segfaulting in XalanDOMString constructor when the static member "XalanLocator::getSystemId" is returning null-pointer ** this should seemingly be handled by passing a pointer to the static constant m_dummy but this sadly fails to prevent the segfault ** the patch provided by this commit fixes the problem for now but I cannot guarantee that this wont cause any side effects in a other context * Adapted TransformationFacade to handle errors during transformation compilation ** errors generated during transformation compilation are returned through the generate member method ** throwing an exeception during TransformationFacade construction would require additional error handling in the calling code * Added xalan::ProblemListener functionality to the ErrorHandler class ** XSLT problems passed to the ProblemListener are returned alongside to and treated as all other transformation errors
2014-05-29Improved TransformationFacade error handlingAdrian Kummerländer
* ErrorHandler class created in 5859cb6 now caches all errors instead of pushing them to std::cerr ** cached errors are retrieved by TransformationFacade's "generate" member method * test frontend pushes all errors to std::cerr * FunctionTransform returns errors to the calling template as XML ** FunctionTransform test case demonstrates how one may test for successful transformation * "generate" member method returns std::string vector wrapped in a std::unique_ptr ** this is used as a kind of optional pointer, as the std::unique_ptr instance only wraps a vector if errors where actually generated
2014-05-28Moved input trimming into XObjectValue namespaceAdrian Kummerländer
* std::string specialization of "get" template method * replaces FunctionTransform local input trimming implemented in 5859cb6
2014-05-28Implemented basic ErrorHandlerAdrian Kummerländer
* InputXSLT::ErrorHandler is derived from xercesc::ErrorHandler and enables contextual printing of transformation errors ** currently this means that the error messages passed to std::cerr contain the full path of the offending transformation * added input trimming to the external transform function ** calls to this function from inside a transformation may contain unnecessary whitespace characters which disrupt further processing
2014-05-27Expanded "read-directory" test caseAdrian Kummerländer
* verifying type attribute and extension value node if available
2014-05-26Added "external-text-formatter" test caseAdrian Kummerländer
* test case requires markdown.pl formatter to be available in "/usr/bin/" * updated README.md to mention "external-text-formatter" instead of "execute" * updated "read-directory" test case reference file * included library resolution test into "read-file" and "read-xml-file" test cases
2014-05-26Revamped external execute function into a external text formatter functionAdrian Kummerländer
* importing XML output of a called executable into the result document required special logic which clashed with a general execute function * general execute function may be implemented in the future ** support for external text formatters with XML output has a higher priority * current implementation enables calling a markdown parser and including the XHTML output into the document
2014-05-25Implemented basic external "execute" functionAdrian Kummerländer
* enables execution of external programs ** second parameter is passed to stdin ** stdout is captured and returned ** based on booost::process * this was implemented to enable access to external content preprocessors such as markdown
2014-05-24Prevented FilesystemContext from resolving absolute pathsAdrian Kummerländer
* there are situations where one may pass absolute paths to external functions which should not be resolved against the context path ** for example when reading files found by "read-directory" through its "full" value node * this could be checked by the external functions themself ** but as this check is required by all of them it is better implemented in the FilesystemContext
2014-05-24Implemented ResultNodeFacade as a DOM node construction helperAdrian Kummerländer
* wraps result node construction and appends it to root node on destruction * offers a simpler interface for common node construction patterns * simplifies result node construction in all external function implementations ** most noticeable in FunctionReadDirectory * expanded FunctionReadDirectory result nodes by name, extension, and full-path nodes
2014-05-23Changed iterate functor parameter to const referenceAdrian Kummerländer
* replaced ranged for loop with more appropriate std::for_each
2014-05-23Simplified IncludeEntityResolver constructor and improved constnessAdrian Kummerländer
* std::vector<FilesystemContext> instance is now const ** this required a constructor change * marked resolve member method as const as it doesn't need to modify anything ** this is also true for the overloaded resolveEntity member method ** the base class xercesc::EntityResolver prevents us from marking it as such
2014-05-22Replaced std::pair<bool, *> with the more convenient boost::optional<*>Adrian Kummerländer
* InputXSLT is dependent on boost anyway, so there is no argument to be made to emulate boost::optional using std::pair
2014-05-22Added include path resolution to external file access functionsAdrian Kummerländer
* if a given file can not be located relative to the transformation's location both "read-file" and "read-xml-file" will now try to resolve the path using the IncludeEntityResolver * all external functions based on the FunctionBase template are now provided with a pointer to a IncludeEntityResolver instance * it is determined by the external function implementation whether include path resolution will be used
2014-05-21Moved include path resolution into separate member methodAdrian Kummerländer
* enables access to include path resolution from external functions ** this will be useful to enable reading files from the include path using the external read-file or read-xml-file functions * moved file path extraction into a function local to the compilation unit
2014-05-21Added test case base template and improved transformer helper templateAdrian Kummerländer
* test case base template contains the basic test case markup ** it was mostly created to include include-path resolution into the test cases * improved transformer helper template by separating the external function call into its own variable
2014-05-20Replaced FunctionResolveInclude with IncludeEntityResolverAdrian Kummerländer
* xalan / xerces offers the possibility of implementing custom entity resolvers which are called upon by "<xsl:include..." ** such a custom resolver was implemented to resolve include path entities * this is a much better way to support include paths than offering a custom external "resolve-include" function * as entity paths are expanded before they are passed to the entity resolver, a special "[path]" syntax simmilar to "#include <path>" had to be implemented
2014-05-19Implemented external "resolve-include" functionAdrian Kummerländer
* resolves paths provided as strings against include paths provided through the newly created "--include" argument of the test executable * this was implemented to enable central collections of XSLT libraries simmilar to how there are C headers in "/usr/include"
2014-05-18Added possibility for streaming TransformationFacade outputAdrian Kummerländer
* added "std::basic_ostream<char>" taking "generate" member method overloads * marked cli parameter "target" as optional ** output is streamed to std::cout if target file is not provided
2014-05-17Improved FunctionTransform test case transformationsAdrian Kummerländer
* added basic "transformer" wrapper template to call "InputXSLT:transform" ** this removes the need to specifiy arguments in a separate xslt variable
2014-05-17Equalized parameter/argument naming pattern accross all external functionsAdrian Kummerländer
* names matter, from now on parameters to external functions will be called parameters uniformly instead of mixing arguments and parameters
2014-05-16Added XObjectPtr parameter to FunctionTransformAdrian Kummerländer
* the given XObject is passed to the called transformation ** this was done to enable templates to pass information to each other ** this should support any type usable in a XPath context to be passed as an argument * expanded FunctionTransform test case accordingly
2014-05-15Adapted FunctionBase template to accept multiple argument typesAdrian Kummerländer
* FunctionBase::argument_tuple is a std::tuple specialization type specialized on the argument types passed inside the variadic template argument of FunctionBase * added tuple Mapper and XObjectValue helper namespaces containing recursive tuple construction and XObjectPtr value extraction logic * changed all external function implementations accordingly * this change was implemented to uniformly support different external function argument types than std::string
2014-05-14Moved responsibility for argument conversion to FunctionBase descendantsAdrian Kummerländer
* external functions may expect arguments with a type different from boost::filesystem::path so they are only provided raw string values * moved xalan string conversion logic into separate compilation unit
2014-05-14Added ArgumentCount parameter to FunctionBase templateAdrian Kummerländer
* constructDocument member method is provided with a FunctionBase::argument_array instance * improved argument validation in FunctionBase * this parameter was added to support FunctionBase as a base class for FunctionTransform
2014-05-13Sorting FilesystemContext iteration resultsAdrian Kummerländer
* order of items in a directory was varying across platforms which hindered testability * they are now temporarily copied into a std::vector instance and then sorted using std::sort * updated "read_directory" test case reference file accordingly