codeclimate-fede 0.85.21

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

@@ -0,0 +1,50 @@
+require "yaml"
+
+module CC
+  module Analyzer
+    autoload :Bridge, "cc/analyzer/bridge"
+    autoload :CompositeContainerListener, "cc/analyzer/composite_container_listener"
+    autoload :Container, "cc/analyzer/container"
+    autoload :ContainerListener, "cc/analyzer/container_listener"
+    autoload :Engine, "cc/analyzer/engine"
+    autoload :EngineOutput, "cc/analyzer/engine_output"
+    autoload :EngineOutputFilter, "cc/analyzer/engine_output_filter"
+    autoload :EngineOutputOverrider, "cc/analyzer/engine_output_overrider"
+    autoload :Filesystem, "cc/analyzer/filesystem"
+    autoload :Formatters, "cc/analyzer/formatters"
+    autoload :Issue, "cc/analyzer/issue"
+    autoload :IssueSorter, "cc/analyzer/issue_sorter"
+    autoload :IssueValidations, "cc/analyzer/issue_validations"
+    autoload :IssueValidator, "cc/analyzer/issue_validator"
+    autoload :LocationDescription, "cc/analyzer/location_description"
+    autoload :LoggingContainerListener, "cc/analyzer/logging_container_listener"
+    autoload :Measurement, "cc/analyzer/measurement"
+    autoload :MeasurementValidations, "cc/analyzer/measurement_validations"
+    autoload :MeasurementValidator, "cc/analyzer/measurement_validator"
+    autoload :MountedPath, "cc/analyzer/mounted_path"
+    autoload :RaisingContainerListener, "cc/analyzer/raising_container_listener"
+    autoload :SourceBuffer, "cc/analyzer/source_buffer"
+    autoload :SourceExtractor, "cc/analyzer/source_extractor"
+    autoload :SourceFingerprint, "cc/analyzer/source_fingerprint"
+    autoload :StatsdContainerListener, "cc/analyzer/statsd_container_listener"
+    autoload :Validator, "cc/analyzer/validator"
+
+    class DummyStatsd
+      def method_missing(*)
+        yield if block_given?
+      end
+    end
+
+    class DummyLogger
+      def method_missing(*)
+        yield if block_given?
+      end
+    end
+
+    cattr_accessor :statsd, :logger
+    self.statsd = DummyStatsd.new
+    self.logger = DummyLogger.new
+
+    UnreadableFileError = Class.new(StandardError)
+  end
+end

data/lib/cc/cli/analyze/engine_failure.rb

@@ -0,0 +1,11 @@
+module CC
+  module CLI
+    class Analyze < Command
+      class EngineFailure < StandardError
+        def initialize(message, _engine_name)
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/analyze.rb

@@ -0,0 +1,90 @@
+require "cc/cli/command"
+
+module CC
+  module CLI
+    class Analyze < Command
+      ARGUMENT_LIST = "[-f format] [-e engine[:channel]] [path]".freeze
+      SHORT_HELP = "Run analysis with the given arguments".freeze
+      HELP = "#{SHORT_HELP}\n" \
+        "\n" \
+        "    -f <format>, --format <format>   Format of output. Possible values: #{CC::Analyzer::Formatters::FORMATTERS.keys.join ", "}\n" \
+        "    -e <engine[:channel]>            Engine to run. Can be specified multiple times.\n" \
+        "    --dev                            Run in development mode. Engines installed locally that are not in the manifest will be run.\n" \
+        "    path                             Path to check. Can be specified multiple times.".freeze
+
+      autoload :EngineFailure, "cc/cli/analyze/engine_failure"
+
+      include CC::Analyzer
+
+      def run
+        # Load config here so it sees ./.codeclimate.yml
+        @config = Config.load
+
+        # process args after, so it modifies loaded configuration
+        process_args
+
+        bridge = Bridge.new(
+          config: config,
+          formatter: formatter,
+          listener: CompositeContainerListener.new(
+            LoggingContainerListener.new(Analyzer.logger),
+            RaisingContainerListener.new(EngineFailure),
+          ),
+          registry: EngineRegistry.new,
+        )
+
+        bridge.run
+      end
+
+      private
+
+      attr_reader :config, :engines_disabled, :listener, :registry
+
+      def process_args
+        while (arg = @args.shift)
+          case arg
+          when "-f", "--format"
+            @formatter = Formatters.resolve(@args.shift).new(filesystem)
+          when "-e", "--engine"
+            disable_all_engines!
+            name, channel = @args.shift.split(":", 2)
+            enable_engine(name, channel)
+          when "--dev"
+            config.development = true
+          when "--no-plugins"
+            config.disable_plugins!
+          else
+            config.analysis_paths << arg
+          end
+        end
+      rescue Formatters::Formatter::InvalidFormatterError => ex
+        fatal(ex.message)
+      end
+
+      def formatter
+        @formatter ||= Formatters::PlainTextFormatter.new(filesystem)
+      end
+
+      def disable_all_engines!
+        unless engines_disabled
+          config.engines.each { |e| e.enabled = false }
+          @engines_disabled = true
+        end
+      end
+
+      def enable_engine(name, channel)
+        existing_engine = config.engines.detect { |e| e.name == name }
+        if existing_engine.present?
+          existing_engine.enabled = true
+          existing_engine.channel = channel if channel.present?
+        else
+          config.engines << Config::Engine.new(
+            name,
+            channel: channel,
+            enabled: true,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/command.rb

@@ -0,0 +1,85 @@
+require "highline"
+require "active_support"
+require "active_support/core_ext"
+require "rainbow"
+require "cc/cli/output"
+
+module CC
+  module CLI
+    class Command
+      include CC::CLI::Output
+
+      CODECLIMATE_YAML = ".codeclimate.yml".freeze
+      NAMESPACE = name.split("::")[0..-2].join("::").freeze
+
+      def self.abstract!
+        @abstract = true
+      end
+
+      def self.abstract?
+        @abstract == true
+      end
+
+      def self.all
+        @@subclasses.reject(&:abstract?)
+      end
+
+      def self.[](name)
+        all.find { |command| command.name == "#{NAMESPACE}::#{name}" || command.command_name == name }
+      end
+
+      # rubocop: disable Style/ClassVars
+      def self.inherited(subclass)
+        @@subclasses ||= []
+        @@subclasses << subclass
+      end
+      # rubocop: enable Style/ClassVars
+
+      def self.synopsis
+        "#{command_name} #{self::ARGUMENT_LIST if const_defined?(:ARGUMENT_LIST)}".strip
+      end
+
+      def self.short_help
+        if const_defined? :SHORT_HELP
+          self::SHORT_HELP
+        else
+          ""
+        end
+      end
+
+      def self.help
+        if const_defined? :HELP
+          self::HELP
+        else
+          short_help
+        end
+      end
+
+      def initialize(args = [])
+        @args = args
+      end
+
+      def run
+        $stderr.puts "unknown command #{self.class.name.split("::").last.underscore}"
+      end
+
+      def self.command_name
+        name.gsub(/^#{NAMESPACE}::/, "").split("::").map do |part|
+          part.split(/(?=[A-Z])/).map(&:downcase).join("-")
+        end.join(":")
+      end
+
+      def execute
+        run
+      end
+
+      private
+
+      def filesystem
+        @filesystem ||= CC::Analyzer::Filesystem.new(
+          CC::Analyzer::MountedPath.code.container_path,
+        )
+      end
+    end
+  end
+end

data/lib/cc/cli/console.rb

@@ -0,0 +1,12 @@
+module CC
+  module CLI
+    class Console < Command
+      SHORT_HELP = "Open a ruby console for the CLI. Useful for developing against the CLI.".freeze
+
+      def run
+        require "pry"
+        binding.pry(quiet: true, prompt: Pry::SIMPLE_PROMPT, output: $stdout)
+      end
+    end
+  end
+end

data/lib/cc/cli/engines/engine_command.rb

@@ -0,0 +1,15 @@
+require "cc/analyzer"
+
+module CC
+  module CLI
+    module Engines
+      class EngineCommand < Command
+        abstract!
+
+        def engine_registry
+          @engine_registry ||= EngineRegistry.new
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/engines/install.rb

@@ -0,0 +1,35 @@
+module CC
+  module CLI
+    module Engines
+      class Install < EngineCommand
+        SHORT_HELP = "Pull the latest images for enabled engines in your configuration".freeze
+
+        ImagePullFailure = Class.new(StandardError)
+
+        def run
+          say "Pulling docker images."
+          pull_docker_images
+        end
+
+        private
+
+        def config
+          @config ||= CC::Config.load
+        end
+
+        def pull_docker_images
+          config.engines.each(&method(:pull_engine))
+        end
+
+        def pull_engine(engine)
+          metadata = engine_registry.fetch_engine_details(engine)
+          unless system("docker pull #{metadata.image}")
+            raise ImagePullFailure, "unable to pull image #{metadata.image}"
+          end
+        rescue EngineRegistry::EngineDetailsNotFoundError
+          warn("unknown engine <#{engine.name}:#{engine.channel}>")
+        end
+      end
+    end
+  end
+end