Class: RailsCodeAuditor::Scorer

Inherits:
Object
  • Object
show all
Defined in:
lib/rails_code_auditor/scorer.rb

Class Method Summary collapse

Class Method Details

.calculate_score(issue_count, active_tool_count) ⇒ Object 



114
115
116
117
118
119
120
 
# File 'lib/rails_code_auditor/scorer.rb', line 114

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

.code_quality_score(results) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/rails_code_auditor/scorer.rb', line 52

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

.dependency_score(results) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/rails_code_auditor/scorer.rb', line 85

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

.extract_issue_count(status) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
 
# File 'lib/rails_code_auditor/scorer.rb', line 103

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

.extract_rubycritic_score(status) ⇒ Object 



76
77
78
79
80
81
82
83
 
# File 'lib/rails_code_auditor/scorer.rb', line 76

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

.overall_score(scores_hash) ⇒ Object 



122
123
124
125
126
127
 
# File 'lib/rails_code_auditor/scorer.rb', line 122

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

.remark_for(score) ⇒ Object 



32
33
34
35
36
37
38
39
 
# File 'lib/rails_code_auditor/scorer.rb', line 32

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

.score(results) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/rails_code_auditor/scorer.rb', line 3

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

.security_score(results) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
 
# File 'lib/rails_code_auditor/scorer.rb', line 41

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

.test_coverage_score(results) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/rails_code_auditor/scorer.rb', line 92

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