roxml 2.5.3 → 3.1.0

data/spec/definition_spec.rb

@@ -1,8 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-class RoxmlObject
-  include ROXML
-end
+require 'spec/spec_helper'
 
 describe ROXML::Definition do
   describe "#name_explicit?" do
@@ -17,141 +13,132 @@ describe ROXML::Definition do
     end
   end
 
-  describe "hash options declaration", :shared => true do
-    it "should represent a hash" do
-      @opts.hash?.should be_true
+  describe "DateTime reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
     end
 
-    it "should have hash definition" do
-      {@opts.hash.key.type => @opts.hash.key.name}.should == @hash_args[:key]
-      {@opts.hash.value.type => @opts.hash.value.name}.should == @hash_args[:value]
+    it "should return a time version of the string" do
+      @subject.blocks.first.call("12:05pm, September 3rd, 1970").to_s == "1970-09-03T12:05:00+00:00"
     end
 
-    it "should not represent an array" do
-      @opts.array?.should be_false
+    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"]
+      end
     end
   end
 
-  describe "types" do
-    describe ":content" do
-      it "should be recognized" do
-        ROXML::Definition.new(:author).content?.should be_false
-        ROXML::Definition.new(:author, :content).content?.should be_true
-      end
+  describe "Date reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
+    end
 
-      it "should be deprecated"
+    it "should return a time version of the string" do
+      @subject.blocks.first.call("September 3rd, 1970").to_s == "1970-09-03"
     end
 
-    describe "array reference" do
-      it "[] means array of texts" do
-        opts = ROXML::Definition.new(:authors, [])
-        opts.array?.should be_true
-        opts.type.should == :text
+    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"]
       end
+    end
+  end
 
-      it "[:text] means array of texts" do
-        opts = ROXML::Definition.new(:authors, [:text])
-        opts.array?.should be_true
-        opts.type.should == :text
+  it "should unescape xml entities" do
+    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?"]
+  end
+
+  describe "attr name" do
+    context "when ending with '_at'" do
+      context "and without an :as argument" do
+        before(:all) do
+          @subject = ROXML::Definition.new(:time_at)
+        end
+        it_should_behave_like "DateTime reference"
       end
+    end
 
-      it "[:attr] means array of attrs" do
-        opts = ROXML::Definition.new(:authors, [:attr])
-        opts.array?.should be_true
-        opts.type.should == :attr
+    context "when ending with '_on'" do
+      context "and without an :as argument" do
+        before(:all) do
+          @subject = ROXML::Definition.new(:created_on)
+        end
+        it_should_behave_like "Date reference"
       end
+    end
+  end
 
-      it "[Object] means array of objects" do
-        opts = ROXML::Definition.new(:authors, [Hash])
+  describe ":as" do
+    describe "=> []" do
+      it "should means array of texts" do
+        opts = ROXML::Definition.new(:authors, :as => [])
         opts.array?.should be_true
-        opts.type.should == Hash
+        opts.type.should == :text
       end
     end
 
-    describe "{}" do
-      describe "hash with attr key and text val" do
-        before do
-          @opts = ROXML::Definition.new(:attributes, {:key => {:attr => :name},
-                                         :value => :value})
-          @hash_args = {:key => {:attr => 'name'},
-                        :value => {:text => 'value'}}
-        end
-
-        it_should_behave_like "hash options declaration"
+    describe "=> RoxmlClass" do
+      class RoxmlClass
+        include ROXML
       end
 
-      describe "hash with String class for type" do
-        before do
-          @opts = ROXML::Definition.new(:attributes, {:key => {String => 'name'},
-                                         :value => {String => 'value'}})
-          @hash_args = {:key => {:text => 'name'}, :value => {:text => 'value'}}
-        end
-
-        it_should_behave_like "hash options declaration"
+      it "should store type" do
+        opts = ROXML::Definition.new(:name, :as => RoxmlClass)
+        opts.type.should == RoxmlClass
       end
+    end
 
-      describe "hash with attr key and content val" do
-        before do
-          @opts = ROXML::Definition.new(:attributes, {:key => {:attr => :name},
-                                         :value => :content})
-          @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
+    describe "=> NonRoxmlClassWithFromXmlDefined" do
+      class OctalInteger
+        def self.from_xml(val)
+          new(Integer(val.content))
         end
-
-        it_should_behave_like "hash options declaration"
       end
 
-      describe "hash of attrs" do
-        before do
-          @hash_args = {:key => {:attr => 'name'}, :value => {:attr => 'value'}}
-          @opts = ROXML::Definition.new(:attributes, {:attrs => [:name, :value]})
-        end
-
-        it_should_behave_like "hash options declaration"
-
-        describe "with options" do
-          before do
-            @hash_args = {:key => {:attr => 'dt'}, :value => {:attr => 'dd'}}
-            @opts = ROXML::Definition.new(:definitions, {:attrs => [:dt, :dd]},
-                                    :in => 'definitions')
-          end
-
-          it_should_behave_like "hash options declaration"
-
-          it "should not interfere with options" do
-            @opts.wrapper.should == 'definitions'
-          end
-        end
+      it "should accept type" do
+        opts = ROXML::Definition.new(:name, :as => OctalInteger)
+        opts.type.should == OctalInteger
       end
     end
-  end
 
-  describe ":as" do
-    describe "=> :array" do
-      it "should be deprecated"
-    end
-
-    describe "=> []" do
-      it "should means array of texts" do
-        opts = ROXML::Definition.new(:authors, :as => [])
-        opts.array?.should be_true
-        opts.type.should == :text
+    describe "=> NonRoxmlClass" do
+      it "should fail with a warning" do
+        proc { ROXML::Definition.new(:authors, :as => Module) }.should raise_error(ArgumentError)
       end
+    end
 
-      it "should unescape xml entities" do
-        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?"]
+    describe "=> [NonRoxmlClass]" do
+      it "should raise" do
+        proc { ROXML::Definition.new(:authors, :as => [Module]) }.should raise_error(ArgumentError)
       end
     end
 
     describe "=> {}" do
+      describe "hash options declaration", :shared => true do
+        it "should represent a hash" do
+          @opts.hash?.should be_true
+        end
+
+        it "should have hash definition" do
+          {@opts.hash.key.type => @opts.hash.key.name}.should == @hash_args[:key]
+          {@opts.hash.value.type => @opts.hash.value.name}.should == @hash_args[:value]
+        end
+
+        it "should not represent an array" do
+          @opts.array?.should be_false
+        end
+      end
+
       describe "hash with attr key and text val" do
         before do
-          @opts = ROXML::Definition.new(:attributes, :as => {:key => {:attr => :name},
-                                                             :value => :value})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
+                                                             :value => 'value'})
           @hash_args = {:key => {:attr => 'name'},
                         :value => {:text => 'value'}}
         end
@@ -161,8 +148,8 @@ describe ROXML::Definition do
 
       describe "hash with String class for type" do
         before do
-          @opts = ROXML::Definition.new(:attributes, :as => {:key => {String => 'name'},
-                                                             :value => {String => 'value'}})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => 'name',
+                                                             :value => 'value'})
           @hash_args = {:key => {:text => 'name'}, :value => {:text => 'value'}}
         end
 
@@ -171,7 +158,7 @@ describe ROXML::Definition do
 
       describe "hash with attr key and content val" do
         before do
-          @opts = ROXML::Definition.new(:attributes, :as => {:key => {:attr => :name},
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
                                                              :value => :content})
           @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
         end
@@ -179,27 +166,14 @@ describe ROXML::Definition do
         it_should_behave_like "hash options declaration"
       end
 
-      describe "hash of attrs" do
+      describe "hash with names as keys and content vals" do
         before do
-          @hash_args = {:key => {:attr => 'name'}, :value => {:attr => 'value'}}
-          @opts = ROXML::Definition.new(:attributes, :as => {:attrs => [:name, :value]})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => :name,
+                                                             :value => :content})
+          @hash_args = {:key => {:text => '*'}, :value => {:text => '.'}}
         end
 
         it_should_behave_like "hash options declaration"
-
-        describe "with options" do
-          before do
-            @hash_args = {:key => {:attr => 'dt'}, :value => {:attr => 'dd'}}
-            @opts = ROXML::Definition.new(:definitions, :as => {:attrs => [:dt, :dd]},
-                                    :in => 'definitions')
-          end
-
-          it_should_behave_like "hash options declaration"
-
-          it "should not interfere with options" do
-            @opts.wrapper.should == 'definitions'
-          end
-        end
       end
     end
 
@@ -221,8 +195,11 @@ describe ROXML::Definition do
 
       it "should have no blocks without a shorthand" do
         ROXML::Definition.new(:count).blocks.should be_empty
-        ROXML::Definition.new(:count, :as => :bogus).blocks.should be_empty
-        ROXML::Definition.new(:count, :as => :foat).blocks.should be_empty # misspelled
+      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)
       end
 
       describe "block shorthand type declaration", :shared => true do
@@ -236,7 +213,11 @@ describe ROXML::Definition do
         end
       end
 
-      describe ":as => Integer", :shared => true do
+      describe "Integer" do
+        before do
+          @definition = ROXML::Definition.new(:intvalue, :as => Integer)
+        end
+
         it_should_behave_like "block shorthand type declaration"
 
         it "should translate text to integers" do
@@ -258,25 +239,11 @@ describe ROXML::Definition do
         end
       end
 
-      describe "Integer" do
-        before do
-          @definition = ROXML::Definition.new(:intvalue, :as => Integer)
-        end
-
-        it_should_behave_like ":as => Integer"
-      end
-
-      describe ":integer" do
+      describe "Float" do
         before do
-          @definition = ROXML::Definition.new(:intvalue, :as => :integer)
+          @definition = ROXML::Definition.new(:floatvalue, :as => Float)
         end
 
-        it_should_behave_like ":as => Integer"
-
-        it "should be deprecated"
-      end
-
-      describe ":as => Float", :shared => true do
         it_should_behave_like "block shorthand type declaration"
 
         it "should translate text to float" do
@@ -296,24 +263,6 @@ describe ROXML::Definition do
         end
       end
 
-      describe ":float" do
-        before do
-          @definition = ROXML::Definition.new(:floatvalue, :as => :float)
-        end
-
-        it_should_behave_like ":as => Float"
-
-        it "should be deprecated"
-      end
-
-      describe "Float" do
-        before do
-          @definition = ROXML::Definition.new(:floatvalue, :as => Float)
-        end
-
-        it_should_behave_like ":as => Float"
-      end
-
       describe "BigDecimal" do
         before do
           @definition = ROXML::Definition.new(:decimalvalue, :as => BigDecimal)
@@ -408,35 +357,17 @@ describe ROXML::Definition do
       end
 
       describe "Date" do
-        it "should return nil on empty string" do
-          ROXML::Definition.new(:floatvalue, :as => Date).blocks.first.call("  ").should be_nil
-        end
-
-        it "should return a time version of the string" do
-          ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call("September 3rd, 1970").to_s == "1970-09-03"
-        end
-
-        context "when passed an array of values" do
-          it "should timify all of them" do
-            ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s).should == ["1970-09-03", "1776-07-04"]
-          end
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => Date)
         end
+        it_should_behave_like "Date reference"
       end
 
       describe "DateTime" do
-        it "should return nil on empty string" do
-          ROXML::Definition.new(:floatvalue, :as => DateTime).blocks.first.call("  ").should be_nil
-        end
-
-        it "should return a time version of the string" do
-          ROXML::Definition.new(:datevalue, :as => DateTime).blocks.first.call("12:05pm, September 3rd, 1970").to_s == "1970-09-03T12:05:00+00:00"
-        end
-
-        context "when passed an array of values" do
-          it "should timify all of them" do
-            ROXML::Definition.new(:datevalue, :as => DateTime).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"]
-          end
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => DateTime)
         end
+        it_should_behave_like "DateTime reference"
       end
 
       it "should prohibit multiple shorthands" do
@@ -481,19 +412,11 @@ describe ROXML::Definition do
       end
 
       it_should_behave_like "attribute reference"
-
-      describe "and with :attr" do
-        before do
-          @opts = ROXML::Definition.new(:attr_name, :attr, :from => '@attr_name')
-        end
-
-        it_should_behave_like "attribute reference"
-        it "should be deprecated"
-      end
     end
 
     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
       end
 
@@ -521,13 +444,13 @@ describe ROXML::Definition do
 
     describe "boolean option", :shared => true do
       it "should be recognized" do
-        ROXML::Definition.new(:author, :content, @option => true).respond_to?(:"#{@option}?")
-        ROXML::Definition.new(:author, :content, @option => true).send(:"#{@option}?").should be_true
-        ROXML::Definition.new(:author, :content, @option => false).send(:"#{@option}?").should be_false
+        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
       end
 
       it "should default to false" do
-        ROXML::Definition.new(:author, :content).send(:"#{@option}?").should be_false
+        ROXML::Definition.new(:author, :from => :content).send(:"#{@option}?").should be_false
       end
     end
 
@@ -539,8 +462,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, :content, :required => true, :else => 'Johnny') }.should raise_error(ArgumentError)
-        proc { ROXML::Definition.new(:author, :content, :required => false, :else => 'Johnny') }.should_not raise_error
+        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
       end
     end