rails_map 1.1.0

data/lib/generators/rails_map/install_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module RailsMap
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Installs RailsMap with environment-based authentication (use --skip-auth to disable)"
+      
+      class_option :skip_auth, type: :boolean, default: false, desc: "Skip authentication setup"
+      class_option :skip_routes, type: :boolean, default: false, desc: "Skip adding route mount"
+      
+      def copy_initializer
+        template 'initializer.rb', 'config/initializers/rails_map.rb'
+      end
+      
+      def add_route_mount
+        unless options[:skip_routes]
+          route "mount RailsMap::Engine, at: '/api-doc'"
+        end
+      end
+      
+      def add_to_gitignore
+        gitignore_path = '.gitignore'
+        
+        if File.exist?(gitignore_path)
+          gitignore_content = File.read(gitignore_path)
+          
+          unless gitignore_content.include?('doc/api')
+            append_to_file gitignore_path do
+              "\n# Ignore generated documentation\n/doc/api\n"
+            end
+          end
+        else
+          create_file gitignore_path, "# Ignore generated documentation\n/doc/api\n"
+        end
+      end
+      
+      def show_readme
+        readme 'README' if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/rails_map/templates/README

@@ -0,0 +1,47 @@
+===============================================================================
+
+RailsMap has been installed!
+
+✓ Configuration file created at:
+    config/initializers/rails_map.rb
+
+<% unless options[:skip_routes] %>
+✓ Route mounted in config/routes.rb:
+    mount RailsMap::Engine, at: '/api-doc'
+<% end %>
+
+✓ Added /doc/api to .gitignore
+
+<% unless options[:skip_auth] %>
+Authentication has been ENABLED (default)
+
+Next steps:
+1. Set environment variables:
+     export RAILS_MAP_USERNAME=admin
+     export RAILS_MAP_PASSWORD=your_secure_password
+
+   Or add to .env file:
+     RAILS_MAP_USERNAME=admin
+     RAILS_MAP_PASSWORD=your_secure_password
+
+2. Restart your server and visit /api-doc
+   You'll be prompted to login with your credentials
+
+To disable authentication, run:
+  rails destroy rails_map:install
+  rails g rails_map:install --skip-auth
+<% else %>
+Authentication has been DISABLED (--skip-auth flag used)
+
+To enable authentication:
+1. Set RAILS_MAP_USERNAME and RAILS_MAP_PASSWORD environment variables
+2. Uncomment authentication in config/initializers/rails_map.rb
+<% end %>
+
+Documentation:
+  Visit http://localhost:3000/api-doc after starting your server
+
+For more information, see:
+  https://rails-map.netlify.app
+
+===============================================================================

data/lib/generators/rails_map/templates/initializer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RailsMap.configure do |config|
+  # Application name displayed in the documentation
+  config.app_name = '<%= Rails.application.class.module_parent_name %>'
+  
+  # Theme color (any valid CSS color)
+  config.theme_color = '#3B82F6'
+  
+  # Output directory for static HTML generation
+  config.output_dir = Rails.root.join('doc', 'api').to_s
+  
+  # Include timestamp columns (created_at, updated_at) in model documentation
+  config.include_timestamps = true
+  
+  # Include model validations in documentation
+  config.include_validations = true
+  
+  # Include model scopes in documentation
+  config.include_scopes = true
+
+  # ============================================================================
+  # AUTHENTICATION
+  # ============================================================================
+  # Set RAILS_MAP_USERNAME and RAILS_MAP_PASSWORD environment variables
+  # to enable authentication. Leave them unset for public access.
+
+  <% unless options[:skip_auth] %>
+    config.authenticate_with = proc {
+      RailsMap::Auth.authenticate(self)
+    }
+  <% else %>
+    # Authentication disabled via --skip-auth flag
+    # To enable: Set RAILS_MAP_USERNAME and RAILS_MAP_PASSWORD environment variables
+    # and uncomment the line below:
+    # config.authenticate_with = proc { RailsMap::Auth.authenticate(self) }
+  <% end %>
+end

data/lib/generators/rails_map/templates/migration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateRailsMapUsers < ActiveRecord::Migration[7.0]
+  def change
+    create_table :rails_map_users do |t|
+      t.string :username, null: false
+      t.string :password_digest, null: false
+      
+      t.timestamps
+    end
+    
+    add_index :rails_map_users, :username, unique: true
+  end
+end

data/lib/rails_map/auth.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsMap
+  module Auth
+    class << self
+      # Authenticates using environment variables with HTTP Basic Auth
+      def authenticate(controller)
+        controller.authenticate_or_request_with_http_basic('Documentation') do |username, password|
+          username == (ENV['RAILS_MAP_USERNAME'] || 'admin') && 
+          password == (ENV['RAILS_MAP_PASSWORD'] || 'password')
+        end
+      end
+    end
+  end
+end

data/lib/rails_map/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RailsMap
+  class Configuration
+    attr_accessor :output_dir, :app_name, :include_timestamps, :include_validations,
+                  :include_scopes, :theme_color, :authenticate_with
+
+    def initialize
+      @output_dir = default_output_dir
+      @app_name = default_app_name
+      @include_timestamps = true
+      @include_validations = true
+      @include_scopes = true
+      @theme_color = "#3B82F6" # Default blue
+    end
+
+    private
+
+    def default_output_dir
+      if defined?(Rails)
+        Rails.root.join("doc", "api").to_s
+      else
+        File.join(Dir.pwd, "doc", "api")
+      end
+    end
+
+    def default_app_name
+      if defined?(Rails)
+        Rails.application.class.module_parent_name
+      else
+        "Rails Application"
+      end
+    end
+  end
+end

data/lib/rails_map/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RailsMap
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsMap
+
+    initializer "rails_map.assets" do |app|
+      # No external assets needed - CSS is inline
+    end
+  end
+end

data/lib/rails_map/generators/html_generator.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+
+module RailsMap
+  module Generators
+    class HtmlGenerator
+      attr_reader :routes, :models, :output_dir
+
+      TEMPLATES_DIR = File.expand_path("../../../templates", __dir__)
+
+      def initialize(routes:, models:, output_dir:)
+        @routes = routes
+        @models = models
+        @output_dir = output_dir
+      end
+
+      def generate_all
+        generate_index
+        generate_routes_page
+        generate_controller_pages
+        generate_model_pages
+      end
+
+      private
+
+      def generate_index
+        content = render_template("index", binding_for_index)
+        write_page("index.html", "Home", content)
+      end
+
+      def generate_routes_page
+        content = render_template("routes", binding_for_routes)
+        write_page("routes.html", "All Routes", content)
+      end
+
+      def generate_controller_pages
+        routes.each do |controller_name, data|
+          content = render_template("controller", binding_for_controller(controller_name, data))
+          filename = "controllers/#{controller_name.gsub('/', '_')}.html"
+          write_page(filename, "#{controller_name.camelize}Controller", content)
+        end
+      end
+
+      def generate_model_pages
+        models.each do |name, model|
+          content = render_template("model", binding_for_model(model))
+          filename = "models/#{name.underscore.gsub('/', '_')}.html"
+          write_page(filename, name, content)
+        end
+      end
+
+      def render_template(name, template_binding)
+        template_path = File.join(TEMPLATES_DIR, "#{name}.html.erb")
+        template = ERB.new(File.read(template_path), trim_mode: "-")
+        template.result(template_binding)
+      end
+
+      def write_page(filename, title, content)
+        layout_path = File.join(TEMPLATES_DIR, "layout.html.erb")
+        layout = ERB.new(File.read(layout_path), trim_mode: "-")
+
+        html = layout.result(binding_for_layout(title, content))
+
+        filepath = File.join(output_dir, filename)
+        FileUtils.mkdir_p(File.dirname(filepath))
+        File.write(filepath, html)
+      end
+
+      def binding_for_layout(title, content)
+        app_name = RailsMap.configuration.app_name
+        theme_color = RailsMap.configuration.theme_color
+        binding
+      end
+
+      def binding_for_index
+        controllers = routes
+        controllers_count = routes.size
+        routes_count = routes.values.sum { |d| d[:routes].size }
+        models_count = models.size
+        binding
+      end
+
+      def binding_for_routes
+        routes_count = routes.values.sum { |d| d[:routes].size }
+        binding
+      end
+
+      def binding_for_controller(controller_name, data)
+        routes_list = data[:routes]
+        actions = data[:actions]
+        base_path = data[:base_path]
+        routes = routes_list # alias for template
+        binding
+      end
+
+      def binding_for_model(model)
+        binding
+      end
+    end
+  end
+end
+
+# String extensions for camelization if not in Rails
+unless String.method_defined?(:camelize)
+  class String
+    def camelize
+      split(/[_\/]/).map(&:capitalize).join("::")
+    end
+
+    def underscore
+      gsub("::", "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+  end
+end

data/lib/rails_map/parsers/model_parser.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RailsMap
+  module Parsers
+    class ModelParser
+      ColumnInfo = Struct.new(
+        :name, :type, :default, :null, :limit, :precision, :scale,
+        keyword_init: true
+      )
+
+      AssociationInfo = Struct.new(
+        :name, :type, :class_name, :foreign_key, :options,
+        keyword_init: true
+      )
+
+      ValidationInfo = Struct.new(
+        :attribute, :kind, :options,
+        keyword_init: true
+      )
+
+      ScopeInfo = Struct.new(
+        :name, :arity,
+        keyword_init: true
+      )
+
+      ModelInfo = Struct.new(
+        :name, :table_name, :columns, :associations, :validations, :scopes, :primary_key,
+        keyword_init: true
+      )
+
+      def parse
+        return {} unless defined?(Rails) && defined?(ActiveRecord::Base)
+
+        # Eager load all models - force it even in development
+        begin
+          Rails.application.eager_load!
+        rescue => e
+          Rails.logger.warn "Could not eager load: #{e.message}" if defined?(Rails.logger)
+        end
+        
+        # Also try to load app/models directory explicitly
+        if defined?(Rails.root)
+          Dir[Rails.root.join('app/models/**/*.rb')].each do |file|
+            begin
+              require_dependency file
+            rescue => e
+              # Ignore errors, file might already be loaded
+            end
+          end
+        end
+
+        models = ActiveRecord::Base.descendants.reject do |model|
+          model.abstract_class? || 
+            model.name.nil? || 
+            model.name.start_with?("HABTM_") ||
+            excluded_model?(model)
+        end
+
+        models.each_with_object({}) do |model, hash|
+          hash[model.name] = parse_model(model)
+        rescue StandardError => e
+          # Skip models that can't be introspected
+          Rails.logger.warn("Could not parse model #{model.name}: #{e.message}") if defined?(Rails.logger)
+        end.sort.to_h
+      end
+
+      private
+
+      def parse_model(model)
+        ModelInfo.new(
+          name: model.name,
+          table_name: safe_table_name(model),
+          columns: parse_columns(model),
+          associations: parse_associations(model),
+          validations: parse_validations(model),
+          scopes: parse_scopes(model),
+          primary_key: safe_primary_key(model)
+        )
+      end
+
+      def safe_table_name(model)
+        model.table_name
+      rescue StandardError
+        nil
+      end
+
+      def safe_primary_key(model)
+        model.primary_key
+      rescue StandardError
+        "id"
+      end
+
+      def parse_columns(model)
+        return [] unless model.table_exists?
+
+        model.columns.map do |column|
+          ColumnInfo.new(
+            name: column.name,
+            type: column.type.to_s,
+            default: column.default,
+            null: column.null,
+            limit: column.limit,
+            precision: column.precision,
+            scale: column.scale
+          )
+        end.sort_by(&:name)
+      rescue StandardError
+        []
+      end
+
+      def parse_associations(model)
+        model.reflect_on_all_associations.map do |assoc|
+          AssociationInfo.new(
+            name: assoc.name.to_s,
+            type: assoc.macro.to_s,
+            class_name: association_class_name(assoc),
+            foreign_key: association_foreign_key(assoc),
+            options: extract_association_options(assoc)
+          )
+        end.sort_by(&:name)
+      rescue StandardError
+        []
+      end
+
+      def association_class_name(assoc)
+        assoc.class_name
+      rescue StandardError
+        assoc.name.to_s.classify
+      end
+
+      def association_foreign_key(assoc)
+        assoc.foreign_key.to_s
+      rescue StandardError
+        nil
+      end
+
+      def extract_association_options(assoc)
+        options = {}
+        options[:dependent] = assoc.options[:dependent] if assoc.options[:dependent]
+        options[:through] = assoc.options[:through].to_s if assoc.options[:through]
+        options[:polymorphic] = true if assoc.options[:polymorphic]
+        options[:as] = assoc.options[:as].to_s if assoc.options[:as]
+        options
+      end
+
+      def parse_validations(model)
+        return [] unless RailsMap.configuration.include_validations
+
+        model.validators.flat_map do |validator|
+          validator.attributes.map do |attr|
+            ValidationInfo.new(
+              attribute: attr.to_s,
+              kind: validator.kind.to_s,
+              options: extract_validation_options(validator)
+            )
+          end
+        end.sort_by { |v| [v.attribute, v.kind] }
+      rescue StandardError
+        []
+      end
+
+      def extract_validation_options(validator)
+        validator.options.reject { |k, _| k == :if || k == :unless }
+                 .transform_values(&:to_s)
+      rescue StandardError
+        {}
+      end
+
+      def parse_scopes(model)
+        return [] unless RailsMap.configuration.include_scopes
+
+        scope_names = model.methods.grep(/^_scope_/).map { |m| m.to_s.sub("_scope_", "") }
+
+        # Alternative: check defined scopes
+        if model.respond_to?(:defined_scopes)
+          scope_names = model.defined_scopes.keys.map(&:to_s)
+        end
+
+        # Fallback: look at singleton methods that return ActiveRecord::Relation
+        if scope_names.empty?
+          scope_names = extract_scope_names_from_singleton_methods(model)
+        end
+
+        scope_names.uniq.sort.map do |name|
+          ScopeInfo.new(
+            name: name,
+            arity: safe_scope_arity(model, name)
+          )
+        end
+      rescue StandardError
+        []
+      end
+
+      def extract_scope_names_from_singleton_methods(model)
+        # This is a heuristic approach
+        model.singleton_methods(false).select do |method|
+          # Skip common non-scope methods
+          !%w[table_name primary_key inheritance_column].include?(method.to_s)
+        end.map(&:to_s)
+      rescue StandardError
+        []
+      end
+
+      def safe_scope_arity(model, name)
+        model.method(name).arity
+      rescue StandardError
+        0
+      end
+
+      def excluded_model?(model)
+        return true if model.name.nil?
+        
+        # Exclude models from gems/engines by namespace
+        excluded_namespaces = %w[
+          RailsMap
+          ActionMailbox
+          ActionText
+          ActiveStorage
+          Turbo
+          Devise
+          Sidekiq
+          SolidQueue
+          SolidCache
+          GoodJob
+          Que
+          Delayed
+          Flipper
+          PgHero
+          Blazer
+          Avo
+          MissionControl
+          Administrate
+          RailsAdmin
+          Ahoy
+        ]
+        
+        # Check namespace exclusions first (fast check)
+        model_name = model.name.to_s
+        first_namespace = model_name.split('::').first
+        return true if excluded_namespaces.include?(first_namespace)
+        return true if excluded_namespaces.any? { |ns| model_name.start_with?("#{ns}::") }
+        
+        # Check if model file exists in app/models of host app
+        if defined?(Rails.root)
+          # Convert model name to file path (e.g., User -> user.rb, Admin::User -> admin/user.rb)
+          model_path = model_name.underscore + '.rb'
+          model_file = Rails.root.join('app', 'models', model_path)
+          
+          # If the file doesn't exist in app/models, it's likely from a gem
+          return true unless File.exist?(model_file)
+        end
+        
+        false
+      end
+    end
+  end
+end