rails-crud-tools 0.6.8 → 0.6.10

data/lib/rails/crud/tools/cli.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "rubyXL"
+require "rubyXL/convenience_methods"
+require "active_record"
+require "yaml"
+require "erb"
+
+module RailsCrudTools
+  # The CLI class provides command-line interface methods for generating CRUD files and configurations.
+  # It includes methods to generate CRUD files, generate configuration files, and initialize the application.
+  class CLI
+    @application_loaded = false
+
+    class << self
+      def generate_crud_file
+        load_application unless @application_loaded
+
+        # 1. `bundle exec rails routes --expanded`の結果を取得
+        routes_output = `bundle exec rails routes --expanded`
+        config = Rails::Crud::Tools::CrudConfig.instance.config
+        font_name = config.crud_file.font_name
+
+        # 2. 取得した結果を区切り文字で分割
+        routes_lines = routes_output.split("\n").reject(&:empty?)
+        routes_data = []
+        current_route = {}
+
+        routes_lines.each do |line|
+          if line.start_with?("--[ Route")
+            routes_data << current_route unless current_route.empty?
+            current_route = {}
+          else
+            key, value = line.split("|").map(&:strip)
+            current_route[key] = value
+          end
+        end
+        routes_data << current_route unless current_route.empty?
+
+        # 3. 全テーブル名を取得し、アルファベット順にソート
+        table_names = ActiveRecord::Base.connection.tables.sort
+
+        # 4. `rubyXL`を使って`xlsx`ファイルに書き込み
+        workbook = RubyXL::Workbook.new
+        sheet = workbook[0]
+        sheet.sheet_name = config.crud_file.sheet_name
+
+        # ヘッダー行を追加
+        headers = %w[Prefix Verb URI Controller#Action crud_count] + table_names
+
+        headers.each_with_index do |header, index|
+          cell = sheet.add_cell(0, index, header)
+          cell.change_fill("00FFCC")
+          cell.change_font_name(font_name)
+          cell.change_font_bold(true)
+          apply_borders(cell)
+        end
+
+        start_col = "F"
+        end_col = ("A".."ZZ").to_a[table_names.length + 4] # 'F'から始まる列の範囲を計算
+
+        # データ行を追加
+        routes_data.each_with_index do |route, row_index|
+          headers.each_with_index do |header, col_index|
+            cell = sheet.add_cell(row_index + 1, col_index, route[header])
+            cell.change_font_name(font_name)
+            apply_borders(cell)
+          end
+
+          # 追加: crud_count列に式を設定
+          crud_count_formula = "=SUMPRODUCT(LEN(#{start_col}#{row_index + 2}:#{end_col}#{row_index + 2}))"
+          crud_count_cell = sheet.add_cell(row_index + 1, 4, "", crud_count_formula)
+          crud_count_cell.change_font_name(font_name)
+          apply_borders(crud_count_cell)
+        end
+
+        # app/jobs ディレクトリ内のジョブ名を取得
+        job_files = Dir.glob("app/jobs/**/*.rb")
+        job_classes = job_files.map do |file|
+          File.basename(file, ".rb").camelize
+        end.reject { |job| job == "ApplicationJob" }.sort
+
+        # ジョブ名を Controller#Action 列に追加
+        job_classes.each_with_index do |job, index|
+          headers.each_with_index do |header, col_index|
+            if header == "Controller#Action"
+              cell = sheet.add_cell(routes_data.length + 1 + index, col_index, job)
+              cell.change_font_name(font_name)
+            else
+              cell = sheet.add_cell(routes_data.length + 1 + index, col_index, nil)
+            end
+            apply_borders(cell)
+          end
+
+          # 追加: crud_count列に式を設定
+          crud_count_formula = "=SUMPRODUCT(LEN(#{start_col}#{routes_data.length + 2 + index}:#{end_col}#{routes_data.length + 2 + index}))"
+          crud_count_cell = sheet.add_cell(routes_data.length + 1 + index, 4, "", crud_count_formula)
+          crud_count_cell.change_font_name(font_name)
+          apply_borders(crud_count_cell)
+        end
+
+        # ヘッダーの背景色を設定
+        (0..headers.length - 1).each do |col_index|
+          sheet[0][col_index].change_fill(config.crud_file.header_bg_color)
+        end
+
+        # 列幅を設定
+        headers.each_with_index do |header, col_index|
+          max_length = header.length
+          (1..routes_data.length).each do |row_index|
+            cell_value = sheet[row_index][col_index].value.to_s
+            max_length = [max_length, cell_value.length].max
+          end
+          sheet.change_column_width(col_index, max_length + 2)
+        end
+
+        # ファイルを保存
+        crud_file = config.crud_file_path
+        base_dir = File.dirname(crud_file)
+
+        # base_dirが存在しなければ作成
+        FileUtils.mkdir_p(base_dir) unless Dir.exist?(base_dir)
+        workbook.write(crud_file)
+
+        puts "Output: #{crud_file}"
+      end
+
+      def generate_crud_config
+        load_application unless @application_loaded
+
+        table_names = ActiveRecord::Base.connection.tables.sort
+        table_start_col = table_names.any? ? table_names.first : "active_admin_comments"
+
+        config_content = <<~CONFIG
+          enabled: true
+          base_dir: doc
+          crud_file:
+            file_name: crud.xlsx
+            sheet_name: CRUD
+            header_bg_color: 00FFCC
+            font_name: Arial
+          method_col: Verb
+          action_col: Controller#Action
+          table_start_col: #{table_start_col}
+          sql_logging_enabled: true
+        CONFIG
+
+        File.write(".crudconfig.yml", config_content)
+        puts "Generated .crudconfig.yml file"
+      end
+
+      def init
+        generate_crud_config
+        generate_crud_file
+      end
+
+      private
+
+      def load_application
+        return if @application_loaded
+
+        path = Dir.pwd
+        $stderr.puts "Loading application in '#{File.basename(path)}'..."
+        environment_path = "#{path}/config/environment.rb"
+        require environment_path
+
+        if defined? Rails
+          Rails.application.eager_load!
+          Rails.application.config.eager_load_namespaces.each(&:eager_load!) if Rails.application.config.respond_to?(:eager_load_namespaces)
+        end
+
+        @application_loaded = true
+      rescue ::LoadError
+        error_message = <<~EOS
+          Tried to load your application environment from '#{environment_path}'.
+        EOS
+        puts error_message
+      rescue TypeError
+      end
+
+      def apply_borders(cell)
+        %i[top bottom left right].each do |side|
+          cell.change_border(side, "thin")
+        end
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/constants.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rails
+  module Crud
+    module Tools
+      module Constants
+        DEFAULT_METHOD = "default_method"
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/crud_config.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "singleton"
+
+module Rails
+  module Crud
+    module Tools
+      # The CrudConfig class is a singleton class responsible for loading and managing configuration settings from a YAML file (.crudconfig.yml).
+      # It ensures that the configuration is reloaded if the file is updated.
+      class CrudConfig
+        include Singleton
+
+        CONFIG_PATH = File.expand_path(".crudconfig.yml", Dir.pwd)
+
+        def initialize
+          @last_loaded_time = Time.at(0)
+        end
+
+        def self.config_path
+          CONFIG_PATH
+        end
+
+        def config
+          load_config if @config.nil? || config_file_updated?
+          @config
+        end
+
+        def load_config
+          @config = deep_convert_to_struct(YAML.load_file(CONFIG_PATH))
+          @last_loaded_time = File.mtime(CONFIG_PATH)
+        rescue Errno::ENOENT
+          raise "Configuration file not found: #{CONFIG_PATH}"
+        rescue Psych::SyntaxError => e
+          raise "YAML syntax error occurred while parsing #{CONFIG_PATH}: #{e.message}"
+        end
+
+        private
+
+        def config_file_updated?
+          File.mtime(CONFIG_PATH) > @last_loaded_time
+        end
+
+        # Recursively convert hash to Struct and add crud_file_path method
+        def deep_convert_to_struct(hash)
+          struct_class = Struct.new(*hash.keys.map(&:to_sym)) do
+            def crud_file_path
+              File.join(base_dir, crud_file.file_name)
+            end
+          end
+          struct_class.new(*hash.values.map { |value| value.is_a?(Hash) ? deep_convert_to_struct(value) : value })
+        end
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/crud_data.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "zip"
+require_relative "crud_logger"
+require_relative "constants"
+
+module Rails
+  module Crud
+    module Tools
+      # The CrudData class is responsible for loading and managing CRUD data from a file.
+      # It includes methods to load data, reload if needed, and retrieve specific information from the data.
+      class CrudData
+        include Singleton
+
+        attr_accessor :process_id, :crud_rows, :crud_cols, :workbook, :last_loaded_time
+
+        def initialize
+          @process_id = nil
+          @crud_rows = {}
+          @crud_cols = {}
+          @last_loaded_time = nil
+        end
+
+        def load_crud_data
+          config = CrudConfig.instance.config
+          return unless config.enabled
+
+          unless File.exist?(config.crud_file_path)
+            CrudLogger.logger.warn "CRUD file not found: #{config.crud_file_path}"
+            return false
+          end
+
+          @workbook = RubyXL::Parser.parse(config.crud_file_path)
+          @last_loaded_time = File.mtime(config.crud_file_path)
+          sheet = crud_sheet
+          headers = sheet[0].cells.map(&:value)
+
+          method_col_index = headers.index(config.method_col)
+          action_col_index = headers.index(config.action_col)
+          table_start_col_index = headers.index(config.table_start_col)
+
+          raise "Method column not found" unless method_col_index
+          raise "Action column not found" unless action_col_index
+          raise "Table start column not found" unless table_start_col_index
+
+          headers[table_start_col_index..].each_with_index do |table_name, index|
+            @crud_cols[table_name] = table_start_col_index + index
+          end
+
+          sheet.each_with_index do |row, index|
+            next if index.zero?
+
+            method = row[method_col_index]&.value.to_s.strip
+            method = Constants::DEFAULT_METHOD if method.empty?
+            value = row[action_col_index]&.value
+            split_value = value&.split
+            action = split_value&.first
+            next if action.nil?
+
+            @crud_rows[method] ||= {}
+            @crud_rows[method][action] = index
+          end
+        end
+
+        # CRUDデータが更新された場合に再読み込みする
+        def reload_if_needed
+          config = CrudConfig.instance.config
+          return unless config.enabled
+
+          return unless @last_loaded_time.nil? || File.mtime(config.crud_file_path) > @last_loaded_time
+
+          last_modified_by = get_last_modified_by(config.crud_file_path)
+          CrudLogger.logger.info "last modified by: #{last_modified_by}. process_id: #{process_id}"
+          return if process_id == last_modified_by
+
+          CrudLogger.logger.info "Reloading CRUD data due to file modification. last_loaded_time = #{@last_loaded_time}"
+          load_crud_data
+        end
+
+        # xlsxファイルの最終更新者を取得する
+        def get_last_modified_by(file_path)
+          last_modified_by = nil
+
+          Zip::File.open(file_path) do |zipfile|
+            doc_props = zipfile.find_entry("docProps/core.xml")
+            if doc_props
+              content = doc_props.get_input_stream.read
+              last_modified_by = content[%r{<cp:lastModifiedBy>(.*?)</cp:lastModifiedBy>}, 1]
+            else
+              CrudLogger.logger.warn "docProps/core.xml が見つかりませんでした。"
+            end
+          end
+
+          last_modified_by
+        end
+
+        # CRUDシートを取得する
+        def crud_sheet
+          sheet_name = CrudConfig.instance.config.crud_file.sheet_name
+          sheet = @workbook[sheet_name]
+          raise "CRUD sheet '#{sheet_name}' not found" if sheet.nil?
+
+          sheet
+        end
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/crud_logger.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "logger"
+require "singleton"
+
+module Rails
+  module Crud
+    module Tools
+      # The CrudLogger class is responsible for logging CRUD operations to a file.
+      # It uses the Singleton pattern to ensure only one instance of the logger exists.
+      class CrudLogger
+        include Singleton
+
+        attr_reader :logger
+
+        def initialize
+          @logger = Logger.new("log/crud.log")
+        end
+
+        def self.logger
+          instance.logger
+        end
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/crud_notifications.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Rails
+  module Crud
+    # The Tools module provides utility methods for setting up notifications and processing SQL queries.
+    # It includes methods to subscribe to ActiveSupport notifications and handle different types of SQL operations.
+    module Tools
+      def self.setup_notifications
+        # 初回呼び出し時に @subscribed を false に設定
+        @subscribed ||= false
+        # 既に通知が登録されている場合は処理を中断
+        return if @subscribed
+
+        if CrudConfig.instance.config.enabled
+          # SQL クエリを監視する
+          ActiveSupport::Notifications.subscribe(/sql.active_record/) do |_name, _started, _finished, _unique_id, data|
+            process_sql(data)
+          end
+        end
+
+        # 通知の登録が完了した後に @subscribed を true に設定
+        @subscribed = true
+      end
+
+      OPERATION_UNKNOWN = "Unknown"
+
+      def self.process_sql(data)
+        return unless data[:sql] =~ /\A\s*(INSERT|UPDATE|DELETE|SELECT)/i
+
+        case data[:sql]
+        when /\bINSERT INTO\b.*\bSELECT\b/i
+          handle_insert_select(data)
+        when /\bUPDATE\b.*\bSET\b.*\bSELECT\b/i
+          handle_update_select(data)
+        when /\bDELETE\b.*\bEXISTS\b.*\bSELECT\b/i
+          handle_delete_select(data)
+        else
+          handle_general_sql(data)
+        end
+
+        return unless CrudConfig.instance.config.sql_logging_enabled
+
+        # SQL ログを出力
+        CrudLogger.logger.info "#{data[:name]} - #{data[:sql]}"
+      end
+
+      def self.handle_insert_select(data)
+        # INSERT INTO ... SELECT の特別な処理
+        insert_table = data[:sql].match(/INSERT INTO\s+`?(\w+)`?/i)[1]
+        select_tables = data[:sql].scan(/SELECT .* FROM\s+`?(\w+)`?(?:\s*,\s*`?(\w+)`?)*|JOIN\s+`?(\w+)`?/i).flatten.compact.uniq
+
+        key, method = determine_key_and_method
+        if key.nil? || method.nil?
+          CrudLogger.logger.warn "Request not found. #{data[:name]} - #{data[:sql]}"
+          return
+        end
+
+        CrudOperations.instance.add_operation(method, key, insert_table, "C")
+        select_tables.each do |select_table|
+          CrudOperations.instance.add_operation(method, key, select_table, "R")
+        end
+      end
+
+      def self.handle_update_select(data)
+        # UPDATE ... SET ... SELECT の特別な処理
+        update_table = data[:sql].match(/UPDATE\s+`?(\w+)`?/i)[1]
+        select_tables = data[:sql].scan(/SELECT .* FROM\s+`?(\w+)`?(?:\s*,\s*`?(\w+)`?)*|JOIN\s+`?(\w+)`?/i).flatten.compact.uniq
+
+        key, method = determine_key_and_method
+        if key.nil? || method.nil?
+          CrudLogger.logger.warn "Request not found. #{data[:name]} - #{data[:sql]}"
+          return
+        end
+
+        CrudOperations.instance.add_operation(method, key, update_table, "U")
+        select_tables.each do |select_table|
+          CrudOperations.instance.add_operation(method, key, select_table, "R")
+        end
+      end
+
+      def self.handle_delete_select(data)
+        # DELETE ... WHERE EXISTS ... SELECT の特別な処理
+        delete_table = data[:sql].match(/DELETE FROM\s+`?(\w+)`?/i)[1]
+        select_tables = data[:sql].scan(/SELECT .* FROM\s+`?(\w+)`?(?:\s*,\s*`?(\w+)`?)*|JOIN\s+`?(\w+)`?/i).flatten.compact.uniq
+
+        key, method = determine_key_and_method
+        if key.nil? || method.nil?
+          CrudLogger.logger.warn "Request not found. #{data[:name]} - #{data[:sql]}"
+          return
+        end
+
+        CrudOperations.instance.add_operation(method, key, delete_table, "D")
+        select_tables.each do |select_table|
+          CrudOperations.instance.add_operation(method, key, select_table, "R")
+        end
+      end
+
+      def self.handle_general_sql(data)
+        operation = if (match = data[:sql].match(/\A\s*(INSERT|UPDATE|DELETE|SELECT)/i))
+                      case match[1].upcase
+                      when "INSERT" then "C"
+                      when "SELECT" then "R"
+                      when "UPDATE" then "U"
+                      when "DELETE" then "D"
+                      else OPERATION_UNKNOWN
+                      end
+                    else
+                      OPERATION_UNKNOWN
+                    end
+
+        if operation == OPERATION_UNKNOWN
+          warn "Warning: Unknown SQL operation. #{data[:name]} - #{data[:sql]}"
+          return
+        end
+
+        table_names = data[:sql].scan(/(?:INSERT INTO|UPDATE|DELETE FROM|FROM|JOIN)\s+`?(\w+)`?(?:\s*,\s*`?(\w+)`?)*/i).flatten.compact.uniq
+        if table_names.empty?
+          # テーブル名が見つからない場合は警告を出力
+          CrudLogger.logger.warn "Table name not found in SQL: #{data[:sql]}"
+          return
+        end
+
+        key, method = determine_key_and_method
+        if key.nil? || method.nil?
+          CrudLogger.logger.warn "Request not found. #{data[:name]} - #{data[:sql]}"
+          return
+        end
+
+        # テーブル名を取得して CRUD 操作に追加
+        table_names.each do |table_name|
+          CrudOperations.instance.add_operation(method, key, table_name, operation)
+        end
+      end
+
+      # キーとメソッドを決定する
+      def self.determine_key_and_method
+        request = Thread.current[:crud_request]
+        sidekiq_job_class = Thread.current[:crud_sidekiq_job_class]
+
+        if request
+          method = request.request_method
+          controller = request.params["controller"]
+          action = request.params["action"]
+          key = "#{controller}##{action}"
+        elsif sidekiq_job_class
+          key = sidekiq_job_class
+          method = Constants::DEFAULT_METHOD
+        else
+          return nil
+        end
+
+        [key, method]
+      end
+    end
+  end
+end

data/lib/rails/crud/tools/crud_operations.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "crud_logger"
+require_relative "constants"
+
+module Rails
+  module Crud
+    module Tools
+      # The CrudOperations class is responsible for managing CRUD operations for different tables.
+      # It stores operations in a nested hash structure and provides methods to add and log operations.
+      class CrudOperations
+        include Singleton
+
+        attr_accessor :table_operations, :logs
+
+        def initialize
+          @table_operations = Hash.new do |hash, method|
+            hash[method] = Hash.new do |h, key|
+              h[key] = Hash.new do |hh, table|
+                hh[table] = []
+              end
+            end
+          end
+        end
+
+        def add_operation(method, key, table_name, operation)
+          # @table_operations[method]が存在しない場合は初期化
+          @table_operations[method] ||= {}
+          # @table_operations[method][key]が存在しない場合は初期化
+          @table_operations[method][key] ||= {}
+          # @table_operations[method][key][table_name]が存在しない場合は初期化
+          @table_operations[method][key][table_name] ||= []
+
+          @table_operations[method][key][table_name] << operation unless @table_operations[method][key][table_name].include?(operation)
+        end
+
+        def log_operations(method, key)
+          CrudLogger.logger.info "\nSummary: Method: #{method}, Key: #{key}"
+
+          @table_operations[method][key].each do |table_name, operations|
+            CrudLogger.logger.info "#{table_name} - #{operations.join(", ")}"
+          end
+        end
+
+        def table_operations_present?(method, key)
+          return false if @table_operations[method].nil?
+          return false if @table_operations[method][key].nil?
+
+          !@table_operations[method][key].empty?
+        end
+      end
+    end
+  end
+end