plumb 0.0.1

data/lib/plumb/steppable.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'plumb/metadata_visitor'
+
+module Plumb
+  class UndefinedClass
+    def inspect
+      %(Undefined)
+    end
+
+    def to_s = inspect
+    def node_name = :undefined
+  end
+
+  TypeError = Class.new(::TypeError)
+  Undefined = UndefinedClass.new.freeze
+
+  BLANK_STRING = ''
+  BLANK_ARRAY = [].freeze
+  BLANK_HASH = {}.freeze
+  BLANK_RESULT = Result.wrap(Undefined)
+
+  module Callable
+    def metadata
+      MetadataVisitor.call(self)
+    end
+
+    def resolve(value = Undefined)
+      call(Result.wrap(value))
+    end
+
+    def parse(value = Undefined)
+      result = resolve(value)
+      raise TypeError, result.errors if result.invalid?
+
+      result.value
+    end
+
+    def call(result)
+      raise NotImplementedError, "Implement #call(Result) => Result in #{self.class}"
+    end
+  end
+
+  module Steppable
+    include Callable
+
+    def self.included(base)
+      nname = base.name.split('::').last
+      nname.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      nname.downcase!
+      nname.gsub!(/_class$/, '')
+      nname = nname.to_sym
+      base.define_method(:node_name) { nname }
+    end
+
+    def self.wrap(callable)
+      if callable.is_a?(Steppable)
+        callable
+      elsif callable.respond_to?(:call)
+        Step.new(callable)
+      else
+        StaticClass.new(callable)
+      end
+    end
+
+    attr_reader :name
+
+    class Name
+      def initialize(name)
+        @name = name
+      end
+
+      def to_s = @name
+
+      def set(n)
+        @name = n
+        self
+      end
+    end
+
+    def freeze
+      return self if frozen?
+
+      @name = Name.new(_inspect)
+      super
+    end
+
+    private def _inspect = self.class.name
+
+    def inspect = name.to_s
+
+    def node_name = self.class.name.split('::').last.to_sym
+
+    def defer(definition = nil, &block)
+      Deferred.new(definition || block)
+    end
+
+    def >>(other)
+      And.new(self, Steppable.wrap(other))
+    end
+
+    def |(other)
+      Or.new(self, Steppable.wrap(other))
+    end
+
+    def transform(target_type, callable = nil, &block)
+      self >> Transform.new(target_type, callable || block)
+    end
+
+    def check(errors = 'did not pass the check', &block)
+      a_check = lambda { |result|
+        block.call(result.value) ? result : result.invalid(errors:)
+      }
+
+      self >> a_check
+    end
+
+    def meta(data = {})
+      self >> Metadata.new(data)
+    end
+
+    def not(other = self)
+      Not.new(other)
+    end
+
+    def invalid(errors: nil)
+      Not.new(self, errors:)
+    end
+
+    def value(val)
+      self >> ValueClass.new(val)
+    end
+
+    def match(*args)
+      self >> MatchClass.new(*args)
+    end
+
+    def [](val) = match(val)
+
+    DefaultProc = proc do |callable|
+      proc do |result|
+        result.valid(callable.call)
+      end
+    end
+
+    def default(val = Undefined, &block)
+      val_type = if val == Undefined
+        DefaultProc.call(block)
+      else
+        Types::Static[val]
+      end
+
+      self | (Types::Undefined >> val_type)
+    end
+
+    class Node
+      include Steppable
+
+      attr_reader :node_name, :type, :attributes
+
+      def initialize(node_name, type, attributes = BLANK_HASH)
+        @node_name = node_name
+        @type = type
+        @attributes = attributes
+        freeze
+      end
+
+      def call(result) = type.call(result)
+    end
+
+    def as_node(node_name, metadata = BLANK_HASH)
+      Node.new(node_name, self, metadata)
+    end
+
+    def nullable
+      Types::Nil | self
+    end
+
+    def present
+      Types::Present >> self
+    end
+
+    def options(opts = [])
+      rule(included_in: opts)
+    end
+
+    def rule(*args)
+      specs = case args
+        in [::Symbol => rule_name, value]
+        { rule_name => value }
+        in [::Hash => rules]
+        rules
+      else
+        raise ArgumentError, "expected 1 or 2 arguments, but got #{args.size}"
+      end
+
+      self >> Rules.new(specs, metadata[:type])
+    end
+
+    def is_a(klass)
+      rule(is_a: klass)
+    end
+
+    def ===(other)
+      case other
+      when Steppable
+        other == self
+      else
+        resolve(other).valid?
+      end
+    end
+
+    def coerce(type, coercion = nil, &block)
+      coercion ||= block
+      step = lambda { |result|
+        if type === result.value
+          result.valid(coercion.call(result.value))
+        else
+          result.invalid(errors: "%s can't be coerced" % result.value.inspect)
+        end
+      }
+      self >> step
+    end
+
+    def build(cns, factory_method = :new, &block)
+      self >> Build.new(cns, factory_method:, &block)
+    end
+
+    def pipeline(&block)
+      Pipeline.new(self, &block)
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end
+
+require 'plumb/deferred'
+require 'plumb/transform'
+require 'plumb/build'
+require 'plumb/metadata'

data/lib/plumb/tagged_hash.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class TaggedHash
+    include Steppable
+
+    attr_reader :key, :types
+
+    def initialize(hash_type, key, types)
+      @hash_type = hash_type
+      @key = Key.wrap(key)
+      @types = types
+
+      raise ArgumentError, 'all types must be HashClass' if @types.size == 0 || @types.any? do |t|
+        !t.is_a?(HashClass)
+      end
+      raise ArgumentError, "all types must define key #{@key}" unless @types.all? { |t| !!t.at_key(@key) }
+
+      # types are assumed to have static values for the index field :key
+      @index = @types.each.with_object({}) do |t, memo|
+        memo[t.at_key(@key).resolve.value] = t
+      end
+    end
+
+    def call(result)
+      result = @hash_type.call(result)
+      return result unless result.valid?
+
+      child = @index[result.value[@key.to_sym]]
+      return result.invalid(errors: "expected :#{@key.to_sym} to be one of #{@index.keys.join(', ')}") unless child
+
+      child.call(result)
+    end
+  end
+end

data/lib/plumb/transform.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class Transform
+    include Steppable
+
+    attr_reader :target_type
+
+    def initialize(target_type, callable)
+      @target_type = target_type
+      @callable = callable
+    end
+
+    def call(result)
+      result.valid(@callable.call(result.value))
+    end
+  end
+end

data/lib/plumb/tuple_class.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class TupleClass
+    include Steppable
+
+    attr_reader :types
+
+    def initialize(*types)
+      @types = types.map { |t| t.is_a?(Steppable) ? t : Types::Any.value(t) }
+    end
+
+    def of(*types)
+      self.class.new(*types)
+    end
+
+    alias [] of
+
+    private def _inspect
+      "#{name}[#{@types.map(&:inspect).join(', ')}]"
+    end
+
+    def call(result)
+      return result.invalid(errors: 'must be an Array') unless result.value.is_a?(::Array)
+      return result.invalid(errors: 'must have the same size') unless result.value.size == @types.size
+
+      errors = {}
+      values = @types.map.with_index do |type, idx|
+        val = result.value[idx]
+        r = type.resolve(val)
+        errors[idx] = ["expected #{type.inspect}, got #{val.inspect}", r.errors].flatten unless r.valid?
+        r.value
+      end
+
+      return result.valid(values) unless errors.any?
+
+      result.invalid(errors:)
+    end
+  end
+end

data/lib/plumb/type_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Plumb
+  module TypeRegistry
+    def const_added(const_name)
+      obj = const_get(const_name)
+      case obj
+      when Module
+        obj.extend TypeRegistry
+      when Steppable
+        anc = [name, const_name].join('::')
+        obj.freeze.name.set(anc)
+      end
+    end
+
+    def included(host)
+      host.extend TypeRegistry
+      constants(false).each do |const_name|
+        const = const_get(const_name)
+        anc = [host.name, const_name].join('::')
+        case const
+        when Module
+          child_mod = Module.new
+          child_mod.define_singleton_method(:name) do
+            anc
+          end
+          child_mod.send(:include, const)
+          host.const_set(const_name, child_mod)
+        when Steppable
+          type = const.dup
+          type.freeze.name.set(anc)
+          host.const_set(const_name, type)
+        end
+      end
+    end
+  end
+end

data/lib/plumb/types.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Plumb
+  Rules.define :eq, 'must be equal to %<value>s' do |result, value|
+    value == result.value
+  end
+  Rules.define :not_eq, 'must not be equal to %<value>s' do |result, value|
+    value != result.value
+  end
+  # :gt for numbers and #size (arrays, strings, hashes)
+  [::String, ::Array, ::Hash].each do |klass|
+    Rules.define :gt, 'must contain more than %<value>s elements', expects: klass do |result, value|
+      value < result.value.size
+    end
+
+    # :lt for numbers and #size (arrays, strings, hashes)
+    Rules.define :lt, 'must contain fewer than %<value>s elements', expects: klass do |result, value|
+      value > result.value.size
+    end
+
+    Rules.define :gte, 'must be size greater or equal to %<value>s', expects: klass do |result, value|
+      value <= result.value.size
+    end
+
+    Rules.define :lte, 'must be size less or equal to %<value>s', expects: klass do |result, value|
+      value >= result.value
+    end
+  end
+  # :gt and :lt for numbers, BigDecimal
+  [::Numeric].each do |klass|
+    Rules.define :gt, 'must be greater than %<value>s', expects: klass do |result, value|
+      value < result.value
+    end
+    Rules.define :lt, 'must be greater than %<value>s', expects: klass do |result, value|
+      value > result.value
+    end
+    Rules.define :gte, 'must be greater or equal to %<value>s', expects: klass do |result, value|
+      value <= result.value
+    end
+    # :lte for numbers and #size (arrays, strings, hashes)
+    Rules.define :lte, 'must be less or equal to %<value>s', expects: klass do |result, value|
+      value >= result.value
+    end
+  end
+
+  Rules.define :match, 'must match %<value>s', metadata_key: :pattern do |result, value|
+    value === result.value
+  end
+  Rules.define :included_in, 'elements must be included in %<value>s', expects: ::Array,
+    metadata_key: :options do |result, opts|
+      result.value.all? { |v| opts.include?(v) }
+    end
+  Rules.define :included_in, 'must be included in %<value>s', metadata_key: :options do |result, opts|
+    opts.include? result.value
+  end
+  Rules.define :excluded_from, 'elements must not be included in %<value>s', expects: ::Array do |result, value|
+    result.value.all? { |v| !value.include?(v) }
+  end
+  Rules.define :excluded_from, 'must not be included in %<value>s' do |result, value|
+    !value.include?(result.value)
+  end
+  Rules.define :respond_to, 'must respond to %<value>s' do |result, value|
+    Array(value).all? { |m| result.value.respond_to?(m) }
+  end
+  Rules.define :size, 'must be of size %<value>s', expects: :size, metadata_key: :size do |result, value|
+    value === result.value.size
+  end
+
+  module Types
+    extend TypeRegistry
+
+    Any = AnyClass.new
+    Undefined = Any.value(Plumb::Undefined)
+    String = Any[::String]
+    Symbol = Any[::Symbol]
+    Numeric = Any[::Numeric]
+    Integer = Any[::Integer]
+    Decimal = Any[BigDecimal]
+    Static = StaticClass.new
+    Value = ValueClass.new
+    Nil = Any[::NilClass]
+    True = Any[::TrueClass]
+    False = Any[::FalseClass]
+    Boolean = (True | False).as_node(:boolean)
+    Array = ArrayClass.new
+    Tuple = TupleClass.new
+    Hash = HashClass.new
+    Interface = InterfaceClass.new
+    # TODO: type-speficic concept of blank, via Rules
+    Blank = (
+      Undefined \
+      | Nil \
+      | String.value(BLANK_STRING) \
+      | Hash.value(BLANK_HASH) \
+      | Array.value(BLANK_ARRAY)
+    )
+
+    Present = Blank.invalid(errors: 'must be present')
+    Split = String.transform(::String) { |v| v.split(/\s*,\s*/) }
+
+    module Lax
+      NUMBER_EXPR = /^\d{1,3}(?:,\d{3})*(?:\.\d+)?$/
+
+      String = Types::String \
+        | Any.coerce(BigDecimal) { |v| v.to_s('F') } \
+        | Any.coerce(::Numeric, &:to_s)
+
+      Symbol = Types::Symbol | Types::String.transform(::Symbol, &:to_sym)
+
+      NumberString = Types::String.match(NUMBER_EXPR)
+      CoercibleNumberString = NumberString.transform(::String) { |v| v.tr(',', '') }
+
+      Numeric = Types::Numeric | CoercibleNumberString.transform(::Numeric, &:to_f)
+
+      Decimal = Types::Decimal | \
+        (Types::Numeric.transform(::String, &:to_s) | CoercibleNumberString) \
+          .transform(::BigDecimal) { |v| BigDecimal(v) }
+
+      Integer = Numeric.transform(::Integer, &:to_i)
+    end
+
+    module Forms
+      True = Types::True \
+        | Types::String >> Any.coerce(/^true$/i) { |_| true } \
+        | Any.coerce('1') { |_| true } \
+        | Any.coerce(1) { |_| true }
+
+      False = Types::False \
+        | Types::String >> Any.coerce(/^false$/i) { |_| false } \
+        | Any.coerce('0') { |_| false } \
+        | Any.coerce(0) { |_| false }
+
+      Boolean = True | False
+
+      Nil = Nil | (String[BLANK_STRING] >> nil)
+    end
+  end
+end

data/lib/plumb/value_class.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'plumb/steppable'
+
+module Plumb
+  class ValueClass
+    include Steppable
+
+    attr_reader :value
+
+    def initialize(value = Undefined)
+      @value = value
+    end
+
+    def inspect = @value.inspect
+
+    def [](value) = self.class.new(value)
+
+    def call(result)
+      @value == result.value ? result : result.invalid(errors: "Must be equal to #{@value}")
+    end
+  end
+end

data/lib/plumb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Plumb
+  VERSION = '0.0.1'
+end

data/lib/plumb/visitor_handlers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Plumb
+  module VisitorHandlers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def on(node_name, &block)
+        name = node_name.is_a?(Symbol) ? node_name : :"#{node_name}_class"
+        self.define_method("visit_#{name}", &block)
+      end
+
+      def visit(type, props = BLANK_HASH)
+        new.visit(type, props)
+      end
+    end
+
+    def visit(type, props = BLANK_HASH)
+      method_name = type.respond_to?(:node_name) ? type.node_name : :"#{(type.is_a?(::Class) ? type : type.class)}_class"
+      method_name = "visit_#{method_name}"
+      if respond_to?(method_name)
+        send(method_name, type, props)
+      else
+        on_missing_handler(type, props, method_name)
+      end
+    end
+
+    def on_missing_handler(type, _props, method_name)
+      raise "No handler for #{type.inspect} with :#{method_name}"
+    end
+  end
+end

data/lib/plumb.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plumb
+end
+
+require 'plumb/result'
+require 'plumb/type_registry'
+require 'plumb/steppable'
+require 'plumb/any_class'
+require 'plumb/step'
+require 'plumb/and'
+require 'plumb/pipeline'
+require 'plumb/rules'
+require 'plumb/static_class'
+require 'plumb/value_class'
+require 'plumb/match_class'
+require 'plumb/not'
+require 'plumb/or'
+require 'plumb/tuple_class'
+require 'plumb/array_class'
+require 'plumb/hash_class'
+require 'plumb/interface_class'
+require 'plumb/types'
+require 'plumb/json_schema_visitor'
+require 'plumb/schema'