test_launcher 1.5.0 → 1.5.1

data/lib/test_launcher/queries.rb

@@ -0,0 +1,346 @@
+module TestLauncher
+  module Queries
+    class CommandFinder
+      def initialize(request)
+        @request = request
+      end
+
+      def specified_name
+        commandify(SpecifiedNameQuery)
+      end
+
+      def multi_search_term
+        commandify(MultiTermQuery)
+      end
+
+      def by_path
+        commandify(PathQuery)
+      end
+
+      def example_name
+        commandify(ExampleNameQuery)
+      end
+
+      def from_full_regex
+        commandify(FullRegexQuery)
+      end
+
+      def single_search_term
+        commandify(SingleTermQuery)
+      end
+
+      def full_search
+        commandify(SearchQuery)
+      end
+
+      def generic_search
+        commandify(GenericQuery)
+      end
+
+      def line_number
+        commandify(LineNumberQuery)
+      end
+
+      def request
+        @request
+      end
+
+      def commandify(klass)
+        klass.new(
+          request,
+          self
+        ).command
+      end
+    end
+
+    class BaseQuery
+      attr_reader :shell, :searcher, :request
+      def initialize(request, command_finder)
+        @request = request
+        @command_finder = command_finder
+      end
+
+      def command
+        raise NotImplementedError
+      end
+
+      private
+
+      def test_cases
+        raise NotImplementedError
+      end
+
+      def runner
+        request.runner
+      end
+
+      def shell
+        request.shell
+      end
+
+      def searcher
+        request.searcher
+      end
+
+      def one_file?
+         file_count == 1
+      end
+
+      def file_count
+        @file_count ||= test_cases.map {|tc| tc.file }.uniq.size
+      end
+
+      def most_recently_edited_test_case
+        @most_recently_edited_test_case ||= test_cases.sort_by(&:mtime).last
+      end
+
+      def pluralize(count, singular)
+        phrase = "#{count} #{singular}"
+        if count == 1
+          phrase
+        else
+          "#{phrase}s"
+        end
+      end
+
+      def command_finder
+        @command_finder
+      end
+    end
+
+    class SpecifiedNameQuery < BaseQuery
+      def command
+        return unless file
+
+        shell.notify("Found matching test.")
+        runner.single_example(test_case)
+      end
+
+      def test_case
+        request.test_case(
+          file: file,
+          example: request.example_name,
+          request: request,
+        )
+      end
+
+      def file
+        if potential_files.size == 0
+          shell.warn("Could not locate file: #{request.search_string}")
+        elsif potential_files.size > 1
+          shell.warn("Too many files matched: #{request.search_string}")
+        else
+          potential_files.first
+        end
+      end
+
+      def potential_files
+        @potential_files ||= searcher.test_files(request.search_string)
+      end
+    end
+
+    class MultiTermQuery < BaseQuery
+      def command
+        return if test_cases.empty?
+
+        shell.notify("Found #{pluralize(file_count, "file")}.")
+        runner.multiple_files(test_cases)
+      end
+
+      def test_cases
+        @test_cases ||= files.map { |file_path|
+          request.test_case(
+            file: file_path,
+            request: request,
+          )
+        }
+      end
+
+      def files
+        if found_files.any? {|files_array| files_array.empty? }
+          if !found_files.all? {|files_array| files_array.empty? }
+            shell.warn("It looks like you're searching for multiple files, but we couldn't identify them all.")
+          end
+          []
+        else
+          found_files.flatten.uniq
+        end
+      end
+
+      def found_files
+        @found_files ||= queries.map {|query|
+          searcher.test_files(query)
+        }
+      end
+
+      def queries
+        @queries ||= request.search_string.split(" ")
+      end
+    end
+
+    class PathQuery < BaseQuery
+      def command
+        return if test_cases.empty?
+
+        if one_file?
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          runner.single_file(test_cases.first)
+        elsif request.run_all?
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          runner.multiple_files(test_cases)
+        else
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          shell.notify "Running most recently edited. Run with '--all' to run all the tests."
+          runner.single_file(most_recently_edited_test_case)
+        end
+      end
+
+      def test_cases
+        @test_cases ||= files_found_by_path.map { |file_path|
+          request.test_case(file: file_path, request: request)
+        }
+      end
+
+      def files_found_by_path
+        @files_found_by_path ||= searcher.test_files(request.search_string)
+      end
+    end
+
+    class ExampleNameQuery < BaseQuery
+      def command
+        return if test_cases.empty?
+
+        if one_example?
+          shell.notify("Found 1 example in 1 file.")
+          runner.single_example(test_cases.first)
+        elsif one_file?
+          shell.notify("Found #{test_cases.size} examples in 1 file.")
+          runner.multiple_examples_same_file(test_cases) # it will regex with the query
+        elsif request.run_all?
+          shell.notify "Found #{pluralize(test_cases.size, "example")} in #{pluralize(file_count, "file")}."
+          runner.multiple_files(test_cases)
+        else
+          shell.notify "Found #{pluralize(test_cases.size, "example")} in #{pluralize(file_count, "file")}."
+          shell.notify "Running most recently edited. Run with '--all' to run all the tests."
+          runner.single_example(most_recently_edited_test_case) # let it regex the query
+        end
+      end
+
+      def test_cases
+        @test_cases ||=
+          examples_found_by_name.map { |grep_result|
+            request.test_case(
+              file: grep_result[:file],
+              example: request.search_string,
+              line_number: grep_result[:line_number],
+              request: request
+            )
+          }
+      end
+
+      def examples_found_by_name
+        @examples_found_by_name ||= searcher.examples(request.search_string)
+      end
+
+      def one_example?
+        test_cases.size == 1
+      end
+    end
+
+    class FullRegexQuery < BaseQuery
+      def command
+        return if test_cases.empty?
+
+        if one_file?
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          runner.single_file(test_cases.first)
+        elsif request.run_all?
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          runner.multiple_files(test_cases)
+        else
+          shell.notify "Found #{pluralize(file_count, "file")}."
+          shell.notify "Running most recently edited. Run with '--all' to run all the tests."
+          runner.single_file(most_recently_edited_test_case)
+        end
+      end
+
+      def test_cases
+        @test_cases ||=
+          files_found_by_full_regex
+            .uniq { |grep_result| grep_result[:file] }
+            .map { |grep_result|
+              request.test_case(
+                file: grep_result[:file],
+                request: request
+              )
+            }
+      end
+
+      def files_found_by_full_regex
+        @files_found_by_full_regex ||= searcher.grep(request.search_string)
+      end
+    end
+
+    class LineNumberQuery < BaseQuery
+      LINE_SPLIT_REGEX = /\A(?<file>.*):(?<line_number>\d+)\Z/
+
+      def command
+        match = request.search_string.match(LINE_SPLIT_REGEX)
+        return unless match
+
+        search_result = searcher.by_line(match[:file], match[:line_number].to_i)
+        return unless search_result
+
+        if search_result[:line_number]
+          shell.notify("Found 1 example on line #{search_result[:line_number]}.")
+          runner.single_example(request.test_case(file: search_result[:file], line_number: search_result[:line_number], example: search_result[:example_name], request: request))
+        else
+          shell.notify("Found file, but line is not inside an example.")
+          runner.single_file(request.test_case(file: search_result[:file], request: request))
+        end
+
+      end
+    end
+
+    class SingleTermQuery < BaseQuery
+      def command
+        [
+          :by_path,
+          :example_name,
+          :from_full_regex,
+        ]
+          .each { |command_type|
+            command = command_finder.public_send(command_type)
+            return command if command
+          }
+        nil
+      end
+    end
+
+    class SearchQuery < BaseQuery
+      def command
+        {
+          multi_search_term: request.search_string.include?(" "),
+          line_number: request.search_string.include?(":"),
+          single_search_term: true
+        }.each {|command_type, valid|
+          next unless valid
+
+          command = command_finder.public_send(command_type)
+          return command if command
+        }
+        nil
+      end
+    end
+
+    class GenericQuery < BaseQuery
+      def command
+        if request.example_name
+          command_finder.specified_name
+        else
+          command_finder.full_search
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/rubymine/launcher.rb

@@ -1,19 +1,8 @@
-require "test_launcher/request"
 require "test_launcher/frameworks/minitest"
 require "test_launcher/shell/runner"
 
 module TestLauncher
   module Rubymine
-    class MinimalRequest
-      def initialize(disable_spring:)
-        @disable_spring = disable_spring
-      end
-
-      def disable_spring?
-        @disable_spring
-      end
-    end
-
     class Launcher
       def initialize(args:, shell:, request:)
         @args = args
@@ -40,7 +29,7 @@ module TestLauncher
 
       def command
         if test_case.is_example?
-          Frameworks::Minitest::Runner.new.single_example(test_case, exact_match: true)
+          Frameworks::Minitest::Runner.new.single_example(test_case)
         else
           Frameworks::Minitest::Runner.new.single_file(test_case)
         end

data/lib/test_launcher/rubymine/request.rb

@@ -0,0 +1,15 @@
+module TestLauncher
+  module Rubymine
+    class Request
+      class MinimalRequest
+        def initialize(disable_spring:)
+          @disable_spring = disable_spring
+        end
+
+        def disable_spring?
+          @disable_spring
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/rubymine.rb

@@ -1,6 +1,6 @@
-require "test_launcher/rubymine/launcher"
 require "test_launcher/shell/runner"
-require "test_launcher/request"
+require "test_launcher/rubymine/launcher"
+require "test_launcher/rubymine/request"
 
 # To allow us to simply specify our run configuration as:
 #
@@ -20,15 +20,22 @@ require "test_launcher/request"
 # So we throw them in the same bucket and let the launcher figure it
 # out.  It doesn't matter since we will `exec` a new command anyway.
 
-dummy_request = TestLauncher::Request.new(
-  query: nil,
-  framework: nil,
-  run_all: false,
-  disable_spring: ENV["DISABLE_SPRING"]
-)
+module TestLauncher
+  module Rubymine
+    def self.launch
+      shell = TestLauncher::Shell::Runner.new(log_path: "/dev/null")
+
+      request = Request.new(
+        disable_spring: ENV["DISABLE_SPRING"]
+      )
+
+      Launcher.new(
+        args: [$0].concat(ARGV),
+        shell: shell,
+        request: request
+      ).launch
+    end
+  end
+end
 
-TestLauncher::Rubymine::Launcher.new(
-  args: [$0].concat(ARGV),
-  shell: TestLauncher::Shell::Runner.new(log_path: "/dev/null"),
-  request: dummy_request
-).launch
+TestLauncher::Rubymine.launch

data/lib/test_launcher/search/ag.rb

@@ -0,0 +1,96 @@
+require "test_launcher/base_error"
+
+module TestLauncher
+  module Search
+    class Ag
+      NotInRepoError = Class.new(BaseError)
+      class Interface
+        attr_reader :shell
+
+        def initialize(shell)
+          @shell = shell
+        end
+
+        def ls_files(pattern)
+          shell.run("ag -g '.*#{pattern_to_regex(pattern)}.*'")
+        end
+
+        def grep(regex, file_pattern)
+          shell.run("ag '#{regex}' --file-search-regex '#{pattern_to_regex(file_pattern)}'")
+        end
+
+        def root_path
+          shell.run("git rev-parse --show-toplevel").first.tap do
+            if $? != 0
+              raise NotInRepoError, "test_launcher must be used in a git repository"
+            end
+          end
+        end
+
+        def pattern_to_regex(pattern)
+          pattern.gsub("*", ".*")
+        end
+      end
+
+      attr_reader :interface
+
+      def initialize(shell, interface=Interface.new(shell))
+        @interface = interface
+        Dir.chdir(root_path) # MOVE ME!
+      end
+
+      def find_files(pattern)
+        relative_pattern = strip_system_path(pattern)
+        interface.ls_files(relative_pattern).map {|f| system_path(f)}
+      end
+
+      def grep(regex, file_pattern: '*')
+        results = interface.grep(regex, file_pattern)
+        results.map do |result|
+          interpret_grep_result(result)
+        end
+      end
+
+
+      private
+
+      def interpret_grep_result(grep_result)
+        splits = grep_result.split(/:/)
+        file = splits.shift.strip
+        line_number = splits.shift.strip.to_i
+        # we rejoin on ':' because our
+        # code may have colons inside of it.
+        #
+        # example:
+        # path/to/file:126: run_method(a: A, b: B)
+        #
+        # so shift the first one out, then
+        # rejoin the rest
+        line = splits.join(':').strip
+
+        # TODO: Oh goodness, why is this not a class
+        {
+          :file => system_path(file),
+          :line_number => line_number.to_i,
+          :line => line,
+        }
+      end
+
+      def system_path(file)
+        File.join(root_path, file)
+      end
+
+      def strip_system_path(file)
+        file.sub(/^#{root_path}\//, '')
+      end
+
+      def root_path
+        @root_path ||= interface.root_path
+      end
+
+      def shell
+        @shell
+      end
+    end
+  end
+end

data/lib/test_launcher/search/git.rb

@@ -17,7 +17,7 @@ module TestLauncher
         end
 
         def grep(regex, file_pattern)
-          shell.run("git grep --untracked --extended-regexp '#{regex}' -- '#{file_pattern}'")
+          shell.run("git grep --line-number --untracked --extended-regexp '#{regex}' -- '#{file_pattern}'")
         end
 
         def root_path
@@ -48,23 +48,27 @@ module TestLauncher
         end
       end
 
+
       private
 
       def interpret_grep_result(grep_result)
         splits = grep_result.split(/:/)
         file = splits.shift.strip
+        line_number = splits.shift.strip.to_i
         # we rejoin on ':' because our
         # code may have colons inside of it.
         #
         # example:
-        # path/to/file: run_method(a: A, b: B)
+        # path/to/file:126: run_method(a: A, b: B)
         #
         # so shift the first one out, then
         # rejoin the rest
         line = splits.join(':').strip
 
+        # TODO: Oh goodness, why is this not a class
         {
           :file => system_path(file),
+          :line_number => line_number.to_i,
           :line => line,
         }
       end

data/lib/test_launcher/search.rb

@@ -0,0 +1,18 @@
+require 'test_launcher/search/ag'
+require 'test_launcher/search/git'
+
+module TestLauncher
+  module Search
+    def self.searcher(shell)
+      `which ag`
+      implementation =
+        if $?.success?
+          Search::Ag
+        else
+          Search::Git
+        end
+
+      implementation.new(shell)
+    end
+  end
+end

data/lib/test_launcher/shell/runner.rb

@@ -11,7 +11,7 @@ module TestLauncher
       attr_accessor :log_path, :queue
       private :log_path, :queue
 
-      def initialize(log_path:)
+      def initialize(log_path: "/dev/null")
         @log_path = log_path
         %x{echo "" > #{log_path}}
       end
@@ -25,6 +25,7 @@ module TestLauncher
 
       def exec(cmd)
         notify cmd
+        $stdout.flush
         Bundler.clean_exec(cmd)
       end
 

data/lib/test_launcher/version.rb

@@ -1,3 +1,3 @@
 module TestLauncher
-  VERSION = "1.5.0"
+  VERSION = "1.5.1"
 end

data/lib/test_launcher.rb

@@ -1,27 +1 @@
 require "test_launcher/version"
-
-require "test_launcher/base_error"
-require "test_launcher/shell/runner"
-require "test_launcher/search/git"
-require "test_launcher/frameworks"
-
-module TestLauncher
-  def self.launch(request)
-    shell = Shell::Runner.new(log_path: "/tmp/test_launcher.log")
-    searcher = Search::Git.new(shell)
-
-    command = Frameworks.locate(
-      request: request,
-      shell: shell,
-      searcher: searcher
-    )
-
-    if command
-      shell.exec command
-    else
-      shell.warn "No tests found."
-    end
-  rescue BaseError => e
-    shell.warn(e)
-  end
-end

data/test/test_helper.rb

@@ -4,6 +4,7 @@ require "mocha/mini_test"
 require "pry"
 
 require "test_launcher"
+require "test_launcher/shell/runner"
 
 class TestLauncher::Shell::Runner
   def exec(cmd)
@@ -48,7 +49,7 @@ class TestCase < Minitest::Test
     end
 
     def recall(method)
-      instance_variable_get(:"@#{method}")
+      instance_variable_get(:"@#{method}") || []
     end
   end
 

data/test/test_helpers/integration_helper.rb

@@ -0,0 +1,40 @@
+require "test_launcher/search/git"
+require "test_launcher/shell/runner"
+
+require "test_launcher/cli"
+require "test_helpers/mocks"
+
+module TestLauncher
+  module IntegrationHelper
+    include DefaultMocks
+
+    class IntegrationShell < Shell::Runner
+      def exec(string)
+        raise "Cannot exec twice!" if defined?(@exec)
+        @exec = string
+      end
+
+      def recall_exec
+        @exec
+      end
+    end
+
+    private
+
+    def system_path(relative_dir)
+      File.join(Dir.pwd, relative_dir)
+    end
+
+    def launch(search_string, run_all: false, framework:, name: nil)
+      argv = [search_string, "--framework", framework]
+      argv << "--all" if run_all
+      argv.concat(["--name", name]) if name
+      env = {}
+      CLI.launch(argv, env, shell: shell_mock)
+    end
+
+    def shell_mock
+      @shell_mock ||= IntegrationShell.new
+    end
+  end
+end