gyoku 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cdaf80a00de09a2fcb18c9dd5ef5b0bcd1491437
-  data.tar.gz: 8ef2ffc7a90fac372189b3968aed3003bde0f7c4
+  metadata.gz: 5907f34dc0f3b33599c65e59b4fdaa4ccf1878c0
+  data.tar.gz: 3929d2f06c095e3375b37b88822afef27cfee219
 SHA512:
-  metadata.gz: 26ed05f6ae3fde1a51daf47727454a8b279d5041846662608229a1ea2e82c7a0952101fb0a7828e1878df0df23e675001928d0fbdb702d657d242cb4f1369603
-  data.tar.gz: ccf273c1e402883e71570be64ad57ab7ea0a46e0c8abf7b22d952785a35baa49b0c6fbd6c0db1e6d8d701e711fcec5a0f206c5530d7eb157a3aa40bca5324280
+  metadata.gz: 8aa20c9179c8283096c66a64c10ca3b2802ac6e316de1118c0ef77c6b5f331622592fc4ba6d69d5e7e16b89d4d1eb03666140f4d32e8c0b1d68328bf743cdc3c
+  data.tar.gz: a0e9cdb56e8d91767e697b199185041928441f832c17c350dbcd523216c7e22a3f835f2cd4474e1a7bef8ee18957d57cdb69688fb29e1d106847e25c181e73e1

data/.travis.yml

@@ -4,5 +4,6 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1
   - jruby-19mode
-  - rbx
+  - rbx-2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.2.0 (2014-09-18)
+
+* Feature: [#44](https://github.com/savonrb/gyoku/pull/44) support for sorting via :order! with a string key
+
 ## 1.1.1 (2014-01-02)
 
 * Feature: [#38](https://github.com/savonrb/gyoku/pull/38) support for building nested Arrays

data/lib/gyoku/hash.rb

@@ -66,7 +66,7 @@ module Gyoku
     # Defaults to return the actual keys of the Hash if no :order! key could be found.
     # Raises an ArgumentError in case the :order! Array does not match the Hash keys.
     def self.order(hash)
-      order = hash[:order!]
+      order = hash[:order!] || hash.delete('order!')
       hash_without_order = hash.reject { |key, value| key == :order! }
       order = hash_without_order.keys unless order.kind_of? ::Array
 

data/lib/gyoku/version.rb

@@ -1,5 +1,5 @@
 module Gyoku
 
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 
 end

data/lib/gyoku/xml_key.rb

@@ -21,7 +21,7 @@ module Gyoku
           xml_key = xml_key.split(":").last
         end
 
-        xml_key = key_converter(options).call(xml_key) if Symbol === key
+        xml_key = key_converter(options, xml_key).call(xml_key) if Symbol === key
 
         if !unqualified && qualify?(options) && !xml_key.include?(":")
           xml_key = "#{options[:namespace]}:#{xml_key}"
@@ -33,8 +33,17 @@ module Gyoku
     private
 
       # Returns the formula for converting Symbol keys.
-      def key_converter(options)
-        key_converter = options[:key_converter] || :lower_camelcase
+      def key_converter(options, xml_key)
+        defined_key = options[:key_to_convert]
+        if (defined_key != nil) && (defined_key == xml_key)
+          key_converter = options[:key_converter]
+        elsif defined_key != nil
+          key_converter = :lower_camelcase
+        elsif (options[:except] == xml_key)
+          key_converter = :lower_camelcase
+        else
+          key_converter = options[:key_converter] || :lower_camelcase
+        end
         FORMULAS[key_converter]
       end
 

data/spec/gyoku/array_spec.rb

@@ -7,56 +7,56 @@ describe Gyoku::Array do
       array = [{ :name => "adam" }, { :name => "eve" }]
       result = "<user><name>adam</name></user><user><name>eve</name></user>"
 
-      to_xml(array, "user").should == result
+      expect(to_xml(array, "user")).to eq(result)
     end
 
     it "returns the XML for an Array of different Objects" do
       array = [:symbol, "string", 123]
       result = "<value>symbol</value><value>string</value><value>123</value>"
 
-      to_xml(array, "value").should == result
+      expect(to_xml(array, "value")).to eq(result)
     end
 
     it "defaults to escape special characters" do
       array = ["<tag />", "adam & eve"]
       result = "<value>&lt;tag /&gt;</value><value>adam &amp; eve</value>"
 
-      to_xml(array, "value").should == result
+      expect(to_xml(array, "value")).to eq(result)
     end
 
     it "does not escape special characters when told to" do
       array = ["<tag />", "adam & eve"]
       result = "<value><tag /></value><value>adam & eve</value>"
 
-      to_xml(array, "value", false).should == result
+      expect(to_xml(array, "value", false)).to eq(result)
     end
 
     it "adds attributes to a given tag" do
       array = ["adam", "eve"]
       result = '<value active="true">adam</value><value active="true">eve</value>'
 
-      to_xml(array, "value", :escape_xml, :active => true).should == result
+      expect(to_xml(array, "value", :escape_xml, :active => true)).to eq(result)
     end
 
     it "adds attributes to duplicate tags" do
       array = ["adam", "eve"]
       result = '<value id="1">adam</value><value id="2">eve</value>'
 
-      to_xml(array, "value", :escape_xml, :id => [1, 2]).should == result
+      expect(to_xml(array, "value", :escape_xml, :id => [1, 2])).to eq(result)
     end
 
     it "skips attribute for element without attributes if there are fewer attributes than elements" do
       array = ["adam", "eve", "serpent"]
       result = '<value id="1">adam</value><value id="2">eve</value><value>serpent</value>'
 
-      to_xml(array, "value", :escape_xml, :id => [1, 2]).should == result
+      expect(to_xml(array, "value", :escape_xml, :id => [1, 2])).to eq(result)
     end
 
     it "handles nested Arrays" do
       array = [["one", "two"]]
       result = "<value><element>one</element><element>two</element></value>"
 
-      to_xml(array, "value").should == result
+      expect(to_xml(array, "value")).to eq(result)
     end
   end
 

data/spec/gyoku/hash_spec.rb

@@ -5,41 +5,66 @@ describe Gyoku::Hash do
   describe ".to_xml" do
     describe "returns SOAP request compatible XML" do
       it "for a simple Hash" do
-        to_xml(:some => "user").should == "<some>user</some>"
+        expect(to_xml(:some => "user")).to eq("<some>user</some>")
       end
 
       it "for a nested Hash" do
-        to_xml(:some => { :new => "user" }).should == "<some><new>user</new></some>"
+        expect(to_xml(:some => { :new => "user" })).to eq("<some><new>user</new></some>")
+      end
+
+      context "with key_converter" do
+        it "expect all keys change" do
+          expect(to_xml({:some => { :new => "user" }}, {key_converter: :camelcase})).to eq("<Some><New>user</New></Some>")
+        end
+
+        it "and key_to_convert option should change only key" do
+          hash = {:some => { :new => "user", :age => 20 }}
+          options = {key_converter: :camelcase, key_to_convert: "some"}
+          result = "<Some><new>user</new><age>20</age></Some>"
+          expect(to_xml(hash, options)).to eq(result)
+
+          hash = {:some => { :new => "user", :age => 20 }}
+          options = {key_converter: :camelcase, key_to_convert: "new"}
+          result = "<some><New>user</New><age>20</age></some>"
+          expect(to_xml(hash, options)).to eq(result)
+        end
+
+        it "with except option, dont convert this key" do
+          hash = {:some => { :new => "user", :age => 20 }}
+          options = {key_converter: :camelcase, except: "some"}
+          result = "<some><New>user</New><Age>20</Age></some>"
+          expect(to_xml(hash, options)).to eq(result)
+        end
       end
 
       it "for a Hash with multiple keys" do
-        to_xml(:all => "users", :before => "whatever").should include(
+        expect(to_xml(:all => "users", :before => "whatever")).to include(
           "<all>users</all>",
           "<before>whatever</before>"
         )
       end
 
       it "for a Hash containing an Array" do
-        to_xml(:some => ["user", "gorilla"]).should == "<some>user</some><some>gorilla</some>"
+        expect(to_xml(:some => ["user", "gorilla"])).to eq("<some>user</some><some>gorilla</some>")
       end
 
       it "for a Hash containing an Array of Hashes" do
-        to_xml(:some => [{ :new => "user" }, { :old => "gorilla" }]).
-          should == "<some><new>user</new></some><some><old>gorilla</old></some>"
+        expect(to_xml(:some => [{ :new => "user" }, { :old => "gorilla" }])).
+          to eq("<some><new>user</new></some><some><old>gorilla</old></some>")
       end
     end
 
     it "converts Hash key Symbols to lowerCamelCase" do
-      to_xml(:find_or_create => "user").should == "<findOrCreate>user</findOrCreate>"
+      expect(to_xml(:find_or_create => "user")).to eq("<findOrCreate>user</findOrCreate>")
     end
 
     it "does not convert Hash key Strings" do
-      to_xml("find_or_create" => "user").should == "<find_or_create>user</find_or_create>"
+      expect(to_xml("find_or_create" => "user")).to eq("<find_or_create>user</find_or_create>")
     end
 
     it "converts DateTime objects to xs:dateTime compliant Strings" do
-      to_xml(:before => DateTime.new(2012, 03, 22, 16, 22, 33)).
-        should == "<before>2012-03-22T16:22:33+00:00</before>"
+      expect(to_xml(:before => DateTime.new(2012, 03, 22, 16, 22, 33))).
+        to eq("<before>2012-03-22T16:22:33+00:00</before>")
     end
 
     it "converts Objects responding to to_datetime to xs:dateTime compliant Strings" do
@@ -48,7 +73,7 @@ describe Gyoku::Hash do
         DateTime.new(2012, 03, 22, 16, 22, 33)
       end
 
-      to_xml(:before => singleton).should == "<before>2012-03-22T16:22:33+00:00</before>"
+      expect(to_xml(:before => singleton)).to eq("<before>2012-03-22T16:22:33+00:00</before>")
     end
 
     it "calls to_s on Strings even if they respond to to_datetime" do
@@ -57,78 +82,94 @@ describe Gyoku::Hash do
         DateTime.new(2012, 03, 22, 16, 22, 33)
       end
 
-      to_xml(:name => singleton).should == "<name>gorilla</name>"
+      expect(to_xml(:name => singleton)).to eq("<name>gorilla</name>")
     end
 
     it "properly serializes nil values" do
-      to_xml(:some => nil).should == '<some xsi:nil="true"/>'
+      expect(to_xml(:some => nil)).to eq('<some xsi:nil="true"/>')
     end
 
     it "creates self-closing tags for Hash keys ending with a forward slash" do
-      to_xml("self-closing/" => nil).should == '<self-closing/>'
+      expect(to_xml("self-closing/" => nil)).to eq('<self-closing/>')
     end
 
     it "calls to_s on any other Object" do
       [666, true, false].each do |object|
-        to_xml(:some => object).should == "<some>#{object}</some>"
+        expect(to_xml(:some => object)).to eq("<some>#{object}</some>")
       end
     end
 
     it "defaults to escape special characters" do
       result = to_xml(:some => { :nested => "<tag />" }, :tag => "<tag />")
-      result.should include("<tag>&lt;tag /&gt;</tag>")
-      result.should include("<some><nested>&lt;tag /&gt;</nested></some>")
+      expect(result).to include("<tag>&lt;tag /&gt;</tag>")
+      expect(result).to include("<some><nested>&lt;tag /&gt;</nested></some>")
     end
 
     it "does not escape special characters for keys marked with an exclamation mark" do
       result = to_xml(:some => { :nested! => "<tag />" }, :tag! => "<tag />")
-      result.should include("<tag><tag /></tag>")
-      result.should include("<some><nested><tag /></nested></some>")
+      expect(result).to include("<tag><tag /></tag>")
+      expect(result).to include("<some><nested><tag /></nested></some>")
     end
 
     it "preserves the order of Hash keys and values specified through :order!" do
       hash = { :find_user => { :name => "Lucy", :id => 666, :order! => [:id, :name] } }
       result = "<findUser><id>666</id><name>Lucy</name></findUser>"
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
 
       hash = { :find_user => { :mname => "in the", :lname => "Sky", :fname => "Lucy", :order! => [:fname, :mname, :lname] } }
       result = "<findUser><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></findUser>"
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
+    end
+
+    it "preserves the order of Hash keys and values specified through 'order!' (as a string key)" do
+      hash = { :find_user => { :name => "Lucy", :id => 666, 'order!' => [:id, :name] } }
+      result = "<findUser><id>666</id><name>Lucy</name></findUser>"
+      expect(to_xml(hash)).to eq(result)
+
+      hash = { :find_user => { :mname => "in the", :lname => "Sky", :fname => "Lucy", 'order!' => [:fname, :mname, :lname] } }
+      result = "<findUser><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></findUser>"
+      expect(to_xml(hash)).to eq(result)
+    end
+
+    it "uses :order! symbol values for ordering but leaves the string key 'order!' if both are present" do
+      hash = { :find_user => { :name => "Lucy", :id => 666, 'order!' => 'value', :order! => [:id, :name, 'order!'] } }
+      result = "<findUser><id>666</id><name>Lucy</name><order>value</order></findUser>"
+      expect(to_xml(hash)).to eq(result)
     end
 
     it "raises if the :order! Array is missing Hash keys" do
       hash = { :name => "Lucy", :id => 666, :order! => [:name] }
-      lambda { to_xml(hash) }.should raise_error(ArgumentError, "Missing elements in :order! [:id]")
+      expect { to_xml(hash) }.to raise_error(ArgumentError, "Missing elements in :order! [:id]")
     end
 
     it "raises if the :order! Array contains missing Hash keys" do
       hash = { :by_name => { :first_name => "Lucy", :last_name => "Sky", :order! => [:first_name, :middle_name, :last_name] } }
-      lambda { to_xml(hash) }.should raise_error(ArgumentError, "Spurious elements in :order! [:middle_name]")
+      expect { to_xml(hash) }.to raise_error(ArgumentError, "Spurious elements in :order! [:middle_name]")
     end
 
     it "adds attributes to Hash keys specified through :attributes!" do
       hash = { :find_user => { :person => "Lucy", :attributes! => { :person => { :id => 666 } } } }
       result = '<findUser><person id="666">Lucy</person></findUser>'
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
 
       hash = { :find_user => { :person => "Lucy", :attributes! => { :person => { :id => 666, :city => "Hamburg" } } } }
-      to_xml(hash).should include('id="666"', 'city="Hamburg"')
+      expect(to_xml(hash)).to include('id="666"', 'city="Hamburg"')
     end
 
     it "adds attributes to duplicate Hash keys specified through :attributes!" do
       hash = { :find_user => { :person => ["Lucy", "Anna"], :attributes! => { :person => { :id => [1, 3] } } } }
       result = '<findUser><person id="1">Lucy</person><person id="3">Anna</person></findUser>'
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
 
       hash = { :find_user => { :person => ["Lucy", "Anna"], :attributes! => { :person => { :active => "true" } } } }
       result = '<findUser><person active="true">Lucy</person><person active="true">Anna</person></findUser>'
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
     end
 
     it "skips attribute for element without attributes if there are fewer attributes than elements" do
       hash = { :find_user => { :person => ["Lucy", "Anna", "Beth"], :attributes! => { :person => { :id => [1, 3] } } } }
       result = '<findUser><person id="1">Lucy</person><person id="3">Anna</person><person>Beth</person></findUser>'
-      to_xml(hash).should == result
+      expect(to_xml(hash)).to eq(result)
     end
 
     it "adds attributes to self-closing tags" do
@@ -137,7 +178,7 @@ describe Gyoku::Hash do
         :attributes! => { "category/" => { :id => 1 }  }
       }
 
-      to_xml(hash).should == '<category id="1"/>'
+      expect(to_xml(hash)).to eq('<category id="1"/>')
     end
 
     it "recognizes @attribute => value along :attributes!" do
@@ -147,7 +188,7 @@ describe Gyoku::Hash do
           :@id => 1
         }
       }
-      to_xml(hash).should == '<category id="1">users</category>'
+      expect(to_xml(hash)).to eq('<category id="1">users</category>')
     end
 
     it "recognizes @attribute => value along :attributes! in selfclosed tags" do
@@ -156,7 +197,7 @@ describe Gyoku::Hash do
           :@id => 1
         }
       }
-      to_xml(hash).should == '<category id="1"/>'
+      expect(to_xml(hash)).to eq('<category id="1"/>')
     end
 
     it ":@attribute => value takes over :attributes!" do
@@ -172,7 +213,7 @@ describe Gyoku::Hash do
         }
       }
       # attribute order is undefined
-      ['<category id="1" type="admins"/>','<category type="admins" id="1"/>'].should include to_xml(hash)
+      expect(['<category id="1" type="admins"/>','<category type="admins" id="1"/>']).to include to_xml(hash)
 
       # with symbols
       hash = {
@@ -186,7 +227,7 @@ describe Gyoku::Hash do
           }
         }
       }
-      ['<category id="1" type="admins"/>','<category type="admins" id="1"/>'].should include to_xml(hash)
+      expect(['<category id="1" type="admins"/>','<category type="admins" id="1"/>']).to include to_xml(hash)
     end
 
     it "recognizes :content! => value as tag content" do
@@ -195,7 +236,7 @@ describe Gyoku::Hash do
           :content! => "users"
         }
       }
-      to_xml(hash).should == "<category>users</category>"
+      expect(to_xml(hash)).to eq("<category>users</category>")
     end
 
     it "recognizes :content! => value as tag content with value Fixnum" do
@@ -204,7 +245,7 @@ describe Gyoku::Hash do
           :content! => 666
         }
       }
-      to_xml(hash).should == "<category>666</category>"
+      expect(to_xml(hash)).to eq("<category>666</category>")
     end
 
     it "recognizes :content! => value as tag content with value true" do
@@ -213,7 +254,7 @@ describe Gyoku::Hash do
           :content! => true
         }
       }
-      to_xml(hash).should == "<category>true</category>"
+      expect(to_xml(hash)).to eq("<category>true</category>")
     end
 
     it "recognizes :content! => value as tag content with value false" do
@@ -222,7 +263,7 @@ describe Gyoku::Hash do
           :content! => false
         }
       }
-      to_xml(hash).should == "<category>false</category>"
+      expect(to_xml(hash)).to eq("<category>false</category>")
     end
 
     it "recognizes :content! => value as tag content with value DateTime" do
@@ -231,7 +272,7 @@ describe Gyoku::Hash do
           :content! => DateTime.new(2012, 03, 22, 16, 22, 33)
         }
       }
-      to_xml(hash).should == "<before>2012-03-22T16:22:33+00:00</before>"
+      expect(to_xml(hash)).to eq("<before>2012-03-22T16:22:33+00:00</before>")
     end
 
     it "ignores :content! if self-closing mark present" do
@@ -240,14 +281,14 @@ describe Gyoku::Hash do
           :content! => "users"
         }
       }
-      to_xml(hash).should == "<category/>"
+      expect(to_xml(hash)).to eq("<category/>")
     end
 
     it "recognizes array of attributes" do
       hash = {
         "category" => [{:@name => 'one'}, {:@name => 'two'}]
       }
-      to_xml(hash).should == '<category name="one"></category><category name="two"></category>'
+      expect(to_xml(hash)).to eq('<category name="one"></category><category name="two"></category>')
 
       # issue #31.
       hash = {
@@ -255,7 +296,7 @@ describe Gyoku::Hash do
         'foo' => { :@foo => 'foo' },
         'bar' => { :@bar => 'bar', 'baz' => { } },
       }
-      to_xml(hash).should == '<foo foo="foo"></foo><bar bar="bar"><baz></baz></bar>'
+      expect(to_xml(hash)).to eq('<foo foo="foo"></foo><bar bar="bar"><baz></baz></bar>')
     end
 
     it "recognizes array of attributes with content in each" do
@@ -263,10 +304,10 @@ describe Gyoku::Hash do
         "foo" => [{:@name => "bar", :content! => 'gyoku'}, {:@name => "baz", :@some => "attr", :content! => 'rocks!'}]
       }
 
-      [
+      expect([
         '<foo name="bar">gyoku</foo><foo name="baz" some="attr">rocks!</foo>',
         '<foo name="bar">gyoku</foo><foo some="attr" name="baz">rocks!</foo>'
-      ].should include to_xml(hash)
+      ]).to include to_xml(hash)
     end
 
     it "recognizes array of attributes but ignores content in each if selfclosing" do
@@ -274,17 +315,17 @@ describe Gyoku::Hash do
         "foo/" => [{:@name => "bar", :content! => 'gyoku'}, {:@name => "baz", :@some => "attr", :content! => 'rocks!'}]
       }
 
-      [
+      expect([
         '<foo name="bar"/><foo name="baz" some="attr"/>',
         '<foo name="bar"/><foo some="attr" name="baz"/>'
-      ].should include to_xml(hash)
+      ]).to include to_xml(hash)
     end
 
     it "recognizes array of attributes with selfclosing tag" do
       hash = {
         "category/" => [{:@name => 'one'}, {:@name => 'two'}]
       }
-      to_xml(hash).should == '<category name="one"/><category name="two"/>'
+      expect(to_xml(hash)).to eq('<category name="one"/><category name="two"/>')
     end
 
     context "with :element_form_default set to :qualified and a :namespace" do
@@ -292,7 +333,7 @@ describe Gyoku::Hash do
         hash = { :first => { "first_name" => "Lucy" }, ":second" => { :":first_name" => "Anna" }, "v2:third" => { "v2:firstName" => "Danie" } }
         result = to_xml hash, :element_form_default => :qualified, :namespace => :v1
 
-        result.should include(
+        expect(result).to include(
           "<v1:first><v1:first_name>Lucy</v1:first_name></v1:first>",
           "<second><firstName>Anna</firstName></second>",
           "<v2:third><v2:firstName>Danie</v2:firstName></v2:third>"
@@ -303,7 +344,7 @@ describe Gyoku::Hash do
         hash = { :array => [ :first  => "Lucy", :second => "Anna" ]}
         result = to_xml hash, :element_form_default => :qualified, :namespace => :v1
 
-        result.should include("<v1:array>", "<v1:first>Lucy</v1:first>", "<v1:second>Anna</v1:second>")
+        expect(result).to include("<v1:array>", "<v1:first>Lucy</v1:first>", "<v1:second>Anna</v1:second>")
       end
     end
 
@@ -322,7 +363,7 @@ describe Gyoku::Hash do
 
       to_xml(hash)
 
-      hash.should == {
+      expect(hash).to eq({
         :persons => {
           :first => "Lucy",
           :second => "Anna",
@@ -332,14 +373,14 @@ describe Gyoku::Hash do
         :countries => [:de, :us],
         :order! => [:countries, :persons],
         :attributes! => { :countries => { :array => true } }
-      }
+      })
     end
   end
 
   it "doesn't modify original hash parameter by deleting its attribute keys" do
     hash = { :person => {:name => "Johnny", :surname => "Bravo", :"@xsi:type" => "People"} }
     to_xml(hash)
-    hash.should == {:person=>{:name=>"Johnny", :surname=>"Bravo", :"@xsi:type"=>"People"}}
+    expect(hash).to eq({:person=>{:name=>"Johnny", :surname=>"Bravo", :"@xsi:type"=>"People"}})
   end
 
   def to_xml(hash, options = {})

data/spec/gyoku/xml_key_spec.rb

@@ -4,36 +4,57 @@ describe Gyoku::XMLKey do
 
   describe ".create" do
     it "removes exclamation marks from the end of a String" do
-      create("value!").should == "value"
+      expect(create("value!")).to eq("value")
     end
 
     it "removes forward slashes from the end of a String" do
-      create("self-closing/").should == "self-closing"
+      expect(create("self-closing/")).to eq("self-closing")
     end
 
     it "does not convert snake_case Strings" do
-      create("lower_camel_case").should == "lower_camel_case"
+      expect(create("lower_camel_case")).to eq("lower_camel_case")
     end
 
     it "converts snake_case Symbols to lowerCamelCase Strings" do
-      create(:lower_camel_case).should == "lowerCamelCase"
-      create(:lower_camel_case!).should == "lowerCamelCase"
+      expect(create(:lower_camel_case)).to eq("lowerCamelCase")
+      expect(create(:lower_camel_case!)).to eq("lowerCamelCase")
+    end
+
+    context "with key_converter" do
+      it "convert symbol to the specified type" do
+        expect(create(:some_text, {key_converter: :camelcase})).to eq("SomeText")
+        expect(create(:some_text, {key_converter: :upcase})).to eq("SOME_TEXT")
+        expect(create(:some_text, {key_converter: :none})).to eq("some_text")
+      end
+
+      it "when key_to_convert is defined, convert only this key" do
+        options = {key_converter: :camelcase, key_to_convert: 'somekey'}
+        expect(create(:some_key, options)).to eq("someKey")
+
+        options = {key_converter: :camelcase, key_to_convert: 'some_key'}
+        expect(create(:some_key, options)).to eq("SomeKey")
+      end
+
+      it "when except is defined, dont convert this key" do
+        options = {key_converter: :camelcase, except: 'some_key'}
+        expect(create(:some_key, options)).to eq("someKey")
+      end
     end
 
     context "with :element_form_default set to :qualified and a :namespace" do
       it "adds the given namespace" do
         key = create :qualify, :element_form_default => :qualified, :namespace => :v1
-        key.should == "v1:qualify"
+        expect(key).to eq("v1:qualify")
       end
 
       it "does not add the given namespace if the key starts with a colon" do
         key = create ":qualify", :element_form_default => :qualified, :namespace => :v1
-        key.should == "qualify"
+        expect(key).to eq("qualify")
       end
 
       it "adds a given :namespace after converting the key" do
         key = create :username, :element_form_default => :qualified, :namespace => :v1, :key_converter => :camelcase
-        key.should == "v1:Username"
+        expect(key).to eq("v1:Username")
       end
     end
   end

data/spec/gyoku/xml_value_spec.rb

@@ -5,31 +5,31 @@ describe Gyoku::XMLValue do
   describe ".create" do
     context "for DateTime objects" do
       it "returns an xs:dateTime compliant String" do
-        create(DateTime.new(2012, 03, 22, 16, 22, 33)).should == "2012-03-22T16:22:33+00:00"
+        expect(create(DateTime.new(2012, 03, 22, 16, 22, 33))).to eq("2012-03-22T16:22:33+00:00")
       end
     end
 
     context "for Date objects" do
       it "returns an xs:date compliant String" do
-        create(Date.new(2012, 03, 22)).should == "2012-03-22"
+        expect(create(Date.new(2012, 03, 22))).to eq("2012-03-22")
       end
     end
 
     context "for Time objects" do
       it "returns an xs:time compliant String" do
-        create(Time.local(2012, 03, 22, 16, 22, 33)).should == "16:22:33"
+        expect(create(Time.local(2012, 03, 22, 16, 22, 33))).to eq("16:22:33")
       end
     end
 
     it "returns the String value and escapes special characters" do
-      create("string").should == "string"
-      create("<tag>").should == "&lt;tag&gt;"
-      create("at&t").should == "at&amp;t"
-      create('"quotes"').should == "&quot;quotes&quot;"
+      expect(create("string")).to eq("string")
+      expect(create("<tag>")).to eq("&lt;tag&gt;")
+      expect(create("at&t")).to eq("at&amp;t")
+      expect(create('"quotes"')).to eq("&quot;quotes&quot;")
     end
 
     it "returns the String value without escaping special characters" do
-      create("<tag>", false).should == "<tag>"
+      expect(create("<tag>", false)).to eq("<tag>")
     end
 
     it "returns an xs:dateTime compliant String for Objects responding to #to_datetime" do
@@ -38,16 +38,16 @@ describe Gyoku::XMLValue do
         DateTime.new 2012, 03, 22, 16, 22, 33
       end
 
-      create(singleton).should == "2012-03-22T16:22:33+00:00"
+      expect(create(singleton)).to eq("2012-03-22T16:22:33+00:00")
     end
 
     it "calls Proc objects and converts their return value" do
       object = lambda { DateTime.new 2012, 03, 22, 16, 22, 33 }
-      create(object).should == "2012-03-22T16:22:33+00:00"
+      expect(create(object)).to eq("2012-03-22T16:22:33+00:00")
     end
 
     it "calls #to_s unless the Object responds to #to_datetime" do
-      create("value").should == "value"
+      expect(create("value")).to eq("value")
     end
   end
 

data/spec/gyoku_spec.rb

@@ -29,15 +29,40 @@ describe Gyoku do
       hash = { :id => 1 }
       xml = Gyoku.xml(hash, :element_form_default => :qualified)
 
-      xml.should == "<id>1</id>"
+      expect(xml).to eq("<id>1</id>")
     end
 
     it "accepts a key_converter for the Hash keys" do
+      hash = { :user_name => "finn", :pass_word => "secret" }
+      xml = Gyoku.xml(hash, {key_converter: :upcase})
+
+      expect(xml).to include("<USER_NAME>finn</USER_NAME>")
+      expect(xml).to include("<PASS_WORD>secret</PASS_WORD>")
+    end
+
+    it "don't converts Strings keys" do
       hash = { :user_name => "finn", "pass_word" => "secret" }
-      xml = Gyoku.xml(hash, :key_converter => :upcase)
+      xml = Gyoku.xml(hash, {key_converter: :upcase})
+
+      expect(xml).to include("<USER_NAME>finn</USER_NAME>")
+      expect(xml).to include("<pass_word>secret</pass_word>")
+    end
+
+    it "when defined key_to_convert only convert this key" do
+      hash = { user_name: "finn", pass_word: "secret" }
+      options = {key_converter: :upcase, key_to_convert: 'user_name'}
+      xml = Gyoku.xml(hash, options)
+
+      expect(xml).to include("<USER_NAME>finn</USER_NAME>")
+      expect(xml).to include("<passWord>secret</passWord>")
+    end
+
+    it "accepts key_converter for nested hash" do
+      hash = { user: { user_name: "finn", pass_word: "secret" }}
+      xml = Gyoku.xml(hash, {key_converter: :upcase})
 
-      xml.should include("<USER_NAME>finn</USER_NAME>")
-      xml.should include("<pass_word>secret</pass_word>")
+      expect(xml).to include("<USER><USER_NAME>finn</USER_NAME>")
+      expect(xml).to include("<PASS_WORD>secret</PASS_WORD></USER>")
     end
 
     it "does not modify the original Hash" do
@@ -52,7 +77,7 @@ describe Gyoku do
       original_hash = hash.dup
 
       Gyoku.xml(hash)
-      original_hash.should == hash
+      expect(original_hash).to eq(hash)
     end
   end
 

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: gyoku
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Daniel Harrington
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Gyoku translates Ruby Hashes to XML
@@ -58,9 +58,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
@@ -89,17 +89,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: gyoku
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Translates Ruby Hashes to XML