ru.Bee 1.6.0 → 1.7.0

data/lib/rubee/cli/console.rb

@@ -0,0 +1,39 @@
+module Rubee
+  module CLI
+    module Console
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def console(argv)
+          argv.clear
+          ENV['RACK_ENV'] ||= 'development'
+
+          if Rubee::PROJECT_NAME == '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
+            # Start IRB
+            IRB.start
+          rescue => _e
+            IRB.start
+          end
+        end
+
+        alias_method :c, :console
+      end
+    end
+  end
+end

data/lib/rubee/cli/db.rb

@@ -0,0 +1,105 @@
+module Rubee
+  module CLI
+    module Db
+      class << self
+        def call(command, argv)
+          command = argv[1].split(':').first
+          ENV['RACK_ENV'] ||= 'development'
+          if Rubee::PROJECT_NAME == 'rubee'
+            Rubee::Configuration.setup(env = :test) do |config|
+              config.database_url = { url: 'sqlite://lib/tests/test.db', env: }
+            end
+            Rubee::SequelObject.reconnect! unless command == 'init'
+          end
+
+          send(command, argv)
+        end
+
+        def run(argv)
+          _, file_name = argv[1]&.split(':')
+          file_names = if file_name == 'all'
+            lib = Rubee::PROJECT_NAME == 'rubee' ? '/lib' : ''
+            Dir.glob(".#{lib}/db/*.rb").map do |file|
+              File.basename(file, '.rb')
+            end.reject { |file| file == 'structure' }
+          else
+            [file_name]
+          end
+          Rubee::Configuration.envs.each do |env|
+            ENV['RACK_ENV'] = env.to_s
+            file_names.each do |file|
+              color_puts("Run #{file} file for #{env} env", color: :cyan)
+              Object.const_get(file.split('_').map(&:capitalize).join).new.call
+            end
+          end
+          color_puts("Migration for #{file_name} completed", color: :green)
+          unless Rubee::PROJECT_NAME == 'rubee'
+            color_puts('Regenerate schema file', color: :cyan)
+            generate_structure
+          end
+        end
+
+        def init(_argv)
+          ensure_database_exists(Rubee::Configuration.get_database_url)
+        end
+
+        def structure(_argv)
+          generate_structure
+        end
+
+        private
+
+        def generate_structure
+          schema_hash = {}
+
+          Rubee::SequelObject::DB.tables.each do |table|
+            schema_hash[table] = {}
+
+            Rubee::SequelObject::DB.schema(table).each do |column, details|
+              schema_hash[table][column] = details
+            end
+          end
+          formatted_hash = JSON.pretty_generate(schema_hash)
+            .gsub(/"(\w+)":/, '\1:') # Convert keys to symbols
+            .gsub(': null', ': nil') # Convert `null` to `nil`
+
+          File.open('db/structure.rb', 'w') do |file|
+            file.puts "STRUCTURE = #{formatted_hash}"
+          end
+
+          color_puts('db/structure.rb updated', color: :green)
+        end
+
+        def ensure_database_exists(db_url)
+          uri = URI.parse(db_url)
+          case uri.scheme
+          when 'sqlite'
+            begin
+              Sequel.connect(db_url)
+              color_puts("Database #{ENV['RACK_ENV']} exists", color: :cyan)
+            rescue => _e
+              if File.exist?(db_path = db_url.sub(%r{^sqlite://}, ''))
+                color_puts("Database #{ENV['RACK_ENV']} exists", color: :cyan)
+              else
+                Sequel.sqlite(db_path)
+                color_puts("Database #{ENV['RACK_ENV']} created", color: :green)
+              end
+            end
+          when 'postgres'
+            begin
+              Sequel.connect(db_url)
+              color_puts("Database #{ENV['RACK_ENV']} exists", color: :cyan)
+            rescue StandardError => _e
+              con = Sequel.connect(Rubee::Configuration.get_database_url.gsub(%r{(/test|/development|/production)},
+        ''))
+              con.run("CREATE DATABASE #{ENV['RACK_ENV']}")
+              color_puts("Database #{ENV['RACK_ENV']} created", color: :green)
+            end
+          else
+            color_puts("Unsupported database type: #{db_url}", color: :red)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/generate.rb

@@ -0,0 +1,33 @@
+module Rubee
+  module CLI
+    module Generate
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def generate(argv)
+          method, path = argv[1..2]
+          app = argv[3]
+          app_name = app.nil? ? :app : app.split(':')[1]
+          ENV['RACK_ENV'] ||= 'development'
+          file = Rubee::PROJECT_NAME == 'rubee' ? File.join(Dir.pwd, '/lib', 'config/routes.rb') : 'config/routes.rb'
+          routes = eval(File.read(file))
+          route = routes.find { |route| route[:path] == path.to_s && route[:method] == method.to_sym }
+
+          color_puts("Route not found with path: #{path} and method: #{method}", color: :red) unless route
+          Rubee::Generator.new(
+            route[:model]&.[](:name),
+            route[:model]&.[](:attributes),
+            "#{route[:controller]&.capitalize}Controller",
+            route[:action],
+            react: route[:react],
+            app_name:
+          ).call
+        end
+
+        alias_method :gen, :generate
+      end
+    end
+  end
+end

data/lib/rubee/cli/project.rb

@@ -0,0 +1,124 @@
+module Rubee
+  module CLI
+    class Project
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def project(argv)
+          project_name = argv[1]
+
+          if project_name.nil?
+            color_puts('Please indicate project name.', color: :red)
+            exit(1)
+          end
+
+          if project_name == 'rubee'
+            color_puts("Error: Project 'rubee' is reserved", color: :red)
+            exit(1)
+          end
+          source_dir = File.join(Rubee::ROOT_PATH, '/lib')
+          target_dir = File.expand_path("./#{project_name}", Dir.pwd)
+
+          if Dir.exist?(target_dir)
+            color_puts("Error: Project #{project_name} already exists!", color: :red)
+            exit(1)
+          end
+          # Create target directory
+          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]
+          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)
+          # create tests dir and copy test_helper.rb and user_model_test.rb
+          setup_test_structure(target_dir, source_dir)
+          # create db dir
+          setup_db_structure(target_dir, source_dir)
+          # create inits dir
+          FileUtils.mkdir_p("#{target_dir}/inits")
+          # create a gemfile context
+          setup_gemfile(target_dir)
+          color_puts("Project #{project_name} created successfully at #{target_dir}", color: :green)
+        end
+
+        private
+
+        def copy_project_files(source_dir, target_dir, blacklist_files, blacklist_dirs)
+          Dir.glob("#{source_dir}/**/*", File::FNM_DOTMATCH).each do |file|
+            relative_path = file.sub("#{source_dir}/", '')
+            # Skip blacklisted directories
+            next if blacklist_dirs.any? { |dir| relative_path.split('/').include?(dir) }
+            # Skip blacklisted files
+            next if blacklist_files.include?(File.basename(file))
+
+            target_path = File.join(target_dir, relative_path)
+            if File.directory?(file)
+              FileUtils.mkdir_p(target_path)
+            else
+              FileUtils.cp(file, target_path)
+            end
+          end
+        end
+
+        def setup_test_structure(target_dir, source_dir)
+          FileUtils.mkdir_p("#{target_dir}/tests")
+          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 test_helper.rb file
+          test_helper = <<~TESTHELPER
+            require "bundler/setup"
+            Bundler.require(:test)
+
+            require 'minitest/autorun'
+            require 'rack/test'
+            require 'rubee'
+
+            Rubee::Autoload.call
+          TESTHELPER
+
+          File.open("#{target_dir}/tests/test_helper.rb", 'w') do |file|
+            file.puts test_helper
+          end
+        end
+
+        def setup_db_structure(target_dir, source_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")
+        end
+
+        def setup_gemfile(target_dir)
+          gemfile = <<~GEMFILE
+            source 'https://rubygems.org'
+
+            gem 'ru.Bee'
+            gem 'sequel'
+            gem 'sqlite3'
+            gem 'rake'
+            gem 'rack'
+            gem 'rackup'
+            gem 'pry'
+            gem 'pry-byebug'
+            gem 'puma'
+            gem 'json'
+
+            group :development do
+              gem 'rerun'
+              gem 'minitest'
+              gem 'rack-test'
+            end
+          GEMFILE
+          # create a gemfile
+          File.open("#{target_dir}/Gemfile", 'w') do |file|
+            file.puts gemfile
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/react.rb

@@ -0,0 +1,28 @@
+module Rubee
+  module CLI
+    class React
+      class << self
+        def call(command, argv)
+          command = argv[1]
+          send(command, argv)
+        end
+
+        def prepare(_argv)
+          if Rubee::PROJECT_NAME == 'rubee'
+            exec('cd ./lib && npm run prepare')
+          else
+            exec('npm run prepare')
+          end
+        end
+
+        def watch(_argv)
+          if Rubee::PROJECT_NAME == 'rubee'
+            exec('cd ./lib && npm run watch')
+          else
+            exec('npm run watch')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/routes.rb

@@ -0,0 +1,18 @@
+module Rubee
+  module CLI
+    class Routes
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def routes(_argv)
+          file = Rubee::PROJECT_NAME == 'rubee' ? File.join(Dir.pwd, '/lib', 'config/routes.rb') : 'config/routes.rb'
+          routes = eval(File.read(file)) # TODO: rewrite it omitting eval
+
+          color_puts(routes, color: :green)
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/server.rb

@@ -0,0 +1,52 @@
+module Rubee
+  module CLI
+    class Server
+      LOGO = <<-'LOGO'
+  ____  _    _  ____  _____
+ |  _ \| |  | || __ )| ____|
+ | |_) | |  | ||  _ \|  _|
+ |  _ <| |__| || |_) | |___
+ |_| \_\\____/ |____/|_____|
+ Ver: %s
+LOGO
+
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def start(argv)
+          _, port = argv.first&.split(':')
+
+          port ||= '7000'
+          print_logo
+          color_puts("Starting takeoff of ruBee server on port #{port}...", color: :yellow)
+          exec("rackup #{ENV['RACKUP_FILE']} -p #{port}")
+        end
+
+        def start_dev(argv)
+          _, port = argv.first&.split(':')
+
+          port ||= '7000'
+          print_logo
+
+          color_puts("Starting takeoff of ruBee server on port #{port} in dev mode...", color: :yellow)
+
+          exec("rerun -- rackup --port #{port} #{ENV['RACKUP_FILE']}")
+        end
+
+        def stop(_argv)
+          exec('pkill -f rubee')
+        end
+
+        def status(_argv)
+          exec('ps aux | grep rubee')
+        end
+
+        def print_logo
+          puts "\e[36m#{LOGO % Rubee::VERSION}\e[0m" # Cyan color
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/test.rb

@@ -0,0 +1,24 @@
+module Rubee
+  module CLI
+    module Test
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def test(argv)
+          ENV['RACK_ENV'] = 'test'
+          file_name = argv[1] # Get the first argument
+          lib = Rubee::PROJECT_NAME == 'rubee' ? '/lib' : ''
+          if file_name
+            color_puts("Running #{file_name} test ...", color: :yellow)
+            exec("ruby -Itest -e \"require '.#{lib}/tests/#{file_name}'\"")
+          else
+            color_puts('Running all tests ...', color: :yellow)
+            exec("ruby -Itest -e \"Dir.glob('.#{lib}/tests/**/*_test.rb').each { |file| require file }\"")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/version.rb

@@ -0,0 +1,15 @@
+module Rubee
+  module CLI
+    class Version
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def version(_argv)
+          color_puts("ruBee v#{Rubee::VERSION}", color: :yellow)
+        end
+      end
+    end
+  end
+end

data/lib/rubee/configuration.rb

@@ -1,55 +1,78 @@
 module Rubee
   class Configuration
     include Singleton
+    require_relative '../inits/charged_hash' unless defined?(ChargedHash)
+    using ChargedHash
 
     @configuraiton = {
-      development: {
-        database_url: '',
-        port: 7000,
+      app: {
+        development: {
+          database_url: '',
+          port: 7000,
+        },
+        production: {},
+        test: {},
       },
-      production: {},
-      test: {},
     }
 
     class << self
-      def setup(_env)
+      def setup(env, app = :app)
+        unless @configuraiton[app.to_sym]
+          @configuraiton[app.to_sym] = {
+            development: {},
+            production: {},
+            test: {},
+          }
+          unless @configuraiton[app.to_sym][env.to_sym]
+            @configuraiton[app.to_sym][env.to_sym] = {}
+          end
+        end
+
         yield(self)
       end
 
       def database_url=(args)
-        @configuraiton[args[:env].to_sym][:database_url] = args[:url]
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:database_url] = args[:url]
       end
 
       def async_adapter=(args)
-        @configuraiton[args[:env].to_sym][:async_adapter] = args[:async_adapter]
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:async_adapter] = args[:async_adapter]
       end
 
       def threads_limit=(args)
-        @configuraiton[args[:env].to_sym][:thread_pool_limit] = args[:value]
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:thread_pool_limit] = args[:value]
       end
 
       def fibers_limit=(args)
-        @configuraiton[args[:env].to_sym][:fiber_pool_limit] = args[:value]
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:fiber_pool_limit] = args[:value]
       end
 
       def logger=(args)
-        @configuraiton[args[:env].to_sym][:logger] = args[:logger]
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][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])
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:react] ||= { on: false }
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:react].merge!(on: args[:on])
       end
 
-      def react
-        @configuraiton[ENV['RACK_ENV']&.to_sym || :development][:react] || {}
+      def react(**args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][ENV['RACK_ENV']&.to_sym || :development][:react] || {}
       end
 
-      def method_missing(method_name, *_args)
+      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)
+        app_name = args[0] || :app
+        @configuraiton[app_name.to_sym][ENV['RACK_ENV']&.to_sym || :development]
+          &.[](method_name.to_s.delete_prefix('get_').to_sym)
       end
 
       def envs

data/lib/rubee/controllers/base_controller.rb

@@ -68,12 +68,18 @@ module Rubee
       in :not_found
         [404, { 'content-type' => 'text/plain' }, ['Route not found']]
       else # rendering erb view is a default behavior
-        view_file_name = self.class.name.split('Controller').first.downcase
+        # TODO: refactor
+        view_file_name = self.class.name.split('Controller').first.gsub('::', '_').downcase
         erb_file = render_view ? render_view.to_s : "#{view_file_name}_#{@route[:action]}"
         lib = Rubee::PROJECT_NAME == 'rubee' ? 'lib/' : ''
-        view = render_template(erb_file, { object:, **(options[:locals] || {}) })
-
-        whole_erb = if File.exist?(layout_path = "#{lib}app/views/#{options[:layout] || 'layout'}.erb")
+        path_parts = self.class.instance_method(@route[:action]).source_location[0].split('/').reverse
+        controller_index = path_parts.find_index { |part| part == 'controllers' }
+        app_name = path_parts[controller_index + 1]
+        view = render_template(erb_file, { object:, **(options[:locals] || {}) }, app_name:)
+        # Since controller sits in the controllers folder we can get parent folder of it and pull out name of the app
+        app_name_prefix = app_name == 'app' ? '' : "#{app_name}_"
+        layout_path = "#{lib}#{app_name}/views/#{app_name_prefix}#{options[:layout] || 'layout'}.erb"
+        whole_erb = if File.exist?(layout_path)
           context = Object.new
           context.define_singleton_method(:_yield_template) { view }
           layout = File.read(layout_path)
@@ -86,9 +92,9 @@ module Rubee
       end
     end
 
-    def render_template(file_name, locals = {})
+    def render_template(file_name, locals = {}, **options)
       lib = Rubee::PROJECT_NAME == 'rubee' ? 'lib/' : ''
-      path = "#{lib}app/views/#{file_name}.erb"
+      path = "#{lib}#{options[:app_name] || 'app'}/views/#{file_name}.erb"
       erb_template = ERB.new(File.read(path))
 
       erb_template.result(binding)

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

@@ -3,8 +3,8 @@ require 'date'
 
 module Rubee
   module AuthTokenable
-    KEY = "secret#{Date.today}".freeze # Feel free to cusomtize it
-    EXPIRE = 3600 # 1 hour
+    KEY = "secret#{Date.today}".freeze unless defined?(KEY) # Feel free to cusomtize it
+    EXPIRE = 3600 unless defined?(EXPIRE)
 
     def self.included(base)
       base.include(Middlewarable)