rexslt 0.1.3 → 0.1.4

data/lib/rexslt.rb

@@ -1,120 +1,177 @@
 require 'rexml/document'
 
+
 class Rexslt
   include REXML
-
+  
   def initialize(xsl, xml)
-
+   
     doc_xml = Document.new(xml)
     doc_xsl = Document.new(xsl)
+    
+    @doc = Document.new('<root/>')
+    indent = ''
+    previous_indent = indent.clone
+    @xsl_methods = [:apply_templates, :value_of, :element, :if, :choose, :when, :copy_of, :attribute]
+
+    h = XPath.match(doc_xsl.root, "xsl:output/attribute::*").inject({})\
+      {|r,x| r.merge(x.name.to_sym => x.value)}
 
-    @xsl_methods = [:apply_templates, :value_of, :element, :if, :choose, :when]
+    @indent = true if h and h[:indent] == 'yes'
 
     # fetch the templates
     @templates = XPath.match(doc_xsl.root, 'xsl:template').inject({}) do |r,x|
       r.merge(x.attribute('match').value => x)
     end
 
-    xpath = String.new @templates.to_a[0][0] 
-    o = XPath.first(doc_xml, xpath)
-
     # using the 1st template
-    @a = XPath.match(doc_xml, xpath).map do |x|
-      read_node @templates.to_a[0][-1], x
+    xpath = String.new @templates.to_a[0][0] 
+    XPath.match(doc_xml, xpath).each_with_index do |x,i|
+      read_node @templates.to_a[0][-1], x, @doc.root, indent.clone, previous_indent.clone
     end
-
   end
 
-  def to_s() @a.flatten.join end
-
-  def to_a() @a end
-
-  alias text to_s
+  def to_s() 
+    @doc.to_s[/<root>(.*)<\/root>/m,1]
+  end
+             
+  def to_doc(); @doc; end
 
   private
 
-  def read_node(template_node, doc_node)
+  def read_node(template_node, element, doc_element, indent, previous_indent)
 
     procs = {"REXML::Element" => :read_raw_element, "REXML::Text" => :read_raw_text}
-    template_node.map do |x|
-      #puts 'x : ' + x.inspect
-      method(procs[x.class.to_s]).call(doc_node, x)
+    template_node.each do |x|
+      method(procs[x.class.to_s]).call(element, x, doc_element, indent.clone, previous_indent)
     end
-    
+
   end
 
-  def read_raw_text(doc_node, x)
-    r = x.to_s.strip.length > 0 ? x.to_s : ''
-    #puts 'xx : ' + r.inspect
-    r
+  # element: xml source element, x: xsl element, doc_element: current destination xml element
+  #
+  def read_raw_text(element, x, doc_element, raw_indent, previous_indent)
+
+    indent = @indent == true ? (raw_indent + '  ') : ''
+    doc_element.add(REXML::Text.new(indent + x.to_s, raw=true)) if x.to_s.strip.length > 0 
   end
   
-  def read_raw_element(doc_node, x)
+  def read_raw_element(element, x, doc_element, indent, previous_indent)
+    
     method_name = x.name.gsub(/-/,'_').to_sym
     if @xsl_methods.include? method_name then
 
-      method(method_name).call(doc_node, x)
+      method(method_name).call(element, x, doc_element, indent, previous_indent)
     else
 
       if x.has_elements? then           
-        element = "<%s>%%s</%s>" % ([x.name.to_s] * 2)
-        k = element % read_node(x, doc_node).flatten.join
-        #puts 'k : ' + k.inspect
-        k
-      else        
-        x.to_s
+        
+        new_element = Element.new x.name.to_s
+
+        previous_indent = indent.clone
+        indent = indent_before(element, x, doc_element, indent, previous_indent) if @indent == true
+        
+        doc_element.add new_element
+        read_node(x, element, new_element, indent.clone, previous_indent.clone)
+        
+        indent_after(element, x, doc_element, indent, previous_indent) if @indent == true
+
+      else
+        doc_element.add Document.new(x.to_s)
+
       end
     end    
   end
 
-  def apply_templates(doc_node, x)
+  def apply_templates(element, x, doc_element, indent, previous_indent)
+    
     field = x.attribute('select').value.to_s
-    XPath.match(doc_node, field).map do |x|
-      read_node @templates[field], x
+    XPath.match(element, field).each do |x|
+      read_node @templates[field], x, doc_element, indent, previous_indent
     end
   end
 
-  def value_of(doc_node, x)
+  def value_of(element, x, doc_element, indent, previous_indent)
+    
     field = x.attribute('select').value.to_s
-    doc_node.text(field)
+    o = element.text(field)
+    doc_element.add REXML::Text.new(o.to_s)
+
   end
 
-  def element(doc_node, x)
-    name = x.attribute('name').value.to_s
-    element = "<%s>%%s</%s>" % ([name] * 2)
-    r = element % (read_node(x, doc_node).flatten.join)
-    #puts 'r : ' + r.inspect
-    r
+  def element(element, x, doc_element, indent, previous_indent)
+
+    name = x.attribute('name').value.to_s    
+    new_element = Element.new name
+    doc_element.add new_element
+    read_node(x, element, new_element, indent, previous_indent)
   end
   
-  def if(doc_node, x)
+  def if(element, x, doc_element, indent, previous_indent)
+    
     condition = x.attribute('test').value.to_s
-    node = XPath.first(doc_node, condition)
-    read_node(x, doc_node).flatten.join if node and node == true
+    node = XPath.first(element, condition)
+    read_node(x, element, doc_element, indent, previous_indent) if node and node == true
   end
 
-  def choose(doc_node, x)
+  def choose(element, x, doc_element, indent, previous_indent)
 
     #get the when clause    
-    nodes = XPath.match(x, "xsl:when")
-
-    r = nodes.map do |xsl_node|
 
+    r = XPath.match(x, "xsl:when").map do |xsl_node|
       condition = xsl_node.attribute('test').value.to_s
-      node = XPath.first(doc_node, condition)
-
-      if node and node == true then
-        read_node(xsl_node, doc_node).flatten.join       
+      node = XPath.first(element, condition)
+      if node and node == true
+        read_node(xsl_node, element, doc_element, indent, previous_indent)      
+        true
       else
-        nil
+        false
       end
     end
 
-    if r.compact.length <= 0 then
-      xsl_node = XPath.first(x, 'xsl:otherwise')
-      r = read_node(xsl_node, doc_node).flatten.join if xsl_node
+    unless r.any? then
+      node = XPath.first(x, 'xsl:otherwise')
+      read_node(node, element, doc_element, indent, previous_indent) if node
+    end       
+
+  end
+  
+  def copy_of(element, x, doc_element, indent, previous_indent)
+
+    indent_element(element, x, doc_element, indent, previous_indent) do
+      doc_element.add element 
+    end
+
+  end
+  
+  def indent_before(element, x, doc_element, indent, previous_indent)
+    text = ''
+    unless doc_element.texts.empty? and doc_element.texts.last.nil? then
+      text = indent unless doc_element.texts.last.to_s[/^\n\s/m]
+    else
+      text = "\n" + indent
     end
+    (doc_element.add REXML::Text.new text, raw=true) if text
+    indent += '  '    
+  end
+
+  def indent_after(element, x, doc_element, indent, previous_indent)
+    if @indent == true then          
+      doc_element.add REXML::Text.new "\n" + previous_indent[0..-3], raw=true
+    end            
+  end
+  
+  def indent_element(element, x, doc_element, indent, previous_indent)    
+    indent_before(element, x, doc_element, indent, previous_indent) if @indent == true    
+    yield
+    indent_after(element, x, doc_element, indent, previous_indent) if @indent == true
+  end
+  
+  def attribute(element, x, doc_element, indent, previous_indent)
     
-    r
+    name = x.attribute('name').value
+    value = x.text.to_s
+    doc_element.add_attribute name, value
   end
-end
+  
+end

metadata

@@ -2,7 +2,7 @@
 name: rexslt
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: []
 
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 +01:00
+date: 2011-04-13 00:00:00 +01:00
 default_executable: 
 dependencies: []