codeclimate-fede 0.85.23

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,54 @@
+module CC
+  class Config
+    class DefaultAdapter
+      # intentionally not sorted: we want them in a particular order
+      ENGINES = {
+        "structure".freeze => "stable".freeze,
+        "duplication".freeze => "stable".freeze,
+      }.freeze
+
+      EXCLUDE_PATTERNS = %w[
+        config/
+        db/
+        dist/
+        features/
+        **/node_modules/
+        script/
+        **/spec/
+        **/test/
+        **/tests/
+        Tests/
+        **/vendor/
+        **/*_test.go
+        **/*.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

data/lib/cc/config/json_adapter.rb

@@ -0,0 +1,17 @@
+module CC
+  class Config
+    class JSONAdapter < Config
+      DEFAULT_PATH = ".codeclimate.json".freeze
+
+      attr_reader :config
+
+      def self.load(path = DEFAULT_PATH)
+        new(::JSON.parse(File.open(path).read))
+      end
+
+      def initialize(json = {})
+        @config = json
+      end
+    end
+  end
+end

data/lib/cc/config/prepare.rb

@@ -0,0 +1,92 @@
+module CC
+  class Config
+    class Prepare
+      attr_reader :fetch
+
+      def self.from_data(data)
+        if data.present?
+          fetch = Fetch.from_data(data.fetch("fetch", []))
+
+          new(fetch: fetch)
+        else
+          new
+        end
+      end
+
+      def initialize(fetch: Fetch.new)
+        @fetch = fetch
+      end
+
+      def merge(other)
+        Prepare.new(fetch: fetch.merge(other.fetch))
+      end
+
+      class Fetch
+        def self.from_data(data)
+          new(data.map { |d| Entry.from_data(d) })
+        end
+
+        def initialize(entries = [])
+          @entries = Set.new(entries)
+        end
+
+        def each(&block)
+          entries.each(&block)
+        end
+
+        def merge(other)
+          Fetch.new(each.to_a | other.each.to_a)
+        end
+
+        private
+
+        attr_reader :entries
+
+        class Entry
+          attr_reader :url, :path
+
+          def self.from_data(data)
+            case data
+            when String then new(data)
+            when Hash then new(data.fetch("url"), data["path"])
+            end
+          end
+
+          def initialize(url, path = nil)
+            @url = url
+            @path = path || url.split("/").last
+
+            validate_path!
+          end
+
+          # Useful in specs
+          def ==(other)
+            other.is_a?(self.class) &&
+              other.url == url &&
+              other.path == path
+          end
+
+          private
+
+          # Duplicate a validation which has security implication. This should
+          # always be caught upstream, so raising loudly is fine.
+          def validate_path!
+            if path.blank?
+              raise ArgumentError, "path cannot be be blank"
+            end
+
+            pathname = Pathname.new(path)
+
+            if pathname.absolute?
+              raise ArgumentError, "path cannot be absolute: #{path}"
+            end
+
+            if pathname.cleanpath.to_s != pathname.to_s || path.include?("..")
+              raise ArgumentError, "path cannot point outside the current directory: #{path}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module CC
+  class Config
+    module Validation
+      class CheckValidator
+        include HashValidations
+
+        attr_reader :errors, :warnings
+
+        def initialize(data)
+          @data = data
+
+          @errors = []
+          @warnings = []
+
+          validate
+        end
+
+        private
+
+        attr_reader :data
+
+        def validate
+          unless data.is_a?(Hash)
+            errors << "must be a hash"
+            return
+          end
+
+          validate_key_type("enabled", [TrueClass, FalseClass])
+          validate_key_type("config", Hash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module CC
+  class Config
+    module Validation
+      class EngineValidator
+        include HashValidations
+
+        RECOGNIZED_KEYS = %w[
+          enabled
+          channel
+          checks
+          config
+          exclude_fingerprints
+          exclude_patterns
+        ].freeze
+
+        attr_reader :errors, :warnings
+
+        def initialize(data, legacy: false)
+          @data = data
+          @legacy = legacy
+
+          @errors = []
+          @warnings = []
+
+          validate
+        end
+
+        def valid?
+          errors.none?
+        end
+
+        private
+
+        attr_reader :data
+
+        def legacy?
+          @legacy
+        end
+
+        def validate
+          validate_root
+          return unless data.is_a?(Hash)
+
+          validate_key_type("enabled", [TrueClass, FalseClass])
+          validate_key_type("channel", String)
+          validate_key_type("config", [String, Hash])
+          validate_key_type("exclude_patterns", Array)
+          if legacy?
+            validate_exclude_paths
+          end
+
+          validate_checks
+          validate_exclude_fingerprints
+
+          if legacy?
+            warn_unrecognized_keys(RECOGNIZED_KEYS + %w[exclude_paths])
+          else
+            warn_unrecognized_keys(RECOGNIZED_KEYS)
+          end
+        end
+
+        def validate_root
+          if !data.is_a?(Hash) && ![true, false].include?(data)
+            errors << "section must be a boolean or a hash"
+            return false
+          end
+          true
+        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)
+            errors.push(*validator.errors)
+            warnings.push(*validator.warnings)
+          end
+        end
+
+        def validate_exclude_paths
+          validate_key_type("exclude_paths", [Array, String])
+          if data.key?("exclude_paths")
+            warnings << "'exclude_paths' has been deprecated, please use 'exclude_patterns' instead"
+          end
+        end
+
+        def validate_exclude_fingerprints
+          validate_key_type("exclude_fingerprints", Array)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require "uri"
+require "pathname"
+
+module CC
+  class Config
+    module Validation
+      class FetchValidator
+        include HashValidations
+
+        attr_reader :errors, :warnings
+
+        def initialize(data)
+          @data = data
+
+          @errors = []
+          @warnings = []
+
+          validate
+        end
+
+        private
+
+        attr_reader :data
+
+        def validate
+          if data.is_a?(String)
+            validate_url(data)
+          elsif data.is_a?(Hash)
+            validate_fetch_hash
+          else
+            errors << "fetch section should be a string or a hash"
+          end
+        end
+
+        def validate_url(url)
+          unless valid_url?(url)
+            errors << "fetch section: invalid URL '#{url}'"
+          end
+        end
+
+        def valid_url?(url)
+          uri = URI.parse(url)
+          uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+        rescue URI::InvalidURIError
+          false
+        end
+
+        def validate_fetch_hash
+          if !data.key?("path") || !data.key?("url")
+            errors << "fetch section must include 'url' & 'path'"
+          end
+
+          validate_key_type("path", String)
+          validate_key_type("url", String)
+
+          validate_path(data["path"])
+          validate_url(data["url"])
+
+          warn_unrecognized_keys(%w[path url])
+        end
+
+        def validate_path(path)
+          if path.nil? || path.length.zero?
+            errors << "fetch section's 'path' cannot be empty"
+          else
+            pathname = Pathname.new(path)
+            if pathname.absolute?
+              errors << "fetch section: absolute path '#{path}' is invalid"
+            end
+            if pathname.cleanpath.to_s != pathname.to_s || path.include?("..")
+              errors << "fetch section: relative path elements in '#{path}' are invalid"
+            end
+          end
+        end
+      end
+    end
+  end
+end