xml-fu 0.1.7 → 0.1.8

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 *.swp
 .rvmrc
+.ruby-*
 .bundle
 .config
 .yardoc

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Changes by Version
 
+### 0.1.8
+
+* Fixed XmlFu.symbol_conversion_algorithm functionality
+* Added specs for above
+* Removed :snake_case algorithm
+** It never worked and can be implemented via a custom algorithm.
+* Added :upcase algorithm
+* Added :downcase algorithm
+* Updated README
+
 ### 0.1.7
 
 * Added pass through for Builder::XmlMarkup options via XmlFu.xml
@@ -41,9 +51,9 @@
 
 ### 0.1.0
 
-* Initial version. born as a replacement of 
+* Initial version. born as a replacement of
   [Gyoku](http://www.rubygems.org/gems/gyoku)
   with corrected assumptions about Array values and
   no need for meta tags such as:
-  * :order! 
+  * :order!
   * :attributes!

data/README.md

@@ -2,7 +2,7 @@
 
 Convert Ruby Hashes to XML
 
-A hash is meant to be a structured set of data. So is XML. The two are very similar in that they have 
+A hash is meant to be a structured set of data. So is XML. The two are very similar in that they have
 the capability of nesting information within a tree structure. With XML you have nodes. With Hashes, you
 have key/value pairs. The value of an XML node is referenced by its parent's name. A hash value is referenced
 by its key. This basic lesson tells the majority of what you need to know about creating XML via Hashes in
@@ -29,30 +29,53 @@ Or install it yourself as:
 Hash keys are translated into XML nodes (whether it be a document node or attribute node).
 
 
-### Translation
+### Key Translation
 
-With Ruby, a hash key may be a string or a symbol. XmlFu will convert the symbols into an XML safe name 
-by lower camel-casing them. So :foo\_bar will become "fooBar". You may change the conversion algorithm to your
-liking by setting the XmlFu.symbol\_conversion\_algorithm to a lambda or proc of your liking.
+With Ruby, a hash key may be a string or a symbol.  **Strings will be preserved** as they may
+contain node namespacing ("foo:Bar" would need preserved rather than converted).  Symbols will
+be converted into an XML safe name by lower camel-casing them. So :foo\_bar will become "fooBar".
+You may change the conversion algorithm to your liking by setting the
+XmlFu.symbol\_conversion\_algorithm to a lambda or proc of your liking.
 
 
 #### Built-In Algorithms
 
-* :lower\_camelcase **(default)**
+For a complete list, reference XmlFu::Node::ALGORITHMS
+
 * :camelcase
+* :downcase
+* :lower\_camelcase **(default)**
 * :none (result of :sym.to\_s)
-* :snake\_case (alias for :none)
+* :upcase
 
 ```ruby
-# Built-in Algorithm
-XmlFu.symbol_conversion_algorithm(:camelcase)
+# Default Algorithm (:lower_camelcase)
+XmlFu.xml( :FooBar => "bang" ) #=> "<fooBar>bang</fooBar>"
+XmlFu.xml( :foo_bar => "bang" ) #=> "<fooBar>bang</fooBar>"
+
+
+# Built-in Algorithms (:camelcase)
+XmlFu.symbol_conversion_algorithm = :camelcase
+XmlFu.xml( :Foo_Bar => "bang" ) #=> "<FooBar>bang</FooBar>"
+XmlFu.xml( :foo_bar => "bang" ) #=> "<FooBar>bang</FooBar>"
+
+
+# Built-in Algorithms (:downcase)
+XmlFu.symbol_conversion_algorithm = :downcase
+XmlFu.xml( :foo_bar => "bang" ) #=> "<foo_bar>bang</foo_bar>"
+XmlFu.xml( :Foo_Bar => "bang" ) #=> "<foo_bar>bang</foo_bar>"
+XmlFu.xml( :FOO => "bar" ) #=> "<foo>bar</foo>"
+
+
+# Built-in Algorithms (:upcase)
+XmlFu.symbol_conversion_algorithm = :upcase
+XmlFu.xml( :foo_bar => "bang" ) #=> "<FOO_BAR>bang</FOO_BAR>"
+XmlFu.xml( :Foo_Bar => "bang" ) #=> "<FOO_BAR>bang</FOO_BAR>"
+XmlFu.xml( :foo => "bar" ) #=> "<FOO>bar</FOO>"
 
-XmlFu.xml( :foo => "bar" ) #=> "<foo>bar</foo>"
-XmlFu.xml( "foo" => "bar" ) #=> "<foo>bar</foo>"
-# :foo and "foo" both translate to <foo>
 
 # Custom Algorithm
-XmlFu.symbol_conversion_algorithm {|sym| sym.downcase }
+XmlFu.symbol_conversion_algorithm = lambda {|sym| sym.do_something_special }
 ```
 
 ### Types of Nodes
@@ -91,14 +114,14 @@ XmlFu.xml("foo!" => "<bar/>") #=> "<foo><bar/></foo>"
 
 #### Attribute Node (@key)
 
-Yes, the attributes of an XML node are nodes themselves, so we need a way of defining them. Since XPath syntax 
+Yes, the attributes of an XML node are nodes themselves, so we need a way of defining them. Since XPath syntax
 uses @ to denote an attribute, so does XmlFu.
 
 ``` ruby
-XmlFu.xml(:agent => { 
-  "@id" => "007", 
-  "FirstName" => "James", 
-  "LastName" => "Bond" 
+XmlFu.xml(:agent => {
+  "@id" => "007",
+  "FirstName" => "James",
+  "LastName" => "Bond"
 })
 #=> <agent id="007"><FirstName>James</FirstName><LastName>Bond</LastName></agent>
 ```
@@ -156,7 +179,7 @@ XmlFu.xml(:agent => {"@id" => "007", "=" => "James Bond"})
 #=> "<agent id=\"007\">James Bond</agent>"
 ```
 
-This key will not get around the self-closing node rule. The only nodes that will be used in this case will be 
+This key will not get around the self-closing node rule. The only nodes that will be used in this case will be
 attribute nodes and additional content will be ignored.
 
 ```ruby
@@ -167,7 +190,7 @@ XmlFu.xml("foo/" => {"@id" => "123", "=" => "You can't see me."})
 
 ### Arrays
 
-Since the value in a key/value pair is (for the most part) used as the contents of a key/node, there are some 
+Since the value in a key/value pair is (for the most part) used as the contents of a key/node, there are some
 assumptions that XmlFu makes when dealing with Array values.
 
 * For a typical key, the contents of the array are considered to be nodes to be contained within the <key> node.
@@ -177,7 +200,7 @@ assumptions that XmlFu makes when dealing with Array values.
 
 ``` ruby
 XmlFu.xml( "SecretAgents" => [
-  { "agent/" => { "@id"=>"006", "@name"=>"Alec Trevelyan" } }, 
+  { "agent/" => { "@id"=>"006", "@name"=>"Alec Trevelyan" } },
   { "agent/" => { "@id"=>"007", "@name"=>"James Bond" } }
 ])
 #=> "<SecretAgents><agent name=\"Alec Trevelyan\" id=\"006\"/><agent name=\"James Bond\" id=\"007\"/></SecretAgents>"
@@ -202,12 +225,12 @@ How about a more complex example:
 
 ```ruby
 XmlFu.xml(
-  "person*" => { 
-    "@foo" => "bar", 
+  "person*" => {
+    "@foo" => "bar",
     "=" => [
-      {"@foo" => "nope", "=" => "Bob"}, 
+      {"@foo" => "nope", "=" => "Bob"},
       "Sheila"
-    ] 
+    ]
   }
 )
 #=> "<person foo=\"nope\">Bob</person><person foo=\"bar\">Sheila</person>"
@@ -268,7 +291,7 @@ are currently ignored in arrays and only Hashes are translated.
   1. if key denotes self-closing node (key/)
     * attributes are preserved with Hash values
     * value and "=" values are ignored
-  2. if key denotes collection (key*) with Array value 
+  2. if key denotes collection (key*) with Array value
     * Array is flattened
     * Only Hash and Simple values are translated
     * Hashes may override default attributes set by parent

data/lib/xml-fu.rb

@@ -5,7 +5,7 @@ require "xml-fu/markup"
 
 module XmlFu
   class << self
-    
+
     # Convert construct into XML
     def xml(construct, options={})
       case construct
@@ -16,7 +16,7 @@ module XmlFu
     end#convert
 
     # @todo Add Nori-like parsing capability to convert XML back into XmlFu-compatible Hash/Array
-    # Parse XML into array of hashes.  If XML used as input contains only sibling nodes, output 
+    # Parse XML into array of hashes.  If XML used as input contains only sibling nodes, output
     # will be array of hashes corresponding to those sibling nodes.
     #
     #     <foo/><bar/> => [{"foo/" => ""}, {"bar/" => ""}]
@@ -38,7 +38,7 @@ module XmlFu
     ################################################################################
     ## CONFIGURATIONS
     ################################################################################
-    
+
     @@infer_simple_value_nodes = false
 
     # Set configuration option to be used with future releases
@@ -58,5 +58,18 @@ module XmlFu
       return @@infer_simple_value_nodes
     end
 
+
+    # @param formula_enum Formula Enumeration
+    # @return [lambda]
+    def symbol_conversion_algorithm=( formula_enum=nil, &block )
+      XmlFu::Node.symbol_conversion_algorithm = (formula_enum ? formula_enum : block)
+    end#symbol_conversion_algorithm
+
+
+    # @return [lambda]
+    def symbol_conversion_algorithm
+      XmlFu::Node.symbol_conversion_algorithm
+    end#symbol_conversion_algorithm
+
   end#class<<self
 end#XmlFu

data/lib/xml-fu/hash.rb

@@ -9,57 +9,61 @@ module XmlFu
   # If order is of concern, use Array.to_xml
   class Hash
 
-    # Convert Hash to XML String
-    def self.to_xml(hash, options={})
-      each_with_xml hash, options do |xml, name, value, attributes|
-        xml << Node.new(name, value, attributes).to_xml 
-      end
-    end#self.to_xml
+    class << self
 
+      # Convert Hash to XML String
+      def to_xml(hash, options={})
+        each_with_xml hash, options do |xml, name, value, attributes|
+          xml << Node.new(name, value, attributes).to_xml
+        end
+      end#to_xml
 
-    # Class method to filter out attributes and content
-    # from a given hash
-    def self.filter(hash)
-      attribs = {}
-      content = hash.dup
 
-      content.keys.select{|k| k =~ /^@/ }.each do |k|
-        attribs[k[1..-1]] = content.delete(k)
-      end
+      # Class method to filter out attributes and content
+      # from a given hash
+      def filter(hash)
+        attribs = {}
+        content = hash.dup
 
-      # Use _content value if defined
-      content = content.delete("=") || content
+        content.keys.select{|k| k =~ /^@/ }.each do |k|
+          attribs[k[1..-1]] = content.delete(k)
+        end
 
-      return [content, attribs]
-    end#self.filter
+        # Use _content value if defined
+        content = content.delete("=") || content
 
-  private
+        return [content, attribs]
+      end#filter
 
-    # Provides a convenience function to iterate over the hash
-    # Logic will filter out attribute and content keys from hash values
-    def self.each_with_xml(hash, opts={})
-      xml = XmlFu::Markup.new(opts)
+    private
 
-      hash.each do |key,value|
-        node_value = value
-        node_attrs = {}
+      # Provides a convenience function to iterate over the hash
+      # Logic will filter out attribute and content keys from hash values
+      def each_with_xml(hash, opts={})
+        xml = XmlFu::Markup.new(opts)
 
-        # yank the attribute keys into their own hash
-        if value.respond_to?(:keys)
-          filtered = Hash.filter(value)
-          node_value, node_attrs = filtered.first, filtered.last
-        end
+        hash.each do |key,value|
+          node_value = 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 )
+          # yank the attribute keys into their own hash
+          if value.respond_to?(:keys)
+            filtered = Hash.filter(value)
+            node_value, node_attrs = filtered.first, filtered.last
+          end
+
+          # 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
 
-        yield xml, node_name, node_value, node_attrs
-      end
+        xml.target!
+      end#each_with_xml
 
-      xml.target!
-    end#self.each_with_xml
+    end#class << self
 
   end#Hash
 

data/lib/xml-fu/node.rb

@@ -17,10 +17,11 @@ module XmlFu
 
     # default set of algorithms to choose from
     ALGORITHMS = {
-      :lower_camelcase => lambda { |sym| sym.to_s.lower_camelcase },
       :camelcase => lambda { |sym| sym.to_s.camelcase },
-      :snakecase => lambda { |sym| sym.to_s },
-      :none => lambda { |sym| sym.to_s }
+      :downcase => lambda { |sym| sym.to_s.downcase },
+      :lower_camelcase => lambda { |sym| sym.to_s.lower_camelcase }, # DEFAULT
+      :none => lambda { |sym| sym.to_s },
+      :upcase => lambda { |sym| sym.to_s.upcase }
     }
 
     # Class method for retrieving global Symbol-to-string conversion algorithm
@@ -30,9 +31,15 @@ module XmlFu
     end#self.symbol_conversion_algorithm
 
     # Class method for setting global Symbol-to-string conversion algorithm
-    # @param [lambda] algorithm Should accept a symbol as an argument and return a string
+    # @param [symbol, lambda] algorithm
+    #   Can be symbol corresponding to predefined algorithm or a lambda that accepts a symbol
+    #   as an argument and returns a string
     def self.symbol_conversion_algorithm=(algorithm)
-      algorithm = ALGORITHMS[algorithm] unless algorithm.respond_to?(:call)
+      if algorithm == :default
+        algorithm = ALGORITHMS[:lower_camelcase]
+      else
+        algorithm = ALGORITHMS[algorithm] unless algorithm.respond_to?(:call)
+      end
       raise(ArgumentError, "Invalid symbol conversion algorithm") unless algorithm
       @symbol_conversion_algorithm = algorithm
     end#self.symbol_conversion_algorithm=
@@ -69,8 +76,6 @@ module XmlFu
 
       use_name = name_parse_special_characters(use_name)
 
-      # TODO: Add additional logic that Gyoku XmlKey puts in place 
-     
       # remove ":" if name begins with ":" (i.e. no namespace)
       use_name = use_name[1..-1] if use_name[0,1] == ":"
 
@@ -97,7 +102,7 @@ module XmlFu
 
         # Will this be a self closing node?
         if use_this.to_s[-1,1] == '/'
-          @self_closing = true 
+          @self_closing = true
           use_this.chop!
         end
 
@@ -148,14 +153,14 @@ module XmlFu
       case
       when @self_closing && @content_type == 'container'
         xml.tag!(@name, @attributes)
-      when @value.nil? 
+      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, { 
+          xml << XmlFu::Array.to_xml(@value.flatten, {
             :key => (@self_closing ? "#{@name}/" : @name),
             :attributes => @attributes,
             :content_type => "collection"

data/lib/xml-fu/version.rb

@@ -1,3 +1,3 @@
 module XmlFu
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/spec/lib/xml-fu_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe XmlFu do
+  after(:each) do
+    XmlFu.symbol_conversion_algorithm = :default
+  end
+
+  describe "with default symbol conversion algorithm" do
+    before(:each) do
+      XmlFu.symbol_conversion_algorithm = :default
+    end
+
+    {
+      :FooBar => "fooBar",
+      :foobar => "foobar"
+    }.each do |k,v|
+      it "should convert :#{k} to #{v}" do
+        doc = XmlFu.xml( k => "")
+        doc.should == "<#{v}></#{v}>"
+      end
+    end
+  end#default (:lower_camelcase)
+
+
+  describe "with built-in :camelcase algorithm" do
+    before(:each) do
+      XmlFu.symbol_conversion_algorithm = :camelcase
+    end
+
+    {
+      :foo_bar => "FooBar",
+      :foobar => "Foobar"
+    }.each do |k,v|
+      it "should convert :#{k} to #{v}" do
+        doc = XmlFu.xml( k => "")
+        doc.should == "<#{v}></#{v}>"
+      end
+    end
+  end#:camelcase
+
+
+  describe "with built-in :downcase algorithm" do
+    before(:each) do
+      XmlFu.symbol_conversion_algorithm = :downcase
+    end
+
+    {
+      :FOO_BAR => "foo_bar",
+      :FooBar => "foobar"
+    }.each do |k,v|
+      it "should convert :#{k} to #{v}" do
+        doc = XmlFu.xml( k => "")
+        doc.should == "<#{v}></#{v}>"
+      end
+    end
+  end#:downcase
+
+
+  describe "with built-in :upcase algorithm" do
+    before(:each) do
+      XmlFu.symbol_conversion_algorithm = :upcase
+    end
+
+    {
+      :foo_bar => "FOO_BAR",
+      :FooBar => "FOOBAR"
+    }.each do |k,v|
+      it "should convert :#{k} to #{v}" do
+        doc = XmlFu.xml( k => "")
+        doc.should == "<#{v}></#{v}>"
+      end
+    end
+  end#:upcase
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: xml-fu
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 1
-  - 7
-  version: 0.1.7
+  - 8
+  version: 0.1.8
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-21 00:00:00 Z
+date: 2013-07-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -91,6 +91,7 @@ files:
 - spec/lib/array_spec.rb
 - spec/lib/hash_spec.rb
 - spec/lib/node_spec.rb
+- spec/lib/xml-fu_spec.rb
 - spec/lib/xml_spec.rb
 - spec/spec_helper.rb
 - spec/xmlfu_spec.rb
@@ -124,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: xml-fu
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Simple Hash/Array to XML generation
@@ -132,6 +133,7 @@ test_files:
 - spec/lib/array_spec.rb
 - spec/lib/hash_spec.rb
 - spec/lib/node_spec.rb
+- spec/lib/xml-fu_spec.rb
 - spec/lib/xml_spec.rb
 - spec/spec_helper.rb
 - spec/xmlfu_spec.rb