ru.Bee 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c12dfae68f0595266581855939b1d4b80468ad9e4298438a0125b709e96c3fa3
-  data.tar.gz: 6fb74be8efa80754b66f603bbe41b2ba5cc9cbc26eddfcb55ee24f7073c31a74
+  metadata.gz: f5d297ac622918eccf7bd285f4cfdf848e2909cbd19f57378105022505dfd222
+  data.tar.gz: 8976743ad813675bdd5c32d9149c5ffd70c3254980ab4a3b25835532e852d0cc
 SHA512:
-  metadata.gz: 463291b6a407cc39fa1b26620416da495598aa56332091e37eb5c8545e0d1f1a35bbb23586b43958bd7c83d59c66663b382b7c54c7b45a5496803365ee1e1623
-  data.tar.gz: 9bc34459746bc4a060f1fdb697f332cc35246cc104cf1a211ec9533f92a301573f0270e98582d86c64bfe72585fb233170befbc7e5719cb7d88d76a465945d3f
+  metadata.gz: 0d9053f14123576c2a28e58fe39398a207bd5b350e96b871bf291f24ae9470ec15659cfbbbce643fb54a689fb9f45199792b571a3be4634397c7988bc5e9b42d
+  data.tar.gz: 3f2572054237820d93a8cec5daee95f86df00e36991b74e74fa1b5cf5bfeffc088c96d01026d07a1d163486fc8ad47d594c3f484396e8b467832e2946adea869

data/lib/db/create_clients.rb

@@ -0,0 +1,15 @@
+class CreateClients
+  def call
+    return if Rubee::SequelObject::DB.tables.include?(:clients)
+
+    Rubee::SequelObject::DB.create_table(:clients) do
+      primary_key(:id)
+      String(:name)
+      String(:digest_password)
+      index(:name)
+      # timestamps
+      datetime(:created)
+      datetime(:updated)
+    end
+  end
+end

data/lib/rubee/controllers/extensions/auth_tokenable.rb

@@ -3,7 +3,7 @@ require 'date'
 
 module Rubee
   module AuthTokenable
-    KEY = "secret#{Date.today}".freeze unless defined?(KEY) # Feel free to cusomtize it
+    KEY ="secret#{ENV['JWT_KEY']}#{Date.today}".freeze unless defined?(KEY) # Feel free to cusomtize it
     EXPIRE = 3600 unless defined?(EXPIRE)
 
     def self.included(base)
@@ -27,10 +27,10 @@ module Rubee
         @request.env['rack.session']&.[]('authentificated')
       end
 
-      def authentificated_user
-        # User model must be created with email and password properties at least
-        if params[:email] && params[:password]
-          @authentificated_user ||= ::User.where(email: params[:email], password: params[:password]).first
+      def authentificated_user(user_model: ::User, login: :email, password: :password)
+        if params[login] && params[password]
+          query_params = { login => params[login], password => params[password] }
+          @authentificated_user ||= user_model.where(query_params).first
         elsif @request.cookies['jwt'] && valid_token?
           token = @request.cookies['jwt']
           hash = ::JWT.decode(token, Rubee::AuthTokenable::KEY, true, { algorithm: 'HS256' })
@@ -38,11 +38,11 @@ module Rubee
         end
       end
 
-      def authentificate!
-        return false unless authentificated_user
+      def authentificate!(user_model: ::User, login: :email, password: :password)
+        return false unless authentificated_user(user_model:, login:, password:)
 
         # Generate token
-        payload = { username: params[:email], exp: Time.now.to_i + EXPIRE }
+        payload = { username: params[login], exp: Time.now.to_i + EXPIRE }
         @token = ::JWT.encode(payload, KEY, 'HS256')
         # Set jwt token to the browser within cookie, so next browser request will include it.
         # make sure it passed to response_with headers options

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.2.0'
 
   require_relative 'rubee/router'
   require_relative 'rubee/logger'

data/lib/tests/controllers/auth_tokenable_test.rb

@@ -1,5 +1,55 @@
 require_relative '../test_helper'
 
+class TestController < Rubee::BaseController
+  include(Rubee::AuthTokenable)
+  auth_methods(:show)
+  def show
+    response_with(type: :json, object: { ok: :ok })
+  end
+
+  # POST /test/login (login logic)
+  def login
+    if authentificate! # AuthTokenable method that init @token_header
+      # Redirect to restricted area, make sure headers: @token_header is passed
+      response_with(type: :json, object: { ok: :ok }, headers: @token_header)
+    else
+      @error = "Wrong email or password"
+      response_with(type: :json, object: { error: 'user unauthenticated' }, status: :unauthenticated)
+    end
+  end
+
+  # POST /test/logout (logout logic)
+  def logout
+    unauthentificate! # AuthTokenable method aimed to handle logout action.
+    # Make sure @zeroed_token_header is paRssed within headers options
+    response_with(type: :json, object: { ok: 'logged out' }, headers: @zeroed_token_header)
+  end
+end
+
+class TesttwoController < Rubee::BaseController
+  include(Rubee::AuthTokenable)
+  auth_methods(:show)
+  def show
+    response_with(type: :json, object: { ok: :ok })
+  end
+
+  # POST /testtwo/login (login logic)
+  def login
+    if authentificate!(user_model: Client, login: :name, password: :digest_password)
+      response_with(type: :json, object: { ok: :ok }, headers: @token_header)
+    else
+      @error = "Wrong email or password"
+      response_with(type: :json, object: { error: 'user unauthenticated' }, status: :unauthenticated)
+    end
+  end
+
+  # POST /testtwo/logout (logout logic)
+  def logout
+    unauthentificate!(user_model: Client, login: :name, password: :digest_password)
+    response_with(type: :json, object: { ok: 'logged out' }, headers: @zeroed_token_header)
+  end
+end
+
 class AuthTokenableTest < Minitest::Test
   include Rack::Test::Methods
 
@@ -9,21 +59,43 @@ class AuthTokenableTest < Minitest::Test
 
   def setup
     Rubee::Autoload.call
+    Rubee::Router.draw do |route|
+      route.post('/test/login', to: 'test#login')
+      route.post('/test/logout', to: 'test#logout')
+      route.get('/test/show', to: 'test#show')
+      route.post('/testtwo/login', to: 'testtwo#login')
+      route.post('/testtwo/logout', to: 'testtwo#logout')
+      route.get('/testtwo/show', to: 'testtwo#show')
+    end
+    User.create(email: '9oU8S@example.com', password: '123456')
+    Client.create(name: '9oU8S@example.com', digest_password: '123456')
   end
 
-  def teardown
-    # detach auth methods
-    return unless WelcomeController.instance_variable_defined?(:@auth_methods)
+  def test_test_controller_included_auth_tokenable
+    get('/test/show')
 
-    WelcomeController.send(:remove_instance_variable, :@auth_methods)
+    assert_equal(last_response.status, 401)
   end
 
-  def test_welcome_controller_included_auth_tokenable
-    WelcomeController.include(Rubee::AuthTokenable)
-    WelcomeController.auth_methods(:show)
+  def test_test_controller_included_auth_tokenable_authenticated
+    post('/test/login', { email: '9oU8S@example.com', password: '123456' })
+    rack_mock_session.cookie_jar["jwt"] = last_response.cookies["jwt"].value.last
+    get('/test/show')
 
-    get('/')
+    assert_equal(last_response.status, 200)
+  end
+
+  def test_test_controller_included_auth_tokenable_unauthenticated_custom_model
+    get('/testtwo/show')
 
     assert_equal(last_response.status, 401)
   end
+
+  def test_test_controller_included_auth_tokenable_authenticated_custom_model
+    post('/testtwo/login', { name: '9oU8S@example.com', digest_password: '123456' })
+    rack_mock_session.cookie_jar["jwt"] = last_response.cookies["jwt"].value.last
+    get('/testtwo/show')
+
+    assert_equal(last_response.status, 200)
+  end
 end

data/lib/tests/example_models/client.rb

@@ -0,0 +1,3 @@
+class Client < Rubee::SequelObject
+  attr_accessor :id, :name, :digest_password, :created, :updated
+end

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

@@ -151,14 +151,14 @@ cd my_project
 
 ***Prerequisites***<br />
 Make sure:
-**Ruby** language (3.1>) is installed
+**Ruby** language (3.1 or higher, 3.4.1 recommended) is installed
 **Bundler** is installed
 
 ```bash
 bundle install
 ```
 
-4. Run RUBER server. Default port is 7000
+4. Run ru.Bee server. Default port is 7000
 ```bash
 rubee start # or rubee start_dev for development
 
@@ -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')
+  validate do
+    attribute(:name).required.type(String).condition(->{ name.length > 2 })
 
-    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')
+    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.2.0
 platform: ruby
 authors:
 - Oleg Saltykov
@@ -58,6 +58,7 @@ files:
 - lib/css/app.css
 - lib/db/create_accounts.rb
 - lib/db/create_addresses.rb
+- lib/db/create_clients.rb
 - lib/db/create_comments.rb
 - lib/db/create_posts.rb
 - lib/db/create_users.rb
@@ -280,6 +281,7 @@ files:
 - lib/tests/controllers/users_controller_test.rb
 - lib/tests/example_models/account.rb
 - lib/tests/example_models/address.rb
+- lib/tests/example_models/client.rb
 - lib/tests/example_models/comment.rb
 - lib/tests/example_models/post.rb
 - lib/tests/example_models/user.rb