roxml 3.2.2 → 4.1.1

data/lib/roxml/xml/parsers/nokogiri.rb

@@ -46,37 +46,24 @@ module ROXML
           file << doc.serialize
         end
       end
-    end
-
-    Document = Nokogiri::XML::Document
-    Element = Nokogiri::XML::Element
-    Node = Nokogiri::XML::Node
-
-    class Document
-      alias :roxml_search :search
-
-      def default_namespace
-        'xmlns' if root.namespaces['xmlns']
-      end
-    end
 
-    module NodeExtensions
-      def roxml_search(xpath, roxml_namespaces = {})
-        xpath = "./#{xpath}"
-        (roxml_namespaces.present? ? search(xpath, roxml_namespaces) : search(xpath))
+      def default_namespace(doc)
+        doc = doc.document if doc.respond_to?(:document)
+        'xmlns' if doc.root.namespaces['xmlns']
       end
 
-      def default_namespace
-        document.default_namespace
+      def search(xml, xpath, roxml_namespaces = {})
+        case xml
+        when Nokogiri::XML::Document
+          xml.search(xpath, roxml_namespaces)
+        else
+          xpath = "./#{xpath}"
+          (roxml_namespaces.present? ? xml.search(xpath, roxml_namespaces) : xml.search(xpath))
+        end
       end
     end
 
-    class Element
-      include NodeExtensions
-    end
-
-    class Node
-      include NodeExtensions
-    end
+    Document = Nokogiri::XML::Document
+    Node = Nokogiri::XML::Node
   end
 end

data/lib/roxml/xml/references.rb

@@ -1,5 +1,7 @@
+require "rexml/xpath_parser"
+
 module ROXML
-  class RequiredElementMissing < Exception # :nodoc:
+  class RequiredElementMissing < ArgumentError # :nodoc:
   end
 
   #
@@ -32,8 +34,9 @@ module ROXML
     end
 
     def value_in(xml)
-      value = fetch_value(XML::Node.from(xml))
-      value = default if value.nil?
+      xml = XML::Node.from(xml)
+      value = fetch_value(xml)
+      value = default if default && (value.nil? || value.to_s.empty?)
 
       value = apply_blocks(value)
       value = freeze(value) if value && opts.frozen?
@@ -51,20 +54,30 @@ module ROXML
     end
 
     def namespacify(what)
-      if what.to_s.present? && !what.to_s.include?(':') && opts.namespace != false
-        [opts.namespace, @instance.class.roxml_namespace, @default_namespace].each do |namespace|
-          return opts.namespace == '*' ? (what == '*' ? "*" : "*[local-name()='#{what}']") : "#{namespace}:#{what}" if namespace
+      if what.to_s.present? && opts.namespace != false && ns = [opts.namespace, @instance.class.roxml_namespace, @default_namespace].compact.map(&:to_s).first
+        parser = REXML::Parsers::XPathParser.new
+        parsed = parser.parse what
+
+        parsed.each_cons(4).with_index.each do |a,i|
+          if a[0..2] == [:child, :qname, ""]
+            if ns == "*"
+              parsed[i+1,3] = [:any, :predicate, [:eq, [:function, "local-name", []], [:literal, a[3]]]] if a[3] != "*"
+            else
+              a[2].replace ns
+            end
+          end
         end
+
+        parser.abbreviate parsed
+      else
+        what
       end
-      what
     end
 
     def apply_blocks(val)
-      begin
-        blocks.inject(val) {|val, block| block.call(val) }
-      rescue Exception => ex
-        raise ex, "#{accessor}: #{ex.message}"
-      end
+      blocks.inject(val) {|val, block| block.call(val) }
+    rescue Exception => ex
+      raise ex, "#{accessor}: #{ex.message}"
     end
 
     def freeze(val)
@@ -90,26 +103,25 @@ module ROXML
 
     def wrap(xml, opts = {:always_create => false})
       wrap_with = @auto_vals ? auto_wrapper : wrapper
-      
+
       return xml if !wrap_with || xml.name == wrap_with
 
       wraps = wrap_with.to_s.split('/')
-      wraps.inject(xml) do |node,wrap| 
-        if !opts[:always_create] && (child = node.children.find {|c| c.name == wrap }) 
+      wraps.inject(xml) do |node,wrap|
+        if !opts[:always_create] && (child = node.children.find {|c| c.name == wrap })
           child
         else
-          XML.add_node(node, wrap)    
+          XML.add_node(node, wrap)
         end
-      end    
-    
+      end
     end
 
     def nodes_in(xml)
-      @default_namespace = xml.default_namespace
-      vals = xml.roxml_search(xpath, @instance.class.roxml_namespaces)
+      @default_namespace = XML.default_namespace(xml)
+      vals = XML.search(xml, xpath, @instance.class.roxml_namespaces)
 
       if several? && vals.empty? && !wrapper && auto_xpath
-        vals = xml.roxml_search(auto_xpath, @instance.class.roxml_namespaces)
+        vals = XML.search(xml, auto_xpath, @instance.class.roxml_namespaces)
         @auto_vals = !vals.empty?
       end
 

data/roxml.gemspec

@@ -1,17 +1,19 @@
-# Generated by jeweler
+# Generated by juwelier
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: roxml 4.1.1 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = "roxml"
-  s.version = "3.2.2"
+  s.name = "roxml".freeze
+  s.version = "4.1.1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ben Woosley", "Zak Mandhro", "Anders Engstrom", "Russ Olsen"]
-  s.date = "2012-01-30"
-  s.description = "ROXML is a Ruby library designed to make it easier for Ruby developers to work with XML.\nUsing simple annotations, it enables Ruby classes to be mapped to XML. ROXML takes care\nof the marshalling and unmarshalling of mapped attributes so that developers can focus on\nbuilding first-class Ruby classes. As a result, ROXML simplifies the development of\nRESTful applications, Web Services, and XML-RPC.\n"
-  s.email = "ben.woosley@gmail.com"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Ben Woosley".freeze, "Zak Mandhro".freeze, "Anders Engstrom".freeze, "Russ Olsen".freeze]
+  s.date = "2020-07-06"
+  s.description = "ROXML is a Ruby library designed to make it easier for Ruby developers to work with XML.\nUsing simple annotations, it enables Ruby classes to be mapped to XML. ROXML takes care\nof the marshalling and unmarshalling of mapped attributes so that developers can focus on\nbuilding first-class Ruby classes. As a result, ROXML simplifies the development of\nRESTful applications, Web Services, and XML-RPC.\n".freeze
+  s.email = "ben.woosley@gmail.com".freeze
   s.extra_rdoc_files = [
     "History.txt",
     "README.rdoc"
@@ -19,6 +21,7 @@ Gem::Specification.new do |s|
   s.files = [
     ".gitmodules",
     ".rspec",
+    ".travis.yml",
     "Gemfile",
     "Gemfile.lock",
     "History.txt",
@@ -35,6 +38,7 @@ Gem::Specification.new do |s|
     "examples/person.rb",
     "examples/posts.rb",
     "examples/rails.rb",
+    "examples/search_query.rb",
     "examples/twitter.rb",
     "examples/xml/active_record.xml",
     "examples/xml/amazon.xml",
@@ -61,6 +65,7 @@ Gem::Specification.new do |s|
     "spec/examples/library_with_fines_spec.rb",
     "spec/examples/person_spec.rb",
     "spec/examples/post_spec.rb",
+    "spec/examples/search_query_spec.rb",
     "spec/examples/twitter_spec.rb",
     "spec/reference_spec.rb",
     "spec/regression_spec.rb",
@@ -107,7 +112,6 @@ Gem::Specification.new do |s|
     "test/fixtures/person.xml",
     "test/fixtures/person_with_guarded_mothers.xml",
     "test/fixtures/person_with_mothers.xml",
-    "test/load_test.rb",
     "test/mocks/dictionaries.rb",
     "test/mocks/mocks.rb",
     "test/support/fixtures.rb",
@@ -128,40 +132,36 @@ Gem::Specification.new do |s|
     "test/unit/xml_text_test.rb",
     "website/index.html"
   ]
-  s.homepage = "http://roxml.rubyforge.org"
-  s.require_paths = ["lib"]
-  s.rubyforge_project = "roxml"
-  s.rubygems_version = "1.8.10"
-  s.summary = "Ruby Object to XML mapping library"
+  s.homepage = "https://github.com/Empact/roxml".freeze
+  s.rubygems_version = "3.1.2".freeze
+  s.summary = "Ruby Object to XML mapping library".freeze
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
+  end
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.0"])
-      s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.3"])
-      s.add_development_dependency(%q<rake>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
-      s.add_development_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
-      s.add_development_dependency(%q<activerecord>, [">= 2.2.2"])
-    else
-      s.add_dependency(%q<activesupport>, [">= 2.3.0"])
-      s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
-      s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 2.0.0"])
-      s.add_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
-      s.add_dependency(%q<activerecord>, [">= 2.2.2"])
-    end
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<activesupport>.freeze, [">= 4.0"])
+    s.add_runtime_dependency(%q<nokogiri>.freeze, [">= 1.3.3"])
+    s.add_development_dependency(%q<rake>.freeze, ["~> 0.9"])
+    s.add_development_dependency(%q<juwelier>.freeze, [">= 0"])
+    s.add_development_dependency(%q<minitest>.freeze, [">= 0"])
+    s.add_development_dependency(%q<rspec>.freeze, ["~> 3.7.0"])
+    s.add_development_dependency(%q<sqlite3>.freeze, [">= 1.2.4"])
+    s.add_development_dependency(%q<activerecord>.freeze, [">= 4.0"])
+    s.add_development_dependency(%q<rack>.freeze, ["< 2.0.0"])
+    s.add_development_dependency(%q<equivalent-xml>.freeze, [">= 0.6.0"])
   else
-    s.add_dependency(%q<activesupport>, [">= 2.3.0"])
-    s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
-    s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 2.0.0"])
-    s.add_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
-    s.add_dependency(%q<activerecord>, [">= 2.2.2"])
+    s.add_dependency(%q<activesupport>.freeze, [">= 4.0"])
+    s.add_dependency(%q<nokogiri>.freeze, [">= 1.3.3"])
+    s.add_dependency(%q<rake>.freeze, ["~> 0.9"])
+    s.add_dependency(%q<juwelier>.freeze, [">= 0"])
+    s.add_dependency(%q<minitest>.freeze, [">= 0"])
+    s.add_dependency(%q<rspec>.freeze, ["~> 3.7.0"])
+    s.add_dependency(%q<sqlite3>.freeze, [">= 1.2.4"])
+    s.add_dependency(%q<activerecord>.freeze, [">= 4.0"])
+    s.add_dependency(%q<rack>.freeze, ["< 2.0.0"])
+    s.add_dependency(%q<equivalent-xml>.freeze, [">= 0.6.0"])
   end
 end
 

data/spec/definition_spec.rb

@@ -4,19 +4,19 @@ require_relative './spec_helper'
 describe ROXML::Definition do
   describe "#name_explicit?" do
     it "should indicate whether from option is present" do
-      ROXML::Definition.new(:element, :from => 'somewhere').name_explicit?.should be_true
-      ROXML::Definition.new(:element).name_explicit?.should be_false
+      expect(ROXML::Definition.new(:element, :from => 'somewhere').name_explicit?).to be_truthy
+      expect(ROXML::Definition.new(:element).name_explicit?).to be_falsey
     end
 
     it "should not consider name proxies as explicit" do
-      ROXML::Definition.new(:element, :from => :attr).name_explicit?.should be_false
-      ROXML::Definition.new(:element, :from => :content).name_explicit?.should be_false
+      expect(ROXML::Definition.new(:element, :from => :attr).name_explicit?).to be_falsey
+      expect(ROXML::Definition.new(:element, :from => :content).name_explicit?).to be_falsey
     end
   end
 
   shared_examples_for "DateTime reference" do
     it "should return nil on empty string" do
-      @subject.blocks.first.call("  ").should be_nil
+      expect(@subject.blocks.first.call("  ")).to be_nil
     end
 
     it "should return a time version of the string" do
@@ -25,14 +25,14 @@ describe ROXML::Definition do
 
     context "when passed an array of values" do
       it "should timify all of them" do
-        @subject.blocks.first.call(["12:05pm, September 3rd, 1970", "3:00pm, May 22, 1700"]).map(&:to_s).should == ["1970-09-03T12:05:00+00:00", "1700-05-22T15:00:00+00:00"]
+        expect(@subject.blocks.first.call(["12:05pm, September 3rd, 1970", "3:00pm, May 22, 1700"]).map(&:to_s)).to eq(["1970-09-03T12:05:00+00:00", "1700-05-22T15:00:00+00:00"])
       end
     end
   end
 
   shared_examples_for "Date reference" do
     it "should return nil on empty string" do
-      @subject.blocks.first.call("  ").should be_nil
+      expect(@subject.blocks.first.call("  ")).to be_nil
     end
 
     it "should return a time version of the string" do
@@ -41,26 +41,26 @@ describe ROXML::Definition do
 
     context "when passed an array of values" do
       it "should timify all of them" do
-        @subject.blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s).should == ["1970-09-03", "1776-07-04"]
+        expect(@subject.blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s)).to eq(["1970-09-03", "1776-07-04"])
       end
     end
   end
 
   it "should unescape xml entities" do
-    ROXML::Definition.new(:questions, :as => []).to_ref(RoxmlObject.new).value_in(%{
+    expect(ROXML::Definition.new(:questions, :as => []).to_ref(RoxmlObject.new).value_in(%{
       <xml>
         <question>&quot;Wickard &amp; Filburn&quot; &gt;</question>
         <question> &lt; McCulloch &amp; Maryland?</question>
       </xml>
-    }).should == ["\"Wickard & Filburn\" >", " < McCulloch & Maryland?"]
+    })).to eq(["\"Wickard & Filburn\" >", " < McCulloch & Maryland?"])
   end
 
   it "should unescape utf characters in xml" do
-    ROXML::Definition.new(:questions, :as => []).to_ref(RoxmlObject.new).value_in(%{
+    expect(ROXML::Definition.new(:questions, :as => []).to_ref(RoxmlObject.new).value_in(%{
       <xml>
         <question>ROXML\342\204\242</question>
       </xml>
-    }).should == ["ROXML™"]
+    })).to eq(["ROXML™"])
   end
 
   describe "attr name" do
@@ -87,8 +87,8 @@ describe ROXML::Definition do
     describe "=> []" do
       it "should means array of texts" do
         opts = ROXML::Definition.new(:authors, :as => [])
-        opts.array?.should be_true
-        opts.sought_type.should == :text
+        expect(opts.array?).to be_truthy
+        expect(opts.sought_type).to eq(:text)
       end
     end
 
@@ -99,7 +99,7 @@ describe ROXML::Definition do
 
       it "should store type" do
         opts = ROXML::Definition.new(:name, :as => RoxmlClass)
-        opts.sought_type.should == RoxmlClass
+        expect(opts.sought_type).to eq(RoxmlClass)
       end
     end
 
@@ -112,35 +112,35 @@ describe ROXML::Definition do
 
       it "should accept type" do
         opts = ROXML::Definition.new(:name, :as => OctalInteger)
-        opts.sought_type.should == OctalInteger
+        expect(opts.sought_type).to eq(OctalInteger)
       end
     end
 
     describe "=> NonRoxmlClass" do
       it "should fail with a warning" do
-        proc { ROXML::Definition.new(:authors, :as => Module) }.should raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:authors, :as => Module) }.to raise_error(ArgumentError)
       end
     end
 
     describe "=> [NonRoxmlClass]" do
       it "should raise" do
-        proc { ROXML::Definition.new(:authors, :as => [Module]) }.should raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:authors, :as => [Module]) }.to raise_error(ArgumentError)
       end
     end
 
     describe "=> {}" do
       shared_examples_for "hash options declaration" do
         it "should represent a hash" do
-          @opts.hash?.should be_true
+          expect(@opts.hash?).to be_truthy
         end
 
         it "should have hash definition" do
-          {@opts.hash.key.sought_type => @opts.hash.key.name}.should == @hash_args[:key]
-          {@opts.hash.value.sought_type => @opts.hash.value.name}.should == @hash_args[:value]
+          expect({@opts.hash.key.sought_type => @opts.hash.key.name}).to eq(@hash_args[:key])
+          expect({@opts.hash.value.sought_type => @opts.hash.value.name}).to eq(@hash_args[:value])
         end
 
         it "should not represent an array" do
-          @opts.array?.should be_false
+          expect(@opts.array?).to be_falsey
         end
       end
 
@@ -193,32 +193,32 @@ describe ROXML::Definition do
         end
 
         it "should be detected as array reference" do
-          @opts.array?.should be_true
+          expect(@opts.array?).to be_truthy
         end
 
         it "should be normal otherwise" do
-          @opts.sought_type.should == :text
-          @opts.blocks.size.should == 1
+          expect(@opts.sought_type).to eq(:text)
+          expect(@opts.blocks.size).to eq(1)
         end
       end
 
       it "should have no blocks without a shorthand" do
-        ROXML::Definition.new(:count).blocks.should be_empty
+        expect(ROXML::Definition.new(:count).blocks).to be_empty
       end
 
       it "should raise on unknown :as" do
-        proc { ROXML::Definition.new(:count, :as => :bogus) }.should raise_error(ArgumentError)
-        proc { ROXML::Definition.new(:count, :as => :foat) }.should raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:count, :as => :bogus) }.to raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:count, :as => :foat) }.to raise_error(ArgumentError)
       end
 
       shared_examples_for "block shorthand type declaration" do
         it "should translate nil to nil" do
-          @definition.blocks.first.call(nil).should be_nil
+          expect(@definition.blocks.first.call(nil)).to be_nil
         end
 
         it "should translate empty strings to nil" do
-          @definition.blocks.first.call("").should be_nil
-          @definition.blocks.first.call(" ").should be_nil
+          expect(@definition.blocks.first.call("")).to be_nil
+          expect(@definition.blocks.first.call(" ")).to be_nil
         end
       end
 
@@ -230,20 +230,21 @@ describe ROXML::Definition do
         it_should_behave_like "block shorthand type declaration"
 
         it "should translate text to integers" do
-          @definition.blocks.first['3'].should == 3
-          @definition.blocks.first['792'].should == 792
+          expect(@definition.blocks.first['3']).to eq(3)
+          expect(@definition.blocks.first['792']).to eq(792)
+          expect(@definition.blocks.first['08']).to eq(8)
+          expect(@definition.blocks.first['279.23']).to eq(279)
         end
 
-        it "should raise on non-integer values" do
-          proc { @definition.blocks.first['08'] }.should raise_error(ArgumentError)
-          proc { @definition.blocks.first['793.12'] }.should raise_error(ArgumentError)
-          proc { @definition.blocks.first['junk 11'] }.should raise_error(ArgumentError)
-          proc { @definition.blocks.first['11sttf'] }.should raise_error(ArgumentError)
+        it "should extract whatever is possible and fall back to 0" do
+          expect(@definition.blocks.first['junk 11']).to eql(0)
+          expect(@definition.blocks.first['.?sttf']).to eql(0)
+          expect(@definition.blocks.first['11sttf']).to eql(11)
         end
 
         context "when passed an array" do
           it "should translate the array elements to integer" do
-            @definition.blocks.first.call(["792", "12", "328"]).should == [792, 12, 328]
+            expect(@definition.blocks.first.call(["792", "12", "328"])).to eq([792, 12, 328])
           end
         end
       end
@@ -256,18 +257,18 @@ describe ROXML::Definition do
         it_should_behave_like "block shorthand type declaration"
 
         it "should translate text to float" do
-          @definition.blocks.first['3'].should == 3.0
-          @definition.blocks.first['12.7'].should == 12.7
+          expect(@definition.blocks.first['3']).to eq(3.0)
+          expect(@definition.blocks.first['12.7']).to eq(12.7)
         end
 
         it "should raise on non-float values" do
-          proc { @definition.blocks.first['junk 11.3'] }.should raise_error(ArgumentError)
-          proc { @definition.blocks.first['11.1sttf'] }.should raise_error(ArgumentError)
+          expect { @definition.blocks.first['junk 11.3'] }.to raise_error(ArgumentError)
+          expect { @definition.blocks.first['11.1sttf'] }.to raise_error(ArgumentError)
         end
 
         context "when passed an array" do
           it "should translate the array elements to integer" do
-            @definition.blocks.first.call(["792.13", "240", "3.14"]).should == [792.13, 240.0, 3.14]
+            expect(@definition.blocks.first.call(["792.13", "240", "3.14"])).to eq([792.13, 240.0, 3.14])
           end
         end
       end
@@ -280,67 +281,42 @@ describe ROXML::Definition do
         it_should_behave_like "block shorthand type declaration"
 
         it "should translate text to decimal numbers" do
-          @definition.blocks.first['3'].should == BigDecimal.new("3.0")
-          @definition.blocks.first['0.3'].should == BigDecimal.new("0.3")
-        end
-
-        it "should extract what it can, and fall back to 0" do
-          @definition.blocks.first['junk 11'].should eql(BigDecimal.new("0"))
-          @definition.blocks.first['11sttf'].should eql(BigDecimal.new("11.0"))
+          expect(@definition.blocks.first['3']).to eq(BigDecimal("3.0"))
+          expect(@definition.blocks.first['0.3']).to eq(BigDecimal("0.3"))
         end
 
-        context "when passed an array" do
-          it "should translate the array elements to integer" do
-            @definition.blocks.first.call(["12.1", "328.2"]).should == [BigDecimal.new("12.1"), BigDecimal.new("328.2")]
+        # Ruby behavior of BigDecimal changed in 2.4, this test is not valid on older rubies
+        if RUBY_VERSION >= "2.4"
+          it "should raise on non-decimal values" do
+            expect { @definition.blocks.first['junk 11'] }.to raise_error(ArgumentError)
           end
         end
-      end
-
-      describe "Fixnum" do
-        before do
-          @definition = ROXML::Definition.new(:fixnumvalue, :as => Fixnum)
-        end
-
-        it_should_behave_like "block shorthand type declaration"
-
-        it "should translate text to integers" do
-          @definition.blocks.first['3'].should == 3
-          @definition.blocks.first['792'].should == 792
-          @definition.blocks.first['08'].should == 8
-          @definition.blocks.first['279.23'].should == 279
-        end
-
-        it "should extract whatever is possible and fall back to 0" do
-          @definition.blocks.first['junk 11'].should eql(0)
-          @definition.blocks.first['.?sttf'].should eql(0)
-          @definition.blocks.first['11sttf'].should eql(11)
-        end
 
         context "when passed an array" do
           it "should translate the array elements to integer" do
-            @definition.blocks.first.call(["792", "12", "328"]).should == [792, 12, 328]
+            expect(@definition.blocks.first.call(["12.1", "328.2"])).to eq([BigDecimal("12.1"), BigDecimal("328.2")])
           end
         end
       end
 
       describe ":bool" do
         it "should boolify individual values" do
-          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("1").should be_true
-          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("True").should be_true
-          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("Yes").should be_true
+          expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("1")).to be_truthy
+          expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("True")).to be_truthy
+          expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("Yes")).to be_truthy
         end
 
         context "when an array is passed in" do
           it "should boolify arrays of values" do
-            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("0").should be_false
-            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("false").should be_false
-            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("nO").should be_false
+            expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("0")).to be_falsey
+            expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("false")).to be_falsey
+            expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("nO")).to be_falsey
           end
         end
 
         context "when no value is detected" do
           it "should return nil" do
-            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("junk").should be_nil
+            expect(ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("junk")).to be_nil
           end
 
           context "when a literal block is available" do
@@ -351,16 +327,16 @@ describe ROXML::Definition do
 
       describe "Time" do
         it "should return nil on empty string" do
-          ROXML::Definition.new(:floatvalue, :as => Time).blocks.first.call("  ").should be_nil
+          expect(ROXML::Definition.new(:floatvalue, :as => Time).blocks.first.call("  ")).to be_nil
         end
 
         it "should return a time version of the string" do
-          ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call("12:31am").min.should == 31
+          expect(ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call("12:31am").min).to eq(31)
         end
 
         context "when passed an array of values" do
           it "should timify all of them" do
-            ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call(["12:31am", "3:00pm", "11:59pm"]).map(&:min).should == [31, 0, 59]
+            expect(ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call(["12:31am", "3:00pm", "11:59pm"]).map(&:min)).to eq([31, 0, 59])
           end
         end
       end
@@ -380,12 +356,12 @@ describe ROXML::Definition do
       end
 
       it "should prohibit multiple shorthands" do
-        proc { ROXML::Definition.new(:count, :as => [Float, Integer]) }.should raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:count, :as => [Float, Integer]) }.to raise_error(ArgumentError)
       end
 
       it "should stack block shorthands with explicit blocks" do
-        ROXML::Definition.new(:count, :as => Integer) {|val| val.to_i }.blocks.size.should == 2
-        ROXML::Definition.new(:count, :as => Float) {|val| val.object_id }.blocks.size.should == 2
+        expect(ROXML::Definition.new(:count, :as => Integer) {|val| val.to_i }.blocks.size).to eq(2)
+        expect(ROXML::Definition.new(:count, :as => Float) {|val| val.object_id }.blocks.size).to eq(2)
       end
     end
   end
@@ -393,17 +369,17 @@ describe ROXML::Definition do
   describe ":from" do
     shared_examples_for "attribute reference" do
       it "should be interpreted as :attr" do
-        @opts.sought_type.should == :attr
+        expect(@opts.sought_type).to eq(:attr)
       end
 
       it "should strip '@' from name" do
-        @opts.name.should == 'attr_name'
+        expect(@opts.name).to eq('attr_name')
       end
 
       it "should unescape xml entities" do
-        @opts.to_ref(RoxmlObject.new).value_in(%{
+        expect(@opts.to_ref(RoxmlObject.new).value_in(%{
           <question attr_name="&quot;Wickard &amp; Filburn&quot; &gt; / &lt; McCulloch &amp; Marryland?" />
-        }).should == "\"Wickard & Filburn\" > / < McCulloch & Marryland?"
+        })).to eq("\"Wickard & Filburn\" > / < McCulloch & Marryland?")
       end
     end
 
@@ -425,12 +401,12 @@ describe ROXML::Definition do
 
     describe ":content" do
       it "should be recognized" do
-        ROXML::Definition.new(:author).content?.should be_false
-        ROXML::Definition.new(:author, :from => :content).content?.should == true
+        expect(ROXML::Definition.new(:author).content?).to be_falsey
+        expect(ROXML::Definition.new(:author, :from => :content).content?).to eq(true)
       end
 
       it "should be equivalent to :from => '.'" do
-        ROXML::Definition.new(:author, :from => '.').content?.should == true
+        expect(ROXML::Definition.new(:author, :from => '.').content?).to eq(true)
       end
     end
   end
@@ -438,28 +414,27 @@ describe ROXML::Definition do
   describe ":in" do
     context "as xpath" do
       it "should pass through as wrapper" do
-        ROXML::Definition.new(:manufacturer, :in => './').wrapper.should == './'
+        expect(ROXML::Definition.new(:manufacturer, :in => './').wrapper).to eq('./')
       end
     end
 
     context "as xpath" do
       it "should pass through as wrapper" do
-        ROXML::Definition.new(:manufacturer, :in => 'wrapper').wrapper.should == 'wrapper'
+        expect(ROXML::Definition.new(:manufacturer, :in => 'wrapper').wrapper).to eq('wrapper')
       end
     end
   end
 
   describe "options" do
-
     shared_examples_for "boolean option" do
       it "should be recognized" do
         ROXML::Definition.new(:author, :from => :content, @option => true).respond_to?(:"#{@option}?")
-        ROXML::Definition.new(:author, :from => :content, @option => true).send(:"#{@option}?").should be_true
-        ROXML::Definition.new(:author, :from => :content, @option => false).send(:"#{@option}?").should be_false
+        expect(ROXML::Definition.new(:author, :from => :content, @option => true).send(:"#{@option}?")).to be_truthy
+        expect(ROXML::Definition.new(:author, :from => :content, @option => false).send(:"#{@option}?")).to be_falsey
       end
 
       it "should default to false" do
-        ROXML::Definition.new(:author, :from => :content).send(:"#{@option}?").should be_false
+        expect(ROXML::Definition.new(:author, :from => :content).send(:"#{@option}?")).to be_falsey
       end
     end
 
@@ -471,8 +446,8 @@ describe ROXML::Definition do
       it_should_behave_like "boolean option"
 
       it "should not be allowed together with :else" do
-        proc { ROXML::Definition.new(:author, :from => :content, :required => true, :else => 'Johnny') }.should raise_error(ArgumentError)
-        proc { ROXML::Definition.new(:author, :from => :content, :required => false, :else => 'Johnny') }.should_not raise_error
+        expect { ROXML::Definition.new(:author, :from => :content, :required => true, :else => 'Johnny') }.to raise_error(ArgumentError)
+        expect { ROXML::Definition.new(:author, :from => :content, :required => false, :else => 'Johnny') }.to_not raise_error
       end
     end
 
@@ -492,4 +467,10 @@ describe ROXML::Definition do
       it_should_behave_like "boolean option"
     end
   end
+
+  describe 'frozen_string_literal behavior' do
+    it 'should not raise error' do
+      expect { ROXML::Definition.new(:element, :from => '@somewhere'.freeze) }.not_to raise_error(FrozenError)
+    end
+  end
 end