codeclimate 0.69.0 → 0.70.0

data/lib/cc/cli/prepare.rb

@@ -1,5 +1,3 @@
-require "cc/cli/config"
-require "cc/resolv"
 require "fileutils"
 require "ipaddr"
 require "json"
@@ -7,6 +5,8 @@ require "net/http"
 require "pathname"
 require "uri"
 
+require "cc/resolv"
+
 module CC
   module CLI
     class Prepare < Command
@@ -29,13 +29,7 @@ module CC
       ].freeze
 
       def run
-        require_codeclimate_yml
-        fatal("No fetches configured") unless fetches.present?
-
-        Dir.chdir(CC::Analyzer::MountedPath.code.container_path) do
-          ::CC::Resolv.with_fixed_dns { fetch_all }
-        end
-        success("All fetches fetched")
+        ::CC::Resolv.with_fixed_dns { fetch_all }
       rescue FetchError, InternalHostError => ex
         fatal(ex.message)
       end
@@ -47,11 +41,11 @@ module CC
       end
 
       def fetches
-        @fetches ||= config[:prepare] && config[:prepare].fetch
+        @fetches ||= config.prepare.fetch
       end
 
       def config
-        @config ||= CC::Yaml.parse(filesystem.read_path(CODECLIMATE_YAML))
+        @config ||= CC::Config.load
       end
 
       def fetch_all

data/lib/cc/cli/runner.rb

@@ -9,8 +9,7 @@ module CC
         new(argv).run
       rescue => ex
         $stderr.puts("error: (#{ex.class}) #{ex.message}")
-
-        CLI.debug("backtrace: #{ex.backtrace.join("\n\t")}")
+        CLI.logger.debug("backtrace: #{ex.backtrace.join("\n\t")}")
         exit 1
       end
 

data/lib/cc/cli/test.rb

@@ -1,4 +1,3 @@
-require "cc/yaml"
 require "tmpdir"
 
 module CC

data/lib/cc/cli/validate_config.rb

@@ -1,97 +1,83 @@
-require "cc/yaml"
-
 module CC
   module CLI
     class ValidateConfig < Command
-      SHORT_HELP = "Validate your .codeclimate.yml.".freeze
-
-      include CC::Analyzer
-      include CC::Yaml
-
-      VALID_CONFIG_MESSAGE = "No errors or warnings found in .codeclimate.yml file.".freeze
+      NO_CONFIG_MESSAGE = "No checked in config: nothing to validate.".freeze
+      TOO_MANY_CONFIG_MESSAGE = "Don't commit both .codeclimate.yml & .codeclimate.json: only the JSON will be used.".freeze
+      SHORT_HELP = "Validate your .codeclimate.yml or .codeclimate.json.".freeze
+      VALID_CONFIG_MESSAGE = "No errors or warnings found in %s.".freeze
 
       def run
-        require_codeclimate_yml
-        verify_yaml
-      end
+        require_json_or_yaml
+        process_args
 
-      private
-
-      def verify_yaml
         if any_issues?
           display_issues
         else
-          puts colorize(VALID_CONFIG_MESSAGE, :green)
+          puts format(VALID_CONFIG_MESSAGE, validator.path)
         end
-      end
 
-      def any_issues?
-        parsed_yaml.errors? || parsed_yaml.nested_warnings.any? || parsed_yaml.warnings? || invalid_engines.any?
+        exit 1 unless validator.valid?
       end
 
-      def yaml_content
-        filesystem.read_path(CODECLIMATE_YAML).freeze
-      end
+      private
 
-      def parsed_yaml
-        @parsed_yaml ||= CC::Yaml.parse(yaml_content)
-      end
+      attr_reader :config, :registry_path, :registry_prefix, :validator
 
-      def warnings
-        @warnings ||= parsed_yaml.warnings
-      end
+      def process_args
+        @registry_path = EngineRegistry::DEFAULT_MANIFEST_PATH
+        @registry_prefix = ""
 
-      def nested_warnings
-        @nested_warnings ||= parsed_yaml.nested_warnings
+        # Undocumented; we only need these from Builder so we can validate
+        # engines/channels against our own registry and prefix.
+        while (arg = @args.shift)
+          case arg
+          when "--registry" then @registry_path = @args.shift
+          when "--registry-prefix" then @registry_prefix = @args.shift
+          end
+        end
       end
 
-      def errors
-        @errors ||= parsed_yaml.errors
+      def any_issues?
+        validator.errors.any? ||
+          validator.warnings.any?
       end
 
       def display_issues
-        display_errors
-        display_warnings
-        display_invalid_engines
-        display_nested_warnings
-      end
-
-      def display_errors
-        errors.each do |error|
-          puts colorize("ERROR: #{error}", :red)
-        end
-      end
-
-      def display_nested_warnings
-        nested_warnings.each do |nested_warning|
-          if nested_warning[0][0]
-            puts colorize("WARNING in #{nested_warning[0][0]}: #{nested_warning[1]}", :red)
-          end
+        validator.errors.each do |error|
+          puts "#{colorize("ERROR", :red)}: #{error}"
         end
-      end
 
-      def display_warnings
-        warnings.each do |warning|
-          puts colorize("WARNING: #{warning}", :red)
+        validator.warnings.each do |warning|
+          puts "#{colorize("WARNING", :yellow)}: #{warning}"
         end
       end
 
-      def display_invalid_engines
-        invalid_engines.each do |engine_name|
-          puts colorize("WARNING: unknown engine <#{engine_name}>", :red)
+      def require_json_or_yaml
+        if !filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH) && !filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+          puts NO_CONFIG_MESSAGE
+          exit 0
+        elsif filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH) && filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+          puts "#{colorize("WARNING", :yellow)}: #{TOO_MANY_CONFIG_MESSAGE}"
         end
       end
 
-      def invalid_engines
-        @invalid_engines ||= engine_names.reject { |engine_name| engine_registry.exists? engine_name }
-      end
-
-      def engine_names
-        @engine_names ||= engines.keys
+      def validator
+        @validator =
+          if filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+            Config::Validation::JSON.new(
+              Config::JSONAdapter::DEFAULT_PATH,
+              engine_registry,
+            )
+          elsif filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH)
+            Config::Validation::YAML.new(
+              Config::YAMLAdapter::DEFAULT_PATH,
+              engine_registry,
+            )
+          end
       end
 
-      def engines
-        @engines ||= parsed_yaml.engines || {}
+      def engine_registry
+        EngineRegistry.new(registry_path, registry_prefix)
       end
     end
   end

data/lib/cc/cli/version_checker.rb

@@ -16,7 +16,7 @@ module CC
 
         global_config.save
       rescue => error
-        CLI.debug(error)
+        CLI.logger.debug(error)
       end
 
       private
@@ -42,7 +42,7 @@ module CC
           begin
             cache! JSON.parse(api_response_body)
           rescue JSON::ParserError => error
-            CLI.debug(error)
+            CLI.logger.debug(error)
             {
               "outdated" => false,
             }
@@ -56,7 +56,7 @@ module CC
           raise Net::HTTPFatalError.new("HTTP Error", http_response)
         end
       rescue Net::HTTPFatalError => error
-        CLI.debug(error)
+        CLI.logger.debug(error)
         ""
       end
 

data/lib/cc/config.rb

@@ -0,0 +1,70 @@
+require "cc/config/checks_adapter"
+require "cc/config/default_adapter"
+require "cc/config/engine"
+require "cc/config/engine_set"
+require "cc/config/json_adapter"
+require "cc/config/prepare"
+require "cc/config/validation/hash_validations"
+require "cc/config/validation/check_validator"
+require "cc/config/validation/engine_validator"
+require "cc/config/validation/fetch_validator"
+require "cc/config/validation/file_validator"
+require "cc/config/validation/json"
+require "cc/config/validation/prepare_validator"
+require "cc/config/validation/yaml"
+require "cc/config/yaml_adapter"
+
+module CC
+  class Config
+    attr_reader \
+      :analysis_paths,
+      :engines,
+      :exclude_patterns,
+      :prepare
+
+    attr_writer \
+      :development
+
+    def self.load
+      config =
+        if File.exist?(JSONAdapter::DEFAULT_PATH)
+          JSONAdapter.load.config
+        elsif File.exist?(YAMLAdapter::DEFAULT_PATH)
+          YAMLAdapter.load.config
+        else
+          {}
+        end
+      config = DefaultAdapter.new(config).config
+      config = ChecksAdapter.new(config).config
+      build(config)
+    end
+
+    def self.build(data)
+      new(
+        engines: EngineSet.new(data.fetch("plugins", {})).engines,
+        exclude_patterns: data.fetch("exclude_patterns", DefaultAdapter::EXCLUDE_PATTERNS),
+        prepare: Prepare.from_data(data["prepare"]),
+      )
+    end
+
+    def initialize(analysis_paths: [], development: false, engines: [], exclude_patterns: [], prepare: Prepare.new)
+      @analysis_paths = analysis_paths
+      @development = development
+      @engines = engines
+      @exclude_patterns = exclude_patterns
+      @prepare = prepare
+    end
+
+    def merge(other)
+      Merge.new(self, other).run
+    end
+
+    def development?
+      @development
+    end
+
+    def disable_plugins!
+      @engines.delete_if(&:plugin?)
+    end
+  end
+end

data/lib/cc/config/checks_adapter.rb

@@ -0,0 +1,40 @@
+module CC
+  class Config
+    class ChecksAdapter
+      attr_reader :config
+
+      def initialize(data = {})
+        @config = data
+
+        return unless checks.present?
+        copy_qm_checks_config
+      end
+
+      private
+
+      def copy_qm_checks_config
+        DefaultAdapter::ENGINES.keys.each do |name|
+          copy_checks(name)
+        end
+      end
+
+      def copy_checks(engine_name)
+        engine = config.fetch("plugins", {}).fetch(engine_name, {})
+        engine["config"] ||= {}
+
+        if engine["config"].is_a?(String)
+          engine["config"] = {
+            "file" => engine["config"],
+            "checks" => checks,
+          }
+        elsif engine["config"].is_a?(Hash)
+          engine["config"]["checks"] = checks
+        end
+      end
+
+      def checks
+        config["checks"]
+      end
+    end
+  end
+end

data/lib/cc/config/default_adapter.rb

@@ -0,0 +1,52 @@
+module CC
+  class Config
+    class DefaultAdapter
+      # intentionally not sorted: we want them in a particular order
+      ENGINES = {
+        "structure".freeze => "stable".freeze,
+        "duplication".freeze => "cronopio".freeze,
+      }.freeze
+
+      EXCLUDE_PATTERNS = %w[
+        config/
+        db/
+        dist/
+        features/
+        **/node_modules/
+        script/
+        **/spec/
+        **/test/
+        **/tests/
+        **/vendor/
+        **/*.d.ts
+      ].freeze
+
+      attr_reader :config
+
+      def initialize(data = {})
+        @config = data
+
+        apply_default_excludes
+        apply_default_engines
+      end
+
+      private
+
+      def apply_default_engines
+        config["plugins"] ||= {}
+
+        ENGINES.each do |name, channel|
+          config["plugins"][name] ||= {}
+          unless [true, false].include?(config["plugins"][name]["enabled"])
+            config["plugins"][name]["enabled"] = true
+          end
+          config["plugins"][name]["channel"] ||= channel
+        end
+      end
+
+      def apply_default_excludes
+        config["exclude_patterns"] ||= EXCLUDE_PATTERNS
+      end
+    end
+  end
+end

data/lib/cc/config/engine.rb

@@ -0,0 +1,41 @@
+module CC
+  class Config
+    class Engine
+      DEFAULT_CHANNEL = "stable".freeze
+
+      attr_accessor :channel
+      attr_reader :name, :config, :exclude_patterns
+      attr_writer :enabled
+
+      def initialize(name, enabled: false, channel: nil, config: nil, exclude_patterns: [])
+        @name = name
+        @enabled = enabled
+        @channel = channel || DEFAULT_CHANNEL
+        @config = config || {}
+        @exclude_patterns = exclude_patterns
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def plugin?
+        !DefaultAdapter::ENGINES.keys.include?(name)
+      end
+
+      def container_label
+        @container_label ||= SecureRandom.uuid
+      end
+
+      def hash
+        name.hash
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && name.eql?(other.name)
+      end
+      alias_method :==, :eql?
+      alias_method :equal?, :eql?
+    end
+  end
+end

data/lib/cc/config/engine_set.rb

@@ -0,0 +1,47 @@
+module CC
+  class Config
+    class EngineSet
+      attr_reader :engines
+
+      def initialize(data)
+        @data = data
+        @engines = []
+
+        build_set
+      end
+
+      private
+
+      attr_reader :data
+
+      def build_set
+        DefaultAdapter::ENGINES.keys.each do |name|
+          if (engine = extract_engine(name))
+            engines << engine
+          end
+        end
+
+        data.each do |name, engine_data|
+          engines << build_engine(name, engine_data)
+        end
+      end
+
+      def extract_engine(name)
+        if data[name]
+          engine_data = data.delete(name)
+          build_engine(name, engine_data)
+        end
+      end
+
+      def build_engine(name, data)
+        Config::Engine.new(
+          name,
+          enabled: data.fetch("enabled", true),
+          channel: data["channel"],
+          config: data,
+          exclude_patterns: data.fetch("exclude_patterns", []),
+        )
+      end
+    end
+  end
+end