monolens 0.3.0 → 0.5.1

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/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,34 @@ 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
 
@@ -54,7 +71,7 @@ describe Monolens, 'core.mapping' do
       Monolens.lens({
         'array.map' => {
           :lenses => {
-            'core.mapping' => mapping.merge('fail_if_missing' => true)
+            'core.mapping' => mapping.merge('on_missing' => 'fail')
           }
         }
       })

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_select.rb

@@ -75,6 +75,115 @@ describe Monolens, 'object.select' do
     end
   end
 
+  context 'when using strategy: first' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        },
+        strategy: 'first',
+        on_missing: on_missing
+      }.compact)
+    end
+
+    context 'without on_missing' do
+      let(:on_missing) do
+        nil
+      end
+
+      it 'works as expected when first option is present' do
+        input = {
+          firstname: 'Bernard',
+          priority: 12
+        }
+        expected = {
+          name: 'Bernard',
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+
+      it 'works as expected when second is present' do
+        input = {
+          lastname: 'Lambeau',
+          priority: 12
+        }
+        expected = {
+          name: 'Lambeau',
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+
+      it 'fails when none is present' do
+        input = {
+          priority: 12
+        }
+        expect {
+          subject.call(input)
+        }.to raise_error(Monolens::Error)
+      end
+    end
+
+    context 'with on_missing: skip' do
+      let(:on_missing) do
+        :skip
+      end
+
+      it 'works as expected when missing' do
+        input = {
+          priority: 12
+        }
+        expected = {
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+    end
+
+    context 'with on_missing: null' do
+      let(:on_missing) do
+        :null
+      end
+
+      it 'works as expected when missing' do
+        input = {
+          priority: 12
+        }
+        expected = {
+          name: nil,
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+    end
+  end
+
+  context 'when using an array as selection' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: [
+          :firstname,
+          :priority
+        ]
+      })
+    end
+
+    it 'works as expected' do
+      input = {
+        firstname: 'Bernard',
+        lastname: 'Lambeau',
+        priority: 12
+      }
+      expected = {
+        firstname: 'Bernard',
+        priority: 12
+      }
+      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' => {
@@ -162,7 +271,6 @@ describe Monolens, 'object.select' do
 
     subject do
       lens.call(input)
-      nil
     rescue Monolens::LensError => ex
       ex
     end
@@ -172,7 +280,7 @@ describe Monolens, 'object.select' do
     end
 
     it 'correctly updates the location' do
-      expect(subject.location).to eql([:status])
+      expect(subject.location).to eql(['status'])
     end
   end
 end

data/spec/monolens/test_command.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'stringio'
+require 'monolens'
+require 'monolens/command'
+
+module Monolens
+  class Exited < Monolens::Error
+  end
+  class Command
+    attr_reader :exit_status
+
+    def do_exit(status)
+      @exit_status = status
+      raise Exited
+    end
+  end
+  describe Command do
+    FIXTURES = (Path.dir/"command").expand_path
+
+    let(:command) do
+      Command.new(argv, stdin, stdout, stderr)
+    end
+
+    let(:stdin) do
+      StringIO.new
+    end
+
+    let(:stdout) do
+      StringIO.new
+    end
+
+    let(:stderr) do
+      StringIO.new
+    end
+
+    let(:file_args) do
+      [FIXTURES/'map-upcase.lens.yml', FIXTURES/'names.json']
+    end
+
+    subject do
+      begin
+        command.call
+      rescue Exited
+      end
+    end
+
+    before do
+      subject
+    end
+
+    def exit_status
+      command.exit_status
+    end
+
+    def reloaded_json
+      JSON.parse(stdout.string)
+    end
+
+    context 'with no option nor args' do
+      let(:argv) do
+        []
+      end
+
+      it 'prints the help and exits' do
+        expect(exit_status).to eql(0)
+        expect(stdout.string).to match(/monolens/)
+      end
+    end
+
+    context 'with --version' do
+      let(:argv) do
+        ['--version']
+      end
+
+      it 'prints the version and exits' do
+        expect(exit_status).to eql(0)
+        expect(stdout.string).to eql("Monolens v#{VERSION} - (c) Enspirit #{Date.today.year}\n")
+      end
+    end
+
+    context 'with a lens and a json input' do
+      let(:argv) do
+        file_args
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(reloaded_json).to eql(['BERNARD', 'DAVID'])
+      end
+    end
+
+    context 'with --pretty' do
+      let(:argv) do
+        ['--pretty'] + file_args
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(stdout.string).to match(/^\[\n/)
+        expect(reloaded_json).to eql(['BERNARD', 'DAVID'])
+      end
+    end
+
+    context 'when yielding an error' do
+      let(:argv) do
+        [FIXTURES/'map-upcase.lens.yml', FIXTURES/'names-with-null.json']
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to eql(-2)
+        expect(stdout.string).to eql('')
+        expect(stderr.string).to eql("[1] String expected, got NilClass\n")
+      end
+    end
+
+    context 'when yielding an error on a robust lens' do
+      let(:argv) do
+        [FIXTURES/'robust-map-upcase.lens.yml', FIXTURES/'names-with-null.json']
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(stdout.string).to eql('["BERNARD","DAVID"]'+"\n")
+        expect(stderr.string).to eql("[1] String expected, got NilClass\n")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monolens
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 2022-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: bmg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Data transformations inspired by Cambria lenses
 email: blambeau@gmail.com
 executables: []
@@ -62,6 +76,7 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- bin/monolens
 - lib/monolens.rb
 - lib/monolens/array.rb
 - lib/monolens/array/compact.rb
@@ -70,17 +85,22 @@ files:
 - lib/monolens/coerce.rb
 - lib/monolens/coerce/date.rb
 - lib/monolens/coerce/date_time.rb
+- lib/monolens/coerce/integer.rb
 - lib/monolens/coerce/string.rb
+- lib/monolens/command.rb
 - lib/monolens/core.rb
 - lib/monolens/core/chain.rb
+- lib/monolens/core/dig.rb
 - lib/monolens/core/mapping.rb
 - lib/monolens/error.rb
+- lib/monolens/error_handler.rb
 - lib/monolens/file.rb
 - lib/monolens/lens.rb
 - lib/monolens/lens/fetch_support.rb
 - lib/monolens/lens/location.rb
 - lib/monolens/lens/options.rb
 - lib/monolens/object.rb
+- lib/monolens/object/extend.rb
 - lib/monolens/object/keys.rb
 - lib/monolens/object/rename.rb
 - lib/monolens/object/select.rb
@@ -102,9 +122,16 @@ files:
 - spec/monolens/array/test_map.rb
 - spec/monolens/coerce/test_date.rb
 - spec/monolens/coerce/test_datetime.rb
+- spec/monolens/coerce/test_integer.rb
 - spec/monolens/coerce/test_string.rb
+- spec/monolens/command/map-upcase.lens.yml
+- spec/monolens/command/names-with-null.json
+- spec/monolens/command/names.json
+- spec/monolens/command/robust-map-upcase.lens.yml
+- spec/monolens/core/test_dig.rb
 - spec/monolens/core/test_mapping.rb
 - spec/monolens/lens/test_options.rb
+- spec/monolens/object/test_extend.rb
 - spec/monolens/object/test_keys.rb
 - spec/monolens/object/test_rename.rb
 - spec/monolens/object/test_select.rb
@@ -115,6 +142,7 @@ files:
 - spec/monolens/str/test_split.rb
 - spec/monolens/str/test_strip.rb
 - spec/monolens/str/test_upcase.rb
+- spec/monolens/test_command.rb
 - spec/monolens/test_error_traceability.rb
 - spec/monolens/test_lens.rb
 - spec/spec_helper.rb