plumb 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61f58e5f4e5e3de9e6f830fc4f27ea9fb3771b50f3133781c2dcb0d5415a6d81
-  data.tar.gz: 4f336457499ba6538fd3c0137a961e1ecac915aadd4b1438770d1ef075b9fef9
+  metadata.gz: 970d29a4515fd3e9938a93474cee93d37ee90e7b197c004d4a6e2fd9f36fef4a
+  data.tar.gz: ed7e89f47023ee9d1cdf53b3c39758ff69f0c0cb4399a4b972a4ad670f9c4cfd
 SHA512:
-  metadata.gz: be801887ab34b217ac4d1c274bbfa58546a232566bb1cf43d051fcf0c39f1516fbcc6fea587cd5ce34455c869b957fe56b4c9e86b6fce8a8ac364457ba678bf7
-  data.tar.gz: a5d010337c21e90439c54dc3e9a6a9e72aacf4c3bc89cf2d4c3c57c3bf245f8b7224ff8381d2f42e5377a2ffe5968eb718fc59ee5312165daaa4f9e85682cc1f
+  metadata.gz: 066e9e2d5e06c19286600e21bbe85da7304c87156241e7eae79c2dcc4abb30a370416dd4cfe343d66535521848b25c4e348a1bacc7f7aff71c5ab790c6afeae4
+  data.tar.gz: b6064b236ec5656b648bcc576c7ca0dbccfc172ec8615eba32e98a157ba2600ce282ab1e154b07a5be47999dcda2838698c639d51651b6e41e49f7dce6058d71

data/README.md

@@ -328,6 +328,28 @@ type.resolve(['a', 'a', 'b']) # Valid
 type.resolve(['a', 'x', 'b']) # Failure
 ```
 
+### `#with`
+
+The `#with` helper matches attributes of the object with values, using `#===`.
+
+```ruby
+LimitedArray = Types::Array[String].with(size: 10)
+LimitedString = Types::String.with(size: 10)
+LimitedSet = Types::Any[Set].with(size: 10)
+```
+
+The size is matched via `#===`, so ranges also work.
+
+```ruby
+Password = Types::String.with(bytesize: 10..20)
+```
+
+The helper accepts multiple attribute/valye pairs
+
+```ruby
+JoeBloggs = Types::Any[User].with(first_name: 'Joe', last_name: 'Bloggs')
+```
+
 #### `#transform`
 
 Transform value. Requires specifying the resulting type of the value after transformation.
@@ -588,23 +610,7 @@ The opposite of `#options`, this policy validates that the value _is not_ includ
 Name = Types::String.policy(excluded_from: ['Joe', 'Joan'])
 ```
 
-#### `:size`
-
-Works for any value that responds to `#size` and validates that the value's size matches the argument.
-
-```ruby
-LimitedArray = Types::Array[String].policy(size: 10)
-LimitedString = Types::String.policy(size: 10)
-LimitedSet = Types::Any[Set].policy(size: 10)
-```
-
-The size is matched via `#===`, so ranges also work.
-
-```ruby
-Password = Types::String.policy(size: 10..20)
-```
-
-#### `:split` (strings only)
+#### :split` (strings only)
 
 Splits string values by a separator (default: `,`).
 

data/examples/concurrent_downloads.rb

@@ -67,7 +67,7 @@ module Types
 end
 
 ###################################
-# Program 1: idempoent download of images from the internet
+# Program 1: idempotent download of images from the internet
 # If not present in the cache, images are downloaded and written to the cache.
 # Otherwise images are listed directly from the cache (files on disk).
 ###################################

data/examples/csv_stream.rb

@@ -10,7 +10,7 @@ module Types
   include Plumb::Types
 
   # Open a File
-  # ex. file = FileStep.parse('./files/data.csv') # => File
+  # ex. file = OpenFile.parse('./files/data.csv') # => File
   OpenFile = String
              .check('no file for that path') { |s| ::File.exist?(s) }
              .build(::File)

data/lib/plumb/attribute_value_match.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plumb
+  class AttributeValueMatch
+    include Composable
+
+    attr_reader :type, :attr_name, :value
+
+    def initialize(type, attr_name, value)
+      @type = type
+      @attr_name = attr_name
+      @value = value
+      @error = "must have attribute #{attr_name} === #{value.inspect}"
+      freeze
+    end
+
+    def metadata = type.metadata
+
+    def call(result)
+      return result if value === result.value.public_send(attr_name)
+
+      result.invalid(errors: @error)
+    end
+  end
+end

data/lib/plumb/composable.rb

@@ -273,15 +273,16 @@ module Plumb
     class Node
       include Composable
 
-      attr_reader :node_name, :type, :attributes
+      attr_reader :node_name, :type, :args
 
-      def initialize(node_name, type, attributes = BLANK_HASH)
+      def initialize(node_name, type, args = BLANK_HASH)
         @node_name = node_name
         @type = type
-        @attributes = attributes
+        @args = args
         freeze
       end
 
+      def metadata = type.metadata
       def call(result) = type.call(result)
     end
 
@@ -291,10 +292,22 @@ module Plumb
     # Ex. Types::Boolean is a compoition of Types::True | Types::False, but we want to treat it as a single node.
     #
     # @param node_name [Symbol]
-    # @param metadata [Hash]
+    # @param args [Hash]
     # @return [Node]
-    def as_node(node_name, metadata = BLANK_HASH)
-      Node.new(node_name, self, metadata)
+    def as_node(node_name, args = BLANK_HASH)
+      Node.new(node_name, self, args)
+    end
+
+    # Check attributes of an object against values, using #===
+    # @example
+    #   type = Types::Array.with(size: 1..10)
+    #   type = Types::String.with(bytesize: 1..10)
+    #
+    # @param attrs [Hash]
+    def with(attrs)
+      attrs.reduce(self) do |t, (name, value)|
+        t >> AttributeValueMatch.new(t, name, value)
+      end
     end
 
     # Register a policy for this step.
@@ -425,6 +438,7 @@ module Plumb
 end
 
 require 'plumb/deferred'
+require 'plumb/attribute_value_match'
 require 'plumb/transform'
 require 'plumb/policy'
 require 'plumb/build'

data/lib/plumb/json_schema_visitor.rb

@@ -138,30 +138,41 @@ module Plumb
       end
     end
 
+    on(:attribute_value_match) do |node, props|
+      method_name = :"visit_with_#{node.attr_name}_attribute"
+      if respond_to?(method_name)
+        send(method_name, node, props)
+      else
+        props
+      end
+    end
+
     on(:options_policy) do |node, props|
       props.merge(ENUM => node.arg)
     end
 
-    on(:size_policy) do |node, props|
-      opts = {}
-      case props[TYPE]
+    on(:with_size_attribute) do |node, props|
+      opts = visit(node.type)
+      value = node.value
+
+      case opts[TYPE]
       when 'array'
-        case node.arg
+        case value
         when Range
-          opts[MIN_ITEMS] = node.arg.min if node.arg.begin
-          opts[MAX_ITEMS] = node.arg.max if node.arg.end
+          opts[MIN_ITEMS] = value.min if value.begin
+          opts[MAX_ITEMS] = value.max if value.end
         when Numeric
-          opts[MIN_ITEMS] = node.arg
-          opts[MAX_ITEMS] = node.arg
+          opts[MIN_ITEMS] = value
+          opts[MAX_ITEMS] = value
         end
       when 'string'
-        case node.arg
+        case value
         when Range
-          opts[MIN_LENGTH] = node.arg.min if node.arg.begin
-          opts[MAX_LENGTH] = node.arg.max if node.arg.end
+          opts[MIN_LENGTH] = value.min if value.begin
+          opts[MAX_LENGTH] = value.max if value.end
         when Numeric
-          opts[MIN_LENGTH] = node.arg
-          opts[MAX_LENGTH] = node.arg
+          opts[MIN_LENGTH] = value
+          opts[MAX_LENGTH] = value
         end
       end
 
@@ -242,7 +253,11 @@ module Plumb
       opts = visit(element.class)
       if element.is_a?(::Numeric)
         opts[MINIMUM] = node.min if node.begin
-        opts[MAXIMUM] = node.max if node.end
+        if node.end
+          max = node.end
+          max -= 1 if node.exclude_end?
+          opts[MAXIMUM] = max
+        end
       end
       props.merge(opts)
     end

data/lib/plumb/schema.rb

@@ -178,6 +178,11 @@ module Plumb
         self
       end
 
+      def with(...)
+        @_type = @_type.with(...)
+        self
+      end
+
       def inspect
         "#{self.class}[#{@_type.inspect}]"
       end

data/lib/plumb/types.rb

@@ -7,6 +7,7 @@ require 'time'
 
 module Plumb
   # Define core policies
+  #
   # Allowed options for an array type.
   # It validates that each element is in the options array.
   # Usage:
@@ -43,17 +44,6 @@ module Plumb
     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
-
   # Validate that an object is not #empty? nor #nil?
   # Usage:
   #   Types::String.present

data/lib/plumb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-16 00:00:00.000000000 Z
+date: 2025-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -65,6 +65,7 @@ files:
 - lib/plumb/and.rb
 - lib/plumb/any_class.rb
 - lib/plumb/array_class.rb
+- lib/plumb/attribute_value_match.rb
 - lib/plumb/attributes.rb
 - lib/plumb/build.rb
 - lib/plumb/composable.rb