monolens 0.2.0 → 0.3.0

data/lib/monolens/object/values.rb

@@ -3,20 +3,44 @@ module Monolens
     class Values
       include Lens
 
-      def initialize(lens)
-        super({})
-        @lens = Monolens.lens(lens)
-      end
-
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
 
-        dup = arg.dup
+        lenses = option(:lenses)
+        result = arg.dup
         arg.each_pair do |attr, value|
-          dup[attr] = @lens.call(value)
+          deeper(world, attr) do |w|
+            begin
+              result[attr] = lenses.call(value, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, attr, value, world)
+            end
+          end
+        end
+        result
+      end
+
+      def handle_error(strategy, ex, result, attr, value, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, attr, value, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result[attr] = nil
+        when :skip
+          result.delete(attr)
+        when :keep
+          result[attr] = value
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
         end
-        dup
       end
+      private :handle_error
     end
   end
 end

data/lib/monolens/skip/null.rb

@@ -3,7 +3,7 @@ module Monolens
     class Null
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         throw :skip if arg.nil?
 
         arg

data/lib/monolens/str/downcase.rb

@@ -3,8 +3,8 @@ module Monolens
     class Downcase
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         arg.downcase
       end

data/lib/monolens/str/split.rb

@@ -3,8 +3,8 @@ module Monolens
     class Split
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         sep = option(:separator)
         sep ? arg.split(sep) : arg.split

data/lib/monolens/str/strip.rb

@@ -3,7 +3,9 @@ module Monolens
     class Strip
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
+        is_string!(arg, world)
+
         arg.to_s.strip
       end
     end

data/lib/monolens/str/upcase.rb

@@ -3,8 +3,8 @@ module Monolens
     class Upcase
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         arg.upcase
       end

data/lib/monolens/version.rb

@@ -1,7 +1,7 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/spec/fixtures/coerce.yml

@@ -2,5 +2,6 @@
 version: "1.0"
 lenses:
 - object.transform:
-    at:
-    - coerce.date: { formats: [ '%d/%m/%Y', '%Y/%m/%d' ] }
+    defn:
+      at:
+      - coerce.date: { formats: [ '%d/%m/%Y', '%Y/%m/%d' ] }

data/spec/fixtures/transform.yml

@@ -2,7 +2,8 @@
 version: "1.0"
 lenses:
 - object.transform:
-    firstname:
-    - str.upcase
-    lastname:
-    - str.downcase
+    defn:
+      firstname:
+      - str.upcase
+      lastname:
+      - str.downcase

data/spec/monolens/array/test_map.rb

@@ -1,13 +1,96 @@
 require 'spec_helper'
 
 describe Monolens, 'array.map' do
-  subject do
-    Monolens.lens('array.map' => 'str.upcase')
+  context 'without options' do
+    subject do
+      Monolens.lens('array.map' => 'str.upcase')
+    end
+
+    it 'joins values with spaces' do
+      input = ['hello', 'world']
+      expected = ['HELLO', 'WORLD']
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'default on error' do
+    subject do
+      Monolens.lens('array.map' => {
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'raise errors' do
+      input = [nil, 'world']
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError)
+    end
+  end
+
+  context 'skipping on error' do
+    subject do
+      Monolens.lens('array.map' => {
+        on_error: 'skip',
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'skips errors' do
+      input = [nil, 'world']
+      expected = ['WORLD']
+      expect(subject.call(input)).to eql(expected)
+    end
   end
 
-  it 'joins values with spaces' do
-    input = ['hello', 'world']
-    expected = ['HELLO', 'WORLD']
-    expect(subject.call(input)).to eql(expected)
+  context 'nulling on error' do
+    subject do
+      Monolens.lens('array.map' => {
+        on_error: 'null',
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'skips errors' do
+      input = [nil, 'world']
+      expected = [nil, 'WORLD']
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'on error with :handler' do
+    subject do
+      Monolens.lens('array.map' => {
+        on_error: 'handler',
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'collects the error then skips' do
+      input = [nil, 'world']
+      expected = ['WORLD']
+      errs = []
+      got = subject.call(input, error_handler: ->(err){ errs << err })
+      expect(errs.size).to eql(1)
+      expect(got).to eql(expected)
+    end
+  end
+
+  context 'collecting on error then nulling' do
+    subject do
+      Monolens.lens('array.map' => {
+        on_error: ['handler', 'null'],
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'uses the handler' do
+      input = [nil, 'world']
+      expected = [nil, 'WORLD']
+      errs = []
+      got = subject.call(input, error_handler: ->(err){ errs << err })
+      expect(errs.size).to eql(1)
+      expect(got).to eql(expected)
+    end
   end
 end

data/spec/monolens/coerce/test_date.rb

@@ -9,9 +9,34 @@ describe Monolens, 'coerce.date' do
     expect(subject.call('11/12/2022')).to eql(Date.parse('2022-12-11'))
   end
 
-  it 'fails on invalid dates' do
-    expect {
-      subject.call('invalid')
-    }.to raise_error(Monolens::LensError)
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => 'coerce.date'
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+        nil
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    let(:input) do
+      ['invalid']
+    end
+
+    it 'fails on invalid dates' do
+      expect(subject).to be_a(Monolens::LensError)
+    end
+
+    it 'properly sets the location' do
+      expect(subject.location).to eql([0])
+    end
   end
 end

data/spec/monolens/coerce/test_datetime.rb

@@ -9,9 +9,34 @@ describe Monolens, 'coerce.datetime' do
     expect(subject.call('11/12/2022 17:38')).to eql(DateTime.parse('2022-12-11 17:38'))
   end
 
-  it 'fails on invalid dates' do
-    expect {
-      subject.call('invalid')
-    }.to raise_error(Monolens::LensError)
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => 'coerce.datetime'
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+        nil
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    let(:input) do
+      ['invalid']
+    end
+
+    it 'fails on invalid dates' do
+      expect(subject).to be_a(Monolens::LensError)
+    end
+
+    it 'properly sets the location' do
+      expect(subject.location).to eql([0])
+    end
   end
 end

data/spec/monolens/coerce/test_string.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Monolens, 'coerce.string' do
+  subject do
+    Monolens.lens('coerce.string')
+  end
+
+  it 'works' do
+    expect(subject.call(12)).to eql('12')
+  end
+
+  it 'accepts null' do
+    expect(subject.call(nil)).to eql('')
+  end
+end

data/spec/monolens/core/test_mapping.rb

@@ -48,4 +48,29 @@ describe Monolens, 'core.mapping' do
       }.to raise_error(Monolens::LensError)
     end
   end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => {
+            'core.mapping' => mapping.merge('fail_if_missing' => true)
+          }
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(['todo', 'foo'])
+        nil
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    it 'sets the location correctly' do
+      expect(subject.location).to eql([1])
+    end
+  end
 end

data/spec/monolens/lens/test_options.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Monolens
+  module Lens
+    describe Options do
+      subject do
+        Options.new(input)
+      end
+
+      describe 'initialize' do
+        context('when used with a Hash') do
+          let(:input) do
+            { separator: ',' }
+          end
+
+          it 'uses a copy of the hash' do
+            expect(subject.send(:options)).not_to be(input)
+            expect(subject.to_h).not_to be(input)
+            expect(subject.to_h).to eql(input)
+          end
+        end
+
+        context('when used with an Array') do
+          let(:input) do
+            ['str.strip']
+          end
+
+          it 'converts it to lenses' do
+            expect(subject.to_h.keys).to eql([:lenses])
+            lenses = subject.to_h[:lenses]
+            expect(lenses).to be_a(Core::Chain)
+          end
+        end
+
+        context('when used with a String') do
+          let(:input) do
+            'str.strip'
+          end
+
+          it 'converts it to lenses' do
+            expect(subject.to_h.keys).to eql([:lenses])
+            lenses = subject.to_h[:lenses]
+            expect(lenses).to be_a(Str::Strip)
+          end
+        end
+      end
+
+      describe 'fetch' do
+        context 'when used with Symbols' do
+          let(:input) do
+            { separator: ',' }
+          end
+
+          it 'lets fetch as Symbols' do
+            expect(subject.fetch(:separator)).to eql(',')
+          end
+
+          it 'lets fetch as Strings' do
+            expect(subject.fetch('separator')).to eql(',')
+          end
+
+          it 'raises if not found' do
+            expect { subject.fetch('nosuchone') }.to raise_error(Monolens::Error)
+          end
+
+          it 'lets pass a default value' do
+            expect(subject.fetch('nosuchone', 'foo')).to eql('foo')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/monolens/object/test_keys.rb

@@ -1,31 +1,63 @@
 require 'spec_helper'
 
 describe Monolens, 'object.keys' do
-  subject do
-    Monolens.lens('object.keys' => ['str.upcase'])
+  context 'with string keys' do
+    subject do
+      Monolens.lens('object.keys' => ['str.upcase'])
+    end
+
+    it 'works as expected' do
+      input = {
+        'firstname' => 'Bernard',
+        'lastname' => 'Lambeau'
+      }
+      expected = {
+        'FIRSTNAME' => 'Bernard',
+        'LASTNAME' => 'Lambeau'
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
   end
 
-  it 'works as expected' do
-    input = {
-      'firstname' => 'Bernard',
-      'lastname' => 'Lambeau'
-    }
-    expected = {
-      'FIRSTNAME' => 'Bernard',
-      'LASTNAME' => 'Lambeau'
-    }
-    expect(subject.call(input)).to eql(expected)
+  context 'with symbol keys' do
+    subject do
+      Monolens.lens('object.keys' => ['coerce.string', 'str.upcase'])
+    end
+
+    it 'works as expected with Symbol keys' do
+      input = {
+        firstname: 'Bernard',
+        lastname: 'Lambeau'
+      }
+      expected = {
+        FIRSTNAME: 'Bernard',
+        LASTNAME: 'Lambeau'
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
   end
 
-  it 'works as expected with Symbol keys' do
-    input = {
-      firstname: 'Bernard',
-      lastname: 'Lambeau'
-    }
-    expected = {
-      FIRSTNAME: 'Bernard',
-      LASTNAME: 'Lambeau'
-    }
-    expect(subject.call(input)).to eql(expected)
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens('object.keys' => ['str.upcase'])
+    end
+
+    subject do
+      lens.call(input)
+      nil
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    let(:input) do
+      {
+        'firstname' => 'Bernard',
+        nil => 'Lambeau'
+      }
+    end
+
+    it 'correctly updates the location' do
+      expect(subject.location).to eql([nil])
+    end
   end
 end

data/spec/monolens/object/test_rename.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Monolens, 'object.rename' do
   subject do
-    Monolens.lens('object.rename' => { lastname: :name })
+    Monolens.lens('object.rename' => { defn: { lastname: :name } })
   end
 
   it 'works as expected' do

data/spec/monolens/object/test_select.rb

@@ -4,8 +4,10 @@ describe Monolens, 'object.select' do
   context 'when using symbols in the definition' do
     subject do
       Monolens.lens('object.select' => {
-        name: [:firstname, :lastname],
-        status: :priority
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        }
       })
     end
 
@@ -39,8 +41,10 @@ describe Monolens, 'object.select' do
   context 'when using strings in the definition' do
     subject do
       Monolens.lens('object.select' => {
-        'name' => ['firstname', 'lastname'],
-        'status' => 'priority'
+        'defn' => {
+          'name' => ['firstname', 'lastname'],
+          'status' => 'priority'
+        }
       })
     end
 
@@ -70,4 +74,105 @@ describe Monolens, 'object.select' do
       expect(subject.call(input)).to eql(expected)
     end
   end
+
+  context 'when a key is missing and no option' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        }
+      })
+    end
+
+    it 'raises an error' do
+      input = {
+        firstname: 'Bernard'
+      }
+      expect{
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, /lastname/)
+    end
+  end
+
+  context 'when using on_missing: skip' do
+    subject do
+      Monolens.lens('object.select' => {
+        on_missing: :skip,
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        }
+      })
+    end
+
+    it 'works as expected' do
+      input = {
+        firstname: 'Bernard'
+      }
+      expected = {
+        name: ['Bernard']
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'when using on_missing: null' do
+    subject do
+      Monolens.lens('object.select' => {
+        on_missing: :null,
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        }
+      })
+    end
+
+    it 'works as expected' do
+      input = {
+        firstname: 'Bernard'
+      }
+      expected = {
+        name: ['Bernard', nil],
+        status: nil
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'works as expected' do
+      input = {
+        priority: 12
+      }
+      expected = {
+        name: [nil, nil],
+        status: 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  describe 'error traceability' do
+    let(:lens) do
+      Monolens.lens('object.select' => {
+        defn: {
+          status: :priority
+        }
+      })
+    end
+
+    subject do
+      lens.call(input)
+      nil
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    let(:input) do
+      {}
+    end
+
+    it 'correctly updates the location' do
+      expect(subject.location).to eql([:status])
+    end
+  end
 end