monolens 0.1.0 → 0.4.0

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

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Monolens, 'object.select' do
+  context 'when using symbols in the definition' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        }
+      })
+    end
+
+    it 'works as expected' do
+      input = {
+        firstname: 'Bernard',
+        lastname: 'Lambeau',
+        priority: 12
+      }
+      expected = {
+        name: ['Bernard', 'Lambeau'],
+        status: 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'works as with Strings' do
+      input = {
+        'firstname' => 'Bernard',
+        'lastname' => 'Lambeau',
+        'priority' => 12
+      }
+      expected = {
+        'name' => ['Bernard', 'Lambeau'],
+        'status' => 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'when using strings in the definition' do
+    subject do
+      Monolens.lens('object.select' => {
+        'defn' => {
+          'name' => ['firstname', 'lastname'],
+          'status' => 'priority'
+        }
+      })
+    end
+
+    it 'works as expected with Symbols' do
+      input = {
+        firstname: 'Bernard',
+        lastname: 'Lambeau',
+        priority: 12
+      }
+      expected = {
+        name: ['Bernard', 'Lambeau'],
+        status: 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'works with Strings' do
+      input = {
+        'firstname' => 'Bernard',
+        'lastname' => 'Lambeau',
+        'priority' => 12
+      }
+      expected = {
+        'name' => ['Bernard', 'Lambeau'],
+        'status' => 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    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)
+      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

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/skip/test_null.rb

@@ -17,7 +17,7 @@ describe Monolens, 'skip.null' do
 
   context 'when used in a Map' do
     subject do
-      Monolens.lens('map' => ['skip.null', 'str.upcase'])
+      Monolens.lens('array.map' => ['skip.null', 'str.upcase'])
     end
 
     it 'maps nils' do
@@ -27,7 +27,7 @@ describe Monolens, 'skip.null' do
 
   context 'when used in a Map, but we want no nils' do
     subject do
-      Monolens.lens(['array.compact', { 'map' => ['skip.null', 'str.upcase'] }])
+      Monolens.lens(['array.compact', { 'array.map' => ['skip.null', 'str.upcase'] }])
     end
 
     it 'works' do

data/spec/monolens/str/test_downcase.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Monolens, 'str.downcase' do
+  subject do
+    Monolens.lens('str.downcase')
+  end
+
+  it 'converts to lowercase' do
+    input = 'FOO'
+    expected = 'foo'
+    expect(subject.call(input)).to eql(expected)
+  end
+end

data/spec/monolens/str/test_split.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Monolens, 'str.split' do
+  context 'without options' do
+    subject do
+      Monolens.lens('str.split')
+    end
+
+    it 'splits a string as an array using space separator' do
+      input = 'foo bar'
+      expected = ['foo', 'bar']
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'is greedy on spaces and splits on carriage returns and tabs' do
+      input = "foo   bar\nbaz\tboz"
+      expected = ['foo', 'bar', 'baz', 'boz']
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  context 'when specifying the separator' do
+    subject do
+      Monolens.lens('str.split' => { separator: ',' })
+    end
+
+    it 'uses it' do
+      input = 'foo,bar'
+      expected = ['foo', 'bar']
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'does not make whitespace magic' do
+      input = "foo, bar"
+      expected = ['foo', ' bar']
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+end

data/spec/monolens/str/test_strip.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Monolens, 'str.strip' do
+  subject do
+    Monolens.lens('str.strip')
+  end
+
+  it 'strips leading and trailing spaces' do
+    input = '   foo  '
+    expected = 'foo'
+    expect(subject.call(input)).to eql(expected)
+  end
+end

data/spec/monolens/str/test_upcase.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Monolens, 'str.upcase' do
+  subject do
+    Monolens.lens('str.upcase')
+  end
+
+  it 'converts to uppercase' do
+    input = 'foo'
+    expected = 'FOO'
+    expect(subject.call(input)).to eql(expected)
+  end
+end