rails_architect_analyzer 0.1.0

data/lib/rails_architect/analyzers/bdd_analyzer.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RailsArchitect
+  module Analyzers
+    # Analyzes behavior-driven development practices in Rails projects
+    class BddAnalyzer
+      attr_reader :project_path
+
+      def initialize(project_path = Rails.root)
+        @project_path = project_path
+      end
+
+      def analyze
+        {
+          has_cucumber: cucumber?,
+          has_rspec: rspec?,
+          feature_files_count: count_feature_files,
+          step_definitions_count: count_step_definitions,
+          score: calculate_bdd_score,
+          suggestions: generate_suggestions,
+          practices: check_bdd_practices
+        }
+      end
+
+      private
+
+      def cucumber?
+        gemfile_path = File.join(project_path, "Gemfile")
+        return false unless File.exist?(gemfile_path)
+
+        File.read(gemfile_path).include?("cucumber")
+      end
+
+      def rspec?
+        gemfile_path = File.join(project_path, "Gemfile")
+        return false unless File.exist?(gemfile_path)
+
+        File.read(gemfile_path).include?("rspec")
+      end
+
+      def count_feature_files
+        features_path = File.join(project_path, "features")
+        return 0 unless File.directory?(features_path)
+
+        Dir.glob(File.join(features_path, "**/*.feature")).count
+      end
+
+      def count_step_definitions
+        steps_path = File.join(project_path, "features/step_definitions")
+        return 0 unless File.directory?(steps_path)
+
+        Dir.glob(File.join(steps_path, "**/*.rb")).count
+      end
+
+      def calculate_bdd_score
+        features = count_feature_files
+        count_step_definitions
+
+        case features
+        when 0
+          { score: 0, rating: "❌ No BDD implemented", color: :red }
+        when 1...5
+          { score: 25, rating: "⚠️  Minimal BDD coverage", color: :yellow }
+        when 5...15
+          { score: 50, rating: "✅ Some BDD coverage", color: :light_yellow }
+        else
+          { score: 100, rating: "🎉 Strong BDD practices", color: :light_green }
+        end
+      end
+
+      def check_bdd_practices
+        {
+          user_stories: user_stories?,
+          readable_scenarios: check_readable_scenarios,
+          step_reusability: analyze_step_reusability,
+          integration_tests: check_integration_tests
+        }
+      end
+
+      def user_stories?
+        features_path = File.join(project_path, "features")
+        return false unless File.directory?(features_path)
+
+        Dir.glob(File.join(features_path, "**/*.feature")).any? do |file|
+          content = File.read(file)
+          content.include?("Feature:") && (content.include?("As a") || content.include?("Scenario"))
+        end
+      end
+
+      def check_readable_scenarios
+        features_path = File.join(project_path, "features")
+        return { present: false, count: 0 } unless File.directory?(features_path)
+
+        readable = Dir.glob(File.join(features_path, "**/*.feature")).count do |file|
+          content = File.read(file)
+          content.match?(/Given|When|Then/)
+        end
+
+        { present: readable.positive?, count: readable }
+      end
+
+      def analyze_step_reusability
+        steps_path = File.join(project_path, "features/step_definitions")
+        return { score: 0, recommendation: "Create step definitions" } unless File.directory?(steps_path)
+
+        step_files = Dir.glob(File.join(steps_path, "*.rb"))
+        return { score: 0, recommendation: "Create step definitions" } if step_files.empty?
+
+        avg_lines = step_files.map { |f| File.readlines(f).count }.sum / step_files.count
+
+        {
+          score: avg_lines,
+          recommendation: avg_lines > 200 ? "Refactor steps - they're getting too large" : "Steps are well-organized"
+        }
+      end
+
+      def check_integration_tests
+        {
+          request_specs: count_request_specs,
+          feature_tests: count_feature_files,
+          integration_test_files: count_integration_test_files
+        }
+      end
+
+      def count_request_specs
+        specs_path = File.join(project_path, "spec/requests")
+        return 0 unless File.directory?(specs_path)
+
+        Dir.glob(File.join(specs_path, "**/*_spec.rb")).count
+      end
+
+      def count_integration_test_files
+        integration_path = File.join(project_path, "test/integration")
+        return 0 unless File.directory?(integration_path)
+
+        Dir.glob(File.join(integration_path, "**/*_test.rb")).count
+      end
+
+      def generate_suggestions
+        suggestions = []
+
+        suggestions << "Consider adding Cucumber for BDD with human-readable scenarios" unless cucumber?
+
+        if count_feature_files.zero? && cucumber?
+          suggestions << "No feature files found. Start writing user stories in features/"
+        end
+
+        suggestions << "Consider using RSpec for more expressive tests" unless rspec?
+
+        unless user_stories?
+          suggestions << "Write user stories using 'As a... I want... So that...' format in feature files"
+        end
+
+        suggestions << "Structure your scenarios using Given/When/Then format" unless check_readable_scenarios[:present]
+
+        suggestions
+      end
+    end
+  end
+end

data/lib/rails_architect/analyzers/solid_analyzer.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module RailsArchitect
+  module Analyzers
+    # Evaluates SOLID principles adherence in Rails projects
+    class SolidAnalyzer
+      attr_reader :project_path
+
+      def initialize(project_path = Rails.root)
+        @project_path = project_path
+      end
+
+      def analyze
+        {
+          score: calculate_solid_score,
+          single_responsibility: analyze_single_responsibility,
+          open_closed: analyze_open_closed,
+          liskov_substitution: analyze_liskov,
+          interface_segregation: analyze_interface_segregation,
+          dependency_inversion: analyze_dependency_inversion,
+          suggestions: generate_suggestions
+        }
+      end
+
+      private
+
+      def analyze_single_responsibility
+        {
+          description: "A class should have only one reason to change",
+          issues: detect_srp_violations,
+          status: detect_srp_violations.empty? ? "✅ Good" : "⚠️  Violations found"
+        }
+      end
+
+      def analyze_open_closed
+        {
+          description: "Classes should be open for extension, closed for modification",
+          has_concerns: concerns?,
+          has_modules: modules?,
+          has_inheritance: inheritance?,
+          status: concerns? || inheritance? ? "✅ Some patterns found" : "⚠️  Consider using concerns or inheritance"
+        }
+      end
+
+      def analyze_liskov
+        chains = analyze_inheritance_chains
+        {
+          description: "Objects should be replaceable by their subtypes without breaking",
+          inheritance_chains: chains,
+          concerns_usage: count_concerns,
+          status: chains < 3 ? "✅ Good" : "⚠️  Deep inheritance chains detected"
+        }
+      end
+
+      def analyze_interface_segregation
+        {
+          description: "Clients should not depend on interfaces they don't use",
+          fat_modules: detect_fat_modules,
+          large_classes: detect_large_classes,
+          status: (detect_fat_modules + detect_large_classes).empty? ? "✅ Good" : "⚠️  Violations found"
+        }
+      end
+
+      def analyze_dependency_inversion
+        {
+          description: "Depend on abstractions, not concretions",
+          service_layer: services?,
+          dependency_injection: detect_dependency_injection,
+          status: services? ? "✅ Service layer detected" : "⚠️  Consider implementing service layer"
+        }
+      end
+
+      def calculate_solid_score
+        srp = detect_srp_violations.empty? ? 20 : 10
+        ocp = concerns? || inheritance? ? 20 : 10
+        lsp = analyze_inheritance_chains < 3 ? 20 : 10
+        isp = (detect_fat_modules + detect_large_classes).empty? ? 20 : 10
+        dip = services? ? 20 : 10
+
+        total = srp + ocp + lsp + isp + dip
+        { score: total, rating: rating_from_score(total), color: color_from_score(total) }
+      end
+
+      def rating_from_score(score)
+        case score
+        when 0...30
+          "❌ Poor"
+        when 30...60
+          "⚠️  Fair"
+        when 60...80
+          "✅ Good"
+        else
+          "🎉 Excellent"
+        end
+      end
+
+      def color_from_score(score)
+        case score
+        when 0...30
+          :red
+        when 30...60
+          :yellow
+        when 60...80
+          :light_green
+        else
+          :green
+        end
+      end
+
+      def detect_srp_violations
+        violations = []
+        models_path = File.join(project_path, "app/models")
+        return violations unless File.directory?(models_path)
+
+        Dir.glob(File.join(models_path, "*.rb")).each do |file|
+          content = File.read(file)
+          # Simple heuristic: check for many associations and methods
+          associations = content.scan(/has_many|belongs_to|has_one/).count
+          methods = content.scan("def ").count
+
+          violations << File.basename(file, ".rb") if associations > 5 && methods > 10
+        end
+
+        violations
+      end
+
+      def concerns?
+        concerns_path = File.join(project_path, "app/concerns")
+        File.directory?(concerns_path) && !Dir.glob(File.join(concerns_path, "*.rb")).empty?
+      end
+
+      def modules?
+        lib_path = File.join(project_path, "lib")
+        return false unless File.directory?(lib_path)
+
+        Dir.glob(File.join(lib_path, "**/*.rb")).any? { |f| File.read(f).include?("module ") }
+      end
+
+      def inheritance?
+        app_path = File.join(project_path, "app")
+        return false unless File.directory?(app_path)
+
+        Dir.glob(File.join(app_path, "**/*.rb")).any? { |f| File.read(f).match?(/class \w+ </) }
+      end
+
+      def analyze_inheritance_chains
+        app_path = File.join(project_path, "app")
+        return 0 unless File.directory?(app_path)
+
+        max_depth = 0
+        Dir.glob(File.join(app_path, "**/*.rb")).each do |file|
+          content = File.read(file)
+          depth = content.scan(/class \w+ </).count
+          max_depth = depth if depth > max_depth
+        end
+
+        max_depth
+      end
+
+      def count_concerns
+        concerns_path = File.join(project_path, "app/concerns")
+        return 0 unless File.directory?(concerns_path)
+
+        Dir.glob(File.join(concerns_path, "*.rb")).count
+      end
+
+      def detect_fat_modules
+        modules = []
+        lib_path = File.join(project_path, "lib")
+        return modules unless File.directory?(lib_path)
+
+        Dir.glob(File.join(lib_path, "**/*.rb")).each do |file|
+          lines = File.readlines(file).count
+          modules << File.basename(file, ".rb") if lines > 300
+        end
+
+        modules
+      end
+
+      def detect_large_classes
+        classes = []
+        app_path = File.join(project_path, "app")
+        return classes unless File.directory?(app_path)
+
+        Dir.glob(File.join(app_path, "**/*.rb")).each do |file|
+          lines = File.readlines(file).count
+          classes << File.basename(file, ".rb") if lines > 150
+        end
+
+        classes
+      end
+
+      def services?
+        services_path = File.join(project_path, "app/services")
+        File.directory?(services_path) && !Dir.glob(File.join(services_path, "*.rb")).empty?
+      end
+
+      def detect_dependency_injection
+        app_path = File.join(project_path, "app")
+        return 0 unless File.directory?(app_path)
+
+        count = 0
+        Dir.glob(File.join(app_path, "**/*.rb")).each do |file|
+          content = File.read(file)
+          # Look for initialize methods with parameters
+          count += 1 if content.match?(/def initialize\([^)]+\)/)
+        end
+
+        count
+      end
+
+      def generate_suggestions
+        suggestions = []
+
+        unless detect_srp_violations.empty?
+          suggestions << "⚠️  Classes with mixed responsibilities detected: #{detect_srp_violations.join(', ')}"
+          suggestions << "Extract logic into service objects or concerns"
+        end
+
+        suggestions << "Consider creating app/concerns for shared behavior" unless concerns?
+
+        suggestions << "Implement a service layer (app/services) for complex business logic" unless services?
+
+        if analyze_inheritance_chains >= 3
+          suggestions << "⚠️  Deep inheritance chains detected. Consider using composition or concerns"
+        end
+
+        unless detect_large_classes.empty?
+          suggestions << "⚠️  Large classes detected: #{detect_large_classes.first(3).join(', ')}"
+          suggestions << "Break them down using SRP (Single Responsibility Principle)"
+        end
+
+        suggestions << "Use dependency injection to reduce tight coupling" if detect_dependency_injection < 10
+
+        suggestions
+      end
+    end
+  end
+end

data/lib/rails_architect/analyzers/tdd_analyzer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RailsArchitect
+  module Analyzers
+    # Analyzes test-driven development coverage and practices
+    class TddAnalyzer
+      attr_reader :project_path
+
+      def initialize(project_path = Rails.root)
+        @project_path = project_path
+      end
+
+      def analyze
+        {
+          score: calculate_coverage_score,
+          test_files: count_test_files,
+          spec_files: count_spec_files,
+          coverage_percentage: estimate_coverage,
+          suggestions: generate_suggestions,
+          test_structure: analyze_test_structure
+        }
+      end
+
+      private
+
+      def count_test_files
+        test_path = File.join(project_path, "test")
+        return 0 unless File.directory?(test_path)
+
+        Dir.glob(File.join(test_path, "**/*_test.rb")).count
+      end
+
+      def count_spec_files
+        spec_path = File.join(project_path, "spec")
+        return 0 unless File.directory?(spec_path)
+
+        Dir.glob(File.join(spec_path, "**/*_spec.rb")).count
+      end
+
+      def estimate_coverage
+        spec_files = count_spec_files
+        test_files = count_test_files
+        code_files = count_code_files
+
+        return 0 if code_files.zero?
+
+        total_tests = spec_files + test_files
+        ((total_tests.to_f / code_files) * 100).round(2)
+      end
+
+      def count_code_files
+        app_path = File.join(project_path, "app")
+        return 0 unless File.directory?(app_path)
+
+        Dir.glob(File.join(app_path, "**/*.rb")).count
+      end
+
+      def calculate_coverage_score
+        coverage = estimate_coverage
+        case coverage
+        when 0...20
+          { score: coverage, rating: "❌ Poor", color: :red }
+        when 20...50
+          { score: coverage, rating: "⚠️  Fair", color: :yellow }
+        when 50...80
+          { score: coverage, rating: "✅ Good", color: :green }
+        else
+          { score: coverage, rating: "🎉 Excellent", color: :light_green }
+        end
+      end
+
+      def analyze_test_structure
+        {
+          models: analyze_test_type("models"),
+          controllers: analyze_test_type("controllers"),
+          services: analyze_test_type("services"),
+          helpers: analyze_test_type("helpers"),
+          requests: analyze_test_type("requests")
+        }
+      end
+
+      def analyze_test_type(type)
+        spec_path = File.join(project_path, "spec", type)
+        test_path = File.join(project_path, "test", type)
+
+        spec_count = File.directory?(spec_path) ? Dir.glob(File.join(spec_path, "**/*.rb")).count : 0
+        test_count = File.directory?(test_path) ? Dir.glob(File.join(test_path, "**/*.rb")).count : 0
+
+        {
+          spec: spec_count,
+          test: test_count,
+          total: spec_count + test_count
+        }
+      end
+
+      def generate_suggestions
+        suggestions = []
+
+        if count_spec_files.zero? && count_test_files.zero?
+          suggestions << "❌ No tests found! Start by creating specs using RSpec or Minitest"
+        end
+
+        coverage = estimate_coverage
+        if coverage < 50 && coverage.positive?
+          suggestions << "⚠️  Test coverage is low (#{coverage.round(2)}%). Aim for at least 80%"
+        end
+
+        if analyze_test_structure[:models][:total].zero?
+          suggestions << "Add model specs/tests to ensure data validation logic"
+        end
+
+        if analyze_test_structure[:controllers][:total].zero?
+          suggestions << "Add controller specs/tests for request/response handling"
+        end
+
+        if analyze_test_structure[:services][:total].zero? && services?
+          suggestions << "Create tests for service objects"
+        end
+
+        suggestions << "Use factories (FactoryBot) for test data creation" if using_minitest_only?
+
+        suggestions
+      end
+
+      def services?
+        services_path = File.join(project_path, "app/services")
+        File.directory?(services_path) && !Dir.glob(File.join(services_path, "*.rb")).empty?
+      end
+
+      def using_minitest_only?
+        spec_files = count_spec_files
+        has_gemfile = File.exist?(File.join(project_path, "Gemfile"))
+
+        spec_files.zero? && has_gemfile
+      end
+    end
+  end
+end

data/lib/rails_architect/cli.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "thor"
+require "colorize"
+
+module RailsArchitect
+  # Command-line interface for Rails Architect analysis tool
+  class CLI < Thor
+    desc "analyze [PROJECT_PATH]", "Analyze a Rails project for architecture, TDD, BDD, and SOLID principles"
+    option :json, type: :boolean, desc: "Output results as JSON"
+    option :output, type: :string, desc: "Save report to a file"
+
+    def analyze(project_path = nil)
+      project_path ||= Dir.pwd
+
+      unless File.directory?(project_path)
+        puts "❌ Project path does not exist: #{project_path}".colorize(:red)
+        exit 1
+      end
+
+      results = RailsArchitect::Core.new(project_path).analyze
+
+      if options[:json]
+        output = RailsArchitect::Reporters::ReportGenerator.new(results).to_json
+        if options[:output]
+          File.write(options[:output], output)
+          puts "✅ JSON report saved to: #{options[:output]}".colorize(:light_green)
+        else
+          puts output
+        end
+      elsif options[:output]
+        File.open(options[:output], "w") do |f|
+          # Redirect output to file
+          original_stdout = $stdout
+          $stdout = f
+          RailsArchitect::Reporters::ReportGenerator.new(results).generate
+          $stdout = original_stdout
+        end
+        puts "✅ Report saved to: #{options[:output]}".colorize(:light_green)
+      else
+        RailsArchitect::Reporters::ReportGenerator.new(results).generate
+      end
+    end
+
+    desc "suggest [PROJECT_PATH]", "Get architecture suggestions for your Rails project"
+    def suggest(project_path = nil)
+      project_path ||= Dir.pwd
+
+      unless File.directory?(project_path)
+        puts "❌ Project path does not exist: #{project_path}".colorize(:red)
+        exit 1
+      end
+
+      results = RailsArchitect::Core.new(project_path).analyze
+
+      puts "\n#{'=' * 80}"
+      puts "🎯 ARCHITECTURE SUGGESTIONS".colorize(:blue).bold
+      puts "#{'=' * 80}\n"
+
+      suggestions = (
+        results[:architecture][:suggestions] +
+        results[:tdd][:suggestions] +
+        results[:bdd][:suggestions] +
+        results[:solid][:suggestions]
+      ).uniq
+
+      if suggestions.any?
+        suggestions.each_with_index do |suggestion, index|
+          puts "#{index + 1}. #{suggestion}"
+        end
+      else
+        puts "✅ Your project is well-structured!".colorize(:light_green)
+      end
+
+      puts "\n#{'=' * 80}\n"
+    end
+
+    desc "version", "Show the version of rails_architect"
+    def version
+      puts "Rails Architect #{RailsArchitect::VERSION}"
+    end
+  end
+end