codeclimate-fede 0.85.23

data/lib/cc/analyzer/measurement_validations/value_validation.rb

@@ -0,0 +1,21 @@
+module CC
+  module Analyzer
+    module MeasurementValidations
+      class ValueValidation < Validation
+        def valid?
+          value&.is_a?(Numeric)
+        end
+
+        def message
+          "Value must be present and numeric"
+        end
+
+        private
+
+        def value
+          object["value"]
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/measurement_validator.rb

@@ -0,0 +1,11 @@
+module CC
+  module Analyzer
+    class MeasurementValidator
+      include Validator
+
+      def self.validations
+        MeasurementValidations.validations
+      end
+    end
+  end
+end

data/lib/cc/analyzer/mounted_path.rb

@@ -0,0 +1,80 @@
+module CC
+  module Analyzer
+    class MountedPath
+      DEFAULT_CODECLIMATE_TMP = "/tmp/cc".freeze
+
+      def self.code
+        host_prefix = ENV["CODECLIMATE_CODE"]
+        host_prefix ||= ENV["CODE_PATH"] # deprecated
+
+        if ENV["CODECLIMATE_DOCKER"]
+          new(host_prefix, "/code")
+        else
+          host_prefix ||= Dir.pwd
+
+          new(host_prefix, host_prefix)
+        end
+      end
+
+      def self.tmp
+        host_prefix = ENV["CODECLIMATE_TMP"]
+        host_prefix ||= DEFAULT_CODECLIMATE_TMP
+
+        if ENV["CODECLIMATE_DOCKER"]
+          new(host_prefix, "/tmp/cc")
+        else
+          new(host_prefix, host_prefix)
+        end
+      end
+
+      def initialize(host_prefix, container_prefix, path = nil)
+        @host_prefix = host_prefix
+        @container_prefix = container_prefix
+        @path = path
+      end
+
+      def host_path
+        if path
+          File.join(host_prefix, path)
+        else
+          host_prefix
+        end
+      end
+
+      def container_path
+        if path
+          File.join(container_prefix, path)
+        else
+          container_prefix
+        end
+      end
+
+      def join(path)
+        @path = path
+
+        self
+      end
+
+      def file?
+        File.file?(container_path)
+      end
+
+      def read
+        File.read(container_path)
+      end
+
+      def write(content)
+        FileUtils.mkdir_p(File.dirname(container_path))
+        File.write(container_path, content)
+      end
+
+      def delete
+        File.delete(container_path)
+      end
+
+      private
+
+      attr_reader :host_prefix, :container_prefix, :path
+    end
+  end
+end

data/lib/cc/analyzer/raising_container_listener.rb

@@ -0,0 +1,32 @@
+module CC
+  module Analyzer
+    class RaisingContainerListener < ContainerListener
+      def initialize(failure_ex, timeout_ex = nil, maximum_output_ex = nil)
+        @failure_ex = failure_ex
+        @timeout_ex = timeout_ex || failure_ex
+        @maximum_output_ex = maximum_output_ex || failure_ex
+      end
+
+      def finished(engine, _details, result)
+        if result.timed_out?
+          message = "engine #{engine.name} ran for #{result.duration / 1000}"
+          message << " seconds and was killed"
+          raise timeout_ex.new(message, engine.name)
+        elsif result.maximum_output_exceeded?
+          message = "engine #{engine.name} produced too much output"
+          message << " (#{result.output_byte_count} bytes)"
+          raise maximum_output_ex.new(message, engine.name)
+        elsif result.exit_status.nonzero?
+          message = "engine #{engine.name} failed"
+          message << " with status #{result.exit_status}"
+          message << " and stderr \n#{result.stderr}"
+          raise failure_ex.new(message, engine.name)
+        end
+      end
+
+      private
+
+      attr_reader :failure_ex, :timeout_ex, :maximum_output_ex
+    end
+  end
+end

data/lib/cc/analyzer/source_buffer.rb

@@ -0,0 +1,47 @@
+# Adapted from https://github.com/whitequark/parser/blob/master/lib/parser/source/buffer.rb
+module CC
+  module Analyzer
+    class SourceBuffer
+      attr_reader :name
+      attr_reader :source
+
+      def initialize(name, source)
+        @name = name
+        @source = source
+      end
+
+      def decompose_position(position)
+        line_no, line_begin = line_for(position)
+
+        [1 + line_no, position - line_begin]
+      end
+
+      def line_count
+        @source.lines.count
+      end
+
+      private
+
+      def line_for(position)
+        line_begins.bsearch do |_, line_begin|
+          line_begin <= position
+        end
+      end
+
+      def line_begins
+        unless @line_begins
+          @line_begins = [[0, 0]]
+          index = 1
+
+          @source.each_char do |char|
+            @line_begins.unshift [@line_begins.length, index] if char == "\n"
+
+            index += 1
+          end
+        end
+
+        @line_begins
+      end
+    end
+  end
+end

data/lib/cc/analyzer/source_extractor.rb

@@ -0,0 +1,79 @@
+module CC
+  module Analyzer
+    class SourceExtractor
+      InvalidLocation = Class.new(StandardError)
+
+      def initialize(source)
+        @source = source
+      end
+
+      def extract(location)
+        validate_location(location)
+
+        if (lines = location["lines"])
+          extract_from_lines(lines)
+        elsif (positions = location["positions"])
+          extract_from_positions(positions)
+        end
+      end
+
+      private
+
+      attr_reader :source
+
+      def validate_location(location)
+        validator = IssueValidations::LocationFormatValidation::Validator.new(location)
+        unless validator.valid?
+          raise InvalidLocation, validator.message
+        end
+      end
+
+      def extract_from_lines(lines)
+        begin_index = lines.fetch("begin") - 1
+        end_index = lines.fetch("end") - 1
+        range = (begin_index..end_index)
+
+        source.each_line.with_object("").with_index do |(source_line, memo), index|
+          memo << source_line if range.include?(index)
+        end
+      end
+
+      def extract_from_positions(positions)
+        positions = convert_to_offsets(positions)
+        begin_offset = positions.fetch("begin").fetch("offset")
+        end_offset = positions.fetch("end").fetch("offset")
+        length = end_offset - begin_offset
+
+        source[begin_offset, length + 1]
+      end
+
+      def convert_to_offsets(positions)
+        positions.each_with_object({}) do |(key, value), memo|
+          memo[key] =
+            if value.key?("offset")
+              value
+            else
+              {
+                "offset" => to_offset(value["line"] - 1, value["column"] - 1),
+              }
+            end
+        end
+      end
+
+      def to_offset(line, column, offset = 0)
+        source.each_line.with_index do |source_line, index|
+          offset +=
+            if line == index
+              column
+            else
+              source_line.length
+            end
+
+          break if index >= line
+        end
+
+        offset
+      end
+    end
+  end
+end

data/lib/cc/analyzer/source_fingerprint.rb

@@ -0,0 +1,40 @@
+require "digest/md5"
+
+module CC
+  module Analyzer
+    class SourceFingerprint
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def compute
+        md5 = Digest::MD5.new
+        md5 << issue.path
+        md5 << issue.check_name.to_s
+        md5 << relevant_source.gsub(/\s+/, "") if relevant_source
+        md5.hexdigest
+      end
+
+      private
+
+      attr_reader :issue
+
+      def relevant_source
+        source = SourceExtractor.new(raw_source).extract(issue.location)
+
+        if source && !source.empty?
+          source.encode(Encoding::UTF_8, "binary", invalid: :replace, undef: :replace, replace: "")
+        end
+      end
+
+      def raw_source
+        @raw_source ||=
+          if File.file?(issue.path)
+            File.read(issue.path)
+          else
+            ""
+          end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/statsd_container_listener.rb

@@ -0,0 +1,51 @@
+module CC
+  module Analyzer
+    class StatsdContainerListener < ContainerListener
+      def initialize(statsd)
+        @statsd = statsd
+      end
+
+      def started(engine, _details)
+        increment(engine, "started")
+      end
+
+      def finished(engine, _details, result)
+        timing(engine, "time", result.duration)
+        increment(engine, "finished")
+
+        if result.timed_out?
+          timing(engine, "time", result.duration)
+          increment(engine, "result.error")
+          increment(engine, "result.error.timeout")
+        elsif result.maximum_output_exceeded?
+          increment(engine, "result.error")
+          increment(engine, "result.error.output_exceeded")
+        elsif result.exit_status.nonzero?
+          increment(engine, "result.error")
+        else
+          increment(engine, "result.success")
+        end
+      end
+
+      private
+
+      attr_reader :statsd
+
+      def increment(engine, metric)
+        statsd.increment("engines.#{metric}")
+        statsd.increment("engines.names.#{engine.name}.#{metric}")
+        if engine.respond_to?(:channel) && engine.channel
+          statsd.increment("engines.names.#{engine.name}.#{engine.channel}.#{metric}")
+        end
+      end
+
+      def timing(engine, metric, ms)
+        statsd.timing("engines.#{metric}", ms)
+        statsd.timing("engines.names.#{engine.name}.#{metric}", ms)
+        if engine.respond_to?(:channel) && engine.channel
+          statsd.timing("engines.names.#{engine.name}.#{engine.channel}.#{metric}", ms)
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/validator.rb

@@ -0,0 +1,38 @@
+module CC
+  module Analyzer
+    module Validator
+      attr_reader :error
+
+      def initialize(document)
+        @document = document
+        validate
+      end
+
+      def validate
+        return @valid unless @valid.nil?
+
+        if document && invalid_messages.any?
+          @error = {
+            message: "#{invalid_messages.join("; ")}: `#{document}`.",
+            document: document,
+          }
+          @valid = false
+        else
+          @valid = true
+        end
+      end
+      alias valid? validate
+
+      private
+
+      attr_reader :document
+
+      def invalid_messages
+        @invalid_messages ||= self.class.validations.each_with_object([]) do |check, result|
+          validator = check.new(document)
+          result << validator.message unless validator.valid?
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli.rb

@@ -0,0 +1,39 @@
+require "active_support"
+require "active_support/core_ext"
+require "yaml"
+require "cc/analyzer"
+require "cc/config"
+require "cc/engine_registry"
+require "cc/workspace"
+
+require "cc/cli/analyze"
+require "cc/cli/command"
+require "cc/cli/console"
+require "cc/cli/engines"
+require "cc/cli/help"
+require "cc/cli/output"
+require "cc/cli/prepare"
+require "cc/cli/runner"
+require "cc/cli/validate_config"
+require "cc/cli/version"
+
+module CC
+  module CLI
+    def self.debug?
+      ENV["CODECLIMATE_DEBUG"].present?
+    end
+
+    def self.logger
+      @logger ||= ::Logger.new(STDERR).tap do |logger|
+        logger.level =
+          if debug?
+            ::Logger::DEBUG
+          else
+            ::Logger::ERROR
+          end
+      end
+    end
+  end
+
+  Analyzer.logger = CLI.logger
+end