xml_mapper 0.3.3 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.4.0

data/lib/xml_mapper.rb

@@ -6,24 +6,10 @@ class XmlMapper
   class << self
     attr_accessor :mapper
     
-    def text(*args)
-      mapper.add_mapping(:text, *args)
-    end
-    
-    def integer(*args)
-      mapper.add_mapping(:integer, *args)
-    end
-    
-    def boolean(*args)
-      mapper.add_mapping(:boolean, *args)
-    end
-    
-    def exists(*args)
-      mapper.add_mapping(:exists, *args)
-    end
-    
-    def node(*args)
-      mapper.add_mapping(:node, *args)
+    [:text, :integer, :boolean, :exists, :not_exists, :node_name, :inner_text, :node, :attribute].each do |method_name|
+      define_method(method_name) do |*args|
+        mapper.add_mapping(method_name, *args)
+      end
     end
     
     def within(xpath, &block)
@@ -63,7 +49,7 @@ class XmlMapper
     
     def capture_submapping(&block)
       saved_mapper = self.mapper
-      self.mapper = XmlMapper.new
+      self.mapper = self.new
       self.instance_eval(&block)
       captured_mapper = self.mapper
       self.mapper = saved_mapper
@@ -94,7 +80,10 @@ class XmlMapper
   def add_mapping(type, *args)
     options = extract_options_from_args(args)
     if args.first.is_a?(Hash)
-      args.first.map { |xpath, key|  add_single_mapping(type, xpath, key, options) }
+      if after_map_method = args.first.delete(:after_map)
+        options.merge!(:after_map => after_map_method)
+      end
+      args.first.map { |xpath, key| add_single_mapping(type, xpath, key, options) }
     else
       args.map { |arg| add_single_mapping(type, arg, arg, options) }
     end
@@ -104,8 +93,14 @@ class XmlMapper
     self.after_map_block = block
   end
   
-  def add_single_mapping(type, xpath, key, options = {})
-    self.mappings << { :type => type, :xpath => add_with_to_xpath(xpath), :key => key, :options => options }
+  def add_single_mapping(type, xpath_or_attribute, key, options = {})
+    mappings = { :type => type, :key => key, :options => options }
+    xpath = type == :attribute ? nil : xpath_or_attribute
+    if type == :attribute
+      mappings[:attribute] = xpath_or_attribute.to_s
+    end
+    mappings[:xpath] = add_with_to_xpath(xpath)
+    self.mappings << mappings
   end
   
   def add_with_to_xpath(xpath)
@@ -126,6 +121,7 @@ class XmlMapper
       xml_or_doc.map { |doc| attributes_from_xml(doc) } 
     else
       doc = xml_or_doc.is_a?(Nokogiri::XML::Node) ? xml_or_doc : Nokogiri::XML(xml_or_doc)
+      doc = doc.root if doc.respond_to?(:root)
       atts = self.mappings.inject(xml_path.nil? ? {} : { :xml_path => xml_path }) do |hash, mapping|
         hash.merge(mapping[:key] => value_from_doc_and_mapping(doc, mapping))
       end
@@ -137,28 +133,44 @@ class XmlMapper
   def value_from_doc_and_mapping(doc, mapping)
     if mapping[:type] == :many
       mapping[:options][:mapper].attributes_from_xml(doc.search(mapping[:xpath]).to_a)
-    elsif mapping[:type] == :exists
-      !doc.at("//#{mapping[:xpath]}").nil?
     else
-      value = mapping[:type] == :node ? doc.at(mapping[:xpath]) : inner_text_for_xpath(doc, mapping[:xpath])
-      apply_after_map_to_value(value, mapping)
+      node = mapping[:xpath].length == 0 ? doc : doc.xpath(mapping[:xpath]).first
+      if mapping[:type] == :exists
+        !node.nil?
+      elsif mapping[:type] == :not_exists
+        node.nil?
+      else
+        value = 
+        case mapping[:type]
+          when :node_name
+            doc.nil? ? nil : doc.name
+          when :inner_text
+            doc.nil? ? nil : doc.inner_text
+          when :node
+            node
+          when :attribute
+            node.nil? ? nil : (node.respond_to?(:root) ? node.root : node)[mapping[:attribute]]
+          else
+            inner_text_for_node(node)
+        end
+        apply_after_map_to_value(value, mapping)
+      end
     end
   end
   
   def apply_after_map_to_value(value, mapping)
-    after_map = TYPE_TO_AFTER_CODE[mapping[:type]]
-    after_map ||= mapping[:options][:after_map]
-    if value && after_map
-      value = value.send(after_map)  if value.respond_to?(after_map)
-      value = self.send(after_map, value) if self.respond_to?(after_map)
+    after_mappings = [TYPE_TO_AFTER_CODE[mapping[:type]], mapping[:options][:after_map]].compact
+    if value
+      after_mappings.each do |after_map|
+        value = value.send(after_map) if value.respond_to?(after_map)
+        value = self.send(after_map, value) if self.respond_to?(after_map)
+      end
     end
     value
   end
   
-  def inner_text_for_xpath(doc, xpath)
-    if node = doc.at(xpath)
-      node.inner_text
-    end
+  def inner_text_for_node(node)
+    node.inner_text if node
   end
   
   MAPPINGS = {
@@ -166,7 +178,9 @@ class XmlMapper
     "false" => false,
     "yes" => true,
     "y" => true,
-    "n" => false
+    "n" => false,
+    "1" => true,
+    "0" => false
   }
   
   def string_to_boolean(value)

data/spec/example_spec.rb

@@ -11,7 +11,10 @@ describe "ExampleSpec" do
     { 
       :title => "Black on Both Sides", :version_title => "Extended Edition", :released_in => 1999,
       :artist_name => "Mos Def", :artist_id => 1212, :country => "DE", :allows_streaming => true,
-      :tracks_count => 2, :released_on => Date.new(1999, 10, 12)
+      :tracks_count => 2, :released_on => Date.new(1999, 10, 12), :contributions => [ 
+        { :role => "artist", :name => "Mos Def" },
+        { :role => "producer", :name => "DJ Premier" },
+      ]
     }.each do |key, value|
       it "extracts #{value.inspect} as #{key}" do
         @attributes[key].should == value
@@ -19,8 +22,8 @@ describe "ExampleSpec" do
     end
     
     [
-      { :track_title => "Fear Not of Man", :track_number => 1, :disk_number => 1, :explicit_lyrics => true },
-      { :track_title => "Hip Hop", :track_number => 2, :disk_number => 1, :explicit_lyrics => true },
+      { :track_title => "Fear Not of Man", :track_number => 1, :disk_number => 1, :explicit_lyrics => true, :isrc => "1234" },
+      { :track_title => "Hip Hop", :track_number => 2, :disk_number => 1, :explicit_lyrics => false, :isrc => "2345" },
     ].each_with_index do |hash, offset|
       hash.each do |key, value|
         it "extracts #{value.inspect} for #{key} for track with offset #{offset}" do

data/spec/fixtures/base.xml

@@ -9,17 +9,27 @@
     <name>Mos Def</name>
     <id>1212</id>
   </artist>
+  <contributions>
+    <artist>Mos Def</artist>
+    <producer>DJ Premier</producer>
+  </contributions>
   <tracks>
-    <track>
+    <track code="1234">
       <title>Fear Not of Man</title>
       <number>1</number>
       <disk>1</number>
       <explicit_lyrics />
+      <not_streamable_in>
+        <country>de</country>
+      </not_streamable_in>
     </track>
-    <track>
+    <track code="2345">
       <title>Hip Hop</title>
       <number>2</number>
       <disk>1</number>
+      <not_streamable_in>
+        <country>at</country>
+      </not_streamable_in>
     </track>
   </tracks>
 </album>

data/spec/my_mapper.rb

@@ -13,11 +13,18 @@ class MyMapper < XmlMapper
     integer :id => :artist_id
   end
   
+  many "contributions/*" => :contributions do         # use the name of xml nodes for mappings
+    node_name :role                                   # map name of xml node to :role
+    inner_text :name                                  # map inner_text of xml node to :name
+  end
+  
   many "tracks/track" => :tracks do                   # maps xpath "tracks/track" to array with key :tracks
+    attribute :code => :isrc                          # map xml attribute "code" to :isrc
     text :title => :track_title
     integer :number => :track_number
     integer :disk => :disk_number
-    exists :explicit_lyrics                           # checks if a node with the xpath exists
+    exists :explicit_lyrics                            # checks if a node with the xpath exists
+    not_exists "not_streamable_in/country[text()='de']" => :allows_streaming
   end
   
   after_map do                                        # is called after attributes are extracted, self references the extracted attributes

data/spec/xml_mapper_spec.rb

@@ -29,6 +29,20 @@ describe "XmlMapper" do
       ]
     end
     
+    it "sets attribute for attribute mapping when attribute is mapped to same name" do
+      @mapper.add_mapping(:attribute, :first_name)
+      @mapper.mappings.should == [
+        { :type => :attribute, :attribute => "first_name", :key => :first_name, :options => {}, :xpath => "" }
+      ]
+    end
+    
+    it "sets attribute for attribute mapping when attribute is mapped to different name" do
+      @mapper.add_mapping(:attribute, :first_name => :firstname)
+      @mapper.mappings.should == [
+        { :type => :attribute, :attribute => "first_name", :key => :firstname, :options => {}, :xpath => "" }
+      ]
+    end
+    
     it "adds mappings when mapping given as hash" do
       @mapper.add_mapping(:text, :name => :first_name)
       @mapper.mappings.should == [{ :type => :text, :xpath => "name", :key => :first_name, :options => {} }]
@@ -61,6 +75,7 @@ describe "XmlMapper" do
     describe "#exists" do
       it "returns true when node exists" do
         xml = %(<album><title>Black on Both Sides</title><rights><country>DE</country></rights></album>)
+        root = Nokogiri::XML(xml).root
         @mapper.add_mapping(:exists, "rights[country='DE']" => :allows_streaming)
         @mapper.attributes_from_xml(xml).should == { :allows_streaming => true }
       end
@@ -138,10 +153,29 @@ describe "XmlMapper" do
       }
     end
     
+    it "allows multiple after_code mappings" do
+      class << @mapper
+        def double(value)
+          value * 2
+        end
+      end
+      @mapper.add_mapping(:integer, :track_number, :after_map => :double)
+      @mapper.attributes_from_xml(@xml).should == {
+        :track_number => 14
+      }
+    end
+    
+    it "allows defining a after_map mapping without ridicolous brackets" do
+      @mapper.add_mapping(:string, :track_number => :num, :after_map => :to_i)
+      @mapper.attributes_from_xml(@xml).should == {
+        :num => 7
+      }
+    end
+    
     it "uses mapper method defined in xml_mapper when value does not respond to :after_map and given as hash" do
       class << @mapper
         def double(value)
-          value.to_s * 2
+          value * 2
         end
       end
       # [{:type=>:text, :xpath=>"Graphic/ImgFormat", :key=>:image_format, :options=>{:after_map=>:double}}]
@@ -153,12 +187,27 @@ describe "XmlMapper" do
     
     it "takes a nokogiri node as argument" do
       @mapper.add_mapping(:text, :artist_name)
-      @mapper.attributes_from_xml(Nokogiri::XML(@xml)).should == {
+      @mapper.attributes_from_xml(Nokogiri::XML(@xml).root).should == {
+        :artist_name => "Mos Def"
+      }
+    end
+    
+    it "takes a nokogiri document as argument" do
+      @mapper.add_mapping(:text, :artist_name)
+      @mapper.attributes_from_xml(Nokogiri::XML(@xml).root).should == {
         :artist_name => "Mos Def"
       }
     end
     
     it "should also takes an array of nodes as argument" do
+      @mapper.add_mapping(:text, :artist_name)
+      @mapper.attributes_from_xml([Nokogiri::XML(@xml).root, Nokogiri::XML(@xml).root]).should == [
+        { :artist_name => "Mos Def" },
+        { :artist_name => "Mos Def" }
+      ]
+    end
+    
+    it "also takes an array of nokogiri documents as argument" do
       @mapper.add_mapping(:text, :artist_name)
       @mapper.attributes_from_xml([Nokogiri::XML(@xml), Nokogiri::XML(@xml)]).should == [
         { :artist_name => "Mos Def" },
@@ -265,7 +314,7 @@ describe "XmlMapper" do
     describe "#string_to_boolean" do
       { 
         "true" => true, "false" => false, "y" => true, "TRUE" => true, "" => nil, "YES" => true, "yes" => true,
-        "n" => false
+        "n" => false, "1" => true, "0" => false
       }.each do |value, result|
         it "converts #{value.inspect} to #{result}" do
           @mapper.string_to_boolean(value).should == result
@@ -351,6 +400,31 @@ describe "XmlMapper" do
       }
     end
     
+    it "allows after map when used in submapper and method exists in mapper" do
+      xml = %(
+        <album>
+          <tracks>
+            <track>
+              <track_number>11</track_number>
+            </track>
+            <track>
+              <track_number>22</track_number>
+            </track>
+          </tracks>
+        </album>
+      )
+      @clazz.send(:define_method, "double") do |*args|
+        args.first * 2
+      end
+      
+      @clazz.many "tracks/track" => :tracks do
+        integer :track_number => :num, :after_map => :double
+      end
+      @clazz.attributes_from_xml(xml).should == {
+        :tracks => [ { :num => 22 }, { :num => 44 }]
+      }
+    end
+    
     it "accepts boolean as keyword" do
       @clazz.boolean(:allows_streaming)
       xml = %(<album><title>Test Title</title><allows_streaming>true</allows_streaming></album>)
@@ -363,6 +437,41 @@ describe "XmlMapper" do
       @clazz.attributes_from_xml(xml).should == { :allows_streaming => true }
     end
     
+    it "accepts not_exists as keyword" do
+      @clazz.not_exists("forbidden_countries/country[text()='DE']" => :allows_streaming)
+      xml = %(<album><title>Black on Both Sides</title><forbidden_countries><country>DE</country></rights></album>)
+      @clazz.attributes_from_xml(xml).should == { :allows_streaming => false }
+    end
+    
+    it "does keep scope for not_exists" do
+      xml = %(
+        <album>
+          <tracks>
+            <track>
+              <title>Track 1</title>
+              <forbidden_countries>
+                <country>DE</country>
+              </forbidden_countries>
+            </track>
+            <track>
+              <title>Track 2</title>
+              <forbidden_countries>
+                <country>AT</country>
+              </forbidden_countries>
+            </track>
+          </tracks>
+        </album>
+      )
+      @clazz.many "tracks/track" => :tracks do
+        text :title
+        not_exists "forbidden_countries/country[text()='DE']" => :allows_streaming
+      end
+      @clazz.attributes_from_xml(xml)[:tracks].should == [
+        { :title => "Track 1", :allows_streaming => false },
+        { :title => "Track 2", :allows_streaming => true },
+      ]
+    end
+    
     describe "#within" do
       it "adds the within xpath to all xpath mappings" do
         @clazz.within("artist") do
@@ -511,5 +620,75 @@ describe "XmlMapper" do
       end
     end
   
+  
+    describe "using node_name, inner_text and attribute" do
+      it "extracts attributes for a many relationship when node_name and inner_text is used" do
+        xml = %(
+          <album>
+            <Contributors>
+              <Performer>Sexy sushi</Performer>
+              <Composer>Sexi Sushi</Composer>
+              <Author>Sexi Sushi</Author>
+            </Contributors>
+          </album>
+        )
+        @clazz.many "Contributors/*" => :contributions do
+          node_name :contribution_type
+          inner_text :name
+        end
+        @clazz.attributes_from_xml(xml).should == {
+          :contributions => [
+            { :contribution_type => "Performer", :name => "Sexy sushi" },
+            { :contribution_type => "Composer", :name => "Sexi Sushi" },
+            { :contribution_type => "Author", :name => "Sexi Sushi" },
+          ]
+        }
+      end
+      
+      it "extracts the correct attributes when attribute keyword is used in 'many'-mapping" do
+        xml = %(
+          <album>
+            <tracks>
+              <track some_code="1234">
+                <title>Track 1</title>
+              </track>
+            </tracks>
+          </album>
+        )
+        @clazz.many "tracks/track" => :tracks do
+          attribute "some_code" => :isrc
+          text :title
+        end
+        @clazz.attributes_from_xml(xml).should == {
+          :tracks => [
+            { :isrc => "1234", :title => "Track 1" }
+          ]
+        }
+      end
+      
+      it "extracts the correct attributes when attribute is used in within-mapping" do
+        xml = %(
+          <album>
+            <meta code="1234">
+              <title>Product Title</title>
+            </meta>
+          </></album>
+        )
+        @clazz.within "meta" do
+          attribute "code" => :upc
+        end
+        @clazz.attributes_from_xml(xml)[:upc].should == "1234"
+      end
+      
+      it "extracts the correct attributes when attribute is used in root mapping" do
+        xml = %(
+          <album code="1234">
+            <title>Product Title</title>
+          </></album>
+        )
+        @clazz.attribute :code => :upc
+        @clazz.attributes_from_xml(xml)[:upc].should == "1234"
+      end
+    end
   end
 end

data/xml_mapper.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{xml_mapper}
-  s.version = "0.3.3"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]
-  s.date = %q{2010-11-29}
+  s.date = %q{2010-12-01}
   s.description = %q{Declarative XML to Ruby mapping}
   s.email = %q{tobias.schwab@dynport.de}
   s.extra_rdoc_files = [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: xml_mapper
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 3
-  version: 0.3.3
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tobias Schwab
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-29 00:00:00 +01:00
+date: 2010-12-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency