ru.Bee 1.3.2 → 1.4.0

data/lib/rubee.rb

@@ -1,14 +1,20 @@
-require "singleton"
-require "bundler/setup"
+require 'singleton'
+require 'bundler/setup'
 require 'bundler'
 
-Bundler.require(:default) rescue nil
+begin
+  Bundler.require(:default)
+rescue StandardError
+  nil
+end
 
 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)
-  VERSION = '1.3.1'
+  LIB = PROJECT_NAME == 'rubee' ? 'lib/' : '' unless defined?(LIB)
+  IMAGE_DIR = File.join(APP_ROOT, LIB, 'images') unless defined?(IMAGE_DIR)
+  JS_DIR = File.join(APP_ROOT, LIB, 'js') unless defined?(JS_DIR)
+  VERSION = '1.4.0'
 
   class Application
     include Singleton
@@ -19,16 +25,25 @@ module Rubee
       # 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"}
+      Router.draw do |route|
+        route.get('/images/{path}', to: 'base#image', namespace: 'Rubee')
+        route.get('/js/{path}', to: 'base#js', namespace: 'Rubee')
+        route.get('/css/{path}', to: 'base#css', namespace: 'Rubee')
+      end
       # define route
       route = Router.route_for(request)
+      # if react is the view so we would like to delegate not cauth by rubee routes to it.
+      if Rubee::Configuration.react[:on] && !route
+        index = File.read File.join(Rubee::APP_ROOT, Rubee::LIB, 'app/views', 'index.html')
+        return [200, { 'content-type' => 'text/html' }, [index]]
+      end
+      # if not found return 404
+      return [404, { 'content-type' => 'text/plain' }, ['Route not found']] unless route
       # 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"
+      controller_class = if route[:namespace]
+        "#{route[:namespace]}::#{route[:controller].capitalize}Controller"
       else
-        controller_class = "#{route[:controller].capitalize}Controller"
+        "#{route[:controller].capitalize}Controller"
       end
       # instantiate controller
       controller = Object.const_get(controller_class).new(request, route)
@@ -44,15 +59,15 @@ module Rubee
 
     @configuraiton = {
       development: {
-        database_url: "",
-        port: 7000
+        database_url: '',
+        port: 7000,
       },
       production: {},
-      test: {}
+      test: {},
     }
 
     class << self
-      def setup(env)
+      def setup(_env)
         yield(self)
       end
 
@@ -64,10 +79,19 @@ module Rubee
         @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
+      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
@@ -79,7 +103,7 @@ module Rubee
   class Router
     include Singleton
 
-    HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head, :connect, :options, :trace].freeze
+    HTTP_METHODS = %i[get post put patch delete head connect options trace].freeze
 
     attr_reader :request, :routes
 
@@ -92,19 +116,19 @@ module Rubee
 
       def route_for(request)
         puts request.request_method
-        method = (request.params["_method"] || request.request_method).downcase.to_sym
+        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 = /^#{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 }
+        controller, action = to.split('#')
+        @routes.delete_if { |route| route[:path] == path && route[:method] == method }
         @routes << { path:, controller:, action:, method:, **args }
       end
 
@@ -116,10 +140,9 @@ module Rubee
     end
   end
 
-
   class Autoload
     class << self
-      def call(black_list=[])
+      def call(black_list = [])
         # autoload all rbs
         root_directory = File.dirname(__FILE__)
         priority_order_require(root_directory, black_list)
@@ -149,20 +172,20 @@ module Rubee
           require_relative file unless black_list.include?("#{file}.rb")
         end
         # app config and routes
-        lib = PROJECT_NAME == 'rubee' ? 'lib/' : ''
-        require_relative File.join(APP_ROOT, lib, "config/base_configuration") unless black_list.include?('base_configuration.rb')
+        unless black_list.include?('base_configuration.rb')
+          require_relative File.join(APP_ROOT, LIB,
+                                     'config/base_configuration')
+        end
         # This is necessary prerequisitedb init step
-        unless defined?(Rubee::SequelObject::DB)
-          if PROJECT_NAME == 'rubee'
-            Rubee::Configuration.setup(env=:test) do |config|
-              config.database_url = { url: "sqlite://lib/tests/test.db", env: }
-            end
+        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')
+        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|
+        Dir[File.join(root_directory, 'rubee/extensions/**', '*.rb')].each do |file|
           require_relative file unless black_list.include?("#{file}.rb")
         end
         # rubee controllers
@@ -172,21 +195,31 @@ module Rubee
         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')
+        unless black_list.include?('base_controller.rb')
+          require_relative File.join(root_directory,
+                                     'rubee/controllers/base_controller')
+        end
         # rubee models
-        require_relative File.join(root_directory, "rubee/models/database_objectable") unless black_list.include?('database_objectable.rb')
-        require_relative File.join(root_directory, "rubee/models/sequel_object") unless black_list.include?('sequel_object.rb')
+        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
 
   class Generator
-    def initialize(model_name, attributes, controller_name, action_name)
+    def initialize(model_name, attributes, controller_name, action_name, **options)
       @model_name = model_name&.downcase
       @attributes = attributes
-      @plural_name = "#{controller_name.to_s.gsub("Controller", "").downcase}"
+      @plural_name = controller_name.to_s.gsub('Controller', '').downcase.to_s
       @action_name = action_name
       @controller_name = controller_name
+      @react = options[:react] || {}
     end
 
     def call
@@ -199,7 +232,7 @@ module Rubee
     private
 
     def generate_model
-      model_file = File.join("app/models/#{@model_name}.rb")
+      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
@@ -207,16 +240,16 @@ module Rubee
 
       content = <<~RUBY
         class #{@model_name.capitalize} < Rubee::SequelObject
-          attr_accessor #{@attributes.map { |hash| ":#{hash[:name]}"  }.join(", ")}
+          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
+      color_puts("Model #{@model_name} created", color: :green)
     end
 
     def generate_controller
-      controller_file = File.join("app/controllers/#{@plural_name}_controller.rb")
+      controller_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "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
@@ -231,26 +264,45 @@ module Rubee
       RUBY
 
       File.open(controller_file, 'w') { |file| file.write(content) }
-      color_puts "Controller #{@plural_name} created", color: :green
+      color_puts("Controller #{@plural_name} created", color: :green)
     end
 
     def generate_view
-      view_file = File.join("app/views/#{@plural_name}_#{@action_name}.erb")
+      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 User() {
+
+          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 #{@plural_name}_#{@action_name} already exists. Remove it if you want to regenerate"
+        puts "View #{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
+      color_puts("View #{name} created", color: :green)
     end
 
     def generate_db_file
-      db_file = File.join("db/create_#{@plural_name}.rb")
+      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
@@ -264,8 +316,7 @@ module Rubee
       RUBY
 
       File.open(db_file, 'w') { |file| file.write(content) }
-      color_puts "DB file for #{@plural_name} created", color: :green
+      color_puts("DB file for #{@plural_name} created", color: :green)
     end
   end
 end
-

data/lib/tests/account_model_test.rb

@@ -3,16 +3,16 @@ require_relative 'test_helper'
 describe 'Account model' do
   describe 'holds :user' do
     after do
-      Account.destroy_all cascade: true
+      Account.destroy_all(cascade: true)
     end
 
     describe 'when it holds user_id' do
       it 'returns associated User record' do
-        user = User.new(email: "ok-test@test.com", password: "123")
+        user = User.new(email: 'ok-test@test.com', password: '123')
         user.save
-        account = Account.new(user_id: user.id, addres: "test")
+        account = Account.new(user_id: user.id, addres: 'test')
         account.save
-        _(account.user.id).must_equal user.id
+        _(account.user.id).must_equal(user.id)
       end
     end
   end

data/lib/tests/auth_tokenable_test.rb

@@ -13,17 +13,17 @@ class RubeeAppTest < Minitest::Test
 
   def teardown
     # detach auth methods
-     if WelcomeController.instance_variable_defined?(:@auth_methods)
-       WelcomeController.send(:remove_instance_variable, :@auth_methods)
-     end
+    return unless WelcomeController.instance_variable_defined?(:@auth_methods)
+
+    WelcomeController.send(:remove_instance_variable, :@auth_methods)
   end
 
   def test_welcome_controller_included_auth_tokenable
     WelcomeController.include(Rubee::AuthTokenable)
-    WelcomeController.auth_methods :show
+    WelcomeController.auth_methods(:show)
 
-    get '/'
+    get('/')
 
-    assert_equal last_response.status, 401
+    assert_equal(last_response.status, 401)
   end
 end

data/lib/tests/comment_model_test.rb

@@ -3,32 +3,32 @@ require_relative 'test_helper'
 describe 'Comment model' do
   describe 'owns_many :users, over: :posts' do
     before do
-      comment = Comment.new(text: "test")
+      comment = Comment.new(text: 'test')
       comment.save
-      user = User.new(email: "ok-test@test.com", password: "123")
+      user = User.new(email: 'ok-test@test.com', password: '123')
       user.save
       post = Post.new(user_id: user.id, comment_id: comment.id)
       post.save
     end
 
     after do
-      Comment.destroy_all cascade: true
+      Comment.destroy_all(cascade: true)
     end
 
     describe 'when there are associated comment records' do
       it 'returns all records' do
-        _(Comment.where(text: "test").last.users.count).must_equal 1
-        _(Comment.where(text: "test").last.users.first.email).must_equal "ok-test@test.com"
+        _(Comment.where(text: 'test').last.users.count).must_equal(1)
+        _(Comment.where(text: 'test').last.users.first.email).must_equal('ok-test@test.com')
       end
     end
 
     describe 'sequel dataset query' do
       it 'returns all records' do
         result = Comment.dataset.join(:posts, comment_id: :id)
-          .where(comment_id: Comment.where(text: "test").last.id)
+          .where(comment_id: Comment.where(text: 'test').last.id)
           .then { |dataset| Comment.serialize(dataset) }
 
-        _(result.first.text).must_equal "test"
+        _(result.first.text).must_equal('test')
       end
     end
   end

data/lib/tests/example_models/account.rb

@@ -1,4 +1,5 @@
 class Account < Rubee::SequelObject
   attr_accessor :id, :addres, :user_id
+
   holds :user
 end

data/lib/tests/example_models/comment.rb

@@ -1,4 +1,5 @@
 class Comment < Rubee::SequelObject
   attr_accessor :id, :text, :user_id
+
   owns_many :users, over: :posts
 end

data/lib/tests/example_models/post.rb

@@ -1,5 +1,6 @@
 class Post < Rubee::SequelObject
   attr_accessor :id, :user_id, :comment_id
+
   holds :comment
   holds :user
 end

data/lib/tests/example_models/user.rb

@@ -1,4 +1,5 @@
 class User < Rubee::SequelObject
   attr_accessor :id, :email, :password
+
   owns_many :accounts, cascade: true
 end

data/lib/tests/rubeeapp_test.rb

@@ -7,18 +7,33 @@ class RubeeAppTest < Minitest::Test
     Rubee::Application.instance
   end
 
+  def setup
+    Rubee::Configuration.setup(env = :test) { _1.react = { on: false, env: } }
+  end
+
+  def teardown
+    Rubee::Configuration.setup(env = :test) { _1.react = { on: false, env: } }
+  end
 
   def test_welcome_route
-    get '/'
+    get('/')
 
-    assert_equal 200, last_response.status, "Unexpected response: #{last_response.body}"
-    assert_includes last_response.body, 'All set up and running!'
+    assert_equal(200, last_response.status, "Unexpected response: #{last_response.body}")
+    assert_includes(last_response.body, 'All set up and running!')
   end
 
-
   def test_not_found_route
-    get '/random'
+    get('/random')
+
+    assert_equal(404, last_response.status)
+  end
+
+  def test_react_home
+    Rubee::Configuration.setup(env = :test) { _1.react = { on: true, env: } }
+    get('/home')
 
-    assert_equal 404, last_response.status
+    assert_equal(200, last_response.status)
+    assert_includes(last_response.body, '<div id="app">')
+    assert_includes(last_response.body, 'bundle.js')
   end
 end

data/lib/tests/test_helper.rb

@@ -1,4 +1,4 @@
-require "bundler/setup"
+require 'bundler/setup'
 Bundler.require(:test)
 
 require 'minitest/autorun'
@@ -6,9 +6,7 @@ require 'rack/test'
 require_relative '../../lib/rubee'
 
 Rubee::Autoload.call
-Rubee::Configuration.setup(env=:test) do |config|
-  config.database_url = { url: "sqlite://lib/tests/test.db", env: }
+Rubee::Configuration.setup(env = :test) do |config|
+  config.database_url = { url: 'sqlite://lib/tests/test.db', env: }
 end
 Rubee::SequelObject.reconnect!
-
-