plumb 0.0.2 → 0.0.4

data/lib/plumb/json_schema_visitor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'date'
 require 'plumb/visitor_handlers'
 
 module Plumb
@@ -12,17 +13,26 @@ module Plumb
     DEFAULT = 'default'
     ANY_OF = 'anyOf'
     ALL_OF = 'allOf'
+    NOT = 'not'
     ENUM = 'enum'
     CONST = 'const'
     ITEMS = 'items'
     PATTERN = 'pattern'
     MINIMUM = 'minimum'
     MAXIMUM = 'maximum'
+    MIN_ITEMS = 'minItems'
+    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)
@@ -32,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|
@@ -53,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
@@ -64,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])
@@ -78,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|
@@ -103,36 +116,76 @@ 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(:rules) do |node, props|
-      node.rules.reduce(props) do |acc, rule|
-        acc.merge(visit(rule))
+    on(:policy) do |node, props|
+      props = visit_children(node, props)
+      method_name = :"visit_#{node.policy_name}_policy"
+      if respond_to?(method_name)
+        send(method_name, node, props)
+      else
+        props
       end
     end
 
-    on(:rule_included_in) do |node, props|
-      props.merge(ENUM => node.arg_value)
+    on(:options_policy) do |node, props|
+      props.merge(ENUM => node.arg)
+    end
+
+    on(:size_policy) do |node, props|
+      opts = {}
+      case props[TYPE]
+      when 'array'
+        case node.arg
+        when Range
+          opts[MIN_ITEMS] = node.arg.min if node.arg.begin
+          opts[MAX_ITEMS] = node.arg.max if node.arg.end
+        when Numeric
+          opts[MIN_ITEMS] = node.arg
+          opts[MAX_ITEMS] = node.arg
+        end
+      when 'string'
+        case node.arg
+        when Range
+          opts[MIN_LENGTH] = node.arg.min if node.arg.begin
+          opts[MAX_LENGTH] = node.arg.max if node.arg.end
+        when Numeric
+          opts[MIN_LENGTH] = node.arg
+          opts[MAX_LENGTH] = node.arg
+        end
+      end
+
+      props.merge(opts)
+    end
+
+    on(:excluded_from_policy) do |node, props|
+      props.merge(NOT => { ENUM => node.arg })
+    end
+
+    on(Proc) do |_node, props|
+      props
     end
 
     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|
@@ -185,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
@@ -202,7 +263,7 @@ module Plumb
       {
         TYPE => 'object',
         'patternProperties' => {
-          '.*' => visit(node.value_type)
+          '.*' => visit(node.children[1])
         }
       }
     end
@@ -211,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
 
@@ -243,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,18 +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)
+    def initialize(matcher = Undefined, error: nil, label: nil)
       raise TypeError '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
 
@@ -22,9 +24,7 @@ module Plumb
 
     private
 
-    def _inspect
-      @matcher.inspect
-    end
+    def _inspect = @label
 
     def build_error(matcher)
       case matcher

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,22 +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|
-      props.merge(static: node.value)
+      value = node.children[0]
+      type = value.is_a?(Class) ? value : value.class
+      props.merge(static: value, type:)
     end
 
-    on(:rules) do |node, props|
-      node.rules.reduce(props) do |acc, rule|
-        acc.merge(rule.name => rule.arg_value)
-      end
+    on(:policy) do |node, props|
+      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|
@@ -98,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
@@ -117,5 +93,9 @@ module Plumb
     on(:tagged_hash) do |_node, props|
       props.merge(type: Hash)
     end
+
+    on(Proc) do |_node, props|
+      props
+    end
   end
 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/policies.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'plumb/policies'
+
+module Plumb
+  # A policy registry for Plumb
+  # It holds and gets registered policies.
+  # Policies are callable objects that act as factories for type compositions.
+  class Policies
+    UnknownPolicyError = Class.new(StandardError)
+    MethodAlreadyDefinedError = Class.new(StandardError)
+
+    def initialize
+      @policies = {}
+    end
+
+    # Register a policy for all or specific outpyt types.
+    # Example for a policy that works for all types:
+    #   #register(Object, :my_policy, ->(node, arg) { ... })
+    # Example for a policy that works for a specific type:
+    #   #register(String, :my_policy, ->(node, arg) { ... })
+    # Example for a policy that works for a specific interface:
+    #   #register(:size, :my_policy, ->(node, arg) { ... })
+    #
+    # The policy callable takes the step it is applied to, a policy argument (if any) and a policy block (if any).
+    # Example for a policy #default(default_value = Undefined) { 'some-default-value' }
+    #   policy = proc do |type, default_value = Undefined, &block|
+    #     type | (Plumb::Types::Undefined >> Plumb::Types::Static[default_value])
+    #   end
+    #
+    # @param for_type [Class, Symbol] the type the policy is for.
+    # @param name [Symbol] the name of the policy.
+    # @param policy [Proc] the policy to register.
+    def register(for_type, name, policy)
+      @policies[name] ||= {}
+      @policies[name][for_type] = policy
+    end
+
+    # Get a policy for a given type.
+    # @param types [Array<Class>] the types
+    # @param name [Symbol] the policy name
+    # @return [#call] the policy callable
+    # @raise [UnknownPolicyError] if the policy is not registered for the given types
+    def get(types, name)
+      if (pol = resolve_shared_policy(types, name))
+        pol
+      elsif (pol = @policies.dig(name, Object))
+        raise UnknownPolicyError, "Unknown policy #{name} for #{types.inspect}" unless pol
+
+        pol
+      else
+        raise UnknownPolicyError, "Unknown or incompatible policy #{name} for #{types.inspect}"
+      end
+    end
+
+    private
+
+    def resolve_shared_policy(types, name)
+      pols = types.map do |type|
+        resolve_policy(type, name)
+      end.uniq
+      pols.size == 1 ? pols.first : nil
+    end
+
+    def resolve_policy(type, name)
+      policies = @policies[name]
+      return nil unless policies
+
+      # { Object => policy1, String => policy2, size: policy3 }
+      #
+      policies.find do |for_type, _pol|
+        case for_type
+        when Symbol # :size
+          type.instance_methods.include?(for_type)
+        when Class # String
+          for_type == type
+        end
+      end&.last
+    end
+  end
+end

data/lib/plumb/policy.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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 Composable
+
+    attr_reader :policy_name, :arg, :children
+
+    # @param policy_name [Symbol]
+    # @param arg [Object, nil] the argument to the policy, if any.
+    # @param step [Step] the step composition wrapped by this policy.
+    def initialize(policy_name, arg, step)
+      @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]
+    def call(result) = @step.call(result)
+
+    private def _inspect = @step.inspect
+  end
+end