monolens 0.2.0 → 0.5.0

data/lib/monolens/lens.rb

@@ -1,51 +1,67 @@
+require_relative 'lens/fetch_support'
+require_relative 'lens/options'
+require_relative 'lens/location'
+
 module Monolens
   module Lens
+    include FetchSupport
+
     def initialize(options = {})
-      @options = options.each_with_object({}){|(k,v),memo|
-        memo[k.to_sym] = v
-      }
+      @options = Options.new(options)
     end
     attr_reader :options
 
-    def fetch_on(attr, arg)
-      if arg.key?(attr)
-        [ attr, arg[attr] ]
-      elsif arg.key?(attr_s = attr.to_s)
-        [ attr_s, arg[attr_s] ]
-      elsif arg.key?(attr_sym = attr.to_sym)
-        [ attr_sym, arg[attr_sym] ]
-      else
-        [ attr, nil ]
-      end
+    def fail!(msg, world)
+      location = world[:location]&.to_a || []
+      raise Monolens::LensError.new(msg, location)
     end
 
+  protected
+
     def option(name, default = nil)
-      _, option = fetch_on(name, options)
-      option.nil? ? default : option
+      @options.fetch(name, default)
+    end
+
+    def deeper(world, part)
+      world[:location] ||= Location.new
+      world[:location].deeper(part) do |loc|
+        yield(world.merge(location: loc))
+      end
+    end
+
+    MISSING_ERROR_HANDLER = <<~TXT
+      An :error_handler world entry is required to use error handling
+    TXT
+
+    def error_handler!(world)
+      _, handler = fetch_on(:error_handler, world)
+      return handler if handler
+
+      raise Monolens::Error, MISSING_ERROR_HANDLER
     end
 
-    def is_string!(arg)
+    def is_string!(arg, world)
       return if arg.is_a?(::String)
 
-      raise Monolens::Error, "String expected, got #{arg.class}"
+      fail!("String expected, got #{arg.class}", world)
     end
 
-    def is_hash!(arg)
+    def is_hash!(arg, world)
       return if arg.is_a?(::Hash)
 
-      raise Monolens::Error, "Hash expected, got #{arg.class}"
+      fail!("Hash expected, got #{arg.class}", world)
     end
 
-    def is_enumerable!(arg)
+    def is_enumerable!(arg, world)
       return if arg.is_a?(::Enumerable)
 
-      raise Monolens::Error, "Enumerable expected, got #{arg.class}"
+      fail!("Enumerable expected, got #{arg.class}", world)
     end
 
-    def is_array!(arg)
+    def is_array!(arg, world)
       return if arg.is_a?(::Array)
 
-      raise Monolens::Error, "Array expected, got #{arg.class}"
+      fail!("Array expected, got #{arg.class}", world)
     end
   end
 end

data/lib/monolens/object/extend.rb

@@ -0,0 +1,53 @@
+module Monolens
+  module Object
+    class Extend
+      include Lens
+
+      def initialize(options)
+        super(options)
+        ts = option(:defn, {})
+        ts.each_pair do |k,v|
+          ts[k] = Monolens.lens(v)
+        end
+      end
+
+      def call(arg, world = {})
+        is_hash!(arg, world)
+
+        result = arg.dup
+        is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
+        option(:defn, {}).each_pair do |attr, lens|
+          deeper(world, attr) do |w|
+            actual = is_symbol ? attr.to_sym : attr.to_s
+            begin
+              result[actual] = lens.call(arg, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, actual, world)
+            end
+          end
+        end
+        result
+      end
+
+      def handle_error(strategy, ex, result, attr, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, attr, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result[attr] = nil
+        when :skip
+          nil
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
+        end
+      end
+      private :handle_error
+    end
+  end
+end

data/lib/monolens/object/keys.rb

@@ -3,19 +3,17 @@ module Monolens
     class Keys
       include Lens
 
-      def initialize(lens)
-        super({})
-        @lens = Monolens.lens(lens)
-      end
-
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
 
+        lenses = option(:lenses)
         dup = {}
         arg.each_pair do |attr, value|
-          lensed = @lens.call(attr.to_s)
-          lensed = lensed.to_sym if lensed && attr.is_a?(Symbol)
-          dup[lensed] = value
+          deeper(world, attr) do |w|
+            lensed = lenses.call(attr, w)
+            lensed = lensed.to_sym if lensed && attr.is_a?(Symbol)
+            dup[lensed] = value
+          end
         end
         dup
       end

data/lib/monolens/object/rename.rb

@@ -3,11 +3,11 @@ module Monolens
     class Rename
       include Lens
 
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
 
         dup = arg.dup
-        options.each_pair do |oldname, newname|
+        option(:defn).each_pair do |oldname, newname|
           actual_name, value = fetch_on(oldname, arg)
           newname = actual_name.is_a?(Symbol) ? newname.to_sym : newname.to_s
           dup.delete(actual_name)

data/lib/monolens/object/select.rb

@@ -3,28 +3,84 @@ module Monolens
     class Select
       include Lens
 
-      def initialize(selection)
-        super({})
-        @selection = selection
+      def call(arg, world = {})
+        is_hash!(arg, world)
+
+        result = {}
+        is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
+        defn.each_pair do |new_attr, selector|
+          new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
+
+          deeper(world, new_attr) do |w|
+            catch (:skip) do
+              value = do_select(arg, selector, w)
+              result[new_attr] = value
+            end
+          end
+        end
+        result
       end
 
-      def call(arg, *rest)
-        is_hash!(arg)
+    private
 
-        result = {}
-        @selection.each_pair do |new_attr, selector|
-          is_array = selector.is_a?(::Array)
-          is_symbol = false
-          values = Array(selector).map do |old_attr|
+      def do_select(arg, selector, world)
+        if selector.is_a?(::Array)
+          do_array_select(arg, selector, world)
+        else
+          do_single_select(arg, selector, world)
+        end
+      end
+
+      def do_array_select(arg, selector, world)
+        case option(:strategy, :all).to_sym
+        when :all
+          selector.each_with_object([]) do |old_attr, values|
+            catch (:skip) do
+              values << do_single_select(arg, old_attr, world)
+            end
+          end
+        when :first
+          selector.each do |old_attr|
             actual, fetched = fetch_on(old_attr, arg)
-            is_symbol ||= actual.is_a?(Symbol)
-            fetched
+            return fetched if actual
           end
-          new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
-          result[new_attr] = is_array ? values : values.first
+          on_missing(selector.first, [], world).first
+        else
+          raise Monolens::Error, "Unexpected strategy `#{strategy}`"
+        end
+      end
+
+      def do_single_select(arg, selector, world)
+        actual, fetched = fetch_on(selector, arg)
+        if actual.nil?
+          on_missing(selector, [], world).first
+        else
+          fetched
+        end
+      end
+
+      def defn
+        defn = option(:defn, {})
+        defn = defn.each_with_object({}) do |attr, memo|
+          memo[attr] = attr
+        end if defn.is_a?(::Array)
+        defn
+      end
+
+      def on_missing(attr, values, world)
+        strategy = option(:on_missing, :fail)
+        case strategy.to_sym
+        when :fail
+          fail!("Expected `#{attr}` to be defined", world)
+        when :null
+          values << nil
+        when :skip
+          throw :skip
+        else
+          raise Monolens::Error, "Unexpected on_missing strategy `#{strategy}`"
         end
-        result
       end
+      private :on_missing
     end
   end
 end

data/lib/monolens/object/transform.rb

@@ -3,23 +3,45 @@ module Monolens
     class Transform
       include Lens
 
-      def initialize(transformation)
-        super({})
-        @transformation = transformation.each_with_object({}){|(attr,lens),memo|
-          memo[attr.to_sym] = Monolens.lens(lens)
-        }
+      def initialize(options)
+        super(options)
+        ts = option(:defn, {})
+        ts.each_pair do |k,v|
+          ts[k] = Monolens.lens(v)
+        end
       end
 
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
+
+        result = arg.dup
+        option(:defn, {}).each_pair do |attr, sub_lens|
+          deeper(world, attr) do |w|
+            actual_attr, fetched = fetch_on(attr, arg)
+            if actual_attr
+              result[actual_attr] = sub_lens.call(fetched, w)
+            else
+              on_missing(result, attr, world)
+            end
+          end
+        end
+        result
+      end
 
-        dup = arg.dup
-        @transformation.each_pair do |attr, sub_lens|
-          actual_attr, fetched = fetch_on(attr, dup)
-          dup[actual_attr] = sub_lens.call(fetched)
+      def on_missing(result, attr, world)
+        strategy = option(:on_missing, :fail)
+        case strategy&.to_sym
+        when :fail
+          fail!("Expected `#{attr}` to be defined", world)
+        when :null
+          result[attr] = nil
+        when :skip
+          nil
+        else
+          raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
         end
-        dup
       end
+      private :on_missing
     end
   end
 end

data/lib/monolens/object/values.rb

@@ -3,20 +3,44 @@ module Monolens
     class Values
       include Lens
 
-      def initialize(lens)
-        super({})
-        @lens = Monolens.lens(lens)
-      end
-
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
 
-        dup = arg.dup
+        lenses = option(:lenses)
+        result = arg.dup
         arg.each_pair do |attr, value|
-          dup[attr] = @lens.call(value)
+          deeper(world, attr) do |w|
+            begin
+              result[attr] = lenses.call(value, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, attr, value, world)
+            end
+          end
+        end
+        result
+      end
+
+      def handle_error(strategy, ex, result, attr, value, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, attr, value, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result[attr] = nil
+        when :skip
+          result.delete(attr)
+        when :keep
+          result[attr] = value
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
         end
-        dup
       end
+      private :handle_error
     end
   end
 end

data/lib/monolens/object.rb

@@ -1,5 +1,10 @@
 module Monolens
   module Object
+    def extend(options)
+      Extend.new(options)
+    end
+    module_function :extend
+
     def rename(parts)
       Rename.new(parts)
     end
@@ -33,3 +38,4 @@ require_relative 'object/transform'
 require_relative 'object/keys'
 require_relative 'object/values'
 require_relative 'object/select'
+require_relative 'object/extend'

data/lib/monolens/skip/null.rb

@@ -3,7 +3,7 @@ module Monolens
     class Null
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         throw :skip if arg.nil?
 
         arg

data/lib/monolens/str/downcase.rb

@@ -3,8 +3,8 @@ module Monolens
     class Downcase
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         arg.downcase
       end

data/lib/monolens/str/split.rb

@@ -3,8 +3,8 @@ module Monolens
     class Split
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         sep = option(:separator)
         sep ? arg.split(sep) : arg.split

data/lib/monolens/str/strip.rb

@@ -3,7 +3,9 @@ module Monolens
     class Strip
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
+        is_string!(arg, world)
+
         arg.to_s.strip
       end
     end

data/lib/monolens/str/upcase.rb

@@ -3,8 +3,8 @@ module Monolens
     class Upcase
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      def call(arg, world = {})
+        is_string!(arg, world)
 
         arg.upcase
       end

data/lib/monolens/version.rb

@@ -1,7 +1,7 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 2
+    MINOR = 5
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/lib/monolens.rb

@@ -5,6 +5,7 @@ module Monolens
   class << self
     require_relative 'monolens/version'
     require_relative 'monolens/error'
+    require_relative 'monolens/error_handler'
     require_relative 'monolens/lens'
 
     def define_namespace(name, impl_module)
@@ -43,6 +44,10 @@ module Monolens
     end
     private :chain
 
+    def file_lens(arg)
+      File.new(arg)
+    end
+
     def leaf_lens(arg)
       namespace_name, lens_name = arg.to_s.split('.')
       factor_lens(namespace_name, lens_name, {})
@@ -50,6 +55,7 @@ module Monolens
     private :leaf_lens
 
     def hash_lens(arg)
+      return file_lens(arg) if arg['version'] || arg[:version]
       raise "Invalid lens #{arg}" unless arg.size == 1
 
       name, options = arg.to_a.first

data/spec/fixtures/coerce.yml

@@ -2,5 +2,6 @@
 version: "1.0"
 lenses:
 - object.transform:
-    at:
-    - coerce.date: { formats: [ '%d/%m/%Y', '%Y/%m/%d' ] }
+    defn:
+      at:
+      - coerce.date: { formats: [ '%d/%m/%Y', '%Y/%m/%d' ] }

data/spec/fixtures/transform.yml

@@ -2,7 +2,8 @@
 version: "1.0"
 lenses:
 - object.transform:
-    firstname:
-    - str.upcase
-    lastname:
-    - str.downcase
+    defn:
+      firstname:
+      - str.upcase
+      lastname:
+      - str.downcase

data/spec/monolens/array/test_map.rb

@@ -1,13 +1,96 @@
 require 'spec_helper'
 
 describe Monolens, 'array.map' do
-  subject do
-    Monolens.lens('array.map' => 'str.upcase')
+  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
 
-  it 'joins values with spaces' do
-    input = ['hello', 'world']
-    expected = ['HELLO', 'WORLD']
-    expect(subject.call(input)).to eql(expected)
+  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