railsforge 1.0.1 → 2.0.0

data/lib/railsforge/graph.rb

@@ -1,270 +0,0 @@
-# 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/mailer_generator.rb

@@ -1,191 +0,0 @@
-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

@@ -1,60 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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.rb

@@ -1,99 +0,0 @@
-# ProfileLoader module handles loading RailsForge profiles
-require 'yaml'
-
-module RailsForge
-  # Profile module for managing application profiles
-  module Profile
-    # Error class for profile loading issues
-    class ProfileError < StandardError; end
-
-    # Profile directory path
-    PROFILES_DIR = File.expand_path('../profiles', __FILE__)
-
-    # Load a profile by name
-    # @param profile_name [String] The name of the profile to load
-    # @return [Hash] The profile configuration
-    # @raises [ProfileError] If profile not found or invalid
-    def self.load(profile_name)
-      profile_path = File.join(PROFILES_DIR, "#{profile_name}.yml")
-      
-      unless File.exist?(profile_path)
-        raise ProfileError, "Profile '#{profile_name}' not found. Available profiles: #{available_profiles.join(', ')}"
-      end
-
-      begin
-        YAML.safe_load(File.read(profile_path), permitted_classes: [], permitted_symbols: [], aliases: true)
-      rescue => e
-        raise ProfileError, "Failed to load profile '#{profile_name}': #{e.message}"
-      end
-    end
-
-    # Get list of available profiles
-    # @return [Array<String>] Array of profile names
-    def self.available_profiles
-      return [] unless Dir.exist?(PROFILES_DIR)
-      
-      Dir.glob(File.join(PROFILES_DIR, '*.yml')).map do |file|
-        File.basename(file, '.yml')
-      end.sort
-    end
-
-    # Validate a profile configuration
-    # @param profile [Hash] The profile configuration to validate
-    # @return [Boolean] True if valid
-    def self.validate?(profile)
-      return false unless profile.is_a?(Hash)
-      
-      required_keys = %w[name description folders]
-      required_keys.all? { |key| profile.key?(key) }
-    end
-
-    # Create folders defined in profile
-    # @param base_path [String] The Rails app root path
-    # @param profile [Hash] The profile configuration
-    def self.create_folders(base_path, profile)
-      folders = profile['folders'] || []
-      
-      folders.each do |folder|
-        full_path = File.join(base_path, folder)
-        unless Dir.exist?(full_path)
-          FileUtils.mkdir_p(full_path)
-          puts "  Created #{folder}"
-        end
-      end
-    end
-
-    # Get default features from profile
-    # @param profile [Hash] The profile configuration
-    # @return [Array<String>] Array of feature names
-    def self.default_features(profile)
-      profile['features'] || []
-    end
-
-    # Get default template variables from profile
-    # @param profile [Hash] The profile configuration
-    # @return [Hash] Default template variables
-    def self.defaults(profile)
-      profile['defaults'] || {}
-    end
-
-    # Show available profiles with descriptions
-    # @return [String] Formatted list of profiles
-    def self.show_available
-      profiles = available_profiles
-      
-      if profiles.empty?
-        return "No profiles available."
-      end
-
-      output = "Available profiles:\n\n"
-      
-      profiles.each do |name|
-        profile = load(name)
-        output += "  #{name.ljust(15)} - #{profile['description']}\n"
-      end
-      
-      output
-    end
-  end
-end