fastererer 0.12.0 → 1.1.0

data/lib/fastererer/file_traverser.rb

@@ -5,7 +5,9 @@ require 'English'
 
 require_relative 'analyzer'
 require_relative 'config'
-require_relative 'painter'
+require_relative 'finding'
+require_relative 'report'
+require_relative 'formatters/text_formatter'
 
 module Fastererer
   class FileTraverser
@@ -14,19 +16,17 @@ module Fastererer
     EXCLUDE_PATHS_KEY = Config::EXCLUDE_PATHS_KEY
 
     attr_reader :config, :parse_error_paths
-    attr_accessor :offenses_total_count
 
-    def initialize(path)
+    def initialize(path, formatter: Formatters::TextFormatter.new)
       @path = Pathname(path || '.')
       @parse_error_paths = []
       @config = Config.new
-      @offenses_total_count = 0
+      @formatter = formatter
+      @findings = []
     end
 
     def traverse
-      traverse_files
-      output_parse_errors
-      output_statistics
+      @formatter.render(build_report)
     end
 
     def config_file
@@ -34,7 +34,13 @@ module Fastererer
     end
 
     def offenses_found?
-      !!offenses_found
+      findings.any?
+    end
+
+    def path_missing?
+      return @path_missing if defined?(@path_missing)
+
+      @path_missing = !@path.exist?
     end
 
     def scannable_files
@@ -43,79 +49,53 @@ module Fastererer
 
     private
 
-    attr_accessor :offenses_found
+    attr_reader :findings
 
-    def traverse_files
-      if @path.exist?
-        scannable_files.each { |ruby_file| scan_file(ruby_file) }
-      else
-        output_unable_to_find_file(@path)
-      end
+    def build_report
+      scan_files
+
+      Report.new(
+        findings:,
+        files_inspected_count: scannable_files.count,
+        unparsable_files: parse_error_paths,
+        missing_path: (@path.to_s if path_missing?)
+      )
+    end
+
+    def scan_files
+      scannable_files.each { |ruby_file| scan_file(ruby_file) }
     end
 
     def scan_file(path)
       analyzer = Analyzer.new(path)
       analyzer.scan
-    rescue RubyParser::SyntaxError, Racc::ParseError, Timeout::Error => e
-      parse_error_paths.push(ErrorData.new(path, e.class, e.message).to_s)
+    rescue Fastererer::ParseError, SystemCallError, SystemStackError, EncodingError => e
+      parse_error_paths.push(ErrorData.new(path, e.class, e.message))
     else
-      if offenses_grouped_by_type(analyzer).any?
-        output(analyzer)
-        self.offenses_found = true
-        self.offenses_total_count += analyzer.errors.count
-      end
+      collect_findings(analyzer)
     end
 
-    def all_files
-      if @path.directory?
-        Dir[File.join(@path, '**', '*.rb')].map do |ruby_file_path|
-          Pathname(ruby_file_path).relative_path_from(root_dir).to_s
-        end
-      else
-        [@path.to_s]
+    def collect_findings(analyzer)
+      reported_offenses(analyzer).each do |offense|
+        findings.push(Finding.from(offense, analyzer.file_path))
       end
     end
 
-    def root_dir
-      @root_dir ||= Pathname('.')
+    def reported_offenses(analyzer)
+      ignored = ignored_speedups
+      analyzer.errors.reject { |offense| ignored.include?(offense.name) }
     end
 
-    def output(analyzer)
-      offenses_grouped_by_type(analyzer).each do |error_group_name, error_occurences|
-        error_occurences.map(&:line_number).each do |line|
-          file_and_line = "#{analyzer.file_path}:#{line}"
-          print "#{Painter.paint(file_and_line, :red)} #{Fastererer::Offense::EXPLANATIONS[error_group_name]}.\n"
-        end
-      end
-
-      print "\n"
-    end
+    def all_files
+      return [] if path_missing?
+      return [@path.to_s] unless @path.directory?
 
-    def offenses_grouped_by_type(analyzer)
-      analyzer.errors.group_by(&:name).delete_if do |offense_name, _|
-        ignored_speedups.include?(offense_name)
+      # base: takes the directory literally; interpolating it would read [ ] { } * ? as pattern
+      Dir.glob('**/*.rb', base: @path.to_s).map do |relative_path|
+        Pathname(File.join(@path, relative_path)).cleanpath.to_s
       end
     end
 
-    def output_parse_errors
-      return if parse_error_paths.none?
-
-      puts 'Fastererer was unable to process some files because the'
-      puts 'internal parser is not able to read some characters or'
-      puts 'has timed out. Unprocessable files were:'
-      puts '-----------------------------------------------------'
-      puts parse_error_paths
-      puts
-    end
-
-    def output_statistics
-      puts Statistics.new(self)
-    end
-
-    def output_unable_to_find_file(path)
-      puts Painter.paint("No such file or directory - #{path}", :red)
-    end
-
     def ignored_speedups
       config.ignored_speedups
     end
@@ -134,53 +114,4 @@ module Fastererer
       "#{file_path} - #{error_class} - #{error_message}"
     end
   end
-
-  class Statistics
-    def initialize(traverser)
-      @files_inspected_count  = traverser.scannable_files.count
-      @offenses_found_count   = traverser.offenses_total_count
-      @unparsable_files_count = traverser.parse_error_paths.count
-    end
-
-    def to_s
-      [
-        inspected_files_output,
-        offenses_found_output,
-        unparsable_files_output
-      ].compact.join(', ')
-    end
-
-    def inspected_files_output
-      Painter.paint(
-        "#{@files_inspected_count} #{pluralize(@files_inspected_count, 'file')} inspected", :green
-      )
-    end
-
-    def offenses_found_output
-      color = @offenses_found_count.zero? ? :green : :red
-
-      Painter.paint(
-        "#{@offenses_found_count} #{pluralize(@offenses_found_count, 'offense')} detected", color
-      )
-    end
-
-    def unparsable_files_output
-      return if @unparsable_files_count.zero?
-
-      Painter.paint(
-        "#{@unparsable_files_count} unparsable #{pluralize(@unparsable_files_count, 'file')} found",
-        :red
-      )
-    end
-
-    def pluralize(count, singular, plural = nil)
-      if count == 1
-        singular.to_s
-      elsif plural
-        plural.to_s
-      else
-        "#{singular}s"
-      end
-    end
-  end
 end

data/lib/fastererer/finding.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fastererer
+  Finding = Data.define(:path, :line, :rule_key, :rule_name, :description, :url) do
+    def self.from(offense, path)
+      explanation = offense.explanation
+
+      new(
+        path: path.to_s.scrub,
+        line: offense.line_number,
+        rule_key: offense.name.to_s,
+        rule_name: explanation.rule_name,
+        description: explanation.description,
+        url: explanation.url
+      )
+    end
+  end
+end

data/lib/fastererer/formatters/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fastererer
+  module Formatters
+    class Base
+      # The gap at \x09 keeps tabs, which are printable, out of the escaping
+      UNSAFE_CHARS = /[\x00-\x08\x0A-\x1F\x7F]/
+      private_constant :UNSAFE_CHARS
+
+      def initialize(out: $stdout, err: $stderr)
+        @out = out
+        @err = err
+      end
+
+      private
+
+      attr_reader :out, :err
+
+      # Undecorated on purpose for the machine formats; TextFormatter overrides with color
+      def output_diagnostics(report)
+        missing_path = report.missing_path
+
+        err.puts("No such file or directory - #{sanitize(missing_path)}") if missing_path
+        report.unparsable_files.each { |unparsable_file| err.puts(sanitize(unparsable_file.to_s)) }
+      end
+
+      def sanitize(text)
+        text.to_s.scrub.gsub(UNSAFE_CHARS) { |char| format('\\x%02X', char.ord) }
+      end
+    end
+  end
+end

data/lib/fastererer/formatters/json_formatter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+require_relative '../version'
+
+module Fastererer
+  module Formatters
+    # Diagnostics go to stderr so stdout carries nothing but the JSON document
+    class JsonFormatter < Base
+      def render(report)
+        output_diagnostics(report)
+        out.puts JSON.pretty_generate(document(report))
+      end
+
+      private
+
+      def document(report)
+        {
+          'metadata' => { 'fastererer_version' => Fastererer::VERSION },
+          'summary' => summary(report),
+          'offenses' => offenses(report)
+        }
+      end
+
+      def summary(report)
+        {
+          'offense_count' => report.offenses_detected_count,
+          'inspected_file_count' => report.files_inspected_count,
+          'unparsable_file_count' => report.unparsable_files.count
+        }
+      end
+
+      def offenses(report)
+        report.findings.sort_by { |finding| [finding.path, finding.line] }.map do |finding|
+          {
+            'path' => finding.path,
+            'line' => finding.line,
+            'rule' => finding.rule_name,
+            'rule_key' => finding.rule_key,
+            'message' => finding.description,
+            'url' => finding.url
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fastererer/formatters/rdjsonl_formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+
+module Fastererer
+  module Formatters
+    # Shape is pinned to reviewdog's Diagnostic schema: WARNING severity, start-only range
+    # code.value is the rule key, not the display name — the reader pastes it into .fastererer.yml
+    class RdjsonlFormatter < Base
+      SEVERITY = 'WARNING'
+      private_constant :SEVERITY
+
+      def render(report)
+        output_diagnostics(report)
+        report.findings.each { |finding| out.puts JSON.generate(diagnostic(finding)) }
+      end
+
+      private
+
+      def diagnostic(finding)
+        {
+          'message' => finding.description,
+          'location' => {
+            'path' => finding.path,
+            'range' => { 'start' => { 'line' => finding.line } }
+          },
+          'severity' => SEVERITY,
+          'code' => { 'value' => finding.rule_key, 'url' => finding.url }
+        }
+      end
+    end
+  end
+end

data/lib/fastererer/formatters/text_formatter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../painter'
+require_relative 'text_statistics'
+require_relative '../explanation'
+
+module Fastererer
+  module Formatters
+    class TextFormatter < Base
+      def render(report)
+        output_offenses(report)
+        output_diagnostics(report)
+        output_statistics(report)
+      end
+
+      private
+
+      def output_offenses(report)
+        report.findings.group_by(&:path).each_value do |path_findings|
+          path_findings.group_by(&:rule_name).each_value { |group| output_group(group) }
+          out.puts
+        end
+      end
+
+      def output_group(group)
+        group.each do |finding|
+          location = Painter.paint("#{sanitize(finding.path)}:#{finding.line}", :red)
+          out.puts "#{location}: #{severity}: #{Explanation.format_line(finding)}"
+        end
+      end
+
+      def output_diagnostics(report)
+        output_missing_path(report)
+        output_parse_errors(report)
+      end
+
+      def output_missing_path(report)
+        return unless report.missing_path
+
+        message = "No such file or directory - #{sanitize(report.missing_path)}"
+        err.puts Painter.paint(message, :red)
+      end
+
+      def output_parse_errors(report)
+        return if report.unparsable_files.none?
+
+        err.puts 'Fastererer was unable to process some files. Unprocessable files were:'
+        err.puts '-----------------------------------------------------'
+        report.unparsable_files.each { |unparsable_file| err.puts sanitize(unparsable_file.to_s) }
+        err.puts
+      end
+
+      def output_statistics(report)
+        out.puts TextStatistics.new(report)
+      end
+
+      def severity
+        @severity ||= Painter.paint('W', :magenta)
+      end
+    end
+  end
+end

data/lib/fastererer/formatters/text_statistics.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../painter'
+
+module Fastererer
+  module Formatters
+    class TextStatistics
+      def initialize(report)
+        @files_inspected_count   = report.files_inspected_count
+        @offenses_detected_count = report.offenses_detected_count
+        @unparsable_files_count  = report.unparsable_files.count
+      end
+
+      def to_s
+        [inspected_files_output, offenses_detected_output, unparsable_files_output]
+          .compact.join(', ')
+      end
+
+      def inspected_files_output
+        count = @files_inspected_count
+
+        Painter.paint("#{count} #{pluralize(count, 'file')} inspected", :green)
+      end
+
+      def offenses_detected_output
+        count = @offenses_detected_count
+        color = count.zero? ? :green : :red
+
+        Painter.paint("#{count} #{pluralize(count, 'offense')} detected", color)
+      end
+
+      def unparsable_files_output
+        return if @unparsable_files_count.zero?
+
+        count = @unparsable_files_count
+
+        Painter.paint("#{count} unparsable #{pluralize(count, 'file')} found", :red)
+      end
+
+      def pluralize(count, singular)
+        count == 1 ? singular : "#{singular}s"
+      end
+    end
+  end
+end

data/lib/fastererer/formatters.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'formatters/text_formatter'
+require_relative 'formatters/json_formatter'
+require_relative 'formatters/rdjsonl_formatter'
+
+module Fastererer
+  class UnknownFormatError < StandardError; end
+
+  module Formatters
+    FORMATS = {
+      'text' => TextFormatter,
+      'json' => JsonFormatter,
+      'rdjsonl' => RdjsonlFormatter
+    }.freeze
+
+    def self.fetch(name)
+      FORMATS.fetch(name) do
+        raise UnknownFormatError,
+              "Unknown format: #{name.inspect}. Valid formats: #{FORMATS.keys.join(', ')}."
+      end
+    end
+  end
+end