rails-architect 0.1.0 → 0.2.0

data/lib/rails_architect/kiss_analyzer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RailsArchitect
+  class KissAnalyzer
+    attr_reader :issues
+
+    def initialize
+      @issues = []
+    end
+
+    def analyze
+      check_method_complexity
+      check_class_size
+      check_nesting_depth
+    end
+
+    private
+
+    def add_issue(file, type, message)
+      @issues << { file: file, type: type, message: message }
+    end
+
+    private
+
+    def check_method_complexity
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        methods = extract_methods(content)
+
+        methods.each do |method_name, method_body|
+          complexity = calculate_cyclomatic_complexity(method_body)
+          lines = method_body.count("\n") + 1
+
+          if complexity > 10
+            class_name = extract_class_name(file)
+            add_issue(file, "kiss_complexity", "#{class_name}##{method_name} has cyclomatic complexity #{complexity}, keep it simple")
+          end
+
+          if lines > 25
+            class_name = extract_class_name(file)
+            add_issue(file, "kiss_length", "#{class_name}##{method_name} is #{lines} lines long, keep it simple")
+          end
+        end
+      end
+    end
+
+    def check_class_size
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        lines = content.count("\n") + 1
+
+        if lines > 200
+          class_name = extract_class_name(file)
+          add_issue(file, "kiss_class_size", "#{class_name} is #{lines} lines long, consider splitting into smaller classes")
+        end
+      end
+    end
+
+    def check_nesting_depth
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        max_depth = calculate_max_nesting_depth(content)
+
+        if max_depth > 4
+          class_name = extract_class_name(file)
+          add_issue(file, "kiss_nesting", "#{class_name} has nesting depth of #{max_depth}, keep it simple")
+        end
+      end
+    end
+
+    def extract_methods(content)
+      methods = {}
+      current_method = nil
+      indent_level = 0
+      method_start = false
+
+      content.each_line do |line|
+        if line.match?(/^\s*def \w+/)
+          current_method = line.strip.match(/def (\w+)/)[1]
+          methods[current_method] = ""
+          method_start = true
+          indent_level = line.match(/^\s*/).to_s.length
+        elsif method_start && line.match(/^\s*end\s*$/) && line.match(/^\s*/).to_s.length == indent_level
+          method_start = false
+          current_method = nil
+        elsif method_start
+          methods[current_method] += line
+        end
+      end
+
+      methods
+    end
+
+    def calculate_cyclomatic_complexity(method_body)
+      complexity = 1 # base complexity
+
+      # Count control flow keywords
+      complexity += method_body.scan(/\b(if|unless|case|when|while|until|for|rescue|&&|\|\|)\b/).count
+      complexity += method_body.scan(/\?\s*:/).count # ternary operators
+
+      complexity
+    end
+
+    def calculate_max_nesting_depth(content)
+      max_depth = 0
+      current_depth = 0
+
+      content.each_line do |line|
+        indent = line.match(/^\s*/).to_s.length / 2 # assuming 2 spaces per indent
+
+        # Increase depth for control structures
+        if line.match?(/\b(if|unless|case|while|until|for|begin|def|class|module)\b/)
+          current_depth = [current_depth, indent + 1].max
+          max_depth = [max_depth, current_depth].max
+        end
+      end
+
+      max_depth
+    end
+
+    def extract_class_name(file)
+      relative_path = file.sub('app/', '').sub('.rb', '')
+      parts = relative_path.split('/')
+      class_parts = parts.map do |part|
+        part.split('_').map(&:capitalize).join
+      end
+      class_parts.join('::')
+    end
+  end
+end

data/lib/rails_architect/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module RailsArchitect
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path('tasks/rails_architect.rake', __dir__)
+    end
+  end
+end

data/lib/rails_architect/solid_analyzer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RailsArchitect
+  class SolidAnalyzer
+    attr_reader :issues
+
+    def initialize
+      @issues = []
+    end
+
+    def analyze
+      check_single_responsibility
+      check_open_closed
+      check_liskov_substitution
+      check_interface_segregation
+      check_dependency_inversion
+    end
+
+    private
+
+    def add_issue(file, type, message)
+      @issues << { file: file, type: type, message: message }
+    end
+
+    def check_single_responsibility
+      # Check for classes with too many public methods (fat interfaces)
+      Dir.glob("app/models/**/*.rb").each do |file|
+        content = File.read(file)
+        public_methods = count_public_methods(content)
+        if public_methods > 10
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_srp", "#{class_name} has #{public_methods} public methods, violates Single Responsibility Principle (fat model)")
+        end
+
+        # Check for models with callbacks doing business logic
+        callback_methods = content.scan(/after_create|before_save|after_save|before_destroy|after_destroy/).count
+        if callback_methods > 2
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_srp", "#{class_name} has #{callback_methods} callbacks, consider moving to service objects or jobs")
+        end
+
+        # Check for models with complex business logic methods
+        complex_methods = content.scan(/def \w+.*\n.*\n.*\n.*\n.*end/m).count
+        if complex_methods > 0
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_srp", "#{class_name} has complex methods, extract to service objects")
+        end
+      end
+
+      Dir.glob("app/controllers/**/*.rb").each do |file|
+        content = File.read(file)
+        public_methods = count_public_methods(content)
+        if public_methods > 8
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_srp", "#{class_name} has #{public_methods} public actions, violates Single Responsibility Principle (fat controller)")
+        end
+
+        # Check for controllers doing business logic
+        if content.include?("UserMailer") || content.include?("NotificationService") || content.include?("ActivityLogger")
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_srp", "#{class_name} is doing business logic, extract to service objects")
+        end
+      end
+    end
+
+    def check_open_closed
+      # Check for long inheritance chains
+      Dir.glob("app/models/**/*.rb").each do |file|
+        content = File.read(file)
+        inheritance_depth = count_inheritance_depth(content)
+        if inheritance_depth > 3
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_ocp", "#{class_name} has inheritance depth of #{inheritance_depth}, consider composition over inheritance")
+        end
+      end
+
+      # Check for classes that would need modification for new features
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        if content.include?("case ") && content.scan(/when /).count > 3
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_ocp", "#{class_name} uses case statements that may need modification, consider polymorphism")
+        end
+      end
+    end
+
+    def check_liskov_substitution
+      # Check for STI models that might violate LSP
+      Dir.glob("app/models/**/*.rb").each do |file|
+        content = File.read(file)
+        if content.include?("self.inheritance_column") || content.match?(/class \w+ < \w+/)
+          class_name = extract_class_name(file)
+          # Look for methods that might not be implemented in subclasses
+          methods_with_bang = content.scan(/def \w+!/).map { |m| m.sub("def ", "").sub("!", "") }
+          if methods_with_bang.any?
+            add_issue(file, "solid_lsp", "#{class_name} uses inheritance/STI, ensure subclasses implement #{methods_with_bang.join(', ')} methods")
+          end
+        end
+      end
+
+      # Check for polymorphic associations that might violate contracts
+      Dir.glob("app/models/**/*.rb").each do |file|
+        content = File.read(file)
+        if content.include?("belongs_to :") && content.include?("polymorphic: true")
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_lsp", "#{class_name} uses polymorphic associations, ensure all associated classes honor the same interface")
+        end
+      end
+    end
+
+    def check_interface_segregation
+      # Check for controllers with many dependencies (includes/modules)
+      Dir.glob("app/controllers/**/*.rb").each do |file|
+        content = File.read(file)
+        includes_count = content.scan(/\binclude\b|\bextend\b|\bprepend\b/).count
+        if includes_count > 3
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_isp", "#{class_name} includes #{includes_count} modules, consider interface segregation")
+        end
+      end
+
+      # Check for heavy ActiveSupport::Concern usage
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        concern_methods = content.scan(/def \w+/).count
+        if content.include?("ActiveSupport::Concern") && concern_methods > 5
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_isp", "#{class_name} concern has #{concern_methods} methods, consider splitting into smaller concerns")
+        end
+      end
+
+      # Check for god services with many methods
+      Dir.glob("app/services/**/*.rb").each do |file|
+        content = File.read(file)
+        public_methods = count_public_methods(content)
+        if public_methods > 10
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_isp", "#{class_name} service has #{public_methods} methods, split into smaller focused services")
+        end
+      end
+    end
+
+    def check_dependency_inversion
+      # Check for direct instantiation of classes (new keyword)
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        new_calls = content.scan(/\b\w+\.new\b/).count
+        if new_calls > 2
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_dip", "#{class_name} has #{new_calls} direct instantiations, consider dependency injection")
+        end
+      end
+
+      # Check for hard-coded external service dependencies
+      Dir.glob("app/**/*.rb").each do |file|
+        content = File.read(file)
+        if content.include?("TwilioClient.new") || content.include?("Stripe::") || content.include?("HTTParty.get")
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_dip", "#{class_name} has hard-coded external dependencies, inject abstractions instead")
+        end
+      end
+
+      # Check for model callbacks triggering network calls
+      Dir.glob("app/models/**/*.rb").each do |file|
+        content = File.read(file)
+        callback_content = content.split(/\b(private|protected)\b/).first
+        if callback_content.include?("deliver") || callback_content.include?("HTTP") || callback_content.include?("Net::")
+          class_name = extract_class_name(file)
+          add_issue(file, "solid_dip", "#{class_name} has network calls in callbacks, move to background jobs")
+        end
+      end
+    end
+
+    def count_public_methods(content)
+      public_content = content.split(/\b(private|protected)\b/).first
+      public_content.scan(/def \w+/).count
+    end
+
+    def count_inheritance_depth(content)
+      inheritance_matches = content.scan(/class \w+ < (\w+(?:::\w+)*)/)
+      return 0 if inheritance_matches.empty?
+
+      # Simple depth calculation - in real app would need to resolve inheritance tree
+      inheritance_matches.first.first.split('::').count
+    end
+
+    def extract_class_name(file)
+      relative_path = file.sub('app/', '').sub('.rb', '')
+      parts = relative_path.split('/')
+      class_parts = parts.map do |part|
+        part.split('_').map(&:capitalize).join
+      end
+      class_parts.join('::')
+    end
+  end
+end

data/lib/rails_architect/tasks/rails_architect.rake

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rails_architect'
+
+namespace :rails_architect do
+  desc "Check SOLID principles"
+  task check_solid: :environment do
+    analyzer = RailsArchitect::SolidAnalyzer.new
+    analyzer.analyze
+    issues = analyzer.issues
+    puts "SOLID violations: #{issues.count}"
+    issues.each { |issue| puts "- #{issue[:message]}" }
+    exit 1 if issues.any?
+  end
+
+  desc "Check KISS principle (Keep It Simple)"
+  task check_kiss: :environment do
+    analyzer = RailsArchitect::KissAnalyzer.new
+    analyzer.analyze
+    issues = analyzer.issues
+    puts "KISS violations: #{issues.count}"
+    issues.each { |issue| puts "- #{issue[:message]}" }
+    exit 1 if issues.any?
+  end
+
+  desc "Check DRY principle (Don't Repeat Yourself)"
+  task check_dry: :environment do
+    analyzer = RailsArchitect::DryAnalyzer.new
+    analyzer.analyze
+    issues = analyzer.issues
+    puts "DRY violations: #{issues.count}"
+    issues.each { |issue| puts "- #{issue[:message]}" }
+    exit 1 if issues.any?
+  end
+end

data/lib/rails_architect/version.rb

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

data/lib/rails_architect.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails_architect/version"
+require "rails_architect/solid_analyzer"
+require "rails_architect/kiss_analyzer"
+require "rails_architect/dry_analyzer"
+require "rails_architect/railtie"
+
+module RailsArchitect
+  def self.analyze
+    all_issues = []
+
+    # Run SOLID analysis
+    solid_analyzer = SolidAnalyzer.new
+    solid_analyzer.analyze
+    all_issues.concat(solid_analyzer.issues)
+
+    # Run KISS analysis
+    kiss_analyzer = KissAnalyzer.new
+    kiss_analyzer.analyze
+    all_issues.concat(kiss_analyzer.issues)
+
+    # Run DRY analysis
+    dry_analyzer = DryAnalyzer.new
+    dry_analyzer.analyze
+    all_issues.concat(dry_analyzer.issues)
+
+    all_issues
+  end
+end

data/test/rails_app/README.md

@@ -0,0 +1,72 @@
+# Test Rails Application
+
+This is a sample Rails application designed to demonstrate various code quality violations that Rails Architect can detect.
+
+## Purpose
+
+This app contains intentional violations of software design principles to test the analyzers.
+
+## Violations by File
+
+### Models
+
+#### `app/models/user.rb`
+- **SOLID Violation**: Fat Model with 15+ instance methods
+  - Violates Single Responsibility Principle
+  - Should be split into separate concerns/services
+  - Exceeds threshold of 10 methods per model
+
+#### `app/models/report_generator.rb`
+- **KISS Violation**: Overly complex `generate_complex_report` method
+  - Deeply nested conditionals (if/elsif chains)
+  - Multiple loop types (while, until, for)
+  - Complex case statements
+  - Exceeds complexity threshold of 10
+  
+- **DRY Violation**: Duplicated calculation logic
+  - `calculate_user_score_v1` and `calculate_user_score_v2` contain identical code
+  - Should be refactored to a single method
+
+#### `app/models/post.rb`
+- Example of a well-structured model (no violations)
+
+### Controllers
+
+#### `app/controllers/users_controller.rb`
+- **SOLID Violation**: Controller doing too much
+  - Business logic in controller actions (calculating stats, reputation)
+  - Multiple responsibilities (data fetching, business logic, presentation)
+  - Should use service objects
+  
+- **KISS Violation**: Complex action logic
+  - Nested conditionals for permissions
+  - Multiple concerns mixed together in `create` action
+
+#### `app/controllers/posts_controller.rb`
+- **DRY Violation**: Repeated query and filtering patterns
+  - Same filtering logic in `index` and `recent` actions
+  - Repeated published/draft post selection
+  - Should be extracted to scopes or service methods
+
+## Running Checks
+
+From the gem root directory:
+
+```bash
+# Check SOLID principles
+bundle exec rake rails_architect:check_solid
+
+# Check KISS principle  
+bundle exec rake rails_architect:check_kiss
+
+# Check DRY principle
+bundle exec rake rails_architect:check_dry
+```
+
+## Expected Results
+
+When running the analyzers, you should see violations detected in:
+- User model (too many methods)
+- ReportGenerator (complex method, duplicated code)
+- UsersController (fat controller)
+- PostsController (code duplication)

data/test/rails_app/app/controllers/posts_controller.rb

@@ -0,0 +1,54 @@
+class PostsController < ApplicationController
+  # DRY Violation: Repeated query patterns
+  def index
+    @posts = Post.all.includes(:user)
+
+    # Potential N+1 query - accessing user.name for each post
+    @posts.each do |post|
+      puts "Author: #{post.user.name}"
+      puts "Comments: #{post.comments.count}"
+    end
+    
+    # Repeated filtering logic (DRY violation)
+    @published_posts = @posts.select { |p| p.published? }
+    @draft_posts = @posts.reject { |p| p.published? }
+  end
+
+  def show
+    @post = Post.find(params[:id])
+    @comments = @post.comments.includes(:user)
+
+    # Another potential N+1
+    @comments.each do |comment|
+      puts comment.user.email
+    end
+  end
+
+  # DRY Violation: Similar logic to index
+  def recent
+    @posts = Post.all.includes(:user)
+    
+    # Same filtering logic as in index
+    @published_posts = @posts.select { |p| p.published? }
+    @draft_posts = @posts.reject { |p| p.published? }
+    
+    render :index
+  end
+
+  def create
+    @post = current_user.posts.build(post_params)
+
+    if @post.save
+      redirect_to @post
+    else
+      render :new
+    end
+  end
+
+  private
+
+  def post_params
+    params.require(:post).permit(:title, :content, :published)
+  end
+end
+```

data/test/rails_app/app/controllers/users_controller.rb

@@ -0,0 +1,104 @@
+class UsersController < ApplicationController
+  before_action :set_user, only: [:show, :edit, :update, :destroy]
+  before_action :authenticate_user!
+  before_action :authorize_admin, only: [:index, :destroy]
+
+  # SOLID Violation: Controller action doing too much (violates Single Responsibility)
+  def index
+    @users = User.all
+    @users = @users.where(organization_id: current_user.organization_id) unless current_user.admin?
+    @users = @users.page(params[:page]).per(20)
+    
+    # Doing business logic in controller
+    @user_stats = @users.map do |user|
+      {
+        id: user.id,
+        posts_count: user.posts.count,
+        comments_count: user.comments.count,
+        reputation: user.posts.count * 5 + user.comments.count * 2
+      }
+    end
+  end
+
+  # KISS Violation: Complex controller action
+  def show
+    @posts = @user.posts.includes(:comments).limit(10)
+    @recent_comments = @user.comments.order(created_at: :desc).limit(5)
+    
+    # Complex conditional logic in controller
+    if @user.admin?
+      @permissions = ['all']
+    elsif @user.moderator?
+      @permissions = ['read', 'write', 'moderate']
+    else
+      @permissions = ['read']
+    end
+  end
+
+  def new
+    @user = User.new
+    @organizations = Organization.all
+  end
+
+  def create
+    @user = User.new(user_params)
+    @user.organization = current_user.organization unless current_user.admin?
+
+    if @user.save
+      # Should be in a service object
+      UserMailer.welcome(@user).deliver_later
+      NotificationService.notify_admins(@user)
+      ActivityLogger.log_user_creation(@user)
+      
+      redirect_to @user, notice: 'User was successfully created.'
+    else
+      @organizations = Organization.all
+      render :new
+    end
+  end
+
+  def edit
+    @organizations = Organization.all
+  end
+
+  def update
+    if @user.update(user_params)
+      redirect_to @user, notice: 'User was successfully updated.'
+    else
+      @organizations = Organization.all
+      render :edit
+    end
+  end
+
+  def destroy
+    @user.destroy
+    redirect_to users_url, notice: 'User was successfully destroyed.'
+  end
+
+  def activate
+    @user = User.find(params[:id])
+    @user.activate
+    redirect_to @user, notice: 'User activated.'
+  end
+
+  def deactivate
+    @user = User.find(params[:id])
+    @user.deactivate
+    redirect_to @user, notice: 'User deactivated.'
+  end
+
+  private
+
+  def set_user
+    @user = User.find(params[:id])
+  end
+
+  def user_params
+    params.require(:user).permit(:name, :email, :role, :organization_id)
+  end
+
+  def authorize_admin
+    redirect_to root_path unless current_user.admin?
+  end
+end
+```

data/test/rails_app/app/models/post.rb

@@ -0,0 +1,34 @@
+class Post < ApplicationRecord
+  belongs_to :user
+  has_many :comments
+
+  validates :title, presence: true
+  validates :content, presence: true
+
+  scope :published, -> { where(published: true) }
+  scope :recent, -> { order(created_at: :desc) }
+
+  def author_name
+    user.name
+  end
+
+  def comment_count
+    comments.count
+  end
+
+  def published_comments
+    comments.where(published: true)
+  end
+
+  def featured?
+    featured
+  end
+
+  def publish
+    update(published: true, published_at: Time.current)
+  end
+
+  def unpublish
+    update(published: false, published_at: nil)
+  end
+end