ru.Bee 1.5.4 → 1.7.0

data/lib/rubee/cli/attach.rb

@@ -0,0 +1,124 @@
+module Rubee
+  module CLI
+    class Attach
+      using ChargedString
+
+      class << self
+        def call(command, argv)
+          send(command, argv)
+        end
+
+        def attach(argv)
+          new_app_name = argv[1]
+
+          # create project folde
+          if new_app_name.nil?
+            color_puts('Please indicate app name.', color: :red)
+            exit(1)
+          end
+
+          if new_app_name == 'rubee'
+            color_puts("Error: App 'rubee' name is reserved", color: :red)
+            exit(1)
+          end
+          target_dir = File.join(Rubee::APP_ROOT, new_app_name)
+
+          if Dir.exist?(target_dir)
+            color_puts("Error: App #{new_app_name} already exists!", color: :red)
+            exit(1)
+          end
+
+          # create controllers models view folders
+          FileUtils.mkdir_p(target_dir)
+          # creare controllers models views dirs
+          ['controllers', 'models', 'views'].each do |dir|
+            FileUtils.mkdir_p("#{target_dir}/#{dir}")
+          end
+
+          config_file = <<~CONFIG_FILE
+            Rubee::Configuration.setup(env = :test, app = :#{new_app_name}) do |config|
+            end
+            Rubee::Configuration.setup(env = :developmenti, app = :#{new_app_name}) do |config|
+            end
+            Rubee::Configuration.setup(env = :production, app = :#{new_app_name}) do |config|
+            end
+          CONFIG_FILE
+
+          File.open("#{target_dir}/#{new_app_name}_configuration.rb", 'w') do |file|
+            file.puts config_file
+          end
+
+          # create app routes.rb file
+          route_file = <<~ROUTE_FILE
+            Rubee::Router.draw do |router|
+            end
+          ROUTE_FILE
+
+          File.open("#{target_dir}/#{new_app_name}_routes.rb", 'w') do |file|
+            file.puts route_file
+          end
+
+          # copy views
+          copy_files(
+            File.join(Rubee::ROOT_PATH, '/lib/app/views'),
+            "#{target_dir}/views",
+            %w[welcome_header.erb welcome_show.erb App.tsx],
+            %w[utils],
+            app_name: new_app_name
+          )
+
+          # create namespace module
+          module_content = <<~RUBY
+            module #{new_app_name.camelize}
+            end
+          RUBY
+
+          File.open("#{target_dir}/#{new_app_name.snakeize}_namespace.rb", 'w') { |file| file.write(module_content) }
+          color_puts("App #{new_app_name} attached!", color: :green)
+
+          # create react app file
+          react_app_file = <<~REACT_APP_FILE
+            import React from 'react';
+
+            export function #{new_app_name.camelize}App() {
+              return (
+                <h1>#{new_app_name.camelize}App</h1>
+              );
+            }
+          REACT_APP_FILE
+
+          File.open("#{target_dir}/views/#{new_app_name.camelize}App.tsx", 'w') do |file|
+            file.puts react_app_file
+          end
+        end
+
+        private
+
+        def copy_files(source_dir, target_dir, blacklist_files = [], blacklist_dirs = [], **options)
+          Dir.glob("#{source_dir}/**/*", File::FNM_DOTMATCH).each do |file|
+            relative_path = file.sub("#{source_dir}/", '')
+            next if blacklist_dirs.any? { |dir| relative_path.split('/').include?(dir) }
+            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
+          return unless options[:app_name]
+          # rename copied file with prefixing base name with app_name
+          Dir["#{target_dir}/**/*"].each do |f|
+            ext = File.extname(f).delete('.')
+            if %w[ts tsx js jsx].include?(ext)
+              File.rename(f, f.gsub(File.basename(f), "#{options[:app_name].camelize}#{File.basename(f)}"))
+            else
+              File.rename(f, f.gsub(File.basename(f), "#{options[:app_name].snakeize}_#{File.basename(f)}"))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubee/cli/command.rb

@@ -0,0 +1,41 @@
+module Rubee
+  module CLI
+    class Command
+      def initialize(argv)
+        @command = argv[0]
+        @argv = argv
+      end
+
+      def call
+        factory.call(@command, @argv)
+      end
+
+      def factory
+        case @command
+        in /^(start|start_dev|stop|status)$/
+          Rubee::CLI::Server
+        in /^react$/
+          Rubee::CLI::React
+        in /^project$/
+          Rubee::CLI::Project
+        in /^version$/
+          Rubee::CLI::Version
+        in /^routes$/
+          Rubee::CLI::Routes
+        in /^test$/
+          Rubee::CLI::Test
+        in /^(generate|gen)$/
+          Rubee::CLI::Generate
+        in /^db$/
+          Rubee::CLI::Db
+        in /^(console|c)$/
+          Rubee::CLI::Console
+        in /^(attach|att)$/
+          Rubee::CLI::Attach
+        else
+          proc { color_puts("Unknown command: #{@command}", color: :red) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Rubee
+  class Configuration
+    include Singleton
+    require_relative '../inits/charged_hash' unless defined?(ChargedHash)
+    using ChargedHash
+
+    @configuraiton = {
+      app: {
+        development: {
+          database_url: '',
+          port: 7000,
+        },
+        production: {},
+        test: {},
+      },
+    }
+
+    class << self
+      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)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:database_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]
+      end
+
+      def threads_limit=(args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:thread_pool_limit] = args[:value]
+      end
+
+      def fibers_limit=(args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:fiber_pool_limit] = args[:value]
+      end
+
+      def logger=(args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][args[:env].to_sym][:logger] = args[:logger]
+      end
+
+      def react=(args)
+        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(**args)
+        args[:app] ||= :app
+        @configuraiton[args[:app].to_sym][ENV['RACK_ENV']&.to_sym || :development][:react] || {}
+      end
+
+      def method_missing(method_name, *args)
+        return unless method_name.to_s.start_with?('get_')
+
+        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
+        @configuraiton.keys
+      end
+    end
+  end
+end