codeclimate 0.69.0 → 0.70.0

data/lib/cc/analyzer/statsd_container_listener.rb

@@ -1,44 +1,44 @@
 module CC
   module Analyzer
     class StatsdContainerListener < ContainerListener
-      def initialize(engine_name, statsd)
-        @engine_name = engine_name
+      def initialize(statsd)
         @statsd = statsd
       end
 
-      def started(_data)
-        increment("started")
+      def started(engine, _details)
+        increment(engine.name, "started")
       end
 
-      def timed_out(data)
-        timing("time", data.duration)
-        increment("result.error")
-        increment("result.error.timeout")
-      end
-
-      def finished(data)
-        timing("time", data.duration)
-        increment("finished")
-
-        if data.status.success?
-          increment("result.success")
+      def finished(engine, _details, result)
+        timing(engine.name, "time", result.duration)
+        increment(engine.name, "finished")
+
+        if result.timed_out?
+          timing(engine.name, "time", result.duration)
+          increment(engine.name, "result.error")
+          increment(engine.name, "result.error.timeout")
+        elsif result.maximum_output_exceeded?
+          increment(engine.name, "result.error")
+          increment(engine.name, "result.error.output_exceeded")
+        elsif result.exit_status.nonzero?
+          increment(engine.name, "result.error")
         else
-          increment("result.error")
+          increment(engine.name, "result.success")
         end
       end
 
       private
 
-      attr_reader :engine_name, :statsd
+      attr_reader :statsd
 
-      def increment(metric)
+      def increment(name, metric)
         statsd.increment("engines.#{metric}")
-        statsd.increment("engines.names.#{engine_name}.#{metric}")
+        statsd.increment("engines.names.#{name}.#{metric}")
       end
 
-      def timing(metric, ms)
+      def timing(name, metric, ms)
         statsd.timing("engines.#{metric}", ms)
-        statsd.timing("engines.names.#{engine_name}.#{metric}", ms)
+        statsd.timing("engines.names.#{name}.#{metric}", ms)
       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

@@ -1,20 +1,18 @@
 require "active_support"
-require "active_support/core_ext/module/remove_method" # Temporary, see https://github.com/codeclimate/codeclimate/pull/658
 require "active_support/core_ext"
 require "yaml"
 require "cc/analyzer"
+require "cc/config"
+require "cc/engine_registry"
 require "cc/workspace"
-require "cc/yaml"
 
 require "cc/cli/analyze"
 require "cc/cli/command"
 require "cc/cli/console"
 require "cc/cli/engines"
 require "cc/cli/help"
-require "cc/cli/init"
 require "cc/cli/output"
 require "cc/cli/prepare"
-require "cc/cli/prepare/quality"
 require "cc/cli/runner"
 require "cc/cli/test"
 require "cc/cli/validate_config"
@@ -26,15 +24,17 @@ module CC
       ENV["CODECLIMATE_DEBUG"]
     end
 
-    def self.debug(message, values = {})
-      if debug?
-        if values.any?
-          message << " "
-          message << values.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
-        end
-
-        $stderr.puts("[DEBUG] #{message}")
+    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

data/lib/cc/cli/analyze.rb

@@ -12,32 +12,33 @@ module CC
         "    --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 initialize(_args = [])
-        super
-        @engine_options = []
-        @path_options = []
+      def run
+        # Load config here so it sees ./.codeclimate.yml
+        @config = Config.load
 
+        # process args after, so it modifies loaded configuration
         process_args
-        apply_config_options
-      end
-
-      def run
-        require_codeclimate_yml
 
-        Dir.chdir(MountedPath.code.container_path) do
-          runner = EnginesRunner.new(registry, formatter, source_dir, config, path_options)
-          runner.run
-        end
-      rescue EnginesRunner::NoEnabledEngines
-        fatal("No enabled engines. Add some to your .codeclimate.yml file!")
+        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_accessor :config
-      attr_reader :engine_options, :path_options
+      attr_reader :config, :engines_disabled, :listener, :registry
 
       def process_args
         while (arg = @args.shift)
@@ -45,62 +46,43 @@ module CC
           when "-f", "--format"
             @formatter = Formatters.resolve(@args.shift).new(filesystem)
           when "-e", "--engine"
-            @engine_options << @args.shift
+            disable_all_engines!
+            name, channel = @args.shift.split(":", 2)
+            enable_engine(name, channel)
           when "--dev"
-            @dev_mode = true
+            config.development = true
+          when "--no-plugins"
+            config.disable_plugins!
           else
-            @path_options << arg
+            config.analysis_paths << arg
           end
         end
-      rescue Formatters::Formatter::InvalidFormatterError => e
-        fatal(e.message)
-      end
-
-      def registry
-        EngineRegistry.new(@dev_mode)
+      rescue Formatters::Formatter::InvalidFormatterError => ex
+        fatal(ex.message)
       end
 
       def formatter
         @formatter ||= Formatters::PlainTextFormatter.new(filesystem)
       end
 
-      def source_dir
-        MountedPath.code.host_path
-      end
-
-      def config
-        @config ||= CC::Yaml.parse(filesystem.read_path(CODECLIMATE_YAML))
-      end
-
-      def apply_config_options
-        if engine_options.any? && config.engines?
-          filter_by_engine_options
-        elsif engine_options.any?
-          config["engines"] = CC::Yaml::Nodes::EngineList.new(config).with_value({})
+      def disable_all_engines!
+        unless engines_disabled
+          config.engines.each { |e| e.enabled = false }
+          @engines_disabled = true
         end
-        add_engine_options
       end
 
-      def filter_by_engine_options
-        config.engines.keys.each do |engine|
-          unless engine_options.include?(engine)
-            config.engines.delete(engine)
-          end
-        end
-      end
-
-      def add_engine_options
-        engine_options.each do |engine|
-          name, channel = engine.split(":", 2)
-
-          if config.engines.include?(engine)
-            config.engines[name].enabled = true
-            config.engines[name].channel = channel if channel
-          else
-            value = { "enabled" => true }
-            value["channel"] = channel if channel
-            config.engines[name] = CC::Yaml::Nodes::Engine.new(config.engines).with_value(value)
-          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

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

@@ -73,12 +73,6 @@ module CC
         run
       end
 
-      def require_codeclimate_yml
-        unless filesystem.exist?(CODECLIMATE_YAML)
-          fatal("No '.codeclimate.yml' file found. Run 'codeclimate init' to generate a config file.")
-        end
-      end
-
       private
 
       def filesystem
@@ -86,10 +80,6 @@ module CC
           CC::Analyzer::MountedPath.code.container_path,
         )
       end
-
-      def engine_registry
-        @engine_registry ||= CC::Analyzer::EngineRegistry.new
-      end
     end
   end
 end

data/lib/cc/cli/engines.rb

@@ -1,8 +1,5 @@
 require "cc/analyzer"
 
-require "cc/cli/engines/disable"
-require "cc/cli/engines/enable"
 require "cc/cli/engines/engine_command"
 require "cc/cli/engines/install"
 require "cc/cli/engines/list"
-require "cc/cli/engines/remove"

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

@@ -4,42 +4,10 @@ module CC
   module CLI
     module Engines
       class EngineCommand < Command
-        include CC::Analyzer
-
         abstract!
 
-        private
-
-        def engine_name
-          @engine_name ||= @args.first
-        end
-
-        def parsed_yaml
-          @parsed_yaml ||= CC::Analyzer::Config.new(yaml_content)
-        end
-
-        def yaml_content
-          filesystem.read_path(CODECLIMATE_YAML).freeze
-        end
-
-        def update_yaml
-          filesystem.write_path(CODECLIMATE_YAML, parsed_yaml.to_yaml)
-        end
-
-        def engine_present_in_yaml?
-          parsed_yaml.engine_present?(engine_name)
-        end
-
-        def engine_enabled?
-          parsed_yaml.engine_enabled?(engine_name)
-        end
-
-        def engine_exists?
-          engine_registry.exists?(engine_name)
-        end
-
-        def engine_registry_list
-          engine_registry.list
+        def engine_registry
+          @engine_registry ||= EngineRegistry.new
         end
       end
     end

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

@@ -2,38 +2,32 @@ module CC
   module CLI
     module Engines
       class Install < EngineCommand
-        SHORT_HELP = "Pull the latest images for enabled engines in your codeclimate.yml.".freeze
+        SHORT_HELP = "Pull the latest images for enabled engines in your configuration".freeze
 
         ImagePullFailure = Class.new(StandardError)
 
         def run
-          require_codeclimate_yml
-
           say "Pulling docker images."
           pull_docker_images
         end
 
         private
 
-        def pull_docker_images
-          engine_names.each do |name|
-            if engine_registry.exists?(name)
-              images = engine_registry[name]["channels"].values
-              images.each { |image| pull_engine_image(image) }
-            else
-              warn("unknown engine name: #{name}")
-            end
-          end
+        def config
+          @config ||= CC::Config.load
         end
 
-        def engine_names
-          @engine_names ||= parsed_yaml.engine_names
+        def pull_docker_images
+          config.engines.each(&method(:pull_engine))
         end
 
-        def pull_engine_image(engine_image)
-          unless system("docker pull #{engine_image}")
-            raise ImagePullFailure, "unable to pull image #{engine_image}"
+        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

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

@@ -6,9 +6,11 @@ module CC
 
         def run
           say "Available engines:"
-          engine_registry_list.sort_by { |name, _| name }.each do |name, attributes|
-            say "- #{name}: #{attributes["description"]}"
-          end
+          engine_registry.
+            sort_by { |engine, _| engine.name }.
+            each do |engine, metadata|
+              say "- #{engine.name}: #{metadata.description}"
+            end
         end
       end
     end