codeclimate 0.69.0 → 0.70.0

data/lib/cc/analyzer/config.rb

@@ -1,86 +0,0 @@
-module CC
-  module Analyzer
-    # TODO: replace each use of this with CC::Yaml and remove it
-    class Config
-      def initialize(config_body)
-        @config = YAML.safe_load(config_body) || { "engines" => {} }
-        @config["engines"] ||= {}
-
-        expand_shorthand
-      end
-
-      def to_hash
-        @config
-      end
-
-      def engine_config(engine_name)
-        @config["engines"][engine_name] || {}
-      end
-
-      def engine_names
-        @config["engines"].keys.select { |name| engine_enabled?(name) }
-      end
-
-      def engine_present?(engine_name)
-        @config["engines"][engine_name].present?
-      end
-
-      def engine_enabled?(engine_name)
-        @config["engines"][engine_name] && @config["engines"][engine_name]["enabled"]
-      end
-
-      def enable_engine(engine_name)
-        if engine_present?(engine_name)
-          @config["engines"][engine_name]["enabled"] = true
-        else
-          @config["engines"][engine_name] = { "enabled" => true }
-          enable_default_config(engine_name) if default_config(engine_name)
-        end
-      end
-
-      def enable_default_config(engine_name)
-        @config["engines"][engine_name]["config"] = default_config(engine_name)
-      end
-
-      def exclude_paths
-        @config["exclude_paths"]
-      end
-
-      def disable_engine(engine_name)
-        if engine_present?(engine_name) && engine_enabled?(engine_name)
-          @config["engines"][engine_name]["enabled"] = false
-        end
-      end
-
-      def remove_engine(engine_name)
-        if engine_present?(engine_name)
-          @config["engines"].delete(engine_name)
-        end
-      end
-
-      def to_yaml
-        @config.to_yaml
-      end
-
-      private
-
-      def expand_shorthand
-        @config["engines"].each do |name, engine_config|
-          if [true, false].include?(engine_config)
-            @config["engines"][name] = { "enabled" => engine_config }
-          end
-        end
-      end
-
-      def default_config(engine_name)
-        if (engine_config = engine_registry[engine_name])
-          engine_config["default_config"]
-        end
-      end
-
-      def engine_registry
-        @engine_registry ||= CC::Analyzer::EngineRegistry.new
-      end
-    end
-  end
-end

data/lib/cc/analyzer/engine_registry.rb

@@ -1,36 +0,0 @@
-module CC
-  module Analyzer
-    class EngineRegistry
-      def initialize(dev_mode = false)
-        @path = File.expand_path("../../../../config/engines.yml", __FILE__)
-        @config = YAML.safe_load(File.read(@path))
-        @dev_mode = dev_mode
-      end
-
-      def [](engine_name)
-        if dev_mode?
-          { "channels" => { "stable" => "codeclimate/codeclimate-#{engine_name}:latest" } }
-        else
-          @config[engine_name]
-        end
-      end
-
-      def list
-        @config
-      end
-
-      def key?(engine_name)
-        return true if dev_mode?
-        list.key?(engine_name)
-      end
-
-      alias_method :exists?, :key?
-
-      private
-
-      def dev_mode?
-        @dev_mode
-      end
-    end
-  end
-end

data/lib/cc/analyzer/engines_config_builder.rb

@@ -1,97 +0,0 @@
-require "securerandom"
-
-module CC
-  module Analyzer
-    class EnginesConfigBuilder
-      class RegistryAdapter < SimpleDelegator
-        # Calling this is guarded by Registry#key?(name) so we can assume
-        # metadata itself will be present. We own the YAML loaded into the
-        # registry, so we can also assume the "channels" key will be present. We
-        # can't assume it will have a key for the given channel, but the nil
-        # value for the returned image key will trigger the desired error
-        # handling.
-        def fetch(name, channel)
-          metadata = self[name]
-          metadata.merge("image" => metadata["channels"][channel.to_s])
-        end
-      end
-
-      Result = Struct.new(
-        :name,
-        :registry_entry,
-        :code_path,
-        :config,
-        :container_label,
-      )
-
-      def initialize(registry:, config:, container_label:, source_dir:, requested_paths:)
-        @registry = RegistryAdapter.new(registry)
-        @config = config
-        @container_label = container_label
-        @requested_paths = requested_paths
-        @source_dir = source_dir
-      end
-
-      def run
-        names_and_raw_engine_configs.map do |name, raw_engine_config|
-          label = @container_label || SecureRandom.uuid
-          engine_config = engine_config(raw_engine_config)
-          engine_metadata = @registry.fetch(name, raw_engine_config.channel)
-          Result.new(name, engine_metadata, @source_dir, engine_config, label)
-        end
-      end
-
-      private
-
-      def engine_config(raw_engine_config)
-        engine_workspace = engine_workspace(raw_engine_config)
-        config = raw_engine_config.merge(
-          include_paths: engine_workspace.paths,
-        )
-
-        normalize_config_file(config)
-
-        config
-      end
-
-      def engine_workspace(raw_engine_config)
-        if raw_engine_config.key?("exclude_paths") && !@requested_paths.present?
-          base_workspace.clone.tap do |workspace|
-            workspace.remove(raw_engine_config["exclude_paths"])
-          end
-        else
-          base_workspace
-        end
-      end
-
-      def names_and_raw_engine_configs
-        {}.tap do |ret|
-          (@config.engines || {}).each do |name, raw_engine_config|
-            if raw_engine_config.enabled? && @registry.key?(name)
-              ret[name] = raw_engine_config
-            end
-          end
-        end
-      end
-
-      def base_workspace
-        @base_workspace ||= Workspace.new.tap do |workspace|
-          workspace.add(@requested_paths)
-          unless @requested_paths.present?
-            workspace.remove([".git"])
-            workspace.remove(@config.exclude_paths)
-          end
-        end
-      end
-
-      # The yaml gem turns a config file string into a hash, but engines expect
-      # the string. So we (for now) need to turn it into a string in that one
-      # scenario.
-      def normalize_config_file(config)
-        if config.fetch("config", {}).keys.size == 1 && config["config"].key?("file")
-          config["config"] = config["config"]["file"]
-        end
-      end
-    end
-  end
-end

data/lib/cc/analyzer/engines_runner.rb

@@ -1,64 +0,0 @@
-require "securerandom"
-
-module CC
-  module Analyzer
-    class EnginesRunner
-      NoEnabledEngines = Class.new(StandardError)
-
-      def initialize(registry, formatter, source_dir, config, requested_paths = [], container_label = nil)
-        @registry = registry
-        @formatter = formatter
-        @source_dir = source_dir
-        @config = config
-        @requested_paths = requested_paths
-        @container_label = container_label
-      end
-
-      def run(container_listener = ContainerListener.new)
-        raise NoEnabledEngines if engines.empty?
-
-        @formatter.started
-
-        engines.each { |engine| run_engine(engine, container_listener) }
-
-        @formatter.finished
-      ensure
-        @formatter.close if @formatter.respond_to?(:close)
-      end
-
-      private
-
-      attr_reader :requested_paths
-
-      def build_engine(built_config)
-        Engine.new(
-          built_config.name,
-          built_config.registry_entry,
-          built_config.code_path,
-          built_config.config,
-          built_config.container_label,
-        )
-      end
-
-      def configs
-        EnginesConfigBuilder.new(
-          registry: @registry,
-          config: @config,
-          container_label: @container_label,
-          source_dir: @source_dir,
-          requested_paths: requested_paths,
-        ).run
-      end
-
-      def engines
-        @engines ||= configs.map { |result| build_engine(result) }
-      end
-
-      def run_engine(engine, container_listener)
-        @formatter.engine_running(engine) do
-          engine.run(@formatter, container_listener)
-        end
-      end
-    end
-  end
-end

data/lib/cc/cli/config.rb

@@ -1,44 +0,0 @@
-module CC
-  module CLI
-    class Config
-      delegate :to_yaml, to: :config
-
-      def initialize(config = {})
-        @config = default_config.merge(config)
-      end
-
-      def add_engine(engine_name, engine_config)
-        config["engines"][engine_name] = { "enabled" => true }
-
-        if engine_config["default_config"].present?
-          config["engines"][engine_name]["config"] = engine_config["default_config"]
-        end
-
-        # we may not want this code in the general case.
-        # for now, we need it to test one of our own Maintainability engines
-        # which is in the 'beta' channel
-        if engine_config.key?("channels") && !engine_config["channels"].include?("stable")
-          config["engines"][engine_name]["channel"] = engine_config["channels"].first.first
-        end
-
-        config["ratings"]["paths"] |= engine_config["default_ratings_paths"]
-      end
-
-      def add_exclude_paths(paths)
-        config["exclude_paths"] ||= []
-        config["exclude_paths"] |= paths
-      end
-
-      private
-
-      attr_reader :config
-
-      def default_config
-        {
-          "engines" => {},
-          "ratings" => { "paths" => [] },
-        }
-      end
-    end
-  end
-end

data/lib/cc/cli/config_generator.rb

@@ -1,108 +0,0 @@
-require "posix/spawn"
-require "shellwords"
-
-module CC
-  module CLI
-    class ConfigGenerator
-      CODECLIMATE_YAML = Command::CODECLIMATE_YAML
-      AUTO_EXCLUDE_PATHS = %w(config/ db/ dist/ features/ node_modules/ script/ spec/ test/ tests/ vendor/).freeze
-
-      ConfigGeneratorError = Class.new(StandardError)
-
-      def self.for(filesystem, engine_registry, upgrade_requested)
-        if upgrade_requested && upgrade_needed?(filesystem)
-          UpgradeConfigGenerator.new(filesystem, engine_registry)
-        else
-          ConfigGenerator.new(filesystem, engine_registry)
-        end
-      end
-
-      def initialize(filesystem, engine_registry)
-        @filesystem = filesystem
-        @engine_registry = engine_registry
-      end
-
-      def can_generate?
-        true
-      end
-
-      def eligible_engines
-        return @eligible_engines if @eligible_engines
-
-        engines = engine_registry.list
-        @eligible_engines = engines.each_with_object({}) do |(name, config), result|
-          if engine_eligible?(config)
-            result[name] = config
-          end
-        end
-      end
-
-      def errors
-        []
-      end
-
-      def exclude_paths
-        @exclude_paths ||= AUTO_EXCLUDE_PATHS.select { |path| filesystem.exist?(path) }
-      end
-
-      def post_generation_verb
-        "generated"
-      end
-
-      private
-
-      attr_reader :engine_registry, :filesystem
-
-      def self.upgrade_needed?(filesystem)
-        if filesystem.exist?(CODECLIMATE_YAML)
-          YAML.safe_load(File.read(CODECLIMATE_YAML))["languages"].present?
-        end
-      end
-
-      def engine_eligible?(engine)
-        engine["channels"].keys.any? { |channel| channel == "stable" } &&
-          !engine["community"] &&
-          engine["enable_regexps"].present? &&
-          files_exist?(engine)
-      end
-
-      def files_exist?(engine)
-        workspace_files.any? do |path|
-          engine["enable_regexps"].any? { |re| Regexp.new(re).match(path) }
-        end
-      end
-
-      def non_excluded_paths
-        @non_excluded_paths ||= begin
-          excludes = exclude_paths.map { |path| path.chomp("/") }
-          filesystem.ls.reject do |path|
-            path.starts_with?("-") || path.starts_with?(".") || excludes.include?(path)
-          end
-        end
-      end
-
-      def workspace_files
-        @workspace_files ||= Dir.chdir(filesystem.root) do
-          if non_excluded_paths.empty?
-            []
-          else
-            find_workspace_files
-          end
-        end
-      end
-
-      def find_workspace_files
-        find_cmd = %w[find] + non_excluded_paths + %w[-type f -print0]
-        child = POSIX::Spawn::Child.new(*find_cmd)
-
-        if child.status.success?
-          child.out.strip.split("\0").map do |path|
-            path.sub(%r{^\.\/}, "")
-          end
-        else
-          raise ConfigGeneratorError, "Failed to find analyzable files.\nRan '#{find_cmd.shelljoin}', exited with code #{child.status.to_i} and stderr:\n'#{child.err}'"
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require "cc/analyzer"
-require "cc/cli/engines/engine_command"
-
-module CC
-  module CLI
-    module Engines
-      class Disable < EngineCommand
-        ARGUMENT_LIST = "<engine_name>".freeze
-        SHORT_HELP = "Disable an engine in your codeclimate.yml.".freeze
-        HELP = "#{SHORT_HELP}\n" \
-          "\n"\
-          "    <engine_name>    Engine to disable in your codeclimate.yml".freeze
-
-        def run
-          require_codeclimate_yml
-
-          if !engine_exists?
-            say "Engine not found. Run 'codeclimate engines:list' for a list of valid engines."
-          elsif !engine_present_in_yaml?
-            say "Engine not found in .codeclimate.yml."
-          elsif !engine_enabled?
-            say "Engine already disabled."
-          else
-            disable_engine
-            update_yaml
-            say "Engine disabled."
-          end
-        end
-
-        private
-
-        def disable_engine
-          parsed_yaml.disable_engine(engine_name)
-        end
-      end
-    end
-  end
-end