aboutsummaryrefslogtreecommitdiff
path: root/src
AgeCommit message (Collapse)Author
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-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-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-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
2014-05-12Implemented basic external transform functionAdrian Kummerländer
* "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
2014-05-11Switched internal DomDocumentCache structure to std::stackAdrian Kummerländer
* using std::unordered_map for named cache lookups was a nice idea but is not useful when one keeps in mind that: ** we don't want cached external function responses in a situation where we are able to execute transformations inside transformations ** cached responses mean that we can not read a xml file, overwrite it using another transformation and then read it again * the currently available InputXSLT frontend only processes a single transformation anyway, so increased memory requirements should not pose a problem ** if a future frontend should offer batch processing of transformation tasks, one could implement a cache reset method to free memory after a transformation has been processed
2014-05-10Implemented StylesheetParameterGuard classAdrian Kummerländer
* removes responsibility for clearing parameters from the generate member methods * abstracts parameter escaping and setting and handles map conversion * marked actual generate member method as private and added StylesheetParameterGuard reference argument ** "frontend" generate member methods instantiate a StylesheetParameterGuard instance and pass it to the actual generate method ** this enables central default parameter definition while offering the possibility for custom parameters
2014-05-09Added default target file and path parametersAdrian Kummerländer
* 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
2014-05-09Marked DomDocumentCache::item class as privateAdrian Kummerländer
* as the xerces document is not instantiated by DomDocumentCache::item and the class only exports a pointer to the converted xalan document, it makes no sense to expose the class to the outside in the first place
2014-05-08Removed gtest based test cases and added program optionsAdrian Kummerländer
* selectively testing document construction in plain C++ code has turned out to be more work than worth it ** i.e. removed test cases and GTest dependency * added boost::program_options based frontent to InputXSLT ** example command: "./test --transformation ../dummy/transform.xsl --target out.xml" ** the plan is to use a simple shell script that generated test transformations and compares the output to reference files
2014-05-06Added basic external read file function test caseAdrian Kummerländer
* ... as a test of how well we are able to test DOM structures * required change of constructDocument visibility
2014-05-05Encapsulated common parts of external function inplementationsAdrian Kummerländer
* common parts were moved into CRTP template base class _FunctionBase_ * all external functions are derived from that class ** only have to implement _constructDocument_ member method ** currently only supports a single string input parameter which is enough for now * this change condenses external funtion implementations to the essential and should increase readability as well as maintainability
2014-05-04Moved DOM document construction logic into local functionsAdrian Kummerländer
* this change makes the underlying similarity between all currently implemented external functions obvious * they more or less only differ in their document construction logic ** i.e. there is a possibility for a second layer of abstraction between the classes derived from xalan::Function and the actual functionality * added boost::filesystem::path taking overload of the _iterate_ member method to FilesystemGuard ** this overload functions as the _master_ overload that is called by all other overloads which merely perform type conversion and path resolution ** this overload doesn't perform path resolution
2014-05-04Changed FilesystemContext constructor to accept xalan::Locator*Adrian Kummerländer
* all instantiations of a FilesystemContext are currently based on information provided by a xalan::Locator instance provided to the external function execute member method * this change hides the stylesheet path extraction from the actual function implementation
2014-05-03Revamped DomDocumentCache with regard to thread safetyAdrian Kummerländer
* DomDocumentCache::item class now is _finalized_ by default and doesn't perform document instantiation, just lifetime management ** xercesc::DOMDocument is instantiated inside the external function implementations and committed to the document cache for conversion to a xalan document * added mutex with scoped lock to prevent concurrent write access to the std::unordered_map contained withing DomDocumentCache * functionality of the _get_ member method was split into _get_ and _create_ ** added typedef for std::pair specialization type "optional_item" that functions as the return value of _create_ and _get_ * "locator->getSystemId()" was leaking memory as xerces doesn't manage the lifetime of the returned heap-allocated char array ** analog to XMLCh* strings ** transformed XercesStringGuard into template class to be instantiated on either XMLCh or char
2014-05-02Changed external functions to enable global installationAdrian Kummerländer
* up until now all external functions were locally installed to a specific XalanTransformer instance contained within a TransformationGuard instance ** this had to change as I planned to add a "execute-transformation" function based on TransformationGuard which would have led to recursive self-instantiation ** global external functions have to be thread-safe * as global external function can not be provided with a reference to a transformation-specific FilesystemFacade instance, the working path is now determined using xalan::Locator ** currently using pointer arithmetics on XMLCh* to remove the "file://" prefix of the URI returned by locator->getSystemId(), may be unsafe * added compilation unit for PlattformGuard as it now contains function installation in addition to plattform lifetime management
2014-05-01Added basic parameter taking overload of TransformationFacade::generateAdrian Kummerländer
* XSLT stylesheets may be provided with a set of initial parameters ** these parameters can be provided as the second argument to the generate member method in the form of a string to string mapping ** the XSLT standard also permitts number and node set types as value arguments of such input parameters but this is not supported by this change * expanded test transformation to demonstrate this feature
2014-05-01Changed namespace for external functions to InputXSLTAdrian Kummerländer
* "InputXSLT" is defined as "function.inputxslt.application" * functions can now be accessed like "InputXSLT:read-file('../')" * updated test transformation accordingly * the XML standard does not require namespaces to be real, valid HTTP-URIs but treats them as plain strings
2014-04-30Moved file reading functionality into local functionsAdrian Kummerländer
* it was moved into functions local to the respective compilation unit to improve readability ** splits DOM tree construction logic from the actual purpose of the external function
2014-04-29Simplified external function result node setAdrian Kummerländer
* all functions return a single "error" node in the case that something went wrong * otherwise they return one or more "result" nodes that contain the function results and may be distinguished by one or more attributes * this makes handling the return values easier and more pleasing to the eye as not everything has to be prefixed by "self::*" * updated test transformation accordingly
2014-04-28Adapted read-directory tree construction to match the other functionsAdrian Kummerländer
* throwing std::out_of_range exception from DomDocumentCache::get instead of returning nullptr in case of a problem * moved xalanToString method back into FilesystemContext compilation unit as is only needed there
2014-04-27Added status information to external read-xml-file functionAdrian Kummerländer
* XML tree is contained below the _content_ node if read was successful ** status is set to error otherwise * updated test transformation accordingly
2014-04-26Added status information to external read-directory functionAdrian Kummerländer
* updated test transformation accordingly
2014-04-26Converted external read-file function output into a node setAdrian Kummerländer
* A call to _read-file_ now returns a _content_ and _status_ node ** this enables XSL transformations to easily react to io related errors * fixed bug in path resolution ** boost::filesystem _canonical_ method is throwing and exception when the given path does not exist, this pulled down the whole stack ** replaced call to _canonical_ with call to _absolute_ which does not have this requirement
2014-04-26Moved DomDocumentCache instances back into external function classAdrian Kummerländer
* A global DomDocumentCache instance would require key prefixing * switched internal data structure to std::unordered_map for average constant time access
2014-04-26Implemented global DOM document cacheAdrian Kummerländer
* the plan to return XML-nodes from each external function requires a better way to manage the lifetime of many xerces DOM document instances and their support class instances ** this is why DomDocumentCache and DomDocumentCache::item were implemented ** based on std::map so we can easily access the result of old function calls * changed external read-directory function to return the children of the document node instead of the document node itself ** removes unnecessary cruft in function calls ** will make returning status codes alongside the function result more pleasing to the eye * updated test transformation to reflect new features
2014-04-25Improved argument resolution and error handlingAdrian Kummerländer
* execute member method internal argument count checks are not needed when using between one and two arguments ** xalan automatically generates the appropriate message containing the getError message when only offered fixed argument execute member overloads * improved FunctionReadDirectory attribute element generation * added additional validations to FunctionReadFile and FunctionReadXMLFile * I plan to return errors inside a DOM tree alongside the function return values in the future
2014-04-24Added XercesStringGuard scope-guard to manage XMLChAdrian Kummerländer
* xercesc requires XMLCh* strings to be hand-allocated and released using the XMLString class * XercesStringGuard works as a scope-guard for XMLCh* string lifetime and greatly simplifies xerces DOM construction
2014-04-24Expanded FunctionReadDirectory class to return files and directoriesAdrian Kummerländer
* they are marked appropriately by a _type_ attribute
2014-04-24Changed TransformerFacade into TransformationFacade for single XSLTsAdrian Kummerländer
* contains a single, compiled transformation as specified by its construction argument * uses the transformation's location as the FilesystemContext * allows generation of output documents using _generate_ member method
2014-04-23Fixed xerces DOM construction related memory leaksAdrian Kummerländer
* Wrapped xerces DOM and support class instances in now DomDocumentGuard scope-guard class * FunctionReadDirectory class contains interal std::stack instance to store DomDocumentGuard instances ** wrapped in std::shared_ptr as FunctionReadDirectory is internally cloned by xalan... ** this is needed as the DOM has to preserved longer than the external function execution scope * Sadly XMLCh xerces strings have to be manually released ** added appropriate xercesc::XMLString::release calls * xalan::XercesDOMWrapperParsedSource does not mirror a given xerces DOM but convert it on instantiation ** this is why there is a dedicated finalize member method in InputXSLT::DomDocumentGuard * In short: I do not like the amount of trickery needed to simply prevent memory leaks in this context ** there sadly doesn't seem to be a substantially easier way to return arbitrary DOM trees from a external function
2014-04-23Switched read-directory nodeSet generation to a xerces DOM documentAdrian Kummerländer
* replacement for manual XML construction * currently leaks memory as the objects have to exist out of scope and I have not yet thought of how to best manage their lifetime
2014-04-22Implemented basic XML output of external read-directory functionAdrian Kummerländer
* output is generated from XML hand-generated in a std::stringstream ** while this works reasonably well it is not how it should by done, i.e. this will have to be reimplemented using xerces / xalan constructs ** => this is intended to try out how a read-directory could work in a XSLT context
2014-04-21Implemented basic external directory traversal functionAdrian Kummerländer
* _read-directory_ lists all files in a given directory ** currently text-only output, xml planned * improved FilesystemContext path resolution (relative path is fully resolved by boost::filesystem)
2014-04-21Extracted filesystem path resolution into InputXSLT::FilesystemContextAdrian Kummerländer
* this class provides methods for resolving paths relative to the contained base path * other filesystem interaction methods will also be implemented in this class ** for instance directory traversal