monolens 0.2.0 → 0.5.0

data/spec/monolens/coerce/test_date.rb

@@ -5,13 +5,43 @@ describe Monolens, 'coerce.date' do
     Monolens.lens('coerce.date' => { formats: ['%d/%m/%Y'] })
   end
 
+  it 'returns Date objects unchanged (idempotency)' do
+    input = Date.today
+    expect(subject.call(input)).to be(input)
+  end
+
   it 'coerces valid dates' 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

@@ -2,16 +2,79 @@ require 'spec_helper'
 
 describe Monolens, 'coerce.datetime' do
   subject do
-    Monolens.lens('coerce.datetime' => { formats: ['%d/%m/%Y %H:%M'] })
+    Monolens.lens('coerce.datetime' => {
+    }.merge(options))
   end
 
-  it 'coerces valid date times' do
-    expect(subject.call('11/12/2022 17:38')).to eql(DateTime.parse('2022-12-11 17:38'))
+  let(:options) do
+    {}
   end
 
-  it 'fails on invalid dates' do
-    expect {
-      subject.call('invalid')
-    }.to raise_error(Monolens::LensError)
+  it 'returns DateTime objects unchanged (idempotency)' do
+    input = DateTime.now
+    expect(subject.call(input)).to be(input)
+  end
+
+  describe 'support for formats' do
+    let(:options) do
+      { formats: ['%d/%m/%Y %H:%M'] }
+    end
+
+    it 'coerces valid date times' do
+      expect(subject.call('11/12/2022 17:38')).to eql(DateTime.parse('2022-12-11 17:38'))
+    end
+  end
+
+  describe 'support for a timezone' do
+    let(:options) do
+      { parser: timezone }
+    end
+
+    let(:now) do
+      ::DateTime.now
+    end
+
+    let(:timezone) do
+      Object.new
+    end
+
+    before do
+      expect(timezone).to receive(:parse).and_return(now)
+    end
+
+    it 'uses it to parse' do
+      expect(subject.call('2022-01-01')).to be(now)
+    end
+  end
+
+  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_integer.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Monolens, 'coerce.integer' do
+  subject do
+    Monolens.lens('coerce.integer')
+  end
+
+  it 'is idempotent' do
+    expect(subject.call(12)).to eql(12)
+  end
+
+  it 'coerces valid integers' do
+    expect(subject.call('12')).to eql(12)
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => 'coerce.integer'
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+        nil
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    let(:input) do
+      ['12sh']
+    end
+
+    it 'fails on invalid integers' 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/command/map-upcase.lens.yml

@@ -0,0 +1,5 @@
+---
+version: '1.0'
+lenses:
+- array.map:
+    - str.upcase

data/spec/monolens/command/names-with-null.json

@@ -0,0 +1,5 @@
+[
+  "Bernard",
+  null,
+  "David"
+]

data/spec/monolens/command/names.json

@@ -0,0 +1,4 @@
+[
+  "Bernard",
+  "David"
+]

data/spec/monolens/command/robust-map-upcase.lens.yml

@@ -0,0 +1,7 @@
+---
+version: '1.0'
+lenses:
+- array.map:
+    on_error: handler
+    lenses:
+    - str.upcase

data/spec/monolens/core/test_dig.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Monolens, "core.dig" do
+  let(:lens) do
+    Monolens.lens('core.dig' => { defn: ['hobbies', 1, 'name'] })
+  end
+
+  it 'works' do
+    input = {
+      hobbies: [
+        { name: 'programming' },
+        { name: 'music' }
+      ]
+    }
+    expected = 'music'
+    expect(lens.call(input)).to eql(expected)
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          lenses: {
+            'core.dig' => {
+              on_missing: on_missing,
+              defn: ['hobbies', 1, 'name']
+            }.compact
+          }
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    context 'default behavior' do
+      let(:on_missing) do
+        nil
+      end
+
+      let(:input) do
+        [{
+          hobbies: [
+            { name: 'programming' }
+          ]
+        }]
+      end
+
+      it 'fails as expected' do
+        expect(subject).to be_a(Monolens::LensError)
+        expect(subject.location).to eql([0])
+      end
+    end
+
+    context 'on_missing: null' do
+      let(:on_missing) do
+        :null
+      end
+
+      let(:input) do
+        [{
+          hobbies: [
+            { name: 'programming' }
+          ]
+        }]
+      end
+
+      it 'works' do
+        expect(subject).to eql([nil])
+      end
+    end
+  end
+end

data/spec/monolens/core/test_mapping.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Monolens, 'core.mapping' do
   let(:mapping) do
-    { 'values' => { 'todo' => 'open' }}
+    { 'values' => { 'todo' => 'open' } }
   end
 
   context 'with default options' do
@@ -14,14 +14,16 @@ describe Monolens, 'core.mapping' do
       expect(subject.call('todo')).to eql('open')
     end
 
-    it 'returns nil if not found' do
-      expect(subject.call('nosuchone')).to eql(nil)
+    it 'raises if not found' do
+      expect {
+        subject.call('nosuchone')
+      }.to raise_error(Monolens::LensError)
     end
   end
 
-  context 'specifying a default value' do
+  context 'on_missing: default' do
     subject do
-      Monolens.lens('core.mapping' => mapping.merge('default' => 'foo'))
+      Monolens.lens('core.mapping' => mapping.merge('on_missing' => 'default', 'default' => 'foo'))
     end
 
     it 'replaces the value by its mapped' do
@@ -33,19 +35,59 @@ describe Monolens, 'core.mapping' do
     end
   end
 
-  context 'lets raise if not found' do
+  context 'on_missing: null' do
     subject do
-      Monolens.lens('core.mapping' => mapping.merge('fail_if_missing' => true))
+      Monolens.lens('core.mapping' => mapping.merge('on_missing' => 'null'))
     end
 
     it 'replaces the value by its mapped' do
       expect(subject.call('todo')).to eql('open')
     end
 
-    it 'raises if not found' do
-      expect {
-        subject.call('nosuchone')
-      }.to raise_error(Monolens::LensError)
+    it 'returns nil if missing' do
+      expect(subject.call('nosuchone')).to eql(nil)
+    end
+  end
+
+  context 'on_missing: fallback' do
+    subject do
+      Monolens.lens('core.mapping' => mapping.merge(
+        'on_missing' => 'fallback',
+        'fallback' => ->(lens, arg, world) { 'foo' }
+      ))
+    end
+
+    it 'replaces the value by its mapped' do
+      expect(subject.call('todo')).to eql('open')
+    end
+
+    it 'returns nil if missing' do
+      expect(subject.call('nosuchone')).to eql('foo')
+    end
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => {
+            'core.mapping' => mapping.merge('on_missing' => 'fail')
+          }
+        }
+      })
+    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_extend.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Monolens, 'object.extend' do
+  subject do
+    Monolens.lens('object.extend' => {
+      defn: {
+        name: [
+          { 'core.dig' => { defn: ['firstname'] } },
+          'str.upcase'
+        ]
+      }
+    })
+  end
+
+  it 'works as expected' do
+    input = {
+      'firstname' => 'Bernard',
+      'lastname' => 'Lambeau'
+    }
+    expected = input.merge({
+      'name' => 'BERNARD',
+    })
+    expect(subject.call(input)).to eql(expected)
+  end
+
+  describe 'on_error' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => {
+            'object.extend' => {
+              on_error: on_error,
+              defn: {
+                upcased: [
+                  { 'core.dig' => { defn: ['firstname'] } },
+                  'str.upcase'
+                ]
+              }
+            }.compact
+          }
+        }
+      })
+    end
+
+    subject do
+      lens.call(input)
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    context 'default' do
+      let(:on_error) do
+        nil
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to be_a(Monolens::LensError)
+        expect(subject.location).to eql([0, :upcased])
+      end
+    end
+
+    context 'with :null' do
+      let(:on_error) do
+        :null
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to eql([{'upcased' => nil}])
+      end
+    end
+
+    context 'with :skip' do
+      let(:on_error) do
+        :skip
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to eql([{}])
+      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