yaoc 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa280d846afba6ccd2f33412e0ff29851e644456
-  data.tar.gz: 9db2caf9165fafc3225b647d9a7fd504dc302a1b
+  metadata.gz: 441263ba3b9fe09627de69b63629026703c7070d
+  data.tar.gz: 48c6614551a01d37000e914bd48308aca9987424
 SHA512:
-  metadata.gz: 002631bd391b6fe657556f7c2c80c0289fb5ab26cb04e78c8593abc9b1e1288e80d2646ea8b63433d9ca20cb4bed2d4e7a477be0fe26dcce757b8363f5981f51
-  data.tar.gz: 08ef26547007bd532debdcbd39045de8d61e96adc59d9b812329d2b5e3b4ebeb408df5e3137cc0e76866d8667bb461d89c1b7c728c86da9f2a5a8ab949d2973a
+  metadata.gz: d6284f7e096825e82d6244e75eb239a1ef2d388bce4714c71d844619cbd0a71d8923770134947ee81e90a544c67255a9146ff463005794b28f53731f98cc772f
+  data.tar.gz: cc8596b471a03029d0edf21f96dec0e47a1df2a5586ed496c331c9b260a7ea39af0aec3193d8d0d0e81f2a7dd658b3547398727b89c0b911c9155d5f86c304b4

data/README.md

@@ -24,7 +24,7 @@ Uptodate doc's look into the specs.
 
 require 'yaoc'
 
-User = Struct.new(:id, :name) do
+User = Struct.new(:id, :firstname, :lastname, :role) do
   def initialize(params={})
     super()
 
@@ -34,7 +34,7 @@ User = Struct.new(:id, :name) do
    end
 end
 
-OldUser = Struct.new(:id, :fullname) do
+OldUser = Struct.new(:id, :fullname, :r_role) do
   def initialize(params={})
     super()
 
@@ -47,25 +47,100 @@ end
 mapper = Yaoc::ObjectMapper.new(User, OldUser).tap do |mapper|
   mapper.add_mapping do
     fetcher :public_send
-    rule to: :name, from: :fullname
+    rule to: :role, from: :r_role
+
+    rule to: :firstname,
+         from: :fullname,
+         converter: ->(source, result){ result.merge({firstname:
+                                                      source.fullname.split().first }) },
+         reverse_converter: ->(source, result){ result.merge({fullname:
+                                                              "#{source.firstname} #{source.lastname}" }) }
+
+    rule to: :lastname,
+         from: :fullname,
+         converter: ->(source, result){ result.merge({lastname:  source.fullname.split().last }) },
+         reverse_converter: ->(source, result){ result }
+
     rule to: :id
+
+    # or
+    # rule to: [:id, :foo, :bar, ...], from: [:rid, :rfoo], converter: [->(){}]
+
   end
 end
 
-old_user = OldUser.new({id: 1, fullname: "myname" })
+old_user = OldUser.new({id: 1, fullname: "myfirst mysecond", r_role: "admin" })
 new_user = mapper.load(old_user)
 
-
 puts old_user
 puts new_user
 
-new_user.name = "no name"
+new_user.firstname = "no"
+new_user.lastname = "name"
 
 puts mapper.dump(new_user)
 
-#<struct OldUser id=1, fullname="myname">
-#<struct User id=1, name="myname">
-#<struct OldUser id=1, fullname="no name">
+#<struct OldUser id=1, fullname="myfirst mysecond", r_role="admin">
+#<struct User id=1, firstname="myfirst", lastname="mysecond", role="admin">
+#<struct OldUser id=1, fullname="no name", r_role="admin">
+
+# the resulting class has no hash enabled constructor?
+
+puts "\n" * 5
+
+OldUser2 = Struct.new(:id, :fullname, :r_role)
+
+User2 = Struct.new(:id, :firstname, :lastname, :role)
+
+reverse_source = ->(attrs){
+  OldUser2.new.tap do |old_user|
+    attrs.each_pair do |key, value|
+      old_user.public_send "#{key}=", value
+    end
+  end
+}
+
+source = ->(attrs){
+  User2.new.tap do |old_user|
+    attrs.each_pair do |key, value|
+      old_user.public_send "#{key}=", value
+    end
+  end
+}
+
+mapper = Yaoc::ObjectMapper.new(source, reverse_source).tap do |mapper|
+  mapper.add_mapping do
+    fetcher :public_send
+    rule to: :role, from: :r_role
+
+    rule to: :firstname,
+         from: :fullname,
+         converter: ->(source, result){ result.merge({firstname:  source.fullname.split().first }) },
+         reverse_converter: ->(source, result){ result.merge({fullname:  "#{source.firstname} #{source.lastname}" }) }
+
+    rule to: :lastname,
+         from: :fullname,
+         converter: ->(source, result){ result.merge({lastname:  source.fullname.split().last }) },
+         reverse_converter: ->(source, result){ result }
+
+    rule to: :id
+  end
+end
+
+old_user2 = OldUser2.new(1, "myfirst mysecond",  "admin" )
+new_user2 = mapper.load(old_user)
+
+puts old_user2
+puts new_user2
+
+new_user2.firstname = "no"
+new_user2.lastname = "name"
+
+puts mapper.dump(new_user2)
+
+#<struct OldUser2 id=1, fullname="myfirst mysecond", r_role="admin">
+#<struct User2 id=1, firstname="myfirst", lastname="mysecond", role="admin">
+#<struct OldUser2 id=1, fullname="no name", r_role="admin">
 
 ```
 

data/lib/yaoc.rb

@@ -4,6 +4,7 @@ require 'yaoc/mapping_base'
 
 Dir[File.join(File.expand_path(__dir__ ), "yaoc/strategies/*.rb")].each { |f| require f }
 
+require 'yaoc/converter_builder'
 require 'yaoc/object_mapper'
 
 module Yaoc

data/lib/yaoc/converter_builder.rb

@@ -0,0 +1,73 @@
+module Yaoc
+
+  class ConverterBuilder
+    attr_accessor  :build_commands, :command_order
+
+    def initialize(command_order=:recorded_order, fetcher=:fetch)
+      self.build_commands = []
+      self.command_order = command_order
+      self.fetcher = fetcher
+    end
+
+    def add_mapping(&block)
+      instance_eval &block
+      apply_commands!
+    end
+
+    def converter_class
+      @converter_class ||= Struct.new(:to_convert, :fetcher) do
+        include MappingBase
+        include Strategies::ToHashMapping
+      end
+    end
+
+
+    def rule(to: nil, from: to, converter: nil)
+      to_s = Array(to)
+      from_s = Array(from)
+      converter_s = Array(converter)
+
+      to_s.each_with_index do |to, index|
+        build_commands.push  ->{ converter_class.map(to, from_s[index] || to, converter_s[index]) }
+      end
+    end
+
+    def apply_commands!
+      reset_converters!
+
+      build_commands_ordered.each &:call
+    end
+
+    def converter(fetch_able)
+      converter_class.new(fetch_able, fetcher)
+    end
+
+    def fetcher=(new_fetcher)
+      @fetcher= new_fetcher
+    end
+
+    protected
+
+    def fetcher
+      @fetcher ||= :fetch
+    end
+
+    def fetch_with(new_fetcher)
+      self.fetcher = new_fetcher
+    end
+
+    def build_commands_ordered
+      if command_order == :recorded_order
+        build_commands
+      else
+        build_commands.reverse
+      end
+    end
+
+    def reset_converters!
+      @converter_class = nil
+    end
+
+  end
+
+end

data/lib/yaoc/object_mapper.rb

@@ -1,15 +1,11 @@
 module Yaoc
 
   class ObjectMapper
-    attr_accessor :load_result_source, :dump_result_source,
-                  :forward_commands, :backward_commads
+    attr_accessor :load_result_source, :dump_result_source
 
     def initialize(load_result_source, dump_result_source=->(attrs){ attrs})
       self.load_result_source = load_result_source.respond_to?(:call) ? load_result_source : ->(attrs){load_result_source.new(attrs)}
       self.dump_result_source = dump_result_source.respond_to?(:call) ? dump_result_source : ->(attrs){dump_result_source.new(attrs)}
-
-      self.forward_commands = []
-      self.backward_commads = []
     end
 
     def load(fetch_able)
@@ -28,59 +24,46 @@ module Yaoc
     protected
 
     def apply_commands
-      reset_converters!
-
-      forward_commands.each &:call
-      backward_commads.each &:call
-    end
-
-    def reset_converters!
-      @reverse_converter_class = nil
-      @converter_class = nil
+      converter_builder.apply_commands!
+      reverse_converter_builder.apply_commands!
     end
 
     def rule(to: nil, from: to, converter: nil, reverse_converter: nil)
-      forward_commands.push    ->{ converter_class.map(to, from, converter) }
-      backward_commads.unshift ->{ reverse_converter_class.map(from, to, reverse_converter) }
-    end
+      converter_builder.rule(
+          to: to,
+          from: from,
+          converter: converter,
+      )
 
-    def fetcher(new_fetcher)
-      @fetcher= new_fetcher
+      reverse_converter_builder.rule(
+          to: from,
+          from: to,
+          converter: reverse_converter,
+      )
     end
 
-    def fetcher_method
-      @fetcher ||= :fetch
+    def fetcher(new_fetcher)
+      converter_builder.fetcher = new_fetcher
     end
 
     def reverse_fetcher(new_fetcher)
-      @reverse_fetcher = new_fetcher
-    end
-
-    def reverse_fetcher_method
-      @reverse_fetcher ||= :public_send
+      reverse_converter_builder.fetcher = new_fetcher
     end
 
     def converter(fetch_able)
-      converter_class.new(fetch_able, fetcher_method)
-    end
-
-    def converter_class
-      @converter_class ||= new_converter_class
+      converter_builder.converter(fetch_able)
     end
 
     def reverse_converter(fetch_able)
-      reverse_converter_class.new(fetch_able, reverse_fetcher_method)
+      reverse_converter_builder.converter(fetch_able)
     end
 
-    def reverse_converter_class
-      @reverse_converter_class ||= new_converter_class
+    def converter_builder
+      @converter_builder ||= Yaoc::ConverterBuilder.new()
     end
 
-    def new_converter_class
-      Struct.new(:to_convert, :fetcher) do
-        include MappingBase
-        include Strategies::ToHashMapping
-      end
+    def reverse_converter_builder
+      @reverse_converter_builder ||= Yaoc::ConverterBuilder.new(:reverse_order, :public_send)
     end
 
   end

data/lib/yaoc/version.rb

@@ -1,3 +1,3 @@
 module Yaoc
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/acceptance/map_objects_spec.rb

@@ -16,13 +16,14 @@ feature "Map objects", %q{
              reverse_converter: ->(source, result){ result.merge({name: source.name}) }
         rule to: :role, from: :fullrolename
         rule to: :id
+        rule to: [:foo, :bar]
       end
     end
   }
 
   given(:load_result_object_class) {
-    Struct.new(:id, :name, :role) do
-      include Equalizer.new(:id, :name, :role)
+    Struct.new(:id, :name, :role, :foo, :bar) do
+      include Equalizer.new(:id, :name, :role, :foo, :bar)
 
       def initialize(params={})
         super()
@@ -36,8 +37,8 @@ feature "Map objects", %q{
   }
 
   given(:dump_result_object_class) {
-    Struct.new(:id, :name, :fullrolename) do
-      include Equalizer.new(:id, :name, :fullrolename)
+    Struct.new(:id, :name, :fullrolename, :foo, :bar) do
+      include Equalizer.new(:id, :name, :fullrolename, :foo, :bar)
 
       def initialize(params={})
         super()
@@ -55,11 +56,11 @@ feature "Map objects", %q{
   }
 
   given(:load_result_object){
-    load_result_object_class.new({id: 1, name: "paul", role: "admin"})
+    load_result_object_class.new({id: 1, name: "paul", role: "admin", foo: "some thing", bar: "some other thing"})
   }
 
   given(:dump_result_object){
-    dump_result_object_class.new({id: 1, name: "paul", fullrolename: "admin"})
+    dump_result_object_class.new({id: 1, name: "paul", fullrolename: "admin", foo: "some thing", bar: "some other thing"})
   }
 
   scenario "creates an result object from an input_object" do

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

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Yaoc::ConverterBuilder do
+  subject{
+    Yaoc::ConverterBuilder.new().tap{|converter|
+      converter.stub(:converter_class).and_return(converter_class)
+    }
+  }
+
+
+  let(:converter_class){
+    double("converter_class", map: nil, new: converter)
+  }
+
+  let(:converter){
+    double("converter", call: nil)
+  }
+
+  describe ".new" do
+    it "applies command in recorded order as default" do
+
+      expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
+      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+
+      subject.add_mapping do
+        rule to: :id
+        rule to: :name
+      end
+
+    end
+
+    it "applies command in reverse recorded order when wanted" do
+      subject = Yaoc::ConverterBuilder.new(:reverse_order).tap{|converter|
+        converter.stub(:converter_class).and_return(converter_class)
+      }
+
+
+      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+      expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
+
+      subject.add_mapping do
+        rule to: :id
+        rule to: :name
+      end
+
+    end
+  end
+
+  describe "#add_mapping" do
+
+
+
+    it "delegates to internal methods" do
+      expect(subject).to receive(:fetch_with).with(:public_send)
+      expect(subject).to receive(:rule).with(to: :id, from: :from, converter: :converter)
+
+      subject.add_mapping do
+        fetch_with  :public_send
+        rule to: :id, from: :from, converter: :converter
+      end
+    end
+
+
+
+  end
+
+  describe "#rule" do
+    it "creates a converter" do
+
+      expect(converter_class).to receive(:map).with(:id, :id2, :some_proc)
+
+      subject.add_mapping do
+        rule to: :id,
+             from: :id2,
+             converter: :some_proc
+      end
+
+    end
+
+    it "uses defaults" do
+      expect(converter_class).to receive(:map).with(:id, :id, nil)
+
+      subject.add_mapping do
+        rule to: :id
+      end
+
+    end
+
+    it "allows to use array of attributes" do
+      expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
+      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+
+      subject.add_mapping do
+        rule to: [:id, :name]
+      end
+    end
+
+    it "use the right to when from in arrays is missing" do
+      expect(converter_class).to receive(:map).ordered.with(:id, :r_id, nil)
+      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+
+      subject.add_mapping do
+        rule to: [:id, :name],
+             from: [:r_id]
+      end
+    end
+  end
+end

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

@@ -3,17 +3,17 @@ 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)
+      mapper.stub(:converter_builder).and_return(converter_builder)
+      mapper.stub(:reverse_converter_builder).and_return(reverse_converter_builder)
     }
   }
 
-  let(:converter_class){
-    double("converter_class", map: nil, new: converter)
+  let(:converter_builder){
+    double("converter_builder", rule: nil, apply_commands!: nil, converter: converter)
   }
 
-  let(:reverse_converter_class){
-    double("reverse_converter_class", map: nil, new: reverse_converter)
+  let(:reverse_converter_builder){
+    double("reverse_converter_builder", rule: nil, apply_commands!: nil, converter: reverse_converter)
   }
 
   let(:converter){
@@ -26,9 +26,10 @@ describe Yaoc::ObjectMapper do
 
   describe "#add_mapping" do
 
-    it "creates a mapper" do
+    it "creates a converter" do
+
+      expect(converter_builder).to receive(:rule).with(to: :id, from: :id2, converter: :some_proc)
 
-      expect(converter_class).to receive(:map).with(:id, :id2, :some_proc)
       subject.add_mapping do
         rule to: :id,
              from: :id2,
@@ -38,9 +39,9 @@ describe Yaoc::ObjectMapper do
 
     end
 
-    it "creates a revers mapper" do
+    it "creates a revers converter" do
 
-      expect(reverse_converter_class).to receive(:map).with(:id2, :id, :some_reverse_proc)
+      expect(reverse_converter_builder).to receive(:rule).with(to: :id2, from: :id, converter: :some_reverse_proc)
 
       subject.add_mapping do
         rule to: :id,
@@ -52,8 +53,8 @@ describe Yaoc::ObjectMapper do
     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)
+      expect(converter_builder).to receive(:rule).with(to: :id, from: :id, converter: nil)
+      expect(reverse_converter_builder).to receive(:rule).with(to: :id, from: :id, converter: nil)
 
       subject.add_mapping do
         rule to: :id
@@ -62,21 +63,23 @@ describe Yaoc::ObjectMapper do
     end
 
     it "allows to set a fetcher" do
+      expect(converter_builder).to receive(:fetcher=).with(:public_send)
+
       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
+      expect(reverse_converter_builder).to receive(:fetcher=).with(:fetch)
+
       subject.add_mapping do
         reverse_fetcher :fetch
         rule to: :id
       end
-
-      expect(subject.send :reverse_fetcher_method).to eq(:fetch)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yaoc
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Dieter Späth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-22 00:00:00.000000000 Z
+date: 2014-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -220,6 +220,7 @@ files:
 - README.md
 - Rakefile
 - lib/yaoc.rb
+- lib/yaoc/converter_builder.rb
 - lib/yaoc/mapping_base.rb
 - lib/yaoc/object_mapper.rb
 - lib/yaoc/strategies/to_array_mapping.rb
@@ -228,6 +229,7 @@ files:
 - spec/acceptance/map_objects_spec.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb
+- spec/unit/lib/yaoc/converter_builder_spec.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
@@ -261,6 +263,7 @@ test_files:
 - spec/acceptance/map_objects_spec.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb
+- spec/unit/lib/yaoc/converter_builder_spec.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