plumb 0.0.1 → 0.0.3

data/lib/plumb/json_schema_visitor.rb

@@ -12,46 +12,55 @@ 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'
 
-    def self.call(type)
-      { 
-        '$schema' => 'https://json-schema.org/draft-08/schema#',
-      }.merge(new.visit(type))
+    def self.call(node)
+      {
+        '$schema' => 'https://json-schema.org/draft-08/schema#'
+      }.merge(new.visit(node))
     end
 
     private def stringify_keys(hash) = hash.transform_keys(&:to_s)
 
-    on(:any) do |type, props|
+    on(:any) do |_node, props|
       props
     end
 
-    on(:pipeline) do |type, props|
-      visit(type.type, props)
+    on(:pipeline) do |node, props|
+      visit(node.type, props)
     end
 
-    on(:step) do |type, props|
-      props.merge(stringify_keys(type._metadata))
+    on(:step) do |node, props|
+      props.merge(stringify_keys(node._metadata))
     end
 
-    on(:hash) do |type, props|
+    on(:interface) do |_node, props|
+      props
+    end
+
+    on(:hash) do |node, props|
       props.merge(
         TYPE => 'object',
-        PROPERTIES => type._schema.each_with_object({}) do |(key, value), hash|
+        PROPERTIES => node._schema.each_with_object({}) do |(key, value), hash|
           hash[key.to_s] = visit(value)
         end,
-        REQUIRED => type._schema.select { |key, value| !key.optional? }.keys.map(&:to_s)
+        REQUIRED => node._schema.reject { |key, _value| key.optional? }.keys.map(&:to_s)
       )
     end
 
-    on(:and) do |type, props|
-      left = visit(type.left)
-      right = visit(type.right)
+    on(:and) do |node, props|
+      left = visit(node.left)
+      right = visit(node.right)
       type = right[TYPE] || left[TYPE]
       props = props.merge(left).merge(right)
       props = props.merge(TYPE => type) if type
@@ -59,148 +68,225 @@ module Plumb
     end
 
     # A "default" value is usually an "or" of expected_value | (undefined >> static_value)
-    on(:or) do |type, props|
-      left = visit(type.left)
-      right = visit(type.right)
+    on(:or) do |node, props|
+      left = visit(node.left)
+      right = visit(node.right)
       any_of = [left, right].uniq
       if any_of.size == 1
         props.merge(left)
       elsif any_of.size == 2 && (defidx = any_of.index { |p| p.key?(DEFAULT) })
-        val = any_of[defidx == 0 ? 1 : 0]
+        val = any_of[defidx.zero? ? 1 : 0]
         props.merge(val).merge(DEFAULT => any_of[defidx][DEFAULT])
       else
         props.merge(ANY_OF => any_of)
       end
     end
 
-    on(:value) do |type, props|
-      props = case type.value
-      when ::String, ::Symbol, ::Numeric
-        props.merge(CONST => type.value)
-      else
-        props
-      end
+    on(:not) do |node, props|
+      props.merge(NOT => visit(node.step))
+    end
+
+    on(:value) do |node, props|
+      props = case node.value
+              when ::String, ::Symbol, ::Numeric
+                props.merge(CONST => node.value)
+              else
+                props
+              end
 
-      visit(type.value, props)
+      visit(node.value, props)
     end
 
-    on(:transform) do |type, props|
-      visit(type.target_type, props)
+    on(:transform) do |node, props|
+      visit(node.target_type, props)
     end
 
-    on(:undefined) do |type, props|
+    on(:undefined) do |_node, props|
       props
     end
 
-    on(:static) do |type, props|
-      props = case type.value
-      when ::String, ::Symbol, ::Numeric
-        props.merge(CONST => type.value, DEFAULT => type.value)
+    on(:static) do |node, props|
+      # Set const AND default
+      # to emulate static values
+      props = case node.value
+              when ::String, ::Symbol, ::Numeric
+                props.merge(CONST => node.value, DEFAULT => node.value)
+              else
+                props
+              end
+
+      visit(node.value, props)
+    end
+
+    on(:policy) do |node, props|
+      props = visit(node.step, props)
+      method_name = :"visit_#{node.policy_name}_policy"
+      if respond_to?(method_name)
+        send(method_name, node, props)
       else
         props
       end
+    end
 
-      visit(type.value, props)
+    on(:options_policy) do |node, props|
+      props.merge(ENUM => node.arg)
     end
 
-    on(:rules) do |type, props|
-      type.rules.reduce(props) do |acc, rule|
-        acc.merge(visit(rule))
+    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(:rule_included_in) do |type, props|
-      props.merge(ENUM => type.arg_value)
+    on(:excluded_from_policy) do |node, props|
+      props.merge(NOT => { ENUM => node.arg })
     end
 
-    on(:match) do |type, props|
-      visit(type.matcher, props)
+    on(Proc) do |_node, props|
+      props
     end
 
-    on(:boolean) do |type, props|
+    on(:match) do |node, props|
+      # Set const if primitive
+      props = case node.matcher
+              when ::String, ::Symbol, ::Numeric
+                props.merge(CONST => node.matcher)
+              else
+                props
+              end
+
+      visit(node.matcher, props)
+    end
+
+    on(:boolean) do |_node, props|
       props.merge(TYPE => 'boolean')
     end
 
-    on(::String) do |type, props|
+    on(::String) do |_node, props|
       props.merge(TYPE => 'string')
     end
 
-    on(::Integer) do |type, props|
+    on(::Integer) do |_node, props|
       props.merge(TYPE => 'integer')
     end
 
-    on(::Numeric) do |type, props|
+    on(::Numeric) do |_node, props|
       props.merge(TYPE => 'number')
     end
 
-    on(::BigDecimal) do |type, props|
+    on(::BigDecimal) do |_node, props|
       props.merge(TYPE => 'number')
     end
 
-    on(::Float) do |type, props|
+    on(::Float) do |_node, props|
       props.merge(TYPE => 'number')
     end
 
-    on(::TrueClass) do |type, props|
+    on(::TrueClass) do |_node, props|
       props.merge(TYPE => 'boolean')
     end
 
-    on(::NilClass) do |type, props|
+    on(::NilClass) do |_node, props|
       props.merge(TYPE => 'null')
     end
 
-    on(::FalseClass) do |type, props|
+    on(::FalseClass) do |_node, props|
       props.merge(TYPE => 'boolean')
     end
 
-    on(::Regexp) do |type, props|
-      props.merge(PATTERN => type.source)
+    on(::Regexp) do |node, props|
+      props.merge(PATTERN => node.source, TYPE => props[TYPE] || 'string')
     end
 
-    on(::Range) do |type, props|
-      opts = {}
-      opts[MINIMUM] = type.min if type.begin
-      opts[MAXIMUM] = type.max if type.end
+    on(::Range) do |node, props|
+      element = node.begin || node.end
+      opts = visit(element.class)
+      if element.is_a?(::Numeric)
+        opts[MINIMUM] = node.min if node.begin
+        opts[MAXIMUM] = node.max if node.end
+      end
       props.merge(opts)
     end
 
-    on(:metadata) do |type, props|
-      # TODO: here we should filter out the metadata that is not relevant for JSON Schema
-      props.merge(stringify_keys(type.metadata))
+    on(::Hash) do |_node, props|
+      props.merge(TYPE => 'object')
+    end
+
+    on(::Array) do |_node, props|
+      props.merge(TYPE => 'array')
     end
 
-    on(:hash_map) do |type, props|
+    on(:metadata) do |node, props|
+      #  TODO: here we should filter out the metadata that is not relevant for JSON Schema
+      props.merge(stringify_keys(node.metadata))
+    end
+
+    on(:hash_map) do |node, _props|
       {
         TYPE => 'object',
         'patternProperties' => {
-          '.*' => visit(type.value_type)
+          '.*' => visit(node.value_type)
         }
       }
     end
 
-    on(:build) do |type, props|
-      visit(type.type, props)
+    on(:filtered_hash_map) do |node, _props|
+      {
+        TYPE => 'object',
+        'patternProperties' => {
+          '.*' => visit(node.value_type)
+        }
+      }
+    end
+
+    on(:build) do |node, props|
+      visit(node.type, props)
+    end
+
+    on(:array) do |node, _props|
+      items = visit(node.element_type)
+      { TYPE => 'array', ITEMS => items }
     end
 
-    on(:array) do |type, props|
-      items = visit(type.element_type)
+    on(:stream) do |node, _props|
+      items = visit(node.element_type)
       { TYPE => 'array', ITEMS => items }
     end
 
-    on(:tuple) do |type, props|
-      items = type.types.map { |t| visit(t) }
+    on(:tuple) do |node, _props|
+      items = node.types.map { |t| visit(t) }
       { TYPE => 'array', 'prefixItems' => items }
     end
 
-    on(:tagged_hash) do |type, props|
+    on(:tagged_hash) do |node, _props|
       required = Set.new
       result = {
         TYPE => 'object',
         PROPERTIES => {}
       }
 
-      key = type.key.to_s
-      children  = type.types.map { |c| visit(c) }
+      key = node.key.to_s
+      children = node.types.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

@@ -8,22 +8,24 @@ module Plumb
 
     attr_reader :matcher
 
-    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)
-    end
-
-    def inspect
-      %(#{name}[#{@matcher.inspect}])
+      @label = matcher.is_a?(Class) ? matcher.inspect : "Match(#{label || @matcher.inspect})"
+      freeze
     end
 
     def call(result)
       @matcher === result.value ? result : result.invalid(errors: @error)
     end
 
-    private def build_error(matcher)
+    private
+
+    def _inspect = @label
+
+    def build_error(matcher)
       case matcher
       when Class # A class primitive, ex. String, Integer, etc.
         "Must be a #{matcher}"

data/lib/plumb/metadata.rb

@@ -8,8 +8,11 @@ module Plumb
 
     def initialize(metadata)
       @metadata = metadata
+      freeze
     end
 
     def call(result) = result
+
+    private def _inspect = "Metadata[#{@metadata.inspect}]"
   end
 end

data/lib/plumb/metadata_visitor.rb

@@ -6,60 +6,61 @@ module Plumb
   class MetadataVisitor
     include VisitorHandlers
 
-    def self.call(type)
-      new.visit(type)
+    def self.call(node)
+      new.visit(node)
     end
 
-    def on_missing_handler(type, props, method_name)
-      return props.merge(type: type) if type.class == Class
+    def on_missing_handler(node, props, method_name)
+      return props.merge(type: node) if node.instance_of?(Class)
 
-      puts "Missing handler for #{type.inspect} with props #{props.inspect} and method_name :#{method_name}"
+      puts "Missing handler for #{node.inspect} with props #{node.inspect} and method_name :#{method_name}"
       props
     end
 
-    on(:undefined) do |type, props|
+    on(:undefined) do |_node, props|
       props
     end
 
-    on(:any) do |type, props|
+    on(:any) do |_node, props|
       props
     end
 
-    on(:pipeline) do |type, props|
-      visit(type.type, props)
+    on(:pipeline) do |node, props|
+      visit(node.type, props)
     end
 
-    on(:step) do |type, props|
-      props.merge(type._metadata)
+    on(:step) do |node, props|
+      props.merge(node._metadata)
     end
 
-    on(::Regexp) do |type, props|
-      props.merge(pattern: type)
+    on(::Regexp) do |node, props|
+      props.merge(pattern: node, type: props[:type] || String)
     end
 
-    on(::Range) do |type, props|
-      props.merge(match: type)
+    on(::Range) do |node, props|
+      type = props[:type] || (node.begin || node.end).class
+      props.merge(match: node, type:)
     end
 
-    on(:match) do |type, props|
-      visit(type.matcher, props)
+    on(:match) do |node, props|
+      visit(node.matcher, props)
     end
 
-    on(:hash) do |type, props|
+    on(:hash) do |_node, props|
       props.merge(type: Hash)
     end
 
-    on(:and) do |type, props|
-      left = visit(type.left)
-      right = visit(type.right)
+    on(:and) do |node, props|
+      left = visit(node.left)
+      right = visit(node.right)
       type = right[:type] || left[:type]
       props = props.merge(left).merge(right)
       props = props.merge(type:) if type
       props
     end
 
-    on(:or) do |type, props|
-      child_metas = [visit(type.left), visit(type.right)]
+    on(:or) do |node, props|
+      child_metas = [visit(node.left), visit(node.right)]
       types = child_metas.map { |child| child[:type] }.flatten.compact
       types = types.first if types.size == 1
       child_metas.reduce(props) do |acc, child|
@@ -67,50 +68,63 @@ module Plumb
       end.merge(type: types)
     end
 
-    on(:value) do |type, props|
-      visit(type.value, props)
+    on(:value) do |node, props|
+      visit(node.value, props)
     end
 
-    on(:transform) do |type, props|
-      props.merge(type: type.target_type)
+    on(:transform) do |node, props|
+      props.merge(type: node.target_type)
     end
 
-    on(:static) do |type, props|
-      props.merge(static: type.value)
+    on(:static) do |node, props|
+      type = node.value.is_a?(Class) ? node.value : node.value.class
+      props.merge(static: node.value, type:)
     end
 
-    on(:rules) do |type, props|
-      type.rules.reduce(props) do |acc, rule|
+    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
     end
 
-    on(:boolean) do |type, props|
+    on(:boolean) do |_node, props|
       props.merge(type: 'boolean')
     end
 
-    on(:metadata) do |type, props|
-      props.merge(type.metadata)
+    on(:metadata) do |node, props|
+      props.merge(node.metadata)
     end
 
-    on(:hash_map) do |type, props|
+    on(:hash_map) do |_node, props|
       props.merge(type: Hash)
     end
 
-    on(:build) do |type, props|
-      visit(type.type, props)
+    on(:build) do |node, props|
+      visit(node.type, props)
     end
 
-    on(:array) do |type, props|
+    on(:array) do |_node, props|
       props.merge(type: Array)
     end
 
-    on(:tuple) do |type, props|
+    on(:stream) do |_node, props|
+      props.merge(type: Enumerator)
+    end
+
+    on(:tuple) do |_node, props|
       props.merge(type: Array)
     end
 
-    on(:tagged_hash) do |type, props|
+    on(:tagged_hash) do |_node, props|
       props.merge(type: Hash)
     end
+
+    on(Proc) do |_node, props|
+      props
+    end
   end
 end

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,31 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+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
+
+    attr_reader :policy_name, :arg, :step
+
+    # @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
+      freeze
+    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