codeclimate-fede 0.85.23

data/lib/cc/analyzer/formatters/json_formatter.rb

@@ -0,0 +1,38 @@
+module CC
+  module Analyzer
+    module Formatters
+      class JSONFormatter < Formatter
+        def initialize(filesystem)
+          @filesystem = filesystem
+          @has_begun = false
+        end
+
+        def started
+          print "["
+        end
+
+        def finished
+          print "]\n"
+        end
+
+        def write(data)
+          document = JSON.parse(data)
+          document["engine_name"] = current_engine.name
+
+          if @has_begun
+            print ",\n"
+          end
+
+          print document.to_json
+          @has_begun = true
+        end
+
+        def failed(output)
+          $stderr.puts "\nAnalysis failed with the following output:"
+          $stderr.puts output
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/formatters/plain_text_formatter.rb

@@ -0,0 +1,101 @@
+require "rainbow"
+require "tty/spinner"
+require "active_support/number_helper"
+
+module CC
+  module Analyzer
+    module Formatters
+      class PlainTextFormatter < Formatter
+        def started
+          puts colorize("Starting analysis", :green)
+        end
+
+        def finished
+          puts
+
+          issues_by_path.each do |path, file_issues|
+            puts colorize("== #{path} (#{pluralize(file_issues.size, "issue")}) ==", :yellow)
+
+            IssueSorter.new(file_issues).by_location.each do |issue|
+              if (location = issue["location"])
+                source_buffer = @filesystem.source_buffer_for(location["path"])
+                print(colorize(LocationDescription.new(source_buffer, location, ": "), :cyan))
+              end
+
+              print(issue["description"])
+              print(colorize(" [#{issue["engine_name"]}]", "#333333"))
+              puts
+            end
+            puts
+          end
+
+          print(colorize("Analysis complete! Found #{pluralize(issues.size, "issue")}", :green))
+          unless warnings.empty?
+            print(colorize(" and #{pluralize(warnings.size, "warning")}", :green))
+          end
+          puts(colorize(".", :green))
+        end
+
+        def engine_running(engine, &block)
+          super(engine) do
+            result = with_spinner("Running #{current_engine.name}: ", &block)
+            if result.skipped?
+              puts(colorize("Skipped #{current_engine.name}: #{result.stderr}", :yellow))
+            end
+          end
+        end
+
+        def failed(output)
+          spinner.stop("Failed")
+          puts colorize("\nAnalysis failed with the following output:", :red)
+          puts output
+          exit 1
+        end
+
+        private
+
+        def spinner(text = nil)
+          @spinner ||= Spinner.new(text)
+        end
+
+        def with_spinner(text)
+          spinner(text).start
+          yield
+        ensure
+          spinner.stop
+          @spinner = nil
+        end
+
+        def colorize(string, *args)
+          rainbow.wrap(string).color(*args)
+        end
+
+        def rainbow
+          @rainbow ||= Rainbow.new.tap do |rainbow|
+            rainbow.enabled = false unless @output.tty?
+          end
+        end
+
+        def issues
+          @issues ||= []
+        end
+
+        def issues_by_path
+          issues.group_by { |i| i["location"]["path"] }.sort
+        end
+
+        def warnings
+          @warnings ||= []
+        end
+
+        def measurements
+          @measurements ||= []
+        end
+
+        def pluralize(number, noun)
+          "#{ActiveSupport::NumberHelper.number_to_delimited(number)} #{noun.pluralize(number)}"
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/formatters/spinner.rb

@@ -0,0 +1,35 @@
+module CC
+  module Analyzer
+    module Formatters
+      class Spinner
+        def initialize(text)
+          @spinner = TTY::Spinner.new(text)
+        end
+
+        def start
+          return unless $stdout.tty? && !CLI.debug?
+          @thread = Thread.new do
+            loop do
+              @spinning = true
+              spinner.spin
+              sleep 0.075
+            end
+          end
+        end
+
+        def stop(text = "Done!")
+          if @spinning
+            spinner.stop(text)
+            print("\n")
+            @thread.kill
+          end
+          @spinning = false
+        end
+
+        private
+
+        attr_reader :spinner
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue.rb

@@ -0,0 +1,69 @@
+module CC
+  module Analyzer
+    class Issue
+      DEFAULT_SEVERITY = IssueValidations::SeverityValidation::MINOR
+      DEPRECATED_SEVERITY = IssueValidations::SeverityValidation::NORMAL
+
+      SPEC_ISSUE_ATTRIBUTES = %w[
+        categories
+        check_name
+        content
+        description
+        location
+        other_locations
+        remediation_points
+        severity
+        type
+      ]
+
+      def initialize(engine_name, output)
+        @engine_name = engine_name
+        @output = output
+      end
+
+      def as_json(*)
+        parsed_output.reverse_merge!(
+          "engine_name" => engine_name,
+          "fingerprint" => fingerprint,
+        ).merge!("severity" => severity)
+      end
+
+      def fingerprint
+        parsed_output.fetch("fingerprint") { default_fingerprint }
+      end
+
+      # Allow access to hash keys as methods
+      SPEC_ISSUE_ATTRIBUTES.each do |key|
+        define_method(key) do
+          parsed_output[key]
+        end
+      end
+
+      def path
+        parsed_output.fetch("location", {}).fetch("path", "")
+      end
+
+      private
+
+      attr_reader :engine_name, :output
+
+      def default_fingerprint
+        SourceFingerprint.new(self).compute
+      end
+
+      def severity
+        severity = parsed_output.fetch("severity", DEFAULT_SEVERITY)
+
+        if severity == DEPRECATED_SEVERITY
+          DEFAULT_SEVERITY
+        else
+          severity
+        end
+      end
+
+      def parsed_output
+        @parsed_output ||= JSON.parse(output)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_sorter.rb

@@ -0,0 +1,30 @@
+module CC
+  module Analyzer
+    class IssueSorter
+      def initialize(issues)
+        @issues = issues
+      end
+
+      def by_location
+        @issues.sort_by { |i| line_or_offset(i) }
+      end
+
+      private
+
+      def line_or_offset(issue)
+        location = issue["location"]
+
+        case
+        when location["lines"]
+          [location["lines"]["begin"].to_i]
+        when location["positions"] && location["positions"]["begin"]["line"]
+          [location["positions"]["begin"]["line"].to_i, location["positions"]["begin"]["column"].to_i]
+        when location["positions"] && location["positions"]["begin"]["offset"]
+          [1_000_000_000] # push offsets to end of list
+        else
+          [0] # whole-file issues are first
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations.rb

@@ -0,0 +1,26 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      autoload :CategoryValidation, "cc/analyzer/issue_validations/category_validation"
+      autoload :CheckNamePresenceValidation, "cc/analyzer/issue_validations/check_name_presence_validation"
+      autoload :ContentValidation, "cc/analyzer/issue_validations/content_validation"
+      autoload :DescriptionPresenceValidation, "cc/analyzer/issue_validations/description_presence_validation"
+      autoload :LocationFormatValidation, "cc/analyzer/issue_validations/location_format_validation"
+      autoload :OtherLocationsFormatValidation, "cc/analyzer/issue_validations/other_locations_format_validation"
+      autoload :PathExistenceValidation, "cc/analyzer/issue_validations/path_existence_validation"
+      autoload :PathIsFileValidation, "cc/analyzer/issue_validations/path_is_file_validation"
+      autoload :PathPresenceValidation, "cc/analyzer/issue_validations/path_presence_validation"
+      autoload :RelativePathValidation, "cc/analyzer/issue_validations/relative_path_validation"
+      autoload :RemediationPointsValidation, "cc/analyzer/issue_validations/remediation_points_validation"
+      autoload :SeverityValidation, "cc/analyzer/issue_validations/severity_validation"
+      autoload :TypeValidation, "cc/analyzer/issue_validations/type_validation"
+      autoload :Validation, "cc/analyzer/issue_validations/validation"
+
+      def self.validations
+        constants.sort.map(&method(:const_get)).select do |klass|
+          klass.is_a?(Class) && klass.superclass == Validation
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations/category_validation.rb

@@ -0,0 +1,32 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      class CategoryValidation < Validation
+        CATEGORIES = [
+          "Bug Risk".freeze,
+          "Clarity".freeze,
+          "Compatibility".freeze,
+          "Complexity".freeze,
+          "Duplication".freeze,
+          "Performance".freeze,
+          "Security".freeze,
+          "Style".freeze,
+        ].freeze
+
+        def valid?
+          object["categories"].present? && no_invalid_categories?
+        end
+
+        def message
+          "Category must be at least one of #{CATEGORIES.join(", ")}"
+        end
+
+        private
+
+        def no_invalid_categories?
+          (CATEGORIES | object["categories"]) == CATEGORIES
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations/check_name_presence_validation.rb

@@ -0,0 +1,15 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      class CheckNamePresenceValidation < Validation
+        def valid?
+          object["check_name"].present?
+        end
+
+        def message
+          "Check name must be present"
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations/content_validation.rb

@@ -0,0 +1,21 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      class ContentValidation < Validation
+        def valid?
+          !has_content? || (content.is_a?(Hash) && content["body"].is_a?(String))
+        end
+
+        def message
+          "Content must be a hash containing a 'body' key with string contents"
+        end
+
+        private
+
+        def has_content?
+          object.key?("content")
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations/description_presence_validation.rb

@@ -0,0 +1,15 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      class DescriptionPresenceValidation < Validation
+        def valid?
+          object["description"].present?
+        end
+
+        def message
+          "Description must be present"
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_validations/location_format_validation.rb

@@ -0,0 +1,72 @@
+module CC
+  module Analyzer
+    module IssueValidations
+      class LocationFormatValidation < Validation
+        class Validator
+          def initialize(location)
+            @location = location
+            check_validity
+          end
+
+          def valid?
+            error.nil?
+          end
+
+          def message
+            if error
+              "Location is not formatted correctly: #{error}"
+            end
+          end
+
+          private
+
+          attr_accessor :error
+
+          attr_reader :location
+
+          def check_validity
+            if location["lines"]
+              self.error = "location.lines is not valid: #{JSON.dump(location["lines"])}" unless valid_lines?(location["lines"])
+            elsif location["positions"]
+              self.error = "location.positions is not valid: #{JSON.dump(location["positions"])}" unless valid_positions?(location["positions"])
+            else
+              self.error = "location.lines or location.positions must be present"
+            end
+          end
+
+          def valid_positions?(positions)
+            positions.is_a?(Hash) &&
+              valid_position?(positions["begin"]) &&
+              valid_position?(positions["end"])
+          end
+
+          def valid_position?(position)
+            position &&
+              (
+                [position["line"], position["column"]].all? { |value| value.is_a?(Integer) } ||
+                position["offset"].is_a?(Integer)
+              )
+          end
+
+          def valid_lines?(lines)
+            lines.is_a?(Hash) && [lines["begin"], lines["end"]].all? { |value| value.is_a?(Integer) }
+          end
+        end
+
+        def valid?
+          validation.valid?
+        end
+
+        def message
+          validation.message
+        end
+
+        private
+
+        def validation
+          @validation ||= Validator.new(object.fetch("location", {}))
+        end
+      end
+    end
+  end
+end