codeclimate-fede 0.85.21

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/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/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

data/lib/cc/resolv.rb

@@ -0,0 +1,39 @@
+require "resolv-replace"
+
+module CC
+  class Resolv
+    def self.with_fixed_dns(dns = ::Resolv::DNS.new)
+      ::Resolv::DefaultResolver.replace_resolvers([Fixed.new(dns)])
+
+      yield if block_given?
+    ensure
+      # There's no way to ask what the current values are before we override
+      # them; hopefully going by the source is good enough.
+      # https://docs.ruby-lang.org/en/2.0.0/Resolv.html#method-c-new
+      default_resolvers = [::Resolv::Hosts.new, ::Resolv::DNS.new]
+      ::Resolv::DefaultResolver.replace_resolvers(default_resolvers)
+    end
+
+    class Fixed
+      def initialize(fallback)
+        @addresses = {}
+        @fallback = fallback
+      end
+
+      def each_address(name)
+        if addresses.key?(name)
+          yield addresses.fetch(name)
+        else
+          fallback.each_address(name) do |address|
+            addresses[name] ||= address
+            yield address
+          end
+        end
+      end
+
+      private
+
+      attr_reader :addresses, :fallback
+    end
+  end
+end

data/lib/cc/workspace/exclusion.rb

@@ -0,0 +1,34 @@
+module CC
+  class Workspace
+    class Exclusion
+      def initialize(pattern)
+        @negated = pattern.starts_with?("!")
+        @pattern = simplify(pattern)
+      end
+
+      def expand
+        if glob?
+          Dir.glob(pattern)
+        else
+          [pattern]
+        end
+      end
+
+      def glob?
+        pattern.include?("*")
+      end
+
+      def negated?
+        negated
+      end
+
+      private
+
+      attr_reader :negated, :pattern
+
+      def simplify(pattern)
+        pattern.to_s.sub(%r{(/\*\*)?(/\*)?$}, "").sub(/^\!/, "")
+      end
+    end
+  end
+end

data/lib/cc/workspace/path_tree/dir_node.rb

@@ -0,0 +1,67 @@
+module CC
+  class Workspace
+    class PathTree
+      class DirNode
+        def initialize(root_path, children = {})
+          @root_path = root_path.dup.freeze
+          @children = children.each_with_object({}) do |(k, v), memo|
+            memo[k.clone] = v.clone
+          end
+        end
+
+        def clone
+          self.class.new(root_path, children)
+        end
+
+        def all_paths
+          if populated?
+            children.values.flat_map(&:all_paths)
+          else
+            [File.join(root_path, File::SEPARATOR)]
+          end
+        end
+
+        def populated?
+          children.present?
+        end
+
+        def remove(head = nil, *tail)
+          return if head.nil? && tail.empty?
+          populate_direct_children
+
+          if (child = children[head])
+            child.remove(*tail)
+            children.delete(head) if !child.populated? || tail.empty?
+          end
+        end
+
+        def add(head = nil, *tail)
+          return if head.nil? && tail.empty?
+
+          if (entry = find_direct_child(head))
+            children[entry.basename.to_s.dup.freeze] ||= PathTree.node_for_pathname(entry)
+            children[entry.basename.to_s.dup.freeze].add(*tail)
+          else
+            Analyzer.logger.debug("Couldn't include because part of path doesn't exist: #{File.join(root_path, head)}")
+          end
+        end
+
+        private
+
+        attr_reader :children, :root_path
+
+        def populate_direct_children
+          return if populated?
+
+          Pathname.new(root_path).each_child do |child_path|
+            children[child_path.basename.to_s] = PathTree.node_for_pathname(child_path)
+          end
+        end
+
+        def find_direct_child(name)
+          Pathname.new(root_path).children.detect { |c| c.basename.to_s == name }
+        end
+      end
+    end
+  end
+end

data/lib/cc/workspace/path_tree/file_node.rb

@@ -0,0 +1,31 @@
+module CC
+  class Workspace
+    class PathTree
+      class FileNode
+        def initialize(root_path)
+          @root_path = root_path.dup.freeze
+        end
+
+        def all_paths
+          [root_path]
+        end
+
+        def populated?
+          false
+        end
+
+        def remove(*)
+          # this space intentionally left blank
+        end
+
+        def add(*)
+          # this space intentionally left blank
+        end
+
+        private
+
+        attr_reader :root_path
+      end
+    end
+  end
+end

data/lib/cc/workspace/path_tree.rb

@@ -0,0 +1,49 @@
+require "pathname"
+require "set"
+
+module CC
+  class Workspace
+    class PathTree
+      autoload :DirNode, "cc/workspace/path_tree/dir_node"
+      autoload :FileNode, "cc/workspace/path_tree/file_node"
+
+      def self.node_for_pathname(pathname)
+        if pathname.directory?
+          DirNode.new(pathname.to_s)
+        else
+          FileNode.new(pathname.to_s)
+        end
+      end
+
+      def self.for_path(path)
+        new(node_for_pathname(Pathname.new(path)))
+      end
+
+      def initialize(root_node)
+        @root_node = root_node
+      end
+
+      def clone
+        self.class.new(root_node.clone)
+      end
+
+      def exclude_paths(paths)
+        paths.each { |path| root_node.remove(*normalized_path_pieces(path)) }
+      end
+
+      def include_paths(paths)
+        paths.each { |path| root_node.add(*normalized_path_pieces(path)) }
+      end
+
+      delegate :all_paths, to: :root_node
+
+      private
+
+      attr_reader :root_node
+
+      def normalized_path_pieces(path)
+        Pathname.new(path).cleanpath.to_s.split(File::SEPARATOR).reject(&:blank?)
+      end
+    end
+  end
+end

data/lib/cc/workspace.rb

@@ -0,0 +1,39 @@
+module CC
+  class Workspace
+    autoload :Exclusion, "cc/workspace/exclusion"
+    autoload :PathTree, "cc/workspace/path_tree"
+
+    def initialize(path_tree = PathTree.for_path("."))
+      @path_tree = path_tree
+    end
+
+    def clone
+      self.class.new(path_tree.clone)
+    end
+
+    def paths
+      path_tree.all_paths
+    end
+
+    def add(paths)
+      if paths.present?
+        path_tree.include_paths(paths)
+      end
+    end
+
+    def remove(patterns)
+      Array(patterns).each do |pattern|
+        exclusion = Exclusion.new(pattern)
+        if exclusion.negated?
+          path_tree.include_paths(exclusion.expand)
+        else
+          path_tree.exclude_paths(exclusion.expand)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :path_tree
+  end
+end