xmlparsable 1.4.2 → 1.5.0

data/lib/xmlparsable/elements/array.rb

@@ -0,0 +1,36 @@
+module XmlParsable
+  module Elements
+
+    class ArrayElement < AbstractElement
+      attr_reader :name
+
+      class Array < ::Array
+        attr_reader :xmlattrs
+      end
+
+      def initialize(name, attributes, parent, arguments)
+        @name, @parent, @elements = name, parent, Array.new
+
+        @item_name = arguments[:item_name].to_s
+        @item_type = arguments[:class]
+        @item_args = arguments[:item]
+        @elements.instance_variable_set(:@xmlattrs, attributes)
+      end
+
+      def open(name, attributes)
+        if name == @item_name
+          @item_type.parsable.new(name, attributes, self, @item_args)
+        end
+      end
+
+      def close(element, value)
+        @elements << value
+      end
+
+      def finalize
+        @parent.close(self, @elements)
+      end
+    end
+
+  end
+end

data/lib/xmlparsable/elements/record.rb

@@ -10,10 +10,12 @@ module XmlParsable
         @target     = target
         @parsers    = parsers
         @elements   = Hash.new
+        @target.instance_variable_set(:@xmlattrs, @attributes)
       end
 
       def open(name, attributes)
         parser, *arguments = @parsers[name]
+
         if parser
           parser.new(name, attributes, self, *arguments)
         end
@@ -21,15 +23,16 @@ module XmlParsable
 
       def close(element, value)
         parser, *arguments = @parsers[element.name]
+
         if arguments.include?(:repeated)
-          (@elements[element.name] ||= []) << value
+          (@elements[element.name.to_sym] ||= []) << value
         else
-          @elements[element.name] = value
+          @elements[element.name.to_sym] = value
         end
       end
 
       def finalize
-        @elements.each{|name, value| @target.instance_variable_set("@#{name}", value) }
+        @target.instance_variable_set(:@xmlelems, @elements)
         @parent.close(self, @target) if @parent
       end
 

data/lib/xmlparsable/elements.rb

@@ -2,7 +2,7 @@ module XmlParsable
   module Elements
     autoload :AbstractElement,  "xmlparsable/elements/abstract"
     autoload :DateElement,      "xmlparsable/elements/date"
-    autoload :ListElement,      "xmlparsable/elements/list"
+    autoload :ArrayElement,     "xmlparsable/elements/array"
     autoload :NumericElement,   "xmlparsable/elements/numeric"
     autoload :RecordElement,    "xmlparsable/elements/record"
     autoload :StringElement,    "xmlparsable/elements/string"

data/lib/xmlparsable.rb

@@ -20,50 +20,58 @@ module XmlParsable
   end
 
   module ClassMethods
-    def element(name, *arguments)
-      element ||= arguments.pop.delete(:class) if arguments.last.is_a?(Hash)
-      element ||= arguments.shift if arguments.first.is_a?(Class)
-      element ||= Elements::StringElement
 
-      # Look up the inheritance hierarchy to map element name to parser
-      parent = superclass < XmlParsable ?
-        superclass.instance_variable_get(:@parsers) : Hash.new
+    # element :name, StringElement, {options...}
+    # element :name, {:class => StringElement, options...}
+    def element(elem_name, *extras)
+      arguments   = extras.pop if extras.last.is_a?(Hash)
+      arguments ||= Hash.new
 
-      @parsers ||= Hash.new{|h,k| parent[k] }
-      @parsers[name.to_s] = [element.parsable, *arguments]
-
-      define_method(name) { instance_variable_get("@#{name}") }
-    end
-
-    def repeated(name, *arguments)
-      element ||= arguments.pop.delete(:class) if arguments.last.is_a?(Hash)
-      element ||= arguments.shift if arguments.first.is_a?(Class)
-      element ||= Elements::StringElement
+      elem_type   = extras.shift if extras.first.is_a?(Class)
+      elem_type ||= arguments.delete(:class)
+      elem_type ||= Elements::StringElement
+      raise ArgumentError, "extra arguments" unless extras.empty?
 
       # Look up the inheritance hierarchy to map element name to parser
       parent = superclass < XmlParsable ?
         superclass.instance_variable_get(:@parsers) : Hash.new
 
       @parsers ||= Hash.new{|h,k| parent[k] }
-      @parsers[name.to_s.singularize] = [element.parsable, *arguments.push(:repeated)]
+      @parsers[elem_name.to_s] = [elem_type.parsable, arguments]
+
+      # Define accessor method (or don't, see if I care!)
+      attr_name = arguments.fetch(:accessor, elem_name)
 
-      define_method(name) { instance_variable_get("@#{name.to_s.singularize}") }
+      if attr_name and not method_defined?(attr_name)
+        define_method(attr_name) { instance_variable_get(:@xmlelems)[elem_name] }
+      end
     end
 
-    def collection(name, *arguments)
-      item ||= arguments.pop.delete(:class) if arguments.last.is_a?(Hash)
-      item ||= arguments.shift if arguments.first.is_a?(Class)
-      item ||= Elements::StringElement
+    # collection :hive, BeeElement, {:item_name => :bee, array-options..., :item => {item-options...}}
+    # collection :hive, :bee, BeeElement, {array-options..., :item => {item-options...}}
+    # collection :hive, {array-options..., :item => {:class => BeeElement, item-options...}}
+    def collection(elem_name, *extras)
+      arguments   = extras.pop if extras.last.is_a?(Hash)
+      arguments ||= Hash.new
+
+      arguments[:item] ||= Hash.new
+      arguments[:item_name] ||= extras.shift unless extras.first.is_a?(Class)
+      arguments[:item_name] ||= elem_name.to_s.singularize
+      arguments[:class] ||= extras.shift if extras.first.is_a?(Class)
+      arguments[:class] ||= Elements::StringElement
+      raise ArgumentError, "extra arguments" unless extras.empty?
+
+      element(elem_name, Elements::ArrayElement, arguments)
+    end
 
-      if arguments.empty?
-        single = name.to_s.singularize
-        plural = name.to_s.pluralize
+    def repeated(elem_name, *extras)
+      if extras.last.is_a?(Hash)
+        extras.last[:repeated] = true
+        element(elem_name, *extras)
       else
-        plural = name
-        single = arguments.shift
+        extras.push(Hash[:repeated => true])
+        element(elem_name, *extras)
       end
-
-      element(plural, Elements::ListElement, single, item)
     end
 
     def parse(input)

data/spec/examples/accessors.example

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe XmlParsable, "accessors" do
+
+  let(:input) do
+    <<-XML
+      <root lang="en" charset="utf-8">
+        <size>500</size>
+        <wise>none</wise>
+        <secret>Ovaltine</secret>
+      </root>
+    XML
+  end
+
+  context "default" do
+    let(:parser) do
+      Class.new do
+        class Inner
+          attr_reader :xmlattrs
+          attr_reader :xmlelems
+
+          include XmlParsable
+          element :size
+          element :wise
+        end
+
+        include XmlParsable
+        element :root, Inner
+      end
+    end
+
+    it "stores attributes in `xmlattrs`" do
+      xml = parser.parse(input)
+      xml.root.xmlattrs.should == Hash["lang" => "en", "charset" => "utf-8"]
+    end
+
+    it "stores elements in `xmlelems`" do
+      xml = parser.parse(input)
+      xml.root.xmlelems[:size] = "500"
+      xml.root.xmlelems[:wise] = "none"
+    end
+
+    it "creates accessors for elements" do
+      xml = parser.parse(input)
+      xml.root.xmlelems[:size].should eql(xml.root.size)
+      xml.root.xmlelems[:wise].should eql(xml.root.wise)
+    end
+  end
+
+  context "overridden" do
+    let(:parser) do
+      Class.new do
+        class Inner
+          attr_reader :xmlelems
+
+          def size
+            "junk junk"
+          end
+
+          include XmlParsable
+          element :size
+          element :wise, accessor: :wisdom
+          element :secret, accessor: false
+        end
+
+        include XmlParsable
+        element :root, Inner
+      end
+    end
+
+    it "stores elements in `xmlelems`" do
+      xml = parser.parse(input)
+      xml.root.xmlelems[:size] == "500"
+      xml.root.xmlelems[:wise] == "none"
+      xml.root.xmlelems[:secret] == "Ovaltine"
+    end
+
+    it "doesn't create accessors for hidden elements" do
+      xml = parser.parse(input)
+      xml.root.should_not respond_to(:secret)
+    end
+
+    it "creates accessors for renamed elements" do
+      xml = parser.parse(input)
+      xml.root.xmlelems[:wise].should eql(xml.root.wisdom)
+    end
+  end
+
+end

data/spec/examples/elements/array.example

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::ArrayElement do
+
+  describe "declaration" do
+
+    it "fully specified" do
+      parser  = Class.new do
+        sheep = Class.new do
+          include XmlParsable
+          element :name
+          element :bahh
+        end
+
+        include XmlParsable
+        collection :flock, :sheep, sheep
+      end
+
+      xml = parser.parse(<<-XML)
+        <flock>
+          <sheep><bahh>H*</bahh></sheep>
+          <sheep><bahh>HH</bahh></sheep>
+          <sheep><bahh>*H</bahh></sheep>
+        </flock>
+      XML
+
+      xml.flock[0].bahh.should == "H*"
+      xml.flock[1].bahh.should == "HH"
+      xml.flock[2].bahh.should == "*H"
+    end
+
+    specify "default child type is StringElement" do
+      parser = Class.new do
+        include XmlParsable
+        collection :contacts, :name
+      end
+
+      xml = parser.parse("<contacts><name>Green</name><name>White</name></contacts>")
+      xml.contacts.should == %w(Green White)
+    end
+
+    specify "default child name is singular collection name" do
+      parser = Class.new do
+        include XmlParsable
+        collection :bees, XmlParsable::Elements::NumericElement
+      end
+      
+      xml = parser.parse("<bees><bee>1000</bee><bee>1001</bee></bees>")
+      xml.bees.should == [1000, 1001]
+    end
+  end
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        collection :list, :item
+      end
+    end
+
+    it "parses empty list into an empty Array" do
+      input    = "<list/>"
+      expected = []
+
+      parser.parse(input).list.should == expected
+    end
+
+    it "parses attributes" do
+      input    = '<list thang="yarn" milk="yawn"/>'
+      expected = Hash["thang" => "yarn", "milk" => "yawn"]
+
+      parser.parse(input).list.xmlattrs.should == expected
+    end
+
+    it "parses non-empty list into an Array" do
+      input    = "<list><item>a</item><item>b</item></list>"
+      expected = ["a", "b"]
+
+      parser.parse(input).list.should == expected
+    end
+
+    it "ignores non-matching children" do
+      input    = "<list><fail/><item/><boat/><item/><item/></list>"
+      expected = ["", "", ""]
+
+      parser.parse(input).list.should == expected
+    end
+
+    it "ignores comments" do
+      input    = "<list><!-- <item>x</item> --><item><!-- y --></item></list>"
+      expected = [""]
+
+      parser.parse(input).list.should == expected
+    end
+
+    it "ignores whitespace between children" do
+      input = <<-XML
+        <list>
+          <item>a</item>
+          <item>b</item>
+          <item>c</item>
+        </list>
+      XML
+
+      expected = ["a", "b", "c"]
+      parser.parse(input).list.should == expected
+    end
+  end
+
+end

data/spec/examples/elements/date.example

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::DateElement do
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        element :date, XmlParsable::Elements::DateElement
+      end
+    end
+
+    it "parses date into a ruby Date" do
+      expected = Date.today
+      input    = "<date>#{expected}</date>"
+      parser.parse(input).date.should == expected
+    end
+
+    it "parses missing date as nil" do
+      expected = nil
+      input    = "<date><!-- nope --></date>"
+      parser.parse(input).date.should == expected
+    end
+
+    it "ignores children" do
+      expected = nil
+      input    = "<date><x>2010-01-01</x></date>"
+      parser.parse(input).date.should == expected
+    end
+
+    it "ignores comments" do
+      expected = Date.today
+      input    = "<date>#{expected} <!-- that's today --></date>"
+      parser.parse(input).date.should == expected
+    end
+
+    it "ignores whitespace" do
+      expected = Date.today
+      input    = "<date>\n  #{Date.today}\n  </date>"
+      parser.parse(input).date.should == expected
+    end
+  end
+
+end

data/spec/examples/elements/numeric.example

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::StringElement do
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        element :number, XmlParsable::Elements::NumericElement
+      end
+    end
+
+    it "parses integers" do
+      expected = rand(1_000)
+      input    = "<number>#{expected}</number>"
+      parser.parse(input).number.should == expected
+    end
+
+    it "parses hexadecimal" do
+      expected = rand(1_000)
+      input    = "<number>0x#{expected.to_s(16)}</number>"
+      parser.parse(input).number.should == expected
+    end
+
+    it "parser octal" do
+      expected = rand(1_000)
+      input    = "<number>0#{expected.to_s(8)}</number>"
+      parser.parse(input).number.should == expected
+    end
+
+    it "parses binary" do
+      expected = rand(1_000)
+      input    = "<number>0b#{expected.to_s(2)}</number>"
+      parser.parse(input).number.should == expected
+    end
+
+    it "parses rationals" do
+      expected = rand(1_000) + rand
+      input    = "<number>#{expected}</number>"
+      parser.parse(input).number.should == BigDecimal(expected.to_s)
+    end
+
+    it "ignores comments" do
+      input = "<time><!-- 65432 --></time>"
+      parser.parse(input).number.should be_nil
+    end
+
+    it "ignores children" do
+      input = "<time><b>#{rand}</b></time>"
+      parser.parse(input).number.should be_nil
+    end
+
+    it "ignores whitespace" do
+      expected = rand(1_000)
+      input    = "<number>   #{expected}    </number>"
+      parser.parse(input).number.should == expected
+    end
+  end
+
+end

data/spec/examples/elements/record.example

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::RecordElement do
+
+  let(:parser) do
+    Class.new do
+      include XmlParsable
+
+      element :date,    XmlParsable::Elements::DateElement
+      element :string,  XmlParsable::Elements::StringElement
+      element :text,    XmlParsable::Elements::TextElement
+      element :time,    XmlParsable::Elements::TimeElement
+      element :xml,     XmlParsable::Elements::XmlElement
+      element :number,  XmlParsable::Elements::NumericElement
+      element :record,  self
+
+      collection :kids, self
+      collection :list, :item
+    end
+  end
+
+  describe "parser" do
+    it "parses multiple elements" do
+      time = Time.now
+      date = Date.today
+
+      xml = parser.parse <<-XML
+        <record>
+          <date>#{date}</date>
+          <time>#{time}</time>
+          <list>
+            <item>a</item>
+            <item>b</item>
+            <item>c</item>
+          </list>
+          <string>xyz</string>
+          <number>888</number>
+          <text>
+            <ul>
+              <li>vim</li>
+              <li>emacs</li>
+              <li>ctags</li>
+              <li>lint</li>
+              <li>gdb</li>
+            </ul>
+          </text>
+        </record>
+      XML
+
+      xml.record.list.should       == ["a","b","c"]
+      xml.record.string.should     == "xyz"
+      xml.record.number.should     == 888
+      xml.record.date.should       == date
+      xml.record.time.to_i.should  == time.to_i
+      xml.record.text.strip.should == <<-DOC.strip
+              vim
+              emacs
+              ctags
+              lint
+              gdb
+      DOC
+    end
+
+    it "parses recursive records" do
+      xml = parser.parse(<<-XML)
+        <record>
+          <string>root</string>
+          <record>
+            <string>child</string>
+            <record>
+              <string>grand child</string>
+            </record>
+          </record>
+        </record>
+      XML
+
+      xml.string.should be_nil
+      xml.record.string.should == "root"
+      xml.record.record.string.should == "child"
+      xml.record.record.record.string.should == "grand child"
+    end
+  end
+
+end

data/spec/examples/elements/string.example

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::StringElement do
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        element :string, XmlParsable::Elements::StringElement
+      end
+    end
+
+    it "parses empty string" do
+      expected = ""
+      input    = "<string></string>"
+      parser.parse(input).string.should == expected
+    end
+
+    it "parses non-empty string" do
+      expected = "lo and behold"
+      input    = "<string>lo and behold</string>"
+      parser.parse(input).string.should == expected
+    end
+
+    it "ignores comments" do
+      expected = "hi"
+      input    = "<string>hi<!-- secret message --></string>"
+      parser.parse(input).string.should == expected
+    end
+
+    it "ignores children" do
+      expected = ", , plain"
+      input    = "<string><b>bold</b>, <i>italic</i>, plain</string>"
+      parser.parse(input).string.should == expected
+    end
+
+    it "does not ignore whitespace" do
+      expected = "   foob  ar"
+      input    = "<string>   foob  ar</string>"
+      parser.parse(input).string.should == expected
+    end
+  end
+
+end

data/spec/examples/elements/text.example

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::StringElement do
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        element :text, XmlParsable::Elements::TextElement
+      end
+    end
+
+    it "parses text" do
+      expected = "lo and behold"
+      input    = "<text>lo and behold</text>"
+      parser.parse(input).text.should == expected
+    end
+
+    it "ignores comments" do
+      expected = "lo  behold"
+      input    = "<text>lo <!--and--> behold</text>"
+      parser.parse(input).text.should == expected
+    end
+
+    it "strips away markup" do
+      expected = "lo and behold"
+      input    = "<text>lo <span class='x'><i>and</i> behold</span></text>"
+      parser.parse(input).text.should == expected
+    end
+
+    it "does not ignore whitespace" do
+      expected = "   foob  ar"
+      input    = "<text>   foob  ar</text>"
+      parser.parse(input).text.should == expected
+    end
+  end
+
+end

data/spec/examples/elements/time.example

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe XmlParsable::Elements::StringElement do
+
+  describe "parser" do
+    let(:parser) do
+      Class.new do
+        include XmlParsable
+        element :time, XmlParsable::Elements::TimeElement
+      end
+    end
+
+    it "parses time" do
+      expected = Time.now
+      input    = "<time>#{expected}</time>"
+      parser.parse(input).time.to_i.should == expected.to_i
+    end
+
+    it "ignores comments" do
+      input = "<time><!-- #{Time.now} --></time>"
+      parser.parse(input).time.should be_nil
+    end
+
+    it "ignores children" do
+      input = "<time><b>#{Time.now}</b></time>"
+      parser.parse(input).time.should be_nil
+    end
+
+    it "ignores whitespace" do
+      expected = Time.now
+      input    = "<time>   #{expected}    </time>"
+      parser.parse(input).time.to_i.should == expected.to_i
+    end
+  end
+
+end

data/spec/examples/elements/xml.example

@@ -0,0 +1 @@
+require "spec_helper"

data/spec/examples/inheritance.example

@@ -1,154 +1,130 @@
 require "spec_helper"
 
-describe XmlParsable::Elements::RecordElement, "inheritance" do
+describe XmlParsable, "inheritance" do
+
+  let(:input) do
+    <<-XML
+      <root>
+        <!-- This is parsed as a Date, Integer, or String -->
+        <id>20120531</id>
+        <inherited>11235</inherited>
+
+        <a>some a-data</a>
+        <b>some b-data</b>
+        <c>
+          <id>IDENTIFIER</id>
+          <inherited></inherited>
+        </c>
+      </root>
+    XML
+  end
 
-  class BaseRecord
-    include XmlParsable
+  let(:common) do
+    Class.new do
+      attr_reader :xmlelems
 
-    class Record
       include XmlParsable
-      element :id, StringElement
-      element :size, NumericElement
+      element :id
+      element :inherited, XmlParsable::Elements::NumericElement
     end
-
-    element :record, Record
   end
 
-  class FirstRecord
-    include XmlParsable
+  let(:base) do
+    root = common
+    Class.new do
+      include XmlParsable
+      element :root, root
+    end
+  end
 
-    class Record < BaseRecord::Record
-      element :id, TimeElement
-      element :name, StringElement
+  # Override the parent's id element
+  let(:a) do
+    parent = common
+    Class.new do
+      inner = Class.new(parent) do
+        element :id, XmlParsable::Elements::TimeElement
+        element :a
+      end
+      include XmlParsable
+      element :root, inner
     end
+  end
 
-    element :record, Record
+  # Override the parent's id element
+  let(:b) do
+    parent = common
+    Class.new do
+      inner = Class.new(parent) do
+        element :id, XmlParsable::Elements::NumericElement
+        element :b
+      end
+      include XmlParsable
+      element :root, inner
+    end
   end
 
-  class SecondRecord
-    include XmlParsable
+  let(:c) do
+    parent = common
 
-    class Record < BaseRecord::Record
-      element :id, NumericElement
-    end
+    Class.new do
+      inner = Class.new(parent) do
+        element :c, self
+      end
 
-    element :record, Record
+      include XmlParsable
+      element :root, inner
+    end
   end
 
-  class ThirdRecord < BaseRecord
-    include XmlParsable
+  describe "base parser" do
+    it "is separate from derived parsers" do
+      xml = base.parse(input)
+      xml.root.id.should == "20120531"
+      xml.root.inherited.should == 11235
 
-    class Record < BaseRecord::Record
-      element :parent, Record
-    end
+      xml.root.xmlelems.should_not have_key(:a)
+      xml.root.xmlelems.should_not have_key(:b)
+      xml.root.xmlelems.should_not have_key(:c)
 
-    element :record, Record
+      xml.root.should_not respond_to(:a)
+      xml.root.should_not respond_to(:b)
+      xml.root.should_not respond_to(:c)
+    end
   end
 
-  describe "parent" do
-    subject { BaseRecord::Record.new }
-    specify { should respond_to(:id) }
-    specify { should respond_to(:size) }
-    specify { should_not respond_to(:name) }
-    specify { should_not respond_to(:parent) }
-
-    it "parses attributes" do
-      data = BaseRecord.parse(<<-XML.strip)
-        <record>
-          <id>0xCAFE</id>
-          <size>0xFE</size>
-        </record>
-      XML
-
-      data.record.should be_a(BaseRecord::Record)
-      data.record.id.should == "0xCAFE"
-      data.record.size.should == 0xFE
+  describe "derived parsers" do
+    it "inherit elements from base parser" do
+      a.parse(input).root.inherited.should == 11235
+      b.parse(input).root.inherited.should == 11235
+      c.parse(input).root.inherited.should == 11235
     end
-  end
 
-  describe "first" do
-    subject { FirstRecord::Record.new }
-    specify { should respond_to(:id) }
-    specify { should respond_to(:size) }
-    specify { should respond_to(:name) }
-    specify { should_not respond_to(:parent) }
-
-    it "parses attributes" do
-      data = FirstRecord.parse(<<-XML.strip)
-        <record>
-          <id>20120530T154500</id>
-          <size>0xCA7</size>
-          <name>Sabji</name>
-        </record>
-      XML
-
-      data.record.should be_a(FirstRecord::Record)
-      data.record.id.should == Time.local(2012, 5, 30, 15, 45)
-      data.record.size.should == 0xCA7
-      data.record.name.should == "Sabji"
+    it "can specify additional elements" do
+      a.parse(input).root.a.should == "some a-data"
+      b.parse(input).root.b.should == "some b-data"
+
+      c.parse(input).root.c.should_not be_nil
+      c.parse(input).root.c.id.should == "IDENTIFIER"
+      c.parse(input).root.c.inherited.should be_nil
     end
-  end
 
-  describe "second" do
-    subject { SecondRecord::Record.new }
-    specify { should respond_to(:id) }
-    specify { should respond_to(:size) }
-    specify { should_not respond_to(:name) }
-    specify { should_not respond_to(:parent) }
-
-    it "parses attributes" do
-      data = SecondRecord.parse(<<-XML)
-        <record>
-          <id>0.314</id>
-          <size>3.014</size>
-        </record>
-      XML
-
-      data.record.should be_a(SecondRecord::Record)
-      data.record.id.should == 0.314
-      data.record.size.should == 3.014
+    it "can override an inherited element" do
+      a.parse(input).root.id.should be_a(Time)
+      b.parse(input).root.id.should be_a(Integer)
     end
-  end
 
-  describe "third" do
-    subject { ThirdRecord::Record.new }
-    specify { should respond_to(:id) }
-    specify { should respond_to(:size) }
-    specify { should_not respond_to(:name) }
-    specify { should respond_to(:parent) }
-
-    it "parses attributes" do
-      data = ThirdRecord.parse(<<-XML)
-        <record>
-          <id>X039-P99-THX1138-U</id>
-          <size>11235813</size>
-          <parent>
-            <id>X039-P99-THX1138</id>
-            <size>112358</size>
-            <parent>
-              <id>X039-P99</id>
-              <size>11235</size>
-              <parent>
-                <id>X039</id>
-                <size>1123</size>
-              </parent>
-            </parent>
-          </parent>
-        </record>
-      XML
-
-      data.record.should be_a(ThirdRecord::Record)
-      data.record.id.should == "X039-P99-THX1138-U"
-      data.record.size.should == 11235813
-
-      data.record.parent.id.should == "X039-P99-THX1138"
-      data.record.parent.size.should == 112358
-
-      data.record.parent.parent.id.should == "X039-P99"
-      data.record.parent.parent.size.should == 11235
-
-      data.record.parent.parent.parent.id.should == "X039"
-      data.record.parent.parent.parent.size.should == 1123
+    specify "are independent from one another" do
+      xml = a.parse(input).root
+      xml.should_not respond_to(:b)
+      xml.should_not respond_to(:c)
+
+      xml = b.parse(input).root
+      xml.should_not respond_to(:a)
+      xml.should_not respond_to(:c)
+
+      xml = c.parse(input).root
+      xml.should_not respond_to(:a)
+      xml.should_not respond_to(:b)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xmlparsable
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -36,8 +36,8 @@ files:
 - README.md
 - Rakefile
 - lib/xmlparsable/elements/abstract.rb
+- lib/xmlparsable/elements/array.rb
 - lib/xmlparsable/elements/date.rb
-- lib/xmlparsable/elements/list.rb
 - lib/xmlparsable/elements/numeric.rb
 - lib/xmlparsable/elements/record.rb
 - lib/xmlparsable/elements/string.rb
@@ -47,8 +47,16 @@ files:
 - lib/xmlparsable/elements.rb
 - lib/xmlparsable/parser.rb
 - lib/xmlparsable.rb
+- spec/examples/accessors.example
+- spec/examples/elements/array.example
+- spec/examples/elements/date.example
+- spec/examples/elements/numeric.example
+- spec/examples/elements/record.example
+- spec/examples/elements/string.example
+- spec/examples/elements/text.example
+- spec/examples/elements/time.example
+- spec/examples/elements/xml.example
 - spec/examples/inheritance.example
-- spec/examples/record.example
 - spec/spec_helper.rb
 homepage: https://github.com/kputnam/xmlparsable
 licenses: []
@@ -75,5 +83,13 @@ signing_key:
 specification_version: 3
 summary: Simple declarative XML parsing
 test_files:
+- spec/examples/accessors.example
+- spec/examples/elements/array.example
+- spec/examples/elements/date.example
+- spec/examples/elements/numeric.example
+- spec/examples/elements/record.example
+- spec/examples/elements/string.example
+- spec/examples/elements/text.example
+- spec/examples/elements/time.example
+- spec/examples/elements/xml.example
 - spec/examples/inheritance.example
-- spec/examples/record.example

data/lib/xmlparsable/elements/list.rb

@@ -1,31 +0,0 @@
-module XmlParsable
-  module Elements
-
-    class ListElement < AbstractElement
-      attr_reader :name
-
-      def initialize(name, attributes, parent, *arguments)
-        @name, @parent, @elements = name, parent, []
-
-        @cname   = arguments.shift.to_s
-        @cparser = arguments.shift
-        @cargs   = arguments
-      end
-
-      def open(name, attributes)
-        if name == @cname
-          @cparser.parsable.new(name, attributes, self, *@cargs)
-        end
-      end
-
-      def close(element, value)
-        @elements << value
-      end
-
-      def finalize
-        @parent.close(self, @elements)
-      end
-    end
-
-  end
-end

data/spec/examples/record.example

@@ -1,260 +0,0 @@
-require "spec_helper"
-
-describe XmlParsable::Elements::RecordElement do
-
-  class Record
-    include XmlParsable
-
-    element :date,    DateElement
-    element :string,  StringElement
-    element :text,    TextElement
-    element :time,    TimeElement
-    element :xml,     XmlElement
-    element :number,  NumericElement
-    element :record,  self
-
-    collection :kids, self
-    collection :list, :item
-  end
-
-  describe "date" do
-    it "parses date into a ruby Date" do
-      Record.parse("<date>#{Date.today}</date>").date.should == Date.today
-    end
-
-    it "parses missing date as nil" do
-      Record.parse("<date><!-- nope --></date>").date.should == nil
-    end
-
-    it "ignores children" do
-      Record.parse("<date><x>2010-01-01</x></date>").date.should == nil
-    end
-
-    it "ignores comments" do
-      Record.parse("<date>#{Date.today} <!-- that's today --></date>").date.should == Date.today
-    end
-
-    it "ignores whitespace" do
-      Record.parse("<date>\n  #{Date.today}\n  </date>").date.should == Date.today
-    end
-  end
-
-  describe "list of strings" do
-    it "parses empty list into an empty Array" do
-      Record.parse("<list/>").list.should == []
-    end
-
-    it "parses non-empty list into an Array" do
-      Record.parse("<list><item>a</item><item>b</item></list>").list.should == ["a", "b"]
-    end
-
-    it "ignores non-matching children" do
-      Record.parse("<list><fail/><item/><boat/><item/><item/></list>").list.should == ["", "", ""]
-    end
-
-    it "ignores comments" do
-      Record.parse("<list><!-- <item>x</item> --><item><!-- y --></item></list>").list.should == [""]
-    end
-
-    it "ignores whitespace between children" do
-      Record.parse(<<-XML).list.should == ["a", "b", "c"]
-        <list>
-          <item>a</item>
-          <item>b</item>
-          <item>c</item>
-        </list>
-      XML
-    end
-  end
-
-  describe "list of records" do
-    it "parses empty list into an empty Array" do
-      Record.parse("<kids/>").kids.should == []
-    end
-
-    it "parses non-empty list into an array" do
-      x = Record.parse(<<-XML)
-        <kids>
-          <kid><text>first</text></kid>
-          <kid><text>second</text></kid>
-          <kid><text>third</text></kid>
-        </kids>
-      XML
-
-      x.kids.should have(3).items
-      x.kids[0].text.should == "first"
-      x.kids[1].text.should == "second"
-      x.kids[2].text.should == "third"
-    end
-  end
-
-  describe "string" do
-    it "parses empty string" do
-      Record.parse("<string></string>").string.should == ""
-    end
-
-    it "parses non-empty string" do
-      Record.parse("<string>lo and behold</string>").string.should == "lo and behold"
-    end
-
-    it "ignores comments" do
-      Record.parse("<string>hi<!-- secret message --></string>").string.should == "hi"
-    end
-
-    it "ignores children" do
-      Record.parse("<string><b>bold</b>, <i>italic</i>, plain</string>").string.should == ", , plain"
-    end
-
-    it "does not ignore whitespace" do
-      Record.parse("<string>   foob  ar</string>").string.should == "   foob  ar"
-    end
-  end
-
-  describe "text" do
-    it "parses text" do
-      Record.parse("<text>lo and behold</text>").text.should == "lo and behold"
-    end
-
-    it "ignores comments" do
-      Record.parse("<text>lo <!--and--> behold</text>").text.should == "lo  behold"
-    end
-
-    it "strips away markup" do
-      Record.parse("<text>lo <span class='x'><i>and</i> behold</span></text>").text.should == "lo and behold"
-    end
-
-    it "does not ignore whitespace" do
-      Record.parse("<text>   foob  ar</text>").text.should == "   foob  ar"
-    end
-  end
-
-  describe "time" do
-    it "parses time" do
-      time = Time.now
-      Record.parse("<time>#{time}</time>").time.to_i.should == time.to_i
-    end
-
-    it "ignores comments" do
-      Record.parse("<time><!-- #{Time.now} --></time>").time.should be_nil
-    end
-
-    it "ignores children" do
-      Record.parse("<time><b>#{Time.now}</b></time>").time.should be_nil
-    end
-
-    it "ignores whitespace" do
-      time = Time.now
-      Record.parse("<time>   #{time}    </time>").time.to_i.should == time.to_i
-    end
-  end
-
-  describe "number" do
-    it "parses integers" do
-      number = rand(1_000)
-      Record.parse("<number>#{number}</number>").number.should == number
-    end
-
-    it "parses rationals" do
-      number = rand(1_000) + rand
-      Record.parse("<number>#{number}</number>").number.should == BigDecimal(number.to_s)
-    end
-
-    it "ignores comments" do
-      Record.parse("<time><!-- 65432 --></time>").number.should be_nil
-    end
-
-    it "ignores children" do
-      Record.parse("<time><b>#{rand}</b></time>").number.should be_nil
-    end
-
-    it "ignores whitespace" do
-      number = rand(1_000)
-      Record.parse("<number>   #{number}    </number>").number.should == number
-    end
-  end
-
-  describe "record" do
-    it "parses date" do
-      x = Record.parse("<record><date>#{Date.today}</date></record>")
-      x.date.should be_nil
-      x.record.date.should == Date.today
-    end
-
-    it "parses list" do
-      x = Record.parse("<record><list/></record>")
-      x.list.should be_nil
-      x.record.list.should == []
-    end
-
-    it "parses string" do
-      x = Record.parse("<record><string>abc</string></record>")
-      x.string.should be_nil
-      x.record.string.should == "abc"
-    end
-
-    it "parses text" do
-      x = Record.parse("<record><text><b>big</b><i>little</i></text></record>")
-      x.text.should be_nil
-      x.record.text.should == "biglittle"
-    end
-
-    it "parses time" do
-      time = Time.now
-      Record.parse("<record><time>#{time}</time></record>").record.time.to_i.should == time.to_i
-    end
-
-    it "parses number" do
-      number = rand(1_000) + rand
-      Record.parse("<record><number>#{number}</number></record>").record.number.should == BigDecimal(number.to_s)
-    end
-
-    it "parses multiple elements" do
-      time = Time.now
-      x = Record.parse <<-XML
-        <record>
-          <date>#{Date.today}</date>
-          <list>
-            <item>a</item>
-            <item>b</item>
-            <item>c</item>
-          </list>
-          <string>xyz</string>
-          <text>
-            <ul>
-              <li>vim</li>
-              <li>emacs</li>
-              <li>ctags</li>
-              <li>lint</li>
-              <li>gdb</li>
-            </ul>
-          </text>
-          <time>#{time}</time>
-        </record>
-      XML
-
-      x.record.date.should == Date.today
-      x.record.list.should == ["a","b","c"]
-      x.record.string.should == "xyz"
-      x.record.text.strip.should == <<-DOC.strip
-              vim
-              emacs
-              ctags
-              lint
-              gdb
-      DOC
-
-      x.record.time.to_i.should == time.to_i
-    end
-
-    it "parses recursive records" do
-      x = Record.parse("<record><record><record><record></record></record></record></record>")
-      x.should be_a(Record)
-      x.record.should be_a(Record)
-      x.record.record.should be_a(Record)
-      x.record.record.record.should be_a(Record)
-      x.record.record.record.record.should be_a(Record)
-      x.record.record.record.record.record.should be_nil
-    end
-  end
-
-end