ru.Bee 1.11.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c1764a41eaa86619270fbaf3077cb5fc55b8d9c6b4f4edac37c2ac7f584fb7
-  data.tar.gz: e298000985901fea481a623fd1a08759b6be441251dba2efd78d0120f1ee16f1
+  metadata.gz: fd4247baa0c82fd81b4be82e8e63446b8b0d7934cee6243dda47ea3b350d4213
+  data.tar.gz: 1ba2c534bcebc7e898408fcf9d4e594c9535ca6fc218a5de8d51895edadc9d7f
 SHA512:
-  metadata.gz: d11f20305783059eef64fa35530e2c6861ff708db527e6ff628b8d735b833d3ec565ce7bbeb4faa9ac0fb98d7868007c8c8728804ecd07adf37a49fc7f665c20
-  data.tar.gz: 91b9a63e9bc18c4be04d6e11b097607c01733921b6ba9e33134ea0ee07780fbdf4352083e76f901f741856048732f2a55b8998451a735260aa61da05df80644c
+  metadata.gz: cff63aa019e6f5895908a7b1fd7122cefd3986c9a4c1aede556aee667cb750ca82ec95727babda0bd4a234a54b3b159fac5668e9a07de7f7974913015b7dcca5
+  data.tar.gz: b4ae2fb9d36dc6c06d87da67d479029fb7c4399f18b26dd57e10ad176a4135a81e2c7840f92393441287e29d470859ef9ec15043dad06b414cf13b680980e35c

data/lib/app/controllers/users_controller.rb

@@ -0,0 +1,57 @@
+class UsersController < Rubee::BaseController
+  attach_websocket! # Method required to turn controller to been able to handle websocket requests
+  using ChargedHash
+
+  # Endpoint to find or create user
+  def create
+    user = User.where(**params).last
+    user ||= User.create(**params)
+
+    response_with(object: user, type: :json)
+  rescue StandardError => e
+    response_with(object: { error: e.message }, type: :json)
+  end
+
+  def subscribe
+    channel = params[:channel]
+    sender_id = params[:options][:id]
+    io = params[:options][:io]
+
+    User.sub(channel, sender_id, io) do |channel, args|
+      websocket_connections.register(channel, args[:io])
+    end
+
+    response_with(object: { type: 'system', channel: params[:channel], status: :subscribed }, type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+
+  def unsubscribe
+    channel = params[:channel]
+    sender_id = params[:options][:id]
+    io = params[:options][:io]
+
+    User.unsub(channel, sender_id, io) do |channel, args|
+      websocket_connections.remove(channel, args[:io])
+    end
+
+    response_with(object: params.merge(type: 'system', status: :unsubscribed), type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+
+  def publish
+    args = {}
+    User.pub(params[:channel], message: params[:message]) do |channel|
+      user = User.find(params[:options][:id])
+      args[:message] = params[:message]
+      args[:sender] = params[:options][:id]
+      args[:sender_name] = user.email
+      websocket_connections.stream(channel, args)
+    end
+
+    response_with(object: { type: 'system', message: params[:message], status: :published }, type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+end

data/lib/app/controllers/welcome_controller.rb

@@ -1,4 +1,6 @@
 class WelcomeController < Rubee::BaseController
+  using ChargedHash
+
   def show
     response_with
   end

data/lib/app/models/user.rb

@@ -2,5 +2,7 @@
 # If you remove or modify it, make sure all changes are inlined
 # with AuthTokenMiddleware and AuthTokenable modules
 class User < Rubee::SequelObject
+  include Rubee::PubSub::Publisher
+  include Rubee::PubSub::Subscriber
   attr_accessor :id, :email, :password, :created, :updated
 end

data/lib/config/routes.rb

@@ -1,3 +1,4 @@
 Rubee::Router.draw do |router|
   router.get('/', to: 'welcome#show') # override it for your app
+  router.get('/ws', to: 'users#websocket')
 end

data/lib/inits/system.rb

@@ -0,0 +1,7 @@
+def reload
+  app_files = Dir["./#{Rubee::APP_ROOT}/**/*.rb"]
+  app_files.each { |file| load(file) }
+  puts "\e[32mReloaded..\e[0m"
+end
+
+

data/lib/rubee/autoload.rb

@@ -1,5 +1,6 @@
 module Rubee
   class Autoload
+    BLACKLIST = ['rubee.rb', 'test_helper.rb']
     class << self
       def call(black_list = [], **options)
         load_whitelisted(options[:white_list_dirs]) && return if options[:white_list_dirs]
@@ -12,7 +13,7 @@ module Rubee
         Dir.glob(File.join(Rubee::APP_ROOT, '**', '*.rb')).sort.each do |file|
           base_name = File.basename(file)
 
-          unless base_name.end_with?('_test.rb') || (black_list + ['rubee.rb', 'test_helper.rb']).include?(base_name)
+          unless base_name.end_with?('_test.rb') || (black_list + BLACKLIST).include?(base_name)
             require_relative file
           end
         end
@@ -35,6 +36,14 @@ module Rubee
         Dir[File.join(Rubee::APP_ROOT, 'inits/**', '*.rb')].each do |file|
           require_relative file unless black_list.include?("#{file}.rb")
         end
+        # rubee pub sub
+        Dir[File.join(root_directory, 'rubee/pubsub/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
+        # rubee websocket
+        Dir[File.join(root_directory, 'rubee/websocket/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
         # rubee async
         Dir[File.join(root_directory, 'rubee/async/**', '*.rb')].each do |file|
           require_relative file unless black_list.include?("#{file}.rb")

data/lib/rubee/cli/console.rb

@@ -14,14 +14,6 @@ module Rubee
             Rubee::Configuration.setup(env = :test) do |config|
               config.database_url = { url: 'sqlite://lib/tests/test.db', env: }
             end
-            # Rubee::Autoload.call
-            # Rubee::SequelObject.reconnect!
-          end
-
-          def reload
-            app_files = Dir["./#{Rubee::APP_ROOT}/**/*.rb"]
-            app_files.each { |file| load(file) }
-            color_puts('Reloaded ..', color: :green)
           end
 
           begin

data/lib/rubee/cli/project.rb

@@ -29,7 +29,7 @@ module Rubee
           FileUtils.mkdir_p(target_dir)
           # Define blacklist
           blacklist_files = %w[rubee.rb print_colors.rb version.rb config.ru test_helper.rb Gemfile.lock test.yml test.db
-                               development.db production.db]
+                               development.db production.db users_controller.rb users_controller.rb]
           blacklist_dirs = %w[rubee tests .git .github .idea node_modules db inits]
           # Copy files, excluding blacklisted ones
           copy_project_files(source_dir, target_dir, blacklist_files, blacklist_dirs)
@@ -108,6 +108,11 @@ module Rubee
             gem 'json'
             gem 'jwt'
 
+            # Websocket is required to use integrated websocket feature
+            gem 'websocket'
+            # Redis is required for pubsub and websocket
+            gem 'redis'
+
             group :development do
               gem 'rerun'
               gem 'minitest'

data/lib/rubee/cli/server.rb

@@ -7,7 +7,7 @@ module Rubee
  | |_) | |  | ||  _ \|  _|
  |  _ <| |__| || |_) | |___
  |_| \_\\____/ |____/|_____|
- Ver: %s
+ Ver: %s        ...bzzz
 LOGO
 
       class << self
@@ -23,7 +23,7 @@ LOGO
 
           port ||= '7000'
           print_logo
-          color_puts("Starting takeoff of ruBee server on port #{port}...", color: :yellow)
+          color_puts("Starting takeoff of ruBee on port: #{port}...", color: :yellow)
           command = "#{jit_prefix(jit)}rackup #{ENV['RACKUP_FILE']} -p #{port}"
           color_puts(command, color: :gray)
           exec(command)

data/lib/rubee/configuration.rb

@@ -9,6 +9,7 @@ module Rubee
         development: {
           database_url: '',
           port: 7000,
+          redis_url: '',
         },
         production: {},
         test: {},
@@ -36,6 +37,11 @@ module Rubee
         @configuraiton[args[:app].to_sym][args[:env].to_sym][:database_url] = args[:url]
       end
 
+      def redis_url=(args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:redis_url] = args[:url]
+      end
+
       def async_adapter=(args)
         args[:app] ||= :app
         @configuraiton[args[:app].to_sym][args[:env].to_sym][:async_adapter] = args[:async_adapter]
@@ -82,6 +88,16 @@ module Rubee
         @configuraiton[args[:app].to_sym][ENV['RACK_ENV']&.to_sym || :development][:react] || {}
       end
 
+      def pubsub_container=(args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:pubsub_container] = args[:pubsub_container]
+      end
+
+      def pubsub_container(**args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][ENV['RACK_ENV']&.to_sym || :development][:pubsub_container] || ::Rubee::PubSub::Redis.instance
+      end
+
       def method_missing(method_name, *args)
         return unless method_name.to_s.start_with?('get_')
 

data/lib/rubee/controllers/base_controller.rb

@@ -51,6 +51,8 @@ module Rubee
         [status, headers.merge('content-type' => 'application/javascript'), [object]]
       in :css
         [status, headers.merge('content-type' => 'text/css'), [object]]
+      in :websocket
+        object # hash is expected
       in :file
         [
           status,
@@ -101,23 +103,38 @@ module Rubee
       erb_template.result(binding)
     end
 
-    def params
-      inputs = @request.env['rack.input'].read
-      body = begin
-        JSON.parse(@request.body.read.strip)
-             rescue StandardError
-               {}
-      end
-      begin
-        body.merge!(URI.decode_www_form(inputs).to_h.transform_keys(&:to_sym))
-      rescue StandardError
-        nil
+    def websocket
+      action = @params[:action]
+      unless ['subscribe', 'unsubscribe', 'publish'].include?(action)
+        response_with(object: "Unknown action: #{action}", type: :websocket)
       end
+
+      public_send(action)
+    end
+
+    def params
+      # Read raw input safely (only once)
+      raw_input = @request.body.read.to_s.strip
+      @request.body.rewind if @request.body.respond_to?(:rewind)
+
+      # Try parsing JSON first, fall back to form-encoded data
+      parsed_input =
+        begin
+          JSON.parse(raw_input)
+        rescue StandardError
+          begin
+            URI.decode_www_form(raw_input).to_h.transform_keys(&:to_sym)
+          rescue
+            {}
+          end
+        end
+
+      # Combine route params, request params, and body
       @params ||= extract_params(@request.path, @route[:path])
-        .merge(body)
+        .merge(parsed_input)
         .merge(@request.params)
         .transform_keys(&:to_sym)
-        .reject { |k, _v| [:_method].include?(k.downcase.to_sym) }
+        .reject { |k, _v| k.to_sym == :_method }
     end
 
     def headers
@@ -125,6 +142,10 @@ module Rubee
         .collect { |key, val| [key.sub(/^HTTP_/, ''), val] }
     end
 
+    def websocket_connections
+      Rubee::WebSocketConnections.instance
+    end
+
     def extract_params(path, pattern)
       regex_pattern = pattern.gsub(/\{(\w+)\}/, '(?<\1>[^/]+)')
       regex = Regexp.new("^#{regex_pattern}$")
@@ -135,5 +156,26 @@ module Rubee
 
       {}
     end
+
+    def handle_websocket
+      res = Rubee::WebSocket.call(@request.env) do |payload|
+        @params = payload
+        yield
+      end
+      res
+    end
+
+    class << self
+      def attach_websocket!
+        around(
+          :websocket, :handle_websocket,
+          if: -> do
+            redis_available = Rubee::Features.redis_available?
+            Rubee::Logger.error(message: 'Please make sure redis server is running') unless redis_available
+            redis_available
+          end
+        )
+      end
+    end
   end
 end

data/lib/rubee/features.rb

@@ -0,0 +1,22 @@
+module Rubee
+  class Features
+    class << self
+      def redis_available?
+        require "redis"
+        redis_url = Rubee::Configuration.get_redis_url
+        redis = redis_url&.empty? ? Redis.new : Redis.new(url: redis_url)
+        redis.ping
+        true
+      rescue LoadError, Redis::CannotConnectError
+        false
+      end
+
+      def websocket_available?
+        require "websocket"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/rubee/pubsub/container.rb

@@ -0,0 +1,44 @@
+module Rubee
+  module PubSub
+    class Container
+      def pub(*)
+        raise NotImplementedError
+      end
+
+      # Container Implementation of sub
+      def sub(*)
+        raise NotImplementedError
+      end
+
+      # Container Implementation of unsub
+      def unsub(*)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def retrieve_klasses(iterable)
+        iterable.map { |clazz| turn_to_class(clazz) }
+      end
+
+      def turn_to_class(string)
+        string.split('::').inject(Object) { |o, c| o.const_get(c) }
+      end
+
+      def fan_out(clazzes, args, &block)
+        mutex = Mutex.new
+
+        mutex.synchronize do
+          clazzes.each do |clazz|
+            if block
+              block.call(clazz.name, args)
+            else
+              clazz.on_pub(clazz.name, args)
+            end
+          end
+          true
+        end
+      end
+    end
+  end
+end

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.0.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/user_model_test.rb

@@ -345,4 +345,98 @@ zip: '555555')
       end
     end
   end
+
+  describe 'pubsub' do
+    describe 'when Rubee::PubSub::Subscriber is included' do
+      before { User.include(Rubee::PubSub::Subscriber) }
+
+      it 'reveals sub method' do
+        _(User.respond_to?(:sub)).must_equal(true)
+      end
+
+      it 'reveals unsub method' do
+        _(User.respond_to?(:unsub)).must_equal(true)
+      end
+    end
+
+    describe 'when Rubee::PubSub::Publisher is included' do
+      before { User.include(Rubee::PubSub::Publisher) }
+
+      it 'reveals pub method' do
+        _(User.respond_to?(:pub)).must_equal(true)
+      end
+    end
+
+    describe '.sub' do
+      before do
+        User.include(Rubee::PubSub::Subscriber)
+        User.include(Rubee::PubSub::Publisher)
+      end
+
+      user = User.create(email: 'ok-test@test.com', password: '123')
+
+      describe 'when sub with channel and args' do
+        it 'returns true' do
+          _(User.sub("ok", [user.id.to_s])).must_equal(true)
+
+          User.unsub("ok", [user.id.to_s])
+          user.destroy
+        end
+      end
+    end
+
+    describe '.unsub' do
+      before do
+        User.include(Rubee::PubSub::Subscriber)
+        User.include(Rubee::PubSub::Publisher)
+      end
+
+      describe 'when unsub with channel and args' do
+        it 'returns true' do
+          _(User.unsub("ok", ["123456"])).must_equal(true)
+        end
+      end
+    end
+
+    describe 'pub flow' do
+      describe 'when pub with channel and args' do
+        after do
+          User.destroy_all(cascade: true)
+        end
+
+        it 'fan out ouput' do
+          User.include(Rubee::PubSub::Subscriber)
+          User.include(Rubee::PubSub::Publisher)
+
+          user_one = User.create(email: 'ok-test1@test.com', password: '123')
+          user_two = User.create(email: 'ok-test@2test.com', password: '123')
+          user_three = User.create(email: 'ok-test3@test.com', password: '123')
+
+          User.singleton_class.define_method(:on_pub) do |channel, *args, **options|
+            id = args.first
+            user = User.find(id)
+            if user
+              user.update(password: '321')
+            else
+              raise "User with id=#{id} not found"
+            end
+          end
+
+          User.sub("ok", [user_one.id.to_s])
+          User.sub("ok", [user_two.id.to_s])
+          User.sub("ok", [user_three.id.to_s])
+
+          User.pub("ok", message: "hello")
+
+          User.unsub("ok", [user_one.id.to_s])
+          User.unsub("ok", [user_two.id.to_s])
+          User.unsub("ok", [user_three.id.to_s])
+
+          _(user_one.reload.password).must_equal('321')
+          _(user_two.reload.password).must_equal('321')
+          _(user_three.reload.password).must_equal('321')
+        end
+      end
+    end
+  end
 end

data/readme.md

@@ -8,7 +8,7 @@
 
 # <img src="lib/images/rubee.svg" alt="RUBEE" height="40"> ... RUBEE
 
-Rubee is a Ruby-based web framework designed to streamline the development of modular monolith web applications. \
+RUBEE is a Ruby-based web framework designed to streamline the development of modular monolith web applications. \
 Under the hood, it leverages the power of Ruby and Rack backed by Puma, offering a clean, efficient, and flexible architecture. \
 It offers a structured approach to building scalable, maintainable, and React-ready projects, \
 making it an ideal choice for developers seeking a balance between monolithic simplicity and modular flexibility.
@@ -19,7 +19,7 @@ Want to get a quick API server up and runing? You can do it for real quick!
 
 ## Production ready
 
-Take a look on the rubee demo site with all documentation stored in there: https://rubee.dedyn.io/
+Take a look on the RUBEE demo site with all documentation stored in there: https://rubee.dedyn.io/
 Want to explore how it built? https://github.com/nucleom42/rubee-site
 
 ## Stress tested
@@ -41,9 +41,9 @@ Transfer/sec:    140.07KB
 - Average latency: ~305 ms
 - Total requests handled: 9,721
 - Hardware: Raspberry Pi 5(8 Gb) (single board computer)
-- Server: Rubee app hosted via Nginx + HTTPS
+- Server: RUBEE app hosted via Nginx + HTTPS
 
-This demonstrates RUBEE’s efficient architecture and suitability for lightweight deployments — even on low-power hardware.
+This demonstrate RUBEE’s efficient architecture and suitability for lightweight deployments — even on low-power hardware.
 
 ## Comparison
 Here below is a **short web frameworks comparison** built with Ruby, so you can evaluate your choice with RUBEE.
@@ -51,7 +51,7 @@ Here below is a **short web frameworks comparison** built with Ruby, so you can
 **Disclaimer:**
 The comparison is based on a very generic and subjective information open in the Internet and is not a real benchmark. The comparison is aimed to give you a general idea of the differences between the frameworks and Rubee and not to compare the frameworks directly.
 
-| Feature / Framework | **Rubee** | Rails | Sinatra | Hanami | Padrino | Grape |
+| Feature / Framework | **RUBEE** | Rails | Sinatra | Hanami | Padrino | Grape |
 |---------------------|-----------|-------|---------|--------|---------|-------|
 | **React readiness** | Built-in React integration (route generator can scaffold React components that fetch data via controllers) | React via webpacker/importmap, but indirect | No direct React support | Can integrate React | Can integrate via JS pipelines | API-focused, no React support |
 | **Routing style**   | Explicit, file-based routes with clear JSON/HTML handling | DSL, routes often implicit inside controllers | Explicit DSL, inline in code | Declarative DSL | Rails-like DSL | API-oriented DSL |
@@ -74,6 +74,7 @@ The comparison is based on a very generic and subjective information open in the
 - [Views](#views)
 - [Hooks](#hooks)
 - [JWT based authentification](#jwt-based-authentification)
+- [OAuth2 based authentification](#oauth-authentification)
 - [Rubee commands](#rubee-commands)
 - [Generate commands](#generate-commands)
 - [Migration commands](#migration-commands)
@@ -105,9 +106,9 @@ Databases – Supports SQLite3, PostgreSQL, MySQL, and more via the Sequel gem.
 <br>
 Views – JSON, ERB, and plain HTML out of the box.
 <br>
-React Ready – React is supported as a first-class Rubee view engine.
+React Ready – React is supported as a first-class RUBEE view engine.
 <br>
-Bundlable – Charge your Rubee app with any gem you need. Update effortlessly via Bundler.
+Bundlable – Charge your RUBEE app with any gem you need. Update effortlessly via Bundler.
 <br>
 ORM-agnostic – Models are native ORM objects, but you can use them as blueprints for any data source.
 <br>
@@ -150,7 +151,7 @@ Make sure:
 bundle install
 ```
 
-4. Run RUBEE server. Default port is 7000
+4. Run RUBER server. Default port is 7000
 ```bash
 rubee start # or rubee start_dev for development
 
@@ -354,7 +355,7 @@ irb(main):023> User.all
 => []
 ```
 
-Use complex queries chains and when ready serialize it back to Rubee object.
+Use complex queries chains and when ready serialize it back to RUBEE object.
 ```Ruby
 # user model
 class User < Rubee::SequelObject
@@ -391,7 +392,7 @@ irb(main):009>  .where(comment_id: Comment.where(text: "test").last.id)
 irb(main):010>  .then { |dataset| Comment.serialize(dataset) }
 => [#<Comment:0x0000000121889998 @id=30, @text="test", @user_id=702, @created=2025-09-28 22:03:07.011332 -0400, @updated=2025-09-28 22:03:07.011332 -0400>]
 ```
-This is recommended when you want to run one query and serialize it back to Rubee object only once.
+This is recommended when you want to run one query and serialize it back to RUBEE object only once.
 So it may safe some resources.
 
 [Back to content](#content)
@@ -407,7 +408,7 @@ If you feel comfortable you can play with retry configuration parameters:
   config.db_busy_timeout = { env:, value: 1000 } # this is busy timeout in ms, before raising bussy error
 ```
 
-For Rubee model class persist methods create and update retry will be added automatically. However, \
+For RUBEE model class persist methods create and update retry will be added automatically. However, \
 if you want to do it with Sequel dataset you need to do it yourself:
 
 ```ruby
@@ -416,7 +417,7 @@ if you want to do it with Sequel dataset you need to do it yourself:
 [Back to content](#content)
 
 ## Routing
-Rubee uses explicit routes. In the routes.rb yout can define routes for any of the main HTTP methods. \
+RUBEE uses explicit routes. In the routes.rb yout can define routes for any of the main HTTP methods. \
 You can also add any matched parameter denoted by a pair of `{ }` in the path of the route. \
 Eg. `/path/to/{a_key}/somewhere`
 
@@ -442,7 +443,7 @@ route.{http_method} {path}, to: "{controller}#{action}",
 ```
 
 ### Defining Model attributes in routes
-One of Rubee's unique traits is where we can define our models for generation. \
+One of RUBEE's unique traits is where we can define our models for generation. \
 You've seen above one possible way you can set up.
 
 ```ruby
@@ -577,7 +578,7 @@ Main philosophy of attach functinality is to keep the main project clean and eas
 share data with the main app. So where to define a border between the main app and subprojects is up to developer.
 Howerver by attching new subproject you will get a new folder and files configured and namespaced respectively.
 
-So if you need to extend your main app with a separate project, you can do it easily in RUBEE.
+So if you need to extend your main app with a separate project, you can do it easily in ruBEE.
 1. Attach new subrpoject
 
 ```bash
@@ -874,7 +875,7 @@ Feel free to customize it in the /db/create_users.rb file before running migrati
 Then in the controller you can include the AuthTokenable module and use its methods:
 ```ruby
 class UsersController < Rubee::BaseController
-  include AuthTokenable
+  include Rubee::AuthTokenable
   # List methods you want to restrict
   auth_methods :index # unless the user is authentificated it will return unauthentificated
 
@@ -907,10 +908,103 @@ class UsersController < Rubee::BaseController
   end
 end
 ```
+## OAuth authentification
+If you want to plug in the OAuth 2.0 authentication, you can use the following code using OAuth2 gem:
+First thing you need to do is to add the gem to your Gemfile
+```bash
+gem 'oauth2'
+```
+Then use down below code as an example and add yours to your controller
+```ruby
+class UsersController < Rubee::BaseController
+  include Rubee::AuthTokenable
+
+  REDIRECT_URI = 'https://mysite.com/users/outh_callback'
+  CLIENT_ID = ENV['GOOGLE_CLIENT_ID']
+  CLIENT_SECRET = ENV['GOOGLE_CLIENT_SECRET']
+
+  # GET /login (login form page)
+  def edit
+    response_with
+  end
+
+  # POST /users/login (login logic)
+  def login
+    Rubee::Logger.info(message: "Login attempt for user #{params[:email]}")
+    if authentificate! # AuthTokenable method that init @token_header
+      Rubee::Logger.info(message: "Successful login for user #{@authentificated_user.email}")
+      response_with(type: :redirect, to: "/sections", headers: @token_header)
+    else
+      @error = "Wrong email or password"
+      response_with(render_view: "users_edit")
+    end
+  end
+
+  # GET /users/outh_login
+  def outh_login
+    response_with(
+      type: :redirect,
+      to: auth_client.auth_code.authorize_url(
+        redirect_uri: REDIRECT_URI,
+        scope: 'email profile openid'
+      )
+    )
+  end
+
+  # GET /users/outh_callback
+  def outh_callback
+    code = params[:code]
+    token = auth_client.auth_code.get_token(code, redirect_uri: REDIRECT_URI)
+    user_info = JSON.parse(token.get('https://www.googleapis.com/oauth2/v1/userinfo?alt=json').body)
+    Rubee::Logger.debug(object: user_info, method: "outh_callback", class: "UsersController")
+
+    user = User.where(email: user_info['email'])&.last
+    unless user
+      raise "User with email #{user_info['email']} not found"
+    end
+
+    params[:email] = user_info['email']
+    params[:password] = user.password
+
+    if authentificate! # AuthTokenable method that init @token_header
+      Rubee::Logger.info(message: "Successful Outh login for user #{@authentificated_user.email}")
+      response_with(type: :redirect, to: "/sections", headers: @token_header)
+    else
+      @error = "Something went wrong"
+      response_with(render_view: "users_edit")
+    end
+  rescue OAuth2::Error => e
+    @error = "OAuth login failed"
+    response_with(render_view: "users_edit")
+  rescue StandardError => e
+    @error = "Something went wrong"
+    response_with(render_view: "users_edit")
+  end
+
+  # POST /users/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: :redirect, to: "/login", headers: @zeroed_token_header)
+  end
+
+  private
+
+  def auth_client
+    @client ||= OAuth2::Client.new(
+      CLIENT_ID,
+      CLIENT_SECRET,
+      site: 'https://accounts.google.com',
+      authorize_url: '/o/oauth2/auth',
+      token_url: 'https://oauth2.googleapis.com/token'
+    )
+  end
+end
+```
 
 [Back to content](#content)
 
-## Rubee commands
+## RUBEE commands
 ```bash
 rubee start # start the server
 rubee start_dev # start the server in dev mode, which restart server on changes
@@ -932,7 +1026,7 @@ rubee db run:create_apples # where create_apples is the name of the migration fi
 rubee db structure # generate migration file for the database structure
 ```
 
-## Rubee console
+## RUBEE console
 ```bash
 rubee console # start the console
 # you can reload the console by typing reload, so it will pick up latest changes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ru.Bee
 version: !ruby/object:Gem::Version
-  version: 1.11.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Oleg Saltykov
@@ -41,6 +41,7 @@ files:
 - bin/rubee
 - bin/test.db
 - lib/Dockerfile
+- lib/app/controllers/users_controller.rb
 - lib/app/controllers/welcome_controller.rb
 - lib/app/models/user.rb
 - lib/app/views/App.tsx
@@ -66,6 +67,7 @@ files:
 - lib/inits/charged_hash.rb
 - lib/inits/charged_string.rb
 - lib/inits/print_colors.rb
+- lib/inits/system.rb
 - lib/js/app.js
 - lib/js/app.js.map
 - lib/js/bundle.js
@@ -254,18 +256,27 @@ files:
 - lib/rubee/controllers/middlewares/auth_token_middleware.rb
 - lib/rubee/extensions/hookable.rb
 - lib/rubee/extensions/serializable.rb
+- lib/rubee/features.rb
 - lib/rubee/generator.rb
 - lib/rubee/logger.rb
 - lib/rubee/models/database_objectable.rb
 - lib/rubee/models/db_tools.rb
 - lib/rubee/models/sequel_object.rb
+- lib/rubee/pubsub/container.rb
+- lib/rubee/pubsub/publisher.rb
+- lib/rubee/pubsub/redis.rb
+- lib/rubee/pubsub/subscriber.rb
+- lib/rubee/pubsub/test_one.rb
 - lib/rubee/router.rb
+- lib/rubee/websocket/websocket.rb
+- lib/rubee/websocket/websocket_connections.rb
 - lib/tests/async/thread_async_test.rb
 - lib/tests/cli/attach_test.rb
 - lib/tests/controllers/auth_tokenable_test.rb
 - lib/tests/controllers/base_controller_test.rb
 - lib/tests/controllers/hookable_test.rb
 - lib/tests/controllers/rubeeapp_test.rb
+- lib/tests/controllers/users_controller_test.rb
 - lib/tests/example_models/account.rb
 - lib/tests/example_models/address.rb
 - lib/tests/example_models/comment.rb
@@ -300,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Fast and lightweight Ruby application server designed for minimalism and
   flexibility