saxon-xslt 0.5.1-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69ba3f6f9956b33cc7dc283bd45612363ad81f63
-  data.tar.gz: 2b1391e74ef5bdcdd0588ceffaf9be97df313ff8
+  metadata.gz: af91b7c69d754725f26d768b1866057099101db0
+  data.tar.gz: 808008c7ca54ec9914f6317664977bb0f9ead2c3
 SHA512:
-  metadata.gz: 0903c2754a622c08d40a901534443ea3e9c54a41206a124d1ee8e066d3db5b10ae28fe0320b4a63d720c9781bd531e7c1160f76b7cf493b7f506911fcfabaabb
-  data.tar.gz: 46ee2706c0df6d6dbe1ab979fb02564533fd3c0546104cad49c3bf5b4efcec937fe1b704ad2c9c6f94cb5061ec51971b30871c764e35878729892e73229498f3
+  metadata.gz: eadf0c7d72d149475479e11845ae9618506f33741b15c4878ff9f44c2a1f5b0a2ae3b186db6cebbfc5258dbe7ba1718152dd9c80c0a02bcda98c501665fff3bb
+  data.tar.gz: c350adfe866ea020afa4b81b3e7a949d2c18d8942fb40b8d3063ca6c29ecbb75151f8552e968a088e360405ceed653e13819f9b7a947fd91e2639089ba8d57c6

data/README.md

@@ -35,8 +35,25 @@ input = Saxon.XML(File.open('/path/to/your.xml'))
 output = transformer.transform(input)
 ```
 
+XSL parameters can be passed to #transform as a flat array of name, value pairs, or as a hash, e.g.
+
+```ruby
+output = transformer.transform(input, ["my-param", "'my-value'",
+                                       "my-other-param", "/take-from@id"])
+
+# or
+
+output = transformer.transform(input, {"my-param" => "'my-value'",
+                                       "my-other-param" => "/take-from@id"})
+```
+
+For those familiar with the Saxon API, names are passed directly to the QName constructor. 
+
+Values are evaluated as XPath expressions in context of the document being transformed; this means
+that, to pass a string, you must pass an XPath that resolves to a string, i.e. "'You must wrap strings in quotes'" 
+
 ## Saxon version
-`saxon-xslt` 0.5 includes Saxon HE 9.5.1.7
+`saxon-xslt` 0.6 includes Saxon HE 9.5.1.7
 
 ## Differences between Saxon and Nokogiri
 

data/lib/saxon/s9api.rb

@@ -7,5 +7,6 @@ module Saxon
   module S9API
     java_import 'net.sf.saxon.s9api.Processor'
     java_import 'net.sf.saxon.s9api.XdmDestination'
+    java_import 'net.sf.saxon.s9api.QName'
   end
 end

data/lib/saxon/xml.rb

@@ -14,6 +14,7 @@ module Saxon
   module XML
     # Parse an XML File or String into a Document object
     class Document
+      # @api private
       # @param [Saxon::Processor] processor The processor object which should
       #   be used to build the document
       # @param [String, File, IO] string_or_io The input XML
@@ -26,6 +27,13 @@ module Saxon
         new(xdm_document)
       end
 
+      # @param [String] expr The XPath expression to evaluate
+      # @return [net.sf.saxon.s9api.XdmValue] return the value, node, or
+      #   nodes selected
+      def xpath(expr)
+        processor.to_java.new_xpath_compiler.evaluate(expr, @xdm_document)
+      end
+
       # @api private
       def initialize(xdm_document)
         @xdm_document = xdm_document

data/lib/saxon/xslt/version.rb

@@ -1,5 +1,5 @@
 module Saxon
   module XSLT
-    VERSION = "0.5.1"
+    VERSION = "0.6.0"
   end
 end

data/lib/saxon/xslt.rb

@@ -15,6 +15,7 @@ module Saxon
   module XSLT
     # a Stylesheet transforms input (XML) into output
     class Stylesheet
+      # @api private
       # @param processor [Saxon::Processor] the Saxon processor object
       # @param string_or_io [File, IO, String] the input XSLT
       # @param opts [Hash] Stylesheet and input options
@@ -24,6 +25,15 @@ module Saxon
         new(source)
       end
 
+      # Compile a stylesheet from an existing Saxon::XML instance of an XSLT
+      # source
+      #
+      # @param [Saxon::XML::Document] source the input XSLT as an XML document
+      # @return [Saxon::XSLT::Stylesheet] the compiled XSLT stylesheet
+      def self.parse_stylesheet_doc(document)
+        new(document)
+      end
+
       # @param [Saxon::XML::Document] source the input XSLT as an XML document
       def initialize(source)
         processor = source.processor
@@ -32,17 +42,64 @@ module Saxon
       end
 
       # Transform an input document
-      # @param [Saxon::XML::Document] document the XML Document object to 
+      #
+      # To pass global parameters you can pass a hash with parameter names as
+      # keys and values as XPath expressions as values: to pass a string value,
+      # you need to pass it quoted: `"'string'"`. An unquoted string is an
+      # XPath reference into the document being transformed.
+      #
+      # @param [Saxon::XML::Document] document the XML Document object to
       #   transform
-      # @return a Saxon::XML::Document object
-      def transform(document)
+      # @param params [Hash,Array] xsl params to set in the xsl document
+      # @return [Saxon::XML::Document] the transformed XML Document
+      def transform(document, params = {})
         output = S9API::XdmDestination.new
         transformer = @xslt.load
         transformer.setInitialContextNode(document.to_java)
         transformer.setDestination(output)
+        set_params(transformer, document, params)
         transformer.transform
         Saxon::XML::Document.new(output.getXdmNode)
       end
+
+      # Transform an input document and return the result as a string.
+      #
+      # See #transform for details of params handling
+      # @param [Saxon::XML::Document] document the XML Document object to
+      #   transform
+      # @param params [Hash,Array] xsl params to set in the xsl document
+      # @return [String] the transformed XML Document serialised to a string
+      def apply_to(document, params = {})
+        serialize(transform(document, params))
+      end
+
+      # Serialise a document to a string
+      #
+      # Not the most useful serialiser in the world. Provided for Nokogiri API
+      # compatibility
+      #
+      # @param [Saxon::XML::Document] document the XML Document object to
+      #   serialise
+      # @return [String] the XML Document serialised to a string
+      def serialize(document)
+        document.to_s
+      end
+
+      private
+
+      def set_params(transformer, document, params)
+        case params
+        when Hash
+          params.each do |k,v|
+            transformer.setParameter(S9API::QName.new(k), document.xpath(v))
+          end
+        when Array
+          params.each_slice(2) do |k,v|
+            raise ArgumentError.new("Odd number of values passed as params: #{params}") if v.nil?
+            transformer.setParameter(S9API::QName.new(k), document.xpath(v))
+          end
+        end
+      end
     end
   end
 end

data/spec/fixtures/eg.xsl

@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
-    <xsl:template match="input">
-      <output/>
-    </xsl:template>
-    <xsl:template match="output">
-      <piped/>
-    </xsl:template>
+  <xsl:param name="testparam">default</xsl:param>
+  <xsl:template match="input">
+    <output/>
+  </xsl:template>
+  <xsl:template match="output">
+    <piped/>
+  </xsl:template>
 </xsl:stylesheet>

data/spec/fixtures/params-eg.xsl

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
+  <xsl:param name="testparam">default</xsl:param>
+  <xsl:template match="input">
+    <xsl:choose>
+      <xsl:when test="$testparam = 'default'">
+        <output/>
+      </xsl:when>
+      <xsl:when test="$testparam = 'input'">
+        <output>
+          Select works
+        </output>
+      </xsl:when>
+      <xsl:otherwise>
+        <output>
+          <xsl:value-of select="$testparam" />
+        </output>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+</xsl:stylesheet>

data/spec/saxon/xslt_spec.rb

@@ -35,6 +35,12 @@ describe Saxon::XSLT do
       xslt = Saxon::XSLT::Stylesheet.new(input)
       expect(xslt).to respond_to(:transform)
     end
+
+    it "provides the parse_stylesheet_doc method to compile from a Saxon::XML::Document" do
+      input = processor.XML(File.open(fixture_path('eg.xsl')))
+      xslt = Saxon::XSLT::Stylesheet.parse_stylesheet_doc(input)
+      expect(xslt).to respond_to(:transform)
+    end
   end
 
   context "transforming a document" do
@@ -57,6 +63,63 @@ describe Saxon::XSLT do
           expect(xsl.transform(result).to_s.strip).to eq('<piped/>')
         end
       end
+
+      context "when passing global parameters at transform time" do
+        let(:xsl) { processor.XSLT(File.open(fixture_path('params-eg.xsl'))) }
+
+        context "using hash params" do
+          let(:result) { xsl.transform(xml, {"testparam" => "'non-default'"}) }
+
+          it "contains the parameter value string" do
+            expect(result.to_s.strip).to include("non-default")
+          end
+        end
+
+        context "using array params" do
+          let(:result) { xsl.transform(xml, ["testparam", "'non-default'"]) }
+
+          it "contains the parameter value string" do
+            expect(result.to_s.strip).to include("non-default")
+          end
+        end
+
+        context "using malformed array params" do
+          it "should raise ArgumentError" do
+            expect{xsl.transform(xml, ["testparam", "'non-default'", "'wrongo'"])}.to raise_error(ArgumentError)
+          end
+        end
+
+        context "using a selection from the input" do
+          let(:result) { xsl.transform(xml, ["testparam", "local-name(/input)"]) }
+
+          it "should contain the name of the tag" do
+          expect(result.to_s.strip).to include('Select works')
+          end
+        end
+      end
+    end
+  end
+
+  describe "applying a stylesheet to a document and returning a serialised XML string" do
+    let(:xsl) { processor.XSLT(File.open(fixture_path('eg.xsl'))) }
+    let(:xml) { processor.XML(File.open(fixture_path('eg.xml'))) }
+
+    it "returns XML as a string" do
+      result = xsl.apply_to(xml)
+
+      expect(result).to match(/<output\/>/)
+    end
+
+    it "correctly invokes transform" do
+      expect(xsl).to receive(:transform).with(xml, {})
+
+      xsl.apply_to(xml)
+    end
+
+    it "correctly passes params through to transform" do
+      expect(xsl).to receive(:transform).with(xml, {"param" => "'value'"})
+
+      xsl.apply_to(xml, {"param" => "'value'"})
     end
   end
 
@@ -68,4 +131,3 @@ describe Saxon::XSLT do
     end
   end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saxon-xslt
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: java
 authors:
 - Matt Patterson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2015-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,7 @@ files:
 - spec/fixtures/config.xml
 - spec/fixtures/eg.xml
 - spec/fixtures/eg.xsl
+- spec/fixtures/params-eg.xsl
 - spec/fixtures/simple-xsl-import.xsl
 - spec/saxon/processor_spec.rb
 - spec/saxon/source_helper_spec.rb
@@ -150,6 +151,7 @@ test_files:
 - spec/fixtures/config.xml
 - spec/fixtures/eg.xml
 - spec/fixtures/eg.xsl
+- spec/fixtures/params-eg.xsl
 - spec/fixtures/simple-xsl-import.xsl
 - spec/saxon/processor_spec.rb
 - spec/saxon/source_helper_spec.rb