plumb 0.0.1 → 0.0.3

data/lib/plumb/types.rb

@@ -3,71 +3,127 @@
 require 'bigdecimal'
 
 module Plumb
-  Rules.define :eq, 'must be equal to %<value>s' do |result, value|
-    value == result.value
-  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
+  # 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
 
-    Rules.define :gte, 'must be size greater or equal to %<value>s', expects: klass do |result, value|
-      value <= result.value.size
+  # 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
 
-    Rules.define :lte, 'must be size less or equal to %<value>s', expects: klass do |result, value|
-      value >= result.value
+  # 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
-  # :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
+
+  # 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
 
-  Rules.define :match, 'must match %<value>s', metadata_key: :pattern do |result, value|
-    value === result.value
+  # 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, 'elements must be included in %<value>s', expects: ::Array,
-    metadata_key: :options do |result, opts|
-      result.value.all? { |v| opts.include?(v) }
+
+  # 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
-  Rules.define :included_in, 'must be included in %<value>s', metadata_key: :options 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|
-    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
+
+    type | (Types::Undefined >> val_type)
   end
-  Rules.define :size, 'must be of size %<value>s', expects: :size, metadata_key: :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
 
@@ -85,27 +141,17 @@ 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
-    # 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*/) }
 
     module Lax
       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 +161,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.3'
 end

data/lib/plumb/visitor_handlers.rb

@@ -9,26 +9,35 @@ 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"
-      method_name = "visit_#{method_name}"
+    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
+
+      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, 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

@@ -1,6 +1,58 @@
 # 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 Steppable 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 Steppable.instance_methods.include?(name)
+      raise Policies::MethodAlreadyDefinedError, "Method #{name} is already defined on Steppable"
+    end
+
+    Steppable.define_method(name) do |arg = Undefined, &bl|
+      if arg == Undefined
+        policy(name, &bl)
+      else
+        policy(name, arg, &bl)
+      end
+    end
+
+    self
+  end
 end
 
 require 'plumb/result'
@@ -10,7 +62,6 @@ 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'
@@ -18,6 +69,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'

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-18 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:
     - - ">="
@@ -50,6 +50,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/command_objects.rb
+- examples/concurrent_downloads.rb
+- examples/csv_stream.rb
+- examples/env_config.rb
+- examples/programmers.csv
+- examples/weekdays.rb
 - lib/plumb.rb
 - lib/plumb/and.rb
 - lib/plumb/any_class.rb
@@ -67,12 +73,14 @@ 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
 - lib/plumb/tuple_class.rb
@@ -81,7 +89,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: {}

data/lib/plumb/rules.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'plumb/steppable'
-
-module Plumb
-  class Rules
-    UnsupportedRuleError = Class.new(StandardError)
-    UndefinedRuleError = Class.new(KeyError)
-
-    class Registry
-      RuleDef = Data.define(:name, :error_tpl, :callable, :metadata_key, :expects) do
-        def supports?(type)
-          types = [type].flatten # may be an array of types for OR logic
-          case expects
-          when Symbol
-            types.all? { |type| type.public_instance_methods.include?(expects) }
-          when Class then types.all? { |type| type <= expects }
-          when Object then true
-          else raise "Unexpected expects: #{expects}"
-          end
-        end
-      end
-
-      Rule = Data.define(:rule_def, :arg_value, :error_str) do
-        def self.build(rule_def, arg_value)
-          error_str = format(rule_def.error_tpl, value: arg_value)
-          new(rule_def, arg_value, error_str)
-        end
-
-        def node_name = :"rule_#{rule_def.name}"
-        def name = rule_def.name
-        def metadata_key = rule_def.metadata_key
-
-        def error_for(result)
-          return nil if rule_def.callable.call(result, arg_value)
-
-          error_str
-        end
-      end
-
-      def initialize
-        @definitions = Hash.new { |h, k| h[k] = Set.new }
-      end
-
-      def define(name, error_tpl, callable = nil, metadata_key: name, expects: Object, &block)
-        name = name.to_sym
-        callable ||= block
-        @definitions[name] << RuleDef.new(name:, error_tpl:, callable:, metadata_key:, expects:)
-      end
-
-      # Ex. size: 3, match: /foo/
-      def resolve(rule_specs, for_type)
-        rule_specs.map do |(name, arg_value)|
-          rule_defs = @definitions.fetch(name.to_sym) { raise UndefinedRuleError, "no rule defined with :#{name}" }
-          rule_def = rule_defs.find { |rd| rd.supports?(for_type) }
-          unless rule_def
-            raise UnsupportedRuleError, "No :#{name} rule for type #{for_type}" unless for_type.is_a?(Array)
-
-            raise UnsupportedRuleError,
-              "Can't apply :#{name} rule for types #{for_type}. All types must support the same rule implementation"
-
-          end
-
-          Rule.build(rule_def, arg_value)
-        end
-      end
-    end
-
-    include Steppable
-
-    def self.registry
-      @registry ||= Registry.new
-    end
-
-    def self.define(...)
-      registry.define(...)
-    end
-
-    # Ex. new(size: 3, match: /foo/)
-    attr_reader :rules
-
-    def initialize(rule_specs, for_type)
-      @rules = self.class.registry.resolve(rule_specs, for_type).freeze
-      freeze
-    end
-
-    def call(result)
-      errors = []
-      err = nil
-      @rules.each do |rule|
-        err = rule.error_for(result)
-        errors << err if err
-      end
-      return result unless errors.any?
-
-      result.invalid(errors: errors.join(', '))
-    end
-
-    private def _inspect
-      +'Rules(' << @rules.map { |r| [r.name, r.arg_value].join(': ') }.join(', ') << +')'
-    end
-  end
-end