plumb 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82cbbcfabbe2240d11a1957c7d06f59e314d8013c1459ecdd6339404f0c3208e
-  data.tar.gz: a17828a33c296ba50bffbb629a806f732bc3a9f73d974617e4526bfd74065d42
+  metadata.gz: 7e5d0ac088968506a61d63da75f4010b050579c873d79604a25dfe0b133d3726
+  data.tar.gz: d559c1a3964544184258043e14d0bf9e3b41ff743a8117eccee09be2c22b084a
 SHA512:
-  metadata.gz: 28ce9c69dcfa1f5d1129745301164400211c1df5707b851a2457f4361b59ed0ad73472851ae2993267f3d74389a6477ded4a60ce3eaed70472c041fad03df7bd
-  data.tar.gz: 45e8f649c646b3236c6e7e5c3c86ed7493b88fc544585e5dc168675c69660b7ca217b5508a834b2dfa1820f97ca87b4edd9b988d17effb82697da28273545e2d
+  metadata.gz: 1207b06d90baa9833cf39737f2697fb6daf9423d94ca531a99307de561b70415bb6c9ec7fb2394af6c1f8b3f86015996ebfde5db6dc3fa2aadd5284fb1867cb2
+  data.tar.gz: 19131a0a289b8c5082ceb3a9cd716cdabb2d12466bba76ecc5d20c2efd6db3fbb9c04d13c8706996225189de50d81c5d8325fc5527ecc8395c492430fd17393d

data/README.md

@@ -294,6 +294,22 @@ NotEmail.parse('hello') # "hello"
 NotEmail.parse('hello@server.com') # error
 ```
 
+`#not` can also be given a type as argument, which might read better:
+
+```ruby
+Types::Any.not(nil)
+Types::Any.not(Types::Email)
+```
+
+Finally, you can use `Types::Not` for the same effect.
+
+```ruby
+NotNil = Types::Not[nil]
+NotNil.parse(1) # 1
+NotNil.parse('hello') # 'hello'
+NotNil.parse(nil) # error
+```
+
 #### `#options`
 
 Sets allowed options for value.
@@ -506,7 +522,7 @@ So, normally you'd only use this attached to primitive types without further pro
 Passing a proc will evaluate the proc on every invocation. Use this for generated values.
 
 ```ruby
-random_number = Types::Numeric.static { rand }
+random_number = Types::Numeric.generate { rand }
 random_number.parse # 0.32332
 random_number.parse('foo') # 0.54322 etc
 ```
@@ -514,7 +530,7 @@ random_number.parse('foo') # 0.54322 etc
 Note that the type of generated value must match the initial step's type, validated at invocation.
 
 ```ruby
-random_number = Types::String.static { rand } # this won't raise an error here
+random_number = Types::String.generate { rand } # this won't raise an error here
 random_number.parse # raises Plumb::ParseError because `rand` is not a String
 ```
 
@@ -1200,6 +1216,30 @@ Payload = Types::Hash[
 ]
 ```
 
+#### Attribute writers
+
+By default `Types::Data` classes are inmutable, but you can define attribute writers to allow for mutation using the `writer: true` option.
+
+```ruby
+class DBConfig < Types::Data
+  attribute :host, Types::String.default('localhost'), writer: true
+end
+
+class Config < Types::Data
+  attribute :host, Types::Forms::URI::HTTP, writer: true
+  attribute :port, Types::Integer.default(80), writer: true
+
+  # Nested structs can have writers too
+  attribute :db, DBConfig.default(DBConfig.new)
+end
+
+config = Config.new
+config.host = 'http://localhost'
+config.db.host = 'db.local'
+config.valid? # true
+config.errors # {}
+```
+
 #### Recursive struct definitions
 
 You can use `#defer`. See [recursive types](#recursive-types).

data/lib/plumb/attributes.rb

@@ -117,6 +117,7 @@ module Plumb
 
     def initialize(attrs = {})
       assign_attributes(attrs)
+      freeze
     end
 
     def ==(other)
@@ -140,13 +141,18 @@ module Plumb
 
     # @return [Hash]
     def to_h
-      attributes.transform_values do |value|
-        case value
-        when ::Array
-          value.map { |v| v.respond_to?(:to_h) ? v.to_h : v }
-        else
-          value.respond_to?(:to_h) ? value.to_h : value
-        end
+      self.class._schema._schema.keys.each.with_object({}) do |key, memo|
+        key = key.to_sym
+        value = attributes[key]
+        val = case value
+              when ::Array
+                value.map { |v| v.respond_to?(:to_h) ? v.to_h : v }
+              when ::NilClass
+                nil
+              else
+                value.respond_to?(:to_h) ? value.to_h : value
+              end
+        memo[key] = val
       end
     end
 
@@ -158,7 +164,7 @@ module Plumb
     def assign_attributes(attrs = BLANK_HASH)
       raise ArgumentError, 'Must be a Hash of attributes' unless attrs.respond_to?(:to_h)
 
-      @errors = BLANK_HASH
+      @errors = {}
       result = self.class._schema.resolve(attrs.to_h)
       @attributes = prepare_attributes(result.value)
       @errors = result.errors unless result.valid?
@@ -211,7 +217,7 @@ module Plumb
       # attribute(:friends, Types::Array[Person])
       # attribute(:friends, [Person])
       #
-      def attribute(name, type = Types::Any, &block)
+      def attribute(name, type = Types::Any, writer: false, &block)
         key = Key.wrap(name)
         name = key.to_sym
         type = Composable.wrap(type)
@@ -234,13 +240,30 @@ module Plumb
         end
 
         @_schema = _schema + { key => type }
-        __plumb_define_attribute_method__(name)
+        __plumb_define_attribute_reader_method__(name)
+        return name unless writer
+
+        __plumb_define_attribute_writer_method__(name)
       end
 
-      def __plumb_define_attribute_method__(name)
+      def __plumb_define_attribute_reader_method__(name)
         define_method(name) { @attributes[name] }
       end
 
+      def __plumb_define_attribute_writer_method__(name)
+        define_method("#{name}=") do |value|
+          type = self.class._schema.at_key(name)
+          result = type.resolve(value)
+          @attributes[name] = result.value
+          if result.valid?
+            @errors.delete(name)
+          else
+            @errors.merge!(name => result.errors)
+          end
+          result.value
+        end
+      end
+
       def attribute?(name, *args, &block)
         attribute(Key.new(name, optional: true), *args, &block)
       end

data/lib/plumb/not.rb

@@ -8,13 +8,19 @@ module Plumb
 
     attr_reader :children, :errors
 
-    def initialize(step, errors: nil)
-      @step = step
-      @errors = errors
+    def initialize(step = nil, errors: nil)
+      @step = Composable.wrap(step)
+      @errors = errors || "must not be #{step.inspect}"
       @children = [step].freeze
       freeze
     end
 
+    # @param step [Object]
+    # @return [Not]
+    def [](step)
+      self.class.new(step)
+    end
+
     private def _inspect
       %(Not(#{@step.inspect}))
     end

data/lib/plumb/types.rb

@@ -159,6 +159,7 @@ module Plumb
     Stream = StreamClass.new
     Tuple = TupleClass.new
     Hash = HashClass.new
+    Not = Plumb::Not.new
     Interface = InterfaceClass.new
     Email = String[URI::MailTo::EMAIL_REGEXP].as_node(:email)
     Date = Any[::Date]

data/lib/plumb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-25 00:00:00.000000000 Z
+date: 2024-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -115,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: Data validation and transformation library.