RubyGems - rails_code_auditor - Versions diffs - 0.1.0 - Mend

rails_code_auditor 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

checksums.yaml +7 -0
data/exe/rails_code_auditor +4 -0
data/lib/rails_code_auditor/analyzer.rb +150 -0
data/lib/rails_code_auditor/grapher.rb +80 -0
data/lib/rails_code_auditor/html_to_pdf_converter.rb +62 -0
data/lib/rails_code_auditor/llm_client.rb +71 -0
data/lib/rails_code_auditor/pdf_generator.rb +80 -0
data/lib/rails_code_auditor/report_generator.rb +175 -0
data/lib/rails_code_auditor/scorer.rb +129 -0
data/lib/rails_code_auditor/simplecov_runner.rb +82 -0
data/lib/rails_code_auditor/version.rb +5 -0
data/lib/rails_code_auditor.rb +31 -0
metadata +270 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83cd23ea4027538587a1814cbf2a3472bd818fe0cb15bf492a3ab54b565c2e63
+  data.tar.gz: 40438e254bed8d07966559ac52df8a3063f427167fbc236a8eac0fba6a591c1d
+SHA512:
+  metadata.gz: e1cdd901ff82b3f2c2d5f0be65175a03b534a6d3a401c34a9c85861401ea2cf416162a1045fe34b2e8cf0ef79a3a220a1c1e9f87b81fff05d06b973735974227
+  data.tar.gz: 721d41c939a3e00321508a4c36033221e58b6f67a6fd1f0ee9df090e1ae289fafe0b65c94e0f07b7e20c6b3c4bad375463b763f00d440c7a96c29af529e6cde2

data/exe/rails_code_auditor ADDED Viewed

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "rails_code_auditor"
+RailsCodeAuditor.run(ARGV)

data/lib/rails_code_auditor/analyzer.rb ADDED Viewed

@@ -0,0 +1,150 @@
+require "fileutils"
+module RailsCodeAuditor
+  class Analyzer
+    REPORT_FOLDER = "report"
+    def self.ruby_version
+      Gem::Version.new(RUBY_VERSION)
+    end
+    def self.rails_version
+      defined?(Rails) ? Gem::Version.new(Rails.version) : nil
+    end
+    def self.run_cmd(command, raw: false)
+      puts "Running: #{command}"
+      output = `#{command}`
+      if output.empty?
+        nil
+      else
+        begin
+          raw ? output : JSON.parse(output)
+        rescue StandardError
+          output
+        end
+      end
+    end
+    def self.ensure_report_folder
+      FileUtils.mkdir_p(REPORT_FOLDER)
+    end
+    def self.write_html_report(tool_name, content)
+      path = File.join(REPORT_FOLDER, "#{tool_name}.html")
+      File.open(path, "w") do |f|
+        f.puts "<html><head><title>#{tool_name.capitalize} Report</title></head><body><pre>"
+        f.puts "<h1>#{tool_name.capitalize} Report</h1>"
+        f.puts content
+        f.puts "</pre></body></html>"
+      end
+      path
+    end
+    def self.generate_brakeman_html
+      run_cmd("brakeman -o #{REPORT_FOLDER}/brakeman.html", raw: true)
+      "#{REPORT_FOLDER}/brakeman.html"
+    end
+    def self.generate_rails_best_practices_html
+      run_cmd("rails_best_practices -f html --output-file #{REPORT_FOLDER}/rails_best_practices.html", raw: true)
+      "#{REPORT_FOLDER}/rails_best_practices.html"
+    end
+    def self.generate_rubycritic_html
+      run_cmd("rubycritic --no-browser --path #{REPORT_FOLDER}/rubycritic", raw: true)
+      "#{REPORT_FOLDER}/rubycritic/overview.html"
+    end
+    def self.generate_reek_html
+      run_cmd("reek --format html > report/reek.html", raw: true)
+      "#{REPORT_FOLDER}/reek.html"
+    end
+    def self.run_all
+      ensure_report_folder
+      results = {}
+      results[:brakeman] = {
+        json: run_cmd("brakeman -f json --no-exit-on-error"),
+        html_path: run_cmd("brakeman -o #{REPORT_FOLDER}/brakeman.html", raw: true)
+      }
+      results[:bundler_audit] = {
+        json: run_cmd("bundle audit check --verbose"),
+        html_path: write_html_report("bundler_audit", run_cmd("bundle audit check --verbose"))
+      }
+      results[:rubocop] = if ruby_version >= Gem::Version.new("2.7")
+                            {
+                              json: run_cmd("rubocop --format json"),
+                              html_path: write_html_report("rubocop", run_cmd("rubocop --format simple"))
+                            }
+                          else
+                            { skipped: true, reason: "Rubocop requires Ruby >= 2.7" }
+                          end
+      results[:rails_best_practices] = {
+        json: run_cmd("rails_best_practices --format json"),
+        html_path: run_cmd("rails_best_practices -f html --output-file #{REPORT_FOLDER}/rails_best_practices.html",
+                           raw: true)
+      }
+      results[:flay] = {
+        text: run_cmd("flay --mass 50 ."),
+        html_path: write_html_report("flay", run_cmd("flay --mass 50 ."))
+      }
+      results[:flog] = {
+        text: run_cmd("flog ."),
+        html_path: write_html_report("flog", run_cmd("flog ."))
+      }
+      results[:license_finder] = if ruby_version >= Gem::Version.new("2.7")
+                                   {
+                                     json: run_cmd("license_finder --format json"),
+                                     html_path: write_html_report("license_finder",
+                                                                  run_cmd("license_finder --format text"))
+                                   }
+                                 else
+                                   { skipped: true, reason: "LicenseFinder requires Ruby >= 2.7" }
+                                 end
+      results[:reek] = {
+        json: run_cmd("reek --format json"),
+        html_path: run_cmd("reek --format html > #{REPORT_FOLDER}/reek.html", raw: true)
+      }
+      begin
+        Timeout.timeout(300) do
+          results[:rubycritic] = if ruby_version >= Gem::Version.new("2.7")
+                                   {
+                                     json: run_cmd("rubycritic --format json"),
+                                     html_path: run_cmd("rubycritic --no-browser --path #{REPORT_FOLDER}/rubycritic",
+                                                        raw: true)
+                                   }
+                                 else
+                                   { skipped: true, reason: "RubyCritic requires Ruby >= 2.7" }
+                                 end
+        end
+      rescue Timeout::Error
+        results[:rubycritic] = { error: "RubyCritic timed out after 5 minutes" }
+      end
+      results[:fasterer] = {
+        text: run_cmd("fasterer ."),
+        html_path: write_html_report("fasterer", run_cmd("fasterer ."))
+      }
+      # Optional: tools only if Rails >= 5
+      if rails_version && rails_version >= Gem::Version.new("5.0")
+        results[:grover] = {
+          html_path: write_html_report("grover", "Grover logic here (if you use it)")
+        }
+      end
+      results
+    end
+  end
+end

data/lib/rails_code_auditor/grapher.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require "gruff"
+require 'active_support/core_ext/hash/indifferent_access'
+module RailsCodeAuditor
+  class Grapher
+    REPORT_PATH = "./report".freeze
+    def self.generate(results)
+      results = results.with_indifferent_access
+      Dir.mkdir(REPORT_PATH) unless Dir.exist?(REPORT_PATH)
+      graphs = []
+      summary = {
+        "Security" => results[:security],
+        "Code Quality" => results[:code_quality],
+        "Dependencies" => results[:dependencies],
+        "Test Coverage" => results[:test_coverage],
+        "Overall" => results[:overall]
+      }.compact
+      graphs << graph_bar("Audit Scores", summary)
+      summary.each do |label, data|
+        graphs << graph_pie(label, data[:score])
+      end
+      graphs
+    end
+    def self.graph_bar(title, metrics)
+      g = Gruff::Bar.new
+      g.title = title
+      labels = {}
+      metrics.each_with_index do |(label, data), index|
+        score = data[:score] || 0
+        labels[index] = label
+        g.data(label, [score], bar_color(score))
+      end
+      g.labels = labels
+      file_name = "#{title.downcase.gsub(" ", "_")}.png"
+      path = File.join(REPORT_PATH, file_name)
+      g.write(path)
+      puts "Generated graph at #{path}"
+      { title: title, path: path }
+    end
+    def self.graph_pie(title, score)
+      score = score || 0
+      remaining = 100 - score
+      g = Gruff::Pie.new
+      g.title = title
+      g.data("Score", score, bar_color(score))
+      g.data("Remaining", remaining, "#dddddd")
+      file_name = "#{title.downcase.gsub(" ", "_")}_pie.png"
+      path = File.join(REPORT_PATH, file_name)
+      g.write(path)
+      puts "Generated pie chart: #{path}"
+      { title: title, path: path }
+    end
+    def self.bar_color(score)
+      case score
+      when 0..49   then '#e74c3c' # red
+      when 50..74  then '#f1c40f' # yellow
+      when 75..89  then '#3498db' # blue
+      else              '#2ecc71' # green
+      end
+    end
+  end
+end

data/lib/rails_code_auditor/html_to_pdf_converter.rb ADDED Viewed

@@ -0,0 +1,62 @@
+require "fileutils"
+require "grover"
+module RailsCodeAuditor
+  class HtmlToPdfConverter
+    INPUT_PATHS = ["report", "report/rubycritic"]
+    OUTPUT_PATH = "report/pdf"
+    def self.puppeteer_installed?
+      system("npx puppeteer --version > /dev/null 2>&1")
+    end
+    def self.convert_all
+      unless puppeteer_installed?
+        puts "[!] Puppeteer is not installed. Please run: yarn add puppeteer"
+        return []
+      end
+      FileUtils.mkdir_p(OUTPUT_PATH)
+      pdf_paths = []
+      html_files = INPUT_PATHS.flat_map { |path| Dir["#{path}/*.html"] }
+      if html_files.empty?
+        puts "[!] No HTML files found in #{INPUT_PATHS.join(', ')}"
+        return []
+      end
+      html_files.each do |html_path|
+        begin
+          relative_name = html_path.sub(%r{^.*?report/}, "").gsub("/", "_")
+          pdf_filename = relative_name.sub(/\.html$/, ".pdf")
+          pdf_output_path = File.join(OUTPUT_PATH, pdf_filename)
+          html_content = File.read(html_path)
+          grover = Grover.new(
+            html_content,
+            print_background: true,
+            prefer_css_page_size: true,
+            wait_until: 'networkidle0',
+            format: 'A4',
+            margin: { top: '1cm', bottom: '1cm' }
+          )
+          File.write(pdf_output_path, grover.to_pdf)
+          pdf_paths << pdf_output_path
+          puts "[✓] PDF generated: #{pdf_output_path}"
+        rescue Grover::DependencyError => e
+          puts "[!] Puppeteer is required but not available. Skipping: #{html_path}"
+          next
+        rescue => e
+          puts "[!] Failed to convert #{html_path}: #{e.class} - #{e.message}"
+          next
+        end
+      end
+      pdf_paths
+    end
+  end
+end

data/lib/rails_code_auditor/llm_client.rb ADDED Viewed

@@ -0,0 +1,71 @@
+require "json"
+require "net/http"
+require "uri"
+module RailsCodeAuditor
+  class LlmClient
+    def self.sanitize_results(results)
+      results.transform_values do |tool|
+        tool.dup.tap do |entry|
+          if entry.is_a?(Hash) && entry[:details].is_a?(String)
+            entry[:details] = entry[:details].slice(0, 500) # Trim details to avoid LLM overload
+            entry[:details].gsub!(/\e\[[\d;]*m/, '')         # Remove ANSI color codes
+          end
+        end
+      end
+    end
+    def self.score_with_llm(json_results)
+      sanitized = sanitize_results(json_results)
+      puts "[*] Scoring with LLM (LLaMA3)..."
+      prompt = <<~PROMPT
+        Analyze the following Rails code audit summary and return a JSON object like:
+        {
+          "security": 75,
+          "code_quality": 80,
+          "test_coverage": 60,
+          "dependencies": 90,
+          "overall": 76
+        }
+        Only return the raw JSON, nothing else.
+        Input:
+        #{JSON.pretty_generate(sanitized)}
+      PROMPT
+      uri = URI("http://localhost:11434/api/generate")
+      body = {
+        model: "llama3",
+        prompt: prompt,
+        stream: false
+      }
+      response = Net::HTTP.post(uri, body.to_json, "Content-Type" => "application/json")
+      response_body = JSON.parse(response.body)
+      raw_output = response_body["response"].strip
+      # Try to extract JSON from any surrounding text
+      json_match = raw_output.match(/\{.*\}/m)
+      if json_match
+        parsed_scores = JSON.parse(json_match[0])
+        scored_results = parsed_scores.transform_values do |score|
+          remark = case score
+                  when 90..100 then "Excellent"
+                  when 75..89  then "Good"
+                  when 60..74  then "Average"
+                  else              "Needs Improvement"
+                  end
+          { score: score, remark: remark }
+        end
+        scored_results
+      else
+        raise "Response did not contain valid JSON"
+      end
+    rescue => e
+      puts "[!] LLM scoring failed: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/rails_code_auditor/pdf_generator.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require "prawn"
+require "prawn/table"
+require "fileutils"
+require "combine_pdf"
+require "active_support/core_ext/string/inflections"
+module RailsCodeAuditor
+  class PdfGenerator
+    OUTPUT_PATH = "code_audit_report.pdf"
+    TEMP_PRWAN_PDF = "tmp/main_audit.pdf"
+    def self.generate(results, scores, graphs, html_pdf_paths = [])
+      FileUtils.mkdir_p("tmp")
+      FileUtils.mkdir_p("report/pdf")
+      # Generate main Prawn PDF
+      Prawn::Document.generate(TEMP_PRWAN_PDF) do |pdf|
+        pdf.text "Rails Code Audit Report", size: 24, style: :bold, align: :center
+        pdf.move_down 20
+        # Summary Scores Table
+        pdf.text "Audit Summary Scores", size: 16, style: :bold
+        pdf.move_down 10
+        summary_data = [["Metric", "Score (0-100)", "Remarks"]]
+        scores.each do |metric, value|
+          summary_data << [metric.to_s.humanize, value[:score], value[:remark]]
+        end
+        pdf.table(summary_data, header: true, width: pdf.bounds.width)
+        pdf.move_down 20
+        # Detailed Audit Results
+        pdf.text "Detailed Audit Results", size: 16, style: :bold
+        pdf.move_down 10
+        results.each do |check_name, result|
+          pdf.text check_name.to_s.humanize, size: 12, style: :bold
+          pdf.text "Status: #{result[:status]}"
+          pdf.text "Details: #{result[:details]}"
+          pdf.move_down 10
+        end
+        # Graphs (optional)
+        if graphs && graphs.any?
+          pdf.start_new_page
+          pdf.text "Visual Graphs", size: 16, style: :bold
+          pdf.move_down 10
+          graphs.each do |graph|
+            if File.exist?(graph[:path])
+              pdf.text graph[:title], size: 12, style: :bold
+              pdf.image graph[:path], fit: [500, 300]
+              pdf.move_down 20
+            else
+              puts "[!] Graph file missing: #{graph[:path]}"
+            end
+          end
+        end
+        pdf.number_pages "Page <page> of <total>", at: [pdf.bounds.right - 150, 0]
+      end
+      puts "[✓] Main audit PDF saved to #{TEMP_PRWAN_PDF}"
+      # Merge all PDFs (main + html converted)
+      combined_pdf = CombinePDF.new
+      combined_pdf << CombinePDF.load(TEMP_PRWAN_PDF)
+      html_pdf_paths.each do |pdf_path|
+        if File.exist?(pdf_path)
+          puts "[+] Merging #{pdf_path}"
+          combined_pdf << CombinePDF.load(pdf_path)
+        else
+          puts "[!] Skipped missing HTML-generated PDF: #{pdf_path}"
+        end
+      end
+      combined_pdf.save(OUTPUT_PATH)
+      puts "[✓] Final merged PDF saved to #{OUTPUT_PATH}"
+    end
+  end
+end

data/lib/rails_code_auditor/report_generator.rb ADDED Viewed

@@ -0,0 +1,175 @@
+module RailsCodeAuditor
+  class ReportGenerator
+    def self.normalize(results)
+      {
+        brakeman: summarize_or_skip(:brakeman, results) { |res| summarize_brakeman(res[:json]) },
+        bundler_audit: summarize_or_skip(:bundler_audit, results) { |res| summarize_bundler(res[:json]) },
+        rubocop: summarize_or_skip(:rubocop, results) { |res| summarize_rubocop(res[:json]) },
+        rails_best_practices: summarize_or_skip(:rails_best_practices, results) do |res|
+          summarize_rails_best_practices(res[:json])
+        end,
+        flay: summarize_or_skip(:flay, results) { |res| summarize_text_tool("Flay", res[:text]) },
+        flog: summarize_or_skip(:flog, results) { |res| summarize_text_tool("Flog", res[:text]) },
+        license_finder: summarize_or_skip(:license_finder, results) { |res| summarize_license_finder(res[:json]) },
+        reek: summarize_or_skip(:reek, results) { |res| summarize_reek(res[:json]) },
+        rubycritic: summarize_or_skip(:rubycritic, results) { |res| summarize_rubycritic(res[:json]) },
+        fasterer: summarize_or_skip(:fasterer, results) { |res| summarize_fasterer(res[:text]) }
+      }
+    end
+    def self.summarize_or_skip(tool, results)
+      if results[tool]&.dig(:skipped)
+        {
+          status: "Skipped",
+          details: results[tool][:reason] || "Tool not available in this environment"
+        }
+      elsif results[tool].nil?
+        {
+          status: "Not Run",
+          details: "No data available for #{tool}"
+        }
+      else
+        yield(results[tool])
+      end
+    end
+    def self.summarize_brakeman(raw)
+      json = parse_json_input(raw, label: "Brakeman")
+      warnings = json["warnings"] || []
+      summary = warnings.map { |w| "#{w["warning_type"]}: #{w["message"]} in #{w["file"]}" }.join("\n")
+      {
+        status: "#{warnings.size} security warning#{"s" unless warnings.size == 1}",
+        details: summary
+      }
+    end
+    def self.parse_json_input(input, label: "JSON")
+      case input
+      when String
+        begin
+          JSON.parse(input)
+        rescue JSON::ParserError => e
+          warn "❌ Failed to parse #{label} string: #{e.message}"
+          {}
+        end
+      when Hash
+        input
+      else
+        warn "❌ Unsupported #{label} input type: #{input.class}"
+        {}
+      end
+    end
+    def self.summarize_bundler(raw)
+      json = begin
+        JSON.parse(raw)
+      rescue StandardError
+        {}
+      end
+      vulns = json["advisories"] || []
+      details = vulns.map { |v| "#{v["gem"]}: #{v["title"]}" }.join("\n")
+      {
+        status: "#{vulns.size} vulnerability#{"ies" unless vulns.size == 1}",
+        details: details
+      }
+    end
+    def self.summarize_rubocop(raw)
+      json = begin
+        JSON.parse(raw)
+      rescue StandardError
+        {}
+      end
+      offenses = json["files"]&.flat_map { |f| f["offenses"] } || []
+      details = offenses.map { |o| "#{o["cop_name"]}: #{o["message"]}" }.join("\n")
+      {
+        status: "#{offenses.size} code offense#{"s" unless offenses.size == 1}",
+        details: details
+      }
+    end
+    def self.summarize_rails_best_practices(raw)
+      issues = begin
+        JSON.parse(raw)
+      rescue StandardError
+        []
+      end
+      status = "#{issues.size} issue#{"s" unless issues.size == 1}"
+      grouped = issues.group_by { |issue| issue["message"] }
+      details = grouped.map do |message, group|
+        "#{message} (#{group.size}x)"
+      end.join("\n")
+      {
+        status: status,
+        details: details
+      }
+    end
+    def self.summarize_text_tool(name, raw)
+      lines = raw ? raw.split("\n").reject(&:empty?) : []
+      {
+        status: "#{lines.size} issue#{"s" unless lines.size == 1}",
+        details: lines.first(10).join("\n") + (lines.size > 10 ? "\n..." : "")
+      }
+    end
+    def self.summarize_license_finder(raw)
+      json = begin
+        JSON.parse(raw)
+      rescue StandardError
+        []
+      end
+      problematic = json.select { |pkg| pkg["approved"] == false }
+      details = problematic.map { |p| "#{p["name"]} - #{p["licenses"].join(", ")}" }.join("\n")
+      {
+        status: "#{problematic.size} unapproved license#{"s" unless problematic.size == 1}",
+        details: details
+      }
+    end
+    def self.summarize_reek(raw)
+      parsed = raw.is_a?(String) ? JSON.parse(raw, symbolize_names: true) : raw
+      puts "JSON array but got #{parsed.class}" unless parsed.is_a?(Array)
+      total_smells = parsed.size
+      sample_smells = parsed.first(10)
+      details = sample_smells.map do |smell|
+        "#{smell["source"]} [#{smell["lines"].join(", ")}]: #{smell["message"]} (#{smell["smell_type"]})"
+      end
+      {
+        status: "#{total_smells} smell#{"s" unless total_smells == 1}",
+        details: details.join("\n") + (total_smells > 10 ? "\n..." : "")
+      }
+    end
+    def self.summarize_rubycritic(raw)
+      lines = raw.to_s.split("\n").map(&:strip).reject(&:empty?)
+      # Extract score
+      score_line = lines.find { |line| line.match?(/^Score:\s+\d+(\.\d+)?$/) }
+      score = score_line&.match(/Score:\s+([\d.]+)/)&.captures&.first
+      # Extract letter-grade issues (lines that start with a grade followed by a dash)
+      issues = lines.select { |line| line.match?(/^\b[FABCDE]\b\s+-\s+/) }
+      {
+        status: score ? "Score: #{score}" : "No score found",
+        details: issues.first(10).join("\n") + (issues.size > 10 ? "\n..." : "")
+      }
+    end
+    def self.summarize_fasterer(raw)
+      suggestions = raw.lines.select { |line| line.include?(":") }
+      {
+        status: "#{suggestions.size} performance suggestion#{"s" unless suggestions.size == 1}",
+        details: suggestions.join("\n")
+      }
+    end
+  end
+end

data/lib/rails_code_auditor/scorer.rb ADDED Viewed

@@ -0,0 +1,129 @@
+module RailsCodeAuditor
+  class Scorer
+    def self.score(results)
+      scores = {
+        security: {
+          score: security_score(results),
+          remark: remark_for(security_score(results))
+        },
+        code_quality: {
+          score: code_quality_score(results),
+          remark: remark_for(code_quality_score(results))
+        },
+        dependencies: {
+          score: dependency_score(results),
+          remark: remark_for(dependency_score(results))
+        },
+        test_coverage: {
+          score: test_coverage_score(results),
+          remark: remark_for(test_coverage_score(results))
+        }
+      }
+      overall = overall_score(scores)
+      scores[:overall] = {
+        score: overall,
+        remark: remark_for(overall)
+      }
+      scores
+    end
+    def self.remark_for(score)
+      case score
+      when 90..100 then "Excellent"
+      when 75..89  then "Good"
+      when 60..74  then "Fair"
+      else              "Needs Improvement"
+      end
+    end
+    def self.security_score(results)
+      tool_scores = [
+        extract_issue_count(results.dig(:brakeman, :status)),
+        extract_issue_count(results.dig(:bundler_audit, :status))
+      ].compact
+      total = tool_scores.sum
+      active_tools = tool_scores.size
+      calculate_score(total, active_tools)
+    end
+    def self.code_quality_score(results)
+      issue_counts = [
+        extract_issue_count(results.dig(:rubocop, :status)),
+        extract_issue_count(results.dig(:rails_best_practices, :status)),
+        extract_issue_count(results.dig(:reek, :status)),
+        extract_issue_count(results.dig(:flay, :status)),
+        extract_issue_count(results.dig(:flog, :status)),
+        extract_issue_count(results.dig(:fasterer, :status))
+      ].compact
+      total_issues = issue_counts.sum
+      active_tool_count = issue_counts.size
+      issue_score = calculate_score(total_issues, active_tool_count)
+      # Handle RubyCritic separately
+      rubycritic_score = extract_rubycritic_score(results.dig(:rubycritic, :status))
+      if rubycritic_score
+        ((issue_score + rubycritic_score) / 2.0).round
+      else
+        issue_score
+      end
+    end
+    def self.extract_rubycritic_score(status)
+      return nil unless status.is_a?(String)
+      return nil if status.downcase.include?("skipped") || status.downcase.include?("not run")
+      return unless match = status.match(/Score:\s*([0-9.]+)/)
+      match[1].to_f.round
+    end
+    def self.dependency_score(results)
+      count = extract_issue_count(results.dig(:license_finder, :status))
+      return 100 if count.nil? # Tool skipped
+      calculate_score(count, 1)
+    end
+    def self.test_coverage_score(results)
+      status = results.dig(:simplecov, :status)
+      return 100 if !status.is_a?(String) || status.downcase.include?("skipped") || status.downcase.include?("not run")
+      if status.match(/Coverage:\s*([\d.]+)/)
+        ::Regexp.last_match(1).to_f.round
+      else
+        0
+      end
+    end
+    def self.extract_issue_count(status)
+      return nil unless status.is_a?(String)
+      return nil if status.downcase.include?("skipped") || status.downcase.include?("not run")
+      if match = status.match(/(\d+)/)
+        match[1].to_i
+      else
+        0
+      end
+    end
+    def self.calculate_score(issue_count, active_tool_count)
+      return 100 if issue_count == 0
+      return 0 if active_tool_count == 0
+      score = 100 - (issue_count.to_f / (active_tool_count * 10)) * 10
+      [[score.round, 0].max, 100].min
+    end
+    def self.overall_score(scores_hash)
+      category_scores = scores_hash.values.map { |v| v[:score] }.compact
+      return 0 if category_scores.empty?
+      (category_scores.sum / category_scores.size.to_f).round
+    end
+  end
+end

data/lib/rails_code_auditor/simplecov_runner.rb ADDED Viewed

@@ -0,0 +1,82 @@
+require "json"
+require "bundler"
+module RailsCodeAuditor
+  class SimpleCovRunner
+    def self.run
+      setup_file = ".simplecov_setup.rb"
+      unless simplecov_installed_in_project?
+        return {
+          status: "Skipped",
+          success: false,
+          error: "simplecov gem not found in the target Rails app",
+          details: "simplecov gem not found in the target Rails app"
+        }
+      end
+      File.write(setup_file, <<~RUBY)
+        require 'simplecov'
+        SimpleCov.start 'rails' do
+          enable_coverage :branch
+          add_filter '/test/'
+          add_filter '/spec/'
+        end
+        SimpleCov.command_name ENV.fetch("SIMPLECOV_COMMAND_NAME", "Rails Tests")
+        puts "[SimpleCov] started"
+      RUBY
+      test_cmd =
+        if Dir.exist?("spec")
+          "SIMPLECOV_COMMAND_NAME='RSpec Tests' bundle exec ruby -r./#{setup_file} -S rspec"
+        elsif Dir.exist?("test")
+          "SIMPLECOV_COMMAND_NAME='Rails Tests' bundle exec ruby -r./#{setup_file} -S rails test"
+        else
+          return { status: "Coverage: 0%", error: "No test directory found", success: false,
+                   details: "No test directory found" }
+        end
+      success = system(test_cmd)
+      coverage_path = "coverage/.last_run.json"
+      if File.exist?(coverage_path)
+        json = JSON.parse(File.read(coverage_path))
+        percent = json["result"]["covered_percent"] || json["result"]["line"]
+        if percent
+          percent = percent.round(2)
+          {
+            status: "Coverage: #{percent}%",
+            success: success,
+            raw_result: json,
+            details: json
+          }
+        else
+          {
+            status: "Coverage: N/A",
+            success: false,
+            error: "Coverage percentage not found in report",
+            details: json
+          }
+        end
+      else
+        {
+          status: "Coverage: 0%",
+          success: success,
+          error: "Coverage file not generated",
+          details: "Coverage file not generated"
+        }
+      end
+    ensure
+      File.delete(setup_file) if setup_file && File.exist?(setup_file)
+    end
+    def self.simplecov_installed_in_project?
+      spec = Bundler.locked_gems.specs.find { |s| s.name == "simplecov" }
+      !spec.nil?
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/rails_code_auditor/version.rb ADDED Viewed

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

data/lib/rails_code_auditor.rb ADDED Viewed

@@ -0,0 +1,31 @@
+require "rails_code_auditor/analyzer"
+require "rails_code_auditor/report_generator"
+require "rails_code_auditor/pdf_generator"
+require "rails_code_auditor/grapher"
+require "rails_code_auditor/scorer"
+require "rails_code_auditor/llm_client"
+require "rails_code_auditor/simplecov_runner"
+rails_version = defined?(Rails) ? Gem::Version.new(Rails::VERSION::STRING) : nil
+USE_GROVER = rails_version.nil? || rails_version >= Gem::Version.new("5.0")
+require "rails_code_auditor/html_to_pdf_converter" if USE_GROVER
+module RailsCodeAuditor
+  def self.run(args)
+    puts "[*] Running Rails Code Auditor..."
+    raw_results = Analyzer.run_all
+    results = ReportGenerator.normalize(raw_results)
+    results[:simplecov] = SimpleCovRunner.run
+    scores = if args.include?("--use-llm")
+               LlmClient.score_with_llm(results) || Scorer.score(results)
+             else
+               Scorer.score(results)
+             end
+    graphs = Grapher.generate(scores)
+    html_pdf_paths = USE_GROVER ? HtmlToPdfConverter.convert_all : []
+    PdfGenerator.generate(results, scores, graphs, html_pdf_paths)
+    puts "[✓] Audit complete. PDF report generated."
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,270 @@
+--- !ruby/object:Gem::Specification
+name: rails_code_auditor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- sivamanikandan
+bindir: exe
+cert_chain: []
+date: 2025-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: brakeman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: combine_pdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fasterer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: flay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.3
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+- !ruby/object:Gem::Dependency
+  name: gruff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: prawn-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: rails_best_practices
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: license_finder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.9.2
+- !ruby/object:Gem::Dependency
+  name: grover
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: rails_code_auditor is a developer-friendly Ruby gem that automates the
+  process of auditing your Rails codebase. It runs a suite of essential tools—including
+  Brakeman, Bundler Audit, RuboCop, Rails Best Practices, Flay, Flog, and License
+  Finder—and consolidates all outputs into a single readable report.
+email:
+- sivamanikandan@railsfactory.org
+executables:
+- rails_code_auditor
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/rails_code_auditor
+- lib/rails_code_auditor.rb
+- lib/rails_code_auditor/analyzer.rb
+- lib/rails_code_auditor/grapher.rb
+- lib/rails_code_auditor/html_to_pdf_converter.rb
+- lib/rails_code_auditor/llm_client.rb
+- lib/rails_code_auditor/pdf_generator.rb
+- lib/rails_code_auditor/report_generator.rb
+- lib/rails_code_auditor/scorer.rb
+- lib/rails_code_auditor/simplecov_runner.rb
+- lib/rails_code_auditor/version.rb
+homepage: https://github.com/railsfactory-sivamanikandan/rails_code_auditor
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/railsfactory-sivamanikandan/rails_code_auditor
+  source_code_uri: https://github.com/railsfactory-sivamanikandan/rails_code_auditor
+  changelog_uri: https://github.com/railsfactory-sivamanikandan/rails_code_auditor/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Easily generate consolidated security and code quality reports for Ruby on
+  Rails applications with a single command.
+test_files: []