yaoc 0.0.13 → 0.0.14

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

@@ -1,33 +1,32 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Yaoc::ConverterBuilder do
-  subject{
-    Yaoc::ConverterBuilder.new().tap{|converter|
+  subject do
+    Yaoc::ConverterBuilder.new.tap do|converter|
       converter.stub(:converter_class).and_return(converter_class)
-    }
-  }
-
+    end
+  end
 
-  let(:converter_class){
-    double("converter_class", map: nil, new: converter)
-  }
+  let(:converter_class)do
+    double('converter_class', map: nil, new: converter)
+  end
 
-  let(:converter){
-    double("converter", call: nil)
-  }
+  let(:converter)do
+    double('converter', call: nil)
+  end
 
-  let(:default_map_args){
+  let(:default_map_args)do
     {
         to: :id,
         from: :id,
         converter: nil,
         lazy_loading: false
     }
-  }
+  end
 
-  describe "#command_order" do
+  describe '#command_order' do
 
-    it "applies command in recorded order as default" do
+    it 'applies command in recorded order as default' do
       subject.command_order = :recorded_order
 
       expected_args_first = default_map_args.clone
@@ -45,10 +44,10 @@ describe Yaoc::ConverterBuilder do
 
     end
 
-    it "applies command in reverse recorded order when wanted" do
+    it 'applies command in reverse recorded order when wanted' do
       subject.command_order = :reverse_order
 
-      expected_args_first = default_map_args.clone.merge({to: :name, from: :name})
+      expected_args_first = default_map_args.clone.merge(to: :name, from: :name)
       expected_args_second = default_map_args.clone
 
       expect(converter_class).to receive(:map).ordered.with(expected_args_first)
@@ -62,9 +61,9 @@ describe Yaoc::ConverterBuilder do
     end
   end
 
-  describe "#add_mapping" do
+  describe '#add_mapping' do
 
-    it "delegates to internal methods" do
+    it 'delegates to internal methods' do
       expect(subject).to receive(:rule).with(to: :id, from: :from, converter: :converter)
 
       subject.add_mapping do
@@ -79,8 +78,8 @@ describe Yaoc::ConverterBuilder do
 
   end
 
-  describe "#rule" do
-    it "creates a converter" do
+  describe '#rule' do
+    it 'creates a converter' do
       expect(converter_class).to receive(:map).with(to: :id, from: :id2, converter: :some_proc, lazy_loading: false)
 
       subject.add_mapping do
@@ -91,7 +90,7 @@ describe Yaoc::ConverterBuilder do
 
     end
 
-    it "uses defaults" do
+    it 'uses defaults' do
       expect(converter_class).to receive(:map).with(default_map_args)
 
       subject.add_mapping do
@@ -100,9 +99,9 @@ describe Yaoc::ConverterBuilder do
 
     end
 
-    it "allows to use array of attributes" do
+    it 'allows to use array of attributes' do
       expected_args_first = default_map_args.clone
-      expected_args_second = default_map_args.clone.merge({to: :name, from: :name})
+      expected_args_second = default_map_args.clone.merge(to: :name, from: :name)
 
       expect(converter_class).to receive(:map).ordered.with(expected_args_first)
       expect(converter_class).to receive(:map).ordered.with(expected_args_second)
@@ -113,9 +112,8 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "use the right 'to' when 'from' in arrays is missing" do
-      expected_args_first = default_map_args.clone.merge({from: :r_id})
-      expected_args_second = default_map_args.clone.merge({to: :name, from: :name})
-
+      expected_args_first = default_map_args.clone.merge(from: :r_id)
+      expected_args_second = default_map_args.clone.merge(to: :name, from: :name)
 
       expect(converter_class).to receive(:map).ordered.with(expected_args_first)
       expect(converter_class).to receive(:map).ordered.with(expected_args_second)
@@ -126,7 +124,7 @@ describe Yaoc::ConverterBuilder do
       end
     end
 
-    it "supports the use of a object converter" do
+    it 'supports the use of a object converter' do
       expect(converter_class).to receive(:map).ordered.with(to: :id, from: :id, converter: kind_of(Proc), lazy_loading: false)
       other_converter = :some_converter
 
@@ -137,8 +135,8 @@ describe Yaoc::ConverterBuilder do
 
     end
 
-    it "supports the collection flag for object converters" do
-      expected_args = default_map_args.clone.merge({converter: kind_of(Proc)})
+    it 'supports the collection flag for object converters' do
+      expected_args = default_map_args.clone.merge(converter: kind_of(Proc))
 
       expect(converter_class).to receive(:map).ordered.with(expected_args)
       other_converter = :some_converter
@@ -151,8 +149,8 @@ describe Yaoc::ConverterBuilder do
 
     end
 
-    it "supports lazy loading" do
-      expected_args = default_map_args.clone.merge({lazy_loading: true})
+    it 'supports lazy loading' do
+      expected_args = default_map_args.clone.merge(lazy_loading: true)
 
       expect(converter_class).to receive(:map).ordered.with(expected_args)
 
@@ -162,8 +160,8 @@ describe Yaoc::ConverterBuilder do
       end
     end
 
-    it "supports a do nothing" do
-      expected_args = default_map_args.clone.merge({converter: kind_of(Proc)})
+    it 'supports a do nothing' do
+      expected_args = default_map_args.clone.merge(converter: kind_of(Proc))
 
       expect(converter_class).to receive(:map).ordered.with(expected_args)
 
@@ -174,9 +172,9 @@ describe Yaoc::ConverterBuilder do
     end
   end
 
-  describe "#converter" do
-    it "creates a new converter class with the wanted strategy" do
-      subject = Yaoc::ConverterBuilder.new()
+  describe '#converter' do
+    it 'creates a new converter class with the wanted strategy' do
+      subject = Yaoc::ConverterBuilder.new
       subject.add_mapping do
         with_strategy :to_array_mapping
       end
@@ -184,18 +182,18 @@ describe Yaoc::ConverterBuilder do
       expect(subject.send(:converter_class).mapping_strategy).to eq(Yaoc::Strategies::ToArrayMapping)
     end
 
-    it "raises an exception when not all commands are applied" do
-      subject = Yaoc::ConverterBuilder.new()
+    it 'raises an exception when not all commands are applied' do
+      subject = Yaoc::ConverterBuilder.new
       subject.strategy = :to_array_mapping
 
-      expect{subject.converter({})}.to raise_exception
+      expect { subject.converter({}) }.to raise_exception
     end
   end
 
-  describe "#noop" do
-    it "returns the input" do
+  describe '#noop' do
+    it 'returns the input' do
       expect(subject.noop.call(:some_thing, :expected_value)).to eq :expected_value
     end
   end
 
-end
+end

data/spec/unit/lib/yaoc/helper/struct_hash_constructor_spec.rb

@@ -1,33 +1,33 @@
 require 'spec_helper'
 
 describe Yaoc::Helper::StructHashConstructor do
-  subject{
-    Yaoc::Helper::StructH(:id, :name).new(id: 1, name: "no name")
-  }
+  subject do
+    Yaoc::Helper::StructH(:id, :name).new(id: 1, name: 'no name')
+  end
 
-  it "creates a struct with a hash enabled constructor" do
+  it 'creates a struct with a hash enabled constructor' do
     expect(subject.id).to eq 1
-    expect(subject.name).to eq "no name"
+    expect(subject.name).to eq 'no name'
   end
 
-  context "with equal support" do
-    subject{
+  context 'with equal support' do
+    subject do
       Yaoc::Helper::StructHE(:id, :name)
-    }
+    end
 
-    it "returns true when all attributes are equal" do
-      first = subject.new(id: 1, name: "no name")
-      second = subject.new(id: 1, name: "no name")
+    it 'returns true when all attributes are equal' do
+      first = subject.new(id: 1, name: 'no name')
+      second = subject.new(id: 1, name: 'no name')
 
       expect(first).to eq second
     end
 
-    it "returns false when not all atributes are equal" do
-      first = subject.new(id: 1, name: "no name")
-      second = subject.new(id: 1, name: "no name2")
+    it 'returns false when not all atributes are equal' do
+      first = subject.new(id: 1, name: 'no name')
+      second = subject.new(id: 1, name: 'no name2')
 
       expect(first).not_to eq second
     end
   end
 
-end
+end

data/spec/unit/lib/yaoc/helper/to_proc_delegator_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe Yaoc::Helper::ToProcDelegator do
-  subject{
+  subject do
     Yaoc::Helper::ToProcDelegator.new(lazy_proc)
-  }
+  end
 
-  let(:lazy_proc){
-    ->{
+  let(:lazy_proc)do
+    ->do
       [:some_value]
-    }
-  }
+    end
+  end
 
   it 'evaluates a proc not with initialisation' do
     expect(lazy_proc).not_to receive :call
@@ -48,18 +48,18 @@ describe Yaoc::Helper::ToProcDelegator do
   end
 
   describe '#nil?' do
-    it "returns true when delegate value is nil" do
-      subject = Yaoc::Helper::ToProcDelegator.new(->{nil})
+    it 'returns true when delegate value is nil' do
+      subject = Yaoc::Helper::ToProcDelegator.new(-> { nil })
       expect(subject).to be_nil
     end
 
-    it "returns false when delegate value is not nil" do
+    it 'returns false when delegate value is not nil' do
       expect(subject).not_to be_nil
     end
   end
 
   describe '#_initialisation_proc_loaded?' do
-    it "returns true, when __getobj__ was accessed" do
+    it 'returns true, when __getobj__ was accessed' do
       expect(subject._initialisation_proc_loaded?).to be_falsy
       subject.__getobj__
       expect(subject._initialisation_proc_loaded?).to be_truthy
@@ -83,4 +83,4 @@ describe Yaoc::Helper::ToProcDelegator do
     end
   end
 
-end
+end

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Yaoc::ManyToOneMapperChain do
 
-  subject{
+  subject do
     Yaoc::ManyToOneMapperChain.new(first_mapper, second_mapper)
-  }
+  end
 
-  let(:first_mapper){
+  let(:first_mapper)do
     Yaoc::ObjectMapper.new(new_user_class, old_user_class).tap do |mapper|
       mapper.add_mapping do
         fetcher :public_send
@@ -14,9 +14,9 @@ describe Yaoc::ManyToOneMapperChain do
              from: :o_id
       end
     end
-  }
+  end
 
-  let(:second_mapper){
+  let(:second_mapper)do
     Yaoc::ObjectMapper.new(new_user_class, old_user_class).tap do |mapper|
       mapper.add_mapping do
         fetcher :public_send
@@ -24,34 +24,34 @@ describe Yaoc::ManyToOneMapperChain do
              from: :o_names
       end
     end
-  }
+  end
 
-  let(:new_user_class){
+  let(:new_user_class)do
     Yaoc::Helper::StructHE(:id, :names)
-  }
+  end
 
-  let(:old_user_class){
+  let(:old_user_class)do
     Yaoc::Helper::StructHE(:o_id, :o_names)
-  }
+  end
 
-  let(:existing_old_user){
+  let(:existing_old_user)do
     old_user_class.new(
         o_id: 'existing_user_2',
         o_names: ['first_name', 'second_name']
     )
-  }
+  end
 
-  let(:existing_user){
+  let(:existing_user)do
     new_user_class.new(
         id: 'existing_user_2',
         names: ['first_name', 'second_name']
     )
-  }
+  end
 
   describe '.new' do
-    subject{
+    subject do
       Yaoc::ManyToOneMapperChain
-    }
+    end
 
     it 'converts symbols into converter' do
       registry = double('registry')
@@ -101,14 +101,14 @@ describe Yaoc::ManyToOneMapperChain do
       converted_user = subject.load_next(existing_old_user)
 
       expect(converted_user.id).to eq 'existing_user_2'
-      expect(converted_user.names).to eq ["first_name", "second_name"]
+      expect(converted_user.names).to eq ['first_name', 'second_name']
     end
 
     it 'raises an exception when too many values are passed' do
       subject.load_first(existing_old_user)
       subject.load_next(existing_old_user)
 
-      expect{subject.load_next(existing_old_user)}.to raise_error "ToManyInputObjects"
+      expect { subject.load_next(existing_old_user) }.to raise_error 'ToManyInputObjects'
     end
 
   end
@@ -132,7 +132,6 @@ describe Yaoc::ManyToOneMapperChain do
     end
   end
 
-
   describe '#dump_first' do
     it 'dumps the first object into the result object' do
       converted_user = subject.dump_first(existing_user)
@@ -151,4 +150,4 @@ describe Yaoc::ManyToOneMapperChain do
       expect(converted_user.o_names).to eq ['first_name', 'second_name']
     end
   end
-end
+end

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

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe Yaoc::MapperRegistry do
-  subject{
+  subject do
     Yaoc::MapperRegistry
-  }
+  end
 
   describe '.add' do
-    it "registers an object" do
+    it 'registers an object' do
       subject.add(:my_key, Object)
       expect(subject.for(:my_key)).to eq Object
     end
   end
 
   describe '.for' do
-    it "returns the registered object" do
+    it 'returns the registered object' do
       subject.add(:my_key, Object)
       expect(subject.for(:my_key)).to eq Object
     end
@@ -21,9 +21,9 @@ describe Yaoc::MapperRegistry do
 
   describe '.scope_storage' do
     it 'supports the change of scope storage' do
-      expect {subject.scope_storage(ScopedStorage::ThreadLocalStorage)}.not_to raise_error
+      expect { subject.scope_storage(ScopedStorage::ThreadLocalStorage) }.not_to raise_error
     end
 
   end
 
-end
+end

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

@@ -1,7 +1,7 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Yaoc::MappingBase do
-  subject{
+  subject do
     Struct.new(:to_convert) do
       include Yaoc::MappingBase
 
@@ -13,84 +13,84 @@ describe Yaoc::MappingBase do
       }
 
     end
-  }
+  end
 
-  describe "created module" do
-    it "can be inspected" do
+  describe 'created module' do
+    it 'can be inspected' do
       subject.map(to: :foo, from: :bar)
-      expect(subject.class_private_module.inspect).to include("map_0000_bar_to_foo")
+      expect(subject.class_private_module.inspect).to include('map_0000_bar_to_foo')
     end
   end
 
-  describe ".map" do
+  describe '.map' do
 
-    it "creates a bunch of mapping methods" do
+    it 'creates a bunch of mapping methods' do
       subject.map(to: :foo, from: :bar)
       subject.map(to: :bar, from: :foo)
 
-      expect(subject.new({bar: :my_to_convert, foo: :my_result}).call()).to eq [{:foo=>:my_to_convert, :bar=>:my_result},
-                                                                                {:foo=>:my_to_convert, :bar=>:my_result}]
+      expect(subject.new(bar: :my_to_convert, foo: :my_result).call).to eq [{ foo: :my_to_convert, bar: :my_result },
+                                                                            { foo: :my_to_convert, bar: :my_result }]
     end
 
-    it "delegates to TransformationCommand.create" do
-      expect(Yaoc::TransformationCommand).to receive(:create).with(to: :bar, from: :foo, deferred: false, conversion_proc: kind_of(Proc)).and_return(->(*){})
-      subject.map(to: :bar, from: :foo, converter: ->(*){})
+    it 'delegates to TransformationCommand.create' do
+      expect(Yaoc::TransformationCommand).to receive(:create).with(to: :bar, from: :foo, deferred: false, conversion_proc: kind_of(Proc)).and_return(->(*) {})
+      subject.map(to: :bar, from: :foo, converter: ->(*) {})
     end
 
   end
 
-  describe "#converter_methods" do
-    it "preserves method order" do
-      subject.map(to: 0, from: 1, converter: ->(*){})
-      subject.map(to: 1, from: :a, converter: ->(*){})
+  describe '#converter_methods' do
+    it 'preserves method order' do
+      subject.map(to: 0, from: 1, converter: ->(*) {})
+      subject.map(to: 1, from: :a, converter: ->(*) {})
 
       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){
+  describe '#fetcher' do
+    let(:subject_with_fetcher)do
       Struct.new(:to_convert) do
         include Yaoc::MappingBase
 
         def fetcher
-          "my_fetcher"
+          'my_fetcher'
         end
 
       end
-    }
+    end
 
-    it "uses in class declared fetcher" do
-      expect(subject_with_fetcher.new().fetcher).to eq "my_fetcher"
+    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
+    it 'uses build in fetcher without a fetcher definition' do
+      expect(subject.new.fetcher).to eq :fetch
     end
 
   end
 
-  describe "#call" do
-    let(:mapper){
+  describe '#call' do
+    let(:mapper)do
       subject.new(:some_thing)
-    }
+    end
 
-    it "delegates execution to strategy" do
+    it 'delegates execution to strategy' do
       expect(subject.mapping_strategy).to receive(:call).with mapper
 
       mapper.call
     end
 
-    it "return nil when to_convert is nil" do
+    it 'return nil when to_convert is nil' do
       mapper.to_convert = nil
       expect(mapper.call).to be_nil
     end
 
   end
 
-  describe "#to_proc" do
-    it "creates a wrapper around call" do
-      mapper = subject.new()
+  describe '#to_proc' do
+    it 'creates a wrapper around call' do
+      mapper = subject.new
       mapper_as_proc = mapper.to_proc
       expect(mapper).to receive :call
 
@@ -112,14 +112,14 @@ describe Yaoc::MappingBase do
       mapper_as_proc = mapper.to_proc
 
       mapper.stub(:call) do
-        raise "MyException"
+        fail 'MyException'
       end
 
       expect(mapper).to receive(:to_convert=).ordered.with(:some_thing)
       expect(mapper).to receive(:to_convert=).ordered.with(:old_some_thing)
 
-      expect{mapper_as_proc.call(:some_thing)}.to raise_error "MyException"
+      expect { mapper_as_proc.call(:some_thing) }.to raise_error 'MyException'
     end
   end
 
-end
+end