plumb 0.0.3 → 0.0.5

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,16 @@ module Plumb
     MAX_ITEMS = 'maxItems'
     MIN_LENGTH = 'minLength'
     MAX_LENGTH = 'maxLength'
+    FORMAT = 'format'
+    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 +43,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 +64,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 +78,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 +91,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 +117,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,20 +178,29 @@ 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|
       props.merge(TYPE => 'boolean')
     end
 
+    on(:uuid) do |_node, props|
+      props.merge(TYPE => 'string', FORMAT => 'uuid')
+    end
+
+    on(:email) do |_node, props|
+      props.merge(TYPE => 'string', FORMAT => 'email')
+    end
+
     on(::String) do |_node, props|
       props.merge(TYPE => 'string')
     end
@@ -228,6 +247,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 +272,7 @@ module Plumb
       {
         TYPE => 'object',
         'patternProperties' => {
-          '.*' => visit(node.value_type)
+          '.*' => visit(node.children[1])
         }
       }
     end
@@ -254,27 +281,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 +313,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,19 +1,20 @@
 # 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?(:===)
+      raise ParseError 'matcher must respond to #===' unless matcher.respond_to?(:===)
 
       @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,11 +19,28 @@ module Plumb
       end
     end
 
-    attr_reader :type
+    class << self
+      def around_blocks
+        @around_blocks ||= []
+      end
+
+      def around(callable = nil, &block)
+        around_blocks << (callable || block)
+        self
+      end
+
+      def inherited(subclass)
+        around_blocks.each { |block| subclass.around(block) }
+        super
+      end
+    end
+
+    attr_reader :children
 
     def initialize(type = Types::Any, &setup)
       @type = type
-      @around_blocks = []
+      @children = [type].freeze
+      @around_blocks = self.class.around_blocks.dup
       return unless block_given?
 
       configure(&setup)
@@ -38,10 +55,11 @@ 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?
+      callable = prepare_step(callable)
+      callable = @around_blocks.reverse.reduce(callable) { |cl, bl| AroundStep.new(cl, bl) } if @around_blocks.any?
       @type >>= callable
       self
     end
@@ -69,5 +87,7 @@ module Plumb
 
       true
     end
+
+    def prepare_step(callable) = callable
   end
 end

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]

data/lib/plumb/schema.rb

@@ -5,13 +5,13 @@ require 'plumb/json_schema_visitor'
 
 module Plumb
   class Schema
-    include Steppable
+    include Composable
 
     def self.wrap(sch = nil, &block)
       raise ArgumentError, 'expected a block or a schema' if sch.nil? && !block_given?
 
       if sch
-        raise ArgumentError, 'expected a Steppable' unless sch.is_a?(Steppable)
+        raise ArgumentError, 'expected a Composable' unless sch.is_a?(Composable)
 
         return sch
       end
@@ -49,8 +49,8 @@ module Plumb
       self
     end
 
-    def json_schema
-      JSONSchemaVisitor.call(_hash).to_h
+    def to_json_schema
+      _hash.to_json_schema(root: true)
     end
 
     def call(result)
@@ -120,7 +120,7 @@ module Plumb
                    block_given? ? ArrayClass.new(element_type: Schema.new(&block)) : type
                  when nil
                    block_given? ? Schema.new(&block) : Types::Any
-                 when Steppable
+                 when Composable
                    type
                  when Class
                    if type == Array && block_given?
@@ -140,13 +140,14 @@ module Plumb
         self
       end
 
-      def meta(md = nil)
-        @_type = @_type.meta(md) if md
-        self
+      def metadata(data = Undefined)
+        if data == Undefined
+          @_type.metadata
+        else
+          @_type = @_type.metadata(data)
+        end
       end
 
-      def metadata = @_type.metadata
-
       def options(opts)
         @_type = @_type.options(opts)
         self

data/lib/plumb/static_class.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class StaticClass
-    include Steppable
+    include Composable
 
-    attr_reader :value
+    attr_reader :children
 
     def initialize(value = Undefined)
       raise ArgumentError, 'value must be frozen' unless value.frozen?
 
       @value = value
+      @children = [value].freeze
       freeze
     end
 

data/lib/plumb/step.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Step
-    include Steppable
+    include Composable
 
-    attr_reader :_metadata
+    attr_reader :_metadata, :children
 
     def initialize(callable = nil, inspect = nil, &block)
       @_metadata = callable.respond_to?(:metadata) ? callable.metadata : BLANK_HASH
       @callable = callable || block
+      @children = [@callable].freeze
       @inspect = inspect || @callable.inspect
       freeze
     end

data/lib/plumb/stream_class.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'thread'
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   # A stream that validates each element.
@@ -15,18 +15,19 @@ module Plumb
   #     result.value # => ['name', 10]
   #   end
   class StreamClass
-    include Steppable
+    include Composable
 
-    attr_reader :element_type
+    attr_reader :children
 
-    # @option element_type [Steppable] the type of the elements in the stream
+    # @option element_type [Composable] the type of the elements in the stream
     def initialize(element_type: Types::Any)
-      @element_type = Steppable.wrap(element_type)
+      @element_type = Composable.wrap(element_type)
+      @children = [@element_type].freeze
       freeze
     end
 
     # return a new Stream definition.
-    # @param element_type [Steppable] the type of the elements in the stream
+    # @param element_type [Composable] the type of the elements in the stream
     def [](element_type)
       self.class.new(element_type:)
     end
@@ -39,7 +40,7 @@ module Plumb
 
       enum = Enumerator.new do |y|
         result.value.each do |e|
-          y << element_type.resolve(e)
+          y << @element_type.resolve(e)
         end
       end