dozuki-mapper 0.0.1

data/.autotest

@@ -0,0 +1,13 @@
+Autotest.add_hook :initialize do |at|
+  root = File.dirname(__FILE__)
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/.*_spec\.rb$%) { |filename|
+    filename
+  }
+  at.add_mapping(%r%^spec/support/.*\.rb$%) { |_|
+    Dir[File.join(root, 'spec/**/*_spec.rb')]
+  }
+  nil
+end

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dozuki-mapper.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,132 @@
+# Dozuki Mapper
+
+A simple DSL for mapping xml documents directly to user-defined classes.
+Ideal for API parsing.
+
+## What does it do?
+
+You've got an XML API and you want to model the output in Ruby objects,
+parse values to primitives and build a structure. You don't want to write lots of code or XPaths or repeat yourself.
+Dozuki-mapper, built on the Dozuki gem, lets you define the mapping
+between the XML and the objects, but does little more, meaning you
+have control over the definition of your class. It is currently only
+suited to reasonably direct mappings as it's being used to model API
+responses.
+
+Features can be found in the [features
+folder](https://github.com/jamesalmond/dozuki-mapper/tree/master/features).
+
+It's built using the [dozuki gem](https://github.com/jamesalmond/dozuki)
+
+# How do I use it?
+
+    xml = %Q{
+    <person>
+      <name>John Smith</name>
+      <address>1 Main Street</address>
+      <post_code>NW1 3ED</post_code>
+    </person>
+    }
+
+    class Person
+      include Dozuki::Mapper
+
+      attr_accessor :name, :address, :post_code
+
+      map_with do |map|
+        map.string :name
+        map.string :address
+        map.string :post_code
+      end
+    end
+
+
+    doc = Dozuki::XML.parse(xml)
+
+    person = Person.from_node(doc.get('./person')
+
+Setting the relevant fields on the person object. More conversions (e.g.
+integer, float, date) to come.
+
+## Mapping data types
+
+* [String](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/string_mapping.feature)
+* [Float](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/float_mapping.feature)
+* [Int](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/int_mapping.feature)
+* [Date](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/date_mapping.feature)
+
+## Mapping object hierarchies
+
+
+* [Mapping nodes](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/node_mapping.feature)
+
+Example:
+
+    xml = %Q{
+      <plot>
+        <name>Tiny Plot</name>
+        <dimensions>
+          <width>100</width>
+          <depth>200</depth>
+        </dimensions>
+      </plot>
+    }
+
+    class Plot
+      include Dozuki::Mapper
+      attr_accessor :name, :dimensions
+      map_with do |map|
+        map.string :name
+        map.node :dimensions, :as => Dimensions
+      end
+    end
+
+    class Dimensions
+      include Dozuki::Mapper
+      attr_accessor :width, :height
+      map_with do |map|
+        map.int :width
+        map.int :height
+      end
+    end
+
+
+## Mapping collections
+
+* [Mapping each](https://github.com/jamesalmond/dozuki-mapper/tree/master/features/each_mapping.feature)
+
+
+## Contributing to Dozuki Mapper
+ 
+* Fork the project.
+* Add tests that cover the new feature or bug fix.
+* Make your feature addition or bug fix.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011:
+
+* [James Almond](http://jamesalmond.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+
+
+desc "Run specs"
+RSpec::Core::RakeTask.new :spec
+
+desc "Run integrations"
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+task :default => [:spec, :features]
+
+

data/dozuki-mapper.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dozuki-mapper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dozuki-mapper"
+  s.version     = Dozuki::Mapper::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["James Almond"]
+  s.email       = ["james@jamesalmond.com"]
+  s.homepage    = "https://github.com/jamesalmond/dozuki-mapper"
+  s.summary     = %q{A DSL for mapping API output to objects}
+  s.description = %q{A DSL for mapping API output to objects}
+
+  s.rubyforge_project = "dozuki-mapper"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/* .autotest`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("dozuki")
+
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("cucumber")
+  s.add_development_dependency("autotest")
+  s.add_development_dependency("rake")
+end

data/features/date_mapping.feature

@@ -0,0 +1,25 @@
+Feature: mapping a document with date elements to an object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a document to an object
+
+
+  Scenario: I have a simple mapping
+    Given I have an event with start_date, end_date and sold_out
+    And I have the XML:
+      """
+      <event>
+        <start_date>2011-02-01</start_date>
+        <end_date>2011-05-13</end_date>
+        <sold_out>2010-12-25</sold_out>
+      </event>
+      """
+    When I map the event node to an event object with:
+      """
+        map.date :start_date
+        map.date :end_date
+        map.date :sold_out
+      """
+    Then the event should have a start_date of 01/2/2011
+    And the event should have a end_date of 13/5/2011
+    And the event should have a sold_out of 25/12/2010

data/features/each_mapping.feature

@@ -0,0 +1,30 @@
+Feature: mapping a node's children to to another object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a node to a series of other objects
+
+  Scenario: I have a simple mapping
+    Given I have car with brand and colours
+    And I have a colour class with description and hex and a from_node method
+    And I have the XML:
+      """
+      <car>
+        <brand>Fawd</brand>
+        <colour>
+          <description>Red</description>
+          <hex>#FF0000</hex>
+        </colour>
+        <colour>
+          <description>Blue</description>
+          <hex>#0000FF</hex>
+        </colour>
+      </car>
+      """
+    When I map the car node to a car object with:
+      """
+        map.string :brand
+        map.each :colour, :as => Colour, :to => :colours
+      """
+    Then the car should have a brand of "Fawd"
+    And the car should have a colour with a description of "Red" and a hex of "#FF0000"
+    And the car should have a colour with a description of "Blue" and a hex of "#0000FF"

data/features/float_mapping.feature

@@ -0,0 +1,25 @@
+Feature: mapping a document with float elements to an object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a document to an object
+
+
+  Scenario: I have a simple mapping
+    Given I have an item with max_price, min_price and average_price
+    And I have the XML:
+      """
+      <item>
+        <max_price>20.43</max_price>
+        <min_price>9.50</min_price>
+        <average_price>99</average_price>
+      </item>
+      """
+    When I map the item node to an item object with:
+      """
+        map.float :max_price
+        map.float :min_price
+        map.float :average_price
+      """
+    Then the event should have a max_price of 20.43
+    And the event should have a min_price of 9.50
+    And the event should have a average_price of 99.0

data/features/int_mapping.feature

@@ -0,0 +1,25 @@
+Feature: mapping a document with int elements to an object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a document to an object
+
+
+  Scenario: I have a simple mapping
+    Given I have a shop with items, staff and suppliers
+    And I have the XML:
+      """
+      <shop>
+        <items>300</items>
+        <staff>1</staff>
+        <suppliers>43</suppliers>
+      </shop>
+      """
+    When I map the shop node to a shop object with:
+      """
+        map.int :items
+        map.int :staff
+        map.int :suppliers
+      """
+    Then the shop should have 1 staff
+    And the shop should have 300 items
+    And the shop should have 43 suppliers

data/features/node_mapping.feature

@@ -0,0 +1,26 @@
+Feature: mapping a node to to another object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a node to another object
+
+
+  Scenario: I have a simple mapping
+    Given I have plot with name and dimensions
+    And I have a dimensions class with width, depth and a from_node class method
+    And I have the XML:
+      """
+      <plot>
+        <name>Tiny Plot</name>
+        <dimensions>
+          <width>100</width>
+          <depth>200</depth>
+        </dimensions>
+      </plot>
+      """
+    When I map the plot node to a plot object with:
+      """
+        map.string :name
+        map.node :dimensions, :as => Dimensions
+      """
+    Then the plot should have a name of "Tiny Plot"
+    And the plot should have dimensions with a width of 100 and a depth of 200

data/features/step_definitions/date_steps.rb

@@ -0,0 +1,20 @@
+Given /^I have an event with start_date, end_date and sold_out$/ do
+  class Event
+    include Dozuki::Mapper
+    attr_accessor :start_date, :end_date, :sold_out
+  end
+end
+
+When /^I map the event node to an event object with:$/ do |string|
+  Event.instance_eval %Q{
+    map_with do |map|
+      #{string}
+    end
+  }
+  @event = Event.from_node(@doc.get('/event'))
+end
+
+Then /^the event should have a (.*) of (\d+)\/(\d+)\/(\d+)$/ do |field, day, month, year|
+  @event.send(field).should == Date.civil(year.to_i, month.to_i, day.to_i)
+end
+

data/features/step_definitions/each_steps.rb

@@ -0,0 +1,38 @@
+Given /^I have car with brand and colours$/ do
+  class Car
+    include Dozuki::Mapper
+    attr_accessor :brand, :colours
+    def initialize
+      self.colours = []
+    end
+  end
+end
+
+Given /^I have a colour class with description and hex and a from_node method$/ do
+  class Colour
+    include Dozuki::Mapper
+    attr_accessor :description, :hex
+    map_with do |map|
+      map.string :description
+      map.string :hex
+    end
+  end
+end
+
+When /^I map the car node to a car object with:$/ do |string|
+  Car.instance_eval %Q{
+    map_with do |map|
+      #{string}
+    end
+  }
+  @car = Car.from_node(@doc.get('/car'))
+end
+
+Then /^the car should have a brand of "([^"]*)"$/ do |brand|
+  @car.brand.should == brand
+end
+
+Then /^the car should have a colour with a description of "([^"]*)" and a hex of "([^"]*)"$/ do |description, hex|
+  @car.colours.any?{|car| car.description == description && car.hex == hex}.should be_true
+end
+

data/features/step_definitions/float_steps.rb

@@ -0,0 +1,19 @@
+Given /^I have an item with max_price, min_price and average_price$/ do
+  class Item
+    include Dozuki::Mapper
+    attr_accessor :max_price, :min_price, :average_price
+  end
+end
+
+When /^I map the item node to an item object with:$/ do |string|
+  Item.instance_eval %Q{
+    map_with do |map|
+     #{string}
+    end
+  }
+  @item = Item.from_node(@doc.get('/item'))
+end
+
+Then /^the event should have a (.*) of (\d+\.\d+)$/ do |field, float|
+  @item.send(field).should == float.to_f
+end

data/features/step_definitions/int_steps.rb

@@ -0,0 +1,20 @@
+Given /^I have a shop with items, staff and suppliers$/ do
+  class Shop
+    include Dozuki::Mapper
+    attr_accessor :staff, :items, :suppliers
+  end
+end
+
+Then /^the shop should have (\d+) (.*)$/ do |count, field|
+  @shop.send(field).should == count.to_i
+end
+
+When /^I map the shop node to a shop object with:$/ do |string|
+  Shop.instance_eval %Q{
+    map_with do |map|
+      #{string}
+    end
+  }
+  @shop = Shop.from_node(@doc.get('/shop'))
+end
+

data/features/step_definitions/node_steps.rb

@@ -0,0 +1,37 @@
+Given /^I have plot with name and dimensions$/ do
+  class Plot
+    include Dozuki::Mapper
+    attr_accessor :name, :dimensions
+  end
+end
+
+Given /^I have a dimensions class with width, depth and a from_node class method$/ do
+  class Dimensions
+    include Dozuki::Mapper
+    attr_accessor :width, :depth
+    map_with do |map|
+      map.int :width
+      map.int :depth
+    end
+  end
+end
+
+When /^I map the plot node to a plot object with:$/ do |string|
+  Plot.instance_eval %Q{
+    map_with do |map|
+      #{string}
+    end
+  }
+  @plot = Plot.from_node(@doc.get('/plot'))
+end
+
+Then /^the plot should have a name of "([^"]*)"$/ do |name|
+  @plot.name.should == name
+end
+
+Then /^the plot should have dimensions with a width of (\d+) and a depth of (\d+)$/ do |width, depth|
+  dimensions = @plot.dimensions
+  dimensions.width.should == width.to_i
+  dimensions.depth.should == depth.to_i
+end
+

data/features/step_definitions/string_steps.rb

@@ -0,0 +1,23 @@
+Given /^I have an person with name, address and post_code$/ do
+  class Person
+    include Dozuki::Mapper
+    attr_accessor :name, :address, :post_code
+  end
+end
+
+Given /^I have the XML:$/ do |string|
+  @doc = Dozuki::XML.parse(string)
+end
+
+When /^I map the person node to a person object with:$/ do |string|
+  Person.instance_eval %Q{
+    map_with do |map|
+     #{string}
+    end
+  }
+  @person = Person.from_node(@doc.get('/person'))
+end
+
+Then /^the person should have the (.*) "([^"]*)"$/ do |field, string|
+  @person.send(field).should == string
+end

data/features/string_mapping.feature

@@ -0,0 +1,25 @@
+Feature: mapping a document with string elements to an object
+  So that I don't have to spend all my time typing in repetitive XPaths
+  As an API consumer
+  I want to map a document to an object
+
+  @string
+  Scenario: I have a simple mapping
+    Given I have an person with name, address and post_code
+    And I have the XML:
+      """
+      <person>
+        <name>John Smith</name>
+        <address>1 Main Street</address>
+        <post_code>NW1 3ED</post_code>
+      </person>
+      """
+    When I map the person node to a person object with:
+      """
+        map.string :name
+        map.string :address
+        map.string :post_code
+      """
+    Then the person should have the name "John Smith"
+    Then the person should have the address "1 Main Street"
+    Then the person should have the post_code "NW1 3ED"

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'dozuki-mapper'

data/lib/dozuki-mapper/proxy.rb

@@ -0,0 +1,39 @@
+module Dozuki
+  module Mapper
+    class Proxy
+      attr_accessor :receiver, :from_node
+
+      def initialize(receiver, node)
+        self.receiver = receiver
+        self.from_node = node
+      end
+
+      def string(attribute)
+        self.receiver.send("#{attribute}=", from_node.string("./#{attribute}"))
+      end
+
+      def int(attribute)
+        self.receiver.send("#{attribute}=", from_node.int("./#{attribute}"))
+      end
+
+      def date(attribute)
+        self.receiver.send("#{attribute}=", from_node.date("./#{attribute}"))
+      end
+
+      def float(attribute)
+        self.receiver.send("#{attribute}=", from_node.float("./#{attribute}"))
+      end
+
+      def node(attribute, opts={})
+        self.receiver.send("#{attribute}=", opts[:as].from_node(from_node.get("./#{attribute}")))
+      end
+
+      def each(attribute, opts={})
+        from_node.each("./#{attribute}") do |node|
+          receiver.send(opts[:to]) << opts[:as].from_node(node)
+        end
+      end
+
+    end
+  end
+end

data/lib/dozuki-mapper/version.rb

@@ -0,0 +1,5 @@
+module Dozuki
+  module Mapper
+    VERSION = "0.0.1"
+  end
+end

data/lib/dozuki-mapper.rb

@@ -0,0 +1,25 @@
+require 'dozuki'
+require 'dozuki-mapper/proxy'
+module Dozuki
+  module Mapper
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    def map_from(node)
+      self.class.mapper.call Proxy.new(self, node)
+    end
+    module ClassMethods
+      def map_with(&blk)
+        @mapper = blk
+      end
+      def mapper
+        @mapper
+      end
+      def from_node(node)
+        new.tap do |instance|
+          instance.map_from(node)
+        end
+      end
+    end
+  end
+end

data/spec/dozuki-mapper/proxy_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+module Dozuki
+  module Mapper
+    describe Proxy do
+      class TestClass < Struct.new(:field, :fields); end
+
+      describe "string" do
+        let(:receiver){ TestClass.new }
+        let(:node) { mock :node}
+        let(:method_name){:field}
+        let(:string) { "The Decemberists" }
+
+        before do
+          node.stub(:string).and_return(string)
+        end
+
+        subject { Proxy.new(receiver, node).string(method_name) }
+        it "should get the field from the node using the xpath ./field as a string" do
+          node.should_receive(:string).with('./field').and_return(string)
+          subject
+        end
+
+        it "should set the field on the receiver with the string" do
+          subject
+          receiver.field.should == string
+        end
+
+      end
+
+      describe "string" do
+        let(:receiver){ TestClass.new }
+        let(:node) { mock :node}
+        let(:method_name){:field}
+        let(:int) { 54 }
+
+        before do
+          node.stub(:int).and_return(int)
+        end
+
+        subject { Proxy.new(receiver, node).int(method_name) }
+        it "should get the field from the node using the xpath ./field as an int" do
+          node.should_receive(:int).with('./field').and_return(int)
+          subject
+        end
+
+        it "should set the field on the receiver with the int" do
+          subject
+          receiver.field.should == int
+        end
+      end
+      
+      describe "float" do
+        let(:receiver){ TestClass.new }
+        let(:node) { mock :node}
+        let(:method_name){:field}
+        let(:float) { 503.0 }
+
+        before do
+          node.stub(:float).and_return(float)
+        end
+
+        subject { Proxy.new(receiver, node).float(method_name) }
+        it "should get the field from the node using the xpath ./field as an float" do
+          node.should_receive(:float).with('./field').and_return(float)
+          subject
+        end
+
+        it "should set the field on the receiver with the float" do
+          subject
+          receiver.field.should == float
+        end
+      end
+
+
+      describe "node" do
+        let(:node) { mock :node }
+        let(:receiver){ TestClass.new }
+        let(:method_name){ :field }
+        let(:other_class) { mock :class }
+        let(:new_object) { mock :new_object }
+
+        before do
+          node.stub(:get).and_return(node)
+          other_class.stub(:from_node).and_return(new_object)
+        end
+
+        subject { Proxy.new(receiver, node).node(method_name, :as => other_class) }
+
+        it "should get the node from the receiver using the ./field xpath" do
+          node.should_receive(:get).with('./field').and_return(node)
+          subject
+        end
+        it "should create a new instance of the other class suing from_node" do
+          other_class.should_receive(:from_node).with(node).and_return(new_object)
+          subject
+        end
+        it "should set the new object to the field" do
+          subject
+          receiver.field.should == new_object
+        end
+      end
+
+      describe "each" do
+        let(:node) { mock :node }
+        let(:receiver){ TestClass.new(nil, []) }
+        let(:other_class){ mock :other_class }
+        let(:new_object) { mock :new_object }
+        let(:field){ mock :field }
+
+        before do
+          node.stub(:each).and_yield(field)
+          other_class.stub(:from_node).and_return(new_object)
+        end
+
+        subject { Proxy.new(receiver, node).each(:field, :as => other_class, :to => :fields)}
+
+        it "should get each field from the node using the ./field xpath" do
+          node.should_receive(:each).with('./field').and_yield(field)
+          subject
+        end
+        it "should create a new instance of the other class using the from_node method" do
+          other_class.should_receive(:from_node).with(field).and_return(new_object)
+          subject
+        end
+        it "should append the object to the as field" do
+          subject
+          receiver.fields.should == [new_object]
+        end
+      end
+
+    end
+  end
+end

data/spec/dozuki-mapper_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Dozuki
+  describe Mapper do
+    let(:node) { mock :node }
+    let(:klass){ Class.new }
+    before do
+      klass.send(:include, Mapper)
+    end
+    describe "mappings" do
+      let(:instance) { klass.new }
+      let(:proxy) { mock :proxy }
+      before { Mapper::Proxy.stub(:new).and_return(proxy) }
+      subject {
+        klass.map_with do |arg|
+          @called_with = arg
+        end
+        instance.map_from(node)
+      }
+      it "should create a new proxy with the node and the mapper" do
+        Mapper::Proxy.should_receive(:new).with(instance, node).and_return(proxy)
+        subject
+      end
+      it "should yield the proxy to the block mapped block" do
+        subject
+        @called_with.should == proxy
+      end
+    end
+    describe "from_node" do
+      let(:node) { mock :node }
+      let(:instance) { mock :klass }
+      before do
+        klass.stub(:new).and_return(instance)
+        instance.stub(:map_from)
+      end
+      subject { klass.from_node(node) }
+      it "should create a new instance of the class" do
+        klass.should_receive(:new).and_return(instance)
+        subject
+      end
+      it "should map the instance from the node" do
+        instance.should_receive(:map_from).with(node)
+        subject
+      end
+      it "should return the instance of the class" do
+        subject.should == instance
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'dozuki-mapper'

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification 
+name: dozuki-mapper
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Almond
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dozuki
+  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: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: A DSL for mapping API output to objects
+email: 
+- james@jamesalmond.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- README.markdown
+- Rakefile
+- dozuki-mapper.gemspec
+- features/date_mapping.feature
+- features/each_mapping.feature
+- features/float_mapping.feature
+- features/int_mapping.feature
+- features/node_mapping.feature
+- features/step_definitions/date_steps.rb
+- features/step_definitions/each_steps.rb
+- features/step_definitions/float_steps.rb
+- features/step_definitions/int_steps.rb
+- features/step_definitions/node_steps.rb
+- features/step_definitions/string_steps.rb
+- features/string_mapping.feature
+- features/support/env.rb
+- lib/dozuki-mapper.rb
+- lib/dozuki-mapper/proxy.rb
+- lib/dozuki-mapper/version.rb
+- spec/dozuki-mapper/proxy_spec.rb
+- spec/dozuki-mapper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/jamesalmond/dozuki-mapper
+licenses: []
+
+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: dozuki-mapper
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A DSL for mapping API output to objects
+test_files: 
+- .autotest
+- features/date_mapping.feature
+- features/each_mapping.feature
+- features/float_mapping.feature
+- features/int_mapping.feature
+- features/node_mapping.feature
+- features/step_definitions/date_steps.rb
+- features/step_definitions/each_steps.rb
+- features/step_definitions/float_steps.rb
+- features/step_definitions/int_steps.rb
+- features/step_definitions/node_steps.rb
+- features/step_definitions/string_steps.rb
+- features/string_mapping.feature
+- features/support/env.rb
+- spec/dozuki-mapper/proxy_spec.rb
+- spec/dozuki-mapper_spec.rb
+- spec/spec_helper.rb