ru.Bee 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c12dfae68f0595266581855939b1d4b80468ad9e4298438a0125b709e96c3fa3
-  data.tar.gz: 6fb74be8efa80754b66f603bbe41b2ba5cc9cbc26eddfcb55ee24f7073c31a74
+  metadata.gz: cc6a4fbeb28a460ca66f75ccf1f5c97fe1572f422392f9ee1b72d082e05cb287
+  data.tar.gz: f4dbeaf7338af243f6e225a2a798a87de75b001fa4196bed94345d78887ba8ea
 SHA512:
-  metadata.gz: 463291b6a407cc39fa1b26620416da495598aa56332091e37eb5c8545e0d1f1a35bbb23586b43958bd7c83d59c66663b382b7c54c7b45a5496803365ee1e1623
-  data.tar.gz: 9bc34459746bc4a060f1fdb697f332cc35246cc104cf1a211ec9533f92a301573f0270e98582d86c64bfe72585fb233170befbc7e5719cb7d88d76a465945d3f
+  metadata.gz: 996510c80521425797e17a1b641d767d6319877e127883692d519457c7573835ae2670a8ed17950f302b1934a0aae1270d8b065acfee079341935ddb8964a26f
+  data.tar.gz: 75a8ab899d3c98fd492a30ec5501982526318387c9214b78ebdf57ec2c39a91778268283db82cbeb5ae9072aa4c62507b1d175423e7f86beec892cddfea0bb90

data/lib/rubee/extensions/validatable.rb

@@ -31,44 +31,73 @@ module Rubee
         @optional = false
       end
 
-      def required(error_hash)
+      def required(error_message = nil)
         value = @instance.send(@attribute)
+
+        error_hash = assemble_error_hash(error_message, :required, attribute: @attribute)
         if value.nil? || (value.respond_to?(:empty?) && value.empty?)
           @state.add_error(@attribute, error_hash)
         end
+
         self
       end
 
       def optional(*)
         @optional = true
+
         self
       end
 
-      def type(expected_class, error_hash)
-        return self if @state.has_errors_for?(@attribute)
+      def attribute
+        self
+      end
 
+      def type(expected_class, error_message = nil)
+        return self if @state.has_errors_for?(@attribute)
         value = @instance.send(@attribute)
         return self if @optional && value.nil?
 
+        error_hash = assemble_error_hash(error_message, :type, class: expected_class)
         unless value.is_a?(expected_class)
           @state.add_error(@attribute, error_hash)
         end
+
         self
       end
 
-      def condition(handler, error_message)
+      def condition(handler, error_message = nil)
         return self if @state.has_errors_for?(@attribute)
         value = @instance.send(@attribute)
         return self if @optional && value.nil?
 
+        error_hash = assemble_error_hash(error_message, :condition)
         if handler.respond_to?(:call)
-          @state.add_error(@attribute, error_message) unless handler.call
+          @state.add_error(@attribute, error_hash) unless handler.call
         else
           @instance.send(handler)
         end
 
         self
       end
+
+      private
+
+      def assemble_error_hash(error_message, error_type, **options)
+        error_message ||= default_message(error_type, **options)
+        if error_message.is_a?(String)
+          error_message = { message: error_message }
+        end
+
+        error_message
+      end
+
+      def default_message(type, **options)
+        {
+          condition: "condition is not met",
+          required: "attribute '#{options[:attribute]}' is required",
+          type: "attribute must be #{options[:class]}",
+        }[type]
+      end
     end
 
     def self.included(base)
@@ -102,7 +131,17 @@ module Rubee
 
       def run_validations
         @__validation_state = State.new
-        self.class&.validation_block&.call(self)
+        if (block = self.class.validation_block)
+          instance_exec(&block)
+        end
+      end
+
+      def subject
+        @__validation_state.instance
+      end
+
+      def attribute(name)
+        RuleChain.new(self, name, @__validation_state).attribute
       end
 
       def required(attribute, options)

data/lib/rubee.rb

@@ -17,7 +17,7 @@ module Rubee
   CSS_DIR = File.join(APP_ROOT, LIB, 'css') unless defined?(CSS_DIR)
   ROOT_PATH = File.expand_path(File.join(__dir__, '..')) unless defined?(ROOT_PATH)
 
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
 
   require_relative 'rubee/router'
   require_relative 'rubee/logger'

data/lib/tests/models/account_model_test.rb

@@ -18,9 +18,8 @@ describe 'Account model' do
 
     describe '#validate_before_persist' do
       it 'rasies error if account is not valid' do
-        Account.validate do |account|
-          account
-            .required(:addres, required: "address is required")
+        Account.validate do
+          required(:addres, required: "address is required")
             .type(String, type: "address must be string")
         end
         Account.validate_before_persist!

data/lib/tests/models/comment_model_test.rb

@@ -47,17 +47,17 @@ describe 'Comment model' do
 
   describe 'validatable' do
     def include_and_validate(required: true)
-      # Comment.include(Rubee::Validatable)
       required_or_optional = required ? :required : :optional
-      required_or_optional_args = required ? [:text, required: "text filed is required"] : [:text]
-      Comment.validate do |comment|
-        comment.send(
+      required_or_optional_args = required ? [required: "text filed is required"] : []
+      Comment.validate do
+        attribute(:text).send(
           required_or_optional, *required_or_optional_args
         )
           .type(String, type: "text field must be string")
-          .condition(proc { comment.text.length > 4 }, { length: "text length must be greater than 4" })
+          .condition(proc { text.length > 4 }, { length: "text length must be greater than 4" })
       end
     end
+
     it 'is valid' do
       include_and_validate
       comment = Comment.new(text: 'test it as valid')
@@ -180,5 +180,47 @@ describe 'Comment model' do
         assert_equal('testerter', comment.text)
       end
     end
+
+    describe 'default errors as error' do
+      it 'assembles error hash' do
+        Comment.validate do
+          attribute(:text).required.type(String).condition(-> { text.length > 4 })
+        end
+
+        comment = Comment.new(text: 'test')
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "condition is not met" })
+
+        comment = Comment.new(text: 123)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "attribute must be String" })
+
+        comment = Comment.new(user_id: User.last)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "attribute 'text' is required" })
+      end
+    end
+
+    describe 'message instead hash as error' do
+      it 'assembles error hash' do
+        Comment.validate do
+          attribute(:text)
+            .required("Text is a mandatory field").type(String, "Text must be a string")
+            .condition(-> { text.length > 4 }, "Text length must be greater than 4")
+        end
+
+        comment = Comment.new(text: 'test')
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text length must be greater than 4" })
+
+        comment = Comment.new(text: 123)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text must be a string" })
+
+        comment = Comment.new(user_id: User.last)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text is a mandatory field" })
+      end
+    end
   end
 end

data/readme.md

@@ -881,70 +881,88 @@ class Foo
     @age = age
   end
 
-  validate do |foo|
-    foo
-      .required(:name, required: 'Name is required')
-      .type(String, type: 'must be a string')
-      .condition(->{ foo.name.length > 2 }, length: 'Name must be at least 3 characters long')
-
-    foo
-      .required(:age, required: 'Age is required')
-      .type(Integer, type: 'must be an integer')
-      .condition(->{ foo.age > 18 }, age: 'You must be at least 18 years old')
+  validate do
+    attribute(:name).required.type(String).condition(->{ name.length > 2 })
+
+    attribute(:age)
+      .required('Age is a manadatory field')
+      .type(Integer, error_message: 'Must be an integerRRRRRRrrr!')
+      .condition(->{ age > 18 }, fancy_error: 'You must be at least 18 years old, dude!')
   end
 end
 ```
+Then we can evaluate it in the ru.Bee console
 ```bash
-    irb(main):068> Foo.new("Joe", "20")
-    =>
-    #<Foo:0x0000000120d7f778
-     @__validation_state=#<Rubee::Validatable::State:0x0000000120d7f700 @errors={age: {type: "must be an integer"}}, @valid=false>,
-     @age="20",
-     @name="Joe">
-    irb(main):069> foo = Foo.new("Joe", 11)
-    =>
-    #<Foo:0x0000000105f2b0b0
-    ...
-    irb(main):070> foo.valid?
-    => false
-    irb(main):071> foo.errors
-    => {age: {age: "You must be at least 18 years old"}}
-    irb(main):072> foo.age=20
-    => 20
-    irb(main):073> foo.valid?
-    => true
+=> #<Proc:0x000000010d389d80 (irb):32>
+irb(main):041> Foo.new("Test", 20)
+=> #<Foo:0x000000010d383fc0 @__validation_state=#<Rubee::Validatable::State:0x000000010d383de0 @errors={}, @valid=true>, @age=20, @name="Test">
+irb(main):042> Foo.new("Test", 1)
+=>
+#<Foo:0x000000010ce61c40
+ @__validation_state=#<Rubee::Validatable::State:0x000000010ce61bc8 @errors={age: {fancy_error: "You must be at least 18 years old, dude!"}}, @valid=false>,
+ @age=1,
+ @name="Test">
+irb(main):043> Foo.new("Test", nil)
+=>
+#<Foo:0x000000010c46f200
+ @__validation_state=#<Rubee::Validatable::State:0x000000010c46f070 @errors={age: {message: "Age is a manadatory field"}}, @valid=false>,
+ @age=nil,
+ @name="Test">
+irb(main):044> Foo.new("Te", 20)
+=>
+#<Foo:0x000000010cfe9270
+ @__validation_state=#<Rubee::Validatable::State:0x000000010cfe91f8 @errors={name: {message: "condition is not met"}}, @valid=false>,
+ @age=20,
+ @name="Te">
+irb(main):045> foo = Foo.new("Joe", "wrong")
+=>
+#<Foo:0x000000010d32eb38
+...
+irb(main):046> foo.valid?
+=> false
+irb(main):047> foo.errors
+=> {age: {error_message: "Must be an integerRRRRRRrrr!"}}
 ```
 Model example
 ```ruby
 class User < Rubee::SequelObject
   attr_accessor :id, :email, :password, :created, :updated
 
-    validate do |user|
-     user
-       .required(:email, required: 'Email is required')
-       .condition(
-         ->{ user.email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }, email: 'Wrong email format'
-       )
-    end
-    validate_before_persist! # This will validate and raise error in case invalid before saving to DB
+  validate_before_persist! # This will validate and raise error in case invalid before saving to DB
+  validate do
+    attribute(:email).required
+      .condition(
+        ->{ email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }, error: 'Wrong email format'
+      )
+  end
 end
 ```
 ```bash
-irb(main):089> user = User.new(email: "wrong", password: 123)
-=> #<User:0x000000010cda23b8 @email="wrong", @password=123>
-irb(main):090> user.valid?
+irb(main):074> user = User.new(email: "wrong", password: 123)
+=>
+#<User:0x000000010d2c3e78
+...
+irb(main):075> user.valid?
 => false
-irb(main):091> user.errors
-=> {email: {email: "Wrong email format"}}
-irb(main):091> user.save
-...sequel_object.rb:229:in 'block in Rubee::SequelObject.validate_before_persist!': {email: {email: "Wrong email format"}} (Rubee::Validatable::Error)
-irb(main):092> user.email = "ok@ok.com"
+irb(main):076> user.errors
+=> {email: {error: "Wrong email format"}}
+irb(main):077> user.save
+=>{email: {error: "Wrong email format"}} (Rubee::Validatable::Error) ..
+irb(main):078> user.email = "ok@ok.com"
 => "ok@ok.com"
-irb(main):094> user.valid?
+irb(main):079> user.valid?
 => true
-irb(main):095> user.save
+irb(main):080> user.save
 => true
-
+irb(main):081> user
+=>
+#<User:0x000000010d2c3e78
+ @__validation_state=#<Rubee::Validatable::State:0x000000010cb28628 @errors={}, @valid=true>,
+ @created=2025-11-30 17:18:52.254197 -0500,
+ @email="ok@ok.com",
+ @id=2260,
+ @password=123,
+ @updated=2025-11-30 17:18:52.254206 -0500>
 ```
 [Back to content](#content)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ru.Bee
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Oleg Saltykov