HornsAndHooves-flat_map 0.2.1 → 0.5.0

data/spec/flat_map/mapping/reader/basic_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Basic do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping') }
-  let(:reader){ described_class.new(mapping) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping') }
+  let(:reader)  { described_class.new(mapping) }
 
   specify("#read should fetch value from mapping's target_attribute") do
-    mapping.should_receive(:target).and_return(target)
-    mapping.should_receive(:target_attribute).and_return(:foo)
-    target.should_receive(:foo).and_return(:bar)
+    expect(mapping).to receive(:target          ).and_return(target)
+    expect(mapping).to receive(:target_attribute).and_return(:foo)
+    expect(target ).to receive(:foo             ).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/reader/formatted_spec.rb

@@ -20,9 +20,9 @@ describe FlatMap::Mapping::Reader::Formatted do
     end
 
     specify "#read should use formatting method for fetching a value" do
-      reader.read.should == 'FOOBAR'
-      reader.read(:downcase).should == 'foobar'
-      reader.read(:unknown).should == 'fOoBaR'
+      expect(reader.read           ).to eq 'FOOBAR'
+      expect(reader.read(:downcase)).to eq 'foobar'
+      expect(reader.read(:unknown )).to eq 'fOoBaR'
     end
   end
 
@@ -32,9 +32,9 @@ describe FlatMap::Mapping::Reader::Formatted do
 
       it "should use I18n_l to format value" do
         formatted_value = "le FooBar"
-        I18n.should_receive(:l).with(value).and_return(formatted_value)
+        expect(I18n).to receive(:l).with(value).and_return(formatted_value)
 
-        reader.read.should == formatted_value
+        expect(reader.read).to eq formatted_value
       end
     end
 
@@ -49,13 +49,13 @@ describe FlatMap::Mapping::Reader::Formatted do
       let(:reader){ described_class.new(mapping, :enum) }
 
       it "should use the name property of the target object for value" do
-        enum.should_receive(:name).and_return(value)
-        reader.read.should == value
+        expect(enum).to receive(:name).and_return(value)
+        expect(reader.read).to eq value
       end
 
       it "should be able to use the desired method to get enum's property" do
-        enum.should_receive(:description).and_return(value)
-        reader.read(:description).should == value
+        expect(enum).to receive(:description).and_return(value)
+        expect(reader.read(:description)).to eq value
       end
     end
   end

data/spec/flat_map/mapping/reader/method_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Method do
-  let(:mapper){ double('mapper') }
-  let(:mapping){ double('mapping', :mapper => mapper) }
-  let(:reader){ described_class.new(mapping, :read_with_method) }
+  let(:mapper)  { double('mapper') }
+  let(:mapping) { double('mapping', :mapper => mapper) }
+  let(:reader)  { described_class.new(mapping, :read_with_method) }
 
   specify("#read delegates to mapper-defined method and passes mapping to it") do
-    mapper.should_receive(:read_with_method).with(mapping).and_return(:bar)
+    expect(mapper).to receive(:read_with_method).with(mapping).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/reader/proc_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Reader::Proc do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping', :target => target) }
-  let(:reader){ described_class.new(mapping, lambda{ |t| t.foo }) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping', :target => target) }
+  let(:reader)  { described_class.new(mapping, lambda{ |t| t.foo }) }
 
   specify("#read should pass target to Proc object to fetch value") do
-    target.should_receive(:foo).and_return(:bar)
+    expect(target).to receive(:foo).and_return(:bar)
 
-    reader.read.should == :bar
+    expect(reader.read).to eq :bar
   end
 end

data/spec/flat_map/mapping/writer/basic_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Basic do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping') }
-  let(:writer){ described_class.new(mapping) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping') }
+  let(:writer)  { described_class.new(mapping) }
 
   specify("#write use target_attribute as writer to assign value to target") do
-    mapping.should_receive(:target).and_return(target)
-    mapping.should_receive(:target_attribute).and_return(:foo)
-    target.should_receive(:foo=).with(:bar)
+    expect(mapping).to receive(:target          ).and_return(target)
+    expect(mapping).to receive(:target_attribute).and_return(:foo)
+    expect(target ).to receive(:foo=).with(:bar)
 
     writer.write(:bar)
   end

data/spec/flat_map/mapping/writer/method_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Method do
-  let(:mapper){ double('mapper') }
-  let(:mapping){ double('mapping', :mapper => mapper) }
-  let(:writer){ described_class.new(mapping, :write_with_method) }
+  let(:mapper)  { double('mapper') }
+  let(:mapping) { double('mapping', :mapper => mapper) }
+  let(:writer)  { described_class.new(mapping, :write_with_method) }
 
   specify("#write delegates to mapper-defined method and passes mapping and value to it") do
-    mapper.should_receive(:write_with_method).with(mapping, :foo)
+    expect(mapper).to receive(:write_with_method).with(mapping, :foo)
 
     writer.write(:foo)
   end

data/spec/flat_map/mapping/writer/proc_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe FlatMap::Mapping::Writer::Proc do
-  let(:target){ double('target') }
-  let(:mapping){ double('mapping', :target => target) }
-  let(:writer){ described_class.new(mapping, lambda{ |t, v| t.foo(v) }) }
+  let(:target)  { double('target') }
+  let(:mapping) { double('mapping', :target => target) }
+  let(:writer)  { described_class.new(mapping, lambda{ |t, v| t.foo(v) }) }
 
   specify("#write should pass target and value to Proc object for assignment") do
-    target.should_receive(:foo).with(:bar)
+    expect(target).to receive(:foo).with(:bar)
 
     writer.write(:bar)
   end

data/spec/flat_map/mapping_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module FlatMap
   describe Mapping do
-    let(:mapper){ double('mapper', :suffixed? => false) }
-    let(:mapping){ Mapping.new(mapper, :name, :attr) }
+    let(:mapper)  { double('mapper', :suffixed? => false) }
+    let(:mapping) { Mapping.new(mapper, :name, :attr) }
 
     describe "initialization" do
       it "should be initializable" do
@@ -11,12 +11,12 @@ module FlatMap
       end
 
       it 'should delegate #read to reader' do
-        mapping.reader.should_receive(:read)
+        expect(mapping.reader).to receive(:read)
         mapping.read
       end
 
       it 'should delegate #write to writer' do
-        mapping.writer.should_receive(:write).with(:foo)
+        expect(mapping.writer).to receive(:write).with(:foo)
         mapping.write(:foo)
       end
 
@@ -25,43 +25,43 @@ module FlatMap
 
         subject{ Mapping.new(mapper, :name, :attr, :multiparam => Date) }
 
-        its(:mapper){ should == mapper }
-        its(:name){ should == :name }
-        its(:target_attribute){ should == :attr }
-        its(:full_name){ should == :name_foo }
-        its(:multiparam){ should == Date }
-        its(:multiparam?){ should be true }
+        its(:mapper)           { is_expected.to eq mapper }
+        its(:name)             { is_expected.to eq :name }
+        its(:target_attribute) { is_expected.to eq :attr }
+        its(:full_name)        { is_expected.to eq :name_foo }
+        its(:multiparam)       { is_expected.to eq Date }
+        its(:multiparam?)      { is_expected.to be true }
       end
 
       describe "#fetch_reader" do
         context 'default' do
           subject{ Mapping.new(mapper, :name, :attr) }
 
-          its(:reader){ should be_a(Mapping::Reader::Basic) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Basic) }
         end
 
         context 'method' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => :method_name) }
 
-          its(:reader){ should be_a(Mapping::Reader::Method) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Method) }
         end
 
         context 'proc' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => lambda{ |t| t.foo }) }
 
-          its(:reader){ should be_a(Mapping::Reader::Proc) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Proc) }
         end
 
         context 'formatted' do
           subject{ Mapping.new(mapper, :name, :attr, :format => :i18n_l) }
 
-          its(:reader){ should be_a(Mapping::Reader::Formatted) }
+          its(:reader) { is_expected.to be_a(Mapping::Reader::Formatted) }
         end
 
         context 'blank' do
           subject{ Mapping.new(mapper, :name, :attr, :reader => false) }
 
-          its(:reader){ should be_nil }
+          its(:reader) { is_expected.to be_nil }
         end
       end
     end
@@ -70,32 +70,32 @@ module FlatMap
       context 'default' do
         subject{ Mapping.new(mapper, :name, :attr) }
 
-        its(:writer){ should be_a(Mapping::Writer::Basic) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Basic) }
       end
 
       context 'method' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => :method_name) }
 
-        its(:writer){ should be_a(Mapping::Writer::Method) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Method) }
       end
 
       context 'proc' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => lambda{ |t| t.foo }) }
 
-        its(:writer){ should be_a(Mapping::Writer::Proc) }
+        its(:writer) { is_expected.to be_a(Mapping::Writer::Proc) }
       end
 
       context 'blank' do
         subject{ Mapping.new(mapper, :name, :attr, :writer => false) }
 
-        its(:writer){ should be_nil }
+        its(:writer) { is_expected.to be_nil }
       end
     end
 
     describe "read_as_params" do
       it "should return mapping as key value pair" do
         stub_target
-        mapping.read_as_params.should == {:name => "target_foo"}
+        expect(mapping.read_as_params).to eq({:name => "target_foo"})
       end
     end
 
@@ -107,16 +107,16 @@ module FlatMap
 
       it "should set no value on the target from params" do
         target = stub_target
-        target.should_not_receive(:attr=)
+        expect(target).not_to receive(:attr=)
         mapping.write_from_params(:not_mapping_name => "value")
-        target.attr.should == 'target_foo'
+        expect(target.attr).to eq 'target_foo'
       end
     end
 
     def stub_target(assignment = nil)
       target = double('target', :attr => 'target_foo')
-      mapper.stub(:target).and_return(target)
-      target.should_receive(:attr=).with(assignment) if assignment.present?
+      allow(mapper).to receive(:target).and_return(target)
+      expect(target).to receive(:attr=).with(assignment) if assignment.present?
       target
     end
   end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+require 'bundler/setup'
+
 require 'flat_map'
 require 'ostruct'
 require 'pry'
@@ -7,3 +9,7 @@ require 'simplecov'
 SimpleCov.start do
   add_filter '/spec/'
 end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end

metadata

@@ -1,46 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: HornsAndHooves-flat_map
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.5.0
 platform: ruby
 authors:
 - HornsAndHooves
 - Artem Kuzko
 - Zachary Belzer
 - Sergey Potapov
-autorequire: 
+- Bruce Burdick
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-29 00:00:00.000000000 Z
+date: 2021-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.0.5
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.0.5
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.0.5
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.0.5
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -61,14 +74,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +117,7 @@ email:
 - a.kuzko@gmail.com
 - zbelzer@gmail.com
 - blake131313@gmail.com
+- rubygems.org@bruceburdick.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -175,7 +189,7 @@ homepage: https://github.com/HornsAndHooves/flat_map
 licenses:
 - LICENSE
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -190,9 +204,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
 summary: Deep object graph to a plain properties mapper
 test_files:
@@ -219,4 +232,3 @@ test_files:
 - spec/flat_map/mapping_spec.rb
 - spec/flat_map/open_mapper_spec.rb
 - spec/spec_helper.rb
-has_rdoc: