codeclimate 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be2909fa3f01d67de344c999494d63d650599c22
-  data.tar.gz: f093673d099ddfbcca4e5ac63456097a76f20ce3
+  metadata.gz: 1cc07ab27995ff71abe7fcf3d17cdb26c0e7cab0
+  data.tar.gz: 0bde4385fe0659131b7254d595a3b87a2a099659
 SHA512:
-  metadata.gz: b6efca56017e42e7991255f0e3acda6058f4c876dde88be14b8e9d113f9a61701e482fedc3b5ce47747f07a69c83b2963288c2ff985d6bc78e9d866b80f39204
-  data.tar.gz: d1c74c3732550d6a001879a22538c9f0d6fdfb8ee15e3bebf6e8cd99776f866454f16ae524ce2a5198b2e6a53de1cb707b1214b2501ebcf6186ab682a9432b80
+  metadata.gz: 788524a629d27d9825bfd87bb3181da46444273395fbac5c16ac10254a7ac5d13f9c0bb86494f5f4710d605115a4ae97385ce6773713802fce2bc983dcbf3caf
+  data.tar.gz: def528a3546470b85c9200334286a1afd1a6c6c0eb8eca43189d3fb747745dd43f22db131e8b87b587438aa2b4379637200adca22c21be62aea9049617833af1

data/lib/cc/analyzer.rb

@@ -12,13 +12,10 @@ module CC
     autoload :EnginesRunner, "cc/analyzer/engines_runner"
     autoload :Filesystem, "cc/analyzer/filesystem"
     autoload :Formatters, "cc/analyzer/formatters"
-    autoload :IncludePathsBuilder, "cc/analyzer/include_paths_builder"
     autoload :Issue, "cc/analyzer/issue"
     autoload :IssueSorter, "cc/analyzer/issue_sorter"
     autoload :LocationDescription, "cc/analyzer/location_description"
     autoload :LoggingContainerListener, "cc/analyzer/logging_container_listener"
-    autoload :PathPatterns, "cc/analyzer/path_patterns"
-    autoload :PathMinimizer, "cc/analyzer/path_minimizer"
     autoload :RaisingContainerListener, "cc/analyzer/raising_container_listener"
     autoload :SourceBuffer, "cc/analyzer/source_buffer"
     autoload :StatsdContainerListener, "cc/analyzer/statsd_container_listener"

data/lib/cc/analyzer/container.rb

@@ -172,6 +172,7 @@ module CC
       def reap_running_container(message)
         Analyzer.logger.warn("killing container name=#{@name} message=#{message.inspect}")
         POSIX::Spawn::Child.new("docker", "kill", @name)
+        POSIX::Spawn::Child.new("docker", "wait", @name, timeout: 5.minutes)
       end
 
       def timeout

data/lib/cc/analyzer/engines_config_builder.rb

@@ -29,23 +29,27 @@ module CC
 
       private
 
-      attr_reader :include_paths
-
       def engine_config(raw_engine_config)
+        engine_workspace = engine_workspace(raw_engine_config)
         config = raw_engine_config.merge(
-          exclude_paths: exclude_paths,
-          include_paths: include_paths,
+          include_paths: engine_workspace.paths,
         )
-        # 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.
-        # TODO: update the engines to expect the hash and then remove this.
-        if config.fetch("config", {}).keys.size == 1 && config["config"].key?("file")
-          config["config"] = config["config"]["file"]
-        end
+
+        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|
@@ -56,20 +60,22 @@ module CC
         end
       end
 
-      def include_paths
-        IncludePathsBuilder.new(exclude_paths, Array(@requested_paths)).build
-      end
-
-      def exclude_paths
-        PathPatterns.new(@config.exclude_paths || []).expanded +
-          gitignore_paths
+      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
 
-      def gitignore_paths
-        if File.exist?(".gitignore")
-          `git ls-files --others -i -z --exclude-from .gitignore`.split("\0")
-        else
-          []
+      # 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

data/lib/cc/analyzer/filesystem.rb

@@ -1,6 +1,8 @@
 module CC
   module Analyzer
     class Filesystem
+      attr_reader :root
+
       def initialize(root)
         @root = root
       end
@@ -22,30 +24,14 @@ module CC
         File.chown(root_uid, root_gid, path_for(path))
       end
 
-      def any?(&block)
-        file_paths.any?(&block)
-      end
-
-      def files_matching(globs)
-        Dir.chdir(@root) do
-          globs.map do |glob|
-            Dir.glob(glob)
-          end.flatten.sort.uniq
-        end
+      def ls
+        Dir.entries(root).reject { |entry| [".", ".."].include?(entry) }
       end
 
       private
 
-      def file_paths
-        @file_paths ||= Dir.chdir(@root) do
-          `find . -type f -print0`.strip.split("\0").map do |path|
-            path.sub(%r{^\.\/}, "")
-          end
-        end
-      end
-
       def path_for(path)
-        File.join(@root, path)
+        File.join(root, path)
       end
 
       def root_uid
@@ -57,7 +43,7 @@ module CC
       end
 
       def root_stat
-        @root_stat ||= File.stat(@root)
+        @root_stat ||= File.stat(root)
       end
     end
   end

data/lib/cc/cli.rb

@@ -1,6 +1,7 @@
 require "active_support"
 require "active_support/core_ext"
 require "cc/analyzer"
+require "cc/workspace"
 require "cc/yaml"
 
 module CC
@@ -15,5 +16,16 @@ module CC
     autoload :Test, "cc/cli/test"
     autoload :ValidateConfig, "cc/cli/validate_config"
     autoload :Version, "cc/cli/version"
+
+    def self.debug(message, values = {})
+      if ENV["CODECLIMATE_DEBUG"]
+        if values.any?
+          message << " "
+          message << values.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
+        end
+
+        $stderr.puts("[DEBUG] #{message}")
+      end
+    end
   end
 end

data/lib/cc/cli/config.rb

@@ -21,13 +21,7 @@ module CC
 
       def add_exclude_paths(paths)
         config["exclude_paths"] ||= []
-        config["exclude_paths"] += paths.map do |path|
-          if path.ends_with?("/")
-            "#{path}**/*"
-          else
-            path
-          end
-        end
+        config["exclude_paths"] |= paths
       end
 
       private

data/lib/cc/cli/config_generator.rb

@@ -1,3 +1,5 @@
+require "shellwords"
+
 module CC
   module CLI
     class ConfigGenerator
@@ -37,7 +39,7 @@ module CC
       end
 
       def exclude_paths
-        AUTO_EXCLUDE_PATHS.select { |path| filesystem.exist?(path) }
+        @exclude_paths ||= AUTO_EXCLUDE_PATHS.select { |path| filesystem.exist?(path) }
       end
 
       def post_generation_verb
@@ -59,10 +61,32 @@ module CC
       end
 
       def files_exist?(engine)
-        filesystem.any? do |path|
+        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?(".") || excludes.include?(path)
+          end
+        end
+      end
+
+      def workspace_files
+        @workspace_files ||= Dir.chdir(filesystem.root) do
+          if non_excluded_paths.empty?
+            []
+          else
+            find_cmd = "find #{non_excluded_paths.map(&:shellescape).join(' ')} -type f -print0"
+            `#{find_cmd}`.strip.split("\0").map do |path|
+              path.sub(%r{^\.\/}, "")
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/cc/cli/init.rb

@@ -10,11 +10,11 @@ module CC
       def run
         if !upgrade? && filesystem.exist?(CODECLIMATE_YAML)
           warn "Config file .codeclimate.yml already present.\nTry running 'validate-config' to check configuration."
-          create_default_configs
+          create_default_engine_configs if engines_enabled?
         elsif upgrade? && engines_enabled?
           fatal "--upgrade should not be used on a .codeclimate.yml configured for the Platform.\nTry running 'validate-config' to check configuration."
         else
-          generate_config
+          generate_all_config
         end
       end
 
@@ -24,7 +24,7 @@ module CC
         @args.include?("--upgrade")
       end
 
-      def generate_config
+      def generate_all_config
         unless config_generator.can_generate?
           config_generator.errors.each do |error|
             $stderr.puts colorize("ERROR: #{error}", :red)
@@ -34,10 +34,11 @@ module CC
 
         create_codeclimate_yaml
         success "Config file .codeclimate.yml successfully #{config_generator.post_generation_verb}.\nEdit and then try running 'validate-config' to check configuration."
-        create_default_configs
+        create_default_engine_configs
       end
 
       def create_codeclimate_yaml
+        say "Generating .codeclimate.yml..."
         config = CC::CLI::Config.new
 
         config_generator.eligible_engines.each do |(engine_name, engine_config)|
@@ -48,8 +49,9 @@ module CC
         filesystem.write_path(CODECLIMATE_YAML, config.to_yaml)
       end
 
-      def create_default_configs
-        available_configs.each do |config_path|
+      def create_default_engine_configs
+        say "Generating default configuration for engines..."
+        available_engine_configs.each do |config_path|
           file_name = File.basename(config_path)
           if filesystem.exist?(file_name)
             say "Skipping generating #{file_name} file (already exists)."
@@ -60,29 +62,34 @@ module CC
         end
       end
 
-      def available_configs
-        all_paths = config_generator.eligible_engines.flat_map do |engine_name, _|
+      def available_engine_configs
+        engine_names = existing_cc_config.engines.select do |_, config|
+          config.enabled?
+        end.keys
+
+        all_paths = engine_names.flat_map do |engine_name|
           engine_directory = File.expand_path("../../../../config/#{engine_name}", __FILE__)
           Dir.glob("#{engine_directory}/*", File::FNM_DOTMATCH)
         end
-
-        all_paths.reject { |path| [".", ".."].include?(File.basename(path)) }
+        all_paths.reject do |path|
+          %w[. ..].include?(File.basename(path))
+        end
       end
 
       def engines_enabled?
-        unless @engines_enabled.nil?
-          return @engines_enabled
-        end
-
-        if filesystem.exist?(CODECLIMATE_YAML)
-          config = CC::Analyzer::Config.new(File.read(CODECLIMATE_YAML))
-          @engines_enabled ||= config.engine_names.any?
-        end
+        cc_config = existing_cc_config
+        cc_config.present? && cc_config.engines.present?
       end
 
       def config_generator
         @config_generator ||= ConfigGenerator.for(filesystem, engine_registry, upgrade?)
       end
+
+      def existing_cc_config
+        if filesystem.exist?(CODECLIMATE_YAML)
+          CC::Yaml.parse(filesystem.read_path(CODECLIMATE_YAML))
+        end
+      end
     end
   end
 end

data/lib/cc/cli/runner.rb

@@ -10,9 +10,7 @@ module CC
       rescue => ex
         $stderr.puts("error: (#{ex.class}) #{ex.message}")
 
-        if ENV["CODECLIMATE_DEBUG"]
-          $stderr.puts("backtrace: #{ex.backtrace.join("\n\t")}")
-        end
+        CLI.debug("backtrace: #{ex.backtrace.join("\n\t")}")
       end
 
       def initialize(args)

data/lib/cc/workspace.rb

@@ -0,0 +1,34 @@
+module CC
+  class Workspace
+    autoload :Exclusion, "cc/workspace/exclusion"
+    autoload :PathTree, "cc/workspace/path_tree"
+
+    def initialize(path_tree = PathTree.new("."))
+      @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|
+        path_tree.exclude_paths(Exclusion.new(pattern).expand)
+      end
+    end
+
+    private
+
+    attr_reader :path_tree
+  end
+end

data/lib/cc/workspace/exclusion.rb

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

data/lib/cc/workspace/path_tree.rb

@@ -0,0 +1,110 @@
+require "pathname"
+require "set"
+
+module CC
+  class Workspace
+    class PathTree
+      def self.create(pathname)
+        if pathname.directory?
+          new(pathname.to_s)
+        else
+          FileNode.new(pathname.to_s)
+        end
+      end
+
+      def initialize(root_path, children = {})
+        @root_path = root_path.dup.freeze
+        @children = children
+      end
+
+      def clone
+        self.class.new(root_path, children.dup)
+      end
+
+      def exclude_paths(paths)
+        paths.each { |path| remove(*normalized_path_pieces(path)) }
+      end
+
+      def include_paths(paths)
+        paths.each { |path| add(*normalized_path_pieces(path)) }
+      end
+
+      def all_paths
+        if populated?
+          children.values.flat_map(&:all_paths)
+        else
+          [File.join(root_path, File::SEPARATOR)]
+        end
+      end
+
+      protected
+
+      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) unless child.populated?
+        end
+      end
+
+      def add(head = nil, *tail)
+        return if head.nil? && tail.empty?
+
+        if (entry = find_direct_child(head))
+          children[entry.basename.to_s] = self.class.create(entry)
+          children[entry.basename.to_s].add(*tail)
+        else
+          CLI.debug("Couldn't include because part of path doesn't exist.", path: 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] = self.class.create(child_path)
+        end
+      end
+
+      def find_direct_child(name)
+        Pathname.new(root_path).children.detect { |c| c.basename.to_s == name }
+      end
+
+      def normalized_path_pieces(path)
+        Pathname.new(path).cleanpath.to_s.split(File::SEPARATOR).reject(&:blank?)
+      end
+
+      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
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codeclimate
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Code Climate
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-21 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -216,15 +216,10 @@ files:
 - lib/cc/analyzer/formatters/json_formatter.rb
 - lib/cc/analyzer/formatters/plain_text_formatter.rb
 - lib/cc/analyzer/formatters/spinner.rb
-- lib/cc/analyzer/include_paths_builder.rb
 - lib/cc/analyzer/issue.rb
 - lib/cc/analyzer/issue_sorter.rb
 - lib/cc/analyzer/location_description.rb
 - lib/cc/analyzer/logging_container_listener.rb
-- lib/cc/analyzer/path_entries.rb
-- lib/cc/analyzer/path_filter.rb
-- lib/cc/analyzer/path_minimizer.rb
-- lib/cc/analyzer/path_patterns.rb
 - lib/cc/analyzer/raising_container_listener.rb
 - lib/cc/analyzer/source_buffer.rb
 - lib/cc/analyzer/statsd_container_listener.rb
@@ -248,7 +243,9 @@ files:
 - lib/cc/cli/upgrade_config_generator.rb
 - lib/cc/cli/validate_config.rb
 - lib/cc/cli/version.rb
-- lib/file_utils_ext.rb
+- lib/cc/workspace.rb
+- lib/cc/workspace/exclusion.rb
+- lib/cc/workspace/path_tree.rb
 homepage: https://codeclimate.com
 licenses:
 - MIT

data/lib/cc/analyzer/include_paths_builder.rb

@@ -1,62 +0,0 @@
-require "file_utils_ext"
-require "cc/analyzer/path_minimizer"
-require "cc/analyzer/path_filter"
-
-module CC
-  module Analyzer
-    class IncludePathsBuilder
-      IGNORE_PATHS = [".", "..", ".git"].freeze
-
-      attr_reader :cc_include_paths
-
-      def initialize(cc_exclude_paths, cc_include_paths = [])
-        @cc_exclude_paths = cc_exclude_paths
-        @cc_include_paths = cc_include_paths
-      end
-
-      def build
-        PathMinimizer.new(paths_filter.paths).minimize.uniq
-      end
-
-      private
-
-      def paths_filter
-        @_paths =
-          PathFilter.new(include_paths).
-          reject_paths(ignored_files).
-          reject_unreadable_paths.
-          select_readable_files.
-          reject_symlinks
-      end
-
-      def include_paths
-        if @cc_include_paths.empty?
-          all_paths
-        else
-          @cc_include_paths.flat_map do |path|
-            PathEntries.new(path).entries
-          end
-        end
-      end
-
-      def all_paths
-        Dir.glob("*", File::FNM_DOTMATCH).
-          reject { |path| IncludePathsBuilder::IGNORE_PATHS.include?(path) }.
-          flat_map { |path| PathEntries.new(path).entries }
-      end
-
-      def ignored_files
-        return @_ignored_files if @_ignored_files
-
-        Tempfile.open(".cc_gitignore") do |tmp|
-          tmp.write(File.read(".gitignore")) if File.file?(".gitignore")
-          tmp << @cc_exclude_paths.join("\n")
-          tmp.close
-          tracked_and_ignored = `git ls-files -zi -X #{tmp.path} 2>/dev/null`.split("\0")
-          untracked_and_ignored = `git ls-files -zio -X #{tmp.path} 2>/dev/null`.split("\0")
-          @_ignored_files = tracked_and_ignored + untracked_and_ignored
-        end
-      end
-    end
-  end
-end

data/lib/cc/analyzer/path_entries.rb

@@ -1,27 +0,0 @@
-module CC
-  module Analyzer
-    class PathEntries
-      def initialize(initial_path)
-        @initial_path = initial_path.gsub(%r{/$}, "")
-      end
-
-      def entries
-        if File.directory?(initial_path)
-          all_entries.reject do |path|
-            path.end_with?("/.") || path.start_with?(".git/")
-          end
-        else
-          initial_path
-        end
-      end
-
-      private
-
-      attr_reader :initial_path
-
-      def all_entries
-        Dir.glob("#{initial_path}/**/*", File::FNM_DOTMATCH).push(initial_path)
-      end
-    end
-  end
-end

data/lib/cc/analyzer/path_filter.rb

@@ -1,50 +0,0 @@
-module CC
-  module Analyzer
-    class PathFilter
-      attr_reader :paths
-
-      def initialize(paths)
-        @paths = paths
-      end
-
-      def reject_unreadable_paths
-        @paths = paths - unreadable_path_entries
-        self
-      end
-
-      def reject_paths(ignore_paths)
-        @paths = paths - ignore_paths
-        self
-      end
-
-      def select_readable_files
-        @paths = paths.select { |path| File.exist?(path) && FileUtils.readable_by_all?(path) }
-        self
-      end
-
-      def reject_symlinks
-        @paths = paths.reject { |path| File.symlink?(path) }
-        self
-      end
-
-      def reject_globs(globs)
-        patterns = PathPatterns.new(globs)
-        @paths = paths.reject { |path| patterns.match?(pathpatterns.match?(path)) }
-        self
-      end
-
-      private
-
-      def unreadable_path_entries
-        @_unreadable_path_entries ||=
-          unreadable_paths.flat_map { |path| PathEntries.new(path).entries }
-      end
-
-      def unreadable_paths
-        paths.select do |path|
-          File.directory?(path) && !FileUtils.readable_by_all?(path)
-        end
-      end
-    end
-  end
-end

data/lib/cc/analyzer/path_minimizer.rb

@@ -1,84 +0,0 @@
-require "cc/analyzer/path_entries"
-require "cc/analyzer/include_paths_builder"
-
-module CC
-  module Analyzer
-    class PathMinimizer
-      def initialize(paths)
-        @paths = paths
-        @to_remove = []
-      end
-
-      def minimize
-        if diff.empty?
-          ["./"]
-        else
-          filtered_paths
-        end
-      end
-
-      private
-
-      attr_reader :paths
-
-      def diff
-        @_diff ||=
-          (all_files - paths).
-          reject { |path| File.symlink?(path) }.
-          flat_map { |path| build_entry_combinations(path) }
-      end
-
-      def filtered_paths
-        filtered_paths = @paths - paths_to_remove
-        filtered_paths.map { |path| add_trailing_slash(path) }
-      end
-
-      def paths_to_remove
-        @paths.reduce([]) do |to_remove, path|
-          if File.directory?(path)
-            to_remove + removable_paths_for(path)
-          else
-            to_remove
-          end
-        end
-      end
-
-      def removable_paths_for(path)
-        file_paths = PathEntries.new(path).entries
-
-        if all_paths_match?(file_paths)
-          file_paths - [path]
-        else
-          [path]
-        end
-      end
-
-      def all_paths_match?(paths)
-        paths.all? { |path| @paths.include?(path) }
-      end
-
-      def add_trailing_slash(path)
-        if File.directory?(path) && !path.end_with?("/")
-          "#{path}/"
-        else
-          path
-        end
-      end
-
-      def build_entry_combinations(path)
-        split = path.split("/")
-
-        0.upto(split.length - 1).map do |n|
-          split[0..n].join("/")
-        end
-      end
-
-      def all_files
-        @_all_files ||=
-          Dir.glob("*", File::FNM_DOTMATCH).
-          reject { |path| IncludePathsBuilder::IGNORE_PATHS.include?(path) }.
-          flat_map { |path| PathEntries.new(path).entries }
-      end
-    end
-  end
-end

data/lib/cc/analyzer/path_patterns.rb

@@ -1,46 +0,0 @@
-module CC
-  module Analyzer
-    class PathPatterns
-      def initialize(patterns, root = Dir.pwd)
-        @patterns = patterns
-        @root = root
-      end
-
-      def match?(path)
-        expanded.include?(path)
-      end
-
-      def expanded
-        @expanded ||= expand
-      end
-
-      private
-
-      def expand
-        results = Dir.chdir(@root) do
-          @patterns.flat_map do |pattern|
-            value = glob_value(pattern)
-            Dir.glob(value)
-          end
-        end
-
-        results.sort.uniq
-      end
-
-      def glob_value(pattern)
-        # FIXME: there exists a temporary workaround whereby **-style globs
-        # are translated to **/*-style globs within cc-yaml's custom
-        # Glob#value method. It was thought that that would work correctly
-        # with Dir.glob but it turns out we have to actually invoke #value
-        # directrly for this to work. We need to guard this on class (not
-        # respond_to?) because our mocking framework adds a #value method to
-        # all objects, apparently.
-        if pattern.is_a?(CC::Yaml::Nodes::Glob)
-          pattern.value
-        else
-          pattern
-        end
-      end
-    end
-  end
-end

data/lib/file_utils_ext.rb

@@ -1,7 +0,0 @@
-require "fileutils"
-
-module FileUtils
-  def self.readable_by_all?(path)
-    (File.stat(path).mode & 004) != 0
-  end
-end