rubosquad 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4122eef7f956af0412b99e4bb2f220ce2afc33a810b77ec2280244eba9e61ec
-  data.tar.gz: dd98295ce280108341cfd86deb9f85a97298011517a1879a7a17fc1f8b634470
+  metadata.gz: bdc45fe50d0678e9dd9f45bc7967aeea4ed6b3ee830593875d9ad8911f277592
+  data.tar.gz: 784949c827c7d611bf125f791cf3d5913f93a9b508efc1dcb0814c3d3350a607
 SHA512:
-  metadata.gz: c6f8fdca8ada9f7020a7f2544f15ef1c5ec61ba3bc085033b42820c2cba27c1a9c7fa015ca2f8aea156f7e22894542995573155f981757e815ca5fb69b3ed61d
-  data.tar.gz: a46e355706bd10b40498712bf2c80f1179e9be08fb804dff81f76391c1a6311092a94325f751fbc6ca7555c9fce78a2167be6ab7e1148714485cc6b3afad07fc
+  metadata.gz: 929f4fea15d4ab2e7396f4a1b7ba159734bad3ba7d9d889f72de7c668bf5b47981028fa24971b263afe5b2655a1a74d4c651fae5d4250cb7c0a06a02eedbe031
+  data.tar.gz: c62933394e08b6520233aec0180384ec8367ac9de7c84f42e7c195a05ca888e91fc23881ef75ac4b2f0997a311657e47a4e75aae52ee35a398f6aa0d2892e6e8

data/lib/rubosquad.rb

@@ -6,6 +6,13 @@ require 'optparse'
 
 module Rubosquad
   class CLI
+    OFFENSE_COLORS = {
+      'E' => "\e[31m",
+      'F' => "\e[31m",
+      'W' => "\e[33m"
+    }.freeze
+    RESET = "\e[0m"
+
     class << self
       def run
         options = parse_options
@@ -24,6 +31,8 @@ module Rubosquad
           exit 0
         end
 
+        options[:base_branch] = base_branch
+        options[:current_branch] = current_branch
         print_file_list(files, current_branch, base_branch)
         run_rubocop(options, files)
       end
@@ -48,6 +57,12 @@ module Rubosquad
           opts.on('-A', '--unsafe-auto-correct', 'Run with rubocop -A (unsafe auto-corrections) instead of -a') do
             options[:unsafe_auto_correct] = true
           end
+          opts.on('-v', '--verbose', 'Show full stderr including new-cops notices and extra detail') do
+            options[:verbose] = true
+          end
+          opts.on('--all', 'Report all offenses, including pre-existing ones not in this branch') do
+            options[:all] = true
+          end
         end.parse!
         options
       end
@@ -112,20 +127,69 @@ module Rubosquad
         cmd = build_rubocop_cmd(options, extensions, files)
         stdout, stderr, status = Open3.capture3(*cmd)
 
+        changed_lines = options[:all] ? nil : parse_changed_lines(options, files)
+
         puts "\nRubocop Output:"
         puts '==Error type: Legend: C = Convention, W = Warning, E = Error, F = Fatal=='
-        puts format_output(stdout)
+        formatted = format_output(stdout, changed_lines: changed_lines)
+        puts formatted
+
+        print_rubocop_result(stdout, stderr, status, extensions, options)
+
+        exit 0 if !status.success? && changed_lines && count_new_offenses(formatted).zero?
 
-        print_rubocop_result(stdout, stderr, status, extensions)
         exit status.exitstatus unless status.success?
       end
 
+      def parse_changed_lines(options, files)
+        base_branch = options[:base_branch]
+        current_branch = options[:current_branch]
+
+        files.each_with_object({}) do |file, changed|
+          diff_text = if current_branch == base_branch
+                        fetch_base_branch_diff(file)
+                      else
+                        fetch_feature_branch_diff(base_branch, file)
+                      end
+          changed[file] = parse_hunk_lines(diff_text)
+        end
+      end
+
+      def fetch_feature_branch_diff(base_branch, file)
+        stdout, = Open3.capture3('git', 'diff', '-U0', "#{base_branch}...HEAD", '--', file)
+        stdout
+      end
+
+      def fetch_base_branch_diff(file)
+        unstaged, = Open3.capture3('git', 'diff', '-U0', 'HEAD', '--', file)
+        staged,   = Open3.capture3('git', 'diff', '-U0', '--cached', '--', file)
+        "#{unstaged}#{staged}"
+      end
+
+      def parse_hunk_lines(diff_text)
+        lines = Set.new
+        diff_text.scan(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/) do |start, count|
+          start = start.to_i
+          count = count.nil? ? 1 : count.to_i
+          count.times { |i| lines << (start + i) } if count.positive?
+        end
+        lines
+      end
+
+      def count_new_offenses(formatted_output)
+        formatted_output.lines.count { |l| l.match?(/^\[.+:\d+:\d+\] -/) }
+      end
+
       def detect_extensions
         %w[rubocop-factory_bot rubocop-rails rubocop-rspec rubocop-rspec_rails].select do |ext|
           Gem::Specification.find_by_name(ext)
+          require ext
           true
         rescue Gem::LoadError
           false
+        rescue LoadError => e
+          warn "Warning: #{ext} is installed but could not be loaded (#{e.message}). Skipping."
+          false
         end
       end
 
@@ -144,7 +208,7 @@ module Rubosquad
         false
       end
 
-      def format_output(stdout)
+      def format_output(stdout, changed_lines: nil)
         lines = []
         seen_files = Set.new
         current_file = nil
@@ -153,13 +217,10 @@ module Rubosquad
           if line.start_with?('==')
             file_path = line.strip.gsub(/^==\s*|\s*==$/, '')
             current_file = file_path
-            lines << (seen_files.add?(file_path) ? "\n\e[36m#{line}\e[0m" : "\n#{line}")
+            lines << (seen_files.add?(file_path) ? "\n\e[36m#{line.chomp}\e[0m\n" : "\n#{line}")
           elsif line.match?(/^[A-Z]:/)
-            parts = line.split(':')
-            offense_type = parts.shift
-            line_col = parts.shift(2).map(&:strip).join(':')
-            message = parts.join(':').strip
-            lines << "[#{current_file || 'unknown'}:#{line_col}] - #{offense_type}: #{message}\n"
+            offense = parse_offense_line(line, current_file, changed_lines)
+            lines << offense if offense
           else
             lines << line
           end
@@ -168,21 +229,61 @@ module Rubosquad
         lines.join
       end
 
-      def print_rubocop_result(stdout, stderr, status, extensions)
+      def parse_offense_line(line, current_file, changed_lines)
+        parts = line.split(':')
+        offense_type = parts.shift
+        line_num = parts.first.strip.to_i
+        line_col = parts.shift(2).map(&:strip).join(':')
+        message = parts.join(':').strip
+
+        return nil if changed_lines && !changed_lines[current_file]&.include?(line_num)
+
+        type_str = if (color = OFFENSE_COLORS[offense_type])
+                     "#{color}#{offense_type}#{RESET}"
+                   else
+                     offense_type
+                   end
+
+        "[#{current_file || 'unknown'}:#{line_col}] - #{type_str}: #{message}\n"
+      end
+
+      def print_rubocop_result(stdout, stderr, status, extensions, options = {})
+        total     = stdout.scan(/(\d+) offenses? detected/).flatten.map(&:to_i).sum
+        corrected = stdout.scan(/(\d+) offenses? corrected/).flatten.map(&:to_i).sum
+        remaining = total - corrected
+
         if status.success?
           puts "\nRubocop auto-corrections complete."
         else
           puts "\nRubocop completed with offenses:"
-          total = stdout.scan(/(\d+) offense.* detected/).flatten.map(&:to_i).sum
           puts "Files inspected: #{stdout[/(\d+) files? inspected/, 1] || 'Unknown'}"
-          puts "Total offenses detected: #{total}"
-          unless stderr.strip.empty?
-            puts "\nStandard error:"
-            puts stderr
-          end
         end
+
+        puts "#{corrected} auto-corrected | #{remaining} remaining" if total.positive?
+        display_stderr(stderr, options[:verbose])
         puts "\nRuboCop extensions used: #{extensions.join(', ')}" unless extensions.empty?
       end
+
+      def display_stderr(stderr, verbose)
+        filtered = verbose ? stderr : filter_new_cops_notice(stderr)
+        return if filtered.strip.empty?
+
+        puts "\nStandard error:"
+        puts filtered
+      end
+
+      def filter_new_cops_notice(stderr)
+        return stderr unless stderr.include?('opt-in to new cops')
+
+        lines = stderr.lines
+        start_idx = lines.index { |l| l.include?('opt-in to new cops') }
+        return stderr unless start_idx
+
+        end_idx = lines.index { |l| l.include?('docs.rubocop.org/rubocop/versioning') }
+        end_idx ||= lines.length - 1
+
+        (lines[0...start_idx] + lines[(end_idx + 1)..]).join
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubosquad
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - LucasWaki