plumb 0.0.1

data/lib/plumb/metadata_visitor.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'plumb/visitor_handlers'
+
+module Plumb
+  class MetadataVisitor
+    include VisitorHandlers
+
+    def self.call(type)
+      new.visit(type)
+    end
+
+    def on_missing_handler(type, props, method_name)
+      return props.merge(type: type) if type.class == Class
+
+      puts "Missing handler for #{type.inspect} with props #{props.inspect} and method_name :#{method_name}"
+      props
+    end
+
+    on(:undefined) do |type, props|
+      props
+    end
+
+    on(:any) do |type, props|
+      props
+    end
+
+    on(:pipeline) do |type, props|
+      visit(type.type, props)
+    end
+
+    on(:step) do |type, props|
+      props.merge(type._metadata)
+    end
+
+    on(::Regexp) do |type, props|
+      props.merge(pattern: type)
+    end
+
+    on(::Range) do |type, props|
+      props.merge(match: type)
+    end
+
+    on(:match) do |type, props|
+      visit(type.matcher, props)
+    end
+
+    on(:hash) do |type, props|
+      props.merge(type: Hash)
+    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:) if type
+      props
+    end
+
+    on(:or) do |type, props|
+      child_metas = [visit(type.left), visit(type.right)]
+      types = child_metas.map { |child| child[:type] }.flatten.compact
+      types = types.first if types.size == 1
+      child_metas.reduce(props) do |acc, child|
+        acc.merge(child)
+      end.merge(type: types)
+    end
+
+    on(:value) do |type, props|
+      visit(type.value, props)
+    end
+
+    on(:transform) do |type, props|
+      props.merge(type: type.target_type)
+    end
+
+    on(:static) do |type, props|
+      props.merge(static: type.value)
+    end
+
+    on(:rules) do |type, props|
+      type.rules.reduce(props) do |acc, rule|
+        acc.merge(rule.name => rule.arg_value)
+      end
+    end
+
+    on(:boolean) do |type, props|
+      props.merge(type: 'boolean')
+    end
+
+    on(:metadata) do |type, props|
+      props.merge(type.metadata)
+    end
+
+    on(:hash_map) do |type, props|
+      props.merge(type: Hash)
+    end
+
+    on(:build) do |type, props|
+      visit(type.type, props)
+    end
+
+    on(:array) do |type, props|
+      props.merge(type: Array)
+    end
+
+    on(:tuple) do |type, props|
+      props.merge(type: Array)
+    end
+
+    on(:tagged_hash) do |type, props|
+      props.merge(type: Hash)
+    end
+  end
+end

data/lib/plumb/not.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Not
+    include Steppable
+
+    attr_reader :step
+
+    def initialize(step, errors: nil)
+      @step = step
+      @errors = errors
+      freeze
+    end
+
+    private def _inspect
+      %(Not(#{@step.inspect}))
+    end
+
+    def call(result)
+      result = @step.call(result)
+      result.valid? ? result.invalid(errors: @errors) : result.valid
+    end
+  end
+end

data/lib/plumb/or.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Or
+    include Steppable
+
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+      freeze
+    end
+
+    private def _inspect
+      %((#{@left.inspect} | #{@right.inspect}))
+    end
+
+    def call(result)
+      left_result = @left.call(result)
+      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)
+    end
+  end
+end

data/lib/plumb/pipeline.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Pipeline
+    include Steppable
+
+    class AroundStep
+      include Steppable
+
+      def initialize(step, block)
+        @step = step
+        @block = block
+      end
+
+      def call(result)
+        @block.call(@step, result)
+      end
+    end
+
+    attr_reader :type
+
+    def initialize(type = Types::Any, &setup)
+      @type = type
+      @around_blocks = []
+      return unless block_given?
+
+      configure(&setup)
+      freeze
+    end
+
+    def call(result)
+      @type.call(result)
+    end
+
+    def step(callable = nil, &block)
+      callable ||= block
+      unless is_a_step?(callable)
+        raise ArgumentError,
+          "#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?
+      @type >>= callable
+      self
+    end
+
+    def around(callable = nil, &block)
+      @around_blocks << (callable || block)
+      self
+    end
+
+    private
+
+    def configure(&setup)
+      case setup.arity
+      when 1
+        setup.call(self)
+      when 0
+        instance_eval(&setup)
+      else
+        raise ArgumentError, 'setup block must have arity of 0 or 1'
+      end
+    end
+
+    def is_a_step?(callable)
+      return false unless callable.respond_to?(:call)
+
+      true
+    end
+  end
+end

data/lib/plumb/result.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Plumb
+  class Result
+    class << self
+      def valid(value)
+        Valid.new(value)
+      end
+
+      def invalid(value = nil, errors: nil)
+        Invalid.new(value, errors:)
+      end
+
+      def wrap(value)
+        return value if value.is_a?(Result)
+
+        valid(value)
+      end
+    end
+
+    attr_reader :value, :errors
+
+    def initialize(value, errors: nil)
+      @value = value
+      @errors = errors
+    end
+
+    def valid? = true
+    def invalid? = false
+
+    def inspect
+      %(<#{self.class}##{object_id} value:#{value.inspect} errors:#{errors.inspect}>)
+    end
+
+    def reset(val)
+      @value = val
+      @errors = nil
+      self
+    end
+
+    def valid(val = value)
+      Result.valid(val)
+    end
+
+    def invalid(val = value, errors: nil)
+      Result.invalid(val, errors:)
+    end
+
+    class Valid < self
+      def map(callable)
+        callable.call(self)
+      end
+    end
+
+    class Invalid < self
+      def valid? = false
+      def invalid? = true
+
+      def map(_)
+        self
+      end
+    end
+  end
+end

data/lib/plumb/rules.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Rules
+    UnsupportedRuleError = Class.new(StandardError)
+    UndefinedRuleError = Class.new(KeyError)
+
+    class Registry
+      RuleDef = Data.define(:name, :error_tpl, :callable, :metadata_key, :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) }
+          when Class then types.all? { |type| type <= expects }
+          when Object then true
+          else raise "Unexpected expects: #{expects}"
+          end
+        end
+      end
+
+      Rule = Data.define(:rule_def, :arg_value, :error_str) do
+        def self.build(rule_def, arg_value)
+          error_str = format(rule_def.error_tpl, value: arg_value)
+          new(rule_def, arg_value, error_str)
+        end
+
+        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)
+
+          error_str
+        end
+      end
+
+      def initialize
+        @definitions = Hash.new { |h, k| h[k] = Set.new }
+      end
+
+      def define(name, error_tpl, callable = nil, metadata_key: name, expects: Object, &block)
+        name = name.to_sym
+        callable ||= block
+        @definitions[name] << RuleDef.new(name:, error_tpl:, callable:, metadata_key:, expects:)
+      end
+
+      # Ex. size: 3, match: /foo/
+      def resolve(rule_specs, for_type)
+        rule_specs.map do |(name, arg_value)|
+          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,
+              "Can't apply :#{name} rule for types #{for_type}. All types must support the same rule implementation"
+
+          end
+
+          Rule.build(rule_def, arg_value)
+        end
+      end
+    end
+
+    include Steppable
+
+    def self.registry
+      @registry ||= Registry.new
+    end
+
+    def self.define(...)
+      registry.define(...)
+    end
+
+    # Ex. new(size: 3, match: /foo/)
+    attr_reader :rules
+
+    def initialize(rule_specs, for_type)
+      @rules = self.class.registry.resolve(rule_specs, for_type).freeze
+      freeze
+    end
+
+    def call(result)
+      errors = []
+      err = nil
+      @rules.each do |rule|
+        err = rule.error_for(result)
+        errors << err if err
+      end
+      return result unless errors.any?
+
+      result.invalid(errors: errors.join(', '))
+    end
+
+    private def _inspect
+      +'Rules(' << @rules.map { |r| [r.name, r.arg_value].join(': ') }.join(', ') << +')'
+    end
+  end
+end

data/lib/plumb/schema.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'plumb/json_schema_visitor'
+
+module Plumb
+  class Schema
+    include Steppable
+
+    def self.wrap(sc = nil, &block)
+      raise ArgumentError, 'expected a block or a schema' if sc.nil? && !block_given?
+
+      if sc
+        raise ArgumentError, 'expected a Steppable' unless sc.is_a?(Steppable)
+
+        return sc
+      end
+
+      new(&block)
+    end
+
+    attr_reader :fields
+
+    def initialize(hash = Types::Hash, &block)
+      @pipeline = Types::Any
+      @before = Types::Any
+      @after = Types::Any
+      @_schema = {}
+      @_hash = hash
+      @fields = SymbolAccessHash.new({})
+
+      setup(&block) if block_given?
+
+      finish
+    end
+
+    def inspect
+      "#{self.class}#{fields.keys.inspect}"
+    end
+
+    def before(callable = nil, &block)
+      @before >>= callable || block
+      self
+    end
+
+    def after(callable = nil, &block)
+      @after >>= callable || block
+      self
+    end
+
+    def json_schema
+      JSONSchemaVisitor.call(_hash).to_h
+    end
+
+    def call(result)
+      @pipeline.call(result)
+    end
+
+    private def setup(&block)
+      case block.arity
+      when 1
+        yield self
+      when 0
+        instance_eval(&block)
+      else
+        raise ::ArgumentError, "#{self.class} expects a block with 0 or 1 argument, but got #{block.arity}"
+      end
+      @_hash = Types::Hash.schema(@fields.transform_values(&:_type))
+      self
+    end
+
+    private def finish
+      @pipeline = @before.freeze >> @_hash.freeze >> @after.freeze
+      @_schema.clear.freeze
+      freeze
+    end
+
+    def field(key)
+      key = Key.new(key.to_sym)
+      @fields[key] = Field.new(key)
+    end
+
+    def field?(key)
+      key = Key.new(key.to_sym, optional: true)
+      @fields[key] = Field.new(key)
+    end
+
+    def +(other)
+      self.class.new(_hash + other._hash)
+    end
+
+    def &(other)
+      self.class.new(_hash & other._hash)
+    end
+
+    def merge(other = nil, &block)
+      other = self.class.wrap(other, &block)
+      self + other
+    end
+
+    protected
+
+    attr_reader :_hash
+
+    private
+
+    attr_reader :_schema
+
+    class SymbolAccessHash < SimpleDelegator
+      def [](key)
+        __getobj__[Key.wrap(key)]
+      end
+    end
+
+    class Field
+      include Callable
+
+      attr_reader :_type, :key
+
+      def initialize(key)
+        @key = key.to_sym
+        @_type = Types::Any
+      end
+
+      def call(result) = _type.call(result)
+
+      def type(steppable)
+        unless steppable.respond_to?(:call)
+          raise ArgumentError,
+            "expected a Plumb type, but got #{steppable.inspect}"
+        end
+
+        @_type >>= steppable
+        self
+      end
+
+      def schema(...)
+        @_type >>= Schema.wrap(...)
+        self
+      end
+
+      def array(...)
+        @_type >>= Types::Array[Schema.wrap(...)]
+        self
+      end
+
+      def default(v, &block)
+        @_type = @_type.default(v, &block)
+        self
+      end
+
+      def meta(md = nil)
+        @_type = @_type.meta(md) if md
+        self
+      end
+
+      def metadata = @_type.metadata
+
+      def options(opts)
+        @_type = @_type.rule(included_in: opts)
+        self
+      end
+
+      def optional
+        @_type = Types::Nil | @_type
+        self
+      end
+
+      def present
+        @_type = @_type.present
+        self
+      end
+
+      def required
+        @_type = Types::Undefined.invalid(errors: 'is required') >> @_type
+        self
+      end
+
+      def rule(...)
+        @_type = @_type.rule(...)
+        self
+      end
+
+      def inspect
+        "#{self.class}[#{@_type.inspect}]"
+      end
+
+      private
+
+      attr_reader :registry
+    end
+  end
+end

data/lib/plumb/static_class.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class StaticClass
+    include Steppable
+
+    attr_reader :value
+
+    def initialize(value = Undefined)
+      raise ArgumentError, 'value must be frozen' unless value.frozen?
+
+      @value = value
+      freeze
+    end
+
+    def [](value)
+      self.class.new(value)
+    end
+
+    private def _inspect
+      %(#{name}[#{@value.inspect}])
+    end
+
+    def call(result)
+      result.valid(@value)
+    end
+  end
+end

data/lib/plumb/step.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Step
+    include Steppable
+
+    attr_reader :_metadata
+
+    def initialize(callable = nil, &block)
+      @_metadata = callable.respond_to?(:metadata) ? callable.metadata : BLANK_HASH
+      @callable = callable || block
+      freeze
+    end
+
+    def call(result)
+      @callable.call(result)
+    end
+  end
+end