plumb 0.0.3 → 0.0.5

data/lib/plumb/tagged_hash.rb

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class TaggedHash
-    include Steppable
+    include Composable
 
-    attr_reader :key, :types
+    attr_reader :key, :children
 
-    def initialize(hash_type, key, types)
+    def initialize(hash_type, key, children)
       @hash_type = hash_type
       @key = Key.wrap(key)
-      @types = types
+      @children = children
 
-      raise ArgumentError, 'all types must be HashClass' if @types.size.zero? || @types.any? do |t|
+      raise ArgumentError, 'all types must be HashClass' if @children.size.zero? || @children.any? do |t|
         !t.is_a?(HashClass)
       end
-      raise ArgumentError, "all types must define key #{@key}" unless @types.all? { |t| !!t.at_key(@key) }
+      raise ArgumentError, "all types must define key #{@key}" unless @children.all? { |t| !!t.at_key(@key) }
 
       # types are assumed to have literal values for the index field :key
-      @index = @types.each.with_object({}) do |t, memo|
+      @index = @children.each.with_object({}) do |t, memo|
         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)
+        raise ParseError, "key type at :#{@key} #{key_type} must be a Match type" unless key_type.is_a?(MatchClass)
 
-        memo[key_type.matcher] = t
+        memo[key_type.children[0]] = t
       end
 
       freeze
@@ -41,6 +41,6 @@ module Plumb
 
     private
 
-    def _inspect = "TaggedHash[#{@key.inspect}, #{@types.map(&:inspect).join(', ')}]"
+    def _inspect = "TaggedHash[#{@key.inspect}, #{@children.map(&:inspect).join(', ')}]"
   end
 end

data/lib/plumb/transform.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Transform
-    include Steppable
+    include Composable
 
-    attr_reader :target_type
+    attr_reader :children
 
     def initialize(target_type, callable)
       @target_type = target_type
       @callable = callable || Plumb::NOOP
+      @children = [target_type].freeze
       freeze
     end
 

data/lib/plumb/tuple_class.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class TupleClass
-    include Steppable
+    include Composable
 
-    attr_reader :types
+    attr_reader :children
 
-    def initialize(*types)
-      @types = types.map { |t| Steppable.wrap(t) }
+    def initialize(*children)
+      @children = children.map { |t| Composable.wrap(t) }.freeze
       freeze
     end
 
@@ -21,10 +21,10 @@ module Plumb
 
     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
+      return result.invalid(errors: 'must have the same size') unless result.value.size == @children.size
 
       errors = {}
-      values = @types.map.with_index do |type, idx|
+      values = @children.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?
@@ -39,7 +39,7 @@ module Plumb
     private
 
     def _inspect
-      "Tuple[#{@types.map(&:inspect).join(', ')}]"
+      "Tuple[#{@children.map(&:inspect).join(', ')}]"
     end
   end
 end

data/lib/plumb/type_registry.rb

@@ -7,7 +7,7 @@ module Plumb
       case obj
       when Module
         obj.extend TypeRegistry
-      when Steppable
+      when Composable
         anc = [name, const_name].join('::')
         obj.freeze.name.set(anc)
       end
@@ -17,16 +17,19 @@ module Plumb
       host.extend TypeRegistry
       constants(false).each do |const_name|
         const = const_get(const_name)
+
         anc = [host.name, const_name].join('::')
         case const
         when Module
+          next if const.is_a?(Class)
+
           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
+        when Composable
           type = const.dup
           type.freeze.name.set(anc)
           host.const_set(const_name, type)

data/lib/plumb/types.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'bigdecimal'
+require 'uri'
+require 'date'
 
 module Plumb
   # Define core policies
@@ -101,7 +103,19 @@ module Plumb
                  Types::Static[value]
                end
 
-    type | (Types::Undefined >> val_type)
+    (Types::Undefined >> val_type) | type
+  end
+
+  # Wrap a step execution in a rescue block.
+  # Expect a specific exception class, and return an invalid result if it is raised.
+  # Usage:
+  #   type = Types::String.build(Date, :parse).policy(:rescue, Date::Error)
+  policy :rescue do |type, exception_class|
+    Step.new(nil, 'Rescue') do |result|
+      type.call(result)
+    rescue exception_class => e
+      result.invalid(errors: e.message)
+    end
   end
 
   # Split a string into an array. Default separator is /\s*,\s*/
@@ -145,6 +159,17 @@ module Plumb
     Tuple = TupleClass.new
     Hash = HashClass.new
     Interface = InterfaceClass.new
+    Email = String[URI::MailTo::EMAIL_REGEXP].as_node(:email)
+    Date = Any[::Date]
+
+    module UUID
+      V4 = String[/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i].as_node(:uuid)
+    end
+
+    class Data
+      extend Composable
+      include Plumb::Attributes
+    end
 
     module Lax
       NUMBER_EXPR = /^\d{1,3}(?:,\d{3})*(?:\.\d+)?$/
@@ -185,6 +210,10 @@ module Plumb
       Boolean = True | False
 
       Nil = Nil | (String[BLANK_STRING] >> nil)
+
+      # Accept a Date, or a string that can be parsed into a Date
+      # via Date.parse
+      Date = Date | (String >> Any.build(::Date, :parse).policy(:rescue, ::Date::Error))
     end
   end
 end

data/lib/plumb/value_class.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class ValueClass
-    include Steppable
+    include Composable
 
-    attr_reader :value
+    attr_reader :children
 
     def initialize(value = Undefined)
       @value = value
+      @children = [value].freeze
       freeze
     end
 

data/lib/plumb/version.rb

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

data/lib/plumb/visitor_handlers.rb

@@ -39,5 +39,11 @@ module Plumb
     def on_missing_handler(node, _props, method_name)
       raise "No handler for #{node.inspect} with :#{method_name}"
     end
+
+    def visit_children(node, props = BLANK_HASH)
+      node.children.reduce(props) do |acc, child|
+        visit(child, acc)
+      end
+    end
   end
 end

data/lib/plumb.rb

@@ -10,7 +10,7 @@ module Plumb
   end
 
   # Register a policy with the given name and block.
-  # Optionally define a method on the Steppable method to call the policy.
+  # Optionally define a method on the Composable method to call the policy.
   # Example:
   #   Plumb.policy(:multiply_by, for_type: Integer, helper: true) do |step, factor, &block|
   #     step.transform(Integer) { |number| number * factor }
@@ -39,11 +39,11 @@ module Plumb
 
     return self unless helper
 
-    if Steppable.instance_methods.include?(name)
-      raise Policies::MethodAlreadyDefinedError, "Method #{name} is already defined on Steppable"
+    if Composable.instance_methods.include?(name)
+      raise Policies::MethodAlreadyDefinedError, "Method #{name} is already defined on Composable"
     end
 
-    Steppable.define_method(name) do |arg = Undefined, &bl|
+    Composable.define_method(name) do |arg = Undefined, &bl|
       if arg == Undefined
         policy(name, &bl)
       else
@@ -53,11 +53,15 @@ module Plumb
 
     self
   end
+
+  def self.decorate(type, &block)
+    Decorator.call(type, &block)
+  end
 end
 
 require 'plumb/result'
 require 'plumb/type_registry'
-require 'plumb/steppable'
+require 'plumb/composable'
 require 'plumb/any_class'
 require 'plumb/step'
 require 'plumb/and'
@@ -72,6 +76,8 @@ require 'plumb/array_class'
 require 'plumb/stream_class'
 require 'plumb/hash_class'
 require 'plumb/interface_class'
+require 'plumb/attributes'
 require 'plumb/types'
 require 'plumb/json_schema_visitor'
 require 'plumb/schema'
+require 'plumb/decorator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -50,17 +50,25 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bench/compare_parametric_schema.rb
+- bench/compare_parametric_struct.rb
+- bench/parametric_schema.rb
+- bench/plumb_hash.rb
 - examples/command_objects.rb
 - examples/concurrent_downloads.rb
 - examples/csv_stream.rb
 - examples/env_config.rb
+- examples/event_registry.rb
 - examples/programmers.csv
 - examples/weekdays.rb
 - lib/plumb.rb
 - lib/plumb/and.rb
 - lib/plumb/any_class.rb
 - lib/plumb/array_class.rb
+- lib/plumb/attributes.rb
 - lib/plumb/build.rb
+- lib/plumb/composable.rb
+- lib/plumb/decorator.rb
 - lib/plumb/deferred.rb
 - lib/plumb/hash_class.rb
 - lib/plumb/hash_map.rb
@@ -79,7 +87,6 @@ files:
 - lib/plumb/schema.rb
 - lib/plumb/static_class.rb
 - lib/plumb/step.rb
-- lib/plumb/steppable.rb
 - lib/plumb/stream_class.rb
 - lib/plumb/tagged_hash.rb
 - lib/plumb/transform.rb

data/lib/plumb/steppable.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-require 'plumb/metadata_visitor'
-
-module Plumb
-  class UndefinedClass
-    def inspect
-      %(Undefined)
-    end
-
-    def to_s = inspect
-    def node_name = :undefined
-    def empty? = true
-  end
-
-  TypeError = Class.new(::TypeError)
-  Undefined = UndefinedClass.new.freeze
-
-  BLANK_STRING = ''
-  BLANK_ARRAY = [].freeze
-  BLANK_HASH = {}.freeze
-  BLANK_RESULT = Result.wrap(Undefined)
-  NOOP = ->(result) { result }
-
-  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.is_a?(::Hash)
-        HashClass.new(schema: callable)
-      elsif callable.respond_to?(:call)
-        Step.new(callable)
-      else
-        MatchClass.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)
-      self >> MatchClass.new(block, error: errors, label: errors)
-    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)
-
-    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
-
-    # 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 a symbol or hash, got #{args.inspect}"
-      end
-    end
-
-    def ===(other)
-      case other
-      when Steppable
-        other == self
-      else
-        resolve(other).valid?
-      end
-    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
-
-    # 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'