plumb 0.0.1

data/lib/plumb/array_class.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'plumb/steppable'
+require 'plumb/result'
+require 'plumb/hash_class'
+
+module Plumb
+  class ArrayClass
+    include Steppable
+
+    attr_reader :element_type
+
+    def initialize(element_type: Types::Any)
+      @element_type = case element_type
+      when Steppable
+        element_type
+      when ::Hash
+        HashClass.new(element_type)
+      else
+        raise ArgumentError,
+          "element_type #{element_type.inspect} must be a Steppable"
+      end
+
+      freeze
+    end
+
+    def of(element_type)
+      self.class.new(element_type:)
+    end
+
+    alias [] of
+
+    def concurrent
+      ConcurrentArrayClass.new(element_type:)
+    end
+
+    private def _inspect
+      %(#{name}[#{element_type}])
+    end
+
+    def call(result)
+      return result.invalid(errors: 'is not an Array') unless result.value.is_a?(::Enumerable)
+
+      values, errors = map_array_elements(result.value)
+      return result.valid(values) unless errors.any?
+
+      result.invalid(errors:)
+    end
+
+    private
+
+    def map_array_elements(list)
+      # Reuse the same result object for each element
+      # to decrease object allocation.
+      # Steps might return the same result instance, so we map the values directly
+      # separate from the errors.
+      element_result = BLANK_RESULT.dup
+      errors = {}
+      values = list.map.with_index do |e, idx|
+        re = element_type.call(element_result.reset(e))
+        errors[idx] = re.errors unless re.valid?
+        re.value
+      end
+
+      [values, errors]
+    end
+
+    class ConcurrentArrayClass < self
+      private
+
+      def map_array_elements(list)
+        errors = {}
+
+        values = list
+          .map { |e| Concurrent::Future.execute { element_type.resolve(e) } }
+          .map.with_index do |f, idx|
+            re = f.value
+            errors[idx] = f.reason if f.rejected?
+            re.value
+          end
+
+        [values, errors]
+      end
+    end
+  end
+end

data/lib/plumb/build.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Build
+    include Steppable
+
+    attr_reader :type
+
+    def initialize(type, factory_method: :new, &block)
+      @type = type
+      @block = block || ->(value) { type.send(factory_method, value) }
+    end
+
+    def call(result) = result.valid(@block.call(result.value))
+  end
+end

data/lib/plumb/deferred.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+module Plumb
+  class Deferred
+    include Steppable
+
+    def initialize(definition)
+      @lock = Mutex.new
+      @definition = definition
+      @cached_type = nil
+      # freeze
+    end
+
+    def call(result)
+      cached_type.call(result)
+    end
+
+    private def cached_type
+      @lock.synchronize do
+        @cached_type = @definition.call
+        self.define_singleton_method(:cached_type) do
+          @cached_type
+        end
+        @cached_type
+      end
+    end
+  end
+end
+

data/lib/plumb/hash_class.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+require 'plumb/key'
+require 'plumb/static_class'
+require 'plumb/hash_map'
+require 'plumb/tagged_hash'
+
+module Plumb
+  class HashClass
+    include Steppable
+
+    attr_reader :_schema
+
+    def initialize(schema = {})
+      @_schema = wrap_keys_and_values(schema)
+      freeze
+    end
+
+    # A Hash type with a specific schema.
+    # Option 1: a Hash representing schema
+    #
+    #   Types::Hash[name: Types::String.present, age?: Types::Integer]
+    #
+    # Option 2: a Map with pre-defined types for all keys and values
+    #
+    #   Types::Hash[Types::String, Types::Integer]
+    def schema(*args)
+      case args
+      in [::Hash => hash]
+      self.class.new(_schema.merge(wrap_keys_and_values(hash)))
+      in [Steppable => key_type, Steppable => value_type]
+      HashMap.new(key_type, value_type)
+    else
+      raise ::ArgumentError, "unexpected value to Types::Hash#schema #{args.inspect}"
+    end
+    end
+
+    alias [] schema
+
+    # Hash#merge keeps the left-side key in the new hash
+    # if they match via #hash and #eql?
+    # 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(merge_rightmost_keys(_schema, other._schema))
+    end
+
+    def &(other)
+      raise ArgumentError, "expected a HashClass, got #{other.class}" unless other.is_a?(HashClass)
+
+      intersected_keys = other._schema.keys & _schema.keys
+      intersected = intersected_keys.each.with_object({}) do |k, memo|
+        memo[k] = other.at_key(k)
+      end
+
+      self.class.new(intersected)
+    end
+
+    def tagged_by(key, *types)
+      TaggedHash.new(self, key, types)
+    end
+
+    def at_key(a_key)
+      _schema[Key.wrap(a_key)]
+    end
+
+    def to_h = _schema
+
+    private def _inspect
+      %(#{name}[#{_schema.map { |(k, v)| [k.inspect, v.inspect].join(':') }.join(' ')}])
+    end
+
+    def call(result)
+      return result.invalid(errors: 'must be a Hash') unless result.value.is_a?(::Hash)
+      return result unless _schema.any?
+
+      input = result.value
+      errors = {}
+      field_result = BLANK_RESULT.dup
+      output = _schema.each.with_object({}) do |(key, field), ret|
+        key_s = key.to_sym
+        if input.key?(key_s)
+          r = field.call(field_result.reset(input[key_s]))
+          errors[key_s] = r.errors unless r.valid?
+          ret[key_s] = r.value
+        elsif !key.optional?
+          r = field.call(BLANK_RESULT)
+          errors[key_s] = r.errors unless r.valid?
+          ret[key_s] = r.value unless r.value == Undefined
+        end
+      end
+
+      errors.any? ? result.invalid(output, errors:) : result.valid(output)
+    end
+
+    private
+
+    def wrap_keys_and_values(hash)
+      case hash
+      when ::Array
+        hash.map { |e| wrap_keys_and_values(e) }
+      when ::Hash
+        hash.each.with_object({}) do |(k, v), ret|
+          ret[Key.wrap(k)] = wrap_keys_and_values(v)
+        end
+      when Callable
+        hash
+      else #  leaf values
+        StaticClass.new(hash)
+      end
+    end
+
+    def merge_rightmost_keys(hash1, hash2)
+      hash2.each.with_object(hash1.clone) do |(k, v), memo|
+        # assigning a key that already exist with #hash and #eql
+        # leaves the original key instance in place.
+        # but we want the hash2 key there, because its optionality could have changed.
+        memo.delete(k) if memo.key?(k)
+        memo[k] = v
+      end
+    end
+  end
+end

data/lib/plumb/hash_map.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class HashMap
+    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)
+      failed = result.value.lazy.filter_map do |key, value|
+        key_r = @key_type.resolve(key)
+        value_r = @value_type.resolve(value)
+        if !key_r.valid?
+          [:key, key, key_r]
+        elsif !value_r.valid?
+          [:value, value, value_r]
+        end
+      end
+      if (first = failed.next)
+        field, val, halt = failed.first
+        result.invalid(errors: "#{field} #{val.inspect} #{halt.errors}")
+      end
+    rescue StopIteration
+      result
+    end
+  end
+end

data/lib/plumb/interface_class.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class InterfaceClass
+    include Steppable
+
+    attr_reader :method_names
+
+    def initialize(method_names = [])
+      @method_names = method_names
+      freeze
+    end
+
+    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
+    end
+
+    alias [] of
+
+    def call(result)
+      obj = result.value
+      missing_methods = @method_names.reject { |m| obj.respond_to?(m) }
+      return result.invalid(errors: "missing methods: #{missing_methods.join(', ')}") if missing_methods.any?
+
+      result
+    end
+  end
+end

data/lib/plumb/json_schema_visitor.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'plumb/visitor_handlers'
+
+module Plumb
+  class JSONSchemaVisitor
+    include VisitorHandlers
+
+    TYPE = 'type'
+    PROPERTIES = 'properties'
+    REQUIRED = 'required'
+    DEFAULT = 'default'
+    ANY_OF = 'anyOf'
+    ALL_OF = 'allOf'
+    ENUM = 'enum'
+    CONST = 'const'
+    ITEMS = 'items'
+    PATTERN = 'pattern'
+    MINIMUM = 'minimum'
+    MAXIMUM = 'maximum'
+
+    def self.call(type)
+      { 
+        '$schema' => 'https://json-schema.org/draft-08/schema#',
+      }.merge(new.visit(type))
+    end
+
+    private def stringify_keys(hash) = hash.transform_keys(&:to_s)
+
+    on(:any) do |type, props|
+      props
+    end
+
+    on(:pipeline) do |type, props|
+      visit(type.type, props)
+    end
+
+    on(:step) do |type, props|
+      props.merge(stringify_keys(type._metadata))
+    end
+
+    on(:hash) do |type, props|
+      props.merge(
+        TYPE => 'object',
+        PROPERTIES => type._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)
+      )
+    end
+
+    on(:and) do |type, props|
+      left = visit(type.left)
+      right = visit(type.right)
+      type = right[TYPE] || left[TYPE]
+      props = props.merge(left).merge(right)
+      props = props.merge(TYPE => type) if type
+      props
+    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)
+      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]
+        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
+
+      visit(type.value, props)
+    end
+
+    on(:transform) do |type, props|
+      visit(type.target_type, props)
+    end
+
+    on(:undefined) do |type, 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)
+    end
+
+    on(:rules) do |type, props|
+      type.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)
+    end
+
+    on(:match) do |type, props|
+      visit(type.matcher, props)
+    end
+
+    on(:boolean) do |type, props|
+      props.merge(TYPE => 'boolean')
+    end
+
+    on(::String) do |type, props|
+      props.merge(TYPE => 'string')
+    end
+
+    on(::Integer) do |type, props|
+      props.merge(TYPE => 'integer')
+    end
+
+    on(::Numeric) do |type, props|
+      props.merge(TYPE => 'number')
+    end
+
+    on(::BigDecimal) do |type, props|
+      props.merge(TYPE => 'number')
+    end
+
+    on(::Float) do |type, props|
+      props.merge(TYPE => 'number')
+    end
+
+    on(::TrueClass) do |type, props|
+      props.merge(TYPE => 'boolean')
+    end
+
+    on(::NilClass) do |type, props|
+      props.merge(TYPE => 'null')
+    end
+
+    on(::FalseClass) do |type, props|
+      props.merge(TYPE => 'boolean')
+    end
+
+    on(::Regexp) do |type, props|
+      props.merge(PATTERN => type.source)
+    end
+
+    on(::Range) do |type, props|
+      opts = {}
+      opts[MINIMUM] = type.min if type.begin
+      opts[MAXIMUM] = type.max if type.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))
+    end
+
+    on(:hash_map) do |type, props|
+      {
+        TYPE => 'object',
+        'patternProperties' => {
+          '.*' => visit(type.value_type)
+        }
+      }
+    end
+
+    on(:build) do |type, props|
+      visit(type.type, props)
+    end
+
+    on(:array) do |type, props|
+      items = visit(type.element_type)
+      { TYPE => 'array', ITEMS => items }
+    end
+
+    on(:tuple) do |type, props|
+      items = type.types.map { |t| visit(t) }
+      { TYPE => 'array', 'prefixItems' => items }
+    end
+
+    on(:tagged_hash) do |type, props|
+      required = Set.new
+      result = {
+        TYPE => 'object',
+        PROPERTIES => {}
+      }
+
+      key = type.key.to_s
+      children  = type.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
+      result[PROPERTIES][key] = { TYPE => key_type.first, ENUM => key_enum }
+      result[ALL_OF] = children.map do |child|
+        child_prop = child[PROPERTIES][key]
+
+        {
+          'if' => {
+            PROPERTIES => { key => child_prop.slice(CONST, TYPE) }
+          },
+          'then' => child.except(TYPE)
+        }
+      end
+
+      result.merge(REQUIRED => required.to_a)
+    end
+  end
+end

data/lib/plumb/key.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Plumb
+  class Key
+    OPTIONAL_EXP = /(\w+)(\?)?$/
+
+    def self.wrap(key)
+      key.is_a?(Key) ? key : new(key)
+    end
+
+    attr_reader :to_sym, :node_name
+
+    def initialize(key, optional: false)
+      key_s = key.to_s
+      match = OPTIONAL_EXP.match(key_s)
+      @node_name = :key
+      @key = match[1]
+      @to_sym = @key.to_sym
+      @optional = !match[2].nil? ? true : optional
+      freeze
+    end
+
+    def to_s = @key
+
+    def hash
+      @key.hash
+    end
+
+    def eql?(other)
+      other.hash == hash
+    end
+
+    def optional?
+      @optional
+    end
+
+    def inspect
+      "#{@key}#{'?' if @optional}"
+    end
+  end
+end

data/lib/plumb/match_class.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class MatchClass
+    include Steppable
+
+    attr_reader :matcher
+
+    def initialize(matcher = Undefined, error: 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}])
+    end
+
+    def call(result)
+      @matcher === result.value ? result : result.invalid(errors: @error)
+    end
+
+    private def build_error(matcher)
+      case matcher
+      when Class # A class primitive, ex. String, Integer, etc.
+        "Must be a #{matcher}"
+      when ::String, ::Symbol, ::Numeric, ::TrueClass, ::FalseClass, ::NilClass, ::Array, ::Hash
+        "Must be equal to #{matcher}"
+      when ::Range
+        "Must be within #{matcher}"
+      else
+        "Must match #{matcher.inspect}"
+      end
+    end
+  end
+end

data/lib/plumb/metadata.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plumb
+  class Metadata
+    include Steppable
+
+    attr_reader :metadata
+
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    def call(result) = result
+  end
+end