yaoc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df536899f7147ce6f470564bab83b8d81db904d7
+  data.tar.gz: 46dbdfd57424ae671873eafaf678ce5a590588c5
+SHA512:
+  metadata.gz: f111573c5f28bfc0c2e459d50c75c8dcbdc8b221c19f833ed9738a64e05caface3ef3c620a12370c55b0a97141376f63fb35fc9e42e90f9447399807d1ade6c7
+  data.tar.gz: c33e319c2d3278aed77877fae3add31de7c0b1ddf49ea044db3a245ac9a6fa50e0831b6e689e7d5f4b8c271d9d4c6ef698f5cf9435fc3af7e581cc9f81447405

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.version.conf
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+ruby "2.1.0"
+
+# Specify your gem's dependencies in yaoc.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,23 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, all_after_pass: true ,
+              all_on_start: true do
+  
+  watch(%r{^spec/.+_spec\.rb$})
+
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/unit/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/integration/lib/#{m[1]}_spec.rb" }
+
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+
+end
+
+
+guard :bundler do
+  watch('Gemfile')
+  # Uncomment next line if your Gemfile contains the `gemspec' command.
+  watch(/^.+\.gemspec/)
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dieter Späth
+
+MIT License
+
+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/README.md

@@ -0,0 +1,54 @@
+# Yaoc
+
+Indentation of this gem is to learn and train a little ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'yaoc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yaoc
+
+## Usage
+
+Uptodate doc's look into the specs.
+
+```ruby
+
+User = Struct.new(:id, :name) do
+  def initialize(params={})
+    super()
+
+    params.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end if params
+   end
+end
+
+mapper = Yaoc::ObjectMapper.new(User).tap do |mapper|
+  mapper.add_mapping do
+    rule to: :name, from: :fullname
+    rule to: :id
+  end
+end
+
+
+user = mapper.load({id: 1, fullname: "myname" })
+
+
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/yaoc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/yaoc.rb

@@ -0,0 +1,11 @@
+require "yaoc/version"
+require 'abstract_type'
+require 'yaoc/mapping_base'
+
+Dir[File.join(File.expand_path(__dir__ ), "yaoc/strategies/*.rb")].each { |f| require f }
+
+require 'yaoc/object_mapper'
+
+module Yaoc
+  # Your code goes here...
+end

data/lib/yaoc/mapping_base.rb

@@ -0,0 +1,57 @@
+module Yaoc
+  module MappingBase
+    include AbstractType
+
+
+    def self.included(other)
+      other.extend(ClassMethods)
+    end
+
+    abstract_method :call
+
+    def converter_methods
+      self.class.converter_methods
+    end
+
+    def fetcher
+      defined?(super) ? super : :fetch
+    end
+
+    module ClassMethods
+      include AbstractType
+
+      abstract_method :converter_proc
+
+      def map(to, from, block=nil)
+        class_private_module(:Mapping).tap do |mod|
+          mod.send :define_method, "map_#{"%04d" %[converter_methods.count]}_#{from}_to_#{to}".to_sym, (block || converter_proc(to, from))
+          include mod
+        end
+      end
+
+      def converter_methods
+        class_private_module(:Mapping).instance_methods(false).sort
+      end
+
+      # inspired by Avdi Grimm, rubytapas.com 028-macros-and-modules
+      def class_private_module(name=:Mapping)
+
+        if const_defined?(name, false)
+          const_get(name)
+        else
+          new_mod = Module.new do
+            def self.to_s
+              "Mapping (#{instance_methods(false).join(', ')})"
+            end
+
+            def self.inspect
+              to_s
+            end
+          end
+          const_set(name, new_mod)
+        end
+      end
+
+    end
+  end
+end

data/lib/yaoc/object_mapper.rb

@@ -0,0 +1,71 @@
+module Yaoc
+
+  class ObjectMapper
+    attr_accessor :result_class
+
+    def initialize(result_class)
+      self.result_class = result_class
+    end
+
+    def load(fetch_able)
+      call = converter(fetch_able).call()
+
+      result_class.new(call)
+    end
+
+    def dump(object)
+      reverse_converter(object).call()
+    end
+
+    def add_mapping(&block)
+      instance_eval &block
+    end
+
+    protected
+
+    def rule(to: nil, from: to, converter: nil, reverse_converter: nil)
+      converter_class.map(to, from, converter)
+      reverse_converter_class.map(from, to, reverse_converter)
+    end
+
+    def fetcher(new_fetcher)
+      @fetcher= new_fetcher
+    end
+
+    def fetcher_method
+      @fetcher ||= :fetch
+    end
+
+    def reverse_fetcher(new_fetcher)
+      @reverse_fetcher = new_fetcher
+    end
+
+    def reverse_fetcher_method
+      @reverse_fetcher ||= :public_send
+    end
+
+    def converter(fetch_able)
+      converter_class.new(fetch_able, fetcher_method)
+    end
+
+    def converter_class
+      @converter_class ||= new_converter_class
+    end
+
+    def reverse_converter(fetch_able)
+      reverse_converter_class.new(fetch_able, reverse_fetcher_method)
+    end
+
+    def reverse_converter_class
+      @reverse_converter_class ||= new_converter_class
+    end
+
+    def new_converter_class
+      Struct.new(:to_convert, :fetcher) do
+        include MappingBase
+        include Strategies::ToHashMapping
+      end
+    end
+
+  end
+end

data/lib/yaoc/strategies/to_array_mapping.rb

@@ -0,0 +1,25 @@
+module Yaoc
+  module Strategies
+    module ToArrayMapping
+      def self.included(other)
+        other.extend(ClassMethods)
+      end
+
+      def call
+        [].tap do |result|
+          converter_methods.each do |method_name|
+            self.public_send(method_name, to_convert, result)
+          end
+        end
+      end
+
+      module ClassMethods
+        def converter_proc(to, from)
+          -> (to_convert, result){
+            result[to] = to_convert.public_send(fetcher, from)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/yaoc/strategies/to_hash_mapping.rb

@@ -0,0 +1,23 @@
+module Yaoc
+  module Strategies
+    module ToHashMapping
+      def self.included(other)
+        other.extend(ClassMethods)
+      end
+
+      def call
+        converter_methods.reduce({}) do |result, method_name|
+          self.public_send(method_name, to_convert, result)
+        end
+      end
+
+      module ClassMethods
+        def converter_proc(to, from)
+          -> (to_convert, result){
+            result.merge({to => to_convert.public_send(fetcher, from)})
+          }
+        end
+      end
+    end
+  end
+end

data/lib/yaoc/version.rb

@@ -0,0 +1,3 @@
+module Yaoc
+  VERSION = "0.0.1"
+end

data/spec/acceptance/map_objects_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+feature "Map objects", %q{
+   In order to map object
+   as a lib user
+   I want to map object from an input object to an output object and reverse
+} do
+
+  given(:mapper){
+    Yaoc::ObjectMapper.new(result_object_class).tap do |mapper|
+      mapper.add_mapping do
+        fetcher :[]
+        reverse_fetcher :public_send
+        rule to: :name,
+             converter: ->(source, result){ result.merge({name:  "#{source[:name]} Hello World"}) },
+             reverse_converter: ->(source, result){ result.merge({name: source.name}) }
+        rule to: :role, from: :fullrolename
+        rule to: :id
+      end
+    end
+  }
+
+  given(:result_object_class) {
+    Struct.new(:id, :name, :role) do
+      include Equalizer.new(:id, :name, :role)
+
+      def initialize(params={})
+        super()
+
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+      end
+
+    end
+  }
+
+  given(:input_hash){
+    {id: 1, name: "paul", fullrolename: "admin"}
+  }
+
+  given(:result_object){
+    result_object_class.new({id: 1, name: "paul", role: "admin"})
+  }
+
+  scenario "creates an result object from an input_object" do
+    result_object.name += " Hello World"
+
+    expect(mapper.load(input_hash)).to eq result_object
+  end
+
+  scenario "dumps an result object as hash" do
+    expect(mapper.dump(result_object)).to eq input_hash
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+Bundler.require(:development)
+
+require 'yaoc'
+
+Dir[File.join(File.expand_path(__dir__ ), "support/**/*.rb")].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/feature.rb

@@ -0,0 +1,30 @@
+#
+# taken from https://github.com/jnicklas/capybara/blob/master/lib/capybara/rspec/features.rb
+#
+module Capybara
+  module Features
+    def self.included(base)
+      base.instance_eval do
+        alias :background :before
+        alias :scenario :it
+        alias :xscenario :xit
+        alias :given :let
+        alias :given! :let!
+        alias :feature :describe
+      end
+    end
+  end
+end
+
+
+def self.feature(*args, &block)
+  options = if args.last.is_a?(Hash) then args.pop else {} end
+  options[:capybara_feature] = true
+  options[:type] = :feature
+  options[:caller] ||= caller
+  args.push(options)
+
+  describe(*args, &block)
+end
+
+RSpec.configuration.include Capybara::Features, :capybara_feature => true

data/spec/unit/lib/yaoc/mapping_base_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Yaoc::MappingBase do
+  subject{
+    Struct.new(:to_convert) do
+      include Yaoc::MappingBase
+
+      def self.converter_proc(to, from)
+        -> (to_convert, result){
+          [to, from, to_convert, result]
+        }
+      end
+
+      def call
+        result = :my_result
+        converter_methods.map do |method_name|
+          self.public_send(method_name, to_convert, result)
+        end
+      end
+
+    end
+  }
+
+  describe ".map" do
+
+    it "creates a bunch of mapping methods" do
+      subject.map(:foo, :bar)
+      subject.map(:bar, :foo)
+
+      expect(subject.new(:my_to_convert).call()).to eq [[:foo, :bar, :my_to_convert, :my_result],
+                                                        [:bar, :foo, :my_to_convert, :my_result]]
+    end
+
+    it "uses my converter when provided" do
+      subject.map(:bar, :foo, ->(*){})
+
+      expect(subject.new(:my_to_convert).call()).to eq [nil]
+    end
+  end
+
+  describe "#converter_methods" do
+    it "preserves method order" do
+      subject.map(0, 1, ->(*){})
+      subject.map(1, :a, ->(*){})
+
+      expect(subject.converter_methods).to eq [:map_0000_1_to_0, :map_0001_a_to_1]
+    end
+  end
+
+  describe "#fetcher" do
+    let(:subject_with_fetcher){
+      Struct.new(:to_convert) do
+        include Yaoc::MappingBase
+
+        def self.create_block(to, from)
+          -> (to_convert, result){
+            [to, from, to_convert, result]
+          }
+        end
+
+        def call
+          result = nil
+
+          converter_methods.map do |method_name|
+            self.public_send(method_name, to_convert, result)
+          end
+        end
+
+        def fetcher
+          "my_fetcher"
+        end
+
+      end
+    }
+
+    it "uses in class declared fetcher" do
+      expect(subject_with_fetcher.new().fetcher).to eq "my_fetcher"
+    end
+
+    it "uses build in fetcher without a fetcher definition" do
+      expect(subject.new().fetcher).to eq :fetch
+    end
+
+  end
+
+end

data/spec/unit/lib/yaoc/object_mapper_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe Yaoc::ObjectMapper do
+  subject{
+    Yaoc::ObjectMapper.new(Struct.new(:id, :name)).tap{|mapper|
+      mapper.stub(:converter_class).and_return(converter_class)
+      mapper.stub(:reverse_converter_class).and_return(reverse_converter_class)
+    }
+  }
+
+  let(:converter_class){
+    double("converter_class", map: nil, new: converter)
+  }
+
+  let(:reverse_converter_class){
+    double("reverse_converter_class", map: nil, new: reverse_converter)
+  }
+
+  let(:converter){
+    double("converter", call: nil)
+  }
+
+  let(:reverse_converter){
+    double("reverse_converter", call: nil)
+  }
+
+  describe "#add_mapping" do
+
+    it "creates a mapper" do
+
+      expect(converter_class).to receive(:map).with(:id, :id2, :some_proc)
+      subject.add_mapping do
+        rule to: :id,
+             from: :id2,
+             converter: :some_proc,
+             reverse_converter: :some_reverse_proc
+      end
+
+    end
+
+    it "creates a revers mapper" do
+
+      expect(reverse_converter_class).to receive(:map).with(:id2, :id, :some_reverse_proc)
+
+      subject.add_mapping do
+        rule to: :id,
+             from: :id2,
+             converter: :some_proc,
+             reverse_converter: :some_reverse_proc
+      end
+
+    end
+
+    it "uses defaults" do
+      expect(converter_class).to receive(:map).with(:id, :id, nil)
+      expect(reverse_converter_class).to receive(:map).with(:id, :id, nil)
+
+      subject.add_mapping do
+        rule to: :id
+      end
+
+    end
+
+    it "allows to set a fetcher" do
+      subject.add_mapping do
+        fetcher :public_send
+        rule to: :id
+      end
+
+      expect(subject.send :fetcher_method).to eq(:public_send)
+    end
+
+    it "allows to set a reverse_fetcher" do
+      subject.add_mapping do
+        reverse_fetcher :fetch
+        rule to: :id
+      end
+
+      expect(subject.send :reverse_fetcher_method).to eq(:fetch)
+    end
+  end
+
+  describe "#load" do
+    it "creates an object of result_class kind" do
+      data = {id: 1}
+
+      converter.stub(call: data)
+
+      expect(subject.result_class).to receive(:new).with(data)
+
+      subject.load(data)
+    end
+  end
+
+  describe "#dump" do
+    it "dump the object as a hash" do
+      obj = subject.result_class.new 1, "paul"
+
+      expect(reverse_converter).to receive(:call)
+
+      subject.dump(obj)
+    end
+  end
+
+end

data/spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Yaoc::Strategies::ToArrayMapping do
+  subject{
+    Struct.new(:to_convert) do
+      include Yaoc::MappingBase
+      include Yaoc::Strategies::ToArrayMapping
+    end
+  }
+
+  let(:mapper){
+    subject.new(source_object)
+  }
+
+  let(:source_object){
+    {id: 1, name: "paul"}
+  }
+
+  let(:expected_array){
+    [1, "paul"]
+  }
+
+  describe ".call" do
+
+    it "creates a hash from a object" do
+      subject.map(0, :id)
+      subject.map(1, :name)
+
+      expect(mapper.call).to eq(expected_array)
+    end
+
+
+    it "uses my converter proc" do
+      subject.map(0, :id)
+      subject.map(3, :fullname, ->(source, result){ result[3] = "#{source.fetch(:name)} Hello World" })
+
+      ext_expectation = expected_array.clone
+      ext_expectation[3] = "#{ext_expectation[1]} Hello World"
+      ext_expectation[1] = nil
+      ext_expectation[2] = nil
+
+      expect(mapper.call).to eq(ext_expectation)
+    end
+
+    context "changed fetcher method" do
+      let(:source_object){
+        Struct.new(:id, :name).new(1, "paul")
+      }
+
+      it "uses custom fetcher methods" do
+        subject.map(0, :id)
+        subject.map(1, :name)
+
+        def mapper.fetcher
+          :public_send
+        end
+
+        expect(mapper.call).to eq(expected_array)
+      end
+
+      it "works with arrays" do
+        subject.map(1, 0)
+        subject.map(0, 1)
+
+        def mapper.fetcher
+          :[]
+        end
+
+        mapper.to_convert = [1, "paul"]
+
+        expect(mapper.call).to eq(expected_array.reverse)
+      end
+    end
+
+  end
+
+end

data/spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe Yaoc::Strategies::ToHashMapping do
+  subject{
+    Struct.new(:to_convert) do
+      include Yaoc::MappingBase
+      include Yaoc::Strategies::ToHashMapping
+    end
+  }
+
+  let(:mapper){
+    subject.new(source_object)
+  }
+
+  let(:source_object){
+    {id: 1, name: "paul"}
+  }
+
+  let(:expected_hash){
+    {id: 1, name: "paul"}
+  }
+
+  describe ".call" do
+
+    it "creates a hash from a object" do
+      subject.map(:id, :id)
+      subject.map(:name, :name)
+
+      expect(mapper.call).to eq(expected_hash)
+    end
+
+    it "renames attributes" do
+      subject.map(:id, :id)
+      subject.map(:fullname, :name)
+
+      renamed_expectation = expected_hash.clone
+      renamed_expectation[:fullname] = renamed_expectation.delete :name
+
+      expect(mapper.call).to eq(renamed_expectation)
+    end
+
+    it "uses my converter proc" do
+      subject.map(:id, :id)
+      subject.map(:name, :fullname, ->(source, result){ result.merge({name: source.fetch(:name) + " Hello World"}) })
+
+      ext_expectation = expected_hash.clone
+      ext_expectation[:name] += " Hello World"
+
+      expect(mapper.call).to eq(ext_expectation)
+    end
+
+    context "changed fetcher method" do
+      let(:source_object){
+        Struct.new(:id, :name).new(1, "paul")
+      }
+
+      it "uses custom fetcher methods" do
+        subject.map(:id, :id)
+        subject.map(:name, :name)
+
+        def mapper.fetcher
+          :public_send
+        end
+
+        expect(mapper.call).to eq(expected_hash)
+      end
+
+      it "works with arrays" do
+        subject.map(:id, 0)
+        subject.map(:name, 1)
+
+        def mapper.fetcher
+          :[]
+        end
+
+        mapper.to_convert = [1, "paul"]
+
+        expect(mapper.call).to eq(expected_hash)
+      end
+    end
+
+  end
+
+end

data/yaoc.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yaoc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "yaoc"
+  spec.version       = Yaoc::VERSION
+  spec.authors       = ["Dieter Späth"]
+  spec.email         = ["dieter.spaeth@gmx.de"]
+  spec.summary       = %q{Yet another object converter}
+  spec.description   = %q{Yet another object converter}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_runtime_dependency "abstract_type", '~> 0.0.7'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec", "2.99.0.beta1"
+  # show nicely how many specs have to be run
+  spec.add_development_dependency "fuubar"
+  # extended console
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency 'pry-remote'
+
+  # automatic execute tasks on file changes
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'guard-bundler'
+  spec.add_development_dependency 'rb-fsevent'
+
+  # https://github.com/pry/pry-stack_explorer
+  spec.add_development_dependency 'pry-stack_explorer'
+  # https://github.com/nixme/pry-debugger
+  spec.add_development_dependency 'pry-debugger'
+
+  # https://github.com/dkubb/equalizer
+  spec.add_development_dependency 'equalizer'
+end

metadata

@@ -0,0 +1,267 @@
+--- !ruby/object:Gem::Specification
+name: yaoc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dieter Späth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abstract_type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.99.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.99.0.beta1
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yet another object converter
+email:
+- dieter.spaeth@gmx.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/yaoc.rb
+- lib/yaoc/mapping_base.rb
+- lib/yaoc/object_mapper.rb
+- lib/yaoc/strategies/to_array_mapping.rb
+- lib/yaoc/strategies/to_hash_mapping.rb
+- lib/yaoc/version.rb
+- spec/acceptance/map_objects_spec.rb
+- spec/spec_helper.rb
+- spec/support/feature.rb
+- spec/unit/lib/yaoc/mapping_base_spec.rb
+- spec/unit/lib/yaoc/object_mapper_spec.rb
+- spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb
+- spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb
+- yaoc.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Yet another object converter
+test_files:
+- spec/acceptance/map_objects_spec.rb
+- spec/spec_helper.rb
+- spec/support/feature.rb
+- spec/unit/lib/yaoc/mapping_base_spec.rb
+- spec/unit/lib/yaoc/object_mapper_spec.rb
+- spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb
+- spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb