codeclimate 0.69.0 → 0.70.0

data/lib/cc/analyzer/engine_output.rb

@@ -2,33 +2,59 @@ module CC
   module Analyzer
     class EngineOutput
       delegate :blank?, to: :raw_output
-      delegate :to_json, to: :as_issue
 
-      def initialize(raw_output)
+      def initialize(name, raw_output)
+        @name = name
         @raw_output = raw_output
       end
 
       def issue?
-        parsed_output &&
-          parsed_output["type"].present? &&
-          parsed_output["type"].downcase == "issue"
+        valid_with_type?("issue")
+      end
+
+      def measurement?
+        valid_with_type?("measurement")
       end
 
       def as_issue
-        Issue.new(raw_output)
+        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?
-        validator.valid?
+        valid_json? && validator && validator.valid?
       end
 
       def error
-        validator.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 :raw_output
+      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)
@@ -37,7 +63,11 @@ module CC
       end
 
       def validator
-        IssueValidator.new(parsed_output)
+        if issue?
+          IssueValidator.new(parsed_output)
+        elsif measurement?
+          MeasurementValidator.new(parsed_output)
+        end
       end
     end
   end

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

@@ -16,6 +16,8 @@ module CC
             issues << json
           when "warning"
             warnings << json
+          when "measurement"
+            measurements << json
           else
             raise "Invalid type found: #{json["type"]}"
           end

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

@@ -405,6 +405,10 @@ module CC
         def warnings
           @warnings ||= []
         end
+
+        def measurements
+          @measurements ||= []
+        end
       end
     end
   end

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

@@ -17,6 +17,7 @@ module CC
 
         def write(data)
           document = JSON.parse(data)
+          return unless document["type"] == "issue"
           document["engine_name"] = current_engine.name
 
           if @has_begun

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

@@ -38,7 +38,10 @@ module CC
 
         def engine_running(engine, &block)
           super(engine) do
-            with_spinner("Running #{current_engine.name}: ", &block)
+            result = with_spinner("Running #{current_engine.name}: ", &block)
+            if result.skipped?
+              puts(colorize("Skipped #{current_engine.name}: #{result.stderr}", :yellow))
+            end
           end
         end
 
@@ -85,6 +88,10 @@ module CC
           @warnings ||= []
         end
 
+        def measurements
+          @measurements ||= []
+        end
+
         def pluralize(number, noun)
           "#{ActiveSupport::NumberHelper.number_to_delimited(number)} #{noun.pluralize(number)}"
         end

data/lib/cc/analyzer/issue.rb

@@ -16,12 +16,14 @@ module CC
         type
       ]
 
-      def initialize(output)
+      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
@@ -43,7 +45,7 @@ module CC
 
       private
 
-      attr_reader :output
+      attr_reader :engine_name, :output
 
       def default_fingerprint
         SourceFingerprint.new(self).compute

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

@@ -4,10 +4,14 @@ module CC
   module Analyzer
     module IssueValidations
       class RelativePathValidation < Validation
+        BUILDER_CODE_PATH = "/tmp/workspace/code".freeze
+
         def valid?
           path &&
-            !path.start_with?("/") &&
-            relative_to?(MountedPath.code.container_path)
+            !path.start_with?("/") && (
+              relative_to?(MountedPath.code.container_path) ||
+              relative_to?(BUILDER_CODE_PATH)
+            )
         end
 
         def message

data/lib/cc/analyzer/issue_validator.rb

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

data/lib/cc/analyzer/logging_container_listener.rb

@@ -1,22 +1,24 @@
 module CC
   module Analyzer
     class LoggingContainerListener < ContainerListener
-      def initialize(engine_name, logger)
-        @engine_name = engine_name
+      def initialize(logger)
         @logger = logger
       end
 
-      def started(_data)
-        logger.info("starting engine #{engine_name}")
+      def started(engine, _details)
+        logger.info("starting engine #{engine.name}")
       end
 
-      def finished(_data)
-        logger.info("finished engine #{engine_name}")
+      def finished(engine, _details, result)
+        logger.info("finished engine #{engine.name}")
+        if result.skipped?
+          logger.warn("skipped engine #{engine.name}: #{result.stderr}")
+        end
       end
 
       private
 
-      attr_reader :engine_name, :logger
+      attr_reader :logger
     end
   end
 end

data/lib/cc/analyzer/measurement.rb

@@ -0,0 +1,22 @@
+module CC
+  module Analyzer
+    class Measurement
+      def initialize(engine_name, output)
+        @engine_name = engine_name
+        @output = output
+      end
+
+      def as_json(*)
+        parsed_output.merge("engine_name" => engine_name)
+      end
+
+      private
+
+      attr_reader :engine_name, :output
+
+      def parsed_output
+        @parsed_output ||= JSON.parse(output)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/measurement_validations.rb

@@ -0,0 +1,16 @@
+module CC
+  module Analyzer
+    module MeasurementValidations
+      autoload :NameValidation, "cc/analyzer/measurement_validations/name_validation"
+      autoload :TypeValidation, "cc/analyzer/measurement_validations/type_validation"
+      autoload :ValueValidation, "cc/analyzer/measurement_validations/value_validation"
+      autoload :Validation, "cc/analyzer/measurement_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/measurement_validations/name_validation.rb

@@ -0,0 +1,23 @@
+module CC
+  module Analyzer
+    module MeasurementValidations
+      class NameValidation < Validation
+        REGEX = /^[A-Za-z0-9_\.\-]+$/
+
+        def valid?
+          name && name.is_a?(String) && REGEX.match?(name)
+        end
+
+        def message
+          "Name must be present and contain only letters, numbers, periods, hyphens, and underscores"
+        end
+
+        private
+
+        def name
+          object["name"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module CC
+  module Analyzer
+    module MeasurementValidations
+      class TypeValidation < Validation
+        def valid?
+          type && type.casecmp("measurement").zero?
+        end
+
+        def message
+          "Type must be 'measurement' but was '#{type}'"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module CC
+  module Analyzer
+    module MeasurementValidations
+      class Validation
+        def initialize(object)
+          @object = object
+        end
+
+        def valid?
+          raise NotImplementedError
+        end
+
+        def message
+          raise NotImplementedError
+        end
+
+        private
+
+        attr_reader :object
+
+        def type
+          object["type"]
+        end
+      end
+    end
+  end
+end

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 && 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/raising_container_listener.rb

@@ -1,32 +1,32 @@
 module CC
   module Analyzer
     class RaisingContainerListener < ContainerListener
-      def initialize(engine_name, failure_ex, timeout_ex)
-        @engine_name = engine_name
+      def initialize(failure_ex, timeout_ex = nil, maximum_output_ex = nil)
         @failure_ex = failure_ex
-        @timeout_ex = timeout_ex
+        @timeout_ex = timeout_ex || failure_ex
+        @maximum_output_ex = maximum_output_ex || failure_ex
       end
 
-      def timed_out(data)
-        message = "engine #{engine_name} ran for #{data.duration / 1000} seconds"
-        message << " and was killed"
-
-        raise timeout_ex, message
-      end
-
-      def finished(data)
-        unless data.status.success?
-          message = "engine #{engine_name} failed"
-          message << " with status #{data.status.exitstatus}"
-          message << " and stderr \n#{data.stderr}"
-
-          raise failure_ex, message
+      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 :engine_name, :failure_ex, :timeout_ex
+      attr_reader :failure_ex, :timeout_ex, :maximum_output_ex
     end
   end
 end