plumb 0.0.2 → 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
@@ -172,8 +173,8 @@ module Plumb
         self
       end
 
-      def rule(...)
-        @_type = @_type.rule(...)
+      def policy(...)
+        @_type = @_type.policy(...)
         self
       end
 

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

@@ -3,25 +3,127 @@
 require 'bigdecimal'
 
 module Plumb
-  Rules.define :included_in, 'elements must be included in %<value>s', expects: ::Array do |result, opts|
-    result.value.all? { |v| opts.include?(v) }
+  # Define core policies
+  # Allowed options for an array type.
+  # It validates that each element is in the options array.
+  # Usage:
+  #   type = Types::Array.options(['a', 'b'])
+  policy :options, helper: true, for_type: ::Array do |type, opts|
+    type.check("must be included in #{opts.inspect}") do |v|
+      v.all? { |val| opts.include?(val) }
+    end
+  end
+
+  # Generic options policy for all other types.
+  # Usage:
+  #   type = Types::String.options(['a', 'b'])
+  policy :options do |type, opts|
+    type.check("must be included in #{opts.inspect}") do |v|
+      opts.include?(v)
+    end
+  end
+
+  # Validate that array elements are NOT in the options array.
+  # Usage:
+  #   type = Types::Array.policy(excluded_from: ['a', 'b'])
+  policy :excluded_from, for_type: ::Array do |type, opts|
+    type.check("must not be included in #{opts.inspect}") do |v|
+      v.none? { |val| opts.include?(val) }
+    end
+  end
+
+  # Usage:
+  #   type = Types::String.policy(excluded_from: ['a', 'b'])
+  policy :excluded_from do |type, opts|
+    type.check("must not be included in #{opts.inspect}") do |v|
+      !opts.include?(v)
+    end
+  end
+
+  # Validate #size against a number or any object that responds to #===.
+  # This works with any type that repsonds to #size.
+  # Usage:
+  #   type = Types::String.policy(size: 10)
+  #   type = Types::Integer.policy(size: 1..10)
+  #   type = Types::Array.policy(size: 1..)
+  #   type = Types::Any[Set].policy(size: 1..)
+  policy :size, for_type: :size do |type, size|
+    type.check("must be of size #{size}") { |v| size === v.size }
   end
-  Rules.define :included_in, 'must be included in %<value>s' do |result, opts|
-    opts.include? result.value
+
+  # Validate that an object is not #empty? nor #nil?
+  # Usage:
+  #   Types::String.present
+  #   Types::Array.present
+  policy :present, helper: true do |type, *_args|
+    type.check('must be present') do |v|
+      if v.respond_to?(:empty?)
+        !v.empty?
+      else
+        !v.nil?
+      end
+    end
   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) }
+
+  # Allow nil values for a type.
+  # Usage:
+  #   nullable_int = Types::Integer.nullable
+  #   nullable_int.parse(nil) # => nil
+  #   nullable_int.parse(10)  # => 10
+  #   nullable_int.parse('nope') # => error: not an Integer
+  policy :nullable, helper: true do |type, *_args|
+    Types::Nil | type
   end
-  Rules.define :excluded_from, 'must not be included in %<value>s' do |result, value|
-    !value.include?(result.value)
+
+  # Validate that a value responds to a method
+  # Usage:
+  #  type = Types::Any.policy(respond_to: :upcase)
+  #  type = Types::Any.policy(respond_to: [:upcase, :strip])
+  policy :respond_to do |type, method_names|
+    type.check("must respond to #{method_names.inspect}") do |value|
+      Array(method_names).all? { |m| value.respond_to?(m) }
+    end
   end
-  Rules.define :respond_to, 'must respond to %<value>s' do |result, value|
-    Array(value).all? { |m| result.value.respond_to?(m) }
+
+  # Return a default value if the input value is Undefined (ie key not present in a Hash).
+  # Usage:
+  #   type = Types::String.default('default')
+  #   type.parse(Undefined) # => 'default'
+  #   type.parse('yes')     # => 'yes'
+  #
+  # Works with a block too:
+  #   date = Type::Any[Date].default { Date.today }
+  #
+  policy :default, helper: true do |type, value = Undefined, &block|
+    val_type = if value == Undefined
+                 Step.new(->(result) { result.valid(block.call) }, 'default proc')
+               else
+                 Types::Static[value]
+               end
+
+    (Types::Undefined >> val_type) | type
   end
-  Rules.define :size, 'must be of size %<value>s', expects: :size do |result, value|
-    value === result.value.size
+
+  # Split a string into an array. Default separator is /\s*,\s*/
+  # Usage:
+  #   type = Types::String.split
+  #   type.parse('a,b,c') # => ['a', 'b', 'c']
+  #
+  # Custom separator:
+  #   type = Types::String.split(';')
+  module SplitPolicy
+    DEFAULT_SEPARATOR = /\s*,\s*/
+
+    def self.call(type, separator = DEFAULT_SEPARATOR)
+      type.invoke(:split, separator) >> Types::Array[String]
+    end
+
+    def self.for_type = ::String
+    def self.helper = false
   end
 
+  policy :split, SplitPolicy
+
   module Types
     extend TypeRegistry
 
@@ -43,17 +145,11 @@ module Plumb
     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*/) }
+
+    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.2'
+  VERSION = '0.0.4'
 end

data/lib/plumb/visitor_handlers.rb

@@ -23,7 +23,12 @@ module Plumb
                     else
                       :"#{(node.is_a?(::Class) ? node : node.class)}_class"
                     end
-      method_name = "visit_#{method_name}"
+
+      visit_name(method_name, node, props)
+    end
+
+    def visit_name(method_name, node, props = BLANK_HASH)
+      method_name = :"visit_#{method_name}"
       if respond_to?(method_name)
         send(method_name, node, props)
       else
@@ -34,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

@@ -1,16 +1,71 @@
 # frozen_string_literal: true
 
+require 'plumb/policies'
+
 module Plumb
+  @policies = Policies.new
+
+  def self.policies
+    @policies
+  end
+
+  # Register a policy with the given name and block.
+  # 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 }
+  #   end
+  #
+  #  type = Types::Integer.multiply_by(2)
+  #  type.parse(10) # => 20
+  #
+  # @param name [Symbol] the name of the policy
+  # @param opts [Hash] options for the policy
+  # @yield [Step, Object, &block] the step (type), policy argument, and policy block, if any.
+  def self.policy(name, opts = {}, &block)
+    name = name.to_sym
+    if opts.is_a?(Hash) && block_given?
+      for_type = opts[:for_type] || Object
+      helper = opts[:helper] || false
+    elsif opts.respond_to?(:call) && opts.respond_to?(:for_type) && opts.respond_to?(:helper)
+      for_type = opts.for_type
+      helper = opts.helper
+      block = opts.method(:call)
+    else
+      raise ArgumentError, 'Expected a block or a hash with :for_type and :helper keys'
+    end
+
+    policies.register(for_type, name, block)
+
+    return self unless helper
+
+    if Composable.instance_methods.include?(name)
+      raise Policies::MethodAlreadyDefinedError, "Method #{name} is already defined on Composable"
+    end
+
+    Composable.define_method(name) do |arg = Undefined, &bl|
+      if arg == Undefined
+        policy(name, &bl)
+      else
+        policy(name, arg, &bl)
+      end
+    end
+
+    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'
 require 'plumb/pipeline'
-require 'plumb/rules'
 require 'plumb/static_class'
 require 'plumb/value_class'
 require 'plumb/match_class'
@@ -21,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,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-11 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
+  name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bigdecimal
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,13 +53,18 @@ files:
 - 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
@@ -72,12 +77,12 @@ files:
 - lib/plumb/not.rb
 - lib/plumb/or.rb
 - lib/plumb/pipeline.rb
+- lib/plumb/policies.rb
+- lib/plumb/policy.rb
 - lib/plumb/result.rb
-- lib/plumb/rules.rb
 - 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
@@ -87,7 +92,7 @@ files:
 - lib/plumb/value_class.rb
 - lib/plumb/version.rb
 - lib/plumb/visitor_handlers.rb
-homepage: ''
+homepage: https://github.com/ismasan/plumb
 licenses:
 - MIT
 metadata: {}