ru.Bee 1.11.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c1764a41eaa86619270fbaf3077cb5fc55b8d9c6b4f4edac37c2ac7f584fb7
-  data.tar.gz: e298000985901fea481a623fd1a08759b6be441251dba2efd78d0120f1ee16f1
+  metadata.gz: c12dfae68f0595266581855939b1d4b80468ad9e4298438a0125b709e96c3fa3
+  data.tar.gz: 6fb74be8efa80754b66f603bbe41b2ba5cc9cbc26eddfcb55ee24f7073c31a74
 SHA512:
-  metadata.gz: d11f20305783059eef64fa35530e2c6861ff708db527e6ff628b8d735b833d3ec565ce7bbeb4faa9ac0fb98d7868007c8c8728804ecd07adf37a49fc7f665c20
-  data.tar.gz: 91b9a63e9bc18c4be04d6e11b097607c01733921b6ba9e33134ea0ee07780fbdf4352083e76f901f741856048732f2a55b8998451a735260aa61da05df80644c
+  metadata.gz: 463291b6a407cc39fa1b26620416da495598aa56332091e37eb5c8545e0d1f1a35bbb23586b43958bd7c83d59c66663b382b7c54c7b45a5496803365ee1e1623
+  data.tar.gz: 9bc34459746bc4a060f1fdb697f332cc35246cc104cf1a211ec9533f92a301573f0270e98582d86c64bfe72585fb233170befbc7e5719cb7d88d76a465945d3f

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/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/extensions/hookable.rb

@@ -11,7 +11,7 @@ module Rubee
           hook = Module.new do
             define_method(method) do |*args, &block|
               if conditions_met?(options[:if], options[:unless])
-                handler.respond_to?(:call) ? handler.call : send(handler)
+                handler.respond_to?(:call) ? safe_call(handler, [self, args]) : send(handler)
               end
 
               super(*args, &block)
@@ -29,7 +29,7 @@ module Rubee
               result = super(*args, &block)
 
               if conditions_met?(options[:if], options[:unless])
-                handler.respond_to?(:call) ? handler.call : send(handler)
+                handler.respond_to?(:call) ? safe_call(handler, [self, args]) : send(handler)
               end
 
               result
@@ -47,7 +47,7 @@ module Rubee
               if conditions_met?(options[:if], options[:unless])
                 if handler.respond_to?(:call)
                   result = nil
-                  handler.call do
+                  safe_call(handler, [self, args]) do
                     result = super(*args, &block)
                   end
 
@@ -67,33 +67,74 @@ module Rubee
         end
       end
 
-      def conditions_met?(if_condition = nil, unless_condition = nil)
+      def conditions_met?(if_condition = nil, unless_condition = nil, instance = nil)
         return true if if_condition.nil? && unless_condition.nil?
-
         if_condition_result =
           if if_condition.nil?
             true
           elsif if_condition.respond_to?(:call)
-            if_condition.call
-          elsif respond_to?(if_condition)
-            send(if_condition)
+            safe_call(if_condition, [instance])
+          elsif instance.respond_to?(if_condition)
+            instance.send(if_condition)
           end
         unless_condition_result =
           if unless_condition.nil?
             false
           elsif unless_condition.respond_to?(:call)
-            unless_condition.call
-          elsif respond_to?(unless_condition)
-            send(unless_condition)
+            safe_call(unless_condition, [instance])
+          elsif instance.respond_to?(unless_condition)
+            instance.send(unless_condition)
           end
 
         if_condition_result && !unless_condition_result
       end
+
+      def safe_call(handler, call_args = [], &block)
+        if handler.is_a?(Proc)
+          wrapped = safe_lambda(handler, &block)
+
+          # Forward block to the handler lambda if present
+          if block
+            wrapped.call(*call_args, &block)
+          else
+            wrapped.call(*call_args)
+          end
+        else
+          handler.call
+          block&.call
+        end
+      end
+
+      def safe_lambda(strict_lambda, &block)
+        return strict_lambda unless strict_lambda.is_a?(Proc)
+        return strict_lambda unless strict_lambda.lambda?
+        return strict_lambda unless strict_lambda.arity >= 0
+
+        proc do |*call_args|
+          lambda_arity = strict_lambda.arity
+
+          # Take only what lambda can handle, pad missing ones with nil
+          args_for_lambda = call_args.first(lambda_arity)
+          if args_for_lambda.length < lambda_arity
+            args_for_lambda += Array.new(lambda_arity - args_for_lambda.length, nil)
+          end
+
+          strict_lambda.call(*args_for_lambda, &block)
+        end
+      end
     end
 
     module InstanceMethods
       def conditions_met?(if_condition = nil, unless_condition = nil)
-        self.class.conditions_met?(if_condition, unless_condition)
+        self.class.conditions_met?(if_condition, unless_condition, self)
+      end
+
+      def safe_lambda(strict_lambda)
+        self.class.safe_lambda(strict_lambda)
+      end
+
+      def safe_call(handler, call_args = [], &block)
+        self.class.safe_call(handler, call_args, &block)
       end
     end
   end

data/lib/rubee/extensions/serializable.rb

@@ -20,7 +20,8 @@ module Rubee
 
       def to_h
         instance_variables.each_with_object({}) do |var, hash|
-          hash[var.to_s.delete('@')] = instance_variable_get(var)
+          attr_name = var.to_s.delete('@')
+          hash[attr_name] = instance_variable_get(var) unless attr_name.start_with?('__')
         end
       end
     end

data/lib/rubee/extensions/validatable.rb

@@ -0,0 +1,130 @@
+module Rubee
+  module Validatable
+    class Error < StandardError; end
+
+    class State
+      attr_accessor :errors, :valid
+
+      def initialize
+        @valid = true
+        @errors = {}
+      end
+
+      def add_error(attribute, hash)
+        @valid = false
+        @errors[attribute] ||= {}
+        @errors[attribute].merge!(hash)
+      end
+
+      def has_errors_for?(attribute)
+        @errors.key?(attribute)
+      end
+    end
+
+    class RuleChain
+      attr_reader :instance, :attribute
+
+      def initialize(instance, attribute, state)
+        @instance = instance
+        @attribute = attribute
+        @state = state
+        @optional = false
+      end
+
+      def required(error_hash)
+        value = @instance.send(@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)
+
+        value = @instance.send(@attribute)
+        return self if @optional && value.nil?
+
+        unless value.is_a?(expected_class)
+          @state.add_error(@attribute, error_hash)
+        end
+        self
+      end
+
+      def condition(handler, error_message)
+        return self if @state.has_errors_for?(@attribute)
+        value = @instance.send(@attribute)
+        return self if @optional && value.nil?
+
+        if handler.respond_to?(:call)
+          @state.add_error(@attribute, error_message) unless handler.call
+        else
+          @instance.send(handler)
+        end
+
+        self
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.prepend(Initializer)
+      base.include(InstanceMethods)
+    end
+
+    module Initializer
+      def initialize(*)
+        @__validation_state = State.new
+        super
+        run_validations
+      end
+    end
+
+    module InstanceMethods
+      def valid?
+        run_validations
+        @__validation_state.valid
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def errors
+        run_validations
+        @__validation_state.errors
+      end
+
+      def run_validations
+        @__validation_state = State.new
+        self.class&.validation_block&.call(self)
+      end
+
+      def required(attribute, options)
+        error_message = options
+        RuleChain.new(self, attribute, @__validation_state).required(error_message)
+      end
+
+      def optional(attribute)
+        RuleChain.new(self, attribute, @__validation_state).optional
+      end
+
+      def add_error(attribute, hash)
+        @__validation_state.add_error(attribute, hash)
+      end
+    end
+
+    module ClassMethods
+      attr_reader :validation_block
+
+      def validate(&block)
+        @validation_block = block
+      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/models/database_objectable.rb

@@ -8,6 +8,7 @@ module Rubee
 
       base.include(Rubee::Hookable)
       base.include(Rubee::Serializable)
+      base.include(Rubee::Validatable)
     end
 
     module ClassMethods

data/lib/rubee/models/sequel_object.rb

@@ -33,12 +33,11 @@ module Rubee
 
       else
         begin
-          created_object = self.class.create(args)
+          created_id = self.class.dataset.insert(args)
         rescue StandardError => _e
           return false
         end
-        self.id = created_object.id
-
+        self.id = created_id
       end
       true
     end
@@ -208,9 +207,9 @@ module Rubee
         if dataset.columns.include?(:created) && dataset.columns.include?(:updated)
           attrs.merge!(created: Time.now, updated: Time.now)
         end
-
-        out_id = Rubee::DBTools.with_retry { dataset.insert(**attrs) }
-        new(**attrs.merge(id: out_id))
+        instance = new(**attrs)
+        Rubee::DBTools.with_retry { instance.save }
+        instance
       end
 
       def destroy_all(cascade: false)
@@ -225,6 +224,15 @@ module Rubee
           klass.new(**klass_attributes)
         end
       end
+
+      def validate_before_persist!
+        before(:save, proc { |model| raise Rubee::Validatable::Error, model.errors.to_s }, if: :invalid?)
+        before(:update, proc do |model, args|
+          if (instance = model.class.new(*args)) && instance.invalid?
+            raise Rubee::Validatable::Error, instance.errors.to_s
+          end
+        end)
+      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