plumb 0.0.1 → 0.0.2

data/lib/plumb/hash_map.rb

@@ -15,6 +15,8 @@ module Plumb
     end
 
     def call(result)
+      return result.invalid(errors: 'must be a Hash') unless result.value.is_a?(::Hash)
+
       failed = result.value.lazy.filter_map do |key, value|
         key_r = @key_type.resolve(key)
         value_r = @value_type.resolve(value)
@@ -31,5 +33,37 @@ module Plumb
     rescue StopIteration
       result
     end
+
+    def filtered
+      FilteredHashMap.new(key_type, value_type)
+    end
+
+    private def _inspect = "HashMap[#{@key_type.inspect}, #{@value_type.inspect}]"
+
+    class FilteredHashMap
+      include Steppable
+
+      attr_reader :key_type, :value_type
+
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+        freeze
+      end
+
+      def call(result)
+        result.invalid(errors: 'must be a Hash') unless result.value.is_a?(::Hash)
+
+        hash = result.value.each.with_object({}) do |(key, value), memo|
+          key_r = @key_type.resolve(key)
+          value_r = @value_type.resolve(value)
+          memo[key_r.value] = value_r.value if key_r.valid? && value_r.valid?
+        end
+
+        result.valid(hash)
+      end
+
+      private def _inspect = "HashMap[#{@key_type.inspect}, #{@value_type.inspect}].filtered"
+    end
   end
 end

data/lib/plumb/interface_class.rb

@@ -16,10 +16,10 @@ module Plumb
     def of(*args)
       case args
       in Array => symbols if symbols.all? { |s| s.is_a?(::Symbol) }
-      self.class.new(symbols)
-    else
-      raise ::ArgumentError, "unexpected value to Types::Interface#of #{args.inspect}"
-    end
+        self.class.new(symbols)
+      else
+        raise ::ArgumentError, "unexpected value to Types::Interface#of #{args.inspect}"
+      end
     end
 
     alias [] of
@@ -31,5 +31,7 @@ module Plumb
 
       result
     end
+
+    private def _inspect = "Interface[#{method_names.join(', ')}]"
   end
 end

data/lib/plumb/json_schema_visitor.rb

@@ -19,39 +19,43 @@ module Plumb
     MINIMUM = 'minimum'
     MAXIMUM = 'maximum'
 
-    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 |node, props|
+      props.merge(stringify_keys(node._metadata))
     end
 
-    on(:step) do |type, props|
-      props.merge(stringify_keys(type._metadata))
+    on(:interface) do |_node, props|
+      props
     end
 
-    on(:hash) do |type, props|
+    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 +63,187 @@ 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
 
-      visit(type.value, props)
+    on(:value) do |node, props|
+      props = case node.value
+              when ::String, ::Symbol, ::Numeric
+                props.merge(CONST => node.value)
+              else
+                props
+              end
+
+      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)
-      else
-        props
-      end
-
-      visit(type.value, props)
+    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(:rules) do |type, props|
-      type.rules.reduce(props) do |acc, rule|
+    on(:rules) do |node, props|
+      node.rules.reduce(props) do |acc, rule|
         acc.merge(visit(rule))
       end
     end
 
-    on(:rule_included_in) do |type, props|
-      props.merge(ENUM => type.arg_value)
+    on(:rule_included_in) do |node, props|
+      props.merge(ENUM => node.arg_value)
     end
 
-    on(:match) do |type, props|
-      visit(type.matcher, 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 |type, props|
+    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(:hash_map) do |type, props|
+    on(::Array) do |_node, props|
+      props.merge(TYPE => 'array')
+    end
+
+    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

@@ -13,17 +13,20 @@ module Plumb
 
       @matcher = matcher
       @error = error.nil? ? build_error(matcher) : (error % matcher)
-    end
-
-    def inspect
-      %(#{name}[#{@matcher.inspect}])
+      freeze
     end
 
     def call(result)
       @matcher === result.value ? result : result.invalid(errors: @error)
     end
 
-    private def build_error(matcher)
+    private
+
+    def _inspect
+      @matcher.inspect
+    end
+
+    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,49 +68,53 @@ 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|
+      props.merge(static: node.value)
     end
 
-    on(:rules) do |type, props|
-      type.rules.reduce(props) do |acc, rule|
+    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
   end

data/lib/plumb/rules.rb

@@ -8,12 +8,12 @@ module Plumb
     UndefinedRuleError = Class.new(KeyError)
 
     class Registry
-      RuleDef = Data.define(:name, :error_tpl, :callable, :metadata_key, :expects) do
+      RuleDef = Data.define(:name, :error_tpl, :callable, :expects) do
         def supports?(type)
           types = [type].flatten # may be an array of types for OR logic
           case expects
           when Symbol
-            types.all? { |type| type.public_instance_methods.include?(expects) }
+            types.all? { |type| type && type.public_instance_methods.include?(expects) }
           when Class then types.all? { |type| type <= expects }
           when Object then true
           else raise "Unexpected expects: #{expects}"
@@ -29,7 +29,6 @@ module Plumb
 
         def node_name = :"rule_#{rule_def.name}"
         def name = rule_def.name
-        def metadata_key = rule_def.metadata_key
 
         def error_for(result)
           return nil if rule_def.callable.call(result, arg_value)
@@ -42,10 +41,10 @@ module Plumb
         @definitions = Hash.new { |h, k| h[k] = Set.new }
       end
 
-      def define(name, error_tpl, callable = nil, metadata_key: name, expects: Object, &block)
+      def define(name, error_tpl, callable = nil, expects: Object, &block)
         name = name.to_sym
         callable ||= block
-        @definitions[name] << RuleDef.new(name:, error_tpl:, callable:, metadata_key:, expects:)
+        @definitions[name] << RuleDef.new(name:, error_tpl:, callable:, expects:)
       end
 
       # Ex. size: 3, match: /foo/
@@ -54,10 +53,10 @@ module Plumb
           rule_defs = @definitions.fetch(name.to_sym) { raise UndefinedRuleError, "no rule defined with :#{name}" }
           rule_def = rule_defs.find { |rd| rd.supports?(for_type) }
           unless rule_def
-            raise UnsupportedRuleError, "No :#{name} rule for type #{for_type}" unless for_type.is_a?(Array)
+            raise UnsupportedRuleError, "No :#{name} rule for type #{for_type.inspect}" unless for_type.is_a?(Array)
 
             raise UnsupportedRuleError,
-              "Can't apply :#{name} rule for types #{for_type}. All types must support the same rule implementation"
+                  "Can't apply :#{name} rule for types #{for_type}. All types must support the same rule implementation"
 
           end