monolens 0.1.0 → 0.4.0

data/lib/monolens/lens.rb

@@ -1,44 +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] ]
-      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 is_string!(arg)
+    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, 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/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

@@ -0,0 +1,58 @@
+module Monolens
+  module Object
+    class Select
+      include Lens
+
+      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|
+          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
+        end
+        result
+      end
+
+    private
+
+      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
+          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

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
@@ -20,6 +25,11 @@ module Monolens
     end
     module_function :values
 
+    def select(lens)
+      Select.new(lens)
+    end
+    module_function :select
+
     Monolens.define_namespace 'object', self
   end
 end
@@ -27,3 +37,5 @@ require_relative 'object/rename'
 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

@@ -0,0 +1,14 @@
+module Monolens
+  module Str
+    class Split
+      include Lens
+
+      def call(arg, world = {})
+        is_string!(arg, world)
+
+        sep = option(:separator)
+        sep ? arg.split(sep) : arg.split
+      end
+    end
+  end
+end

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/str.rb

@@ -1,23 +1,29 @@
 module Monolens
   module Str
+    def downcase(options = {})
+      Downcase.new(options)
+    end
+    module_function :downcase
+
     def strip(options = {})
       Strip.new(options)
     end
     module_function :strip
 
+    def split(options = {})
+      Split.new(options)
+    end
+    module_function :split
+
     def upcase(options = {})
       Upcase.new(options)
     end
     module_function :upcase
 
-    def downcase(options = {})
-      Downcase.new(options)
-    end
-    module_function :downcase
-
     Monolens.define_namespace 'str', self
   end
 end
+require_relative 'str/downcase'
 require_relative 'str/strip'
+require_relative 'str/split'
 require_relative 'str/upcase'
-require_relative 'str/downcase'

data/lib/monolens/version.rb

@@ -1,7 +1,7 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 1
+    MINOR = 4
     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)
@@ -24,7 +25,7 @@ module Monolens
     end
 
     def load_yaml(yaml)
-      Monolens::File.new(YAML.load(yaml))
+      Monolens::File.new(YAML.safe_load(yaml))
     end
 
     def lens(arg)
@@ -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_compact.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Monolens, 'array.compact' do
+  subject do
+    Monolens.lens('array.compact')
+  end
+
+  it 'removes nils' do
+    expect(subject.call([nil, 'notnil'])).to eql(['notnil'])
+  end
+
+  it 'supports empty arrays' do
+    expect(subject.call([])).to eql([])
+  end
+end

data/spec/monolens/array/test_join.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Monolens, 'array.join' do
+  context 'when used without options' do
+    subject do
+      Monolens.lens('array.join')
+    end
+
+    it 'joins values with spaces' do
+      expect(subject.call(['hello', 'world'])).to eql('hello world')
+    end
+
+    it 'supports empty arrays' do
+      expect(subject.call([])).to eql('')
+    end
+  end
+
+  context 'when specifying the separator' do
+    subject do
+      Monolens.lens('array.join' => { separator: ', ' })
+    end
+
+    it 'joins values with it' do
+      expect(subject.call(['hello', 'world'])).to eql('hello, world')
+    end
+  end
+end