ru.Bee 1.5.4 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb5cbb674c5bfbfd6bc0d577039a3ca53fb46f013b62e5e004ef4a9f2c500514
-  data.tar.gz: abd0447b9655b22a85fed893e74c524f97d2d0ecf757eeb3b1730c799ae0e3d4
+  metadata.gz: 400c70fb533f9935fb838941de26bd78875f64a62e1d86bed2a817904ca63a7d
+  data.tar.gz: 23fe0b3b9334a0c34b5fb671806a58dfa0e7f2aeb48f487fe988eec2354bcdc0
 SHA512:
-  metadata.gz: 53195541a6b75bb6bf98ff8e8d54cc6d9fea4c5a8d5232f79c0e5cbe085b0afa48e06e17e717a314fb44fbac92c6ae375e18cbc8f4cc2aba8152fec568c59545
-  data.tar.gz: 193de59c021b3ca2265e816f6c80fc54a0b714c37f02b59194a4dafb6d01b1bc2edf9180d0c932d8a9b2d4dc23954b052926874a691f0a1aaedfbc5870906c34
+  metadata.gz: c2d8526cbce129652658679cc1edf861e33f8479b2c8e9e3849c640fc527dd6116dfe314fc7f1fa79f8d188655a1463320a701dc46f13166b870733ef1d3bc35
+  data.tar.gz: 386b45c69e6513448adf1ab10f6b9caf4cfc15d588b26f920dc6518489cbf6c9abc5f6404b007d65b6e9aaf71cb806cac391b3023156113e8f3e5958f3430868

data/bin/rubee

@@ -89,7 +89,7 @@ elsif command == 'project'
   # 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]
-  blacklist_dirs = %w[rubee tests .git .github .idea node_modules db]
+  blacklist_dirs = %w[rubee tests .git .github .idea node_modules db inits]
 
   # Copy files, excluding blacklisted ones
   Dir.glob("#{source_dir}/**/*", File::FNM_DOTMATCH).each do |file|
@@ -112,13 +112,18 @@ elsif command == 'project'
 
   # create tests dir and copy test_helper.rb and user_model_test.rb
   FileUtils.mkdir_p("#{target_dir}/tests")
-  FileUtils.cp("#{source_dir}/tests/user_model_test.rb", "#{target_dir}/tests/user_model_test.rb")
+  FileUtils.mkdir_p("#{target_dir}/tests/models")
+  FileUtils.mkdir_p("#{target_dir}/tests/controllers")
+  FileUtils.cp("#{source_dir}/tests/models/user_model_test.rb", "#{target_dir}/tests/models/user_model_test.rb")
 
   # create db dir
   FileUtils.mkdir_p("#{target_dir}/db")
   FileUtils.cp("#{source_dir}/db/structure.rb", "#{target_dir}/db/structure.rb")
   FileUtils.cp("#{source_dir}/db/create_users.rb", "#{target_dir}/db/create_users.rb")
 
+  # create inits dir
+  FileUtils.mkdir_p("#{target_dir}/inits")
+
   # create a gemfile context
   gemfile = <<~GEMFILE
     source 'https://rubygems.org'

data/lib/config/base_configuration.rb

@@ -1,23 +1,41 @@
 Rubee::Configuration.setup(env = :development) do |config|
   config.database_url = { url: 'sqlite://db/development.db', env: }
-  config.thread_pool_limit = { env:, value: 5 }
 
-  # Uncomment, if you want to use react
-  # config.react = { on: true, env: }
+  ## configure hybrid thread pooling params
+  # config.threads_limit = { env:, value: 4 }
+  # config.fibers_limit = { env:, value: 4 }
+
+  # Flag on react as a view
+  # config.react = { on: true, env: } # required if you want to use react
+
+  ## configure logger
+  # config.logger = { logger: MyLogger, env: }
 end
 
 Rubee::Configuration.setup(env = :test) do |config|
   config.database_url = { url: 'sqlite://db/test.db', env: }
-  config.thread_pool_limit = { env:, value: 5 }
 
-  # Uncomment, if you want to use react
+  ## configure hybrid thread pooling params
+  # config.threads_limit = { env:, value: 4 }
+  # config.fibers_limit = { env:, value: 4 }
+
+  ## Flag on react as a view
   # config.react = { on: true, env: } # required if you want to use react
+
+  ## configure logger
+  # config.logger = { logger: MyLogger, env: }
 end
 
 Rubee::Configuration.setup(env = :production) do |config|
   config.database_url = { url: 'sqlite://db/production.db', env: }
-  config.thread_pool_limit = { env:, value: 5 }
 
-  # Uncomment,if you want to use react
+  ## configure hybrid thread pooling params
+  # config.threads_limit = { env:, value: 4 }
+  # config.fibers_limit = { env:, value: 4 }
+
+  ## Flag on react as a view
   # config.react = { on: true, env: } # required if you want to use react
+
+  ## configure logger
+  # config.logger = { logger: MyLogger, env: }
 end

data/lib/db/create_addresses.rb

@@ -0,0 +1,17 @@
+class CreateAddresses
+  def call
+    return if Rubee::SequelObject::DB.tables.include?(:addresses)
+
+    Rubee::SequelObject::DB.create_table(:addresses) do
+      primary_key(:id)
+      String(:city)
+      String(:state)
+      String(:zip)
+      String(:street)
+      String(:apt)
+      foreign_key(:user_id, :users)
+    end
+
+    # Address.create(street: '13th Ave', city: 'NY', state: 'NY', zip: '55555', user_id: User.all.first.id)
+  end
+end

data/lib/package.json

@@ -2,7 +2,7 @@
   "scripts": {
     "build": "node esbuild.config.js",
     "watch": "node esbuild.config.js --watch",
-    "prepare": "npm install react react-dom react-router-dom esbuild-plugin-inline-css"
+    "prepare": "npm install esbuild react react-dom react-router-dom esbuild-plugin-inline-css"
   },
   "dependencies": {
     "react": "^18.3.1",

data/lib/rubee/async/fiber_queue.rb

@@ -0,0 +1,27 @@
+class FiberQueue
+  def initialize
+    @fibers = []
+  end
+
+  def add(task, args = {})
+    fiber = Fiber.new do
+      task.new.perform(**args)
+    rescue => e
+      puts "Fiber Error: #{e.message}"
+    end
+    @fibers << fiber
+  end
+
+  def fan_out!
+    while @fibers.any?(&:alive?)
+      @fibers.each do |fiber|
+        fiber.resume if fiber.alive?
+      end
+    end
+  end
+
+  def done?
+    @fibers.none?(&:alive?)
+  end
+end
+

data/lib/rubee/async/thread_pool.rb

@@ -3,58 +3,56 @@ require 'singleton'
 module Rubee
   class ThreadPool
     include Singleton
-    THREAD_POOL_LIMIT = Rubee::Configuration.get_thread_pool_limit || 10 # adjust as needed
+    THREADS_LIMIT = Rubee::Configuration.get_threads_limit || 4
+    FIBERS_LIMIT = Rubee::Configuration.get_fibers_limit || 4
 
     def initialize
-      @queue = Queue.new
-      @workers = []
+      @tasks = Queue.new
+      @threads = []
       @running = true
-      spawn_workers
-    end
+      @mutex = Mutex.new
 
-    def enqueue(task, args)
-      @queue << { task: task, args: args }
-      run_next
+      spawn_workers
     end
 
-    def bulk_enqueue(tasks)
-      @queue << tasks
-      run_next
+    def enqueue(task, args = {})
+      @tasks << [task, args]
     end
 
     def shutdown
       @running = false
-      @queue.clear
+      THREADS_LIMIT.times { @tasks << :shutdown } # Unblock threads
+      @threads.each(&:join)
     end
 
     private
 
-    def run_next
-      @workers.each do |fiber|
-        fiber.resume if fiber.alive? && !@queue.empty?
-      end
-    end
-
     def spawn_workers
-      THREAD_POOL_LIMIT.times do
-        fiber = Fiber.new do
-          loop do
-            Fiber.yield unless @running
-            job = @queue.shift
-            break unless job
-
-            task = job[:task]
-            args = job[:args]
-
-            begin
-              task.new.perform(**args)
-            rescue => e
-              puts "ThreadPool Error: #{e.message}"
+      THREADS_LIMIT.times do
+        @threads << Thread.new do
+          while @running && (task = @tasks.pop)
+            break if task == :shutdown
+
+            fiber_queue = FiberQueue.new
+            fiber_queue.add(*task)
+
+            # pull more to fill the chunk
+            FIBERS_LIMIT.times do
+              next_task = begin
+                            @mutex.synchronize { @tasks.pop(true) }
+                          rescue
+                            nil
+                          end
+              fiber_queue.add(*next_task) if next_task
+            end
+
+            until fiber_queue.done?
+              fiber_queue.fan_out!
             end
+
+            sleep(0.05)
           end
         end
-
-        @workers << fiber
       end
     end
   end

data/lib/rubee/autoload.rb

@@ -0,0 +1,73 @@
+module Rubee
+  class Autoload
+    class << self
+      def call(black_list = [])
+        # autoload all rbs
+        root_directory = File.expand_path(File.join(__dir__, '..',))
+        priority_order_require(root_directory, black_list)
+        # ensure sequel object is connected
+        Rubee::SequelObject.reconnect!
+
+        Dir.glob(File.join(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)
+            require_relative file
+          end
+        end
+      end
+
+      def priority_order_require(root_directory, black_list)
+        # rubee inits
+        Dir[File.join(root_directory, 'inits/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
+        # app inits
+        Dir[File.join(APP_ROOT, 'inits/**', '*.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")
+        end
+        # app config and routes
+        unless black_list.include?('base_configuration.rb')
+          require_relative File.join(APP_ROOT, LIB,
+                                     'config/base_configuration')
+        end
+        # This is necessary prerequisitedb init step
+        if !defined?(Rubee::SequelObject::DB) && (PROJECT_NAME == 'rubee')
+          Rubee::Configuration.setup(env = :test) do |config|
+            config.database_url = { url: 'sqlite://lib/tests/test.db', env: }
+          end
+        end
+
+        require_relative File.join(APP_ROOT, LIB, 'config/routes') unless black_list.include?('routes.rb')
+        # rubee extensions
+        Dir[File.join(root_directory, 'rubee/extensions/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
+        # rubee controllers
+        Dir[File.join(root_directory, 'rubee/controllers/middlewares/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
+        Dir[File.join(root_directory, 'rubee/controllers/extensions/**', '*.rb')].each do |file|
+          require_relative file unless black_list.include?("#{file}.rb")
+        end
+        unless black_list.include?('base_controller.rb')
+          require_relative File.join(root_directory,
+                                     'rubee/controllers/base_controller')
+        end
+        # rubee models
+        unless black_list.include?('database_objectable.rb')
+          require_relative File.join(root_directory,
+                                     'rubee/models/database_objectable')
+        end
+        return if black_list.include?('sequel_object.rb')
+
+        require_relative File.join(root_directory,
+                                   'rubee/models/sequel_object')
+      end
+    end
+  end
+end

data/lib/rubee/configuration.rb

@@ -0,0 +1,60 @@
+module Rubee
+  class Configuration
+    include Singleton
+
+    @configuraiton = {
+      development: {
+        database_url: '',
+        port: 7000,
+      },
+      production: {},
+      test: {},
+    }
+
+    class << self
+      def setup(_env)
+        yield(self)
+      end
+
+      def database_url=(args)
+        @configuraiton[args[:env].to_sym][:database_url] = args[:url]
+      end
+
+      def async_adapter=(args)
+        @configuraiton[args[:env].to_sym][:async_adapter] = args[:async_adapter]
+      end
+
+      def threads_limit=(args)
+        @configuraiton[args[:env].to_sym][:thread_pool_limit] = args[:value]
+      end
+
+      def fibers_limit=(args)
+        @configuraiton[args[:env].to_sym][:fiber_pool_limit] = args[:value]
+      end
+
+      def logger=(args)
+        @configuraiton[args[:env].to_sym][:logger] = args[:logger]
+      end
+
+
+      def react=(args)
+        @configuraiton[args[:env].to_sym][:react] ||= { on: false }
+        @configuraiton[args[:env].to_sym][:react].merge!(on: args[:on])
+      end
+
+      def react
+        @configuraiton[ENV['RACK_ENV']&.to_sym || :development][:react] || {}
+      end
+
+      def method_missing(method_name, *_args)
+        return unless method_name.to_s.start_with?('get_')
+
+        @configuraiton[ENV['RACK_ENV']&.to_sym || :development]&.[](method_name.to_s.delete_prefix('get_').to_sym)
+      end
+
+      def envs
+        @configuraiton.keys
+      end
+    end
+  end
+end

data/lib/rubee/extensions/hookable.rb

@@ -39,9 +39,16 @@ module Rubee
           define_method(method) do |*args, &block|
             if conditions_met?(options[:if], options[:unless])
               if handler.respond_to?(:call)
-                handler.call { super(*args, &block) }
+                result = nil
+                handler.call do
+                  result = super(*args, &block)
+                end
+
+                result
               else
-                send(handler) { super(*args, &block) }
+                return send(handler) do
+                  super(*args, &block)
+                end
               end
             else
               super(*args, &block)

data/lib/rubee/generator.rb

@@ -0,0 +1,152 @@
+module Rubee
+  class Generator
+    require_relative '../inits/charged_string'
+    using ChargedString
+    def initialize(model_name, model_attributes, controller_name, action_name, **options)
+      @model_name = model_name&.downcase
+      @model_attributes = model_attributes || []
+      @base_name = controller_name.to_s.gsub('Controller', '').downcase.to_s
+      color_puts("base_name: #{@base_name}", color: :gray)
+      @plural_name = @base_name.plural? ? @base_name : @base_name.pluralize
+      @action_name = action_name
+      @react = options[:react] || {}
+    end
+
+    def call
+      generate_model if @model_name
+      generate_db_file if @model_name
+      generate_controller if @base_name && @action_name
+      generate_view if @base_name
+    end
+
+    private
+
+    def generate_model
+      model_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "app/models/#{@model_name}.rb")
+      if File.exist?(model_file)
+        puts "Model #{@model_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~RUBY
+        class #{@model_name.capitalize} < Rubee::SequelObject
+          #{'attr_accessor ' + @model_attributes.map { |hash| ":#{hash[:name]}" }.join(', ') unless @model_attributes.empty?}
+        end
+      RUBY
+
+      File.open(model_file, 'w') { |file| file.write(content) }
+      color_puts("Model #{@model_name} created", color: :green)
+    end
+
+    def generate_controller
+      controller_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "app/controllers/#{@base_name}_controller.rb")
+      if File.exist?(controller_file)
+        puts "Controller #{@base_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~RUBY
+        class #{@base_name.capitalize}Controller < Rubee::BaseController
+          def #{@action_name}
+            response_with
+          end
+        end
+      RUBY
+
+      File.open(controller_file, 'w') { |file| file.write(content) }
+      color_puts("Controller #{@base_name} created", color: :green)
+    end
+
+    def generate_view
+      if @react[:view_name]
+        view_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "app/views/#{@react[:view_name]}")
+        content = <<~JS
+          import React, { useEffect, useState } from "react";
+          // 1. Add your logic that fetches data
+          // 2. Do not forget to add respective react route
+          export function #{@react[:view_name].gsub(/\.(.*)+$/, '').capitalize}() {
+
+            return (
+              <div>
+                <h2>#{@react[:view_name]} view</h2>
+              </div>
+            );
+          }
+        JS
+      else
+        view_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "app/views/#{@plural_name}_#{@action_name}.erb")
+        content = <<~ERB
+          <h1>#{@plural_name}_#{@action_name} View</h1>
+        ERB
+      end
+
+      name = @react[:view_name] || "#{@plural_name}_#{@action_name}"
+
+      if File.exist?(view_file)
+        puts "View #{name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      File.open(view_file, 'w') { |file| file.write(content) }
+      color_puts("View #{name} created", color: :green)
+    end
+
+    def generate_db_file
+      db_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "db/create_#{@plural_name}.rb")
+      if File.exist?(db_file)
+        puts "DB file for #{@plural_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~RUBY
+        class Create#{@plural_name.capitalize}
+          def call
+            return if Rubee::SequelObject::DB.tables.include?(:#{@plural_name})
+
+            Rubee::SequelObject::DB.create_table(:#{@plural_name}) do
+              #{@model_attributes.map { |attribute| generate_sequel_schema(attribute) }.join("\n\t\t\t")}
+            end
+          end
+        end
+      RUBY
+
+      File.open(db_file, 'w') { |file| file.write(content) }
+      color_puts("DB file for #{@plural_name} created", color: :green)
+    end
+
+    def generate_sequel_schema(attribute)
+      type = attribute[:type]
+      name = if attribute[:name].is_a?(Array)
+        attribute[:name].map { |nom| ":#{nom}" }.join(", ").prepend('[') + ']'
+      else
+        ":#{attribute[:name]}"
+      end
+      table = attribute[:table] || 'replace_with_table_name'
+      options = attribute[:options] || {}
+
+      lookup_hash = {
+        primary: "primary_key #{name}",
+        string: "String #{name}",
+        text: "String #{name}, text: true",
+        integer: "Integer #{name}",
+        date: "Date #{name}",
+        datetime: "DateTime #{name}",
+        time: "Time #{name}",
+        boolean: "TrueClass #{name}",
+        bigint: "Bignum #{name}",
+        decimal: "BigDecimal #{name}",
+        foreign_key: "foreign_key #{name}, :#{table}",
+        index: "index #{name}",
+        unique: "unique #",
+      }
+
+      statement = lookup_hash[type.to_sym]
+
+      options.keys.each do |key|
+        statement += ", #{key}: '#{options[key]}'"
+      end
+
+      statement
+    end
+  end
+end

data/lib/rubee/logger.rb

@@ -0,0 +1,83 @@
+module Rubee
+  class Logger
+    class << self
+      def warn(message:, **options, &block)
+        out.warn(message:, **options, &block)
+      end
+
+      def error(message:, **options, &block)
+        out.error(message:, **options, &block)
+      end
+
+      def critical(message:, **options, &block)
+        out.critical(message:, **options, &block)
+      end
+
+      def info(message:, **options, &block)
+        out.info(message:, **options, &block)
+      end
+
+      def debug(object:, **options, &block)
+        out.debug(object:, **options, &block)
+      end
+
+      def out
+        Rubee::Configuration.get_logger || Stdout
+      end
+    end
+  end
+
+  class Stdout
+    class << self
+      def warn(message:, **options, &block)
+        log(:warn, message, options, &block)
+      end
+
+      def error(message:, **options, &block)
+        log(:error, message, options, &block)
+      end
+
+      def critical(message:, **options, &block)
+        log(:critical, message, options, &block)
+      end
+
+      def info(message:, **options, &block)
+        log(:info, message, options, &block)
+      end
+
+      def debug(object:, **options, &block)
+        log(:debug, object.inspect, options, &block)
+      end
+
+      def print_error(message)
+        color_puts(message, color: :red)
+      end
+
+      def print_info(message)
+        color_puts(message, color: :gray)
+      end
+
+      def print_warn(message)
+        color_puts(message, color: :yellow)
+      end
+
+      def print_debug(message)
+        color_puts(message)
+      end
+
+      def print_critical(message)
+        color_puts(message, color: :red, style: :blink)
+      end
+
+      def log(severity, message, options = {}, &block)
+        time = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+        if options.any?
+          message = options.map { |k, v| "[#{k}: #{v}]" }.join << " #{message}"
+        end
+        send("print_#{severity}", "[#{time}] #{severity.upcase} #{message}")
+
+        block&.call(message, options) if block_given?
+      end
+    end
+  end
+end

data/lib/rubee/models/sequel_object.rb

@@ -23,7 +23,7 @@ module Rubee
       args = to_h.dup&.transform_keys(&:to_sym)
       if args[:id]
         begin
-          udpate(args)
+          update(args)
         rescue StandardError => _e
           return false
         end
@@ -107,7 +107,6 @@ module Rubee
       # > comment.user
       # > <user>
       def owns_one(assoc, options = {})
-        Sequel::Model.one_to_one(assoc, **options)
         fk_name ||= "#{name.to_s.downcase}_id"
         define_method(assoc) do
           Object.const_get(assoc.capitalize).where(fk_name.to_sym => id)&.first