ru.Bee 1.1.0

data/lib/rubee.rb

@@ -0,0 +1,259 @@
+require "singleton"
+require "bundler/setup"
+require 'bundler'
+
+Bundler.require(:default) rescue nil
+
+module Rubee
+  APP_ROOT = File.expand_path(Dir.pwd) unless defined?(APP_ROOT)
+  IMAGE_DIR = File.join(APP_ROOT, 'images') unless defined?(IMAGE_DIR)
+  PROJECT_NAME = File.basename(APP_ROOT) unless defined?(PROJECT_NAME)
+
+  class Application
+    include Singleton
+
+    def call(env)
+      # autoload rb files
+      Autoload.call
+      # register images paths
+      request = Rack::Request.new(env)
+      # Add default path for images
+      Router.draw { |route| route.get "/images/{path}", to: "base#image", namespace: "Rubee"}
+      # define route
+      route = Router.route_for(request)
+      # init controller class
+      return [404, { "content-type" => "text/plain" }, ["Route not found"]] unless route
+
+      if route[:namespace]
+        controller_class = "#{route[:namespace]}::#{route[:controller].capitalize}Controller"
+      else
+        controller_class = "#{route[:controller].capitalize}Controller"
+      end
+      # instantiate controller
+      controller = Object.const_get(controller_class).new(request, route)
+      # get the action
+      action = route[:action]
+      # fire the action
+      controller.send(action)
+    end
+  end
+
+  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 method_missing(method_name, *args, &block)
+        if method_name.to_s.start_with?("get_")
+          @configuraiton[ENV['RACK_ENV']&.to_sym || :development]&.[](method_name.to_s.delete_prefix("get_").to_sym)
+        end
+      end
+
+      def envs
+        @configuraiton.keys
+      end
+    end
+  end
+
+  class Router
+    include Singleton
+
+    HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head, :connect, :options, :trace].freeze
+
+    attr_reader :request, :routes
+
+    @routes = []
+
+    class << self
+      def draw
+        yield(self) if block_given?
+      end
+
+      def route_for(request)
+        puts request.request_method
+        method = (request.params["_method"] || request.request_method).downcase.to_sym
+        @routes.find do |route|
+          return route if request.path == route[:path] && request.request_method&.downcase&.to_sym == route[:method]
+
+          pattern = route[:path].gsub(/{.*?}/, '([^/]+)')
+          regex = %r{^#{pattern}$}
+          regex.match?(request.path) && method.to_s == route[:method].to_s
+        end
+      end
+
+      def set_route(path, to:, method: __method__, **args)
+        controller, action = to.split("#")
+        @routes.delete_if { |route| route[:path] == path && route[:method]  == method }
+        @routes << { path:, controller:, action:, method:, **args }
+      end
+
+      HTTP_METHODS.each do |method|
+        define_method method do |path, to:, **args|
+          set_route(path, to:, method: method, **args)
+        end
+      end
+    end
+  end
+
+
+  class Autoload
+    class << self
+      def call(black_list=[])
+        # autoload all rbs
+        root_directory = File.dirname(__FILE__)
+        priority_order_require(root_directory, black_list)
+
+        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
+        lib_dir = PROJECT_NAME == 'rubee' ? 'lib' : ''
+        Dir[File.join(APP_ROOT, lib_dir, '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
+        require_relative File.join(APP_ROOT, lib_dir, "config/base_configuration") unless black_list.include?('base_configuration.rb')
+        require_relative File.join(APP_ROOT, lib_dir, "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
+        require_relative File.join(root_directory, "rubee/controllers/base_controller") unless black_list.include?('base_controller.rb')
+        # rubee models
+        require_relative File.join(root_directory, "rubee/models/database_object") unless black_list.include?('database_object.rb')
+        require_relative File.join(root_directory, "rubee/models/sequel_object") unless black_list.include?('sequel_object.rb')
+      end
+    end
+  end
+
+  class Generator
+    def initialize(model_name, attributes, controller_name, action_name)
+      @model_name = model_name&.downcase
+      @attributes = attributes
+      @plural_name = "#{controller_name.to_s.gsub("Controller", "").downcase}"
+      @action_name = action_name
+      @controller_name = controller_name
+    end
+
+    def call
+      generate_model if @model_name
+      generate_db_file if @model_name
+      generate_controller if @controller_name && @action_name
+      generate_view if @controller_name
+    end
+
+    private
+
+    def generate_model
+      model_file = File.join("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 #{@attributes.map { |hash| ":#{hash[:name]}"  }.join(", ")}
+        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("app/controllers/#{@plural_name}_controller.rb")
+      if File.exist?(controller_file)
+        puts "Controller #{@plural_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~RUBY
+        class #{@plural_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 #{@plural_name} created", color: :green
+    end
+
+    def generate_view
+      view_file = File.join("app/views/#{@plural_name}_#{@action_name}.erb")
+      if File.exist?(view_file)
+        puts "View #{@plural_name}_#{@action_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~ERB
+        <h1>#{@plural_name}_#{@action_name} View</h1>
+      ERB
+
+      File.open(view_file, 'w') { |file| file.write(content) }
+      color_puts "View #{@plural_name}_#{@action_name} created", color: :green
+    end
+
+    def generate_db_file
+      db_file = File.join("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
+          end
+        end
+      RUBY
+
+      File.open(db_file, 'w') { |file| file.write(content) }
+      color_puts "DB file for #{@plural_name} created", color: :green
+    end
+  end
+end
+

data/lib/version.rb

@@ -0,0 +1 @@
+VERSION = '1.1.0'

data/readme.md

@@ -0,0 +1,353 @@
+![Tests](https://github.com/nucleom42/rubee/actions/workflows/test.yml/badge.svg)
+![License](https://img.shields.io/github/license/nucleom42/rubee)
+![GitHub Repo stars](https://img.shields.io/github/stars/nucleom42/rubee?style=social)
+
+
+# <img src="images/rubee.svg" alt="Rubee" height="40"> ... ruBee
+
+ruBee is a fast and lightweight Ruby application server designed for minimalism and flexibility .
+
+The main philosophy of ruBee is to focus on Ruby language explicit implementation of the MVC web application.
+
+Want to get a quick API server up and runing? You can do it for real quick!
+<br />
+Laoding ... (demo is on its way)
+
+All greaet features are yet to come!
+
+## Features
+
+- **Lightweight**: A minimal footprint that focuses on serving Ruby applications efficiently.
+- **Contract driven**: Define your API contracts in a simple, declarative manner. And generate the files for you.
+- **Fast**: Optimized for speed, providing a quick response to requests. Everything is relative, I know!
+- **Rack**: Rack backed. All Rack api is available for integration.
+- **Router**: Router driven - generates all required files from the routes.
+- **Databases**: Sqlite3, Postgres, Mysql and many more supported by sequel gem.
+- **Views**: Json, ERB and plain HTML
+- **Bundlable** Charge your ruBee with any gem you need and update your project with bundle.
+- **ORM** All models are natively ORM objects, however you can use it as a blueurpint for any datasources.
+- **Authentificatable** Add JWT authentification easily to any controller action.
+- **Hooks** Add logic before, after and around any action.
+- **Test** Run all or selected tests witin minitest.
+- **Asyncable** Add async adapter and pick any popular background job queue enginee
+
+## Installation
+
+1. Install ruBee
+```bash
+gem install rubee
+```
+
+2. Create your first project
+```bash
+rubee project my_project
+cd my_project
+```
+
+3. Install dependencies
+
+***Prerequisites***<br />
+**ruBee** is using **Sqlite** as a default database. However you can pick up any other database supported by sequel gem.
+Aside that, make sure:
+**Ruby** language (3+) is installed
+**Bundler** is installed
+
+```bash
+bundle install
+```
+
+4. Run ruBee server. Default port is 7000
+```bash
+rubee start
+```
+
+5. Open your browser and go to http://localhost:7000
+
+## Create API contract and generate files from the routes
+1. Add the routes to the routes.rb
+```bash
+Rubee::Router.draw do |router|
+  ...
+  # draw the contract
+  router.get "/apples", to: "apples#index",
+    model: {
+      name: "apple",
+      attributes: [
+        { name: 'id', type: :integer },
+        { name: 'colour', type: :string },
+        { name: 'weight', type: :integer }
+      ]
+    }
+end
+```
+2. genrate the files
+```bash
+rubee generate get /apples
+```
+3. This will generate the following files
+```bash
+./app/controllers/apples_controller.rb # Controller with respective action
+./app/models/apple.rb # Model that acts as ORM
+./app/views/apples_index.erb # ERB view that is rendered by the controller right away
+./db/create_items.rb # Database migration file needed for creating repsective table
+```
+4. Fill those files with the logic you need and run the server again!
+
+## Model
+Model in ruBee is just simple ruby object that can be serilalized in the view
+in the way it required (ie json).
+
+Here below is a simple example on how it can be used by rendering json from in memory object
+
+```ruby
+  #ApplesController
+
+  def show
+    # in memory example
+    apples = [Apple.new(colour: 'red', weight: '1lb'), Apple.new(colour: 'green', weight: '1lb')]
+    apple = apples.find { |apple| apple.colour = params[:colour] }
+
+    response_with object: apple, type: :json
+  end
+```
+
+Just make sure Serializable module included in the target class.
+```ruby
+  class Apple
+    include Serializable
+    attr_accessor :id, :colour, :weight
+  end
+```
+However, you can simply turn it to ORM object by extending database class.
+
+```Ruby
+  class Apple < Rubee::SequelObject
+    attr_accessor :id, :colour, :weight
+  end
+```
+
+So in the controller you would need to query your target object now.
+
+```ruby
+  #ApplesController
+
+  def show
+    apple = Apple.where(colour: params[:colour])&.last
+
+    if apple
+      response_with object: apple, type: :json
+    else
+      response_with object: { error: "apple with colour #{params[:colour]} not found" }, status: 422, type: :json
+    end
+  end
+```
+
+## Views
+View in ruBee is just a plain html/erb file that can be rendered from the controller.
+
+## Object hooks
+
+In ruBee by extending Hookable module any Ruby object can be charged with hooks (logic),
+that can be executed before, after and around a specific method execution.
+
+Here below a controller example. However it can be used in any Ruby object, like Model etc.
+```ruby
+# base conrteoller is hopokable by Default
+class ApplesController < Rubee::BaseController
+  before :index, :print_hello # you can useinstance method as a handler
+  after :index, -> { puts "after index" }, if: -> { true } # or you can use lambda
+  after :index, -> { puts "after index2" }, unless: -> { false } # if, unless guards may accept method or lambda
+  around :index, :log
+
+  def index
+    response_with object: { test: "hooks" }
+  end
+
+  def print_hello
+    puts "hello!"
+  end
+
+  def log
+    puts "before log aroud"
+    res = yield
+    puts "after log around"
+    res
+  end
+  ...
+end
+```
+Then, in the server logs we could see next execution stack
+
+```bash
+before log aroud
+hello!
+after index
+after index2
+after log around
+127.0.0.1 - - [17/Feb/2025:11:42:14 -0500] "GET /apples HTTP/1.1" 401 - 0.0359
+```
+
+## JWT based authentification
+Charge you rpoject with token based authentification system and customize it for your needs.
+include AuthTokenable module to your controller and authentificate any action you need.
+
+Make sure you have initiated User model which is a part of the logic.
+```bash
+rubee db run:create_users
+```
+This will create table users and initiate first user with demo credentials.
+email: "ok@ok.com", password: "password"
+Feel free to customize it in the /db/create_users.rb file before running migration.
+
+Then in the controller you can include the AuthTokenable module and use its methods:
+```ruby
+class UsersController < Rubee::BaseController
+  include AuthTokenable
+  # List methods you want to restrict
+  auth_methods :index # unless the user is authentificated it will return unauthentificated
+
+  # GET /users/login (login form page)
+  def edit
+    response_with
+  end
+
+  # POST /users/login (login logic)
+  def login
+    if authentificate! # AuthTokenable method that init @token_header
+      # Redirect to restricted area, make sure headers: @token_header is passed
+      response_with type: :redirect, to: "/users", headers: @token_header
+    else
+      @error = "Wrong email or password"
+      response_with render_view: "users_edit"
+    end
+  end
+
+  # POST /usres/logout (logout logic)
+  def logout
+    unauthentificate! # AuthTokenable method aimed to handle logout action.
+    # Make sure @zeroed_token_header is passed within headers options
+    response_with type: :redirect, to: "/users/login", headers: @zeroed_token_header
+  end
+
+  # GET /users (restricted endpoint)
+  def index
+    response_with object: User.all, type: :json
+  end
+end
+```
+
+## Rubee commands
+```bash
+rubee start # start the server
+rubee start_dev # start the server in dev mode, which restart server on changes
+rubee stop # stop the server
+rubee restart # restart the server
+```
+
+## Generate commands
+```bash
+rubee generate get /apples # generate controller view, model and migration if set in the routes
+```
+
+## Migraiton commands
+```bash
+rubee db run:create_apples # where create_apples is the name of the migration file, located in /db folder
+rubee db structure # generate migration file for the database structure
+```
+
+## Rubee console
+```bash
+rubee console # start the console
+```
+
+## Testing
+```bash
+rubee test # run all tests
+rubee test auth_tokenable_test.rb # run specific tests
+```
+If you want to run any ruBee command within a specific ENV make sure you added it before a command.
+For instance if you want to run console in test environment you need to run the following command
+
+```bash
+RACK_ENV=test rubee console
+```
+
+## Background jobs
+Set your background job engine with ease!
+
+### Sidekiq engine
+1. Add sidekiq to your Gemfile
+```bash
+gem 'sidekiq'
+```
+2. Configure adapter for desired env
+```ruby
+# config/base_configuration.rb
+
+Rubee::Configuration.setup(env=:development) do |config|
+  config.database_url = { url: "sqlite://db/development.db", env: }
+  config.async_adapter = { async_adapter: SidekiqAsync, env: }
+end
+```
+3. Bundle up
+```bash
+bundle install
+```
+4. Make sure redis is installed and running
+```bash
+redis-server
+```
+5. Add sidekiq configuration file
+```bash
+# config/sidekiq.yml
+
+development:
+  redis: redis://localhost:6379/0
+  concurrency: 5
+  queues:
+    default:
+    low:
+    high:
+```
+6. Create sidekiq worker
+```ruby
+# app/async/test_async_runner.rb
+require_relative 'extensions/asyncable' unless defined? Asyncable
+
+class TestAsyncRunnner
+  include Rubee::Asyncable
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :default
+
+  def perform(options)
+    User.create(email: options['email'], password: options['password'])
+  end
+end
+```
+7. Use it in the code base
+```ruby
+TestAsyncRunnner.new.perform_async(options: {"email"=> "new@new.com", "password"=> "123"})
+```
+### Default engine is ThreadAsync
+However it is not yet recommended for production. Use it with cautions!
+1. Do not define any adapter in the /config/base_configuration.rb file, so default ThreadAsync will be taken.
+2. Just create a worker and process it.
+```ruby
+# test_async_runner.rb
+class TestAsyncRunnner
+  include Rubee::Asyncable
+
+  def perform(options)
+    User.create(email: options['email'], password: options['password'])
+  end
+end
+
+TestAsyncRunnner.new.perform_async(options: {"email"=> "new@new.com", "password"=> "123"})
+```
+
+## TODOs
+- [x] Token authorization API
+- [ ] Document authorization API
+- [ ] Add test coverage
+- [ ] Fix bugs

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: ru.Bee
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Oleg Saltykov
+bindir: bin
+cert_chain: []
+date: 2025-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+description: Application web server written on Ruby
+email:
+- oleg.saltykov@gmail.com
+executables:
+- rubee
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/rubee
+- lib/Dockerfile
+- lib/app/controllers/welcome_controller.rb
+- lib/app/models/user.rb
+- lib/app/views/welcome_show.erb
+- lib/config.ru
+- lib/config/base_configuration.rb
+- lib/config/routes.rb
+- lib/db/create_users.rb
+- lib/db/structure.rb
+- lib/db/test.db
+- lib/images/rubee.svg
+- lib/inits/print_colors.rb
+- lib/rubee.rb
+- lib/rubee/async/asyncable.rb
+- lib/rubee/async/sidekiq_async.rb
+- lib/rubee/async/thread_async.rb
+- lib/rubee/async/thread_pool.rb
+- lib/rubee/controllers/base_controller.rb
+- lib/rubee/controllers/extensions/auth_tokenable.rb
+- lib/rubee/controllers/extensions/middlewarable.rb
+- lib/rubee/controllers/middlewares/auth_token_middleware.rb
+- lib/rubee/extensions/hookable.rb
+- lib/rubee/extensions/serializable.rb
+- lib/rubee/models/database_object.rb
+- lib/rubee/models/sequel_object.rb
+- lib/rubee/tests/auth_tokenable_test.rb
+- lib/rubee/tests/rubeeapp_test.rb
+- lib/rubee/tests/test_helper.rb
+- lib/rubee/tests/user_model_test.rb
+- lib/version.rb
+- readme.md
+homepage: https://github.com/nucleom42/rubee
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: Fast and lightweight Ruby application server designed for minimalism and
+  flexibility
+test_files: []