plumb 0.0.1 → 0.0.3

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,8 +167,13 @@ module Plumb
         self
       end
 
-      def rule(...)
-        @_type = @_type.rule(...)
+      def match(matcher)
+        @_type = @_type.match(matcher)
+        self
+      end
+
+      def policy(...)
+        @_type = @_type.policy(...)
         self
       end
 

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

@@ -10,6 +10,7 @@ module Plumb
 
     def to_s = inspect
     def node_name = :undefined
+    def empty? = true
   end
 
   TypeError = Class.new(::TypeError)
@@ -19,6 +20,7 @@ module Plumb
   BLANK_ARRAY = [].freeze
   BLANK_HASH = {}.freeze
   BLANK_RESULT = Result.wrap(Undefined)
+  NOOP = ->(result) { result }
 
   module Callable
     def metadata
@@ -46,7 +48,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 +58,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 +112,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, label: errors)
     end
 
     def meta(data = {})
@@ -137,22 +137,6 @@ module Plumb
 
     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
 
@@ -172,33 +156,28 @@ module Plumb
       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
+    # Register a policy for this step.
+    # Mode 1.a: #policy(:name, arg) a single policy with an argument
+    # Mode 1.b: #policy(:name) a single policy without an argument
+    # Mode 2: #policy(p1: value, p2: value) multiple policies with arguments
+    # The latter mode will be expanded to multiple #policy calls.
+    # @return [Step]
+    def policy(*args, &blk)
+      case args
+      in [::Symbol => name, *rest] # #policy(:name, arg)
+        types = Array(metadata[:type]).uniq
+
+        bargs = [self]
+        bargs << rest.first if rest.any?
+        block = Plumb.policies.get(types, name)
+        pol = block.call(*bargs, &blk)
+
+        Policy.new(name, rest.first, pol)
+      in [::Hash => opts] # #policy(p1: value, p2: value)
+        opts.reduce(self) { |step, (name, value)| step.policy(name, value) }
       else
-        raise ArgumentError, "expected 1 or 2 arguments, but got #{args.size}"
+        raise ArgumentError, "expected a symbol or hash, got #{args.inspect}"
       end
-
-      self >> Rules.new(specs, metadata[:type])
-    end
-
-    def is_a(klass)
-      rule(is_a: klass)
     end
 
     def ===(other)
@@ -210,18 +189,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,10 +200,30 @@ module Plumb
     def to_s
       inspect
     end
+
+    # Build a step that will invoke one 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
 
 require 'plumb/deferred'
 require 'plumb/transform'
+require 'plumb/policy'
 require 'plumb/build'
 require 'plumb/metadata'

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