plumb 0.0.1 → 0.0.2

data/lib/plumb/schema.rb

@@ -7,13 +7,13 @@ 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?
+    def self.wrap(sch = nil, &block)
+      raise ArgumentError, 'expected a block or a schema' if sch.nil? && !block_given?
 
-      if sc
-        raise ArgumentError, 'expected a Steppable' unless sc.is_a?(Steppable)
+      if sch
+        raise ArgumentError, 'expected a Steppable' unless sch.is_a?(Steppable)
 
-        return sc
+        return sch
       end
 
       new(&block)
@@ -25,9 +25,10 @@ module Plumb
       @pipeline = Types::Any
       @before = Types::Any
       @after = Types::Any
-      @_schema = {}
       @_hash = hash
-      @fields = SymbolAccessHash.new({})
+      @fields = @_hash._schema.each.with_object(SymbolAccessHash.new({})) do |(k, v), memo|
+        memo[k] = Field.new(k, v)
+      end
 
       setup(&block) if block_given?
 
@@ -71,18 +72,17 @@ module Plumb
 
     private def finish
       @pipeline = @before.freeze >> @_hash.freeze >> @after.freeze
-      @_schema.clear.freeze
       freeze
     end
 
-    def field(key)
+    def field(key, type = nil, &block)
       key = Key.new(key.to_sym)
-      @fields[key] = Field.new(key)
+      @fields[key] = Field.new(key, type, &block)
     end
 
-    def field?(key)
+    def field?(key, type = nil, &block)
       key = Key.new(key.to_sym, optional: true)
-      @fields[key] = Field.new(key)
+      @fields[key] = Field.new(key, type, &block)
     end
 
     def +(other)
@@ -102,10 +102,6 @@ module Plumb
 
     attr_reader :_hash
 
-    private
-
-    attr_reader :_schema
-
     class SymbolAccessHash < SimpleDelegator
       def [](key)
         __getobj__[Key.wrap(key)]
@@ -117,33 +113,28 @@ module Plumb
 
       attr_reader :_type, :key
 
-      def initialize(key)
+      def initialize(key, type = nil, &block)
         @key = key.to_sym
-        @_type = Types::Any
+        @_type = case type
+                 when ArrayClass, Array
+                   block_given? ? ArrayClass.new(element_type: Schema.new(&block)) : type
+                 when nil
+                   block_given? ? Schema.new(&block) : Types::Any
+                 when Steppable
+                   type
+                 when Class
+                   if type == Array && block_given?
+                     ArrayClass.new(element_type: Schema.new(&block))
+                   else
+                     Types::Any[type]
+                   end
+                 else
+                   raise ArgumentError, "expected a Plumb type, but got #{type.inspect}"
+                 end
       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
@@ -157,12 +148,12 @@ module Plumb
       def metadata = @_type.metadata
 
       def options(opts)
-        @_type = @_type.rule(included_in: opts)
+        @_type = @_type.options(opts)
         self
       end
 
-      def optional
-        @_type = Types::Nil | @_type
+      def nullable
+        @_type = @_type.nullable
         self
       end
 
@@ -176,6 +167,11 @@ module Plumb
         self
       end
 
+      def match(matcher)
+        @_type = @_type.match(matcher)
+        self
+      end
+
       def rule(...)
         @_type = @_type.rule(...)
         self

data/lib/plumb/static_class.rb

@@ -19,12 +19,12 @@ module Plumb
       self.class.new(value)
     end
 
-    private def _inspect
-      %(#{name}[#{@value.inspect}])
-    end
-
     def call(result)
       result.valid(@value)
     end
+
+    private
+
+    def _inspect = @value.inspect
   end
 end

data/lib/plumb/step.rb

@@ -8,14 +8,19 @@ module Plumb
 
     attr_reader :_metadata
 
-    def initialize(callable = nil, &block)
+    def initialize(callable = nil, inspect = nil, &block)
       @_metadata = callable.respond_to?(:metadata) ? callable.metadata : BLANK_HASH
       @callable = callable || block
+      @inspect = inspect || @callable.inspect
       freeze
     end
 
     def call(result)
       @callable.call(result)
     end
+
+    private
+
+    def _inspect = "Step[#{@inspect}]"
   end
 end

data/lib/plumb/steppable.rb

@@ -19,6 +19,7 @@ module Plumb
   BLANK_ARRAY = [].freeze
   BLANK_HASH = {}.freeze
   BLANK_RESULT = Result.wrap(Undefined)
+  NOOP = ->(result) { result }
 
   module Callable
     def metadata
@@ -46,7 +47,7 @@ module Plumb
 
     def self.included(base)
       nname = base.name.split('::').last
-      nname.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      nname.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
       nname.downcase!
       nname.gsub!(/_class$/, '')
       nname = nname.to_sym
@@ -56,10 +57,12 @@ module Plumb
     def self.wrap(callable)
       if callable.is_a?(Steppable)
         callable
+      elsif callable.is_a?(::Hash)
+        HashClass.new(schema: callable)
       elsif callable.respond_to?(:call)
         Step.new(callable)
       else
-        StaticClass.new(callable)
+        MatchClass.new(callable)
       end
     end
 
@@ -108,11 +111,7 @@ module Plumb
     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
+      self >> MatchClass.new(block, error: errors)
     end
 
     def meta(data = {})
@@ -145,10 +144,10 @@ module Plumb
 
     def default(val = Undefined, &block)
       val_type = if val == Undefined
-        DefaultProc.call(block)
-      else
-        Types::Static[val]
-      end
+                   DefaultProc.call(block)
+                 else
+                   Types::Static[val]
+                 end
 
       self | (Types::Undefined >> val_type)
     end
@@ -186,21 +185,17 @@ module Plumb
 
     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
+              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
@@ -210,18 +205,6 @@ module Plumb
       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
@@ -233,6 +216,25 @@ module Plumb
     def to_s
       inspect
     end
+
+    # Build a step that will invoke onr or more methods on the value.
+    # Ex 1: Types::String.invoke(:downcase)
+    # Ex 2: Types::Array.invoke(:[], 1)
+    # Ex 3 chain of methods: Types::String.invoke([:downcase, :to_sym])
+    # @return [Step]
+    def invoke(*args, &block)
+      case args
+      in [::Symbol => method_name, *rest]
+        self >> Step.new(
+          ->(result) { result.valid(result.value.public_send(method_name, *rest, &block)) },
+          [method_name.inspect, rest.inspect].join(' ')
+        )
+      in [Array => methods] if methods.all? { |m| m.is_a?(Symbol) }
+        methods.reduce(self) { |step, method| step.invoke(method) }
+      else
+        raise ArgumentError, "expected a symbol or array of symbols, got #{args.inspect}"
+      end
+    end
   end
 end
 

data/lib/plumb/stream_class.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'plumb/steppable'
+
+module Plumb
+  # A stream that validates each element.
+  # Example:
+  #   row = Types::Tuple[String, Types::Lax::Integer]
+  #   csv_stream = Types::Stream[row]
+  #
+  #   stream = csv_stream.parse(CSV.new(File.new('data.csv')).to_enum)
+  #   stream.each |result|
+  #     result.valid? # => true
+  #     result.value # => ['name', 10]
+  #   end
+  class StreamClass
+    include Steppable
+
+    attr_reader :element_type
+
+    # @option element_type [Steppable] the type of the elements in the stream
+    def initialize(element_type: Types::Any)
+      @element_type = Steppable.wrap(element_type)
+      freeze
+    end
+
+    # return a new Stream definition.
+    # @param element_type [Steppable] the type of the elements in the stream
+    def [](element_type)
+      self.class.new(element_type:)
+    end
+
+    # The [Step] interface
+    # @param result [Result::Valid]
+    # @return [Result::Valid, Result::Invalid]
+    def call(result)
+      return result.invalid(errors: 'is not an Enumerable') unless result.value.respond_to?(:each)
+
+      enum = Enumerator.new do |y|
+        result.value.each do |e|
+          y << element_type.resolve(e)
+        end
+      end
+
+      result.valid(enum)
+    end
+
+    # @return [Step] a step that resolves to an Enumerator that filters out invalid elements
+    def filtered
+      self >> Step.new(nil, 'filtered') do |result|
+        set = result.value.lazy.filter_map { |e| e.value if e.valid? }
+        result.valid(set)
+      end
+    end
+
+    private
+
+    def _inspect = "Stream[#{@element_type.inspect}]"
+  end
+end

data/lib/plumb/tagged_hash.rb

@@ -13,15 +13,20 @@ module Plumb
       @key = Key.wrap(key)
       @types = types
 
-      raise ArgumentError, 'all types must be HashClass' if @types.size == 0 || @types.any? do |t|
+      raise ArgumentError, 'all types must be HashClass' if @types.size.zero? || @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
+      # types are assumed to have literal values for the index field :key
       @index = @types.each.with_object({}) do |t, memo|
-        memo[t.at_key(@key).resolve.value] = t
+        key_type = t.at_key(@key)
+        raise TypeError, "key type at :#{@key} #{key_type} must be a Match type" unless key_type.is_a?(MatchClass)
+
+        memo[key_type.matcher] = t
       end
+
+      freeze
     end
 
     def call(result)
@@ -33,5 +38,9 @@ module Plumb
 
       child.call(result)
     end
+
+    private
+
+    def _inspect = "TaggedHash[#{@key.inspect}, #{@types.map(&:inspect).join(', ')}]"
   end
 end

data/lib/plumb/transform.rb

@@ -10,11 +10,16 @@ module Plumb
 
     def initialize(target_type, callable)
       @target_type = target_type
-      @callable = callable
+      @callable = callable || Plumb::NOOP
+      freeze
     end
 
     def call(result)
       result.valid(@callable.call(result.value))
     end
+
+    private
+
+    def _inspect = "->(#{@target_type.inspect})"
   end
 end

data/lib/plumb/tuple_class.rb

@@ -9,7 +9,8 @@ module Plumb
     attr_reader :types
 
     def initialize(*types)
-      @types = types.map { |t| t.is_a?(Steppable) ? t : Types::Any.value(t) }
+      @types = types.map { |t| Steppable.wrap(t) }
+      freeze
     end
 
     def of(*types)
@@ -18,10 +19,6 @@ module Plumb
 
     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
@@ -38,5 +35,11 @@ module Plumb
 
       result.invalid(errors:)
     end
+
+    private
+
+    def _inspect
+      "Tuple[#{@types.map(&:inspect).join(', ')}]"
+    end
   end
 end

data/lib/plumb/types.rb

@@ -3,56 +3,10 @@
 require 'bigdecimal'
 
 module Plumb
-  Rules.define :eq, 'must be equal to %<value>s' do |result, value|
-    value == result.value
+  Rules.define :included_in, 'elements must be included in %<value>s', expects: ::Array do |result, opts|
+    result.value.all? { |v| opts.include?(v) }
   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|
+  Rules.define :included_in, 'must be included in %<value>s' 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|
@@ -64,7 +18,7 @@ module Plumb
   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|
+  Rules.define :size, 'must be of size %<value>s', expects: :size do |result, value|
     value === result.value.size
   end
 
@@ -85,6 +39,7 @@ module Plumb
     False = Any[::FalseClass]
     Boolean = (True | False).as_node(:boolean)
     Array = ArrayClass.new
+    Stream = StreamClass.new
     Tuple = TupleClass.new
     Hash = HashClass.new
     Interface = InterfaceClass.new
@@ -104,8 +59,8 @@ module Plumb
       NUMBER_EXPR = /^\d{1,3}(?:,\d{3})*(?:\.\d+)?$/
 
       String = Types::String \
-        | Any.coerce(BigDecimal) { |v| v.to_s('F') } \
-        | Any.coerce(::Numeric, &:to_s)
+        | Types::Decimal.transform(::String) { |v| v.to_s('F') } \
+        | Types::Numeric.transform(::String, &:to_s)
 
       Symbol = Types::Symbol | Types::String.transform(::Symbol, &:to_sym)
 
@@ -115,22 +70,26 @@ module Plumb
       Numeric = Types::Numeric | CoercibleNumberString.transform(::Numeric, &:to_f)
 
       Decimal = Types::Decimal | \
-        (Types::Numeric.transform(::String, &:to_s) | CoercibleNumberString) \
-          .transform(::BigDecimal) { |v| BigDecimal(v) }
+                (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 }
+        | (
+          Types::String[/^true$/i] \
+          | Types::String['1'] \
+          | Types::Integer[1]
+        ).transform(::TrueClass) { |_| true }
 
       False = Types::False \
-        | Types::String >> Any.coerce(/^false$/i) { |_| false } \
-        | Any.coerce('0') { |_| false } \
-        | Any.coerce(0) { |_| false }
+        | (
+          Types::String[/^false$/i] \
+          | Types::String['0'] \
+          | Types::Integer[0]
+        ).transform(::FalseClass) { |_| false }
 
       Boolean = True | False
 

data/lib/plumb/value_class.rb

@@ -10,14 +10,17 @@ module Plumb
 
     def initialize(value = Undefined)
       @value = value
+      freeze
     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
+
+    private
+
+    def _inspect = @value.inspect
   end
 end

data/lib/plumb/version.rb

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

data/lib/plumb/visitor_handlers.rb

@@ -9,26 +9,30 @@ module Plumb
     module ClassMethods
       def on(node_name, &block)
         name = node_name.is_a?(Symbol) ? node_name : :"#{node_name}_class"
-        self.define_method("visit_#{name}", &block)
+        define_method("visit_#{name}", &block)
       end
 
-      def visit(type, props = BLANK_HASH)
-        new.visit(type, props)
+      def visit(node, props = BLANK_HASH)
+        new.visit(node, 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"
+    def visit(node, props = BLANK_HASH)
+      method_name = if node.respond_to?(:node_name)
+                      node.node_name
+                    else
+                      :"#{(node.is_a?(::Class) ? node : node.class)}_class"
+                    end
       method_name = "visit_#{method_name}"
       if respond_to?(method_name)
-        send(method_name, type, props)
+        send(method_name, node, props)
       else
-        on_missing_handler(type, props, method_name)
+        on_missing_handler(node, props, method_name)
       end
     end
 
-    def on_missing_handler(type, _props, method_name)
-      raise "No handler for #{type.inspect} with :#{method_name}"
+    def on_missing_handler(node, _props, method_name)
+      raise "No handler for #{node.inspect} with :#{method_name}"
     end
   end
 end

data/lib/plumb.rb

@@ -18,6 +18,7 @@ require 'plumb/not'
 require 'plumb/or'
 require 'plumb/tuple_class'
 require 'plumb/array_class'
+require 'plumb/stream_class'
 require 'plumb/hash_class'
 require 'plumb/interface_class'
 require 'plumb/types'