monolens 0.2.0 → 0.5.0

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,213 @@ describe Monolens, 'object.select' do
       expect(subject.call(input)).to eql(expected)
     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' => {
+        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)
+    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

data/spec/monolens/object/test_transform.rb

@@ -1,15 +1,102 @@
 require 'spec_helper'
 
 describe Monolens, 'object.transform' do
-  subject do
-    Monolens.lens('object.transform' => { firstname: 'str.upcase' })
+  context 'with default options' do
+    subject do
+      Monolens.lens('object.transform' => {
+        defn: { firstname: 'str.upcase' }
+      })
+    end
+
+    it 'works as expected' do
+      expect(subject.call(firstname: 'Bernard')).to eql(firstname: 'BERNARD')
+    end
+
+    it 'works as expected on an object with String keys' do
+      expect(subject.call('firstname' => 'Bernard')).to eql('firstname' => 'BERNARD')
+    end
+
+    it 'raises an error if input object does not have a key' do
+      expect {
+        subject.call(lastname: 'Lambeau')
+      }.to raise_error(Monolens::LensError, /firstname/)
+    end
+  end
+
+  context 'with on_missing: skip' do
+    subject do
+      Monolens.lens('object.transform' => {
+        on_missing: :skip,
+        defn: { firstname: 'str.upcase' }
+      })
+    end
+
+    it 'works as expected' do
+      expect(subject.call(firstname: 'Bernard')).to eql(firstname: 'BERNARD')
+    end
+
+    it 'skpis if missing' do
+      expect(subject.call(lastname: 'Lambeau')).to eql(lastname: 'Lambeau')
+    end
   end
 
-  it 'works as expected' do
-    expect(subject.call(firstname: 'Bernard')).to eql(firstname: 'BERNARD')
+  context 'with on_missing: null' do
+    subject do
+      Monolens.lens('object.transform' => {
+        on_missing: :null,
+        defn: { firstname: 'str.upcase' }
+      })
+    end
+
+    it 'works as expected' do
+      expect(subject.call(firstname: 'Bernard')).to eql(firstname: 'BERNARD')
+    end
+
+    it 'skpis if missing' do
+      expect(subject.call(lastname: 'Lambeau')).to eql(firstname: nil, lastname: 'Lambeau')
+    end
   end
 
-  it 'works as expected on an object with String keys' do
-    expect(subject.call('firstname' => 'Bernard')).to eql('firstname' => 'BERNARD')
+  describe 'error traceability' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => {
+            'object.transform' => {
+              defn: { firstname: 'str.upcase' }
+            }
+          }
+        }
+      })
+    end
+
+    subject do
+      lens.call(input)
+      nil
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    context 'when missing key' do
+      let(:input) do
+        [{}]
+      end
+
+      it 'correctly updates the location' do
+        expect(subject.location).to eql([0])
+      end
+    end
+
+    context 'when an error down the line' do
+      let(:input) do
+        [{
+          firstname: nil
+        }]
+      end
+
+      it 'correctly updates the location' do
+        expect(subject.location).to eql([0, :firstname])
+      end
+    end
   end
 end

data/spec/monolens/object/test_values.rb

@@ -1,19 +1,117 @@
 require 'spec_helper'
 
 describe Monolens, 'object.values' do
-  subject do
-    Monolens.lens('object.values' => ['str.upcase'])
+  context 'with default options' do
+    subject do
+      Monolens.lens('object.values' => ['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
+
+    it 'raises an error on any problem' do
+      input = {
+        firstname: nil,
+        lastname: 'Lambeau'
+      }
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError)
+    end
+  end
+
+  context 'with on_error: skip' do
+    subject do
+      Monolens.lens('object.values' => {
+        'on_error' => 'skip',
+        'lenses' => ['str.upcase']
+      })
+    end
+
+    it 'skips key/value when an error occurs' do
+      input = {
+        firstname: nil,
+        lastname: 'Lambeau'
+      }
+      expected = {
+        lastname: 'LAMBEAU'
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'with on_error: null' do
+    subject do
+      Monolens.lens('object.values' => {
+        'on_error' => 'null',
+        'lenses' => ['str.upcase']
+      })
+    end
+
+    it 'uses nil as value' do
+      input = {
+        firstname: 12,
+        lastname: 'Lambeau'
+      }
+      expected = {
+        firstname: nil,
+        lastname: 'LAMBEAU'
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'with on_error: keep' do
+    subject do
+      Monolens.lens('object.values' => {
+        'on_error' => 'keep',
+        'lenses' => ['str.upcase']
+      })
+    end
+
+    it 'uses nil as value' do
+      input = {
+        firstname: 12,
+        lastname: 'Lambeau'
+      }
+      expected = {
+        firstname: 12,
+        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)
+  describe 'error traceability' do
+    let(:lens) do
+      Monolens.lens('object.values' => ['str.upcase'])
+    end
+
+    subject do
+      lens.call(input)
+      nil
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    let(:input) do
+      {
+        'firstname' => 'Bernard',
+        'lastname' => nil
+      }
+    end
+
+    it 'correctly updates the location' do
+      expect(subject.location).to eql(['lastname'])
+    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

data/spec/monolens/test_error_traceability.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Monolens, 'error traceability' do
+  context 'on a leaf monolens' do
+    let(:lens) do
+      Monolens.lens('str.upcase')
+    end
+
+    subject do
+      begin
+        lens.call(nil)
+      rescue => ex
+        ex
+      end
+    end
+
+    it 'works as expected' do
+      expect(subject).to be_a(Monolens::LensError)
+      expect(subject.location).to eql([])
+    end
+  end
+
+  context 'on array.map' do
+    let(:lens) do
+      Monolens.lens('array.map' => 'str.upcase')
+    end
+
+    subject do
+      begin
+        lens.call(['foo', nil])
+      rescue => ex
+        ex
+      end
+    end
+
+    it 'works as expected' do
+      expect(subject).to be_a(Monolens::LensError)
+      expect(subject.location).to eql([1])
+    end
+  end
+
+  context 'on array.map => object.values' do
+    let(:lens) do
+      Monolens.lens('array.map' => { lenses: { 'object.values' => 'str.upcase' } })
+    end
+
+    subject do
+      begin
+        lens.call([{ hello: 'foo' }, { hello: nil }])
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    it 'works as expected' do
+      expect(subject).to be_a(Monolens::LensError)
+      expect(subject.location).to eql([1, :hello])
+    end
+  end
+end

data/spec/monolens/test_lens.rb

@@ -16,7 +16,7 @@ describe Monolens, '.lens' do
   it 'preserves options' do
     got = Monolens.lens(:"coerce.date" => { formats: ['%Y'] })
     expect(got).to be_a(Monolens::Coerce::Date)
-    expect(got.options).to eql({ formats: ['%Y'] })
+    expect(got.options.to_h).to eql({ formats: ['%Y'] })
   end
 
   it 'allows using an Array, factors a Chain with coercion recursion' do

data/spec/test_readme.rb

@@ -23,12 +23,14 @@ describe "What's said in README" do
     lenses:
     - array.map:
       - object.transform:
-          status:
-          - str.upcase
-          body:
-          - str.strip
+          defn:
+            status:
+            - str.upcase
+            body:
+            - str.strip
       - object.rename:
-          body: description
+          defn:
+            body: description
     YML
   }