monolens 0.1.0 → 0.4.0

data/spec/monolens/array/test_map.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Monolens, 'array.map' do
+  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
+
+  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

@@ -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

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Monolens, 'core.mapping' do
+  let(:mapping) do
+    { 'values' => { 'todo' => 'open' }}
+  end
+
+  context 'with default options' do
+    subject do
+      Monolens.lens('core.mapping' => mapping)
+    end
+
+    it 'replaces the value by its mapped' do
+      expect(subject.call('todo')).to eql('open')
+    end
+
+    it 'returns nil if not found' do
+      expect(subject.call('nosuchone')).to eql(nil)
+    end
+  end
+
+  context 'specifying a default value' do
+    subject do
+      Monolens.lens('core.mapping' => mapping.merge('default' => 'foo'))
+    end
+
+    it 'replaces the value by its mapped' do
+      expect(subject.call('todo')).to eql('open')
+    end
+
+    it 'returns the default if not found' do
+      expect(subject.call('nosuchone')).to eql('foo')
+    end
+  end
+
+  context 'lets raise if not found' do
+    subject do
+      Monolens.lens('core.mapping' => mapping.merge('fail_if_missing' => true))
+    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)
+    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_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