ru.Bee 1.11.1 → 2.1.0

data/lib/rubee/pubsub/publisher.rb

@@ -0,0 +1,18 @@
+module Rubee
+  module PubSub
+    module Publisher
+      Error = Class.new(StandardError)
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def pub(channel, args = {}, &block)
+          Rubee::Configuration.pubsub_container.pub(channel, args, &block)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rubee/pubsub/redis.rb

@@ -0,0 +1,99 @@
+require "connection_pool"
+require "redis"
+require "singleton"
+require "json"
+
+module Rubee
+  module PubSub
+    class Redis < Container
+      include Singleton
+
+      DEFAULT_POOL_SIZE = 5
+      DEFAULT_TIMEOUT = 5
+
+      def initialize
+        redis_url = Rubee::Configuration.get_redis_url
+        @pool = ConnectionPool.new(size: DEFAULT_POOL_SIZE, timeout: DEFAULT_TIMEOUT) do
+          if redis_url&.empty?
+            ::Redis.new
+          else
+            ::Redis.new(url: redis_url)
+          end
+        end
+        @mutex = Mutex.new
+      end
+
+      # Example: pub("ok", message: "hello")
+      def pub(channel, args = {}, &block)
+        keys = with_redis { |r| r.scan_each(match: "#{channel}:*").to_a }
+        return false if keys.empty?
+
+        values = with_redis { |r| r.mget(*keys) }
+
+        iterable = values.each_with_index.each_with_object({}) do |(val, i), hash|
+          key = keys[i]
+          hash[key] = val
+        end
+
+        clazzes = retrieve_klasses(iterable)
+        fan_out(clazzes, args, &block)
+      end
+
+      # Example: sub("ok", "User", ["123"])
+      def sub(channel, klass_name, *args, &block)
+        @mutex.synchronize do
+          id = args.first
+          id_string = id ? ":#{id}" : ""
+          key = "#{channel}:#{klass_name}#{id_string}"
+          existing = with_redis { |r| r.get(key) }
+          io = args.last.respond_to?(:call) ? args.pop : nil
+
+          with_redis { |r| r.set(key, args.join(",")) } unless existing
+          block&.call(key, io: io)
+        end
+        true
+      end
+
+      def unsub(channel, klass_name, *args, &block)
+        @mutex.synchronize do
+          id = args.first
+          id_string = id ? ":#{id}" : ""
+          key = "#{channel}:#{klass_name}#{id_string}"
+          value = with_redis { |r| r.get(key) }
+          return false unless value
+
+          io = args.pop if args.last.respond_to?(:call)
+          with_redis { |r| r.del(key) }
+          block&.call(key, io: io)
+        end
+        true
+      end
+
+      protected
+
+      def with_redis(&block)
+        @pool.with(&block)
+      end
+
+      def retrieve_klasses(iterable)
+        iterable.each_with_object({}) do |(key, args), hash|
+          channel, clazz, id = key.split(":")
+          arg_list = args.to_s.split(",")
+          hash[key] = { channel:, clazz:, args: arg_list, id: }
+        end
+      end
+
+      def fan_out(clazzes, method_args = {}, &block)
+        clazzes.each do |_key, opts|
+          clazz = turn_to_class(opts[:clazz])
+          clazz_args = opts[:args]
+
+          clazz.on_pub(opts[:channel], *clazz_args, **method_args) if clazz.respond_to?(:on_pub)
+          id_string = opts[:id] ? ":#{opts[:id]}" : ""
+          block&.call("#{opts[:channel]}:#{opts[:clazz]}#{id_string}", **method_args)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/rubee/pubsub/subscriber.rb

@@ -0,0 +1,25 @@
+module Rubee
+  module PubSub
+    module Subscriber
+      Error = Class.new(StandardError)
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def sub(channel, *args, &block)
+          Rubee::Configuration.pubsub_container.sub(channel, name, *args, &block)
+
+          true
+        end
+
+        def unsub(channel, *args, &block)
+          Rubee::Configuration.pubsub_container.unsub(channel, name, *args, &block)
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rubee/pubsub/test_one.rb

@@ -0,0 +1,29 @@
+# class Subscriber
+#   include Rubee::PubSub::Subscriber
+
+#   def self.on_pub(channel, message, options = {})
+#     puts "channel=#{channel} message=#{message} options=#{options}"
+#   end
+# end
+
+# class SubscriberOne
+#   include Rubee::PubSub::Subscriber
+
+#   def self.on_pub(channel, message, options = {})
+#     puts "channel=#{channel} message=#{message} options=#{options}"
+#   end
+# end
+
+# class Publisher
+#   include Rubee::PubSub::Publisher
+# end
+
+# Subscriber.sub("ok", ["123456"])
+
+# SubscriberOne.sub("ok", ["123"])
+
+# Publisher.pub("ok", { message: "hello" })
+
+# SubscriberOne.unsub("ok", ["123"])
+
+# Publisher.pub("ok", { message: "hello" })

data/lib/rubee/websocket/websocket.rb

@@ -0,0 +1,102 @@
+require 'websocket'
+require 'websocket/frame'
+require 'websocket/handshake'
+require 'websocket/handshake/server'
+require 'json'
+require 'redis'
+
+module Rubee
+  class WebSocket
+    using ChargedHash
+    class << self
+      def call(env, &controller_block)
+        unless env['rack.hijack']
+          return [500, { 'Content-Type' => 'text/plain' }, ['Hijack not supported']]
+        end
+
+        env['rack.hijack'].call
+        io = env['rack.hijack_io']
+
+        handshake = ::WebSocket::Handshake::Server.new
+        handshake.from_rack(env)
+        unless handshake.valid?
+          io.write("HTTP/1.1 400 Bad Request\r\n\r\n")
+          io.close
+          return [-1, {}, []]
+        end
+
+        io.write(handshake.to_s)
+        incoming = ::WebSocket::Frame::Incoming::Server.new(version: handshake.version)
+
+        outgoing = ->(data) do
+          frame = ::WebSocket::Frame::Outgoing::Server.new(
+            version: handshake.version,
+            type: :text,
+            data: data.to_json
+          )
+          io.write(frame.to_s)
+        rescue IOError
+          nil
+        end
+
+        # --- Listen to incoming data ---
+        Thread.new do
+          loop do
+            data = io.readpartial(1024)
+            incoming << data
+
+            while (frame = incoming.next)
+              case frame.type
+              when :text
+                out = controller_out(frame, outgoing, &controller_block)
+                outgoing.call(**out)
+
+              when :close
+                # Client closed connection
+                handle_close(frame, io, handshake)
+                break
+              end
+            end
+          end
+        rescue EOFError, IOError
+          begin
+            handle_close(frame, io, handshake)
+          rescue
+            nil
+          end
+        end
+
+        [101, handshake.headers, []]
+      end
+
+      def payload(frame)
+        JSON.parse(frame.data)
+      rescue
+        {}
+      end
+
+      def handle_close(frame, io, handshake)
+        payload_hash = payload(frame)
+        channel = payload_hash["channel"]
+        subcriber = payload_hash["subcriber"]
+        ::Rubee::WebSocketConnections.instance.remove("#{channel}:#{subcriber}", io)
+        io.write(::WebSocket::Frame::Outgoing::Server.new(
+          version: handshake.version,
+          type: :close
+        ).to_s)
+        io.close
+      end
+
+      def controller_out(frame, io, &block)
+        payload_hash = payload(frame)
+        action  = payload_hash["action"]
+        channel = payload_hash["channel"]
+        message = payload_hash["message"]
+        options = payload_hash.select { |k, _| !["action", "channel", "message"].include?(k) }
+        options.merge!(io:)
+
+        block.call(channel:, message:, action:, options:)
+      end
+    end
+  end
+end

data/lib/rubee/websocket/websocket_connections.rb

@@ -0,0 +1,35 @@
+module Rubee
+  class WebSocketConnections
+    include Singleton
+    def initialize
+      @subscribers ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def register(channel, io)
+      @subscribers[channel] << io unless @subscribers[channel].include?(io)
+    end
+
+    def remove(channel, io)
+      @subscribers[channel].delete(io)
+    end
+
+    def remove_all(io)
+      @subscribers.each_value { _1.delete(io) }
+    end
+
+    def flush_all
+      @subscribers.each_value(&:clear)
+    end
+
+    def stream(channel, args = {})
+      ios = @subscribers[channel]
+      if !ios&.empty? && ios.all? { _1.respond_to?(:call) }
+        ios.each { _1.call(args) }
+      end
+    end
+
+    def clear
+      @subscribers = Hash.new { |h, k| h[k] = [] }
+    end
+  end
+end

data/lib/rubee.rb

@@ -16,11 +16,13 @@ module Rubee
   JS_DIR = File.join(APP_ROOT, LIB, 'js') unless defined?(JS_DIR)
   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 = '1.11.1'
+
+  VERSION = '2.1.0'
 
   require_relative 'rubee/router'
   require_relative 'rubee/logger'
   require_relative 'rubee/generator'
+  require_relative 'rubee/features'
   require_relative 'rubee/autoload'
   require_relative 'rubee/configuration'
 
@@ -31,15 +33,10 @@ module Rubee
     def call(env)
       # autoload rb files
       Autoload.call
-
-      # register images paths
+      # init rack request
       request = Rack::Request.new(env)
       # Add default path for assets
-      Router.draw do |route|
-        route.get('/images/{path}', to: 'base#image', namespace: 'Rubee')
-        route.get('/js/{path}', to: 'base#js', namespace: 'Rubee')
-        route.get('/css/{path}', to: 'base#css', namespace: 'Rubee')
-      end
+      register_assets_routes
       # define route
       route = Router.route_for(request)
       # if react is the view so we would like to delegate not cauth by rubee routes to it.
@@ -62,5 +59,15 @@ module Rubee
       # fire the action
       controller.send(action)
     end
+
+    private
+
+    def register_assets_routes
+      Router.draw do |route|
+        route.get('/images/{path}', to: 'base#image', namespace: 'Rubee')
+        route.get('/js/{path}', to: 'base#js', namespace: 'Rubee')
+        route.get('/css/{path}', to: 'base#css', namespace: 'Rubee')
+      end
+    end
   end
 end

data/lib/tests/controllers/base_controller_test.rb

@@ -1,6 +1,6 @@
 require_relative '../test_helper'
 
-class BaseControllerTest < Minitest::Test
+class WebSocketControllerTest < Minitest::Test
   include Rack::Test::Methods
 
   def app

data/lib/tests/controllers/users_controller_test.rb

@@ -0,0 +1,41 @@
+require_relative '../test_helper'
+
+class UsersControllerTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    Rubee::Application.instance
+  end
+
+  def test_websocket_handshake_written_to_io
+    env = Rack::MockRequest.env_for(
+      '/ws',
+      {
+        'REQUEST_METHOD' => 'GET',
+        'PATH_INFO' => '/ws',
+        'HTTP_CONNECTION' => 'keep-alive, Upgrade',
+        'HTTP_UPGRADE' => 'websocket',
+        'HTTP_HOST' => 'localhost:9292',
+        'HTTP_ORIGIN' => 'http://localhost:9292',
+        'HTTP_SEC_WEBSOCKET_KEY' => 'dGhlIHNhbXBsZSBub25jZQ==',
+        'HTTP_SEC_WEBSOCKET_VERSION' => '13',
+        'rack.url_scheme' => 'http'
+      }
+    )
+
+    # Mock hijack interface expected by Rubee::WebSocket
+    io = StringIO.new
+    env['rack.hijack'] = proc {}
+    env['rack.hijack_io'] = io
+
+    # Call the WebSocket handler
+    Rubee::WebSocket.call(env)
+
+    # Expect the handshake response written to IO
+    io.rewind
+    handshake_response = io.read
+    assert_includes(handshake_response, "HTTP/1.1 101 Switching Protocols")
+    assert_includes(handshake_response, "Upgrade: websocket")
+    assert_includes(handshake_response, "Connection: Upgrade")
+  end
+end

data/lib/tests/models/account_model_test.rb

@@ -15,5 +15,22 @@ describe 'Account model' do
         _(account.user.id).must_equal(user.id)
       end
     end
+
+    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")
+            .type(String, type: "address must be string")
+        end
+        Account.validate_before_persist!
+        user = User.new(email: 'ok-test@test.com', password: '123')
+        _(raise_error { Account.create(addres: 1, user_id: user.id) }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        account = Account.create(addres: "13Th street", user_id: user.id)
+        _(account.persisted?).must_equal(true)
+        _(raise_error { account.update(addres: 1) }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        _(raise_error { Account.new(addres: 1, user_id: user.id).save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+      end
+    end
   end
 end

data/lib/tests/models/comment_model_test.rb

@@ -3,7 +3,7 @@ require_relative '../test_helper'
 describe 'Comment model' do
   describe 'owns_many :users, over: :posts' do
     before do
-      comment = Comment.new(text: 'test')
+      comment = Comment.new(text: 'test_enough')
       comment.save
       user = User.new(email: 'ok-test@test.com', password: '123')
       user.save
@@ -17,18 +17,18 @@ describe 'Comment model' do
 
     describe 'when there are associated comment records' do
       it 'returns all records' do
-        _(Comment.where(text: 'test').last.users.count).must_equal(1)
-        _(Comment.where(text: 'test').last.users.first.email).must_equal('ok-test@test.com')
+        _(Comment.where(text: 'test_enough').last.users.count).must_equal(1)
+        _(Comment.where(text: 'test_enough').last.users.first.email).must_equal('ok-test@test.com')
       end
     end
 
     describe 'sequel dataset query' do
       it 'returns all records' do
         result = Comment.dataset.join(:posts, comment_id: :id)
-          .where(comment_id: Comment.where(text: 'test').last.id)
+          .where(comment_id: Comment.where(text: 'test_enough').last.id)
           .then { |dataset| Comment.serialize(dataset) }
 
-        _(result.first.text).must_equal('test')
+        _(result.first.text).must_equal('test_enough')
       end
     end
   end
@@ -44,4 +44,141 @@ describe 'Comment model' do
       _(Comment.find(comment.id).text).must_equal('test 2')
     end
   end
+
+  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, *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" })
+      end
+    end
+    it 'is valid' do
+      include_and_validate
+      comment = Comment.new(text: 'test it as valid')
+
+      _(comment.valid?).must_equal(true)
+    end
+
+    it 'is not valid length' do
+      include_and_validate
+      comment = Comment.new(text: 'test')
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ length: "text length must be greater than 4" })
+    end
+
+    it 'is not valid type' do
+      include_and_validate
+      comment = Comment.new(text: 1)
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ type: "text field must be string" })
+    end
+
+    it 'is not valid required' do
+      include_and_validate
+      comment = Comment.new(user_id: 1)
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ required: "text filed is required" })
+    end
+
+    describe 'when first validation is optional' do
+      it 'no text should be valid' do
+        include_and_validate required: false
+
+        comment = Comment.new(user_id: 1)
+
+        _(comment.valid?).must_equal(true)
+        _(comment.errors[:test]).must_equal(nil)
+      end
+
+      it 'text is a number should be invalid' do
+        include_and_validate required: false
+        comment = Comment.new(text: 1)
+
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ type: "text field must be string" })
+      end
+
+      it 'text is short should be invalid' do
+        include_and_validate required: false
+        comment = Comment.new(text: 'test')
+
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ length: "text length must be greater than 4" })
+      end
+    end
+
+    describe 'before save must be valid' do
+      it 'does not persit if record is invalid' do
+        include_and_validate
+        Comment.before(
+          :save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s },
+          if: ->(comment) { comment&.invalid? }
+        )
+
+        comment = Comment.new(text: 'test')
+        _(raise_error { comment.save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        _(comment.persisted?).must_equal(false)
+      end
+
+      describe 'when usig method' do
+        it 'does not persit if record is invalid' do
+          include_and_validate
+          Comment.before(:save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s }, if: :invalid?)
+
+          comment = Comment.new(text: 'test')
+          _(raise_error { comment.save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+          _(comment.persisted?).must_equal(false)
+        end
+      end
+    end
+
+    describe 'before create must be invalid' do
+      it 'does not create if record is invalid' do
+        include_and_validate
+        Comment.before(:save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s }, if: :invalid?)
+
+        initial_comments_count = Comment.count
+        _(raise_error { Comment.create(text: 'te') }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        assert_equal(initial_comments_count, Comment.count)
+      end
+    end
+
+    describe 'before update must be invalid' do
+      it 'does not update if record is invalid' do
+        include_and_validate
+        Comment.around(:update, proc do |_comment, args, &update_method|
+          com = Comment.new(*args)
+          raise Rubee::Validatable::Error, com.errors.to_s if com.invalid?
+          update_method.call
+        end)
+        comment = Comment.create(text: 'test123123')
+
+        initial_comments_count = Comment.count
+        _(raise_error { comment.update(text: 'te') }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        assert_equal(initial_comments_count, Comment.count)
+      end
+
+      it 'updates the record if record is valid' do
+        include_and_validate
+        Comment.before(:update, ->(model, args) do
+          if (instance = model.class.new(*args)) && instance.invalid?
+            raise Rubee::Validatable::Error, instance.errors.to_s
+          end
+        end)
+        comment = Comment.create(text: 'test123123')
+
+        comment.update(text: 'testerter')
+        assert_equal('testerter', comment.text)
+      end
+    end
+  end
 end