monolens 0.5.3 → 0.6.0

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

@@ -3,6 +3,11 @@ module Monolens
     class Values
       include Lens
 
+      signature(Type::Object, Type::Object, {
+        lenses: [Type::Lenses, false],
+        on_error: [Type::Strategy.error(%w{fail handler keep null skip}), false],
+      })
+
       def call(arg, world = {})
         is_hash!(arg, world)
 
@@ -26,16 +31,16 @@ module Monolens
         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 :handler
+          error_handler!(world).call(ex)
+        when :keep
+          result[attr] = value
         when :null
           result[attr] = nil
         when :skip
           result.delete(attr)
-        when :keep
-          result[attr] = value
         else
           raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
         end

data/lib/monolens/stdlib/object.rb

@@ -0,0 +1,55 @@
+module Monolens
+  module Object
+    extend Namespace
+
+    def allbut(options, registry)
+      Allbut.new(options, registry)
+    end
+    module_function :allbut
+
+    def extend(options, registry)
+      Extend.new(options, registry)
+    end
+    module_function :extend
+
+    def rename(options, registry)
+      Rename.new(options, registry)
+    end
+    module_function :rename
+
+    def transform(options, registry)
+      Transform.new(options, registry)
+    end
+    module_function :transform
+
+    def keys(options, registry)
+      Keys.new(options, registry)
+    end
+    module_function :keys
+
+    def values(options, registry)
+      Values.new(options, registry)
+    end
+    module_function :values
+
+    def select(options, registry)
+      Select.new(options, registry)
+    end
+    module_function :select
+
+    def merge(options, registry)
+      Merge.new(options, registry)
+    end
+    module_function :merge
+
+    Monolens.define_namespace 'object', self
+  end
+end
+require_relative 'object/allbut'
+require_relative 'object/rename'
+require_relative 'object/transform'
+require_relative 'object/keys'
+require_relative 'object/values'
+require_relative 'object/select'
+require_relative 'object/extend'
+require_relative 'object/merge'

data/lib/monolens/{skip → stdlib/skip}/null.rb

@@ -3,6 +3,8 @@ module Monolens
     class Null
       include Lens
 
+      signature(Type::Any, Type::Any)
+
       def call(arg, world = {})
         throw :skip if arg.nil?
 

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

@@ -1,7 +1,9 @@
 module Monolens
   module Skip
-    def null(options = {})
-      Null.new(options)
+    extend Namespace
+
+    def null(options, registry)
+      Null.new(options, registry)
     end
     module_function :null
 

data/lib/monolens/{str → stdlib/str}/downcase.rb

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

data/lib/monolens/{str → stdlib/str}/split.rb

@@ -3,10 +3,14 @@ module Monolens
     class Split
       include Lens
 
+      signature(Type::String, Type::Array.of(Type::String), {
+        separator: [Type::String, false]
+      })
+
       def call(arg, world = {})
         is_string!(arg, world)
 
-        sep = option(:separator)
+        sep = option(:separator, ' ')
         sep ? arg.split(sep) : arg.split
       end
     end

data/lib/monolens/{str → stdlib/str}/strip.rb

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

data/lib/monolens/{str → stdlib/str}/upcase.rb

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

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

@@ -1,22 +1,24 @@
 module Monolens
   module Str
-    def downcase(options = {})
-      Downcase.new(options)
+    extend Namespace
+
+    def downcase(options, registry)
+      Downcase.new(options, registry)
     end
     module_function :downcase
 
-    def strip(options = {})
-      Strip.new(options)
+    def strip(options, registry)
+      Strip.new(options, registry)
     end
     module_function :strip
 
-    def split(options = {})
-      Split.new(options)
+    def split(options, registry)
+      Split.new(options, registry)
     end
     module_function :split
 
-    def upcase(options = {})
-      Upcase.new(options)
+    def upcase(options, registry)
+      Upcase.new(options, registry)
     end
     module_function :upcase
 

data/lib/monolens/stdlib.rb

@@ -0,0 +1,7 @@
+require_relative 'stdlib/core'
+require_relative 'stdlib/skip'
+require_relative 'stdlib/str'
+require_relative 'stdlib/array'
+require_relative 'stdlib/object'
+require_relative 'stdlib/coerce'
+require_relative 'stdlib/check'

data/lib/monolens/type/any.rb

@@ -0,0 +1,39 @@
+module Monolens
+  module Type
+    class Any
+      include Type::ErrorHandling
+
+      def initialize(candidates)
+        @candidates = candidates
+      end
+
+      def self.of(*candidates)
+        Any.new(candidates)
+      end
+
+      def self.dress(instance, registry)
+        instance
+      end
+
+      def self.===(instance)
+        true
+      end
+
+      def ===(instance)
+        @candidates.any?{|c| c === instance }
+      end
+
+      def dress(instance, registry, &block)
+        first_error = nil
+        @candidates.each do |candidate|
+          begin
+            return candidate.dress(instance, registry, &block)
+          rescue TypeError => ex
+            first_error ||= ex
+          end
+        end
+        fail!(first_error.message, &block)
+      end
+    end
+  end
+end

data/lib/monolens/type/array.rb

@@ -0,0 +1,27 @@
+module Monolens
+  module Type
+    class Array
+      include Type::ErrorHandling
+
+      def initialize(item_type)
+        @item_type = item_type
+      end
+
+      def self.of(item_type)
+        Array.new(item_type)
+      end
+
+      def dress(instance, registry, &block)
+        fail!("Array expected, got #{instance.class}", &block) unless instance.is_a?(::Array)
+
+        instance.map{|item| @item_type.dress(item, registry, &block) }
+      end
+
+      def ===(instance)
+        instance.is_a?(::Enumerable) && instance.all?{|item|
+          @item_type === item
+        }
+      end
+    end
+  end
+end

data/lib/monolens/type/boolean.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Type
+    class Boolean
+      include Type::ErrorHandling
+
+      def self.dress(instance, registry, &block)
+        fail!("Invalid Boolean `#{instance}`") unless self === instance
+
+        instance
+      end
+
+      def self.===(instance)
+        instance == true || instance == false
+      end
+    end
+  end
+end

data/lib/monolens/type/callback.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Type
+    class Callback
+      extend Type::ErrorHandling
+
+      def self.dress(instance, registry, &block)
+        fail!("Invalid #{instance}", &block) unless self === instance
+
+        instance
+      end
+
+      def self.===(instance)
+        instance.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/monolens/type/coercible.rb

@@ -0,0 +1,10 @@
+module Monolens
+  module Type
+    class Coercible
+      def self.to(type)
+        # TODO: make me stricter
+        ::Object
+      end
+    end
+  end
+end

data/lib/monolens/type/diggable.rb

@@ -0,0 +1,9 @@
+module Monolens
+  module Type
+    class Diggable
+      def self.===(instance)
+        instance.respond_to?(:dig)
+      end
+    end
+  end
+end

data/lib/monolens/type/emptyable.rb

@@ -0,0 +1,9 @@
+module Monolens
+  module Type
+    class Emptyable
+      def self.===(instance)
+        instance.respond_to?(:empty)
+      end
+    end
+  end
+end

data/lib/monolens/type/integer.rb

@@ -0,0 +1,18 @@
+
+module Monolens
+  module Type
+    class Integer
+      extend Type::ErrorHandling
+
+      def self.===(instance)
+        instance.is_a?(::Integer)
+      end
+
+      def self.dress(instance, registry, &block)
+        fail!("Invalid integer #{instance}", &block) unless self === instance
+
+        instance
+      end
+    end
+  end
+end

data/lib/monolens/type/lenses.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Type
+    class Lenses
+      extend Type::ErrorHandling
+
+      def self.===(arg)
+        arg.is_a?(Lens)
+      end
+
+      def self.dress(value, registry, &block)
+        registry.lens(value)
+      rescue TypeError => ex
+        fail!(ex.message, &block)
+      end
+    end
+  end
+end

data/lib/monolens/type/map.rb

@@ -0,0 +1,30 @@
+module Monolens
+  module Type
+    class Map
+      include Type::ErrorHandling
+
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+      end
+
+      def self.of(key_type, value_type)
+        Map.new(key_type, value_type)
+      end
+
+      def dress(value, registry, &block)
+        fail!("Map expected, got #{value.class}", &block) unless value.is_a?(::Hash)
+
+        value.each_with_object({}) do |(k,v), memo|
+          memo[@key_type.dress(k, registry, &block)] = @value_type.dress(v, registry, &block)
+        end
+      end
+
+      def ===(instance)
+        instance.is_a?(::Hash) && instance.all?{|(k,v)|
+          @key_type === k && @value_type === v
+        }
+      end
+    end
+  end
+end

data/lib/monolens/type/object.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Type
+    class Object
+      extend Type::ErrorHandling
+
+      def self.dress(instance, registry, &block)
+        fail!("Object expected, got #{instance.class}", &block) unless instance.is_a?(::Hash)
+
+        instance
+      end
+
+      def self.===(instance)
+        instance.is_a?(::Hash)
+      end
+    end
+  end
+end

data/lib/monolens/type/responding.rb

@@ -0,0 +1,25 @@
+module Monolens
+  module Type
+    class Responding
+      include Type::ErrorHandling
+
+      def initialize(messages)
+        @messages = messages
+      end
+
+      def self.to(*messages)
+        new(messages)
+      end
+
+      def dress(instance, registry, &block)
+        fail!("Invalid #{instance}", &block) unless self === instance
+
+        instance
+      end
+
+      def ===(instance)
+        @messages.all?{|m| instance.respond_to?(m) }
+      end
+    end
+  end
+end

data/lib/monolens/type/strategy.rb

@@ -0,0 +1,56 @@
+module Monolens
+  module Type
+    class Strategy
+      include Type::ErrorHandling
+
+      def initialize(kind, valid)
+        @kind = kind
+        @valid = valid
+      end
+
+      def self.selection(valid)
+        new('selection', valid)
+      end
+
+      def self.error(valid)
+        new('error', valid)
+      end
+
+      def self.missing(valid)
+        new('missing', valid)
+      end
+
+      def self.priority(valid)
+        new('priority', valid)
+      end
+
+      def dress(arg, registry, &block)
+        case arg
+        when ::Symbol
+          fail!(arg, &block) unless @valid.include?(arg.to_s)
+          arg
+        when ::String
+          fail!(arg, &block) unless @valid.include?(arg)
+          arg.to_sym
+        when ::Array
+          fail!(arg, &block) unless (arg.map(&:to_s) - @valid).empty?
+          arg.map(&:to_sym)
+        else
+          fail!(arg, &block)
+        end
+      end
+
+      def ===(arg)
+        !!dress(arg, nil)
+      rescue TypeError
+        false
+      end
+
+    private
+
+      def fail!(arg, &block)
+        super("Invalid #{kind}strategy `#{arg}`", &block)
+      end
+    end
+  end
+end

data/lib/monolens/type/string.rb

@@ -0,0 +1,18 @@
+
+module Monolens
+  module Type
+    class String
+      extend Type::ErrorHandling
+
+      def self.===(instance)
+        instance.is_a?(::String)
+      end
+
+      def self.dress(instance, registry, &block)
+        fail!("Invalid string #{instance}", &block) unless self === instance
+
+        instance
+      end
+    end
+  end
+end

data/lib/monolens/type/symbol.rb

@@ -0,0 +1,20 @@
+
+module Monolens
+  module Type
+    class Symbol
+      extend Type::ErrorHandling
+
+      def self.===(instance)
+        instance.is_a?(::Symbol)
+      end
+
+      def self.dress(instance, registry, &block)
+        unless instance.is_a?(::String) or instance.is_a?(::Symbol)
+          fail!("Invalid symbol #{instance}", &block)
+        end
+
+        instance.to_sym
+      end
+    end
+  end
+end

data/lib/monolens/type.rb

@@ -0,0 +1,33 @@
+module Monolens
+  module Type
+    module ErrorHandling
+      def fail!(message, &block)
+        block.call(message)
+      end
+    end
+
+    require_relative 'type/any'
+    require_relative 'type/array'
+    require_relative 'type/boolean'
+    require_relative 'type/callback'
+    require_relative 'type/coercible'
+    require_relative 'type/emptyable'
+    require_relative 'type/diggable'
+    require_relative 'type/integer'
+    require_relative 'type/map'
+    require_relative 'type/responding'
+    require_relative 'type/lenses'
+    require_relative 'type/object'
+    require_relative 'type/strategy'
+    require_relative 'type/string'
+    require_relative 'type/symbol'
+
+    Date = ::Date
+
+    DateTime = ::DateTime
+
+    DateTimeParser = Responding.to(:parse, :strptime)
+
+    Name = Any.of(Type::Symbol, Type::String)
+  end
+end

data/lib/monolens/version.rb

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