minitest-tagz 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ebe2a552b70a6c9636949552b092405b0ff8606b
-  data.tar.gz: 41d024c65a904fd822f0e4d15afd7864eb1c9bfd
+  metadata.gz: 8743f494fc917d96a638d22e0d98cfaa5e94a3ae
+  data.tar.gz: 1cdd782cfd5edc53da8e3a25c1817e6d05a6023f
 SHA512:
-  metadata.gz: 520e49ba6db312c4e5617390aa49ba1ee22103518c1523d2f742815eba564d596fe7c664f78ee908131b406752cbe36ba5036027b6b752b8ba2325064ca6f919
-  data.tar.gz: eb2615c95ca8472a814146de35fb8c18d8d0360145c08a844b3d396de6235c17359de0c420968a071e9c72f221b225105119fce69d693e8dda35c92aff8b6910
+  metadata.gz: 712ba39c5104fe7e02d80eb45026fc414a149853d3e86687a87a5670e301116b92e5e128aa1c24e993a458b9e383cfc8fb64085840ba06aaee176f78bde7ea66
+  data.tar.gz: 95a77a32b2cf90933512784b451e26471cf32b6e15071aec741bf5c23ed1cf1d8ac34f65194fb098056a89d8825f42963f82b3b7cc9758938e60112e52eae267

data/README.md

@@ -33,8 +33,11 @@ require 'minitest/tagz'
 Minitest::Tagz.choose_tags(*ENV['TAGS'].split(',')) if ENV['TAGS']
 ```
 
-This wil let you do this like: `bundle exec rake test TAGS=fast,login` to run all
-tests with the fast and login tags.
+Then, for example, you can run all tests with the `:fast` and `:login` tags:
+
+```rb
+bundle exec rake test TAGS=fast,login
+```
 
 ## Usage
 
@@ -86,12 +89,6 @@ class MySpec < Minitest::Spec
 end
 ```
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
 1. Fork it ( https://github.com/backupify/minitest-tagz/fork )

data/lib/minitest/tagz/version.rb

@@ -1,5 +1,5 @@
 module Minitest
   module Tagz
-    VERSION = "0.2.0"
+    VERSION = "1.0.0"
   end
 end

data/lib/minitest/tagz.rb

@@ -1,73 +1,169 @@
 require 'minitest/tagz/version'
-require 'minitest/tagz/minitest_adapter'
+require 'state_machine'
 
 module Minitest
   module Tagz
-    class << self
-      # Pick the tags you want to test
-      def choose_tags(*tags)
-        @chosen_tags = tags.map(&:to_sym).compact.to_set
+    module MinitestRunnerStrategy
+      class << self
+        def serialize(owner, test_name)
+          "#{owner} >> #{test_name}"
+        end
+
+        def patch
+          ::Minitest::Test.singleton_class.class_eval do
+            attr_reader :tag_map
+
+            old_runnable_methods = instance_method(:runnable_methods)
+            define_method :runnable_methods do
+              if Tagz.chosen_tags && Tagz.chosen_tags.any?
+                all_runnables = old_runnable_methods.bind(self).call
+                all_runnables.select do |r|
+                  next false unless MinitestRunnerStrategy.tag_map[MinitestRunnerStrategy.serialize(self, r)]
+                  (Tagz.chosen_tags - MinitestRunnerStrategy.tag_map[MinitestRunnerStrategy.serialize(self, r)]).empty?
+                end
+              else
+                old_runnable_methods.bind(self).call
+              end
+            end
+          end
+        end
+
+        def tag_map
+          @tag_map ||= {}
+        end
       end
+    end
 
-      # Create a tag on a test
-      def declare_tags(*pending_tags)
-        @pending_tags = pending_tags
+    MinitestRunnerStrategy.patch
+    RunnerStrategy = MinitestRunnerStrategy
+
+    module BaseMixin
+      def tag(*tags)
+        Tagz.declare_tag_assignment(self, tags)
       end
+    end
 
-      # Record the given tags with the object
-      def apply_tags(namespace, obj)
-        if @pending_tags
-          # TODO
-          tags["#{namespace}::#{obj}"] += @pending_tags
-          @pending_tags = nil
-        end
+    class TaggerFactory
+      def self.create_tagger(owner, pending_tags)
+        patchers = [MinitestPatcher]
+        Tagger.new(patchers, owner, pending_tags)
       end
+    end
+
+    class Tagger
+      state_machine :state, initial: :awaiting_tag_declaration do
+        after_transition any => :awaiting_test_definition, do: :patch_test_definitions
+        after_transition any => :finished, do: :unpatch_test_definitions
 
-      def record_blanket_tags
-        if @pending_tags
-          # TODO
-          self.blanket_tags = @pending_tags
-          @pending_tags = nil
+        event :tags_declared do
+          transition :awaiting_tag_declaration => :awaiting_test_definition
         end
-      end
 
-      def apply_blanket_tags(namespace, obj)
-        unless blanket_tags.empty?
-          tags["#{namespace}::#{obj}"] += @blanket_tags
+        event :initial_test_definition_encountered do
+          transition :awaiting_test_definition => :applying_tags
         end
-      end
 
-      # Select all the testables with matching tags
-      def filter(namespace, enum)
-        enum.select {|obj| has_matching_tags?(namespace, obj)}
+        event :finished_applying_tags do
+          transition :applying_tags => :finished
+        end
       end
 
-      def reset_blanket_tags
-        @blanket_tags = []
+      attr_reader :patchers, :owner, :pending_tags
+
+      def initialize(patchers, owner, pending_tags)
+        @patchers = patchers
+        @owner = owner
+        @pending_tags = pending_tags
+        super()
       end
 
-      private
+      def patch_test_definitions
+        @patchers.each {|p| p.patch(self)}
+      end
 
-      # Check if object has matching tags
-      def has_matching_tags?(namespace, obj)
-        obj_tags = tags["#{namespace}::#{obj}"] || []
-        chosen_tags.all? { |tag| obj_tags.include?(tag) }
+      def unpatch_test_definitions
+        @patchers.each(&:unpatch)
       end
 
-      def chosen_tags
-        @chosen_tags ||= Set.new
+      def handle_initial_test_definition
+        is_initial = awaiting_test_definition?
+        initial_test_definition_encountered if is_initial
+        res = yield
+        finished_applying_tags if is_initial
+        res
       end
+    end
+
+    module MinitestPatcher
+      ::Minitest::Test.extend(Tagz::BaseMixin)
+
+      class << self
+        def patch(state_machine)
+          patch_minitest_test(state_machine)
+          patch_minitest_spec(state_machine)
+        end
+
+        def unpatch
+          unpatch_minitest_test
+          unpatch_minitest_spec
+        end
+
+        private
+
+        def patch_minitest_test(state_machine)
+          @old_method_added = old_method_added = Minitest::Test.method(:method_added)
+          Minitest::Test.class_eval do
+            define_singleton_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.call(name)
+                end
+              else
+                old_method_added.call(name)
+              end
+            end
+          end
+        end
 
-      def tags
-        @tags ||= Hash.new([])
+        def unpatch_minitest_test
+          Minitest::Test.define_singleton_method(:method_added, @old_method_added)
+        end
+
+        def patch_minitest_spec(state_machine)
+          @old_describe = old_describe = Minitest::Spec.method(:describe)
+          Minitest::Spec.class_eval do
+            define_singleton_method(:describe) do |*args, &block|
+              state_machine.handle_initial_test_definition do
+                old_describe.unbind.bind(self).call(*args, &block)
+              end
+            end
+          end
+        end
+
+        def unpatch_minitest_spec
+          Minitest::Spec.define_singleton_method(:describe, @old_describe)
+        end
       end
+    end
+
+    class << self
+      attr_accessor :chosen_tags
 
-      def blanket_tags
-        @blanket_tags ||= reset_blanket_tags
+      # 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
+      def choose_tags(*tags)
+        @chosen_tags = tags
       end
 
-      def blanket_tags=(arg)
-        @blanket_tags = arg
+      def declare_tag_assignment(owner, pending_tags)
+        tag_machine = TaggerFactory.create_tagger(owner, pending_tags)
+        tag_machine.tags_declared
+        # TODO add debugging tip about this
+        tag_machine
       end
     end
   end

data/minitest-tagz.gemspec

@@ -20,9 +20,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "minitest", "~> 5"
+  spec.add_dependency "shoulda-context"
+  spec.add_dependency 'state_machine'
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency 'pry-byebug'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-tagz
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Josh Bodah
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2015-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: allows you to tag different Minitest tests with tags that can be used
   to filter tests
 email:
@@ -96,10 +138,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/console
-- bin/setup
 - lib/minitest/tagz.rb
-- lib/minitest/tagz/minitest_adapter.rb
 - lib/minitest/tagz/version.rb
 - minitest-tagz.gemspec
 homepage: https://github.com/backupify/minitest-tagz
@@ -122,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: yet another tags implementation for Minitest

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "minitest/tagz"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/minitest/tagz/minitest_adapter.rb

@@ -1,47 +0,0 @@
-module Minitest
-  module Tagz
-    module MinitestAdapter
-      module Base
-        def tag(*tags)
-          Tagz.declare_tags(*tags)
-        end
-
-        def method_added(name)
-          return unless name[/^test_/]
-          Tagz.apply_tags(self, name)
-        end
-
-        def runnable_methods
-          Tagz.filter(self, super)
-        end
-      end
-
-      module Spec
-        def describe(*args, &block)
-          Tagz.record_blanket_tags
-          super
-          apply_blanket_tags_recursively
-          Tagz.reset_blanket_tags
-        end
-
-        def apply_blanket_tags_recursively
-          test_methods_in_describe = instance_methods.select {|m| m[/^test/]}
-          test_methods_in_describe.each do |runnable|
-            Tagz.apply_blanket_tags(self, runnable)
-          end
-
-          children.each do |child|
-            child.apply_blanket_tags_recursively
-          end
-        end
-      end
-    end
-  end
-end
-
-if defined?(Minitest)
-  ::Minitest::Test.singleton_class.prepend(Minitest::Tagz::MinitestAdapter::Base)
-  if defined?(Minitest::Spec)
-    ::Minitest::Spec.singleton_class.prepend(Minitest::Tagz::MinitestAdapter::Spec)
-  end
-end