| Age | Commit message (Collapse) | Author |
|---|
|
* 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
|
|
* 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
|
|
* 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)
|
|
* 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
|
|
* 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
|
|
* 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
|
|
* 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
|
|
* 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
|
|
* 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
|
|
* verifying type attribute and extension value node if available
|
|
* 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
|
|
* 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
|
|
* 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
|
|
* added basic "transformer" wrapper template to call "InputXSLT:transform"
** this removes the need to specifiy arguments in a separate xslt variable
|
|
* 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
|
|
* 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
|
|
* "InputXSLT:transform" expects two input arguments and executes the given transformation into the given target file
** this function respresents a important step in the direction of making it possible to write an actual static site generator on top of InputXSLT using XSLT
* added basic "transform" test case
* updated README.md to include this new function
|
|
* the transformation is now provided with default parameters such as the target file and its parent directory
* added appropriate test case
** default_params
* test frontend now doesn't provide a "test" parameter anymore
* extracted parameter setter into separate member method "setParameters" of TransformationFacade
|
|
* the directories below "./test" contain test cases
** "transformation.xsl" and the expected result as "reference.xml"
** tests are performed by "check.sh"
*** returns diff on error
* this system enables simple verification of external function results
** way simpler than C++ unit tests would be in this scenario
* expanded cmake instructions to automatically execute the test cases
* old example transformation was removed
|
