monolens 0.5.2 → 0.6.1

data/lib/monolens/lens.rb

@@ -1,13 +1,30 @@
 require_relative 'lens/fetch_support'
 require_relative 'lens/options'
 require_relative 'lens/location'
+require_relative 'lens/signature'
 
 module Monolens
   module Lens
     include FetchSupport
 
-    def initialize(options = {})
-      @options = Options.new(options)
+    module ClassMethods
+      def signature(input = nil, output = nil, options = {})
+        return @signature if input.nil?
+
+        @signature = Signature.new(input, output, options)
+      end
+    end
+
+    def self.included(by)
+      by.extend(ClassMethods)
+    end
+
+    def initialize(options, registry)
+      raise ArgumentError if options.nil?
+      raise ArgumentError unless registry.is_a?(Registry)
+      raise ArgumentError, "Missing signature on #{self.class}" unless self.class.signature
+
+      @options = Options.new(options, registry, self.class.signature)
     end
     attr_reader :options
 
@@ -18,6 +35,10 @@ module Monolens
 
   protected
 
+    def lens(*args)
+      options.lens(*args)
+    end
+
     def option(name, default = nil)
       @options.fetch(name, default)
     end
@@ -52,8 +73,8 @@ module Monolens
       fail!("Hash expected, got #{arg.class}", world)
     end
 
-    def is_enumerable!(arg, world)
-      return if arg.is_a?(::Enumerable)
+    def is_array!(arg, world)
+      return if arg.is_a?(Type::Array)
 
       fail!("Enumerable expected, got #{arg.class}", world)
     end

data/lib/monolens/macros.rb

@@ -0,0 +1,28 @@
+module Monolens
+  class Macros
+    def initialize(macros, registry)
+      @macros = macros
+      @registry = registry
+    end
+
+    def factor_lens(namespace_name, lens_name, options, registry)
+      if defn = @macros[lens_name]
+        instantiate_macro(defn, options)
+      else
+        raise Error, "No such lens #{[namespace_name, lens_name].join('.')}"
+      end
+    end
+
+  private
+
+    def instantiate_macro(defn, options)
+      instantiated = Monolens::Core.literal({
+        defn: defn,
+        jsonpath: {
+          root_symbol: '<'
+        }
+      }, @registry).call(options)
+      @registry.lens(instantiated)
+    end
+  end
+end

data/lib/monolens/namespace.rb

@@ -0,0 +1,11 @@
+module Monolens
+  module Namespace
+    def factor_lens(namespace_name, lens_name, options, registry)
+      if private_method_defined?(lens_name, false)
+        send(lens_name, options, registry)
+      else
+        raise Error, "No such lens #{[namespace_name, lens_name].join('.')}"
+      end
+    end
+  end
+end

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/{check → stdlib/check}/not_empty.rb

@@ -5,6 +5,10 @@ module Monolens
     class NotEmpty
       include Lens
 
+      signature(Type::Emptyable, Type::Emptyable, {
+        message: [Type::String, false]
+      })
+
       def call(arg, world = {})
         if arg.nil?
           do_fail!(arg, world)

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

@@ -1,7 +1,9 @@
 module Monolens
   module Check
-    def notEmpty(options)
-      NotEmpty.new(options)
+    extend Namespace
+
+    def notEmpty(options, registry)
+      NotEmpty.new(options, registry)
     end
     module_function :notEmpty
 

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)
 

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)

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)