codeclimate-fede 0.85.23

data/lib/cc/analyzer/container_listener.rb

@@ -0,0 +1,9 @@
+module CC
+  module Analyzer
+    class ContainerListener
+      def started(_engine, _details); end
+
+      def finished(_engine, _details, _result); end
+    end
+  end
+end

data/lib/cc/analyzer/engine.rb

@@ -0,0 +1,125 @@
+require "securerandom"
+
+module CC
+  module Analyzer
+    #
+    # Running specifically an Engine container
+    #
+    # Input:
+    #   - name
+    #   - metadata
+    #     - image
+    #     - command (optional)
+    #   - config (becomes /config.json)
+    #   - label
+    #   - io (to write filtered, validated output)
+    #
+    # Output:
+    #   - Container::Result
+    #
+    class Engine
+      Error = Class.new(StandardError)
+
+      def initialize(name, metadata, config, label)
+        @name = name
+        @metadata = metadata
+        @config = config
+        @label = label.to_s
+        @error = nil
+      end
+
+      def run(io)
+        write_config_file
+
+        container = Container.new(
+          image: metadata.fetch("image"),
+          command: metadata["command"],
+          name: container_name,
+        )
+
+        container.on_output("\0") do |output|
+          handle_output(container, io, output)
+        end
+
+        container.run(container_options).tap do |result|
+          result.merge_from_exception(error) if error.present?
+        end
+      ensure
+        delete_config_file
+      end
+
+      private
+
+      attr_reader :name, :metadata
+      attr_accessor :error
+
+      def handle_output(container, io, raw_output)
+        output = EngineOutput.new(name, raw_output)
+
+        return if output_filter.filter?(output)
+
+        unless output.valid?
+          self.error = Error.new("engine produced invalid output: #{output.error}")
+          container.stop("output invalid")
+        end
+
+        unless io.write(output_overrider.apply(output).to_json)
+          self.error = Error.new("#{io.class}#write returned false, indicating an error")
+          container.stop("output error")
+        end
+      end
+
+      def qualified_name
+        "#{name}:#{@config.fetch("channel", "stable")}"
+      end
+
+      def container_options
+        options = [
+          "--cap-drop", "all",
+          "--label", "com.codeclimate.label=#{@label}",
+          "--log-driver", "none",
+          "--memory-swap", "-1",
+          "--net", "none",
+          "--rm",
+          "--volume", "#{code.host_path}:/code:ro",
+          "--volume", "#{config_file.host_path}:/config.json:ro",
+          "--user", "9000:9000"
+        ]
+        if (memory = metadata["memory"]).present?
+          options.concat(["--memory", memory.to_s])
+        end
+        options
+      end
+
+      def container_name
+        @container_name ||= "cc-engines-#{qualified_name.tr(":", "-")}-#{SecureRandom.uuid}"
+      end
+
+      def write_config_file
+        @config["debug"] = ENV["CODECLIMATE_DEBUG"]
+        Analyzer.logger.debug "/config.json content: #{@config.inspect}"
+        config_file.write(@config.to_json)
+      end
+
+      def delete_config_file
+        config_file.delete if config_file.file?
+      end
+
+      def code
+        @code ||= MountedPath.code
+      end
+
+      def config_file
+        @config_file ||= MountedPath.tmp.join(SecureRandom.uuid)
+      end
+
+      def output_filter
+        @output_filter ||= EngineOutputFilter.new(@config)
+      end
+
+      def output_overrider
+        @output_overrider ||= EngineOutputOverrider.new(@config)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine_output.rb

@@ -0,0 +1,74 @@
+module CC
+  module Analyzer
+    class EngineOutput
+      delegate :blank?, to: :raw_output
+
+      def initialize(name, raw_output)
+        @name = name
+        @raw_output = raw_output
+      end
+
+      def issue?
+        valid_with_type?("issue")
+      end
+
+      def measurement?
+        valid_with_type?("measurement")
+      end
+
+      def as_issue
+        Issue.new(name, raw_output)
+      end
+
+      def to_json
+        if issue?
+          as_issue.to_json
+        elsif measurement?
+          Measurement.new(name, raw_output).to_json
+        end
+      end
+
+      def valid?
+        valid_json? && validator && validator.valid?
+      end
+
+      def error
+        if !valid_json?
+          { message: "Invalid JSON", output: raw_output }
+        elsif !validator.present?
+          { message: "Unsupported document type", output: raw_output }
+        else
+          validator.error
+        end
+      end
+
+      private
+
+      attr_accessor :name, :raw_output
+
+      def valid_json?
+        parsed_output.present?
+      end
+
+      def valid_with_type?(type)
+        parsed_output &&
+          parsed_output["type"].present? &&
+          parsed_output["type"].downcase == type
+      end
+
+      def parsed_output
+        @parsed_output ||= JSON.parse(raw_output)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def validator
+        if issue?
+          IssueValidator.new(parsed_output)
+        elsif measurement?
+          MeasurementValidator.new(parsed_output)
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine_output_filter.rb

@@ -0,0 +1,36 @@
+module CC
+  module Analyzer
+    class EngineOutputFilter
+      ISSUE_TYPE = "issue".freeze
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      def filter?(output)
+        output.blank? || (output.issue? && ignore_issue?(output.as_issue))
+      end
+
+      private
+
+      def ignore_issue?(issue)
+        check_disabled?(issue) || ignore_fingerprint?(issue)
+      end
+
+      def check_disabled?(issue)
+        !check_config(issue.check_name).fetch("enabled", true)
+      end
+
+      def ignore_fingerprint?(issue)
+        @config.fetch("exclude_fingerprints", []).include?(issue.fingerprint)
+      rescue SourceExtractor::InvalidLocation
+        false
+      end
+
+      def check_config(check_name)
+        @checks ||= @config.fetch("checks", {})
+        @checks.fetch(check_name, {})
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine_output_overrider.rb

@@ -0,0 +1,31 @@
+module CC
+  module Analyzer
+    class EngineOutputOverrider
+      def initialize(config = {})
+        @config = config
+      end
+
+      def apply(output)
+        if output.issue?
+          override_severity(output.as_issue.as_json)
+        else
+          output
+        end
+      end
+
+      private
+
+      attr_reader :config
+
+      def override_severity(issue)
+        issue.merge(override("severity"))
+      end
+
+      def override(name)
+        config.
+          fetch("issue_override", {}).
+          slice(name)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/filesystem.rb

@@ -0,0 +1,50 @@
+module CC
+  module Analyzer
+    class Filesystem
+      attr_reader :root
+
+      def initialize(root)
+        @root = root
+      end
+
+      def exist?(path)
+        File.exist?(path_for(path))
+      end
+
+      def source_buffer_for(path)
+        SourceBuffer.new(path, read_path(path))
+      end
+
+      def read_path(path)
+        File.read(path_for(path))
+      end
+
+      def write_path(path, content)
+        File.write(path_for(path), content)
+        File.chown(root_uid, root_gid, path_for(path))
+      end
+
+      def ls
+        Dir.entries(root).reject { |entry| [".", ".."].include?(entry) }
+      end
+
+      private
+
+      def path_for(path)
+        File.join(root, path)
+      end
+
+      def root_uid
+        root_stat.uid
+      end
+
+      def root_gid
+        root_stat.gid
+      end
+
+      def root_stat
+        @root_stat ||= File.stat(root)
+      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/formatters/formatter.rb

@@ -0,0 +1,53 @@
+module CC
+  module Analyzer
+    module Formatters
+      class Formatter
+        def initialize(filesystem, output = $stdout)
+          @filesystem = filesystem
+          @output = output
+        end
+
+        def write(data)
+          json = JSON.parse(data)
+          json["engine_name"] = current_engine.name
+
+          case json["type"].downcase
+          when "issue"
+            issues << json
+          when "warning"
+            warnings << json
+          when "measurement"
+            measurements << json
+          else
+            raise "Invalid type found: #{json["type"]}"
+          end
+        end
+
+        def started
+        end
+
+        def engine_running(engine)
+          @current_engine = engine
+          yield
+        ensure
+          @current_engine = nil
+        end
+
+        def finished
+        end
+
+        def close
+        end
+
+        def failed(_output)
+        end
+
+        InvalidFormatterError = Class.new(StandardError)
+
+        private
+
+        attr_reader :current_engine
+      end
+    end
+  end
+end

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