codeclimate-fede 0.85.21

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

@@ -0,0 +1,415 @@
+require "redcarpet"
+
+module CC
+  module Analyzer
+    module Formatters
+      class HTMLFormatter < Formatter # rubocop: disable Metrics/ClassLength
+        LANGUAGES = Hash.new { |_, ext| ext }.
+                    merge(
+                      # abap
+                      # ada
+                      "appraisals" => "ruby",
+                      "as" => "actionscript",
+                      "asm" => "nasm",
+                      "bas" => "basic",
+                      # c
+                      "c++" => "cpp",
+                      "capfile" => "ruby",
+                      "cc" => "cpp",
+                      "cfc" => "markup",
+                      "cfm" => "markup",
+                      "coffee" => "coffeescript",
+                      "cp" => "cpp",
+                      # cpp
+                      "cr" => "crystal",
+                      "cs" => "csharp",
+                      "css" => %w[css css-extras],
+                      "cu" => "cpp",
+                      "cxx" => "cpp",
+                      # d
+                      # dart
+                      # diff
+                      "dockerfile" => "docker",
+                      "dpr" => "pascal",
+                      "erl" => "erlang",
+                      "ex" => "elixir",
+                      "f" => "fortran",
+                      "f90" => "fortran",
+                      "f95" => "fortran",
+                      "feature" => "gherkin",
+                      "for" => "fortran",
+                      "fs" => "fsharp",
+                      "fsi" => "fsharp",
+                      "fsscript" => "fsharp",
+                      "fsx" => "fsharp",
+                      "gemfile" => "ruby",
+                      "gemspec" => "ruby",
+                      # glsl
+                      # go
+                      # groovy
+                      "gvy" => "groovy",
+                      "h" => "c",
+                      "h++" => "cpp",
+                      # haml
+                      # handlebars
+                      "hbr" => "handlebars",
+                      "hh" => "cpp",
+                      "hpp" => "cpp",
+                      "hs" => "haskell",
+                      "htm" => "markup",
+                      "html" => "markup",
+                      "hx" => "haxe",
+                      "hxml" => "haxe",
+                      "icn" => "icon",
+                      "ijs" => "j",
+                      # ini
+                      "iol" => "jolie",
+                      # java
+                      "jl" => "julia",
+                      "js" => "javascript",
+                      # json
+                      # jsx
+                      "kt" => "kotlin",
+                      "kts" => "kotlin",
+                      # less
+                      "lhs" => "haskell",
+                      "lol" => "lolcode",
+                      "lols" => "lolcode",
+                      "ls" => "livescript",
+                      # lua
+                      "m" => "objective-c",
+                      "mab" => "ruby",
+                      # makefile
+                      # markdown
+                      "md" => "markdown",
+                      # mel
+                      "mkd" => "markdown",
+                      "ml" => "ocaml",
+                      "mli" => "ocaml",
+                      "mm" => "objective-c",
+                      # nim
+                      # nix
+                      "nsi" => "nsis",
+                      "ol" => "jolie",
+                      # oz
+                      "pas" => "pascal",
+                      "patch" => "diff",
+                      "pde" => "processing",
+                      "php" => %w[php php-extras],
+                      "php3" => %w[php php-extras],
+                      "php4" => %w[php php-extras],
+                      "php5" => %w[php php-extras],
+                      "phtml" => %w[php php-extras],
+                      "pl" => "perl",
+                      "pp" => "puppet",
+                      "prawn" => "ruby",
+                      "pro" => "prolog",
+                      # properties
+                      # pure
+                      "py" => "python",
+                      "py3" => "python",
+                      "pyw" => "python",
+                      "q" => "qore",
+                      "qm" => "qore",
+                      "qtest" => "qore",
+                      # r
+                      "rake" => "ruby",
+                      "rakefile" => "ruby",
+                      "rantfile" => "ruby",
+                      "rb" => "ruby",
+                      "rbw" => "ruby",
+                      "rjs" => "ruby",
+                      "rpdf" => "ruby",
+                      "rs" => "rust",
+                      "rst" => "rest",
+                      "ru" => "ruby",
+                      "rxml" => "ruby",
+                      # sass
+                      "sc" => "scala",
+                      # scala
+                      "scs" => "scheme",
+                      # scss
+                      "shader" => "glsl",
+                      # sql
+                      "ss" => "scheme",
+                      "st" => "smalltalk",
+                      "styl" => "stylus",
+                      # swift
+                      # tcl
+                      "template" => "json",
+                      "tex" => "latex",
+                      # textile
+                      "tmproj" => "markup",
+                      "tpl" => "smarty",
+                      "ts" => "typescript",
+                      "v" => "verilog",
+                      "vagrantfile" => "ruby",
+                      "vhd" => "vhdl",
+                      # vim
+                      "xaml" => "markup",
+                      "xhtml" => "markup",
+                      "xml" => "markup",
+                      # yaml
+                      "yaws" => "erlang",
+                      "yml" => "yaml",
+                    ).freeze
+
+        class Location
+          CONTEXT_LINES = 2
+          MAX_LINES = 10
+
+          def initialize(source_buffer, location)
+            @source_buffer = source_buffer
+            @location = location
+          end
+
+          def begin_line
+            @begin_line ||= line("begin")
+          end
+
+          def end_line
+            @end_line ||= line("end")
+          end
+
+          def to_s
+            [
+              begin_line,
+              end_line,
+            ].uniq.join("-")
+          end
+
+          def start
+            [begin_line - CONTEXT_LINES, 1].max
+          end
+
+          def line_offset
+            start - 1
+          end
+
+          def code
+            first_line = start
+            last_line = [
+              end_line + CONTEXT_LINES,
+              begin_line + MAX_LINES + CONTEXT_LINES,
+              source_buffer.line_count,
+            ].min
+            source_buffer.source.lines[(first_line - 1)..(last_line - 1)].join("")
+          end
+
+          private
+
+          attr_reader :location, :source_buffer
+
+          def line(type)
+            if location["lines"]
+              location["lines"][type]
+            elsif location["positions"]
+              position_to_line(location["positions"][type])
+            end
+          end
+
+          def position_to_line(position)
+            if position["line"]
+              position["line"]
+            else
+              @source_buffer.decompose_position(position["offset"]).first
+            end
+          end
+        end
+
+        class SourceFile
+          def initialize(path, filesystem)
+            @path = path
+            @filesystem = filesystem
+          end
+
+          attr_reader :path
+
+          def syntaxes
+            ext = File.basename(path).split(".").last.downcase
+            Array(LANGUAGES[ext])
+          end
+
+          def code
+            filesystem.read_path(path)
+          end
+
+          def buffer
+            @buffer ||= SourceBuffer.new(path, code)
+          end
+
+          def location(loc)
+            Location.new(buffer, loc)
+          end
+
+          private
+
+          attr_reader :filesystem
+        end
+
+        class Issue
+          MARKDOWN_CONFIG = { autolink: true, fenced_code_blocks: true, no_intra_emphasis: true, tables: true }.freeze
+
+          def initialize(data, filesystem)
+            @data = data
+            @filesystem = filesystem
+          end
+
+          def description
+            data["description"]
+          end
+
+          def body
+            @body ||=
+              begin
+                text = data.fetch("content", {}).fetch("body", "").strip
+                unless text.empty?
+                  markdown(text)
+                end
+              end
+          end
+
+          def source
+            @source ||= SourceFile.new(
+              data.fetch("location", {}).fetch("path", ""),
+              filesystem,
+            )
+          end
+
+          def location
+            @location ||=
+              Location.new(
+                source.buffer,
+                data["location"],
+              )
+          end
+
+          def other_locations
+            @other_locations ||=
+              begin
+                data.fetch("other_locations", []).map do |loc|
+                  [SourceFile.new(loc["path"], filesystem), loc]
+                end.to_h
+              end
+          end
+
+          def categories
+            data.fetch("categories", [])
+          end
+
+          def engine_name
+            data["engine_name"]
+          end
+
+          private
+
+          attr_reader :data, :filesystem
+
+          def markdown(text)
+            html = Redcarpet::Render::HTML.new(
+              escape_html: false,
+              link_attributes: { target: "_blank" },
+            )
+            redcarpet = Redcarpet::Markdown.new(html, MARKDOWN_CONFIG)
+            redcarpet.render(text)
+          end
+        end
+
+        class IssueCollection
+          def initialize(filesystem)
+            @collection = []
+            @filesystem = filesystem
+          end
+
+          def each(&block)
+            collection.each(&block)
+          end
+
+          def <<(issue)
+            if issue.is_a? Hash
+              issue = Issue.new(issue, filesystem)
+            end
+            collection.push(issue)
+          end
+
+          def any?
+            collection.any?
+          end
+
+          def syntaxes
+            collection.flat_map do |issue|
+              issue.source.syntaxes
+            end.uniq.sort
+          end
+
+          def categories
+            collection.flat_map(&:categories).uniq.sort
+          end
+
+          def engines
+            collection.map(&:engine_name).uniq.compact.sort
+          end
+
+          private
+
+          attr_reader :collection, :filesystem
+        end
+
+        class ReportTemplate
+          include ERB::Util
+          attr_reader :issues
+
+          TEMPLATE_PATH = File.expand_path(File.join(File.dirname(__FILE__), "templates/html.erb"))
+
+          def initialize(issues, filesystem)
+            @issues = issues
+            @filesystem = filesystem
+          end
+
+          def render
+            template = File.read(TEMPLATE_PATH)
+            ERB.new(template, nil, "-").result(binding)
+          end
+
+          def project_name
+            File.basename(filesystem.root)
+          end
+
+          def param(str)
+            str.downcase.gsub(/\s+/, "-")
+          end
+
+          def params(values)
+            values.map { |c| param c }.join(" ")
+          end
+
+          private
+
+          attr_reader :filesystem
+        end
+
+        def finished
+          puts ReportTemplate.new(issues, @filesystem).render
+        end
+
+        def failed(_)
+          exit 1
+        end
+
+        private
+
+        def issues
+          @issues ||= IssueCollection.new(@filesystem)
+        end
+
+        def warnings
+          @warnings ||= []
+        end
+
+        def measurements
+          @measurements ||= []
+        end
+      end
+    end
+  end
+end

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/formatters.rb

@@ -0,0 +1,21 @@
+module CC
+  module Analyzer
+    module Formatters
+      autoload :Formatter, "cc/analyzer/formatters/formatter"
+      autoload :HTMLFormatter, "cc/analyzer/formatters/html_formatter"
+      autoload :JSONFormatter, "cc/analyzer/formatters/json_formatter"
+      autoload :PlainTextFormatter, "cc/analyzer/formatters/plain_text_formatter"
+      autoload :Spinner, "cc/analyzer/formatters/spinner"
+
+      FORMATTERS = {
+        html: HTMLFormatter,
+        json: JSONFormatter,
+        text: PlainTextFormatter,
+      }.freeze
+
+      def self.resolve(name)
+        FORMATTERS[name.to_sym] or raise Formatter::InvalidFormatterError, "'#{name}' is not a valid formatter. Valid options are: #{FORMATTERS.keys.join(", ")}"
+      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