ru.Bee 1.5.4 → 1.7.0

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)

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,160 @@
+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] || {}
+      @app_name = options[:app_name] || :app
+      @namespace = @app_name == :app ? '' : "#{@app_name.camelize}::"
+    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_name.to_s.snakeize}/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 #{@namespace}#{@model_name.camelize} < 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_name}/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 #{@namespace}#{@base_name.camelize}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
+      prefix = @namespace == "" ? "" : "#{@app_name.snakeize}_"
+      if @react[:view_name]
+        view_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "#{@app_name}/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(/\.(.*)+$/, '').camelize}() {
+
+            return (
+              <div>
+                <h2>#{@react[:view_name].gsub(/\.(.*)+$/, '').camelize} view</h2>
+              </div>
+            );
+          }
+        JS
+      else # erb
+        view_file = File.join(
+          Rubee::APP_ROOT, Rubee::LIB,
+          "#{@app_name}/views/#{prefix}#{@plural_name}_#{@action_name}.erb"
+        )
+        content = <<~ERB
+          <h1>#{prefix}#{@plural_name}_#{@action_name} View</h1>
+        ERB
+      end
+
+      name = @react[:view_name] || "#{prefix}#{@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
+      table_name = @namespace == "" ? @plural_name : "#{@namespace.snakeize}_#{@plural_name}"
+      db_file = File.join(Rubee::APP_ROOT, Rubee::LIB, "db/create_#{table_name}.rb")
+      if File.exist?(db_file)
+        puts "DB file for #{table_name} already exists. Remove it if you want to regenerate"
+        return
+      end
+
+      content = <<~RUBY
+        class Create#{table_name.camelize}
+          def call
+            return if Rubee::SequelObject::DB.tables.include?(:#{table_name})
+
+            Rubee::SequelObject::DB.create_table(:#{table_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 #{table_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/database_objectable.rb

@@ -12,7 +12,7 @@ module Rubee
 
     module ClassMethods
       def pluralize_class_name
-        name.pluralize.downcase
+        name.pluralize.downcase.snakeize
       end
 
       def accessor_names

data/lib/rubee/models/sequel_object.rb

@@ -2,6 +2,7 @@ module Rubee
   class SequelObject
     include Rubee::DatabaseObjectable
     using ChargedString
+    using ChargedHash
 
     def destroy(cascade: false, **_options)
       if cascade
@@ -23,7 +24,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 +108,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
@@ -180,7 +180,7 @@ module Rubee
       def serialize(suquel_dataset, klass = nil)
         klass ||= self
         suquel_dataset.map do |record_hash|
-          target_klass_fields = DB[klass.name.pluralize.downcase.to_sym].columns
+          target_klass_fields = DB[klass.name.pluralize.downcase.camelize.to_sym].columns
           klass_attributes = record_hash.filter { target_klass_fields.include?(_1) }
           klass.new(**klass_attributes)
         end

data/lib/rubee/router.rb

@@ -0,0 +1,40 @@
+module Rubee
+  class Router
+    include Singleton
+
+    HTTP_METHODS = %i[get post put patch delete head connect options trace].freeze unless defined?(HTTP_METHODS)
+
+    attr_reader :request, :routes
+
+    @routes = []
+
+    class << self
+      def draw
+        yield(self) if block_given?
+      end
+
+      def route_for(request)
+        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 = /^#{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
+end