two-way-mapper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcbb9ddd6ab08af20ca40eec44b53bf3ac2109e9
+  data.tar.gz: 914738db9bb087708fc3603c1297738137d6226e
+SHA512:
+  metadata.gz: 9aad37686d32b6c02c163addb8d1a99bcdbbb39c5e5e770de7978825c354051872e114f4468c415b61d1574e83f7ef633bdb008c92d4bdd269bafa841cca000c
+  data.tar.gz: 24b29a8195033c489f9314620e5191c5be144c4d6b4bf15fb4280039ac686117569fabefa293d31081095beca0b7508324224006d1239328b7aa9ec8b77adc3e

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,16 @@
+before_install:
+  - gem install bundler
+
+notifications:
+  email: false
+
+rvm:
+ - 1.9.3
+ - 2.0.0
+ - 2.1.1
+ - 2.1.2
+ - ruby-head
+ - jruby
+
+gemfile:
+  - Gemfile.ci

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'guard-rspec', '~> 4.3', require: false
+gem 'byebug'

data/Gemfile.ci

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/two_way_mapper/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')             { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tima Maslyuchenko
+
+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,79 @@
+# Two Way Mapper [![Build Status](https://travis-ci.org/timsly/two-way-mapper.svg?branch=master)](https://travis-ci.org/timsly/two-way-mapper)
+
+Two way data mapping
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'two-way-mapper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install two-way-mapper
+
+## Usage
+
+First, we need to define mapping
+
+```ruby
+TwoWayMapper.register :customer do |mapping|
+  mapping.left :object # set left plugin to object
+  mapping.right :hash, stringify_keys: true # set right plugin to hash
+
+  # define transformation rules
+  mapping.rule 'first_name', 'FirstName'
+  mapping.rule 'last_name', 'LastName'
+  mapping.rule 'gender', 'sex',
+    map: {
+      'M' => 'male',
+      'F' => 'female'
+    }, default: ''
+end
+```
+
+Once mapping is defined we can convert one object to another and vice versa
+
+```ruby
+Customer = Struct.new :first_name, :last_name, :gender
+
+customer = Customer.new
+api_response = { 'FirstName' => 'Evee', 'LastName' => 'Fjord', 'sex' => 'female' }
+
+TwoWayMapper[:customer].from_right_to_left customer, api_response
+puts customer.first_name # => 'Evee'
+puts customer.last_name # => 'Fjord'
+puts customer.gender # => 'F'
+
+request_data = {}
+
+another_customer = Customer.new
+another_customer.first_name = 'Step'
+another_customer.last_name = 'Bander'
+another_customer.gender = 'M'
+
+TwoWayMapper[:customer].from_left_to_right another_customer, request_data
+puts request_data # => { 'FirstName' => 'Step', 'LastName' => 'Bander', sex: 'male' }
+```
+
+On rails, you can put all mappings into `app/mappings` folder
+
+### Available plugins
+
+* hash
+* object
+* active_record (same as object, but for keys like `user.email`, it will try to build `user` before updating `email` on write)
+
+## Contributing
+
+1. Fork it
+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,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/two-way-mapper.rb

@@ -0,0 +1 @@
+require 'two_way_mapper'

data/lib/two_way_mapper.rb

@@ -0,0 +1,24 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/inflector'
+
+module TwoWayMapper
+  extend ActiveSupport::Autoload
+
+  autoload :Map
+  autoload :Mapping
+  autoload :Rule
+  autoload :Node
+  autoload :Tools
+
+  class << self
+    def map
+      @map ||= Map.new
+    end
+
+    delegate :register, to: :map
+    delegate :[],       to: :map
+  end
+end
+
+require 'two_way_mapper/railtie' if defined? Rails

data/lib/two_way_mapper/map.rb

@@ -0,0 +1,15 @@
+module TwoWayMapper
+  class Map
+    delegate :[], to: :@maps
+
+    def initialize
+      @maps = {}
+    end
+
+    def register(name)
+      mapping = TwoWayMapper::Mapping.new
+      yield mapping if block_given?
+      @maps[name.to_sym] = mapping
+    end
+  end
+end

data/lib/two_way_mapper/mapping.rb

@@ -0,0 +1,56 @@
+module TwoWayMapper
+  class Mapping
+    attr_reader :rules, :left_class, :left_options, :right_class, :right_options
+
+    def initialize
+      @rules = []
+    end
+
+    [:left, :right].each do |method|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{method}(plugin, options = {})
+          @#{method}_class = node_class plugin
+          @#{method}_options = options
+        end
+      CODE
+    end
+
+    def node_class(plugin)
+      TwoWayMapper::Node.const_get plugin.to_s.camelize
+    rescue NameError
+      raise NameError, 'Cannot find node'
+    end
+
+    def rule(left_selector, right_selector = {}, options = {})
+      raise 'You need to set left before calling rule' unless left_class
+      raise 'You need to set right before calling rule' unless right_class
+
+      opt = options.dup
+      left_opt = opt.delete(:left) || {}
+      right_opt = opt.delete(:right) || {}
+
+      if left_selector.is_a?(Hash)
+        raise ArgumentError if left_selector.count < 2
+        opt = left_selector
+        left_selector = opt.keys.first
+        left_opt.merge! opt.delete left_selector
+        right_selector = opt.keys.first
+        right_opt.merge! opt.delete right_selector
+      end
+
+      left = left_class.new left_selector, left_options.merge(left_opt)
+      right = right_class.new right_selector, right_options.merge(right_opt)
+
+      @rules << Rule.new(left, right, opt)
+    end
+
+    { left: :right, right: :left }.each do |from, to|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def from_#{from}_to_#{to}(left_obj, right_obj)
+          rules.each { |r| r.from_#{from}_to_#{to} left_obj, right_obj }
+          #{to}_obj
+        end
+      CODE
+    end
+  end
+end

data/lib/two_way_mapper/node.rb

@@ -0,0 +1,10 @@
+module TwoWayMapper
+  module Node
+    extend ActiveSupport::Autoload
+
+    autoload :Abstract,     'two_way_mapper/node/abstract'
+    autoload :Hash,         'two_way_mapper/node/hash'
+    autoload :Object,       'two_way_mapper/node/object'
+    autoload :ActiveRecord, 'two_way_mapper/node/active_record'
+  end
+end

data/lib/two_way_mapper/node/abstract.rb

@@ -0,0 +1,61 @@
+module TwoWayMapper
+  module Node
+    class Abstract
+      DIVIDER = '.'
+
+      attr_accessor :selector, :options
+
+      def initialize(selector, options = {})
+        @selector, @options = selector, options
+      end
+
+      def keys(&block)
+        unless block
+          block = options[:stringify_keys] ? :to_s : :to_sym
+          block = block.to_proc
+        end
+        selector.split(DIVIDER).map &block
+      end
+
+      def read(source)
+        rewind_forward(source) { |obj, key| return nil }
+      end
+
+      def write(obj, value)
+      end
+
+      def writable?(current_value, new_value)
+        !options[:write_if] ||
+        !options[:write_if].respond_to?(:call) ||
+        options[:write_if].call(current_value, new_value)
+      end
+
+      private
+
+      def rewind_forward(obj, margin = 0)
+        to = -(1 + margin.to_i.abs)
+        keys[0..to].each do |key|
+          unless rewind_to?(obj, key)
+            if block_given?
+              yield obj, key
+            else
+              create_node obj, key
+            end
+          end
+          obj = next_key obj, key
+        end
+
+        obj
+      end
+
+      def rewind_to?(obj, key)
+      end
+
+      def create_node(obj, key)
+      end
+
+      def next_key(obj, key)
+      end
+    end
+  end
+end

data/lib/two_way_mapper/node/active_record.rb

@@ -0,0 +1,13 @@
+module TwoWayMapper
+  module Node
+    class ActiveRecord < Object
+      def rewind_to?(obj, key)
+        super && obj.send(key)
+      end
+
+      def create_node(obj, key)
+        obj.send "build_#{key}"
+      end
+    end
+  end
+end

data/lib/two_way_mapper/node/hash.rb

@@ -0,0 +1,25 @@
+module TwoWayMapper
+  module Node
+    class Hash < Abstract
+      def write(source, value)
+        rewinded = rewind_forward source, 1
+
+        rewinded[keys.last] = value if writable? rewinded[keys.last], value
+      end
+
+      private
+
+      def rewind_to?(obj, key)
+        obj.is_a?(::Hash) && obj.key?(key)
+      end
+
+      def create_node(obj, key)
+        obj[key] = {}
+      end
+
+      def next_key(obj, key)
+        obj[key]
+      end
+    end
+  end
+end

data/lib/two_way_mapper/node/object.rb

@@ -0,0 +1,24 @@
+module TwoWayMapper
+  module Node
+    class Object < Abstract
+      def write(source, value)
+        rewinded = rewind_forward source, 1
+
+        rewinded.send "#{keys.last}=", value if writable? rewinded.send(keys.last), value
+      end
+
+      private
+
+      def rewind_to?(obj, key)
+        obj.respond_to? key
+      end
+
+      def create_node(obj, key)
+      end
+
+      def next_key(obj, key)
+        obj.send key
+      end
+    end
+  end
+end

data/lib/two_way_mapper/railtie.rb

@@ -0,0 +1,10 @@
+require 'rails'
+
+module TwoWayMapper
+  class Railtie < Rails::Railtie
+    initializer "two_way_mapper.set_load_path" do |app|
+      path = Rails.root.join('app', 'mappings', '*.rb').to_s
+      Dir[path].each{ |file| load file }
+    end
+  end
+end

data/lib/two_way_mapper/rule.rb

@@ -0,0 +1,39 @@
+module TwoWayMapper
+  class Rule
+    attr_reader :left, :right
+
+    def initialize(left, right, opt = {})
+      @left = left
+      @right = right
+      @options = opt
+    end
+
+    { left: :right, right: :left }.each do |from, to|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def from_#{from}_to_#{to}(left_obj, right_obj)
+          value = #{from}.read #{from}_obj
+          value = map_value value, #{(from == :left).inspect}
+          if @options[:on_#{from}_to_#{to}].respond_to? :call
+            value = @options[:on_#{from}_to_#{to}].call value
+          end
+          #{to}.write #{to}_obj, value
+
+          #{to}_obj
+        end
+      CODE
+    end
+
+    private
+
+    def map_value(value, left_to_right = true)
+      map = @options[:map]
+      if map && map.is_a?(Hash)
+        map = map.invert unless left_to_right
+        default_key = "default_#{left_to_right ? 'left' : 'right'}".to_sym
+        value = map[value] || @options[default_key] || @options[:default]
+      else
+        value
+      end
+    end
+  end
+end

data/lib/two_way_mapper/tools.rb

@@ -0,0 +1,13 @@
+module TwoWayMapper
+  module Tools
+    class << self
+      def first_item_from_hash!(hash)
+        raise ArgumentError unless hash.is_a?(Hash)
+        raise ArgumentError unless first = hash.first
+
+        hash.delete first[0]
+        first
+      end
+    end
+  end
+end

data/lib/two_way_mapper/version.rb

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

data/spec/map_spec.rb

@@ -0,0 +1,12 @@
+describe TwoWayMapper::Map do
+  describe '#register' do
+    let(:map) { TwoWayMapper::Map.new }
+
+    it 'should register new mapping' do
+      map.register :import
+
+      mapping = map[:import]
+      expect(mapping).to be_instance_of TwoWayMapper::Mapping
+    end
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,96 @@
+describe TwoWayMapper::Mapping do
+  [:left, :right].each do |method|
+    describe "##{method}" do
+      let(:mapping) { TwoWayMapper::Mapping.new }
+
+      it "should set #{method} with options" do
+        mapping.send method, :object, opt1: ''
+
+        expect(mapping.send("#{method}_class")).to eql TwoWayMapper::Node::Object
+        expect(mapping.send("#{method}_options")).to include opt1: ''
+      end
+    end
+  end
+
+  describe '#rule' do
+    let(:mapping) { TwoWayMapper::Mapping.new }
+    before :each do
+      mapping.left :object
+      mapping.right :hash
+    end
+
+    context 'left and right validation' do
+      let(:mapping_without_both) { TwoWayMapper::Mapping.new }
+      let(:mapping_without_left) { TwoWayMapper::Mapping.new }
+      let(:mapping_without_right) { TwoWayMapper::Mapping.new }
+      before :each do
+        mapping_without_left.right :hash
+        mapping_without_right.left :hash
+      end
+
+      it 'should raise error when no left or right nodes' do
+        expect{mapping_without_left.rule 'key', 'key'}.to raise_error
+        expect{mapping_without_right.rule 'key', 'key'}.to raise_error
+        expect{mapping_without_both.rule 'key', 'key'}.to raise_error
+      end
+    end
+
+    it 'should add item to rules hash' do
+      expect{mapping.rule 'key1', 'Key1'}.to change{mapping.rules.count}.from(0).to(1)
+
+      rule = mapping.rules.first
+      expect(rule).to be_instance_of TwoWayMapper::Rule
+      expect(rule.left.selector).to eql 'key1'
+      expect(rule.right.selector).to eql 'Key1'
+    end
+
+    it 'should allow to pass hash' do
+      expect{mapping.rule 'key1' => { opt1: 'val' }}.to raise_error
+
+      mapping.rule 'key1' => { opt1: 'val' }, 'Key2' => {}
+      rule = mapping.rules.first
+
+      expect(rule.left.selector).to eql 'key1'
+      expect(rule.right.selector).to eql 'Key2'
+    end
+
+    it 'should allow to pass left abd right options ' do
+      mapping.rule 'key1', 'Key2', left: { opt1: 'val' }, right: { opt2: 'val' }
+      rule = mapping.rules.first
+
+      expect(rule.left.options).to include opt1: 'val'
+      expect(rule.right.options).to include opt2: 'val'
+    end
+
+    it 'should work with options copy' do
+      options = { left: { opt1: 'val' }, right: { opt2: 'val' } }
+      mapping.rule 'key1', 'Key2', options
+
+      expect(options).to eql left: { opt1: 'val' }, right: { opt2: 'val' }
+    end
+  end
+
+  context 'convertion methods' do
+    let(:mapping) { TwoWayMapper::Mapping.new }
+    let(:rule1) { double from_left_to_right: nil, from_right_to_left: nil }
+    let(:rule2) { double from_left_to_right: nil, from_right_to_left: nil }
+    let(:left_obj) { double() }
+    let(:right_obj) { double() }
+    before :each do
+      mapping.left :object
+      mapping.right :hash
+      allow(mapping).to receive(:rules).and_return [rule1, rule2]
+    end
+
+    [:from_left_to_right, :from_right_to_left].each do |method|
+      describe "##{method}" do
+        it 'should proxy to all rules' do
+          expect(rule1).to receive(method).with left_obj, right_obj
+          expect(rule2).to receive(method).with left_obj, right_obj
+
+          mapping.send method, left_obj, right_obj
+        end
+      end
+    end
+  end
+end

data/spec/node/abstract_spec.rb

@@ -0,0 +1,23 @@
+describe TwoWayMapper::Node::Abstract do
+  describe '#keys' do
+    subject { TwoWayMapper::Node::Abstract.new 'key1.key11.key111' }
+
+    its(:keys) { should eql [:key1, :key11, :key111] }
+  end
+
+  describe 'writable?' do
+    it 'should be truthy if write_if options not set' do
+      node = TwoWayMapper::Node::Abstract.new 'key1.key11.key111'
+
+      expect(node).to be_writable 'current', 'new'
+    end
+
+    it 'should be truthy if write_if option set' do
+      node = TwoWayMapper::Node::Abstract.new 'key1.key11.key111', write_if: ->(c, n) { c == 'current' || n == 'new' }
+
+      expect(node).to be_writable 'current', 'new1'
+      expect(node).to be_writable 'current1', 'new'
+      expect(node).not_to be_writable 'current1', 'new1'
+    end
+  end
+end

data/spec/node/active_record_spec.rb

@@ -0,0 +1,31 @@
+describe TwoWayMapper::Node::ActiveRecord do
+  let(:node) { TwoWayMapper::Node::ActiveRecord.new 'user.email' }
+
+  describe '#write' do
+    it 'should try to build before write' do
+      user = double(email: '')
+      obj = double()
+      allow(obj).to receive :build_user do
+        allow(obj).to receive(:user).and_return user
+      end
+
+      expect(obj).to receive :build_user
+      expect(user).to receive(:email=).with 'test@email.com'
+
+      node.write obj, 'test@email.com'
+    end
+
+    it 'should try to build even if respond_to but obj itself is nil' do
+      user = double(email: '')
+      obj = double(user: nil)
+      allow(obj).to receive :build_user do
+        allow(obj).to receive(:user).and_return user
+      end
+
+      expect(obj).to receive :build_user
+      expect(user).to receive(:email=).with 'test@email.com'
+
+      node.write obj, 'test@email.com'
+    end
+  end
+end

data/spec/node/hash_spec.rb

@@ -0,0 +1,68 @@
+describe TwoWayMapper::Node::Hash do
+  context 'normal keys' do
+    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11.key111' }
+
+    describe '#read' do
+      it 'should return nil when path is not avaiable' do
+        expect(node.read({})).to be_nil
+        expect(node.read(key1: 1)).to be_nil
+        expect(node.read(key1: { key11: 1 })).to be_nil
+      end
+
+      it 'should read from passed object' do
+        expect(node.read(key1: { key11: { key111: 'value' } })).to eql 'value'
+      end
+    end
+
+    describe '#write' do
+      let(:obj) { {} }
+
+      it 'should write by path' do
+        node.write obj, 'value'
+        expect(obj).to eql key1: { key11: { key111: 'value' } }
+      end
+    end
+  end
+
+  context 'string keys' do
+    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11.key111', stringify_keys: true }
+
+    describe '#read' do
+      it 'should return nil when path is not avaiable' do
+        expect(node.read({})).to be_nil
+        expect(node.read('key1' => 1)).to be_nil
+        expect(node.read('key1' => { 'key11' => 1 })).to be_nil
+      end
+
+      it 'should read from passed object' do
+        expect(node.read('key1' => { 'key11' => { 'key111' => 'value' } })).to eql 'value'
+      end
+    end
+
+    describe '#write' do
+      let(:obj) { {} }
+
+      it 'should write by path' do
+        node.write obj, 'value'
+        expect(obj).to eql 'key1' => { 'key11' => { 'key111' => 'value' } }
+      end
+    end
+  end
+
+  context 'write_if option' do
+    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11', write_if: ->(c, n) { c.empty? || n == 'value1' } }
+    let(:writable_obj1) { { key1: { key11: '' } } }
+    let(:writable_obj2) { { key1: { key11: 'smth' } } }
+    let(:not_writable_obj) { { key1: { key11: 'smth' } } }
+
+    it 'should not write if such option passed and it satisfy condition' do
+      node.write writable_obj1, 'value'
+      node.write writable_obj2, 'value1'
+      node.write not_writable_obj, 'value'
+
+      expect(writable_obj1[:key1][:key11]).to eql 'value'
+      expect(writable_obj2[:key1][:key11]).to eql 'value1'
+      expect(not_writable_obj[:key1][:key11]).not_to eql 'value'
+    end
+  end
+end

data/spec/node/object_spec.rb

@@ -0,0 +1,43 @@
+describe TwoWayMapper::Node::Object do
+  let(:node) { TwoWayMapper::Node::Object.new 'key1.key11.key111' }
+
+  describe '#read' do
+    it 'should return nil when path is not avaiable' do
+      expect(node.read(OpenStruct.new)).to be_nil
+      expect(node.read(OpenStruct.new(key1: 1))).to be_nil
+      expect(node.read(OpenStruct.new(key1: OpenStruct.new(key11: 1)))).to be_nil
+    end
+
+    it 'should read from passed object' do
+      obj = OpenStruct.new(key1: OpenStruct.new(key11: OpenStruct.new(key111: 'value')))
+
+      expect(node.read(obj)).to eql 'value'
+    end
+  end
+
+  describe '#write' do
+    let(:obj) { OpenStruct.new(key1: OpenStruct.new(key11: OpenStruct.new(key111: nil))) }
+
+    it 'should write by path' do
+      node.write obj, 'value'
+      expect(obj.key1.key11.key111).to eql 'value'
+    end
+  end
+
+  context 'write_if option' do
+    let(:node) { TwoWayMapper::Node::Object.new 'key', write_if: ->(c, n) { c.empty? || n == 'value1'} }
+    let(:writable_obj1) { OpenStruct.new key: '' }
+    let(:writable_obj2) { OpenStruct.new key: 'smth' }
+    let(:not_writable_obj) { OpenStruct.new key: 'smth' }
+
+    it 'should not write if such option passed and it satisfy condition' do
+      node.write writable_obj1, 'value'
+      node.write writable_obj2, 'value1'
+      node.write not_writable_obj, 'value'
+
+      expect(writable_obj1.key).to eql 'value'
+      expect(writable_obj2.key).to eql 'value1'
+      expect(not_writable_obj.key).not_to eql 'value'
+    end
+  end
+end

data/spec/rule_spec.rb

@@ -0,0 +1,128 @@
+describe TwoWayMapper::Rule do
+  context 'transformation methods' do
+    let(:left_node) { TwoWayMapper::Node::Object.new 'key1' }
+    let(:right_node) { TwoWayMapper::Node::Hash.new 'Kk.Key1' }
+    let(:left_object) { OpenStruct.new }
+    let(:map) { { 'value' => 'VALUE' } }
+
+    context 'without options' do
+      let(:rule) { TwoWayMapper::Rule.new left_node, right_node }
+
+      describe '#from_left_to_right' do
+        it 'should read from left node and write to right node' do
+          left_object.key1 = 'value1'
+          right_object = {}
+          rule.from_left_to_right left_object, right_object
+
+          expect(right_object).to eql Kk: { Key1: 'value1' }
+        end
+      end
+
+      describe '#from_right_to_left' do
+        it 'should read from right node and write to left node' do
+          left_object.key1 = nil
+          right_object = { Kk: { Key1: 'value1' } }
+          rule.from_right_to_left left_object, right_object
+
+          expect(left_object.key1).to eql 'value1'
+        end
+      end
+    end
+
+    context 'with map option' do
+      let(:rule) { TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found' }
+
+      describe '#from_left_to_right' do
+        it 'should read from left node and write to right node' do
+          left_object.key1 = 'value'
+          right_object = {}
+          rule.from_left_to_right left_object, right_object
+
+          expect(right_object).to eql Kk: { Key1: 'VALUE' }
+        end
+      end
+
+      describe '#from_right_to_left' do
+        it 'should read from right node and write to left node' do
+          left_object.key1 = nil
+          right_object = { Kk: { Key1: 'VALUE' } }
+          rule.from_right_to_left left_object, right_object
+
+          expect(left_object.key1).to eql 'value'
+        end
+      end
+    end
+
+    context 'with default option' do
+      describe '#from_left_to_right' do
+        it 'should return default value if not found' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found'
+
+          left_object.key1 = 'value1'
+          right_object = {}
+          rule.from_left_to_right left_object, right_object
+
+          expect(right_object).to eql Kk: { Key1: 'not found' }
+        end
+
+        it 'should return use default_left if present and value not found' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found', default_left: 'not found on left', default_right: 'not found on right'
+
+          left_object.key1 = 'value1'
+          right_object = {}
+          rule.from_left_to_right left_object, right_object
+
+          expect(right_object).to eql Kk: { Key1: 'not found on left' }
+        end
+      end
+
+      describe '#from_right_to_left' do
+        it 'should return default value if not found' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found'
+
+          left_object.key1 = nil
+          right_object = { Kk: { Key1: 'VALUE1' } }
+          rule.from_right_to_left left_object, right_object
+
+          expect(left_object.key1).to eql 'not found'
+        end
+
+        it 'should return use default_right if present and value not found' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found', default_left: 'not found on left', default_right: 'not found on right'
+
+          left_object.key1 = nil
+          right_object = { Kk: { Key1: 'VALUE1' } }
+          rule.from_right_to_left left_object, right_object
+
+          expect(left_object.key1).to eql 'not found on right'
+        end
+      end
+    end
+
+    describe 'with callback option' do
+      describe 'on_left_to_right' do
+        it 'should transform value if such options passed' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, on_left_to_right: ->(v) { v.upcase }
+
+          left_object.key1 = 'value1'
+          right_object = {}
+          rule.from_left_to_right left_object, right_object
+
+          expect(right_object).to eql Kk: { Key1: 'VALUE1' }
+        end
+      end
+
+      describe 'on_right_to_left' do
+        it 'should transform value if such options passed' do
+          rule = TwoWayMapper::Rule.new left_node, right_node, on_right_to_left: ->(v) { v.downcase }
+
+          left_object.key1 = nil
+          right_object = { Kk: { Key1: 'VALUE1' } }
+          rule.from_right_to_left left_object, right_object
+
+          expect(left_object.key1).to eql 'value1'
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'two-way-mapper'
+
+require 'rspec/its'
+require 'ostruct'
+require 'debugger' if defined? Debugger
+
+RSpec.configure do |config|
+end

data/spec/tools_spec.rb

@@ -0,0 +1,29 @@
+describe TwoWayMapper::Tools do
+  let(:tools) { TwoWayMapper::Tools }
+
+  describe '.first_item_from_hash!' do
+    it 'should raise error unless hash passed' do
+      expect{tools.first_item_from_hash!}.to raise_error
+      expect{tools.first_item_from_hash! ''}.to raise_error
+      expect{tools.first_item_from_hash! 1}.to raise_error
+    end
+
+    it 'should raise error if emplt hash passed' do
+      expect{tools.first_item_from_hash! {}}.to raise_error
+    end
+
+    it 'should return first hash key and value' do
+      k, v = tools.first_item_from_hash! a: 1
+
+      expect(k).to eql :a
+      expect(v).to eql 1
+    end
+
+    it 'should delete first item' do
+      hash = { a: 1, b: 2 }
+      k, v = tools.first_item_from_hash! hash
+
+      expect(hash).not_to include a: 1
+    end
+  end
+end

data/two-way-mapper.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'two_way_mapper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "two-way-mapper"
+  spec.version       = TwoWayMapper::VERSION
+  spec.authors       = ["Tima Maslyuchenko"]
+  spec.email         = ["insside@gmail.com"]
+  spec.description   = %q{Two way data mapping}
+  spec.summary       = %q{Two way data mapping}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler",   "~> 1.3"
+  spec.add_development_dependency "rspec",     "~> 3.0"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: two-way-mapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tima Maslyuchenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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: 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'
+description: Two way data mapping
+email:
+- insside@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.ci
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/two-way-mapper.rb
+- lib/two_way_mapper.rb
+- lib/two_way_mapper/map.rb
+- lib/two_way_mapper/mapping.rb
+- lib/two_way_mapper/node.rb
+- lib/two_way_mapper/node/abstract.rb
+- lib/two_way_mapper/node/active_record.rb
+- lib/two_way_mapper/node/hash.rb
+- lib/two_way_mapper/node/object.rb
+- lib/two_way_mapper/railtie.rb
+- lib/two_way_mapper/rule.rb
+- lib/two_way_mapper/tools.rb
+- lib/two_way_mapper/version.rb
+- spec/map_spec.rb
+- spec/mapping_spec.rb
+- spec/node/abstract_spec.rb
+- spec/node/active_record_spec.rb
+- spec/node/hash_spec.rb
+- spec/node/object_spec.rb
+- spec/rule_spec.rb
+- spec/spec_helper.rb
+- spec/tools_spec.rb
+- two-way-mapper.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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Two way data mapping
+test_files:
+- spec/map_spec.rb
+- spec/mapping_spec.rb
+- spec/node/abstract_spec.rb
+- spec/node/active_record_spec.rb
+- spec/node/hash_spec.rb
+- spec/node/object_spec.rb
+- spec/rule_spec.rb
+- spec/spec_helper.rb
+- spec/tools_spec.rb