Merge pull request qltysh#113 from codeclimate/abh-path

Ashley Baldwin-Hunter · Ashley Baldwin-Hunter · commit 3da31029d89d · 2015-09-22T14:00:04.000-04:00
Let users specify engines and paths as options to analyze command for easier debugging
diff --git a/lib/cc/analyzer/engines_runner.rb b/lib/cc/analyzer/engines_runner.rb
@@ -6,11 +6,12 @@ class EnginesRunner
       InvalidEngineName = Class.new(StandardError)
       NoEnabledEngines = Class.new(StandardError)
 
-      def initialize(registry, formatter, source_dir, config, container_label = nil)
+      def initialize(registry, formatter, source_dir, config, requested_paths = [], container_label = nil)
         @registry = registry
         @formatter = formatter
         @source_dir = source_dir
         @config = config
+        @requested_paths = requested_paths
         @container_label = container_label
       end
 
@@ -28,6 +29,8 @@ def run(container_listener = ContainerListener.new)
 
       private
 
+      attr_reader :requested_paths
+
       def run_engine(engine, container_listener)
         @formatter.engine_running(engine) do
           engine.run(@formatter, container_listener)
@@ -72,12 +75,12 @@ def metadata(engine_name)
         @registry[engine_name]
       end
 
-      def exclude_paths
-        PathPatterns.new(@config.exclude_paths || []).expanded + gitignore_paths
+      def include_paths
+        IncludePathsBuilder.new(@config.exclude_paths || [], requested_paths).build
       end
 
-      def include_paths
-        IncludePathsBuilder.new(@config.exclude_paths || []).build
+      def exclude_paths
+        PathPatterns.new(@config.exclude_paths || []).expanded + gitignore_paths
       end
 
       def gitignore_paths
diff --git a/lib/cc/analyzer/include_paths_builder.rb b/lib/cc/analyzer/include_paths_builder.rb
@@ -9,20 +9,41 @@ def self.relevant_entries(path)
         end
       end
 
-      def initialize(cc_exclude_paths)
+      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
-        root = Directory.new('.', ignored_files)
-        paths = root.included_paths
+        if cc_include_paths.any?
+          paths = filter_by_cc_includes
+        else
+          root = Directory.new(".", ignored_files)
+          paths = root.included_paths
+        end
+
         paths.each do |path|
           raise_on_unreadable_files(path)
         end
       end
 
       protected
 
+      def filter_by_cc_includes
+        paths = []
+        cc_include_paths.each do |path|
+          if File.directory?(path)
+            root = Directory.new(path, ignored_files)
+            paths += root.included_paths
+          elsif !ignored_files.include?(path)
+            paths << path
+          end
+        end
+        paths.uniq
+      end
+
       def ignored_files
         Tempfile.open(".cc_gitignore") do |tmp|
           tmp.write(File.read(".gitignore")) if File.exist?(".gitignore")
diff --git a/lib/cc/cli/analyze.rb b/lib/cc/cli/analyze.rb
@@ -5,15 +5,18 @@ class Analyze < Command
 
       def initialize(_args = [])
         super
+        @engine_options = []
+        @path_options = []
 
         process_args
+        apply_config_options
       end
 
       def run
         require_codeclimate_yml
 
         Dir.chdir(ENV['FILESYSTEM_DIR']) do
-          runner = EnginesRunner.new(registry, formatter, source_dir, config)
+          runner = EnginesRunner.new(registry, formatter, source_dir, config, path_options)
           runner.run
         end
 
@@ -25,13 +28,20 @@ def run
 
       private
 
+      attr_accessor :config
+      attr_reader :engine_options, :path_options
+
       def process_args
         while arg = @args.shift
           case arg
           when '-f'
             @formatter = Formatters.resolve(@args.shift)
+          when '-e', '--engine'
+            @engine_options << @args.shift
           when '--dev'
             @dev_mode = true
+          else
+            @path_options << arg
           end
         end
       rescue Formatters::Formatter::InvalidFormatterError => e
@@ -51,7 +61,34 @@ def source_dir
       end
 
       def config
-        CC::Yaml.parse(filesystem.read_path(CODECLIMATE_YAML))
+        @config ||= CC::Yaml.parse(filesystem.read_path(CODECLIMATE_YAML))
+      end
+
+      def apply_config_options
+        if engine_options.any? && config.engines?
+          filter_by_engine_options
+        elsif engine_options.any?
+          config["engines"] = CC::Yaml::Nodes::EngineList.new(config).with_value({})
+        end
+        add_engine_options
+      end
+
+      def filter_by_engine_options
+        config.engines.keys.each do |engine|
+          unless engine_options.include?(engine)
+            config.engines.delete(engine)
+          end
+        end
+      end
+
+      def add_engine_options
+        engine_options.each do |engine|
+          if config.engines.include?(engine)
+            config.engines[engine].enabled = true
+          else
+            config.engines[engine] = CC::Yaml::Nodes::Engine.new(config.engines).with_value({ "enabled" => true })
+          end
+        end
       end
     end
   end
diff --git a/spec/cc/analyzer/engines_runner_spec.rb b/spec/cc/analyzer/engines_runner_spec.rb
@@ -95,7 +95,7 @@ module CC::Analyzer
       end
 
       it "gets include_paths from IncludePathBuilder" do
-        IncludePathsBuilder.expects(:new).with([]).returns(mock(build: ['.']))
+        IncludePathsBuilder.expects(:new).with([], []).returns(mock(build: ['.']))
         expected_config = {
           "enabled" => true,
           :exclude_paths => [],
diff --git a/spec/cc/analyzer/include_paths_builder_spec.rb b/spec/cc/analyzer/include_paths_builder_spec.rb
@@ -8,8 +8,9 @@ module CC::Analyzer
       within_temp_dir { test.call }
     end
 
-    let(:builder) { CC::Analyzer::IncludePathsBuilder.new(cc_excludes) }
+    let(:builder) { CC::Analyzer::IncludePathsBuilder.new(cc_excludes, cc_includes) }
     let(:cc_excludes) { [] }
+    let(:cc_includes) { [] }
     let(:result) { builder.build }
 
     before do
@@ -221,5 +222,26 @@ module CC::Analyzer
         result.include?("subdir/subdir/").must_equal(false)
       end
     end
+
+    describe "when cc_include_paths are passed in addition to excludes" do
+      let(:cc_excludes) { ["untrackable.rb"] }
+      let(:cc_includes) { ["untrackable.rb", "subdir"] }
+
+      before do
+        make_file("untrackable.rb")
+        make_file("trackable.rb")
+        make_file("subdir/subdir_trackable.rb")
+        make_file("subdir/foo.rb")
+        make_file("subdir/baz.rb")
+      end
+
+      it "includes requested paths" do
+        result.include?("subdir/").must_equal(true)
+      end
+
+      it "omits requested paths that are excluded by .codeclimate.yml" do
+        result.include?("untrackable.rb").must_equal(false)
+      end
+    end
   end
 end
diff --git a/spec/cc/cli/analyze_spec.rb b/spec/cc/cli/analyze_spec.rb
@@ -30,13 +30,77 @@ module CC::CLI
               EOYAML
 
               _, stderr = capture_io do
-                lambda { Analyze.new.run }
+                Analyze.new.run
               end
 
               stderr.must_match("")
             end
           end
         end
+
+        describe "when user passes engine options to command" do
+          it "uses only the engines provided" do
+            within_temp_dir do
+              create_yaml(<<-EOYAML)
+                engines:
+                  rubocop:
+                    enabled: true
+              EOYAML
+
+              args = ["-e", "eslint"]
+
+              analyze = Analyze.new(args)
+              qualified_config = analyze.send(:config)
+
+              qualified_config.engines.must_equal("eslint" => { "enabled" => true })
+            end
+          end
+        end
+
+        describe "when user passes path args to command" do
+          it "captures the paths provided as path_options" do
+            within_temp_dir do
+              create_yaml(<<-EOYAML)
+                engines:
+                  rubocop:
+                    enabled: true
+                  eslint:
+                    enabled: true
+              EOYAML
+
+              args = ["-e", "eslint", "foo.rb"]
+              paths = ["foo.rb"]
+
+              analyze = Analyze.new(args)
+
+              analyze.send(:path_options).must_equal(paths)
+            end
+          end
+        end
+
+        describe "when user passes path args to command" do
+          it "passes the paths provided" do
+            within_temp_dir do
+              create_yaml(<<-EOYAML)
+                engines:
+                  rubocop:
+                    enabled: true
+                  eslint:
+                    enabled: true
+              EOYAML
+
+              args = ["-e", "eslint", "foo.rb"]
+              paths = ["foo.rb"]
+
+              analyze = Analyze.new(args)
+              engines_runner = stub(run: "peace")
+
+              CC::Analyzer::EnginesRunner.expects(:new).with(anything, anything, anything, anything, paths).returns(engines_runner)
+
+              analyze.run
+            end
+          end
+        end
       end
     end
 
