monolens 0.5.1 → 0.6.0

data/lib/monolens/registry.rb

@@ -0,0 +1,77 @@
+module Monolens
+  class Registry
+    LENS_NAME_RX = /^[a-z]+\.[a-z][a-zA-Z\-_]+$/
+
+    def initialize(registry = {}, default_namespace = 'core')
+      @registry = registry
+      @default_namespace = default_namespace
+    end
+
+    def define_namespace(name, impl_module)
+      @registry[name] = impl_module
+    end
+
+    def load_file(file, registry = self)
+      load_yaml(::File.read(file), registry)
+    end
+
+    def load_yaml(yaml, registry = self)
+      Monolens::File.new(YAML.safe_load(yaml), registry)
+    end
+
+    def lens(arg, registry = self)
+      case arg
+      when Lens               then arg
+      when ::Array            then chain(arg, registry)
+      when ::String, ::Symbol then leaf_lens(arg, registry)
+      when ::Hash             then hash_lens(arg, registry)
+      else
+        raise Error, "No such lens #{arg} (#{arg.class})"
+      end
+    end
+
+    def fork(default_namespace = 'self')
+      Registry.new(@registry.dup, default_namespace)
+    end
+
+  private
+
+    def chain(lenses, registry)
+      Core::Chain.new(lenses.map{|l| lens(l) }, registry)
+    end
+
+    def file_lens(arg, registry)
+      File.new(arg, registry)
+    end
+
+    def leaf_lens(arg, registry)
+      namespace_name, lens_name = split_lens_name(arg)
+      factor_lens(namespace_name, lens_name, {}, registry)
+    end
+
+    def hash_lens(arg, registry)
+      return file_lens(arg, registry) if arg['version'] || arg[:version]
+      raise Error, "Invalid lens #{arg}" unless arg.size == 1
+
+      name, options = arg.to_a.first
+      namespace_name, lens_name = split_lens_name(name)
+      factor_lens(namespace_name, lens_name, options, registry)
+    end
+
+    def factor_lens(namespace_name, lens_name, options, registry)
+      if namespace = @registry[namespace_name]
+        namespace.factor_lens(namespace_name, lens_name, options, registry)
+      else
+        raise Error, "No such namespace #{namespace_name}"
+      end
+    end
+
+    def split_lens_name(name)
+      if name =~ LENS_NAME_RX
+        name.to_s.split('.')
+      else
+        [@default_namespace, name]
+      end
+    end
+  end
+end

data/lib/monolens/{array → stdlib/array}/compact.rb

@@ -3,6 +3,8 @@ module Monolens
     class Compact
       include Lens
 
+      signature(Type::Array, Type::String)
+
       def call(arg, world = {})
         is_array!(arg, world)
 

data/lib/monolens/{array → stdlib/array}/join.rb

@@ -3,6 +3,10 @@ module Monolens
     class Join
       include Lens
 
+      signature(Type::Array, Type::String, {
+        separator: [Type::String, false]
+      })
+
       def call(arg, world = {})
         is_array!(arg, world)
 

data/lib/monolens/{array → stdlib/array}/map.rb

@@ -3,44 +3,38 @@ module Monolens
     class Map
       include 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
+      signature(Type::Array, Type::Array, {
+        on_error: [Type::Strategy.error(%w{handler keep fail null skip}), false],
+        lenses: [Type::Lenses, true]
+      })
 
       def call(arg, world = {})
-        is_enumerable!(arg, world)
+        is_array!(arg, world)
 
+        lenses = option(:lenses)
         result = []
-        arg.each_with_index do |a, i|
+        arg.each_with_index do |member, i|
           deeper(world, i) do |w|
             begin
-              result << @lenses.call(a, w)
+              result << lenses.call(member, w)
             rescue Monolens::LensError => ex
               strategy = option(:on_error, :fail)
-              handle_error(strategy, ex, result, world)
+              handle_error(strategy, member, ex, result, world)
             end
           end
         end
         result
       end
 
-      def handle_error(strategy, ex, result, world)
+      def handle_error(strategy, member, 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) }
+          strategy.each{|s| handle_error(s, member, ex, result, world) }
         when :handler
           error_handler!(world).call(ex)
+        when :keep
+          result << member
         when :fail
           raise
         when :null

data/lib/monolens/{array.rb → stdlib/array.rb}

@@ -1,17 +1,19 @@
 module Monolens
   module Array
-    def compact(options = {})
-      Compact.new(options)
+    extend Namespace
+
+    def compact(options, registry)
+      Compact.new(options, registry)
     end
     module_function :compact
 
-    def join(options = {})
-      Join.new(options)
+    def join(options, registry)
+      Join.new(options, registry)
     end
     module_function :join
 
-    def map(options)
-      Map.new(options)
+    def map(options, registry)
+      Map.new(options, registry)
     end
     module_function :map
 

data/lib/monolens/stdlib/check/not_empty.rb

@@ -0,0 +1,30 @@
+require 'date'
+
+module Monolens
+  module Check
+    class NotEmpty
+      include Lens
+
+      signature(Type::Emptyable, Type::Emptyable, {
+        message: [Type::String, false]
+      })
+
+      def call(arg, world = {})
+        if arg.nil?
+          do_fail!(arg, world)
+        elsif arg.respond_to?(:empty?) && arg.empty?
+          do_fail!(arg, world)
+        else
+          arg
+        end
+      end
+
+    private
+
+      def do_fail!(arg, world)
+        message = option(:message, 'Input may not be empty')
+        fail!(message, world)
+      end
+    end
+  end
+end

data/lib/monolens/stdlib/check.rb

@@ -0,0 +1,13 @@
+module Monolens
+  module Check
+    extend Namespace
+
+    def notEmpty(options, registry)
+      NotEmpty.new(options, registry)
+    end
+    module_function :notEmpty
+
+    Monolens.define_namespace 'check', self
+  end
+end
+require_relative 'check/not_empty'

data/lib/monolens/{coerce → stdlib/coerce}/date.rb

@@ -9,6 +9,11 @@ module Monolens
         nil
       ]
 
+      signature(Type::Coercible.to(Type::String), Type::Date, {
+        parser: [Type::DateTimeParser, false],
+        formats: [Type::Array.of(Type::String), false]
+      })
+
       def call(arg, world = {})
         return arg if arg.is_a?(::Date)
 
@@ -27,7 +32,7 @@ module Monolens
           end
         end
 
-        fail!(first_error.message, world)
+        fail!("Invalid date `#{arg}`", world) if first_error
       end
 
       def strptime(arg, format = nil)

data/lib/monolens/{coerce → stdlib/coerce}/date_time.rb

@@ -9,6 +9,11 @@ module Monolens
         nil
       ]
 
+      signature(Type::Coercible.to(Type::String), Type::DateTime, {
+        parser: [Type::DateTimeParser, false],
+        formats: [Type::Array.of(Type::String), false]
+      })
+
       def call(arg, world = {})
         return arg if arg.is_a?(::DateTime)
 
@@ -16,7 +21,7 @@ module Monolens
 
         date = nil
         first_error = nil
-        formats = @options.fetch(:formats, DEFAULT_FORMATS)
+        formats = option(:formats, DEFAULT_FORMATS)
         formats.each do |format|
           begin
             return date = strptime(arg, format)
@@ -27,7 +32,7 @@ module Monolens
           end
         end
 
-        fail!(first_error.message, world)
+        fail!("Invalid DateTime `#{arg}`", world) if first_error
       end
 
     private

data/lib/monolens/{coerce → stdlib/coerce}/integer.rb

@@ -5,10 +5,14 @@ module Monolens
     class Integer
       include Lens
 
+      signature(Type::Coercible.to(Type::Integer), Type::Integer)
+
       def call(arg, world = {})
         Integer(arg)
       rescue => ex
         fail!(ex.message, world)
+      rescue ArgumentError => ex
+        fail!(ex.message, world)
       end
     end
   end

data/lib/monolens/{coerce → stdlib/coerce}/string.rb

@@ -5,6 +5,8 @@ module Monolens
     class String
       include Lens
 
+      signature(Type::Any, Type::String)
+
       def call(arg, world = {})
         arg.to_s
       end

data/lib/monolens/{coerce.rb → stdlib/coerce.rb}

@@ -1,22 +1,24 @@
 module Monolens
   module Coerce
-    def date(options = {})
-      Date.new(options)
+    extend Namespace
+
+    def date(options, registry)
+      Date.new(options, registry)
     end
     module_function :date
 
-    def integer(options = {})
-      Integer.new(options)
+    def integer(options, registry)
+      Integer.new(options, registry)
     end
     module_function :integer
 
-    def datetime(options = {})
-      DateTime.new(options)
+    def datetime(options, registry)
+      DateTime.new(options, registry)
     end
     module_function :datetime
 
-    def string(options = {})
-      String.new(options)
+    def string(options, registry)
+      String.new(options, registry)
     end
     module_function :string
 

data/lib/monolens/{core → stdlib/core}/chain.rb

@@ -3,9 +3,11 @@ module Monolens
     class Chain
       include Lens
 
-      def initialize(lenses)
-        super({})
-        @lenses = lenses
+      signature(Type::Any, Type::Any)
+
+      def initialize(options, registry)
+        super({}, registry)
+        @lenses = options.map{|l| lens(l) }
       end
 
       def call(arg, world = {})

data/lib/monolens/{core → stdlib/core}/dig.rb

@@ -3,6 +3,11 @@ module Monolens
     class Dig
       include Lens
 
+      signature(Type::Diggable, Type::Any, {
+        defn: [Type::Array.of(Type::Any.of(Type::Integer, Type::String)), true],
+        on_missing: [Type::Strategy.missing(%w{fail null}), false]
+      })
+
       def call(arg, world = {})
         option(:defn, []).inject(arg) do |memo, part|
           dig_on(part, memo, world)

data/lib/monolens/stdlib/core/literal.rb

@@ -0,0 +1,68 @@
+module Monolens
+  module Core
+    class Literal
+      include Lens
+
+      signature(Type::Any, Type::Any, {
+        defn: [Type::Any, true],
+        jsonpath: [Type::Object, false]
+      })
+
+      def initialize(options, registry)
+        super(options, registry)
+        @root_symbol = extract_jsonpath_root_symbol
+        @one_rx = Jsonpath.one_detect_rx(@root_symbol)
+        @interpolate_rx = Jsonpath.interpolate_detect_rx(@root_symbol)
+      end
+
+      def call(arg, world = {})
+        instantiate(option(:defn), arg, world)
+      end
+
+    private
+
+      def instantiate(obj, input, world)
+        case obj
+        when ::Array
+          obj.map {|item|
+            instantiate(item, input, world)
+          }
+        when ::Hash
+          obj.each_with_object({}){|(k,v),memo|
+            memo[k] = instantiate(v, input, world)
+          }
+        when @one_rx
+          Jsonpath.one(obj, input, jsonpath_options(input))
+        when @interpolate_rx
+          Jsonpath.interpolate(obj, input, jsonpath_options(input))
+        else
+          obj
+        end
+      end
+
+      def jsonpath_options(input)
+        {
+          use_symbols: use_symbols?(input),
+          root_symbol: @root_symbol
+        }
+      end
+
+      def extract_jsonpath_root_symbol
+        opts = option(:jsonpath, {})
+        _, symbol = fetch_on(:root_symbol, opts, '$')
+        symbol
+      end
+
+      def use_symbols?(input)
+        case input
+        when ::Hash
+          input.keys.any?{|s| s.is_a?(Symbol) }
+        when ::Array
+          input.any?{|x| use_symbols?(x) }
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/monolens/{core → stdlib/core}/mapping.rb

@@ -3,8 +3,16 @@ module Monolens
     class Mapping
       include Lens
 
+      signature(Type::Any, Type::Any, {
+        defn: [Type::Object, false],
+        values: [Type::Object, false],    # deprecated
+        default: [Type::Any, false],
+        fallback: [Type::Callback, false],
+        on_missing: [Type::Strategy.missing(%w{default fail fallback keep null}), false]
+      })
+
       def call(arg, world = {})
-        option(:values, {}).fetch(arg) do
+        option(:defn, option(:values, {})).fetch(arg) do
           on_missing(arg, world)
         end
       end
@@ -14,17 +22,19 @@ module Monolens
       def on_missing(arg, world)
         strategy = option(:on_missing, :fail)
         case strategy.to_sym
-        when :fail
-          fail!("Unrecognized value `#{arg}`", world)
         when :default
           option(:default, nil)
-        when :null
-          nil
+        when :fail
+          fail!("Unrecognized value `#{arg}`", world)
         when :fallback
           missing_fallback = ->(arg, world) do
             raise Monolens::Error, "Unexpected missing fallback handler"
           end
           option(:fallback, missing_fallback).call(self, arg, world)
+        when :keep
+          arg
+        when :null
+          nil
         else
           raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
         end

data/lib/monolens/stdlib/core.rb

@@ -0,0 +1,31 @@
+module Monolens
+  module Core
+    extend Namespace
+
+    def chain(options, registry)
+      Chain.new(options, registry)
+    end
+    module_function :chain
+
+    def dig(options, registry)
+      Dig.new(options, registry)
+    end
+    module_function :dig
+
+    def literal(options, registry)
+      Literal.new(options, registry)
+    end
+    module_function :literal
+
+    def mapping(options, registry)
+      Mapping.new(options, registry)
+    end
+    module_function :mapping
+
+    Monolens.define_namespace 'core', self
+  end
+end
+require_relative 'core/chain'
+require_relative 'core/dig'
+require_relative 'core/mapping'
+require_relative 'core/literal'

data/lib/monolens/stdlib/object/allbut.rb

@@ -0,0 +1,22 @@
+module Monolens
+  module Object
+    class Allbut
+      include Lens
+
+      signature(Type::Object, Type::Object, {
+        defn: [Type::Array.of(Type::Name), false]
+      })
+
+      def call(arg, world = {})
+        is_hash!(arg, world)
+
+        allbut = option(:defn, [])
+        arg.delete_if{|k|
+          allbut.include?(k) || \
+          allbut.include?(k.to_s) || \
+          allbut.include?(k.to_sym)
+        }
+      end
+    end
+  end
+end

data/lib/monolens/{object → stdlib/object}/extend.rb

@@ -3,11 +3,16 @@ module Monolens
     class Extend
       include Lens
 
-      def initialize(options)
-        super(options)
+      signature(Type::Object, Type::Object, {
+        defn: [Type::Map.of(Type::Name, Type::Lenses), false],
+        on_error: [Type::Strategy.error(%w{fail handler null skip}), false],
+      })
+
+      def initialize(options, registry)
+        super(options, registry)
         ts = option(:defn, {})
         ts.each_pair do |k,v|
-          ts[k] = Monolens.lens(v)
+          ts[k] = lens(v)
         end
       end
 
@@ -35,10 +40,10 @@ module Monolens
         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 :handler
+          error_handler!(world).call(ex)
         when :null
           result[attr] = nil
         when :skip

data/lib/monolens/{object → stdlib/object}/keys.rb

@@ -3,6 +3,10 @@ module Monolens
     class Keys
       include Lens
 
+      signature(Type::Object, Type::Object, {
+        lenses: [Type::Lenses, false],
+      })
+
       def call(arg, world = {})
         is_hash!(arg, world)
 

data/lib/monolens/stdlib/object/merge.rb

@@ -0,0 +1,56 @@
+module Monolens
+  module Object
+    class Merge
+      include Lens
+
+      signature(Type::Object, Type::Object, {
+        priority: [Type::Strategy.priority(%w{input defn}), false],
+        deep: [Type::Boolean, false],
+        defn: [Type::Object, true]
+      })
+
+      def call(input, world = {})
+        is_hash!(input, world)
+
+        v1, v2 = input, option(:defn, {})
+        if deep?
+          deep_merge(v1, v2, world, priority_at_input?)
+        else
+          normal_merge(v1, v2, world, priority_at_input?)
+        end
+      end
+
+    private
+
+      def normal_merge(v1, v2, world, priority_at_input)
+        is_hash!(v1, world)
+        is_hash!(v2, world)
+
+        v1.merge(v2) do |k, v11, v22|
+          priority_at_input? ? v11 : v22
+        end
+      end
+
+      def deep_merge(v1, v2, world, priority_at_input)
+        case v1
+        when ::Hash
+          is_hash!(v2, world)
+
+          v1.merge(v2) do |k, v11, v22|
+            deep_merge(v11, v22, world, priority_at_input)
+          end
+        else
+          priority_at_input? ? v1 : v2
+        end
+      end
+
+      def deep?
+        option(:deep, false) == true
+      end
+
+      def priority_at_input?
+        @pati ||= (option(:priority, 'defn').to_s == 'input')
+      end
+    end
+  end
+end

data/lib/monolens/{object → stdlib/object}/rename.rb

@@ -3,11 +3,15 @@ module Monolens
     class Rename
       include Lens
 
+      signature(Type::Object, Type::Object, {
+        defn: [Type::Map.of(Type::Name, Type::Name), false],
+      })
+
       def call(arg, world = {})
         is_hash!(arg, world)
 
         dup = arg.dup
-        option(:defn).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 → stdlib/object}/select.rb

@@ -3,6 +3,15 @@ module Monolens
     class Select
       include Lens
 
+      signature(Type::Object, Type::Object, {
+        strategy: [Type::Strategy.selection(%w{all first}), false],
+        defn: [Type::Any.of(
+          Type::Array.of(Type::Name),
+          Type::Map.of(Type::Name, Type::Any.of(Type::Array.of(Type::Name), Type::Name))
+        ), true],
+        on_missing: [Type::Strategy.missing(%w{fail null skip}), false]
+      })
+
       def call(arg, world = {})
         is_hash!(arg, world)