plumb 0.0.3 → 0.0.4

data/lib/plumb/schema.rb

@@ -5,13 +5,13 @@ require 'plumb/json_schema_visitor'
 
 module Plumb
   class Schema
-    include Steppable
+    include Composable
 
     def self.wrap(sch = nil, &block)
       raise ArgumentError, 'expected a block or a schema' if sch.nil? && !block_given?
 
       if sch
-        raise ArgumentError, 'expected a Steppable' unless sch.is_a?(Steppable)
+        raise ArgumentError, 'expected a Composable' unless sch.is_a?(Composable)
 
         return sch
       end
@@ -49,8 +49,8 @@ module Plumb
       self
     end
 
-    def json_schema
-      JSONSchemaVisitor.call(_hash).to_h
+    def to_json_schema
+      _hash.to_json_schema(root: true)
     end
 
     def call(result)
@@ -120,7 +120,7 @@ module Plumb
                    block_given? ? ArrayClass.new(element_type: Schema.new(&block)) : type
                  when nil
                    block_given? ? Schema.new(&block) : Types::Any
-                 when Steppable
+                 when Composable
                    type
                  when Class
                    if type == Array && block_given?
@@ -140,13 +140,14 @@ module Plumb
         self
       end
 
-      def meta(md = nil)
-        @_type = @_type.meta(md) if md
-        self
+      def metadata(data = Undefined)
+        if data == Undefined
+          @_type.metadata
+        else
+          @_type = @_type.metadata(data)
+        end
       end
 
-      def metadata = @_type.metadata
-
       def options(opts)
         @_type = @_type.options(opts)
         self

data/lib/plumb/static_class.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class StaticClass
-    include Steppable
+    include Composable
 
-    attr_reader :value
+    attr_reader :children
 
     def initialize(value = Undefined)
       raise ArgumentError, 'value must be frozen' unless value.frozen?
 
       @value = value
+      @children = [value].freeze
       freeze
     end
 

data/lib/plumb/step.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   class Step
-    include Steppable
+    include Composable
 
-    attr_reader :_metadata
+    attr_reader :_metadata, :children
 
     def initialize(callable = nil, inspect = nil, &block)
       @_metadata = callable.respond_to?(:metadata) ? callable.metadata : BLANK_HASH
       @callable = callable || block
+      @children = [@callable].freeze
       @inspect = inspect || @callable.inspect
       freeze
     end

data/lib/plumb/stream_class.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'thread'
-require 'plumb/steppable'
+require 'plumb/composable'
 
 module Plumb
   # A stream that validates each element.
@@ -15,18 +15,19 @@ module Plumb
   #     result.value # => ['name', 10]
   #   end
   class StreamClass
-    include Steppable
+    include Composable
 
-    attr_reader :element_type
+    attr_reader :children
 
-    # @option element_type [Steppable] the type of the elements in the stream
+    # @option element_type [Composable] the type of the elements in the stream
     def initialize(element_type: Types::Any)
-      @element_type = Steppable.wrap(element_type)
+      @element_type = Composable.wrap(element_type)
+      @children = [@element_type].freeze
       freeze
     end
 
     # return a new Stream definition.
-    # @param element_type [Steppable] the type of the elements in the stream
+    # @param element_type [Composable] the type of the elements in the stream
     def [](element_type)
       self.class.new(element_type:)
     end
@@ -39,7 +40,7 @@ module Plumb
 
       enum = Enumerator.new do |y|
         result.value.each do |e|
-          y << element_type.resolve(e)
+          y << @element_type.resolve(e)
         end
       end
 

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)
 
-        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

@@ -101,7 +101,7 @@ module Plumb
                  Types::Static[value]
                end
 
-    type | (Types::Undefined >> val_type)
+    (Types::Undefined >> val_type) | type
   end
 
   # Split a string into an array. Default separator is /\s*,\s*/
@@ -146,6 +146,11 @@ module Plumb
     Hash = HashClass.new
     Interface = InterfaceClass.new
 
+    class Data
+      extend Composable
+      include Plumb::Attributes
+    end
+
     module Lax
       NUMBER_EXPR = /^\d{1,3}(?:,\d{3})*(?:\.\d+)?$/
 

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.4'
 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.4
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -54,13 +54,17 @@ files:
 - 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 +83,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