minitest-tagz 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 347d2a3aa8e7d5e66ee59e3372e69d78901ca244c6504cbbf2bdfe52e6e11b1e
-  data.tar.gz: e56b65e7fc29a800855af0e267faa14104c19b2d846f002469411740a3c47ef6
+SHA1:
+  metadata.gz: 1a7c2e69a5484b7fe73c7ef7f2f87c22453647b1
+  data.tar.gz: c5fd2e1086daca6e88a567764dd82f6bb21b061e
 SHA512:
-  metadata.gz: 6d7067bf81f5f82a8d9693779e6ab60c482e528082bad305103473e1ce81c7b9c11d0b0602f298fa441601d497294b19d08c2bf9854ef485c5ce6def3df86afc
-  data.tar.gz: 6ca7806d80a96c8dbfa2409e84e5161d74d51bad13faa10c4e4c696982b9ac34f6f268cc1941aacfbb4d5ec8ee61b2508ab3af0efe461b8da5c1e8dc300b54b5
+  metadata.gz: 481ae12df1710000e24b1f5c09b7e50f34192f40c4f9bcf7fdffc4dc9241539c8b2afe0cb87a5d04fae978550dcd754d955a83e62e8002ef4067a7d4bb861da4
+  data.tar.gz: 4f0df35fc26d5b5a08b336f21541fe765fcf8eba5981092bdaebf0bccc87835ff71252318bed73e270713962f251099db5c17e578ceb5321daa7da421b0a2080

data/.travis.yml

@@ -1,6 +1,9 @@
 language: ruby
 rvm:
-  - 2.1.3
+  - 2.5.1
+  - 2.4.4
+  - 2.3.7
   - 2.2.0
   - 2.2.1
+  - 2.1.3
   - 2.0.0

data/lib/minitest/tagz.rb

@@ -1,208 +1,12 @@
 require 'minitest'
+require 'minitest/tagz/minitest_patch'
+require 'minitest/tagz/minitest_test_patch'
+require 'minitest/tagz/tagger'
+require 'minitest/tagz/patcher'
 require 'minitest/tagz/version'
 
 module Minitest
   module Tagz
-    # The strategy for patching the Minitest run time
-    module MinitestRunnerStrategy
-      class << self
-        def serialize(owner, test_name)
-          "#{owner} >> #{test_name}"
-        end
-
-        module RunnableMethodsFilter
-          def runnable_methods
-            all_runnables = super
-
-            if Tagz.positive_tags.any?
-              all_runnables.select! do |r|
-                serialized = MinitestRunnerStrategy.serialize(self, r)
-                tags_on_runnable = MinitestRunnerStrategy.tag_map[serialized]
-                next false unless tags_on_runnable
-                (Tagz.positive_tags - tags_on_runnable).empty?
-              end
-            end
-
-            if Tagz.negative_tags.any?
-              all_runnables.reject! do |r|
-                serialized = MinitestRunnerStrategy.serialize(self, r)
-                tags_on_runnable = MinitestRunnerStrategy.tag_map[serialized]
-                next false unless tags_on_runnable
-                (Tagz.negative_tags & tags_on_runnable).any?
-              end
-            end
-
-            all_runnables
-          end
-        end
-
-        module RunPatch
-          def run(*args)
-            # Check for no match and don't filter runnable methods if there would be no match
-            if Tagz.run_all_if_no_match?
-              run_map = Runnable.runnables.reduce({}) {|memo, r| memo[r] = r.runnable_methods; memo}
-              should_skip_filter = run_map.all? do |ctxt, methods|
-                methods.all? do |m|
-                  serialized = MinitestRunnerStrategy.serialize(ctxt, m)
-                  tags = MinitestRunnerStrategy.tag_map[serialized]
-                  tags.nil? ||
-                    tags.empty? ||
-                    ((tags & Tagz.positive_tags).empty? &&
-                     (tags & Tagz.negative_tags).empty?)
-                end
-              end
-              if should_skip_filter
-                puts "Couldn't find any runnables with the given tag, running all runnables" if Tagz.log_if_no_match?
-                return super
-              end
-            end
-
-            ::Minitest::Test.singleton_class.class_eval { prepend(RunnableMethodsFilter) }
-            super
-          end
-        end
-
-        def patch
-          ::Minitest.singleton_class.class_eval { prepend(RunPatch) }
-        end
-
-        def tag_map
-          @tag_map ||= {}
-        end
-      end
-    end
-
-    # Patch the Minitest runtime to hook into Tagz
-    MinitestRunnerStrategy.patch
-
-    # Alias
-    RunnerStrategy = MinitestRunnerStrategy
-
-    # Was more useful when I was trying to add
-    # shoulda-context support
-    module BaseMixin
-      def tag(*tags)
-        Tagz.declare_tag_assignment(self, tags)
-      end
-    end
-
-    # Was more useful when I was trying to add
-    # shoulda-context support
-    class TaggerFactory
-      def self.create_tagger(owner, pending_tags)
-        patchers = [MinitestPatcher]
-        Tagger.new(patchers, owner, pending_tags)
-      end
-    end
-
-    # Represents the individual instance of a `tag` call
-    # It is essentially a state machine that works with the
-    # patcher to patch and unpatch Minitest properly
-    class Tagger
-      def tags_declared
-        patch_test_definitions
-        @awaiting_initial_test_definition = true
-      end
-
-      attr_reader :patchers, :owner, :pending_tags
-
-      def initialize(patchers, owner, pending_tags)
-        @patchers = patchers
-        @owner = owner
-        @pending_tags = pending_tags.map(&:to_s)
-        super()
-      end
-
-      def patch_test_definitions
-        @patchers.each {|p| p.patch(self)}
-      end
-
-      def unpatch_test_definitions
-        @patchers.each(&:unpatch)
-      end
-
-      def handle_initial_test_definition
-        is_initial = @awaiting_initial_test_definition
-        @awaiting_initial_test_definition = false if is_initial
-        res = yield
-        unpatch_test_definitions if is_initial
-        res
-      end
-    end
-
-    # Patches Minitest to track tags
-    module MinitestPatcher
-      ::Minitest::Test.extend(Tagz::BaseMixin)
-
-      class << self
-        def patch(state_machine)
-          patch_minitest_test(state_machine)
-          patch_minitest_spec(state_machine) if spec_included?
-        end
-
-        def unpatch
-          unpatch_minitest_test
-          unpatch_minitest_spec if spec_included?
-        end
-
-        private
-
-        def spec_included?
-          !defined?(::Minitest::Spec).nil?
-        end
-
-        def patch_minitest_test(state_machine)
-          Minitest::Test.class_eval do
-            self.singleton_class.class_eval do
-              alias :old_method_added :method_added
-
-              define_method(:method_added) do |name|
-                if name[/^test_/]
-                  state_machine.handle_initial_test_definition do
-                    Tagz::RunnerStrategy.tag_map ||= {}
-                    Tagz::RunnerStrategy.tag_map[Tagz::RunnerStrategy.serialize(self, name)] ||= []
-                    Tagz::RunnerStrategy.tag_map[Tagz::RunnerStrategy.serialize(self, name)] += state_machine.pending_tags
-                    old_method_added(name)
-                  end
-                else
-                  old_method_added(name)
-                end
-              end
-            end
-          end
-        end
-
-        def unpatch_minitest_test
-          Minitest::Test.class_eval do
-            self.singleton_class.class_eval do
-              undef_method :method_added
-              alias :method_added :old_method_added
-            end
-          end
-        end
-
-        def patch_minitest_spec(state_machine)
-          Kernel.module_eval do
-            alias :old_describe :describe
-
-            define_method(:describe) do |*args, &block|
-              state_machine.handle_initial_test_definition do
-                old_describe(*args, &block)
-              end
-            end
-          end
-        end
-
-        def unpatch_minitest_spec
-          Kernel.module_eval do
-            undef_method :describe
-            alias :describe :old_describe
-          end
-        end
-      end
-    end
-
-    # Main extensions to Minitest
     class << self
       attr_accessor :run_all_if_no_match, :log_if_no_match
 
@@ -211,6 +15,7 @@ module Minitest
 
       # Create a master TagSet that you wish to test. You only
       # want to run tests with tags in this set
+      #
       # @param [Enumerable<Symbol>] tags - a list of tags you want to test
       # @param [Boolean] run_all_if_no_match - will run all tests if no tests are found with the tag
       # @param [Boolean] log_if_no_match - puts if no match specs found
@@ -220,23 +25,33 @@ module Minitest
         @log_if_no_match = log_if_no_match
       end
 
+      # @private
       def chosen_tags
         @chosen_tags ||= []
       end
 
+      # @private
       def positive_tags
         chosen_tags.reject {|t| t.is_a?(String) && t[/^-/]}
       end
 
+      # @private
       def negative_tags
         chosen_tags.select {|t| t.is_a?(String) && t[/^-/]}.map {|t| t[1..-1]}
       end
 
-      def declare_tag_assignment(owner, pending_tags)
-        tag_machine = TaggerFactory.create_tagger(owner, pending_tags)
-        tag_machine.tags_declared
-        tag_machine
+      # @private
+      def serialize(owner, test_name)
+        "#{owner} >> #{test_name}"
+      end
+
+      # @private
+      def tag_map
+        @tag_map ||= {}
       end
     end
   end
 end
+
+Minitest.singleton_class.prepend(Minitest::Tagz::MinitestPatch)
+Minitest::Test.extend(Minitest::Tagz::MinitestTestPatch)

data/lib/minitest/tagz/minitest_patch.rb

@@ -0,0 +1,56 @@
+module Minitest
+  module Tagz
+    module MinitestPatch
+      def run(*args)
+        # Check for no match and don't filter runnable methods if there would be no match
+        if Tagz.run_all_if_no_match?
+          run_map = Minitest::Runnable.runnables.reduce({}) {|memo, r| memo[r] = r.runnable_methods; memo}
+          should_skip_filter = run_map.all? do |ctxt, methods|
+            methods.all? do |m|
+              serialized = Tagz.serialize(ctxt, m)
+              tags = Tagz.tag_map[serialized]
+              tags.nil? ||
+                tags.empty? ||
+                ((tags & Tagz.positive_tags).empty? &&
+                 (tags & Tagz.negative_tags).empty?)
+            end
+          end
+          if should_skip_filter
+            puts "Couldn't find any runnables with the given tag, running all runnables" if Tagz.log_if_no_match?
+            return super
+          end
+        end
+
+        Minitest::Test.singleton_class.class_eval { prepend(MinitestPatch::RunnableMethodsPatch) }
+        super
+      end
+
+      # Patch which is used ot filter Minitest's `runnable_methods`
+      module RunnableMethodsPatch
+        def runnable_methods
+          all_runnables = super
+
+          if Tagz.positive_tags.any?
+            all_runnables.select! do |r|
+              serialized = Tagz.serialize(self, r)
+              tags_on_runnable = Tagz.tag_map[serialized]
+              next false unless tags_on_runnable
+              (Tagz.positive_tags - tags_on_runnable).empty?
+            end
+          end
+
+          if Tagz.negative_tags.any?
+            all_runnables.reject! do |r|
+              serialized = Tagz.serialize(self, r)
+              tags_on_runnable = Tagz.tag_map[serialized]
+              next false unless tags_on_runnable
+              (Tagz.negative_tags & tags_on_runnable).any?
+            end
+          end
+
+          all_runnables
+        end
+      end
+    end
+  end
+end

data/lib/minitest/tagz/minitest_test_patch.rb

@@ -0,0 +1,13 @@
+# Adds the `tag` method to Minitest::Test. When we encounter a `tag` then we
+# want to create a state machine that will be used to patch/unpatch Minitest
+module Minitest
+  module Tagz
+    module MinitestTestPatch
+      def tag(*tags)
+        state_machine = Tagger.new([Minitest::Tagz::Patcher], self, tags)
+        state_machine.tags_declared!
+        state_machine
+      end
+    end
+  end
+end

data/lib/minitest/tagz/patcher.rb

@@ -0,0 +1,73 @@
+# Responsible for patching/unpatching Minitest. When `tag` is called we patch Minitest and
+module Minitest
+  module Tagz
+    module Patcher
+      class << self
+        def patch(state_machine)
+          patch_minitest_test(state_machine)
+          patch_minitest_spec(state_machine) if spec_included?
+        end
+
+        def unpatch
+          unpatch_minitest_test
+          unpatch_minitest_spec if spec_included?
+        end
+
+        private
+
+        def spec_included?
+          !defined?(::Minitest::Spec).nil?
+        end
+
+        def patch_minitest_test(state_machine)
+          Minitest::Test.class_eval do
+            self.singleton_class.class_eval do
+              alias :old_method_added :method_added
+
+              define_method(:method_added) do |name|
+                if name[/^test_/]
+                  state_machine.handle_initial_test_definition! do
+                    Tagz.tag_map ||= {}
+                    Tagz.tag_map[Tagz.serialize(self, name)] ||= []
+                    Tagz.tag_map[Tagz.serialize(self, name)] += state_machine.pending_tags
+                    old_method_added(name)
+                  end
+                else
+                  old_method_added(name)
+                end
+              end
+            end
+          end
+        end
+
+        def unpatch_minitest_test
+          Minitest::Test.class_eval do
+            self.singleton_class.class_eval do
+              undef_method :method_added
+              alias :method_added :old_method_added
+            end
+          end
+        end
+
+        def patch_minitest_spec(state_machine)
+          Kernel.module_eval do
+            alias :old_describe :describe
+
+            define_method(:describe) do |*args, &block|
+              state_machine.handle_initial_test_definition! do
+                old_describe(*args, &block)
+              end
+            end
+          end
+        end
+
+        def unpatch_minitest_spec
+          Kernel.module_eval do
+            undef_method :describe
+            alias :describe :old_describe
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minitest/tagz/tagger.rb

@@ -0,0 +1,39 @@
+module Minitest
+  module Tagz
+    # Represents the individual instance of a `tag` call
+    # It is essentially a state machine that works with the
+    # patcher to patch and unpatch Minitest properly
+    class Tagger
+      attr_reader :patchers, :owner, :pending_tags
+
+      def initialize(patchers, owner, pending_tags)
+        @patchers = patchers
+        @owner = owner
+        @pending_tags = pending_tags.map(&:to_s)
+      end
+
+      def tags_declared!
+        patch_test_definitions
+        @awaiting_initial_test_definition = true
+      end
+
+      def handle_initial_test_definition!
+        is_initial = @awaiting_initial_test_definition
+        @awaiting_initial_test_definition = false if is_initial
+        res = yield
+        unpatch_test_definitions if is_initial
+        res
+      end
+
+      private
+
+      def patch_test_definitions
+        @patchers.each {|p| p.patch(self)}
+      end
+
+      def unpatch_test_definitions
+        @patchers.each(&:unpatch)
+      end
+    end
+  end
+end

data/lib/minitest/tagz/version.rb

@@ -1,5 +1,5 @@
 module Minitest
   module Tagz
-    VERSION = "1.6.0"
+    VERSION = "1.7.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-tagz
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-09 00:00:00.000000000 Z
+date: 2019-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -112,6 +112,10 @@ files:
 - Rakefile
 - lib/minitest/tagz.rb
 - lib/minitest/tagz/focus.rb
+- lib/minitest/tagz/minitest_patch.rb
+- lib/minitest/tagz/minitest_test_patch.rb
+- lib/minitest/tagz/patcher.rb
+- lib/minitest/tagz/tagger.rb
 - lib/minitest/tagz/version.rb
 - minitest-tagz.gemspec
 homepage: https://github.com/jbodah/minitest-tagz
@@ -134,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: yet another tags implementation for Minitest