codeclimate-fede 0.85.23

data/lib/cc/config/validation/file_validator.rb

@@ -0,0 +1,112 @@
+module CC
+  class Config
+    module Validation
+      class FileValidator
+        include HashValidations
+
+        attr_reader :errors, :path, :warnings
+
+        def initialize(path, registry)
+          @path = path
+          @registry = registry
+
+          @errors = []
+          @warnings = []
+
+          validate
+        end
+
+        def valid?
+          errors.none?
+        end
+
+        private
+
+        attr_reader :data, :registry
+
+        def validate
+          raise NotImplementedError, "use a subclass"
+        end
+
+        def denormalize_subvalidator(validator, prefix)
+          validator.errors.each do |msg|
+            errors << "#{prefix}: #{msg}"
+          end
+          validator.warnings.each do |msg|
+            warnings << "#{prefix}: #{msg}"
+          end
+        end
+
+        def validate_prepare
+          return unless validate_key_type("prepare", Hash)
+
+          validator = PrepareValidator.new(data.fetch("prepare", {}))
+          denormalize_subvalidator(validator, "prepare section")
+        end
+
+        def validate_engines(key, legacy: false)
+          return unless validate_key_type(key, Hash)
+
+          data.fetch(key, {}).each do |engine_name, engine_data|
+            engine_validator = EngineValidator.new(engine_data, legacy: legacy)
+            denormalize_subvalidator(engine_validator, "engine #{engine_name}")
+
+            if engine_validator.valid?
+              validate_engine_existence(engine_name, engine_data)
+            end
+          end
+        end
+
+        def validate_engine_existence(engine_name, engine_data)
+          if [true, false].include?(engine_data)
+            engine_data = {
+              "enabled" => true,
+              "channel" => Engine::DEFAULT_CHANNEL,
+            }
+          end
+
+          engine = Engine.new(
+            engine_name,
+            enabled: engine_data.fetch("enabled", true),
+            channel: engine_data["channel"],
+            config: engine_data["config"],
+          )
+          unless engine_exists?(engine)
+            warnings << "unknown engine or channel <#{engine.name}:#{engine.channel}>"
+          end
+        end
+
+        def engine_exists?(engine)
+          !registry.fetch_engine_details(engine).nil?
+        rescue CC::EngineRegistry::EngineDetailsNotFoundError
+          false
+        end
+
+        def validate_checks
+          return unless validate_key_type("checks", Hash)
+
+          data.fetch("checks", {}).each do |check_name, check_data|
+            validator = CheckValidator.new(check_data)
+            denormalize_subvalidator(validator, "check #{check_name}")
+          end
+        end
+
+        def validate_exclude_pattern(key, legacy: false)
+          types =
+            if legacy
+              [Array, String]
+            else
+              Array
+            end
+          return unless validate_key_type(key, types)
+
+          Array(data.fetch(key, [])).each do |pattern|
+            unless pattern.is_a?(String)
+              errors << "each exclude pattern should be a string, but '#{pattern.inspect}' is a #{pattern.class.to_s.downcase}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/config/validation/hash_validations.rb

@@ -0,0 +1,52 @@
+module CC
+  class Config
+    module Validation
+      module HashValidations
+        def validate_hash_data
+          unless data.is_a?(Hash)
+            errors << "Config file should contain a hash, not a #{data.class.to_s.downcase}"
+            return false
+          end
+          true
+        end
+
+        def validate_key_type(key, types)
+          if types.is_a?(Class)
+            return validate_key_type(key, [types])
+          elsif data.key?(key)
+            unless types.include?(data[key].class)
+              errors << key_type_error_message(key, types)
+              return false
+            end
+          end
+          true
+        end
+
+        def key_type_error_message(key, types)
+          if types.one?
+            klass_name = types[0].to_s.downcase
+            article =
+              if klass_name[0] == "a"
+                "an"
+              else
+                "a"
+              end
+            "'#{key}' must be #{article} #{klass_name}"
+          elsif types == [TrueClass, FalseClass]
+            "'#{key}' must be a boolean"
+          else
+            type_names = types.map(&:to_s).map(&:downcase)
+            "'#{key}' must be one of #{type_names.join(", ")}"
+          end
+        end
+
+        def warn_unrecognized_keys(recognized_keys)
+          unknown_keys = data.keys.reject { |k| recognized_keys.include?(k) }
+          unknown_keys.each do |key|
+            warnings << "unrecognized key '#{key}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/config/validation/json.rb

@@ -0,0 +1,31 @@
+module CC
+  class Config
+    module Validation
+      class JSON < FileValidator
+        private
+
+        def validate
+          @data = ::JSON.parse(File.read(path))
+
+          return unless validate_hash_data
+
+          validate_version
+          validate_prepare
+          validate_engines("plugins")
+          validate_checks
+          validate_exclude_pattern("exclude_patterns")
+
+          warn_unrecognized_keys(%w[checks prepare plugins exclude_patterns version])
+        rescue ::JSON::ParserError => ex
+          errors << "Unable to parse: #{ex.message}"
+        end
+
+        def validate_version
+          unless data.key?("version")
+            warnings << %(missing 'version' key. Please add `"version": "2"`)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/config/validation/prepare_validator.rb

@@ -0,0 +1,40 @@
+module CC
+  class Config
+    module Validation
+      class PrepareValidator
+        include HashValidations
+
+        attr_reader :errors, :warnings
+
+        def initialize(data)
+          @data = data
+
+          @errors = []
+          @warnings = []
+
+          validate
+        end
+
+        private
+
+        attr_reader :data
+
+        def validate
+          return unless validate_key_type("fetch", Array)
+
+          data.fetch("fetch", []).each do |fetch_data|
+            validator = FetchValidator.new(fetch_data)
+            validator.errors.each do |msg|
+              errors << msg
+            end
+            validator.warnings.each do |msg|
+              warnings << msg
+            end
+          end
+
+          warn_unrecognized_keys(%w[fetch])
+        end
+      end
+    end
+  end
+end

data/lib/cc/config/validation/yaml.rb

@@ -0,0 +1,66 @@
+module CC
+  class Config
+    module Validation
+      class YAML < FileValidator
+        private
+
+        def validate
+          @data = ::YAML.safe_load(File.read(path))
+
+          return unless validate_hash_data
+
+          validate_version
+          validate_prepare
+
+          validate_one_of(%w[engines plugins])
+          validate_one_of(%w[exclude_paths exclude_patterns])
+
+          validate_engines("engines", legacy: true)
+          validate_engines("plugins")
+
+          validate_checks
+
+          validate_exclude_pattern("exclude_patterns")
+          validate_exclude_pattern("exclude_paths", legacy: true)
+
+          deprecated_key_warnings
+          warn_unrecognized_keys(%w[checks prepare engines plugins ratings languages exclude_paths exclude_patterns version])
+        rescue Psych::SyntaxError => ex
+          errors << "Unable to parse: #{ex.message}"
+        end
+
+        def validate_version
+          if !data.key?("version") && (data.key?("plugins") || data.key?("exclude_patterns"))
+            warnings << %(missing 'version' key. Please add `version: "2"`)
+          end
+        end
+
+        def validate_one_of(keys)
+          num = keys.map { |k| data.key?(k) }.select(&:present?).count
+          if num > 1
+            wrapped_keys = keys.map { |k| "'#{k}'" }
+            errors << "only use one of #{wrapped_keys.join(", ")}"
+          end
+        end
+
+        def deprecated_key_warnings
+          deprecate_key("engines", "plugins")
+          deprecate_key("exclude_paths", "exclude_patterns")
+          deprecate_key("languages")
+          deprecate_key("ratings")
+        end
+
+        def deprecate_key(key, new_key = nil)
+          if data.key?(key)
+            warnings <<
+              if new_key.nil?
+                "'#{key}' has been deprecated, and will not be used"
+              else
+                "'#{key}' has been deprecated, please use '#{new_key}' instead"
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/config/yaml_adapter.rb

@@ -0,0 +1,73 @@
+module CC
+  class Config
+    class YAMLAdapter
+      DEFAULT_PATH = ".codeclimate.yml".freeze
+
+      attr_reader :config
+
+      def self.load(path = DEFAULT_PATH)
+        new(::YAML.safe_load(File.read(path)))
+      end
+
+      def initialize(yaml = {})
+        @config = yaml || {}
+
+        upconvert_legacy_yaml!
+      end
+
+      private
+
+      def coerce_engine(data)
+        if [true, false].include?(data)
+          { "enabled" => data }
+        elsif data.is_a?(Hash)
+          data
+        else
+          {}
+        end
+      end
+
+      # Many of our plugins still expect:
+      #
+      #   { config: PATH }
+      #
+      # But we document, and hope to eventually move to:
+      #
+      #   { config: { file: PATH } }
+      #
+      # We need to munge from the latter to the former when/if we encounter it
+      def convert_to_legacy_file_config(config)
+        if config.is_a?(Hash) && config.keys.one? && config.key?("file")
+          config["file"]
+        else
+          config
+        end
+      end
+
+      def upconvert_legacy_yaml!
+        config.delete("ratings")
+
+        if config.key?("engines")
+          config["plugins"] ||= config.delete("engines")
+        end
+
+        plugins = config.fetch("plugins", {})
+        plugins.each do |engine, data|
+          plugins[engine] = coerce_engine(data)
+          if plugins.fetch(engine)["exclude_paths"]
+            plugins.fetch(engine)["exclude_patterns"] ||= Array(plugins.fetch(engine).delete("exclude_paths"))
+          end
+          if plugins.fetch(engine)["config"]
+            plugins.fetch(engine)["config"] = convert_to_legacy_file_config(
+              plugins.fetch(engine).fetch("config"),
+            )
+          end
+        end
+
+        if config.key?("exclude_paths")
+          config["exclude_patterns"] ||= Array(config.delete("exclude_paths"))
+        end
+      end
+    end
+  end
+end

data/lib/cc/engine_registry.rb

@@ -0,0 +1,74 @@
+module CC
+  class EngineRegistry
+    include Enumerable
+
+    DEFAULT_MEMORY_LIMIT = 1_024_000_000
+    DEFAULT_COMMAND = nil
+    DEFAULT_MANIFEST_PATH = File.expand_path("../../../config/engines.yml", __FILE__)
+
+    EngineDetails = Struct.new(:image, :command, :description, :memory)
+    EngineDetailsNotFoundError = Class.new(StandardError)
+
+    def initialize(path = DEFAULT_MANIFEST_PATH, prefix = nil)
+      @yaml = YAML.safe_load(File.read(path))
+      @prefix = prefix || ENV["CODECLIMATE_PREFIX"] || ""
+    end
+
+    def each
+      yaml.each do |name, metadata|
+        engine = Config::Engine.new(
+          name,
+          channel: metadata.fetch("channels").keys.first,
+        )
+        engine_details = fetch_engine_details(engine)
+
+        yield(engine, engine_details)
+      end
+    end
+
+    def fetch_engine_details(engine, development: false)
+      if development
+        EngineDetails.new("codeclimate/codeclimate-#{engine.name}", nil, "")
+      else
+        metadata = yaml.fetch(engine.name)
+        channels = metadata.fetch("channels")
+
+        EngineDetails.new(
+          [prefix, channels.fetch(engine.channel)].join,
+          metadata.fetch("command", DEFAULT_COMMAND),
+          metadata.fetch("description", "(No description available)"),
+          memory_limit(metadata["minimum_memory_limit"]),
+        )
+      end
+    rescue KeyError
+      raise EngineDetailsNotFoundError, not_found_message(engine, channels)
+    end
+
+    private
+
+    attr_reader :yaml, :prefix
+
+    def memory_limit(minimum_memory_limit)
+      [
+        minimum_memory_limit.to_i,
+        default_memory_limit.to_i,
+      ].max
+    end
+
+    def default_memory_limit
+      ENV["ENGINE_MEMORY_LIMIT_BYTES"] || DEFAULT_MEMORY_LIMIT
+    end
+
+    def not_found_message(engine, available_channels)
+      if available_channels
+        # Known engine, unknown channel
+        "Channel #{engine.channel} not found" \
+          " for #{engine.name}," \
+          " available channels: #{available_channels.keys.inspect}"
+      else
+        # Unknown engine
+        "No engine named #{engine.name} found"
+      end
+    end
+  end
+end