solid_loop 0.0.4 → 0.0.5

data/lib/tasks/coverage.rake

@@ -1,206 +0,0 @@
-require "json"
-
-namespace :coverage do
-  GROUPS = %w[
-    app/controllers app/models app/services app/helpers
-    app/jobs app/mailers app/queries app/channels
-    app/concerns app/views
-  ].freeze
-
-  desc "Parse coverage/coverage.json and print summary. Args: sort (worst|partial|uncovered|full), filter, git (staged|head|branch)"
-  task :report, [:sort, :filter, :git] do |_t, args|
-    CoverageReporter.report(args)
-  end
-
-  class CoverageReporter
-    COVERAGE_PATH = File.expand_path("../../coverage/coverage.json", __dir__)
-
-    def self.report(args)
-      new(args).report
-    end
-
-    def initialize(args)
-      @args = args
-    end
-
-    def report
-      unless File.exist?(COVERAGE_PATH)
-        abort "coverage/coverage.json not found. Run tests first:\n  bundle exec rspec"
-      end
-
-      data = JSON.parse(File.read(COVERAGE_PATH))
-      raw_coverage = parse_coverage(data)
-
-      git_mode = @args[:git]
-      git_changed_lines = git_mode ? load_git_changes(git_mode) : {}
-
-      if git_mode && git_changed_lines.empty?
-        puts "No changed files found for git mode: #{git_mode}"
-        return
-      end
-
-      filter_pattern = @args[:filter] ? Regexp.new(@args[:filter], Regexp::IGNORECASE) : nil
-      file_stats = []
-      total_lines = 0
-      covered_lines = 0
-
-      raw_coverage.each do |file_path, line_data|
-        next unless file_path.include?("/app/")
-
-        lines = extract_lines(line_data)
-        next if lines.nil?
-
-        short = file_path.sub(%r{.*/(?=app/)}, "")
-        next if filter_pattern && short !~ filter_pattern
-        next if git_mode && !git_changed_lines.key?(short)
-
-        stat = git_mode ? stat_for_changed(short, lines, git_changed_lines[short]) : stat_for_all(short, lines)
-        next if stat.nil?
-
-        total_lines   += stat[:total]
-        covered_lines += stat[:covered]
-        file_stats    << stat
-      end
-
-      if file_stats.empty?
-        puts "No matching files found."
-        return
-      end
-
-      overall = total_lines > 0 ? (covered_lines.to_f / total_lines * 100).round(2) : 0.0
-      header  = ["Coverage Report", filter_pattern && "[filter: #{@args[:filter]}]", git_mode && "[git: #{git_mode}]"].compact.join(" ")
-
-      puts "=" * 60
-      puts "  #{header}"
-      puts "  #{covered_lines}/#{total_lines} lines (#{overall}%)"
-      puts "=" * 60
-
-      sort_mode = (@args[:sort] || "worst").to_sym
-
-      file_stats.group_by { |f| f[:group] }.sort.each do |group_name, files|
-        g_total   = files.sum { |f| f[:total] }
-        g_covered = files.sum { |f| f[:covered] }
-        g_pct     = g_total > 0 ? (g_covered.to_f / g_total * 100).round(1) : 0.0
-
-        filtered = apply_sort(files, sort_mode)
-        next if filtered.empty?
-
-        label = git_mode ? "#{group_name} (changed lines)" : group_name
-        puts "\n--- #{label} (#{g_pct}% | #{g_covered}/#{g_total}) ---"
-        filtered.each do |f|
-          tag = f[:changed_only] ? " [changed]" : ""
-          puts "  #{f[:pct].to_s.rjust(5)}%  #{f[:path]}#{tag}  (#{f[:missed]} missed of #{f[:total]})"
-          next if f[:missed_lines].empty?
-          puts "         uncovered: #{format_line_ranges(f[:missed_lines])}"
-        end
-      end
-
-      puts
-    end
-
-    private
-
-    def parse_coverage(data)
-      if data["files"].is_a?(Array)
-        data["files"].each_with_object({}) { |f, h| h[f["filename"]] = f["coverage"] }
-      else
-        data["coverage"] || {}
-      end
-    end
-
-    def extract_lines(line_data)
-      case line_data
-      when Hash  then line_data["lines"]
-      when Array then line_data
-      end
-    end
-
-    def stat_for_changed(short, lines, changed_line_nums)
-      relevant = lines.each_with_index.select { |l, i| !l.nil? && changed_line_nums.include?(i + 1) }
-      cov      = relevant.count { |l, _| l > 0 }
-      miss     = relevant.count { |l, _| l == 0 }
-      return nil if (cov + miss) == 0
-      build_stat(short, cov, miss, relevant.select { |l, _| l == 0 }.map { |_, i| i + 1 }.sort, changed_only: true)
-    end
-
-    def stat_for_all(short, lines)
-      relevant   = lines.compact
-      cov        = relevant.count { |l| l > 0 }
-      miss       = relevant.count { |l| l == 0 }
-      miss_lines = lines.each_with_index.select { |l, _| l == 0 }.map { |_, i| i + 1 }.sort
-      return nil if (cov + miss) == 0
-      build_stat(short, cov, miss, miss_lines, changed_only: false)
-    end
-
-    def build_stat(short, cov, miss, miss_lines, changed_only:)
-      tot = cov + miss
-      {
-        path:         short,
-        pct:          (cov.to_f / tot * 100).round(1),
-        covered:      cov,
-        total:        tot,
-        missed:       miss,
-        missed_lines: miss_lines,
-        group:        detect_group(short),
-        changed_only: changed_only
-      }
-    end
-
-    def detect_group(short)
-      GROUPS.find { |prefix| short.start_with?(prefix) } || "app/other"
-    end
-
-    def apply_sort(files, mode)
-      case mode
-      when :uncovered then files.select { |f| f[:pct] == 0.0 }.sort_by { |f| -f[:total] }
-      when :partial   then files.select { |f| f[:pct] > 0 && f[:pct] < 100 }.sort_by { |f| f[:pct] }
-      when :full      then files.select { |f| f[:pct] == 100.0 }.sort_by { |f| -f[:total] }
-      else                 files.sort_by { |f| f[:pct] }
-      end
-    end
-
-    def format_line_ranges(line_nums)
-      return "" if line_nums.empty?
-      ranges, start = [], line_nums[0]
-      finish = start
-      line_nums[1..].each do |n|
-        n == finish + 1 ? (finish = n) : (ranges << range_str(start, finish); start = finish = n)
-      end
-      (ranges << range_str(start, finish)).join(", ")
-    end
-
-    def range_str(s, f) = s == f ? s.to_s : "#{s}-#{f}"
-
-    def load_git_changes(mode)
-      diff_output = case mode
-      when "staged"  then `git diff --cached --diff-filter=ACMR --unified=0 -- app/`
-      when "unstaged" then `git diff --diff-filter=ACMR --unified=0 -- app/`
-      when "head"
-        `git diff HEAD~1...HEAD --diff-filter=ACMR --unified=0 -- app/`
-      when "branch"
-        branch = `git rev-parse --abbrev-ref HEAD`.strip
-        base   = `git merge-base main #{branch} 2>/dev/null`.strip
-        base   = `git merge-base master #{branch} 2>/dev/null`.strip if base.empty?
-        base.empty? ? `git diff HEAD --diff-filter=ACMR --unified=0 -- app/` \
-                    : `git diff #{base}...HEAD --diff-filter=ACMR --unified=0 -- app/`
-      else
-        `git diff HEAD --diff-filter=ACMR --unified=0 -- app/`
-      end
-
-      result = {}
-      current_file = nil
-      diff_output.each_line do |line|
-        if line =~ %r{^\+\+\+ b/(app/.+)$}
-          current_file = $1.strip
-          result[current_file] ||= []
-        elsif line =~ /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/
-          next unless current_file
-          start_line = $1.to_i
-          count      = [($2 || "1").to_i, 1].max
-          result[current_file].concat((start_line...(start_line + count)).to_a)
-        end
-      end
-      result
-    end
-  end
-end