guard-minitest 2.4.2 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 851b5a2bd445b0f83efeb90aba66ae605c46ace2
-  data.tar.gz: 698e015c7ad9cafe7adad2e79814423e79d7f150
+  metadata.gz: dcc495e0ea2932c1ab9c7c012d783daa85bf2e15
+  data.tar.gz: 3de792938d8a06d656afa759c05785a4b4cf414b
 SHA512:
-  metadata.gz: 7137097036674b50c4956161ab6092c55077ff1b4852fb00932720890e825182c0f0fa8782a0fabfa181cf37c3cc3804a39b742a76fcad87cfe7a29905d8b2c0
-  data.tar.gz: 5f9cda4bb17dbcbad72e265bdbb837890df27e0acd4c33e930356ac8a35be7c8bce416feff722487128e537f3d726ee637928d0c3b5721673bee8630d6bfc6fa
+  metadata.gz: ea74b63c79336cd5db930b62cd6a745fa12e5b61f3a63969cc61e0c72aae765389f28dc74540faf83814d874562df966f86b673ced1a81d238fd11dfd7cfc3e5
+  data.tar.gz: f2fb0caa615b6879522289811988718a2590b541777da544be7ac1d140a16e472721bbd822b9c9bda9dc6b84047fd6d8864483fe6b60daa354ebdb9239afb41a

data/lib/guard/minitest/notifier.rb

@@ -1,3 +1,5 @@
+require 'guard/compat/plugin'
+
 module Guard
   class Minitest < Plugin
     class Notifier

data/lib/guard/minitest/version.rb

@@ -1,5 +1,5 @@
 module Guard
   class MinitestVersion
-    VERSION = '2.4.2'
+    VERSION = '2.4.3'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-minitest
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.4.3
 platform: ruby
 authors:
 - Yann Lugrin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-15 00:00:00.000000000 Z
+date: 2015-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard-compat
@@ -65,23 +65,15 @@ files:
 - LICENSE
 - README.md
 - lib/guard/minitest.rb
-- lib/guard/minitest.rb.orig
 - lib/guard/minitest/inspector.rb
-- lib/guard/minitest/inspector.rb.orig
 - lib/guard/minitest/notifier.rb
-- lib/guard/minitest/notifier.rb.orig
 - lib/guard/minitest/reporter.rb
-- lib/guard/minitest/reporter.rb.orig
 - lib/guard/minitest/reporters/old_reporter.rb
-- lib/guard/minitest/reporters/old_reporter.rb.orig
 - lib/guard/minitest/runner.rb
-- lib/guard/minitest/runner.rb.orig
 - lib/guard/minitest/runners/old_runner.rb
 - lib/guard/minitest/templates/Guardfile
 - lib/guard/minitest/utils.rb
-- lib/guard/minitest/utils.rb.orig
 - lib/guard/minitest/version.rb
-- lib/guard/minitest/version.rb.orig
 - lib/minitest/guard_minitest_plugin.rb
 homepage: https://rubygems.org/gems/guard-minitest
 licenses:
@@ -103,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Guard plugin for the Minitest framework

data/lib/guard/minitest.rb.orig

@@ -1,56 +0,0 @@
-require 'guard/compat/plugin'
-
-module Guard
-  class Minitest < Plugin
-
-    require 'guard/minitest/runner'
-    require 'guard/minitest/utils'
-    require 'guard/minitest/version'
-
-    attr_accessor :runner
-
-    def initialize(options = {})
-      super
-      @options = {
-        all_on_start: true
-      }.merge(options)
-      @runner  = Runner.new(@options)
-    end
-
-    def start
-      UI.info "Guard::Minitest #{MinitestVersion::VERSION} is running, with Minitest::Unit #{Utils.minitest_version}!"
-      run_all if @options[:all_on_start]
-    end
-
-    def stop
-      true
-    end
-
-    def reload
-      true
-    end
-
-    def run_all
-      throw_on_failed_tests { runner.run_all }
-    end
-
-    def run_on_modifications(paths = [])
-      throw_on_failed_tests { runner.run_on_modifications(paths) }
-    end
-
-    def run_on_additions(paths)
-      runner.run_on_additions(paths)
-    end
-
-    def run_on_removals(paths)
-      runner.run_on_removals(paths)
-    end
-
-    private
-
-    def throw_on_failed_tests
-      throw :task_has_failed unless yield
-    end
-
-  end
-end

data/lib/guard/minitest/inspector.rb.orig

@@ -1,54 +0,0 @@
-module Guard
-  class Minitest
-    class Inspector
-
-      attr_reader :test_folders, :test_file_patterns
-
-      def initialize(test_folders, test_file_patterns)
-        @test_folders = test_folders.uniq.compact
-        @test_file_patterns = test_file_patterns.uniq.compact
-      end
-
-      def clean_all
-        clean(test_folders)
-      end
-
-      def clean(paths)
-        paths.reduce([]) do |memo, path|
-          if File.directory?(path)
-            memo += _test_files_for_paths(path)
-          else
-            memo << path if _test_file?(path)
-          end
-          memo
-        end.uniq
-      end
-
-      def clear_memoized_test_files
-        @all_test_files = nil
-      end
-
-      def all_test_files
-        @all_test_files ||= _test_files_for_paths
-      end
-
-      private
-
-      def _test_files_for_paths(paths = test_folders)
-        paths = _join_for_glob(Array(paths))
-        files = _join_for_glob(test_file_patterns)
-
-        Dir["#{paths}/**/#{files}"]
-      end
-
-      def _test_file?(path)
-        _test_files_for_paths.include?(path)
-      end
-
-      def _join_for_glob(fragments)
-        "{#{fragments.join(',')}}"
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/notifier.rb.orig

@@ -1,39 +0,0 @@
-require 'guard/notifier'
-
-module Guard
-  class Minitest
-    class Notifier
-
-      def self.guard_message(test_count, assertion_count, failure_count, error_count, skip_count, duration)
-        message = "#{test_count} tests"
-        if skip_count > 0
-          message << " (#{skip_count} skipped)"
-        end
-        message << "\n#{assertion_count} assertions, #{failure_count} failures, #{error_count} errors"
-        if test_count && assertion_count
-          message << "\n\n%.2f tests/s, %.2f assertions/s\n\nFinished in %.4f seconds" % [test_count / duration, assertion_count / duration, duration]
-        end
-        message
-      end
-
-      # failed | pending (skip) | success
-      def self.guard_image(failure_count, skip_count)
-        if failure_count > 0
-          :failed
-        elsif skip_count > 0
-          :pending
-        else
-          :success
-        end
-      end
-
-      def self.notify(test_count, assertion_count, failure_count, error_count, skip_count, duration)
-        message = guard_message(test_count, assertion_count, failure_count, error_count, skip_count, duration)
-        image   = guard_image(failure_count + error_count, skip_count)
-
-        ::Guard::Notifier.notify(message, title: 'Minitest results', image: image)
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/reporter.rb.orig

@@ -1,18 +0,0 @@
-require 'minitest'
-require 'guard/minitest/notifier'
-
-module Guard
-  class Minitest
-    class Reporter < ::Minitest::StatisticsReporter
-
-      def report
-        super
-
-        ::Guard::Minitest::Notifier.notify(self.count, self.assertions,
-                                           self.failures, self.errors,
-                                           self.skips, self.total_time)
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/reporters/old_reporter.rb.orig

@@ -1,22 +0,0 @@
-require 'minitest'
-require 'guard/minitest/notifier'
-
-module Guard
-  class Minitest
-    class Reporter < ::Minitest::Reporter
-
-      def report
-        aggregate = results.group_by { |r| r.failure.class }
-        aggregate.default = [] # dumb. group_by should provide this
-
-        f = aggregate[::Minitest::Assertion].size
-        e = aggregate[::Minitest::UnexpectedError].size
-        s = aggregate[::Minitest::Skip].size
-        t = Time.now - start_time
-
-        ::Guard::Minitest::Notifier.notify(count, self.assertions, f, e, s, t)
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/runner.rb.orig

@@ -1,252 +0,0 @@
-require 'guard/minitest/inspector'
-
-module Guard
-  class Minitest
-    class Runner
-      attr_accessor :inspector
-
-      def initialize(options = {})
-        @options = {
-          all_after_pass:     false,
-          bundler:            File.exist?("#{Dir.pwd}/Gemfile"),
-          rubygems:           false,
-          drb:                false,
-          zeus:               false,
-          spring:             false,
-          all_env:            {},
-          env:                {},
-          include:            [],
-          test_folders:       %w[test spec],
-          test_file_patterns: %w[*_test.rb test_*.rb *_spec.rb],
-          cli:                nil,
-          autorun:            true
-        }.merge(options)
-
-        parse_deprecated_options
-
-        [:test_folders, :test_file_patterns].each do |k|
-          @options[k] = Array(@options[k]).uniq.compact
-        end
-
-        @inspector = Inspector.new(test_folders, test_file_patterns)
-      end
-
-      def run(paths, options = {})
-        return unless options[:all] || !paths.empty?
-
-        message = "Running: #{options[:all] ? 'all tests' : paths.join(' ')}"
-        UI.info message, reset: true
-
-        status = _run_command(paths, options[:all])
-
-        # When using zeus or spring, the Guard::Minitest::Reporter can't be used because the minitests run in another
-        # process, but we can use the exit status of the client process to distinguish between :success and :failed.
-        if zeus? || spring?
-          ::Guard::Notifier.notify(message, title: 'Minitest results', image: status ? :success : :failed)
-        end
-
-        if @options[:all_after_pass] && status && !options[:all]
-          run_all
-        else
-          status
-        end
-      end
-
-      def run_all
-        paths = inspector.clean_all
-        run(paths, all: true)
-      end
-
-      def run_on_modifications(paths = [])
-        paths = inspector.clean(paths)
-        run(paths, all: all_paths?(paths))
-      end
-
-      def run_on_additions(paths)
-        inspector.clear_memoized_test_files
-        true
-      end
-
-      def run_on_removals(paths)
-        inspector.clear_memoized_test_files
-      end
-
-      private
-
-      def cli_options
-        @cli_options ||= Array(@options[:cli])
-      end
-
-      def bundler?
-        @options[:bundler] && !@options[:spring]
-      end
-
-      def rubygems?
-        !bundler? && @options[:rubygems]
-      end
-
-      def drb?
-        @options[:drb]
-      end
-
-      def zeus?
-        @options[:zeus].is_a?(String) || @options[:zeus]
-      end
-
-      def spring?
-        @options[:spring].is_a?(String) || @options[:spring]
-      end
-
-      def all_after_pass?
-        @options[:all_after_pass]
-      end
-
-      def test_folders
-        @options[:test_folders]
-      end
-
-      def include_folders
-        @options[:include]
-      end
-
-      def test_file_patterns
-        @options[:test_file_patterns]
-      end
-
-      def autorun?
-        @options[:autorun]
-      end
-
-      def _run_command(paths, all)
-        if bundler?
-          system(*minitest_command(paths, all))
-        else
-          if defined?(::Bundler)
-            ::Bundler.with_clean_env do
-              system(*minitest_command(paths, all))
-            end
-          else
-            system(*minitest_command(paths, all))
-          end
-        end
-      end
-
-      def _commander(paths)
-        if drb?
-          drb_command(paths)
-        elsif zeus?
-          zeus_command(paths)
-        elsif spring?
-          spring_command(paths)
-        else
-          ruby_command(paths)
-        end
-      end
-
-      def minitest_command(paths, all)
-        cmd_parts = []
-
-        cmd_parts << 'bundle exec' if bundler?
-        cmd_parts << _commander(paths)
-
-        [cmd_parts.compact.join(' ')].tap do |args|
-          env = generate_env(all)
-          args.unshift(env) if env.length > 0
-        end
-      end
-
-      def drb_command(paths)
-        %w[testdrb] + generate_includes(false) + relative_paths(paths)
-      end
-
-      def zeus_command(paths)
-        command = @options[:zeus].is_a?(String) ? @options[:zeus] : 'test'
-        ['zeus', command] + relative_paths(paths)
-      end
-
-      def spring_command(paths)
-        command = @options[:spring].is_a?(String) ? @options[:spring] : 'bin/rake test'
-        cmd_parts = [command]
-        cmd_parts << File.expand_path('../runners/old_runner.rb', __FILE__) unless (Utils.minitest_version_gte_5? || command != 'spring testunit')
-        if cli_options.length > 0
-          cmd_parts + paths + ['--'] + cli_options
-        else
-          cmd_parts + paths
-        end
-      end
-
-      def ruby_command(paths)
-        cmd_parts  = ['ruby']
-        cmd_parts.concat(generate_includes)
-        cmd_parts << '-r rubygems' if rubygems?
-        cmd_parts << '-r bundler/setup' if bundler?
-        cmd_parts << '-r minitest/autorun' if autorun?
-        cmd_parts.concat(paths.map { |path| "-r ./#{path}" })
-
-        unless Utils.minitest_version_gte_5?
-          cmd_parts << "-r #{File.expand_path('../runners/old_runner.rb', __FILE__)}"
-        end
-
-        # All the work is done through minitest/autorun
-        # and requiring the test files, so this is just
-        # a placeholder so Ruby doesn't try to exceute
-        # code from STDIN.
-        cmd_parts << '-e ""'
-
-        cmd_parts << '--'
-        cmd_parts += cli_options
-      end
-
-      def generate_includes(include_test_folders = true)
-        if include_test_folders
-          folders = test_folders + include_folders
-        else
-          folders = include_folders
-        end
-
-        folders.map {|f| %[-I"#{f}"] }
-      end
-
-      def generate_env(all=false)
-        base_env.merge(all ? all_env : {})
-      end
-
-      def base_env
-        Hash[(@options[:env] || {}).map{|key, value| [key.to_s, value.to_s]}]
-      end
-
-      def all_env
-        if @options[:all_env].kind_of? Hash
-          Hash[@options[:all_env].map{|key, value| [key.to_s, value.to_s]}]
-        else
-          {@options[:all_env].to_s => "true"}
-        end
-      end
-
-      def relative_paths(paths)
-        paths.map { |p| "./#{p}" }
-      end
-
-      def all_paths?(paths)
-        paths == inspector.all_test_files
-      end
-
-      def parse_deprecated_options
-        if @options.key?(:notify)
-          UI.info %{DEPRECATION WARNING: The :notify option is deprecated. Guard notification configuration is used.}
-        end
-
-        [:seed, :verbose].each do |key|
-          if value = @options.delete(key)
-            final_value = "--#{key}"
-            final_value << " #{value}" unless [TrueClass, FalseClass].include?(value.class)
-            cli_options << final_value
-
-            UI.info %{DEPRECATION WARNING: The :#{key} option is deprecated. Pass standard command line argument "--#{key}" to Minitest with the :cli option.}
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/utils.rb.orig

@@ -1,28 +0,0 @@
-require 'rubygems/requirement'
-
-module Guard
-  class Minitest
-    class Utils
-
-      def self.minitest_version
-        @@minitest_version ||= begin
-          require 'minitest'
-          ::Minitest::VERSION
-
-        rescue LoadError, NameError
-          require 'minitest/unit'
-          ::MiniTest::Unit::VERSION
-        end
-      end
-
-      def self.minitest_version_gte_5?
-        @@minitest_version_gte_5 ||= Gem::Requirement.new('>= 5').satisfied_by?(Gem::Version.new(minitest_version))
-      end
-
-      def self.minitest_version_gte_5_0_4?
-        @@minitest_version_gte_5_0_4 ||= Gem::Requirement.new('>= 5.0.4').satisfied_by?(Gem::Version.new(minitest_version))
-      end
-
-    end
-  end
-end

data/lib/guard/minitest/version.rb.orig

@@ -1,7 +0,0 @@
-module Guard
-  class MinitestVersion
-
-    VERSION = '2.3.2'
-
-  end
-end