plumb 0.0.3 → 0.0.4

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
 
@@ -31,7 +33,7 @@ module Plumb
       in [::Hash => hash]
         self.class.new(schema: _schema.merge(wrap_keys_and_values(hash)), inclusive: @inclusive)
       in [key_type, value_type]
-        HashMap.new(Steppable.wrap(key_type), Steppable.wrap(value_type))
+        HashMap.new(Composable.wrap(key_type), Composable.wrap(value_type))
       else
         raise ::ArgumentError, "unexpected value to Types::Hash#schema #{args.inspect}"
       end
@@ -44,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)
@@ -97,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
@@ -121,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
@@ -138,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) }

data/lib/plumb/json_schema_visitor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'date'
 require 'plumb/visitor_handlers'
 
 module Plumb
@@ -23,11 +24,15 @@ module Plumb
     MAX_ITEMS = 'maxItems'
     MIN_LENGTH = 'minLength'
     MAX_LENGTH = 'maxLength'
+    ENVELOPE = {
+      '$schema' => 'https://json-schema.org/draft-08/schema#'
+    }.freeze
 
-    def self.call(node)
-      {
-        '$schema' => 'https://json-schema.org/draft-08/schema#'
-      }.merge(new.visit(node))
+    def self.call(node, root: true)
+      data = new.visit(node)
+      return data unless root
+
+      ENVELOPE.merge(data)
     end
 
     private def stringify_keys(hash) = hash.transform_keys(&:to_s)
@@ -37,7 +42,7 @@ module Plumb
     end
 
     on(:pipeline) do |node, props|
-      visit(node.type, props)
+      visit_children(node, props)
     end
 
     on(:step) do |node, props|
@@ -58,9 +63,12 @@ module Plumb
       )
     end
 
+    on(:data) do |node, props|
+      visit_name :hash, node._schema, props
+    end
+
     on(:and) do |node, props|
-      left = visit(node.left)
-      right = visit(node.right)
+      left, right = node.children.map { |c| visit(c) }
       type = right[TYPE] || left[TYPE]
       props = props.merge(left).merge(right)
       props = props.merge(TYPE => type) if type
@@ -69,11 +77,10 @@ module Plumb
 
     # A "default" value is usually an "or" of expected_value | (undefined >> static_value)
     on(:or) do |node, props|
-      left = visit(node.left)
-      right = visit(node.right)
-      any_of = [left, right].uniq
+      left, right = node.children.map { |c| visit(c) }
+      any_of = [left, right].uniq.filter(&:any?)
       if any_of.size == 1
-        props.merge(left)
+        props.merge(any_of.first)
       elsif any_of.size == 2 && (defidx = any_of.index { |p| p.key?(DEFAULT) })
         val = any_of[defidx.zero? ? 1 : 0]
         props.merge(val).merge(DEFAULT => any_of[defidx][DEFAULT])
@@ -83,22 +90,23 @@ module Plumb
     end
 
     on(:not) do |node, props|
-      props.merge(NOT => visit(node.step))
+      props.merge(NOT => visit_children(node))
     end
 
     on(:value) do |node, props|
-      props = case node.value
+      value = node.children.first
+      props = case value
               when ::String, ::Symbol, ::Numeric
-                props.merge(CONST => node.value)
+                props.merge(CONST => value)
               else
                 props
               end
 
-      visit(node.value, props)
+      visit(value, props)
     end
 
     on(:transform) do |node, props|
-      visit(node.target_type, props)
+      visit_children(node, props)
     end
 
     on(:undefined) do |_node, props|
@@ -108,18 +116,19 @@ module Plumb
     on(:static) do |node, props|
       # Set const AND default
       # to emulate static values
-      props = case node.value
+      value = node.children.first
+      props = case value
               when ::String, ::Symbol, ::Numeric
-                props.merge(CONST => node.value, DEFAULT => node.value)
+                props.merge(CONST => value, DEFAULT => value)
               else
                 props
               end
 
-      visit(node.value, props)
+      visit(value, props)
     end
 
     on(:policy) do |node, props|
-      props = visit(node.step, props)
+      props = visit_children(node, props)
       method_name = :"visit_#{node.policy_name}_policy"
       if respond_to?(method_name)
         send(method_name, node, props)
@@ -168,14 +177,15 @@ module Plumb
 
     on(:match) do |node, props|
       # Set const if primitive
-      props = case node.matcher
+      matcher = node.children.first
+      props = case matcher
               when ::String, ::Symbol, ::Numeric
-                props.merge(CONST => node.matcher)
+                props.merge(CONST => matcher)
               else
                 props
               end
 
-      visit(node.matcher, props)
+      visit(matcher, props)
     end
 
     on(:boolean) do |_node, props|
@@ -228,6 +238,14 @@ module Plumb
       props.merge(opts)
     end
 
+    on(::Time) do |_node, props|
+      props.merge(TYPE => 'string', 'format' => 'date-time')
+    end
+
+    on(::Date) do |_node, props|
+      props.merge(TYPE => 'string', 'format' => 'date')
+    end
+
     on(::Hash) do |_node, props|
       props.merge(TYPE => 'object')
     end
@@ -245,7 +263,7 @@ module Plumb
       {
         TYPE => 'object',
         'patternProperties' => {
-          '.*' => visit(node.value_type)
+          '.*' => visit(node.children[1])
         }
       }
     end
@@ -254,27 +272,27 @@ module Plumb
       {
         TYPE => 'object',
         'patternProperties' => {
-          '.*' => visit(node.value_type)
+          '.*' => visit(node.children[1])
         }
       }
     end
 
     on(:build) do |node, props|
-      visit(node.type, props)
+      visit_children(node, props)
     end
 
     on(:array) do |node, _props|
-      items = visit(node.element_type)
-      { TYPE => 'array', ITEMS => items }
+      items_props = visit_children(node)
+      { TYPE => 'array', ITEMS => items_props }
     end
 
     on(:stream) do |node, _props|
-      items = visit(node.element_type)
-      { TYPE => 'array', ITEMS => items }
+      items_props = visit_children(node)
+      { TYPE => 'array', ITEMS => items_props }
     end
 
     on(:tuple) do |node, _props|
-      items = node.types.map { |t| visit(t) }
+      items = node.children.map { |t| visit(t) }
       { TYPE => 'array', 'prefixItems' => items }
     end
 
@@ -286,7 +304,7 @@ module Plumb
       }
 
       key = node.key.to_s
-      children = node.types.map { |c| visit(c) }
+      children = node.children.map { |c| visit(c) }
       key_enum =  children.map { |c| c[PROPERTIES][key][CONST] }
       key_type =  children.map { |c| c[PROPERTIES][key][TYPE] }
       required << key

data/lib/plumb/match_class.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class MatchClass
-    include Steppable
+    include Composable
 
-    attr_reader :matcher
+    attr_reader :children
 
     def initialize(matcher = Undefined, error: nil, label: nil)
       raise TypeError 'matcher must respond to #===' unless matcher.respond_to?(:===)
@@ -14,6 +14,7 @@ module Plumb
       @matcher = matcher
       @error = error.nil? ? build_error(matcher) : (error % matcher)
       @label = matcher.is_a?(Class) ? matcher.inspect : "Match(#{label || @matcher.inspect})"
+      @children = [matcher].freeze
       freeze
     end
 

data/lib/plumb/metadata.rb

@@ -2,7 +2,7 @@
 
 module Plumb
   class Metadata
-    include Steppable
+    include Composable
 
     attr_reader :metadata
 
@@ -11,6 +11,10 @@ module Plumb
       freeze
     end
 
+    def ==(other)
+      other.is_a?(self.class) && @metadata == other.metadata
+    end
+
     def call(result) = result
 
     private def _inspect = "Metadata[#{@metadata.inspect}]"

data/lib/plumb/metadata_visitor.rb

@@ -10,23 +10,14 @@ module Plumb
       new.visit(node)
     end
 
-    def on_missing_handler(node, props, method_name)
+    def on_missing_handler(node, props, _method_name)
       return props.merge(type: node) if node.instance_of?(Class)
 
-      puts "Missing handler for #{node.inspect} with props #{node.inspect} and method_name :#{method_name}"
-      props
-    end
-
-    on(:undefined) do |_node, props|
-      props
-    end
+      return props unless node.respond_to?(:children)
 
-    on(:any) do |_node, props|
-      props
-    end
-
-    on(:pipeline) do |node, props|
-      visit(node.type, props)
+      node.children.reduce(props) do |acc, child|
+        visit(child, acc)
+      end
     end
 
     on(:step) do |node, props|
@@ -42,17 +33,12 @@ module Plumb
       props.merge(match: node, type:)
     end
 
-    on(:match) do |node, props|
-      visit(node.matcher, props)
-    end
-
     on(:hash) do |_node, props|
       props.merge(type: Hash)
     end
 
     on(:and) do |node, props|
-      left = visit(node.left)
-      right = visit(node.right)
+      left, right = node.children.map { |child| visit(child) }
       type = right[:type] || left[:type]
       props = props.merge(left).merge(right)
       props = props.merge(type:) if type
@@ -60,7 +46,7 @@ module Plumb
     end
 
     on(:or) do |node, props|
-      child_metas = [visit(node.left), visit(node.right)]
+      child_metas = node.children.map { |child| visit(child) }
       types = child_metas.map { |child| child[:type] }.flatten.compact
       types = types.first if types.size == 1
       child_metas.reduce(props) do |acc, child|
@@ -68,27 +54,16 @@ module Plumb
       end.merge(type: types)
     end
 
-    on(:value) do |node, props|
-      visit(node.value, props)
-    end
-
-    on(:transform) do |node, props|
-      props.merge(type: node.target_type)
-    end
-
     on(:static) do |node, props|
-      type = node.value.is_a?(Class) ? node.value : node.value.class
-      props.merge(static: node.value, type:)
+      value = node.children[0]
+      type = value.is_a?(Class) ? value : value.class
+      props.merge(static: value, type:)
     end
 
     on(:policy) do |node, props|
-      visit(node.step, props).merge(node.policy_name => node.arg)
-    end
-
-    on(:rules) do |node, props|
-      node.rules.reduce(props) do |acc, rule|
-        acc.merge(rule.name => rule.arg_value)
-      end
+      props = visit(node.children[0], props)
+      props = props.merge(node.policy_name => node.arg) unless node.arg == Plumb::Undefined
+      props
     end
 
     on(:boolean) do |_node, props|
@@ -103,10 +78,6 @@ module Plumb
       props.merge(type: Hash)
     end
 
-    on(:build) do |node, props|
-      visit(node.type, props)
-    end
-
     on(:array) do |_node, props|
       props.merge(type: Array)
     end

data/lib/plumb/not.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Not
-    include Steppable
+    include Composable
 
-    attr_reader :step
+    attr_reader :children, :errors
 
     def initialize(step, errors: nil)
       @step = step
       @errors = errors
+      @children = [step].freeze
       freeze
     end
 

data/lib/plumb/or.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Or
-    include Steppable
+    include Composable
 
-    attr_reader :left, :right
+    attr_reader :children
 
     def initialize(left, right)
       @left = left
       @right = right
+      @children = [left, right].freeze
       freeze
     end
 
@@ -23,7 +24,12 @@ module Plumb
       return left_result if left_result.valid?
 
       right_result = @right.call(result)
-      right_result.valid? ? right_result : result.invalid(errors: [left_result.errors, right_result.errors].flatten)
+      if right_result.valid?
+        right_result
+      else
+        right_result.invalid(errors: [left_result.errors,
+                                      right_result.errors].flatten)
+      end
     end
   end
 end

data/lib/plumb/pipeline.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Pipeline
-    include Steppable
+    include Composable
 
     class AroundStep
-      include Steppable
+      include Composable
 
       def initialize(step, block)
         @step = step
@@ -19,10 +19,11 @@ module Plumb
       end
     end
 
-    attr_reader :type
+    attr_reader :children
 
     def initialize(type = Types::Any, &setup)
       @type = type
+      @children = [type].freeze
       @around_blocks = []
       return unless block_given?
 
@@ -38,7 +39,7 @@ module Plumb
       callable ||= block
       unless is_a_step?(callable)
         raise ArgumentError,
-          "#step expects an interface #call(Result) Result, but got #{callable.inspect}"
+              "#step expects an interface #call(Result) Result, but got #{callable.inspect}"
       end
 
       callable = @around_blocks.reduce(callable) { |cl, bl| AroundStep.new(cl, bl) } if @around_blocks.any?

data/lib/plumb/policy.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   # Wrap a policy composition ("step") in a Policy object.
   # So that visitors such as JSONSchema and Metadata visitors
   # can define dedicated handlers for policies, if they need to.
   class Policy
-    include Steppable
+    include Composable
 
-    attr_reader :policy_name, :arg, :step
+    attr_reader :policy_name, :arg, :children
 
     # @param policy_name [Symbol]
     # @param arg [Object, nil] the argument to the policy, if any.
@@ -18,9 +18,16 @@ module Plumb
       @policy_name = policy_name
       @arg = arg
       @step = step
+      @children = [step].freeze
       freeze
     end
 
+    def ==(other)
+      other.is_a?(self.class) &&
+        policy_name == other.policy_name &&
+        arg == other.arg
+    end
+
     # The standard Step interface.
     # @param result [Result::Valid]
     # @return [Result::Valid, Result::Invalid]