xapper 0.1.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gem "nokogiri"
+gem "rspec"
+gem "rspec-mocks"
+gem "jeweler"

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    nokogiri (1.5.0)
+    rake (0.9.2)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.0)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  nokogiri
+  rspec
+  rspec-mocks

data/README.md

@@ -0,0 +1,144 @@
+# Xapper - another XML mapper for Ruby
+
+A simple mapper that takes a mapping and converts your ugly-XML to a lovely-ruby hash.
+
+## Install
+
+
+Use [Bundler](http://gembundler.com/) + git, add this to your `Gemfile`
+
+    gem "xapper"
+
+In your code
+
+    require "xapper"
+
+## Usage
+
+### Setup
+
+Get a mapper object
+
+    mapper = Xapper::Mapper.new
+
+And some hopefully less contrived XML
+
+    <response type="book_list">
+      <title>A list of books on my shelf</title>
+      <books>
+        <book author="Boris Akunin">
+          <title>The Winter Queen</title>
+        </book>
+        <book author="Neil Gaiman">
+          <title>Neverwhere</title>
+        </book>
+        <book author="Hermann Hesse">
+          <title>Steppenwolf</title>
+        </book>
+      </books>
+    </response>
+
+### Mapping text values and attributes using xpath
+
+    mapper.mappings = {
+      :type   => "/response/@type",
+      :title  => "/response/title"
+    }
+
+    data = mapper.map(xml)
+
+    data[:type]  #=> "book_list"
+    data[:title] #=> "A list of books on my shelf"
+
+### Mapping lists of XML nodes into arrays of hashes
+
+    mapper.mappings = {
+      :books => ["/response/books/book", {
+        :title  => "title",
+        :author => "@author"
+      }]
+    }
+
+    data = mapper.map(xml)
+
+    data[:books].size        #=> 3
+    data[:books][0][:title]  #=> "The Winter Queen"
+    data[:books][0][:author] #=> "Boris Akunin"
+
+
+### Using a lambda to convert values
+
+You can map via a lambda, the current [Nokogiri](http://nokogiri.org/) node is passed as an argument
+
+    mapper.mappings = {
+      :books => ["/response/books/book", {
+        :title  => "title",
+        :author => {
+          :name => "@author",
+          :wiki => lambda do |node|
+            "http://en.wikipedia.org/wiki/" + node.attribute('author').value.gsub(" ", "_")
+          end
+        }
+      }]
+    }
+
+    data = mapper.map(xml)
+    data[:books][0][:author][:wiki] #=> "http://en.wikipedia.org/wiki/Boris_Akunin"
+
+### Using namespaces
+
+You can map XML namespaces, the mapper just needs to know about them first
+
+    xml = %q{
+      <root xmlns:h="http://www.w3.org/TR/html4/" xmlns:f="http://www.w3schools.com/furniture">
+        <h:table>
+          <h:tr>
+            <h:td>Apples</h:td>
+            <h:td>Bananas</h:td>
+          </h:tr>
+        </h:table>
+        <f:table>
+          <f:name>African Coffee Table</f:name>
+          <f:width>80</f:width>
+          <f:length>120</f:length>
+        </f:table>
+      </root>
+    }
+
+    mapper.mappings = {
+      :html_table_rows => ["/root/h:table/h:tr/h:td", { :text => "." }],
+      :an_actual_table => {
+        :name   => "/root/f:table/f:name",
+        :width  => "/root/f:table/f:width",
+        :length => "/root/f:table/f:length"
+      }
+    }
+
+    mapper.namespaces = {
+      "h" => "http://www.w3.org/TR/html4/",
+      "f" => "http://www.w3schools.com/furniture"
+    }
+
+    data = mapper.map(xml)
+
+    data[:html_table_rows].size      # => 2
+    data[:html_table_rows][0][:text] # => "Apples"
+
+    data[:an_actual_table][:name]    # => "African Coffee Table"
+    data[:an_actual_table][:width]   # => "80"
+
+## Examples
+
+See `examples/*.rb`, run with `rake examples`
+
+## Development
+
+Please send new code in the form of a pull requests with tests. Run the current test suite with ...
+
+    rake spec         # Runs spec/*_spec.rb
+
+## Contributors:
+
+* [Matt Haynes](https://github.com/matth)
+* [Anuj Dutta](https://github.com/andhapp/)
+* [Jim Lynn](https://github.com/JimLynn)

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "xapper"
+  gem.homepage = "http://github.com/bbcsnippets/xapper"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple mapper that takes an XML and maps it into a ruby hash}
+  gem.description = %Q{Give it an xml and define a mapping for it as a ruby hash and there you have it. A ruby hash for your XML}
+  gem.email = "dutta.anuj@gmail.com"
+  gem.authors = ["andhapp", "matth"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :examples do
+  $: << "."
+  require "examples/book_list"
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/book_list.rb

@@ -0,0 +1,41 @@
+require "xapper"
+require "pp"
+
+xml = %q{
+  <response type="book_list">
+    <title>A list of books on my shelf</title>
+    <books>
+      <book author="Boris Akunin">
+        <title>The Winter Queen</title>
+      </book>
+      <book author="Neil Gaiman">
+        <title>Neverwhere</title>
+      </book>
+      <book author="Hermann Hesse">
+        <title>Steppenwolf</title>
+      </book>
+    </books>
+  </response>
+}
+
+puts "Mapping: \n #{xml}"
+
+mapper = Xapper::Mapper.new
+
+mapper.mappings = {
+  :type   => "/response/@type",
+  :title  => "/response/title",
+  :books => ["/response/books/book", {
+    :title  => "title",
+    :author => {
+      :name => "@author",
+      :wiki => lambda do |node|
+        "http://en.wikipedia.org/wiki/" + node.attribute('author').value.gsub(" ", "_")
+      end
+    }
+  }]
+}
+
+puts "\nTo:\n\n"
+
+pp mapper.map(xml)

data/lib/xapper.rb

@@ -0,0 +1,72 @@
+require "nokogiri"
+
+module Xapper
+
+  @@mappings = {}
+
+  def mappings(hash, namespaces = nil)
+    mapper = Mapper.new
+    mapper.mappings = hash[hash.keys[0]]
+    mapper.namespaces = namespaces
+    @@mappings[hash.keys[0]] = mapper
+  end
+
+  def map(mapping, xml)
+    @@mappings[mapping].map(xml)
+  end
+
+  class Mapper
+
+    attr_accessor :mappings
+    attr_accessor :namespaces
+
+    def map(xml_str)
+      xml  = Nokogiri::XML(xml_str)
+      map_xml_data(xml, @mappings, {})
+    end
+
+    protected
+
+    def map_xml_data(xml, mappings, data)
+
+      mappings.each_pair do |key, val|
+
+        # We have a proc object
+        if val.is_a? Proc
+          data[key] = val.call xml
+          next
+        end
+
+        # Recurse on hash
+        if val.is_a? Hash
+          data[key] = map_xml_data(xml, val, {})
+          next
+        end
+
+        if val.is_a? Array
+          xpath = val[0]
+          submap = val[1]
+          items = xml.xpath(xpath, @namespaces)
+          data[key] = items.map {|node| map_xml_data(node, submap, {})}
+          next
+        end
+
+        # We have an xpath to lookup
+        node      = xml.xpath(val,@namespaces)[0]
+
+        if node.class == Nokogiri::XML::Element
+          data[key] = node.content
+        elsif node.class == Nokogiri::XML::Attr
+          data[key] = node.value
+        else
+          data[key] = nil
+        end
+
+      end
+
+      data
+
+    end
+
+  end
+end

data/spec/lib/xapper_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe Xapper::Mapper do
+
+  before do
+    @mapper = Xapper::Mapper.new
+  end
+
+  describe '#map' do
+
+    it 'should map xml node values' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo>
+          <bar>Hello world</bar>
+          <baz>Goodbye world</baz>
+        </foo>
+      }
+      @mapper.mappings = {
+        :bar => '/foo/bar',
+        :baz => '/foo/baz'
+      }
+      data = @mapper.map xml
+      data[:bar].should == 'Hello world'
+      data[:baz].should == 'Goodbye world'
+    end
+
+    it 'should map xml attribute values' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo>
+          <bar text="Hello world" />
+          <baz text="Goodbye world" />
+        </foo>
+      }
+      @mapper.mappings = {
+        :bar => '/foo/bar/@text',
+        :baz => '/foo/baz/@text'
+      }
+      data = @mapper.map xml
+      data[:bar].should == 'Hello world'
+      data[:baz].should == 'Goodbye world'
+    end
+
+    it 'should map the result of a proc object if given, by passing currnent xml context as value' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo>
+          <bar attr="BAR1">Text value</bar>
+          <bar attr="BAR2">Text value</bar>
+        </foo>
+      }
+      @mapper.mappings = {
+        :bar => {
+          :attributes => lambda do |xml|
+            xml.xpath('//bar').map { |node| node.attribute('attr') }.join(',')
+          end
+        }
+      }
+      data = @mapper.map xml
+      data[:bar][:attributes].should == 'BAR1,BAR2'
+
+    end
+
+    it 'should map a node to nil if it does not exist' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo><bar /></foo>
+      }
+      @mapper.mappings = {
+        :bar => "/foo/bar/@attr",
+        :baz => "/foo/baz"
+      }
+      data = @mapper.map xml
+      data[:bar].should == nil
+      data[:baz].should == nil
+    end
+
+    it 'should map an multiple xml elements to an array' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo>
+          <bar>
+            <baz attr="Attr value 1">Text value 1</bar>
+          </bar>
+          <bar>
+            <baz attr="Attr value 2">Text value 2</bar>
+          </bar>
+        </foo>
+      }
+      @mapper.mappings = {
+        :bar => ['/foo/bar', {
+          :baz => {
+            :attr => 'baz/@attr',
+            :text => 'baz'
+          }
+        }]
+      }
+      data = @mapper.map xml
+      data[:bar].size.should == 2
+      data[:bar][0][:baz][:attr].should == "Attr value 1"
+      data[:bar][0][:baz][:text].should == "Text value 1"
+      data[:bar][1][:baz][:attr].should == "Attr value 2"
+      data[:bar][1][:baz][:text].should == "Text value 2"
+    end
+
+    it 'should map into a nested hash' do
+      xml = %q{
+        <?xml version="1.0" encoding="UTF-8"?>
+        <foo>
+          <bar attr="Attr value">Text value</bar>
+          <baz attr="Attr value">Text value</bar>
+        </foo>
+      }
+      @mapper.mappings = {
+        :bar => {
+          :attr => '/foo/bar/@attr',
+          :text => '/foo/bar'
+        },
+        :baz => {
+          :attr => '/foo/baz/@attr',
+          :text => '/foo/baz'
+        }
+      }
+      data = @mapper.map xml
+      data[:bar][:attr].should == 'Attr value'
+      data[:bar][:text].should == 'Text value'
+      data[:baz][:attr].should == 'Attr value'
+      data[:baz][:text].should == 'Text value'
+    end
+
+  end
+
+  it "should map namespaces correctly" do
+
+    xml = %q{
+      <root xmlns:h="http://www.w3.org/TR/html4/" xmlns:f="http://www.w3schools.com/furniture">
+        <h:table>
+          <h:tr>
+            <h:td>Apples</h:td>
+            <h:td>Bananas</h:td>
+          </h:tr>
+        </h:table>
+        <f:table>
+          <f:name>African Coffee Table</f:name>
+          <f:width>80</f:width>
+          <f:length>120</f:length>
+        </f:table>
+      </root>
+    }
+
+    @mapper.mappings = {
+      :html_table_rows => ["/root/h:table/h:tr/h:td", { :text => "." }],
+      :an_actual_table => {
+        :name   => "/root/f:table/f:name",
+        :width  => "/root/f:table/f:width",
+        :length => "/root/f:table/f:length"
+      }
+    }
+
+    @mapper.namespaces = {
+      "h" => "http://www.w3.org/TR/html4/",
+      "f" => "http://www.w3schools.com/furniture"
+    }
+
+    data = @mapper.map(xml)
+
+    data[:html_table_rows].size.should == 2
+    data[:html_table_rows][0][:text].should  == "Apples"
+
+    data[:an_actual_table][:name].should  == "African Coffee Table"
+    data[:an_actual_table][:width].should == "80"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bundler'
+Bundler.require
+require 'xapper'
+
+RSpec.configure do |config|
+end

data/xapper.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{xapper}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["andhapp", "matth"]
+  s.date = %q{2011-10-21}
+  s.description = %q{Give it an xml and define a mapping for it as a ruby hash and there you have it. A ruby hash for your XML}
+  s.email = %q{dutta.anuj@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "examples/book_list.rb",
+    "lib/xapper.rb",
+    "spec/lib/xapper_spec.rb",
+    "spec/spec_helper.rb",
+    "xapper.gemspec"
+  ]
+  s.homepage = %q{http://github.com/bbcsnippets/xapper}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{A simple mapper that takes an XML and maps it into a ruby hash}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec-mocks>, [">= 0"])
+      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rspec-mocks>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rspec-mocks>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: xapper
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- andhapp
+- matth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec-mocks
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Give it an xml and define a mapping for it as a ruby hash and there you have it. A ruby hash for your XML
+email: dutta.anuj@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- examples/book_list.rb
+- lib/xapper.rb
+- spec/lib/xapper_spec.rb
+- spec/spec_helper.rb
+- xapper.gemspec
+has_rdoc: true
+homepage: http://github.com/bbcsnippets/xapper
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple mapper that takes an XML and maps it into a ruby hash
+test_files: []
+