railsforge 1.0.0

data/lib/railsforge/graph.rb

@@ -0,0 +1,270 @@
+# Graph module for RailsForge
+# Generates dependency graphs using Graphviz
+
+require 'fileutils'
+
+module RailsForge
+  # Graph class generates visual dependency graphs
+  class Graph
+    # Initialize the graph generator
+    def initialize(base_path = nil)
+      @base_path = base_path || find_rails_app_path
+      raise GraphError, "Not in a Rails application directory" unless @base_path
+
+      @output_dir = File.join(@base_path, "tmp", "railsforge")
+      @relationships = []
+    end
+
+    # Generate dependency graph
+    # @return [String] Path to generated files
+    def generate
+      puts "Analyzing Rails app structure..."
+      puts ""
+
+      # Collect relationships
+      analyze_controllers
+      analyze_services
+      analyze_queries
+      analyze_models
+      analyze_jobs
+
+      # Create output directory
+      FileUtils.mkdir_p(@output_dir)
+
+      # Generate DOT file
+      dot_file = generate_dot_file
+
+      # Generate SVG if Graphviz is available
+      svg_file = generate_svg(dot_file)
+
+      puts "Dependency graph generated!"
+      puts "  DOT: #{dot_file}"
+      puts "  SVG: #{svg_file}" if svg_file
+
+      { dot: dot_file, svg: svg_file }
+    end
+
+    private
+
+    # Find Rails app path
+    def find_rails_app_path
+      path = Dir.pwd
+      max_depth = 10
+
+      max_depth.times do
+        return path if File.exist?(File.join(path, "config", "application.rb"))
+        parent = File.dirname(path)
+        break if parent == path
+        path = parent
+      end
+
+      nil
+    end
+
+    # Analyze controllers for dependencies
+    def analyze_controllers
+      controllers_dir = File.join(@base_path, "app", "controllers")
+      return unless Dir.exist?(controllers_dir)
+
+      Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
+        next if file.end_with?("_application_controller.rb")
+
+        controller_name = File.basename(file, "_controller.rb").camelize
+        content = File.read(file)
+
+        # Find service dependencies
+        content.scan(/(\w+Service)\.call/).each do |service|
+          @relationships << { from: controller_name, to: service[0], type: "uses" }
+        end
+
+        # Find query dependencies
+        content.scan(/(\w+Query)\.new|(\w+)\.find_/).each do |match|
+          query = match[0] || match[1]
+          @relationships << { from: controller_name, to: query, type: "queries" }
+        end
+
+        # Find model dependencies
+        content.scan(/@(\w+)\s*=/).each do |model|
+          @relationships << { from: controller_name, to: model[0].singularize.camelize, type: "uses" }
+        end
+
+        # Find job dependencies
+        content.scan(/(\w+Job)\.perform_later/).each do |job|
+          @relationships << { from: controller_name, to: job[0], type: "enqueues" }
+        end
+      end
+    end
+
+    # Analyze services for dependencies
+    def analyze_services
+      services_dir = File.join(@base_path, "app", "services")
+      return unless Dir.exist?(services_dir)
+
+      Dir.glob(File.join(services_dir, "**", "*.rb")).each do |file|
+        service_name = File.basename(file, ".rb").camelize
+        content = File.read(file)
+
+        # Find model dependencies
+        content.scan(/(\w+)\.find|(\w+)\.where/).each do |match|
+          model = match[0] || match[1]
+          @relationships << { from: service_name, to: model.singularize.camelize, type: "queries" }
+        end
+
+        # Find other service dependencies
+        content.scan(/(\w+Service)\.call/).each do |service|
+          @relationships << { from: service_name, to: service[0], type: "uses" }
+        end
+
+        # Find job dependencies
+        content.scan(/(\w+Job)\.perform/).each do |job|
+          @relationships << { from: service_name, to: job[0], type: "enqueues" }
+        end
+      end
+    end
+
+    # Analyze queries for dependencies
+    def analyze_queries
+      queries_dir = File.join(@base_path, "app", "queries")
+      return unless Dir.exist?(queries_dir)
+
+      Dir.glob(File.join(queries_dir, "**", "*.rb")).each do |file|
+        query_name = File.basename(file, ".rb").camelize
+        content = File.read(file)
+
+        # Find model dependencies
+        content.scan(/(\w+)\.find|(\w+)\.where/).each do |match|
+          model = match[0] || match[1]
+          @relationships << { from: query_name, to: model.singularize.camelize, type: "queries" }
+        end
+      end
+    end
+
+    # Analyze models for associations
+    def analyze_models
+      models_dir = File.join(@base_path, "app", "models")
+      return unless Dir.exist?(models_dir)
+
+      Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
+        next if file.end_with?("_application_name = File.basename(file, ".rb.rb")
+
+        model").camelize
+        content = File.read(file)
+
+        # Find associations
+        content.scan(/belongs_to\s+:(\w+)/).each do |assoc|
+          @relationships << { from: model_name, to: assoc[0].camelize, type: "belongs_to" }
+        end
+
+        content.scan(/has_many\s+:(\w+)/).each do |assoc|
+          @relationships << { from: model_name, to: assoc[0].camelize, type: "has_many" }
+        end
+
+        content.scan(/has_one\s+:(\w+)/).each do |assoc|
+          @relationships << { from: model_name, to: assoc[0].camelize, type: "has_one" }
+        end
+      end
+    end
+
+    # Analyze jobs for dependencies
+    def analyze_jobs
+      jobs_dir = File.join(@base_path, "app", "jobs")
+      return unless Dir.exist?(jobs_dir)
+
+      Dir.glob(File.join(jobs_dir, "**", "*.rb")).each do |file|
+        job_name = File.basename(file, ".rb").camelize
+        content = File.read(file)
+
+        # Find service dependencies
+        content.scan(/(\w+Service)\.call/).each do |service|
+          @relationships << { from: job_name, to: service[0], type: "uses" }
+        end
+      end
+    end
+
+    # Generate DOT file
+    def generate_dot_file
+      dot_path = File.join(@output_dir, "dependency_graph.dot")
+
+      # Define colors for different types
+      type_colors = {
+        "controller" => "#3498db",
+        "service" => "#2ecc71",
+        "query" => "#9b59b6",
+        "model" => "#e74c3c",
+        "job" => "#f39c12",
+        "uses" => "#95a5a6",
+        "queries" => "#95a5a6",
+        "enqueues" => "#95a5a6",
+        "belongs_to" => "#e67e22",
+        "has_many" => "#1abc9c",
+        "has_one" => "#16a085"
+      }
+
+      dot_content = []
+      dot_content << "digraph RailsApp {"
+      dot_content << "  rankdir=LR;"
+      dot_content << "  node [shape=box, style=rounded];"
+      dot_content << ""
+
+      # Collect all nodes
+      nodes = Set.new
+      @relationships.each do |rel|
+        nodes.add(rel[:from])
+        nodes.add(rel[:to])
+      end
+
+      # Define node styles
+      nodes.each do |node|
+        type = detect_node_type(node)
+        color = type_colors[type] || "#95a5a6"
+        dot_content << "  \"#{node}\" [fillcolor=\"#{color}\", style=filled, fontcolor=white];"
+      end
+
+      dot_content << ""
+
+      # Define edges
+      @relationships.each do |rel|
+        style = "solid"
+        color = type_colors[rel[:type]] || "#95a5a6"
+        arrow = "normal"
+
+        if %w[belongs_to has_many has_one].include?(rel[:type])
+          style = "dashed"
+        end
+
+        dot_content << "  \"#{rel[:from]}\" -> \"#{rel[:to]}\" [style=#{style}, color=#{color}, arrowhead=#{arrow}];"
+      end
+
+      dot_content << "}"
+
+      File.write(dot_path, dot_content.join("\n"))
+      dot_path
+    end
+
+    # Detect node type based on name
+    def detect_node_type(name)
+      return "controller" if name.downcase.end_with?("controller")
+      return "service" if name.downcase.end_with?("service")
+      return "query" if name.downcase.start_with?("find") || name.downcase.end_with?("query")
+      return "model" if name.downcase.end_with?("job")
+      return "job" if name.downcase.end_with?("job")
+      "model"
+    end
+
+    # Generate SVG from DOT file
+    def generate_svg(dot_path)
+      svg_path = dot_path.sub(".dot", ".svg")
+
+      # Check if Graphviz is installed
+      return nil unless system("which dot > /dev/null 2>&1")
+
+      system("dot -Tsvg #{dot_path} -o #{svg_path} 2>/dev/null")
+      svg_path if File.exist?(svg_path)
+    rescue
+      nil
+    end
+
+    # Error class
+    class GraphError < StandardError; end
+  end
+end

data/lib/railsforge/loader.rb

@@ -0,0 +1,56 @@
+# RailsForge modular loader
+# This file centralizes all require statements
+
+require "fileutils"
+
+# Get the lib directory path
+LIB_DIR = File.dirname(__FILE__)
+
+# Core modules
+require_relative "version"
+require_relative "profiles"
+require_relative "template_loader"
+
+# CLI
+require_relative "cli"
+
+# Generators (modular)
+require_relative "generators/base_generator"
+require_relative "generators/service_generator"
+require_relative "generators/view_component_generator"
+require_relative "generators/stimulus_controller_generator"
+require_relative "generators/demo_generator"
+require_relative "generators/devops_generator"
+require_relative "generators/monitoring_generator"
+require_relative "generators/test_generator"
+
+# Analyzers (modular)
+require_relative "analyzers/base_analyzer"
+require_relative "analyzers/controller_analyzer"
+require_relative "analyzers/model_analyzer"
+require_relative "analyzers/spec_analyzer"
+require_relative "analyzers/database_analyzer"
+require_relative "analyzers/metrics_analyzer"
+require_relative "analyzers/refactor_analyzer"
+require_relative "analyzers/security_analyzer"
+require_relative "analyzers/performance_analyzer"
+
+# Refactors
+require_relative "refactors/refactor_controller"
+
+# Plugins
+require_relative "plugins"
+
+# Additional features (legacy compatibility)
+require_relative "mailer_generator"
+require_relative "feature_generator"
+require_relative "api_generator"
+require_relative "audit"
+require_relative "doctor"
+require_relative "graph"
+require_relative "wizard"
+require_relative "wizard_tui"
+require_relative "config"
+
+# Generator module (app creation)
+require_relative "generator"

data/lib/railsforge/mailer_generator.rb

@@ -0,0 +1,191 @@
+module RailsForge
+  # MailerGenerator module handles generating mailers
+  module MailerGenerator
+    # Error class for invalid mailer names
+    class InvalidMailerNameError < StandardError; end
+
+    # Validates the mailer name to ensure it's valid Ruby class name
+    def self.validate_mailer_name(name)
+      if name.nil? || name.strip.empty?
+        raise InvalidMailerNameError, "Mailer name cannot be empty"
+      end
+
+      unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+        raise InvalidMailerNameError, "Mailer name must be in PascalCase (e.g., UserMailer)"
+      end
+    end
+
+    # Generates a mailer file with views and optionally an RSpec test
+    def self.generate(mailer_name, with_spec: true, with_jobs: false)
+      validate_mailer_name(mailer_name)
+
+      base_path = find_rails_app_path
+      unless base_path
+        raise "Not in a Rails application directory"
+      end
+
+      generate_mailer_file(base_path, mailer_name, with_jobs)
+      generate_view_files(base_path, mailer_name)
+
+      if with_spec
+        generate_spec_file(base_path, mailer_name)
+      end
+
+      "Mailer '#{mailer_name}' generated successfully!"
+    end
+
+    def self.generate_mailer_file(base_path, mailer_name, with_jobs = false)
+      mailer_dir = File.join(base_path, "app", "mailers")
+      FileUtils.mkdir_p(mailer_dir)
+
+      file_name = "#{mailer_name.underscore}.rb"
+      file_path = File.join(mailer_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping mailer (already exists)"
+        return file_path
+      end
+
+      File.write(file_path, mailer_template(mailer_name, with_jobs))
+      puts "  Created app/mailers/#{file_name}"
+      file_path
+    end
+
+    def self.generate_view_files(base_path, mailer_name)
+      views_dir = File.join(base_path, "app", "views", mailer_name.underscore)
+      FileUtils.mkdir_p(views_dir)
+
+      methods = ["welcome_email", "notification_email"]
+
+      methods.each do |method|
+        html_path = File.join(views_dir, "#{method}.html.erb")
+        unless File.exist?(html_path)
+          File.write(html_path, view_html_template(mailer_name, method))
+          puts "  Created app/views/#{mailer_name.underscore}/#{method}.html.erb"
+        end
+
+        text_path = File.join(views_dir, "#{method}.text.erb")
+        unless File.exist?(text_path)
+          File.write(text_path, view_text_template(mailer_name, method))
+          puts "  Created app/views/#{mailer_name.underscore}/#{method}.text.erb"
+        end
+      end
+    end
+
+    def self.generate_spec_file(base_path, mailer_name)
+      spec_dir = File.join(base_path, "spec", "mailers")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{mailer_name.underscore}_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping spec (already exists)"
+        return file_path
+      end
+
+      File.write(file_path, spec_template(mailer_name))
+      puts "  Created spec/mailers/#{file_name}"
+      file_path
+    end
+
+    def self.find_rails_app_path
+      path = Dir.pwd
+      10.times do
+        return path if File.exist?(File.join(path, "config", "application.rb"))
+        parent = File.dirname(path)
+        break if parent == path
+        path = parent
+      end
+      nil
+    end
+
+    def self.mailer_template(mailer_name, with_jobs = false)
+      <<~RUBY
+        # Mailer class for #{mailer_name}
+        # Handles sending emails related to #{mailer_name.underscore}
+        #
+        # Usage:
+        #   #{mailer_name}.with(user: @user).welcome_email.deliver_later
+        #   #{mailer_name}.with(user: @user).notification_email.deliver_now
+        class #{mailer_name} < ApplicationMailer
+          # Sends a welcome email to the user
+          # @param user [User] The user to send the welcome email to
+          # @return [Mail::Message] The sent mail message
+          def welcome_email(user)
+            mail(to: user.email, subject: "Welcome to Our App!")
+          end
+
+          # Sends a notification email to the user
+          # @param user [User] The user to send the notification to
+          # @param message [String] The notification message
+          # @return [Mail::Message] The sent mail message
+          def notification_email(user, message: "You have a new notification")
+            @user = user
+            @message = message
+            mail(to: user.email, subject: "Notification from Our App")
+          end
+
+          # Class method to queue email via ActiveJob
+          # Use with --jobs flag for background delivery
+          # def self.deliver_with_job(user, method: :welcome_email, **args)
+          #   #{mailer_name}Job.perform_later(user, method: method, **args)
+          # end
+        end
+      RUBY
+    end
+
+    def self.view_html_template(mailer_name, method_name)
+      <<~ERB
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta content='text/html; charset=UTF-8' http-equiv='Content-Type' />
+    <style>body { font-family: Arial, sans-serif; }</style>
+  </head>
+  <body>
+    <h1>#{method_name == 'welcome_email' ? 'Welcome!' : 'Notification'}</h1>
+    #{method_name == 'welcome_email' ? '<p>Welcome to our application!</p>' : '<p><%= @message %></p>'}
+  </body>
+</html>
+      ERB
+    end
+
+    def self.view_text_template(mailer_name, method_name)
+      <<~TEXT
+#{method_name == 'welcome_email' ? 'Welcome to our application!' : '<%= @message %>'}
+
+--
+Our App
+      TEXT
+    end
+
+    def self.spec_template(mailer_name)
+      <<~RUBY
+require "rails_helper"
+
+RSpec.describe #{mailer_name}, type: :mailer do
+  describe "welcome_email" do
+    let(:user) { User.create!(name: "Test", email: "test@example.com") }
+    let(:mail) { described_class.welcome_email(user) }
+
+    it "renders the headers" do
+      expect(mail.subject).to eq("Welcome to Our App!")
+      expect(mail.to).to eq([user.email])
+    end
+  end
+
+  describe "notification_email" do
+    let(:user) { User.create!(name: "Test", email: "test@example.com") }
+    let(:mail) { described_class.notification_email(user, message: "Test") }
+
+    it "renders the body" do
+      expect(mail.body.encoded).to include("Test")
+    end
+  end
+end
+      RUBY
+    end
+  end
+
+end

data/lib/railsforge/plugins/plugin_loader.rb

@@ -0,0 +1,60 @@
+# Plugin loader for RailsForge
+# Handles plugin discovery and loading
+
+require 'fileutils'
+
+module RailsForge
+  module Plugins
+    # PluginLoader manages RailsForge plugins
+    class PluginLoader
+      PLUGINS_DIR = File.expand_path('../../plugins', __FILE__)
+
+      # List available plugins
+      def self.list
+        return [] unless Dir.exist?(PLUGINS_DIR)
+
+        Dir.glob(File.join(PLUGINS_DIR, "*.rb")).map do |file|
+          File.basename(file, ".rb")
+        end
+      end
+
+      # Load a plugin
+      def self.load(plugin_name)
+        plugin_path = File.join(PLUGINS_DIR, "#{plugin_name}.rb")
+
+        unless File.exist?(plugin_path)
+          puts "Plugin '#{plugin_name}' not found"
+          return false
+        end
+
+        require plugin_path
+        puts "Plugin '#{plugin_name}' loaded"
+        true
+      end
+
+      # Load all plugins
+      def self.load_all
+        list.each { |plugin| load(plugin) }
+      end
+
+      # Create a new plugin
+      def self.create(plugin_name)
+        FileUtils.mkdir_p(PLUGINS_DIR)
+
+        path = File.join(PLUGINS_DIR, "#{plugin_name}.rb")
+        return if File.exist?(path)
+
+        File.write(path, <<~RUBY)
+          module RailsForge
+            module #{plugin_name.split('_').map(&:capitalize).join}
+              PLUGIN_NAME = "#{plugin_name}"
+              VERSION = "0.1.0"
+            end
+          end
+        RUBY
+
+        puts "Created #{path}"
+      end
+    end
+  end
+end

data/lib/railsforge/plugins.rb

@@ -0,0 +1,30 @@
+# RailsForge Plugins module
+# Provides plugin management functionality
+
+require_relative "plugins/plugin_loader"
+
+module RailsForge
+  module Plugins
+    # Show installed/available plugins
+    def self.show_installed
+      plugins = PluginLoader.list
+      if plugins.empty?
+        puts "No plugins installed."
+        puts "Create one with: railsforge plugins create <name>"
+      else
+        puts "Available plugins:"
+        plugins.each { |p| puts "  - #{p}" }
+      end
+    end
+
+    # Load a plugin by name
+    def self.load(plugin_name)
+      PluginLoader.load(plugin_name)
+    end
+
+    # Create a new plugin
+    def self.create(plugin_name)
+      PluginLoader.create(plugin_name)
+    end
+  end
+end

data/lib/railsforge/profiles/admin_app.yml

@@ -0,0 +1,49 @@
+# Admin App Profile Configuration
+# Use with: railsforge new my_admin --profile=admin_app
+
+name: admin_app
+description: An admin dashboard application with user management, analytics, and CRUD operations
+
+# Default folders to create
+folders:
+  - app/controllers/admin
+  - app/models
+  - app/views/admin
+  - app/helpers
+  - app/services
+  - app/queries
+  - app/presenters
+  - app/policies
+  - app/serializers
+  - app/forms
+  - app/dashboards
+  - config/initializers
+  - config/environments
+  - db/migrate
+  - spec/models
+  - spec/controllers
+  - spec/requests
+  - spec/features
+  - spec/services
+  - spec/policies
+
+# Default generators to run after app creation
+generators:
+  - model
+  - scaffold
+  - resource
+
+# Features to enable by default
+features:
+  - authentication
+  - authorization
+  - admin
+  - pagination
+  - export
+
+# Template variables
+defaults:
+  css_framework: bootstrap
+  testing: rspec
+  database: postgresql
+  admin_framework: activeadmin

data/lib/railsforge/profiles/api_only.yml

@@ -0,0 +1,47 @@
+# API Only Profile Configuration
+# Use with: railsforge new my_api --profile=api_only
+
+name: api_only
+description: A JSON API application with token authentication and versioning
+
+# Default folders to create
+folders:
+  - app/controllers/api
+  - app/controllers/api/v1
+  - app/models
+  - app/serializers
+  - app/services
+  - app/queries
+  - app/policies
+  - app/forms
+  - app/presenters
+  - config/initializers
+  - config/environments
+  - config/initializers/doorkeeper.rb
+  - db/migrate
+  - spec/models
+  - spec/requests
+  - spec/api
+  - spec/services
+  - spec/policies
+  - spec/serializers
+
+# Default generators to run after app creation
+generators:
+  - model
+  - resource
+
+# Features to enable by default
+features:
+  - authentication
+  - authorization
+  - api
+  - versioning
+  - token_auth
+
+# Template variables
+defaults:
+  testing: rspec
+  database: postgresql
+  api_format: json
+  auth_strategy: doorkeeper