monolens 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 704980b0a35ef47c4ea022a0b2bf39922966a11d
-  data.tar.gz: 0a032437e56dbd4d2214ba7b435120ceceb62709
+  metadata.gz: 4a6edbb2568985503bf9228ded96c6d179acc196
+  data.tar.gz: f37432cfc01970a18c57884547f5520ac31fb374
 SHA512:
-  metadata.gz: 2a580e3564f5bd208273e16c0c1da4c261917d371e0e6236bab873920b6a2372b7f36e5a085654f8f2ff79490f762cfeb68a8d38a24265d8cd4da5e983389f6e
-  data.tar.gz: '0229785824434dd14c87581f0060a784b623e3154b514bea8548d7cce94bb35563ceb6fdbc45146a883c4ca476c1c329b9adbd6a329ab1382f197377709170a6'
+  metadata.gz: e83f9436b81460041e6ed9edd73c1fd95ca8b095f2cd0d27d063649b49c8b125363735258c5d03293c1fb74afaa1d042e4a4663b47c2a45276c0b8a730d8ee77
+  data.tar.gz: 5c704058d773ab5bddc4d58541d043a63ef176ad68f9a5f7ba670335b167da7df50c7935691ecb8951e98b354bd39d79ad5d36fb8cafa210372d30d44376051f

data/lib/monolens/array/compact.rb

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

data/lib/monolens/array/join.rb

@@ -3,8 +3,8 @@ module Monolens
     class Join
       include Lens
 
-      def call(arg, *rest)
-        is_array!(arg)
+      def call(arg, world = {})
+        is_array!(arg, world)
 
         arg.join(option(:separator, ' '))
       end

data/lib/monolens/array/map.rb

@@ -3,16 +3,55 @@ module Monolens
     class Map
       include Lens
 
-      def initialize(lens)
-        super({})
-        @lens = Monolens.lens(lens)
+      def initialize(arg)
+        options, lenses = case arg
+        when ::Hash
+          opts = arg.dup; opts.delete(:lenses)
+          _, ls = fetch_on(:lenses, arg)
+          raise ArgumentError, 'Lenses are required' if ls.nil?
+          [ opts, ls ]
+        else
+          [{}, arg]
+        end
+        super(options)
+        @lenses = Monolens.lens(lenses)
       end
 
-      def call(arg, *rest)
-        is_enumerable!(arg)
+      def call(arg, world = {})
+        is_enumerable!(arg, world)
 
-        arg.map { |a| @lens.call(a) }
+        result = []
+        arg.each_with_index do |a, i|
+          deeper(world, i) do |w|
+            begin
+              result << @lenses.call(a, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, world)
+            end
+          end
+        end
+        result
       end
+
+      def handle_error(strategy, ex, result, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result << nil
+        when :skip
+          nil
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
+        end
+      end
+      private :handle_error
     end
   end
 end

data/lib/monolens/array.rb

@@ -10,8 +10,8 @@ module Monolens
     end
     module_function :join
 
-    def map(lens)
-      Map.new(lens)
+    def map(options)
+      Map.new(options)
     end
     module_function :map
 

data/lib/monolens/coerce/date.rb

@@ -5,13 +5,19 @@ module Monolens
     class Date
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      DEFAULT_FORMATS = [
+        nil
+      ]
 
-        date, first_error = nil, nil
-        @options[:formats].each do |format|
+      def call(arg, world = {})
+        is_string!(arg, world)
+
+        date = nil
+        first_error = nil
+        formats = @options.fetch(:formats, DEFAULT_FORMATS)
+        formats.each do |format|
           begin
-            return date = ::Date.strptime(arg, format)
+            return date = strptime(arg, format)
           rescue ArgumentError => ex
             first_error ||= ex
           rescue ::Date::Error => ex
@@ -19,7 +25,15 @@ module Monolens
           end
         end
 
-        raise Monolens::LensError, first_error.message
+        fail!(first_error.message, world)
+      end
+
+      def strptime(arg, format = nil)
+        if format.nil?
+          ::Date.strptime(arg)
+        else
+          ::Date.strptime(arg, format)
+        end
       end
     end
   end

data/lib/monolens/coerce/date_time.rb

@@ -5,13 +5,19 @@ module Monolens
     class DateTime
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      DEFAULT_FORMATS = [
+        nil
+      ]
 
-        date, first_error = nil, nil
-        @options[:formats].each do |format|
+      def call(arg, world = {})
+        is_string!(arg, world)
+
+        date = nil
+        first_error = nil
+        formats = @options.fetch(:formats, DEFAULT_FORMATS)
+        formats.each do |format|
           begin
-            return date = ::DateTime.strptime(arg, format)
+            return date = strptime(arg, format)
           rescue ArgumentError => ex
             first_error ||= ex
           rescue ::Date::Error => ex
@@ -19,7 +25,15 @@ module Monolens
           end
         end
 
-        raise Monolens::LensError, first_error.message
+        fail!(first_error.message, world)
+      end
+
+      def strptime(arg, format = nil)
+        if format.nil?
+          ::DateTime.strptime(arg)
+        else
+          ::DateTime.strptime(arg, format)
+        end
       end
     end
   end

data/lib/monolens/coerce/string.rb

@@ -0,0 +1,13 @@
+require 'date'
+
+module Monolens
+  module Coerce
+    class String
+      include Lens
+
+      def call(arg, world = {})
+        arg.to_s
+      end
+    end
+  end
+end

data/lib/monolens/coerce.rb

@@ -10,11 +10,14 @@ module Monolens
     end
     module_function :datetime
 
+    def string(options = {})
+      String.new(options)
+    end
+    module_function :string
+
     Monolens.define_namespace 'coerce', self
   end
 end
-require_relative 'str/strip'
-require_relative 'str/upcase'
-require_relative 'str/downcase'
 require_relative 'coerce/date'
 require_relative 'coerce/date_time'
+require_relative 'coerce/string'

data/lib/monolens/core/chain.rb

@@ -8,12 +8,12 @@ module Monolens
         @lenses = lenses
       end
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         result = arg
         @lenses.each do |lens|
           done = false
           catch(:skip) do
-            result = lens.call(result, *rest)
+            result = lens.call(result, world)
             done = true
           end
           break unless done

data/lib/monolens/core/mapping.rb

@@ -3,9 +3,9 @@ module Monolens
     class Mapping
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         option(:values, {}).fetch(arg) do
-          raise LensError if option(:fail_if_missing)
+          fail!("Unrecognized value `#{arg}`", world) if option(:fail_if_missing)
 
           option(:default)
         end

data/lib/monolens/error.rb

@@ -1,4 +1,11 @@
 module Monolens
-  class Error < StandardError; end
-  class LensError < Error; end
+  class Error < StandardError
+  end
+  class LensError < Error
+    def initialize(message, location = [])
+      super(message)
+      @location = location
+    end
+    attr_reader :location
+  end
 end

data/lib/monolens/file.rb

@@ -2,13 +2,8 @@ module Monolens
   class File
     include Lens
 
-    def initialize(info)
-      super
-      options[:lenses] = Monolens.lens(options[:lenses])
-    end
-
-    def call(*args, &bl)
-      options[:lenses].call(*args, &bl)
+    def call(arg, world = {})
+      option(:lenses).call(arg, world)
     end
   end
 end

data/lib/monolens/lens/fetch_support.rb

@@ -0,0 +1,21 @@
+module Monolens
+  module Lens
+    module FetchSupport
+
+      def fetch_on(attr, arg, default = nil)
+        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] ]
+        elsif default
+          [ attr, default ]
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/monolens/lens/location.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Lens
+    class Location
+      def initialize(parts = [])
+        @parts = parts
+      end
+
+      def deeper(part)
+        yield Location.new(@parts + [part])
+      end
+
+      def to_a
+        @parts.dup
+      end
+    end
+  end
+end

data/lib/monolens/lens/options.rb

@@ -0,0 +1,41 @@
+module Monolens
+  module Lens
+    class Options
+      include FetchSupport
+
+      def initialize(options)
+        @options = case options
+        when Hash
+          options.dup
+        else
+          { lenses: options }
+        end
+        actual, lenses = fetch_on(:lenses, @options)
+        @options[actual] = Monolens.lens(lenses) if actual && lenses
+        @options.freeze
+      end
+      attr_reader :options
+      private :options
+
+      NO_DEFAULT = Object.new.freeze
+
+      def fetch(key, default = NO_DEFAULT, on = @options)
+        if on.key?(key)
+          on[key]
+        elsif on.key?(s = key.to_s)
+          on[s]
+        elsif on.key?(sym = key.to_sym)
+          on[sym]
+        elsif default != NO_DEFAULT
+          default
+        else
+          raise Error, "Missing option #{key}"
+        end
+      end
+
+      def to_h
+        @options.dup
+      end
+    end
+  end
+end

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 ]
+  protected
+
+    def option(name, default = nil)
+      @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
 
-    def option(name, default = nil)
-      _, option = fetch_on(name, options)
-      option.nil? ? default : option
+    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
+
+    def fail!(msg, world)
+      location = world[:location]&.to_a || []
+      raise Monolens::LensError.new(msg, location)
     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,46 @@ module Monolens
     class Select
       include Lens
 
-      def initialize(selection)
-        super({})
-        @selection = selection
-      end
-
-      def call(arg, *rest)
-        is_hash!(arg)
+      def call(arg, world = {})
+        is_hash!(arg, world)
 
         result = {}
-        @selection.each_pair do |new_attr, selector|
-          is_array = selector.is_a?(::Array)
-          is_symbol = false
-          values = Array(selector).map do |old_attr|
-            actual, fetched = fetch_on(old_attr, arg)
-            is_symbol ||= actual.is_a?(Symbol)
-            fetched
+        is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
+        option(:defn, {}).each_pair do |new_attr, selector|
+          deeper(world, new_attr) do |w|
+            is_array = selector.is_a?(::Array)
+            values = []
+            Array(selector).each do |old_attr|
+              actual, fetched = fetch_on(old_attr, arg)
+              if actual.nil?
+                on_missing(old_attr, values, w)
+              else
+                values << fetched
+              end
+            end
+            new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
+            unless values.empty?
+              result[new_attr] = is_array ? values : values.first
+            end
           end
-          new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
-          result[new_attr] = is_array ? values : values.first
         end
         result
       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
+          nil
+        else
+          raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
+        end
+      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