droppable_table 0.1.0

data/lib/droppable_table/analyzer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "set"
+require "json"
+
+module DroppableTable
+  class Analyzer
+    attr_reader :config, :schema_tables, :model_tables, :sti_base_tables,
+                :habtm_tables, :droppable_tables, :excluded_tables
+
+    def initialize(config = nil)
+      @config = config.is_a?(Config) ? config : Config.new(config)
+      @schema_tables = {}      # DB name => array of table info
+      @model_tables = Set.new  # Table names with corresponding models
+      @sti_base_tables = Set.new # STI base tables
+      @habtm_tables = Set.new  # HABTM join tables
+      @droppable_tables = []   # Potentially droppable tables
+      @excluded_tables = @config.all_excluded_tables # Rails internal + gems + user defined
+      @model_collector = nil
+      @schema_format = nil
+    end
+
+    def analyze
+      check_migration_status   # Check for pending migrations
+      detect_schema_format     # Detect schema.rb vs structure.sql
+      collect_schema_tables    # Collect tables from all schema files
+      eager_load_models        # Ensure all models are loaded
+      collect_model_tables     # Collect from ActiveRecord::Base.descendants
+      collect_sti_tables       # Detect STI hierarchies
+      collect_habtm_tables     # Detect HABTM associations
+      identify_droppable_tables # Identify droppable tables
+
+      self
+    end
+
+    def report(format: :text)
+      # TODO: Implement report generation
+      case format
+      when :json
+        generate_json_report
+      else
+        generate_text_report
+      end
+    end
+
+    private
+
+    def load_excluded_tables
+      @config.all_excluded_tables
+    end
+
+    def check_migration_status
+      # Skip migration check in test environment or if Rails/ActiveRecord not available
+      return if ENV["RAILS_ENV"] == "test"
+      return unless defined?(ActiveRecord::Base) && defined?(Rails)
+
+      begin
+        # Ensure database connection exists
+        ActiveRecord::Base.connection
+
+        # Try to check for pending migrations using available methods
+        if ActiveRecord::Base.connection.respond_to?(:migration_context)
+          # Rails 6.0+
+          context = ActiveRecord::Base.connection.migration_context
+          if context.needs_migration?
+            raise MigrationPendingError, "There are pending migrations. Please run migrations before analyzing."
+          end
+        end
+        # If migration check methods aren't available, skip the check
+      rescue ActiveRecord::NoDatabaseError
+        raise Error, "Database does not exist. Please create and migrate the database first."
+      rescue StandardError
+        # If any other error occurs during migration check, skip it
+        # This ensures the tool remains functional even with different Rails versions
+      end
+    end
+
+    def detect_schema_format
+      schema_rb = File.join(Dir.pwd, "db", "schema.rb")
+      structure_sql = File.join(Dir.pwd, "db", "structure.sql")
+
+      if File.exist?(schema_rb)
+        @schema_format = :ruby
+      elsif File.exist?(structure_sql)
+        @schema_format = :sql
+      else
+        raise SchemaNotFoundError, "No schema.rb or structure.sql found in db/ directory"
+      end
+    end
+
+    def collect_schema_tables
+      # Find all schema files (including from multiple databases)
+      schema_files = find_schema_files
+
+      schema_files.each do |schema_file|
+        parser = SchemaParser.new(schema_file)
+        tables = parser.parse
+
+        # Determine database name from file path
+        db_name = extract_database_name(schema_file)
+        @schema_tables[db_name] = tables
+      end
+    end
+
+    def find_schema_files
+      files = []
+
+      # Main schema file
+      main_schema = File.join(Dir.pwd, "db", @schema_format == :sql ? "structure.sql" : "schema.rb")
+      files << main_schema if File.exist?(main_schema)
+
+      # Look for additional schema files (e.g., secondary_schema.rb)
+      Dir.glob(File.join(Dir.pwd, "db", "*_schema.rb")).each do |file|
+        files << file unless file == main_schema
+      end
+
+      files
+    end
+
+    def extract_database_name(schema_file)
+      basename = File.basename(schema_file, ".*")
+
+      case basename
+      when "schema", "structure"
+        "primary"
+      else
+        # Extract database name from filename like 'secondary_schema.rb'
+        basename.sub(/_schema$/, "")
+      end
+    end
+
+    def eager_load_models
+      @model_collector = ModelCollector.new
+      @model_collector.collect
+    end
+
+    def collect_model_tables
+      return unless @model_collector
+
+      @model_tables = @model_collector.table_names
+    end
+
+    def collect_sti_tables
+      return unless @model_collector
+
+      @sti_base_tables = @model_collector.sti_base_tables
+    end
+
+    def collect_habtm_tables
+      return unless @model_collector
+
+      @habtm_tables = @model_collector.habtm_tables
+    end
+
+    def identify_droppable_tables
+      all_schema_tables = @schema_tables.values.flatten.to_set { |t| t[:name] }
+
+      # Tables that exist in schema but have no corresponding model
+      @droppable_tables = all_schema_tables.reject do |table|
+        # Skip if table is excluded
+        @excluded_tables.include?(table) ||
+          # Skip if table has a model
+          @model_tables.include?(table) ||
+          # Skip if it's a HABTM join table
+          @habtm_tables.include?(table) ||
+          # Skip if it's an STI base table (these are important)
+          @sti_base_tables.include?(table)
+      end.to_a.sort
+    end
+
+    def generate_json_report
+      {
+        summary: {
+          total_tables: @schema_tables.values.flatten.map { |t| t[:name] }.uniq.size,
+          tables_with_models: @model_tables.size,
+          sti_base_tables: @sti_base_tables.size,
+          habtm_tables: @habtm_tables.size,
+          excluded_tables: @excluded_tables.size,
+          droppable_tables: @droppable_tables.size
+        },
+        droppable_tables: @droppable_tables,
+        tables_by_database: @schema_tables.transform_values { |tables| tables.map { |t| t[:name] } },
+        model_tables: @model_tables.to_a.sort,
+        sti_base_tables: @sti_base_tables.to_a.sort,
+        habtm_tables: @habtm_tables.to_a.sort,
+        excluded_tables: @excluded_tables.to_a.sort
+      }
+    end
+
+    def generate_text_report
+      report = []
+      report << "DroppableTable Analysis Report"
+      report << ("=" * 40)
+      report << ""
+
+      # Summary
+      all_tables = @schema_tables.values.flatten.map { |t| t[:name] }.uniq
+      report << "Summary:"
+      report << "  Total tables in schema: #{all_tables.size}"
+      report << "  Tables with models: #{@model_tables.size}"
+      report << "  STI base tables: #{@sti_base_tables.size}"
+      report << "  HABTM join tables: #{@habtm_tables.size}"
+      report << "  Excluded tables: #{@excluded_tables.size}"
+      report << "  Potentially droppable: #{@droppable_tables.size}"
+      report << ""
+
+      # Droppable tables
+      if @droppable_tables.empty?
+        report << "No droppable tables found."
+      else
+        report << "Potentially droppable tables:"
+        @droppable_tables.each do |table|
+          report << "  - #{table}"
+        end
+      end
+      report << ""
+
+      # Tables by database
+      if @schema_tables.size > 1
+        report << "Tables by database:"
+        @schema_tables.each do |db_name, tables|
+          report << "  #{db_name}: #{tables.size} tables"
+        end
+        report << ""
+      end
+
+      report.join("\n")
+    end
+  end
+end

data/lib/droppable_table/cli.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+
+module DroppableTable
+  class CLI < Thor
+    package_name "DroppableTable"
+
+    desc "analyze", "Analyze Rails application for potentially droppable tables"
+    option :json, type: :boolean, desc: "Output results in JSON format"
+    option :config, type: :string, desc: "Path to configuration file"
+    option :strict, type: :boolean, desc: "Strict mode for CI (fail if new droppable tables found)"
+    def analyze
+      # Load configuration
+      config = Config.new(options[:config])
+
+      # Run analysis
+      analyzer = Analyzer.new(config)
+      analyzer.analyze
+
+      # Generate report
+      if options[:json]
+        puts JSON.pretty_generate(analyzer.report(format: :json))
+      else
+        puts analyzer.report(format: :text)
+      end
+
+      # Handle strict mode
+      handle_strict_mode(analyzer, config) if options[:strict] && config.strict_mode_enabled?
+
+      # Exit with appropriate code
+      exit(analyzer.droppable_tables.empty? ? 0 : 1) if options[:strict]
+    rescue RailsNotFoundError => e
+      error_exit("Rails application not found: #{e.message}")
+    rescue MigrationPendingError => e
+      error_exit("Migration pending: #{e.message}")
+    rescue SchemaNotFoundError => e
+      error_exit("Schema not found: #{e.message}")
+    rescue StandardError => e
+      error_exit("Error: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+    end
+
+    desc "version", "Display version"
+    def version
+      puts "DroppableTable #{DroppableTable::VERSION}"
+    end
+    map %w[-v --version] => :version
+
+    def self.exit_on_failure?
+      true
+    end
+
+    default_task :analyze
+
+    private
+
+    def handle_strict_mode(analyzer, config)
+      baseline_file = config.baseline_file
+      current_droppable = analyzer.droppable_tables.sort
+
+      if File.exist?(baseline_file)
+        baseline = JSON.parse(File.read(baseline_file))["droppable_tables"] || []
+        new_tables = current_droppable - baseline
+
+        if new_tables.any?
+          puts "\nERROR: New droppable tables found in strict mode:"
+          new_tables.each { |table| puts "  - #{table}" }
+          puts "\nTo update the baseline, run without --strict flag."
+          exit(1)
+        end
+      else
+        # Create baseline file
+        File.write(baseline_file, JSON.pretty_generate({
+                                                         droppable_tables: current_droppable,
+                                                         generated_at: Time.now.iso8601
+                                                       }))
+        puts "\nCreated baseline file: #{baseline_file}"
+      end
+    end
+
+    def error_exit(message)
+      warn "ERROR: #{message}"
+      exit(1)
+    end
+  end
+end

data/lib/droppable_table/config.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module DroppableTable
+  class Config
+    DEFAULT_CONFIG_FILE = "droppable_table.yml"
+    RAILS_INTERNAL_TABLES_FILE = File.expand_path("../../config/rails_internal_tables.yml", __dir__)
+    KNOWN_GEMS_FILE = File.expand_path("../../config/known_gems.yml", __dir__)
+
+    attr_reader :excluded_tables, :excluded_gems, :strict_mode, :config_file_path
+
+    def initialize(config_file_path = nil)
+      @config_file_path = config_file_path || DEFAULT_CONFIG_FILE
+      @excluded_tables = Set.new
+      @excluded_gems = Set.new
+      @strict_mode = {}
+
+      load_default_config
+      load_user_config if File.exist?(@config_file_path)
+    end
+
+    def rails_internal_tables
+      @rails_internal_tables ||= load_yaml_file(RAILS_INTERNAL_TABLES_FILE)
+    end
+
+    def known_gem_tables
+      @known_gem_tables ||= load_yaml_file(KNOWN_GEMS_FILE)
+    end
+
+    def all_excluded_tables
+      Set.new(excluded_tables) + Set.new(rails_internal_tables) + gem_excluded_tables
+    end
+
+    def strict_mode_enabled?
+      strict_mode["enabled"] == true
+    end
+
+    def baseline_file
+      strict_mode["baseline_file"] || ".droppable_table_baseline.json"
+    end
+
+    private
+
+    def load_default_config
+      @rails_internal_tables = load_yaml_file(RAILS_INTERNAL_TABLES_FILE) || []
+      @known_gem_tables = load_yaml_file(KNOWN_GEMS_FILE) || {}
+    end
+
+    def load_user_config
+      # TODO: Load user configuration from YAML file
+      config = load_yaml_file(@config_file_path)
+      return unless config.is_a?(Hash)
+
+      @excluded_tables = Set.new(config["excluded_tables"] || [])
+      @excluded_gems = Set.new(config["excluded_gems"] || [])
+      @strict_mode = config["strict_mode"] || {}
+    end
+
+    def load_yaml_file(path)
+      return [] unless File.exist?(path)
+
+      content = File.read(path)
+      YAML.safe_load(content, permitted_classes: [Symbol], aliases: true) || []
+    rescue StandardError
+      []
+    end
+
+    def gem_excluded_tables
+      tables = Set.new
+
+      excluded_gems.each do |gem_name|
+        tables += known_gem_tables[gem_name] if known_gem_tables.is_a?(Hash) && known_gem_tables[gem_name]
+      end
+
+      tables
+    end
+  end
+end

data/lib/droppable_table/model_collector.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "set"
+
+module DroppableTable
+  class ModelCollector
+    attr_reader :models, :table_mapping
+
+    def initialize
+      @models = []
+      @table_mapping = {} # model_class => table_name
+    end
+
+    def collect
+      ensure_rails_loaded
+      eager_load_all_models
+      collect_all_descendants
+      build_table_mapping
+
+      self
+    end
+
+    def table_names
+      Set.new(table_mapping.values)
+    end
+
+    def sti_base_tables
+      sti_tables = Set.new
+
+      models.each do |model|
+        next if model.abstract_class?
+
+        # Check if this model uses STI (has a 'type' column)
+        sti_tables << model.table_name if model.columns_hash.key?("type") && model.base_class == model
+      rescue StandardError
+        # Skip models that can't be inspected
+      end
+
+      sti_tables
+    end
+
+    def habtm_tables
+      habtm_join_tables = Set.new
+
+      models.each do |model|
+        next if model.abstract_class?
+
+        # Find HABTM associations
+        model.reflect_on_all_associations(:has_and_belongs_to_many).each do |association|
+          join_table = association.join_table
+          habtm_join_tables << join_table if join_table
+        end
+      rescue StandardError
+        # Skip models that can't be inspected
+      end
+
+      habtm_join_tables
+    end
+
+    private
+
+    def ensure_rails_loaded
+      return if defined?(Rails)
+
+      # Try to load Rails if we're in a Rails directory
+      rails_path = File.join(Dir.pwd, "config", "environment.rb")
+      unless File.exist?(rails_path)
+        raise RailsNotFoundError, "Rails not found. Please run this command from a Rails application directory."
+      end
+
+      ENV["RAILS_ENV"] ||= "development"
+      require rails_path
+    end
+
+    def eager_load_all_models
+      return unless defined?(Rails)
+
+      # Eager load the application to ensure all models are loaded
+      Rails.application.eager_load!
+
+      # Also load models from engines
+      Rails::Engine.subclasses.each do |engine|
+        engine.instance.eager_load!
+      end
+    end
+
+    def collect_all_descendants
+      return unless defined?(ActiveRecord::Base)
+
+      # Collect all ActiveRecord descendants, excluding abstract classes
+      @models = ActiveRecord::Base.descendants.reject(&:abstract_class?)
+    end
+
+    def build_table_mapping
+      models.each do |model|
+        next if model.abstract_class?
+
+        begin
+          # Check if model responds to table_name
+          if model.respond_to?(:table_name)
+            table_name = model.table_name
+            @table_mapping[model] = table_name if table_name && !table_name.empty?
+          end
+        rescue StandardError
+          # Skip models that raise errors when accessing table_name
+          # This can happen with models that have database connection issues
+        end
+      end
+    end
+
+    def resolve_table_name(model)
+      return nil unless model.respond_to?(:table_name)
+
+      # Get the table name, considering custom configurations
+      table_name = model.table_name
+
+      # Apply any table name prefix/suffix if configured
+      if model.respond_to?(:table_name_prefix) && model.table_name_prefix
+        table_name = "#{model.table_name_prefix}#{table_name}"
+      end
+
+      if model.respond_to?(:table_name_suffix) && model.table_name_suffix
+        table_name = "#{table_name}#{model.table_name_suffix}"
+      end
+
+      table_name
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/droppable_table/schema_parser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module DroppableTable
+  class SchemaParser
+    attr_reader :schema_path, :format
+
+    def initialize(schema_path)
+      @schema_path = schema_path
+      @format = detect_format
+    end
+
+    def parse
+      case format
+      when :ruby
+        parse_ruby_schema
+      when :sql
+        parse_sql_schema
+      else
+        raise SchemaNotFoundError, "Unknown schema format: #{schema_path}"
+      end
+    end
+
+    private
+
+    def detect_format
+      # TODO: Detect schema format based on file extension
+      case File.basename(schema_path)
+      when /\.rb$/
+        :ruby
+      when /\.sql$/
+        :sql
+      end
+    end
+
+    def parse_ruby_schema
+      return [] unless File.exist?(schema_path)
+
+      tables = []
+      File.readlines(schema_path).each do |line|
+        next unless (match = line.match(/^\s*create_table\s+"([^"]+)"/))
+
+        table_name = match[1]
+        tables << {
+          name: table_name,
+          type: "table"
+        }
+      end
+
+      tables
+    end
+
+    def parse_sql_schema
+      # TODO: Parse structure.sql
+      []
+    end
+  end
+end

data/lib/droppable_table/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DroppableTable
+  VERSION = "0.1.0"
+end

data/lib/droppable_table.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "droppable_table/version"
+require_relative "droppable_table/cli"
+require_relative "droppable_table/analyzer"
+require_relative "droppable_table/schema_parser"
+require_relative "droppable_table/model_collector"
+require_relative "droppable_table/config"
+
+module DroppableTable
+  class Error < StandardError; end
+  class RailsNotFoundError < Error; end
+  class MigrationPendingError < Error; end
+  class SchemaNotFoundError < Error; end
+end