xml-fu 0.1.1 → 0.1.2

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+### 0.1.2
+
+* Additional nesting support
+* Further encapsulated functionality into Node
+  * xml.tag! is only used in Node
+  * Array collection vs content logic moved to Node
+  * Hash iteration logic reduced to a single Node call
+* Node
+  * New attribute: "content_type"
+  * Special tag characters (\*, \/, !) can be mixed and matched
+    * "foo/\*" will return a collection of <foo/> siblings
+* 12 new spec tests
+* Removed development dependencies for:
+  * autotest
+  * mocha
+
+### 0.1.1
+
+* Rescue false positives when setting Node.value due to interaction with ActiveSupport
+
 ### 0.1.0
 
 * Initial version. born as a replacement of 

data/lib/xml-fu/array.rb

@@ -24,10 +24,6 @@ module XmlFu
           raise(MissingKeyException, "Key name missing for collection") if key.empty?
           
           case 
-          when key[-1,1] == "/"
-            xml << Node.new(key, nil, attributes).to_xml
-          when ::Hash === item
-            xml.tag!(key, attributes) { xml << Hash.to_xml(item,options) }
           when ::Array === item
             xml << Array.to_xml(item.flatten,options)
           else
@@ -42,9 +38,10 @@ module XmlFu
             xml << Array.to_xml(item, options)
           when XmlFu.infer_simple_value_nodes == true
             xml << infer_node(item, attributes)
+          when item.respond_to?(:to_xml)
+            xml << item.to_xml
           else
-            # only act on item if it responds to to_xml
-            xml << item.to_xml if item.respond_to?(:to_xml)
+            # unknown xml tranfromation process
           end
         end
       end
@@ -83,11 +80,14 @@ module XmlFu
 
         if item.respond_to?(:keys)
           filtered = Hash.filter(item)
-          attributes = filtered.last
-          item_content = filtered.first
+          item_content, attributes = filtered.first, filtered.last
         end
 
-        yield xml, key, item_content, attributes
+        item_name = ( Symbol === key ?
+                     XmlFu::Node.symbol_conversion_algorithm.call(key) :
+                     key.to_s )
+
+        yield xml, item_name, item_content, attributes
       end
 
       xml.target!

data/lib/xml-fu/hash.rb

@@ -11,33 +11,8 @@ module XmlFu
 
     # Convert Hash to XML String
     def self.to_xml(hash, options={})
-      each_with_xml hash do |xml, key, value, attributes|
-        # Use symbol conversion algorithm to set tag name
-        tag_name = ( Symbol === key ?
-                     XmlFu::Node.symbol_conversion_algorithm.call(key) :
-                     key.to_s )
-
-        case
-        when tag_name[-1,1] == "/"
-          xml << Node.new(tag_name, nil, attributes).to_xml
-        when ::Array === value
-          if tag_name[-1,1] == '*'
-            options.merge!({
-              :content_type => "collection",
-              :key => tag_name.chop,
-              :attributes => attributes
-            })
-            # Collection is merely a set of sibling nodes
-            xml << Array.to_xml(value.flatten, options)
-          else
-            # Contents will contain a parent node
-            xml.tag!(tag_name, attributes) { xml << Array.to_xml(value, options) }
-          end
-        when ::Hash === value 
-          xml.tag!(tag_name, attributes) { xml << Hash.to_xml(value, options) }
-        else 
-          xml << Node.new(tag_name, value, attributes).to_xml
-        end
+      each_with_xml hash do |xml, name, value, attributes|
+        xml << Node.new(name, value, attributes).to_xml 
       end
     end#self.to_xml
 
@@ -72,11 +47,15 @@ module XmlFu
         # yank the attribute keys into their own hash
         if value.respond_to?(:keys)
           filtered = Hash.filter(value)
-          node_attrs = filtered.last
-          node_value = filtered.first
+          node_value, node_attrs = filtered.first, filtered.last
         end
 
-        yield xml, key, node_value, node_attrs
+        # Use symbol conversion algorithm to set tag name
+        node_name = ( Symbol === key ?
+                     XmlFu::Node.symbol_conversion_algorithm.call(key) :
+                     key.to_s )
+
+        yield xml, node_name, node_value, node_attrs
       end
 
       xml.target!

data/lib/xml-fu/node.rb

@@ -39,6 +39,7 @@ module XmlFu
 
     attr_accessor :escape_xml
     attr_accessor :self_closing
+    attr_accessor :content_type
 
     # Create XmlFu::Node object
     # @param [String, Symbol] name Name of node
@@ -47,6 +48,7 @@ module XmlFu
     def initialize(name, value, attributes={})
       @escape_xml = true
       @self_closing = false
+      @content_type = "container"
       self.attributes = attributes
       self.value = value
       self.name = name
@@ -85,21 +87,25 @@ module XmlFu
     def name_parse_special_characters(val)
       use_this = val.dup
 
-      # Will this be a self closing node?
-      if use_this.to_s[-1,1] == '/'
-        @self_closing = true 
-        use_this.chop!
-      end
-
-      # Will this node contain escaped XML?
-      if use_this.to_s[-1,1] == '!'
-        @escape_xml = false
-        use_this.chop!
-      end
-
       # Ensure that we don't have special characters at end of name
       while ["!","/","*"].include?(use_this.to_s[-1,1]) do
-        use_this.chop!
+        # Will this node contain escaped XML?
+        if use_this.to_s[-1,1] == '!'
+          @escape_xml = false
+          use_this.chop!
+        end
+
+        # Will this be a self closing node?
+        if use_this.to_s[-1,1] == '/'
+          @self_closing = true 
+          use_this.chop!
+        end
+
+        # Will this node contain a collection of sibling nodes?
+        if use_this.to_s[-1,1] == '*'
+          @content_type = "collection"
+          use_this.chop!
+        end
       end
 
       return use_this
@@ -107,16 +113,22 @@ module XmlFu
 
     # Custom Setter for @value instance method
     def value=(val)
-      if DateTime === val || Time === val || Date === val
-        @value = val.strftime XS_DATETIME_FORMAT
-      elsif val.respond_to?(:to_datetime)
-        @value = val.to_datetime
-      elsif val.respond_to?(:call)
-        @value = val.call
-      elsif val.nil?
-        @value = nil
+      case val
+      when ::Hash     then @value = val
+      when ::Array    then @value = val
+      when ::DateTime then @value = val.strftime XS_DATETIME_FORMAT
+      when ::Time     then @value = val.strftime XS_DATETIME_FORMAT
+      when ::Date     then @value = val.strftime XS_DATETIME_FORMAT
       else
-        @value = val.to_s
+        if val.respond_to?(:to_datetime)
+          @value = val.to_datetime
+        elsif val.respond_to?(:call)
+          @value = val.call
+        elsif val.nil?
+          @value = nil
+        else
+          @value = val.to_s
+        end
       end
     rescue => e
       @value = val.to_s
@@ -133,9 +145,27 @@ module XmlFu
     def to_xml
       xml = Builder::XmlMarkup.new
       case
-      when @self_closing  then xml.tag!(@name, @attributes)
-      when @value.nil?    then xml.tag!(@name, @attributes.merge!("xsi:nil" => "true"))
-      else                     xml.tag!(@name, @attributes) { xml << self.value }
+      when @self_closing && @content_type == 'container'
+        xml.tag!(@name, @attributes)
+      when @value.nil? 
+        xml.tag!(@name, @attributes.merge!("xsi:nil" => "true"))
+      when ::Hash === @value
+        xml.tag!(@name, @attributes) { xml << XmlFu::Hash.to_xml(@value) }
+      when ::Array === @value
+        case @content_type
+        when "collection"
+          xml << XmlFu::Array.to_xml(@value.flatten, { 
+            :key => (@self_closing ? "#{@name}/" : @name),
+            :attributes => @attributes,
+            :content_type => "collection"
+          })
+        when "container"
+          xml.tag!(@name, @attributes) { xml << XmlFu::Array.to_xml(@value) }
+        else
+          # Shouldn't be anything else
+        end
+      else
+        xml.tag!(@name, @attributes) { xml << self.value }
       end
       xml.target!
     end#to_xml

data/lib/xml-fu/version.rb

@@ -1,3 +1,3 @@
 module XmlFu
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/xml-fu.rb

@@ -5,13 +5,12 @@ require "xml-fu/array"
 module XmlFu
   class << self
     
-    @@infer_simple_value_nodes = false
-
     # Convert construct into XML
     def xml(construct, options={})
       case construct
       when ::Hash   then Hash.to_xml( construct.dup, options )
       when ::Array  then Array.to_xml( construct.dup, options )
+      else nil
       end
     end#convert
 
@@ -25,13 +24,19 @@ module XmlFu
     # an array of one hash (the root node hash)
     #
     #     <foo><bar/><baz/></foo> => [{"foo" => [{"bar/" => ""},{"baz/" => ""}] }]
-    def hash(xml, options)
+    def parse(xml, options)
     end
 
     def configure
       yield self
     end
 
+    ################################################################################
+    ## CONFIGURATIONS
+    ################################################################################
+    
+    @@infer_simple_value_nodes = false
+
     # Set configuration option to be used with future releases
     def infer_simple_value_nodes=(val)
       @@infer_simple_value_nodes = val

data/spec/lib/array_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe XmlFu::Array do
-
   describe ".to_xml" do
     #after do
     #  XmlFu.infer_simple_value_nodes = false

data/spec/lib/hash_spec.rb

@@ -33,8 +33,10 @@ describe XmlFu::Hash do
 
     describe "with a key that will contain multiple nodes" do
       describe "when key explicitly denotes value is a collection" do
-        hash = { "foo*" => ["bar", "biz"] }
-        XmlFu::Hash.to_xml(hash).should == "<foo>bar</foo><foo>biz</foo>"
+        it "should return the correct collection" do
+          hash = { "foo*" => ["bar", "biz"] }
+          XmlFu::Hash.to_xml(hash).should == "<foo>bar</foo><foo>biz</foo>"
+        end
       end
 
       describe "when key denotes value contains children" do

data/spec/lib/node_spec.rb

@@ -1,6 +1,42 @@
 require 'spec_helper'
 
 describe XmlFu::Node do
+  it "should remove special characters from name no matter how many times they appear at the end" do
+    node = XmlFu::Node.new("foo/*!", 'something')
+    node.name.should == 'foo'
+
+    node = XmlFu::Node.new("foo/*/**/!!!", 'something')
+    node.name.should == 'foo'
+  end
+
+  describe "with hash as value" do
+    it "should store the value as a hash" do
+      node = XmlFu::Node.new("foo", {"bar" => "biz"})
+      node.value.class.should == Hash
+    end
+
+    it "should create nested nodes with simple hash" do
+      node = XmlFu::Node.new("foo", {"bar" => "biz"})
+      node.to_xml.should == "<foo><bar>biz</bar></foo>"
+    end
+  end
+
+  describe "with array as value" do
+    it "should store the value as an array" do
+      node = XmlFu::Node.new("foo", ["bar", "biz"])
+      node.value.class.should == Array
+    end
+
+    it "should create nodes with simple collection array" do
+      node = XmlFu::Node.new("foo*", ["bar", "biz"])
+      node.to_xml.should == "<foo>bar</foo><foo>biz</foo>"
+    end
+
+    it "should create nodes with simple contents array" do
+      node = XmlFu::Node.new("foo*", [{:bar => "biz"}])
+      node.to_xml.should == "<foo><bar>biz</bar></foo>"
+    end
+  end
 
   describe "setting instance variables" do
     it "should correctly remove special characters from a name" do
@@ -12,6 +48,9 @@ describe XmlFu::Node do
 
       node = XmlFu::Node.new("foo!", "something")
       node.name.should == "foo"
+
+      node = XmlFu::Node.new("foo:bar!", "something")
+      node.name.should == "foo:bar"
     end
 
     it "should set self-closing with special name character" do
@@ -24,6 +63,14 @@ describe XmlFu::Node do
       node.escape_xml.should == false
     end
 
+    it "should set content_type with special name character" do
+      node = XmlFu::Node.new("foo", "something")
+      node.content_type.should == "container"
+
+      node = XmlFu::Node.new("foo*", "something")
+      node.content_type.should == "collection"
+    end
+
     it "should set attributes with a hash" do
       node = XmlFu::Node.new("foo", "bar", {:this => "that"})
       node.attributes.should == {:this => "that"}
@@ -54,13 +101,14 @@ describe XmlFu::Node do
     it "should properly preserve namespaceds names" do
       node = XmlFu::Node.new("foo:bar", "biz")
       node.name.should == "foo:bar"
+
+      node = XmlFu::Node.new("foo:bar!", "biz")
+      node.name.should == "foo:bar"
     end
   end
 
   describe "to_xml" do
-    
     describe "should return self-closing nil XML node for nil value" do
-
       it "provided ANY non-blank name" do
         nil_foo = "<foo xsi:nil=\"true\"/>"
         node = XmlFu::Node.new("foo", nil)
@@ -75,9 +123,12 @@ describe XmlFu::Node do
 
       it "with additional attributes provided" do
         node = XmlFu::Node.new("foo", nil, {:this => "that"})
-        node.to_xml.should == "<foo this=\"that\" xsi:nil=\"true\"/>"
+        # Depending on the version of ruby, one of 
+        # these two acceptible values would be returned
+        [ "<foo this=\"that\" xsi:nil=\"true\"/>", 
+          "<foo xsi:nil=\"true\" this=\"that\"/>"
+        ].should include(node.to_xml)
       end
-
     end
 
     it "should escape values by default" do
@@ -108,5 +159,4 @@ describe XmlFu::Node do
       end
     end
   end
-
 end

data/spec/xmlfu_spec.rb

@@ -2,6 +2,12 @@ require 'spec_helper'
 
 describe XmlFu do
   describe ".xml" do
+    it "should return nil for value that isn't a Hash or Array" do
+      XmlFu.xml(1).should == nil
+      XmlFu.xml(nil).should == nil
+      XmlFu.xml(Object.new).should == nil
+    end
+
     it "translates a given Hash to XML" do
       XmlFu.xml( :id => 1 ).should == "<id>1</id>"
     end
@@ -41,6 +47,16 @@ describe XmlFu do
       XmlFu.xml(hash).should == "<foo bar=\"biz\"></foo><foo biz=\"bang\"></foo>"
     end
 
+    it "should return list of self-closing nodes" do
+      hash = {
+        "foo/*" => [
+          {"@bar" => "biz"},
+          {"@biz" => "bang"}
+        ]
+      }
+      XmlFu.xml(hash).should == "<foo bar=\"biz\"/><foo biz=\"bang\"/>"
+    end
+
     it "should ignore nested values for content array" do
       output = XmlFu.xml("foo/" => [{:bar => "biz"}, {:bar => "biz"}])
       output.should == "<foo/>"
@@ -53,7 +69,6 @@ describe XmlFu do
       output = XmlFu.xml("foo/" => {"@id" => "0"})
       output.should == "<foo id=\"0\"/>"
     end
-
   end
 
   describe "configure" do
@@ -71,5 +86,4 @@ describe XmlFu do
     XmlFu.infer_simple_value_nodes = false
     XmlFu.infer_simple_value_nodes.should == false
   end
-
 end

data/xml-fu.gemspec

@@ -19,8 +19,6 @@ Gem::Specification.new do |gem|
   gem.add_dependency "builder", ">= 2.1.2"
 
   gem.add_development_dependency "rspec", ">= 2.4.0"
-  gem.add_development_dependency "autotest"
-  gem.add_development_dependency "mocha", "~> 0.9.9"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: xml-fu
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-13 00:00:00 Z
+date: 2012-03-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -49,36 +49,6 @@ dependencies:
         version: 2.4.0
   type: :development
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: autotest
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 0
-        - 9
-        - 9
-        version: 0.9.9
-  type: :development
-  version_requirements: *id004
 description: "\n    Inspired by the Gyoku gem for hash to xml conversion, \n    XmlFu is designed to require no meta tagging for \n    node attributes and content. (i.e. no :attributes! and no :order!)\n  "
 email: 
 - rhino.citguy@gmail.com