simple-xspec-wrapper 0.1.0-java

data/vendor/xspec-1.0.0/src/schemas/xspec.rnc

@@ -0,0 +1,304 @@
+# XSpec = XSLT Specifications
+# This schema is for XSpec documents, which can be used to describe the behaviour
+# of an XSLT application. They are similar to the RSpec documents used in RoR
+# testing, but for XSLT
+default namespace = "http://www.jenitennison.com/xslt/xspec"
+datatypes xs = "http://www.w3.org/2001/XMLSchema-datatypes"
+
+start = description
+
+description = 
+	## A description is a description of a stylesheet application. 
+	## It must have a stylesheet and/or a query it's associated with.
+	## It may also have a version to aid development over time.
+	element description { 
+		common-attributes,
+		attribute stylesheet { xs:anyURI }?,
+		attribute query { xs:anyURI }?,
+		attribute xslt-version { xs:NMTOKEN }?,
+		attribute query-at { xs:anyURI }?,
+		attribute version { xs:NMTOKEN }?,		
+		attribute preserve-space { xs:NMTOKENS }?,
+		attribute schematron { xs:anyURI }?,
+		(global-param | import | scenario | pending)+ }
+
+import = 
+	## An import brings in all the scenarios from the referenced file (which must
+	## itself be an XSpec description). All the unshared scenarios in that imported
+	## XSpec will be run on the stylesheet that this XSpec document describes.
+	## Importing is recursive and may be circular (although only one copy of a given
+	## imported document will actually be imported).
+	element import { common-attributes,
+	   ## The document URI (location) of the imported document.
+	   attribute href { xs:anyURI } }
+
+pending = 
+	## Anything that is within a <pending> element will remain untested, but will be
+	## reported as (eventual) desired behaviour. This is a good way of commenting out
+	## a set of behaviours that haven't been implemented yet, or scenarios whose
+	## desired behaviour hasn't been determined, or tests for code that you're not
+	## currently working on, to make the testing process faster.
+	##
+	## An optional label attribute can be used to describe why the scenario or
+	## assertion should not be tested.
+	element pending { common-attributes, label?, (scenario | assertion | schematron-assertion)* }
+
+scenario = 
+	## A scenario defines the environment in which a piece of processing takes place.
+	##
+	## Any parameters defined within a scenario equate to global (stylesheet)
+	## parameters.
+	##
+	## If a scenario has a pending attribute, this has the same semantics as
+	## wrapping the scenario in a <pending> element with a label equal to the value
+	## of the pending attribute.
+	##
+	## If any scenario has a focus attribute, any scenarios without a focus 
+	## attribute will be classed as pending.
+	element scenario { common-scenario-attributes, shared?,
+		label,
+		( matching-scenario |
+		  function-scenario |
+		  named-scenario | 
+		  schematron-scenario ) }
+
+common-scenario-attributes = common-attributes,
+                        	## Anything which has the @pending attribute will remain untested, but will be
+                        	## reported as (eventual) desired behaviour. This is a good way of commenting out
+                        	## a set of behaviours that haven't been implemented yet, or scenarios whose
+                        	## desired behaviour hasn't been determined, or tests for code that you're not
+                        	## currently working on, to make the testing process faster.
+                        	##
+                        	## The attribute value can be used to describe why the scenario or
+                        	## assertion should not be tested.
+                             attribute pending { text }?,
+                            ## If any scenario has a focus attribute, any scenarios without a focus 
+	                        ## attribute will be classed as pending.
+                             attribute focus { text }?
+
+label = 
+	## A scenario's label should describe the context that the scenario sets. Top-
+	## level scenarios' labels should be of the form "the square of a number" or 
+	## "the XHTML for a <P1> element". Nested scenario labels will usually start with 
+	## the word "with"; it should make sense if the labels of ancestor scenarios are 
+	## concatenated with this one. For example "with a Type attribute".
+	attribute label { text } |
+	element label { any-content }
+
+shared = 
+	## There are shared scenarios (shared="yes") and unshared scenarios (shared="no",
+	## the default). Shared scenarios can be referenced and reused by other scenarios
+	## with the <like> element. Unshared scenarios are simply run.
+	attribute shared { "yes" | "no" }
+
+like = 
+	## The <like> element pulls a shared scenario into this one (which may be shared
+	## or unshared). Any environment set within the shared scenario is merged with
+	## this one, and any tests in the shared scenario are run in addition to the
+	## ones in this scenario. This allows for modular, reusable sets of tests which
+	## can be applied in multiple contexts.
+	element like { common-attributes, label }
+
+## A matching scenario is one based on the application of templates to a
+## particular node. The <context> element defines <xsl:apply-templates> used to
+## process the node, and the <assertion> elements define the tests on that node.
+## Child scenarios can override the parameters in the context, and can provide
+## any missing values in the <context> (for example, if the context on the parent
+## scenario doesn't provide a mode, that could be provided by the child scenario).
+matching-scenario = context?,
+                    like*,
+                    (pending | assertion)*, 
+                    (pending | 
+                     element scenario { common-scenario-attributes, 
+                                        label, matching-scenario })*
+
+## A function scenario is one based on a call to a stylesheet function. The
+## <call> element defines the function call and the paraemeters passed to it
+## and the <assertion> elements test the result of the function. Child scenarios
+## can override the parameters in the function call.
+function-scenario = function-call?,
+                    like*,
+                    (pending | assertion)*,
+                    (pending | 
+                     element scenario { common-scenario-attributes,
+                                        label, function-scenario })*
+                      
+## A named scenario is one based on a call to a named template. The <call>
+## element defines the template call and the parameters passed to it and the
+## <assertion> elements test the result of the template call. Child scenarios
+## can override the parameters in the template call.
+named-scenario = context?,
+                 template-call?, 
+                 like*,
+                 (pending | assertion)*,
+                 (pending | 
+                  element scenario { common-scenario-attributes,
+                                     label, named-scenario })*
+                   
+context = 
+	## The <context> element defines a context node, the mode in which templates
+	## are applied to it, and any parameters included in the apply templates.
+	element context { 
+		common-attributes,
+		## The mode in which templates are applied to it, and any parameters included in the apply templates.
+		attribute mode { xs:QName }?,
+		template-param*,
+		node-selection
+	}
+
+function-call = 
+	## A <call> element either defines a function call or a template call and the
+	## parameters passed to it. 
+	element call {
+		common-attributes,
+		## The qualified name of the function which should get called.
+		attribute function { xs:QName }?,
+		function-param*
+	}
+
+template-call = 
+	## A <call> element either defines a function call or a template call and the
+	## parameters passed to it. 
+	element call {
+		common-attributes,
+		## The qualified name of the template which should get called.
+		attribute template { xs:QName }?,
+		template-param*
+	}
+
+global-param = 
+	## Global parameters are set globally, for the entire unit test suite. There's
+	## no way to set global parameters within a particular scenario (due to
+	## constraints on implementation).
+	element param { name, selection }
+
+template-param = element param { common-attributes, 
+                                 name, as?, 
+                                 attribute tunnel { "yes" | "no" }?, selection }
+
+function-param = element param { common-attributes,
+                                 name?, as?, position?, selection }
+
+name = attribute name { xs:QName }
+
+position = attribute position { xs:integer }
+
+as = attribute as { text }
+
+selection = node-selection | value-selection
+
+node-selection = 
+                 ## The document URI (location) of the imported document.
+                 attribute href { xs:anyURI }?,
+                 ## The XPath expression to access the selected node. 
+                 attribute select { xpath }?, 
+                 any-content
+
+value-selection =
+    ## The XPath expression to access the selected node. 
+    attribute select { xpath }
+
+xpath = text
+
+assertion = 
+	## An assertion's test XPath can either return a boolean value, in which case the 
+	## assertion succeeds only if the test is true; or a node, in which case the
+	## assertion succeeds only if the node is equal to the one specified with the
+	## href and select attributes or content of the <expect> element.
+	element expect { common-attributes,
+		label, test?, selection }
+
+test = attribute test { xpath }
+
+common-attributes = attribute xml:* { text }*
+
+any-content = mixed { any-element* }
+any-element = element * { attribute * { text }*, any-content }
+
+schematron-scenario = context?,
+                    like*,
+                    (pending | schematron-assertion | assertion)*, 
+                    (pending | 
+                     element scenario { common-scenario-attributes, 
+                                        label, schematron-scenario })*
+
+schematron-assertion =  
+    expect-assert | expect-not-assert | 
+    expect-report | expect-not-report | 
+    expect-valid | expect-rule
+
+expect-valid =
+    ## In a Schematron test, verify that the Schematron is executed and the XML 
+    ## that is provided as context passes validation.
+    ## 
+    ## In the Schematron an <assert> or <report> can have a <role> attribute 
+    ## specifying that it is a warning or informational message and these are 
+    ## considered to be allowed for a passing validation.
+    element expect-valid { empty }
+
+expect-assert = 
+    ## In a Schematron test, verify that an <assert> is thrown.
+    ## 
+    ## The attributes id, role, and location can be used in combination to 
+    ## identify a specific <assert>. 
+    element expect-assert {
+    schematron-common-expect,
+    schematron-count-expect
+}
+expect-report = 
+    ## In a Schematron test, verify that a <report> is thrown.
+    ## 
+    ## The attributes id, role, and location can be used in combination to 
+    ## identify a specific <report>. 
+    element expect-report {
+    schematron-common-expect,
+    schematron-count-expect
+}
+
+expect-not-assert = 
+    ## In a Schematron test, verify that an <assert> is not thrown.
+    ## 
+    ## The attributes id, role, and location can be used in combination to 
+    ## identify a specific <assert>. 
+    element expect-not-assert {
+    schematron-common-expect
+}
+expect-not-report = 
+    ## In a Schematron test, verify that a <report> is not thrown.
+    ## 
+    ## The attributes id, role, and location can be used in combination to 
+    ## identify a specific <report>. 
+    element expect-not-report {
+    schematron-common-expect
+}
+
+expect-rule = 
+    ## In a Schematron test, verify that a <rule> is fired.
+    element expect-rule {
+    ## Optional label to describe the expectation.
+    attribute label { text }?,
+    ## Identify a specific <rule> using its id attribute.
+    attribute id { xs:NCName }?,
+    ## Match a specific context attribute value of a <rule>.
+    attribute context { text }?,
+    schematron-count-expect
+}
+
+schematron-common-expect = 
+    ## Optional label to describe the expectation.
+    attribute label { text }?,
+    ## Identify a specific <assert> or <report> using its id attribute or 
+    ## the id attribute of the parent <rule>.
+    attribute id { xs:NCName }?,
+    ## Match a specific role attribute value of an <assert> or <report> or 
+    ## the parent <rule>. Role attribute values are often used to specify 
+    ## 'error', 'fatal', 'warn', 'warning', 'info', 'information'.
+    attribute role { text }?,
+    ## XPath of a location in the context XML that the <assert> or <report> 
+    ## is expected to find. Namespace prefixes that are defined in Schematron 
+    ## using ns elements can be used.
+    attribute location { xpath }?
+
+schematron-count-expect = 
+    ## Number of times an <assert> or <report> is expected to be thrown.
+    attribute count { xs:nonNegativeInteger }?

data/vendor/xspec-1.0.0/src/schematron/iso-schematron/iso_abstract_expand.xsl

@@ -0,0 +1,313 @@
+<?xml version="1.0" encoding="UTF-8"?><?xar XSLT?>
+
+<!-- 
+     OVERVIEW - iso_abstract_expand.xsl
+     
+	    This is a preprocessor for ISO Schematron, which implements abstract patterns. 
+	    It also 
+	       	* extracts a particular schema using an ID, where there are multiple 
+             schemas, such as when they are embedded in the same NVDL script 
+           * allows parameter substitution inside @context, @test, @select, @path
+	    	   * experimentally, allows parameter recognition and substitution inside
+             text (NOTE: to be removed, for compataibility with other implementations,   
+             please do not use this) 
+		
+		This should be used after iso-dsdl-include.xsl and before the skeleton or
+		meta-stylesheet (e.g. iso-svrl.xsl) . It only requires XSLT 1.
+		 
+		Each kind of inclusion can be turned off (or on) on the command line.
+		 
+-->
+
+<!--
+Open Source Initiative OSI - The MIT License:Licensing
+[OSI Approved License]
+
+This source code was previously available under the zlib/libpng license. 
+Attribution is polite.
+
+The MIT License
+
+Copyright (c) 2004-2010  Rick Jellife and Academia Sinica Computing Centre, Taiwan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+
+<!--
+VERSION INFORMATION
+  2013-09-19 RJ
+     * Allow macro expansion in  @path attributes, eg. for   sch:name/@path
+
+  2010-07-10 RJ
+  		* Move to MIT license
+  		
+  2008-09-18 RJ
+  		* move out param test from iso:schema template  to work with XSLT 1. (Noah Fontes)
+  		
+  2008-07-29 RJ 
+  		* Create.  Pull out as distinct XSL in its own namespace from old iso_pre_pro.xsl
+  		* Put everything in private namespace
+  		* Rewrite replace_substring named template so that copyright is clear
+  	
+  2008-07-24 RJ
+       * correct abstract patterns so for correct names: param/@name and
+     param/@value
+    
+  2007-01-12  RJ 
+     * Use ISO namespace
+     * Use pattern/@id not  pattern/@name 
+     * Add Oliver Becker's suggests from old Schematron-love-in list for <copy> 
+     * Add XT -ism?
+  2003 RJ
+     * Original written for old namespace
+     * http://www.topologi.com/resources/iso-pre-pro.xsl
+-->	
+<xslt:stylesheet version="1.0" xmlns:xslt="http://www.w3.org/1999/XSL/Transform" 
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+    xmlns:iso="http://purl.oclc.org/dsdl/schematron"  
+    xmlns:nvdl="http://purl.oclc.org/dsdl/nvdl"  
+    
+    xmlns:iae="http://www.schematron.com/namespace/iae" 
+     
+      >
+	
+	<xslt:param name="schema-id"></xslt:param>
+	
+	
+	<!-- Driver for the mode -->
+	<xsl:template match="/">
+  		<xsl:apply-templates select="." mode="iae:go" />
+	</xsl:template> 
+	
+	
+	<!-- ================================================================================== -->
+	<!-- Normal processing rules                                                            -->
+	<!-- ================================================================================== -->
+	<!-- Output only the selected schema --> 
+	<xslt:template match="iso:schema" >
+	    <xsl:if test="string-length($schema-id) =0 or @id= $schema-id ">
+	    	<xslt:copy>
+				<xslt:copy-of select="@*" />
+				<xslt:apply-templates  mode="iae:go" /> 
+			</xslt:copy>
+		</xsl:if>
+	</xslt:template>
+	
+ 
+	<!-- Strip out any foreign elements above the Schematron schema .
+		-->
+	<xslt:template match="*[not(ancestor-or-self::iso:*)]"     mode="iae:go"  >
+	   <xslt:apply-templates  mode="iae:go" />
+	</xslt:template>
+	   
+	
+	<!-- ================================================================================== -->
+	<!-- Handle Schematron abstract pattern preprocessing                                   -->
+	<!-- abstract-to-real calls
+			do-pattern calls 
+				macro-expand calls 
+					multi-macro-expand
+						replace-substring                                                   -->
+	<!-- ================================================================================== -->
+	
+	<!--
+		Abstract patterns allow you to say, for example
+		
+		<pattern name="htmlTable" is-a="table">
+			<param name="row" value="html:tr"/>
+			<param name="cell" value="html:td" />
+			<param name="table" value="html:table" />
+		</pattern>
+		
+		For a good introduction, see Uche Ogbujii's article for IBM DeveloperWorks
+		"Discover the flexibility of Schematron abstract patterns"
+		  http://www-128.ibm.com/developerworks/xml/library/x-stron.html
+		However, note that ISO Schematron uses @name and @value attributes on
+		the iso:param element, and @id not @name on the pattern element.
+		
+	-->
+	
+	<!-- Suppress declarations of abstract patterns -->
+	<xslt:template match="iso:pattern[@abstract='true']"  mode="iae:go"  >
+		<xslt:comment>Suppressed abstract pattern <xslt:value-of select="@id"/> was here</xslt:comment>	
+	</xslt:template> 
+	
+	
+	<!-- Suppress uses of abstract patterns -->
+	<xslt:template match="iso:pattern[@is-a]"  mode="iae:go" >
+			
+		<xslt:comment>Start pattern based on abstract <xslt:value-of select="@is-a"/></xslt:comment>
+		
+		<xslt:call-template name="iae:abstract-to-real" >
+			<xslt:with-param name="caller" select="@id" />
+			<xslt:with-param name="is-a" select="@is-a" />
+		</xslt:call-template>
+			
+	</xslt:template>
+	 
+	 
+	
+	<!-- output everything else unchanged -->
+	<xslt:template match="*" priority="-1"  mode="iae:go" >
+	    <xslt:copy>
+			<xslt:copy-of select="@*" />
+			<xslt:apply-templates mode="iae:go"/> 
+		</xslt:copy>
+	</xslt:template>
+	
+	<!-- Templates for macro expansion of abstract patterns -->
+	<!-- Sets up the initial conditions for the recursive call -->
+	<xslt:template name="iae:macro-expand">
+		<xslt:param name="caller"/>
+		<xslt:param name="text" />
+		<xslt:call-template name="iae:multi-macro-expand">
+			<xslt:with-param name="caller" select="$caller"/>
+			<xslt:with-param name="text" select="$text"/>
+			<xslt:with-param name="paramNumber" select="1"/>
+		</xslt:call-template>
+		
+	</xslt:template>
+	
+	<!-- Template to replace the current parameter and then
+	   recurse to replace subsequent parameters. -->
+	    
+	<xslt:template name="iae:multi-macro-expand">
+		<xslt:param name="caller"/>
+		<xslt:param name="text" />
+		<xslt:param name="paramNumber" />
+
+		
+		<xslt:choose>
+			<xslt:when test="//iso:pattern[@id=$caller]/iso:param[ $paramNumber]">
+
+				<xslt:call-template name="iae:multi-macro-expand">
+					<xslt:with-param name="caller" select="$caller"/>	
+					<xslt:with-param name="paramNumber" select="$paramNumber + 1"/>		
+					<xslt:with-param name="text" >
+						<xslt:call-template name="iae:replace-substring">
+							<xslt:with-param name="original" select="$text"/>
+							<xslt:with-param name="substring"
+							select="concat('$', //iso:pattern[@id=$caller]/iso:param[ $paramNumber ]/@name)"/>
+							<xslt:with-param name="replacement"
+								select="//iso:pattern[@id=$caller]/iso:param[ $paramNumber ]/@value"/>			
+						</xslt:call-template>
+					</xslt:with-param>						
+				</xslt:call-template>
+			</xslt:when>
+			<xslt:otherwise><xslt:value-of select="$text" /></xslt:otherwise>		
+		
+		</xslt:choose>
+	</xslt:template>
+	
+	
+	<!-- generate the real pattern from an abstract pattern + parameters-->
+	<xslt:template name="iae:abstract-to-real" >
+		<xslt:param name="caller"/>
+		<xslt:param name="is-a" />
+		<xslt:for-each select="//iso:pattern[@id= $is-a]">
+		<xslt:copy>
+		
+		    <xslt:choose>
+		      <xslt:when test=" string-length( $caller ) = 0">
+		      <xslt:attribute name="id"><xslt:value-of select="concat( generate-id(.) , $is-a)" /></xslt:attribute>
+		      </xslt:when>
+		      <xslt:otherwise>
+				<xslt:attribute name="id"><xslt:value-of select="$caller" /></xslt:attribute>
+		      </xslt:otherwise>
+		    </xslt:choose> 
+			
+			<xslt:apply-templates select="*|text()" mode="iae:do-pattern"    >
+				<xslt:with-param name="caller"><xslt:value-of select="$caller"/></xslt:with-param>
+			</xslt:apply-templates>	
+			
+		</xslt:copy>
+		</xslt:for-each>
+	</xslt:template>
+		
+	
+	<!-- Generate a non-abstract pattern -->
+	<xslt:template mode="iae:do-pattern" match="*">
+		<xslt:param name="caller"/>
+		<xslt:copy>
+			<xslt:for-each select="@*[name()='test' or name()='context' or name()='select'   or name()='path'  ]">
+				<xslt:attribute name="{name()}">
+				<xslt:call-template name="iae:macro-expand">
+						<xslt:with-param name="text"><xslt:value-of select="."/></xslt:with-param>
+						<xslt:with-param name="caller"><xslt:value-of select="$caller"/></xslt:with-param>
+					</xslt:call-template>
+				</xslt:attribute>
+			</xslt:for-each>	
+			<xslt:copy-of select="@*[name()!='test'][name()!='context'][name()!='select'][name()!='path']" />
+			<xsl:for-each select="node()">
+				<xsl:choose>
+				    <!-- Experiment: replace macros in text as well, to allow parameterized assertions
+				        and so on, without having to have spurious <iso:value-of> calls and multiple
+				        delimiting.
+                NOTE: THIS FUNCTIONALITY WILL BE REMOVED IN THE FUTURE    -->
+					<xsl:when test="self::text()">	
+						<xslt:call-template name="iae:macro-expand">
+							<xslt:with-param name="text"><xslt:value-of select="."/></xslt:with-param>
+							<xslt:with-param name="caller"><xslt:value-of select="$caller"/></xslt:with-param>
+						</xslt:call-template>
+					</xsl:when>
+					<xsl:otherwise>
+						<xslt:apply-templates select="." mode="iae:do-pattern">
+							<xslt:with-param name="caller"><xslt:value-of select="$caller"/></xslt:with-param>
+						</xslt:apply-templates>		
+					</xsl:otherwise>
+				</xsl:choose>
+			</xsl:for-each>			
+		</xslt:copy>
+	</xslt:template>
+	
+	<!-- UTILITIES --> 
+	<!-- Simple version of replace-substring function -->
+	<xslt:template name="iae:replace-substring">
+		<xslt:param name="original" />    
+		<xslt:param name="substring" />   
+		<xslt:param name="replacement" select="''"/>
+		
+  <xsl:choose>
+    <xsl:when test="not($original)" /> 
+    <xsl:when test="not(string($substring))">
+      <xsl:value-of select="$original" />
+    </xsl:when> 
+        <xsl:when test="contains($original, $substring)">
+          <xsl:variable name="before" select="substring-before($original, $substring)" />
+          <xsl:variable name="after" select="substring-after($original, $substring)" />
+          
+          <xsl:value-of select="$before" />
+          <xsl:value-of select="$replacement" />
+          <!-- recursion -->
+          <xsl:call-template name="iae:replace-substring">
+            <xsl:with-param name="original" select="$after" />
+            <xsl:with-param name="substring" select="$substring" />
+            <xsl:with-param name="replacement" select="$replacement" /> 
+            </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+        	<!-- no substitution -->
+        	<xsl:value-of select="$original" />
+        </xsl:otherwise>
+      </xsl:choose> 
+</xslt:template>
+
+
+
+</xslt:stylesheet>