plumb 0.0.2 → 0.0.4

data/lib/plumb/{steppable.rb → composable.rb}

@@ -10,6 +10,7 @@ module Plumb
 
     def to_s = inspect
     def node_name = :undefined
+    def empty? = true
   end
 
   TypeError = Class.new(::TypeError)
@@ -22,10 +23,6 @@ module Plumb
   NOOP = ->(result) { result }
 
   module Callable
-    def metadata
-      MetadataVisitor.call(self)
-    end
-
     def resolve(value = Undefined)
       call(Result.wrap(value))
     end
@@ -42,9 +39,15 @@ module Plumb
     end
   end
 
-  module Steppable
-    include Callable
+  # This module gets included by Composable,
+  # but only when Composable is `included` in classes, not `extended`.
+  # The rule of this module is to assign a name to constants that point to Composable instances.
+  module Naming
+    attr_reader :name
 
+    # When including this module,
+    # define a #node_name method on the Composable instance
+    # #node_name is used by Visitors to determine the type of node.
     def self.included(base)
       nname = base.name.split('::').last
       nname.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
@@ -54,20 +57,6 @@ module Plumb
       base.define_method(:node_name) { nname }
     end
 
-    def self.wrap(callable)
-      if callable.is_a?(Steppable)
-        callable
-      elsif callable.is_a?(::Hash)
-        HashClass.new(schema: callable)
-      elsif callable.respond_to?(:call)
-        Step.new(callable)
-      else
-        MatchClass.new(callable)
-      end
-    end
-
-    attr_reader :name
-
     class Name
       def initialize(name)
         @name = name
@@ -93,17 +82,42 @@ module Plumb
     def inspect = name.to_s
 
     def node_name = self.class.name.split('::').last.to_sym
+  end
+
+  #  Composable mixes in composition methods to classes.
+  # such as #>>, #|, #not, and others.
+  # Any Composable class can participate in Plumb compositions.
+  module Composable
+    include Callable
+
+    # This only runs when including Composable,
+    # not extending classes with it.
+    def self.included(base)
+      base.send(:include, Naming)
+    end
+
+    def self.wrap(callable)
+      if callable.is_a?(Composable)
+        callable
+      elsif callable.is_a?(::Hash)
+        HashClass.new(schema: callable)
+      elsif callable.respond_to?(:call)
+        Step.new(callable)
+      else
+        MatchClass.new(callable)
+      end
+    end
 
     def defer(definition = nil, &block)
       Deferred.new(definition || block)
     end
 
     def >>(other)
-      And.new(self, Steppable.wrap(other))
+      And.new(self, Composable.wrap(other))
     end
 
     def |(other)
-      Or.new(self, Steppable.wrap(other))
+      Or.new(self, Composable.wrap(other))
     end
 
     def transform(target_type, callable = nil, &block)
@@ -111,11 +125,15 @@ module Plumb
     end
 
     def check(errors = 'did not pass the check', &block)
-      self >> MatchClass.new(block, error: errors)
+      self >> MatchClass.new(block, error: errors, label: errors)
     end
 
-    def meta(data = {})
-      self >> Metadata.new(data)
+    def metadata(data = Undefined)
+      if data == Undefined
+        MetadataVisitor.call(self)
+      else
+        self >> Metadata.new(data)
+      end
     end
 
     def not(other = self)
@@ -136,24 +154,8 @@ module Plumb
 
     def [](val) = match(val)
 
-    DefaultProc = proc do |callable|
-      proc do |result|
-        result.valid(callable.call)
-      end
-    end
-
-    def default(val = Undefined, &block)
-      val_type = if val == Undefined
-                   DefaultProc.call(block)
-                 else
-                   Types::Static[val]
-                 end
-
-      self | (Types::Undefined >> val_type)
-    end
-
     class Node
-      include Steppable
+      include Composable
 
       attr_reader :node_name, :type, :attributes
 
@@ -171,40 +173,49 @@ module Plumb
       Node.new(node_name, self, metadata)
     end
 
-    def nullable
-      Types::Nil | self
-    end
-
-    def present
-      Types::Present >> self
-    end
-
-    def options(opts = [])
-      rule(included_in: opts)
-    end
-
-    def rule(*args)
-      specs = case args
-              in [::Symbol => rule_name, value]
-                { rule_name => value }
-              in [::Hash => rules]
-                rules
-              else
-                raise ArgumentError, "expected 1 or 2 arguments, but got #{args.size}"
-              end
-
-      self >> Rules.new(specs, metadata[:type])
+    # Register a policy for this step.
+    # Mode 1.a: #policy(:name, arg) a single policy with an argument
+    # Mode 1.b: #policy(:name) a single policy without an argument
+    # Mode 2: #policy(p1: value, p2: value) multiple policies with arguments
+    # The latter mode will be expanded to multiple #policy calls.
+    # @return [Step]
+    def policy(*args, &blk)
+      case args
+      in [::Symbol => name, *rest] # #policy(:name, arg)
+        types = Array(metadata[:type]).uniq
+
+        bargs = [self]
+        arg = Undefined
+        if rest.any?
+          bargs << rest.first
+          arg = rest.first
+        end
+        block = Plumb.policies.get(types, name)
+        pol = block.call(*bargs, &blk)
+
+        Policy.new(name, arg, pol)
+      in [::Hash => opts] # #policy(p1: value, p2: value)
+        opts.reduce(self) { |step, (name, value)| step.policy(name, value) }
+      else
+        raise ArgumentError, "expected a symbol or hash, got #{args.inspect}"
+      end
     end
 
     def ===(other)
       case other
-      when Steppable
+      when Composable
         other == self
       else
         resolve(other).valid?
       end
     end
 
+    def ==(other)
+      other.is_a?(self.class) && other.children == children
+    end
+
+    def children = BLANK_ARRAY
+
     def build(cns, factory_method = :new, &block)
       self >> Build.new(cns, factory_method:, &block)
     end
@@ -217,7 +228,13 @@ module Plumb
       inspect
     end
 
-    # Build a step that will invoke onr or more methods on the value.
+    # @option root [Boolean] whether to include JSON Schema $schema property
+    # @return [Hash]
+    def to_json_schema(root: false)
+      JSONSchemaVisitor.call(self, root:)
+    end
+
+    # Build a step that will invoke one or more methods on the value.
     # Ex 1: Types::String.invoke(:downcase)
     # Ex 2: Types::Array.invoke(:[], 1)
     # Ex 3 chain of methods: Types::String.invoke([:downcase, :to_sym])
@@ -240,5 +257,6 @@ end
 
 require 'plumb/deferred'
 require 'plumb/transform'
+require 'plumb/policy'
 require 'plumb/build'
 require 'plumb/metadata'

data/lib/plumb/decorator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Plumb
+  # A class to help decorate all or some types in a
+  # type composition.
+  # Example:
+  #   Type = Types::Array[Types::String | Types::Integer]
+  #   Decorated = Plumb::Decorator.(Type) do |type|
+  #     if type.is_a?(Plumb::ArrayClass)
+  #       LoggerType.new(type, 'array')
+  #     else
+  #       type
+  #     end
+  #   end
+  class Decorator
+    def self.call(type, &block)
+      new(block).visit(type)
+    end
+
+    def initialize(block)
+      @block = block
+    end
+
+    # @param type [Composable]
+    # @return [Composable]
+    def visit(type)
+      type = case type
+             when And
+               left, right = visit_children(type)
+               And.new(left, right)
+             when Or
+               left, right = visit_children(type)
+               Or.new(left, right)
+             when Not
+               child = visit_children(type).first
+               Not.new(child, errors: type.errors)
+             when Policy
+               child = visit_children(type).first
+               Policy.new(type.policy_name, type.arg, child)
+             else
+               type
+             end
+
+      decorate(type)
+    end
+
+    private
+
+    def visit_children(type)
+      type.children.map { |child| visit(child) }
+    end
+
+    def decorate(type)
+      @block.call(type)
+    end
+  end
+end

data/lib/plumb/deferred.rb

@@ -4,7 +4,7 @@ require 'thread'
 
 module Plumb
   class Deferred
-    include Steppable
+    include Composable
 
     def initialize(definition)
       @lock = Mutex.new

data/lib/plumb/hash_class.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 require 'plumb/key'
 require 'plumb/static_class'
 require 'plumb/hash_map'
@@ -8,7 +8,9 @@ require 'plumb/tagged_hash'
 
 module Plumb
   class HashClass
-    include Steppable
+    include Composable
+
+    NOT_A_HASH = { _: 'must be a Hash' }.freeze
 
     attr_reader :_schema
 
@@ -30,10 +32,8 @@ module Plumb
       case args
       in [::Hash => hash]
         self.class.new(schema: _schema.merge(wrap_keys_and_values(hash)), inclusive: @inclusive)
-      in [Steppable => key_type, value_type]
-        HashMap.new(key_type, Steppable.wrap(value_type))
-      in [Class => key_type, value_type]
-        HashMap.new(Steppable.wrap(key_type), Steppable.wrap(value_type))
+      in [key_type, value_type]
+        HashMap.new(Composable.wrap(key_type), Composable.wrap(value_type))
       else
         raise ::ArgumentError, "unexpected value to Types::Hash#schema #{args.inspect}"
       end
@@ -46,9 +46,14 @@ module Plumb
     # we need to keep the right-side key, because even if the key name is the same,
     # it's optional flag might have changed
     def +(other)
-      raise ArgumentError, "expected a HashClass, got #{other.class}" unless other.is_a?(HashClass)
-
-      self.class.new(schema: merge_rightmost_keys(_schema, other._schema), inclusive: @inclusive)
+      other_schema = case other
+                     when HashClass then other._schema
+                     when ::Hash then other
+                     else
+                       raise ArgumentError, "expected a HashClass or Hash, got #{other.class}"
+                     end
+
+      self.class.new(schema: merge_rightmost_keys(_schema, other_schema), inclusive: @inclusive)
     end
 
     def &(other)
@@ -99,7 +104,7 @@ module Plumb
     end
 
     def call(result)
-      return result.invalid(errors: 'must be a Hash') unless result.value.is_a?(::Hash)
+      return result.invalid(errors: NOT_A_HASH) unless result.value.is_a?(::Hash)
       return result unless _schema.any?
 
       input = result.value
@@ -123,6 +128,10 @@ module Plumb
       errors.any? ? result.invalid(output, errors:) : result.valid(output)
     end
 
+    def ==(other)
+      other.is_a?(self.class) && other._schema == _schema
+    end
+
     private
 
     def _inspect
@@ -140,7 +149,7 @@ module Plumb
       when Callable
         hash
       else #  leaf values
-        Steppable.wrap(hash)
+        Composable.wrap(hash)
       end
     end
 

data/lib/plumb/hash_map.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class HashMap
-    include Steppable
+    include Composable
 
-    attr_reader :key_type, :value_type
+    attr_reader :children
 
     def initialize(key_type, value_type)
       @key_type = key_type
       @value_type = value_type
+      @children = [key_type, value_type].freeze
       freeze
     end
 
@@ -35,19 +36,20 @@ module Plumb
     end
 
     def filtered
-      FilteredHashMap.new(key_type, value_type)
+      FilteredHashMap.new(@key_type, @value_type)
     end
 
     private def _inspect = "HashMap[#{@key_type.inspect}, #{@value_type.inspect}]"
 
     class FilteredHashMap
-      include Steppable
+      include Composable
 
-      attr_reader :key_type, :value_type
+      attr_reader :children
 
       def initialize(key_type, value_type)
         @key_type = key_type
         @value_type = value_type
+        @children = [key_type, value_type].freeze
         freeze
       end
 

data/lib/plumb/interface_class.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class InterfaceClass
-    include Steppable
+    include Composable
 
     attr_reader :method_names
 
@@ -13,6 +13,10 @@ module Plumb
       freeze
     end
 
+    def ==(other)
+      other.is_a?(self.class) && other.method_names == method_names
+    end
+
     def of(*args)
       case args
       in Array => symbols if symbols.all? { |s| s.is_a?(::Symbol) }