phocus 1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2009 Martin Aumont (mynyml)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/README

@@ -0,0 +1,79 @@
+==== Summary
+
+Phocus let's you temporarily focus some tests, ignoring all others, even across test classes.
+
+
+==== Features
+
+* Ultra simple to use
+* Works accross testcase classes
+* Works within contexts
+* Can focus multiple tests
+* Simple code (< 50 LOCs)
+* Compatible with various testing frameworks
+
+
+==== Examples
+
+  require 'test/unit'
+  require 'rubygems'
+  require 'phocus'
+
+  class TestUser < Test::Unit::TestCase
+
+    focus
+    def test_foo
+      assert User.do_something
+    end
+
+    def test_bar
+      assert User.do_something_else
+    end
+  end
+
+  class TestAcmeWidget < Test::Unit::TestCase
+
+    def test_abc
+      assert true
+    end
+
+    focus
+    def test_xyz
+      assert true
+    end
+  end
+
+Executing these tests (say with <tt>rake test</tt> or <tt>autotest</tt>), will
+only run <tt>test_foo</tt> and <tt>test_xyz</tt>.
+
+Also works fine with <tt>test "description"</tt> style tests.
+
+    focus
+    test "abc" do
+      assert true
+    end
+
+
+==== Testing Framework Compatibility
+
+Phocus is known to be compatible with the following testing frameworks (see test/compat/*):
+
+  * test/unit
+  * minitest/unit
+  * shoulda
+  * context
+  * contest
+
+It is possibly compatible out of the box with other test/unit-based testing
+frameworks as well, but it should be fairly easy to set up if it isn't (include
+Phocus in parent testcase class and set proper method_pattern. See rdocs)
+
+
+==== Links
+
+source:: http://github.com/mynyml/phocus
+rdocs::  http://docs.github.com/mynyml/phocus
+
+
+==== License
+MIT. See LICENSE file.

data/Rakefile

@@ -0,0 +1,79 @@
+# --------------------------------------------------
+# based on thin's Rakefile (http://github.com/macournoyer/thin)
+# --------------------------------------------------
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'pathname'
+require 'yaml'
+
+RUBY_1_9  = RUBY_VERSION =~ /^1\.9/
+WIN       = (RUBY_PLATFORM =~ /mswin|cygwin/)
+SUDO      = (WIN ? "" : "sudo")
+
+def gem
+  RUBY_1_9 ? 'gem19' : 'gem'
+end
+
+def all_except(res)
+  Dir['**/*'].reject do |path|
+    Array(res).any? {|re| path.match(re) }
+  end
+end
+
+spec = Gem::Specification.new do |s|
+  s.name            = 'phocus'
+  s.version         = '1.0'
+  s.summary         = "Run focused tests on test/unit."
+  s.description     = "Tell test/unit exactly which tests you want run. It will ignore all the other ones and let you concentrate on a few."
+  s.author          = "Martin Aumont"
+  s.email           = 'mynyml@gmail.com'
+  s.homepage        = ''
+  s.has_rdoc        = true
+  s.require_path    = "lib"
+  s.files           = all_except([/doc/, /pkg/])
+end
+
+desc "Generate rdoc documentation."
+Rake::RDocTask.new("rdoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = "Phocus"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+desc "Remove package products"
+task :clean => :clobber_package
+
+desc "Update the gemspec for GitHub's gem server"
+task :gemspec do
+  Pathname("#{spec.name}.gemspec").open('w') {|f| f << YAML.dump(spec) }
+end
+
+desc "Install gem"
+task :install => [:clobber, :package] do
+  sh "#{SUDO} #{gem} install pkg/#{spec.full_name}.gem"
+end
+
+desc "Uninstall gem"
+task :uninstall => :clean do
+  sh "#{SUDO} #{gem} uninstall -v #{spec.version} -x #{spec.name}"
+end
+
+desc "run framework compatibility tests"
+task :test_all do
+  paths = %w(
+    test/compat/test_contest.rb
+    test/compat/test_context.rb
+    test/compat/test_minitest.rb
+    test/compat/test_shoulda.rb
+    test/compat/test_test_unit.rb
+    test/test_phocus.rb
+  )
+  paths.each {|path| system("ruby #{path}") }
+end

data/TODO

@@ -0,0 +1,17 @@
+o compatibility
+  o with test/unit plugins
+    x test/unit
+    x minitest
+    x context
+    x shoulda
+    x contest
+    o test/spec
+    ...
+  o Rails
+
+o focus a group of tests at once
+
+    focus do
+      ...
+      ...
+    end

data/lib/phocus/autodetect.rb

@@ -0,0 +1,46 @@
+# :stopdoc:
+# Script to auto detect the test framework in use, and set it up with Phocus.
+
+# Somewhat hackish, but simple/straightforward. If there ever is a need for
+# extendability I'll gladly refactor.
+
+
+# --------------------------------------------------
+# test/unit, contest
+# --------------------------------------------------
+if defined?(Test::Unit::TestCase)
+
+  Test::Unit::TestCase.class_eval { include ::Phocus }
+  Test::Unit::TestSuite.class_eval { def empty?() false end }
+  Phocus.method_pattern = /^test_/
+end
+
+# --------------------------------------------------
+# minitest
+# --------------------------------------------------
+if defined?(MiniTest::Unit::TestCase)
+
+  MiniTest::Unit::TestCase.class_eval { include ::Phocus }
+  Phocus.method_pattern = /^test_/
+end
+
+# --------------------------------------------------
+# context
+# --------------------------------------------------
+if defined?(Test::Unit::TestCase) &&
+            Test::Unit::TestCase.class_eval { class << self; self; end }.included_modules.map {|m| m.to_s }.include?('Context::Context')
+
+  Test::Unit::TestCase.class_eval { include ::Phocus }
+  Phocus.method_pattern = /test:/
+end
+
+# --------------------------------------------------
+# shoulda (test/unit)
+# --------------------------------------------------
+if defined?(Test::Unit::TestCase) &&
+   defined?(Shoulda)
+
+  Test::Unit::TestCase.class_eval { include ::Phocus }
+  Test::Unit::TestSuite.class_eval { def empty?() false end }
+  Phocus.method_pattern = /^test:/
+end

data/lib/phocus.rb

@@ -0,0 +1,123 @@
+require 'pathname'
+
+# Phocus let's you single out selected methods out of a defined group of methods.
+#
+# It is intended to be used to focus one or more tests in a test suite,
+# although it is generic enough that it could conceivably be used in other
+# circumstances as well.
+#
+# Use the <tt>focus</tt> statement right before defining your test method.
+#
+# ===== Examples
+#   require 'test/unit'
+#   require 'phocus'
+#
+#   Phocus.method_pattern = /^test_/
+#
+#   class TestUser < Test::Unit::TestCase
+#     include Phocus
+#
+#     focus
+#     def test_foo
+#       assert true
+#     end
+#
+#     def test_bar
+#       flunk "not focused"
+#     end
+#   end
+#
+# When executed, only test_foo will be run. Can also be used on more than one
+# methods.
+#
+# Phocus also let's you focus methods across classes, which is almost always
+# the desired behaviour. Simply include the mixin in the parent class. In the
+# case of test/unit and test/unit based testing frameworks, this means:
+#
+#   class Test::Unit::TestCase
+#     include Phocus
+#   end
+#
+# Now focusing will work across *all* your tests. Not much benifit if you run
+# your test files individually, but indispensable when using <tt>rake test</tt>
+# or autotest.
+#
+module Phocus
+  class << self
+    attr_accessor :method_pattern
+
+    # Specify a pattern that identifies the names of the group of methods
+    # focusing will apply to.
+    #
+    # For example, when using test/unit, you want the relevant group of methods
+    # to be your test methods, which are the ones starting with <tt>test_</tt>.
+    #
+    #   Phocus.method_pattern = /^test_/
+    #
+    # (which happens to be the default pattern)
+    #
+    # On the other hand, context (http://github.com/jeremymcanally/context),
+    # has test methods starting with <tt>test:</tt>, so you can specify:
+    #
+    #   Phocus.method_pattern = /^test:/
+    #
+    # In reality, it's not so much that Phocus focuses on certain methods, but
+    # rather it ignores others. Since we don't want to ignore helper methods
+    # (setup, teardown, custom helpers, etc.), we must restrict the scope of
+    # ignored methods, which is what <tt>method_pattern</tt> allows us to do.
+    def method_pattern
+      @method_pattern || /^test_/
+    end
+  end
+
+  def self.included(base) #:nodoc:
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    @@__test_methods = {}
+    @@__focused      = false
+    @@__focus_next   = false
+
+    # Use right before defining a method to focus it.
+    def focus
+      unless @@__focused
+        clear_test_methods!
+        @@__focused = true
+      end
+      @@__focus_next = true
+    end
+    # :stopdoc:
+    alias :focused :focus
+    alias :phocus  :focus
+    # :startdoc:
+
+    # If the method belongs to target group (method_pattern), then remove it
+    # unless it is focused.
+    #
+    # We don't want any methods removed if focus is never used, so until it is,
+    # keep a reference to methods being defined so that we can come back and
+    # remove them later.
+    #
+    def method_added(name) #:nodoc:
+      super
+      if name.to_s.match(Phocus.method_pattern)
+        if @@__focused
+          @@__focus_next ? @@__focus_next = false : remove_method(name)
+        else
+          @@__test_methods[self] ||= []
+          @@__test_methods[self] << name
+        end
+      end
+    end
+
+    private
+      def clear_test_methods!
+        @@__test_methods.each do |klass, method_names|
+          method_names.each {|name| klass.class_eval { remove_method(name) } }
+        end
+      end
+  end
+end
+
+require Pathname(__FILE__).dirname.expand_path + 'phocus/autodetect'

data/phocus.gemspec

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: phocus
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Martin Aumont
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-11 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Tell test/unit exactly which tests you want run. It will ignore all the other ones and let you concentrate on a few.
+email: mynyml@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- test
+- test/test_phocus.rb
+- test/compat
+- test/compat/test_shoulda.rb
+- test/compat/test_context.rb
+- test/compat/test_contest.rb
+- test/compat/test_test_unit.rb
+- test/compat/test_minitest.rb
+- test/README
+- test/test_helper.rb
+- TODO
+- lib
+- lib/phocus
+- lib/phocus/autodetect.rb
+- lib/phocus.rb
+- phocus.gemspec
+- LICENSE
+- README
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: Run focused tests on test/unit.
+test_files: []
+

data/test/README

@@ -0,0 +1,8 @@
+Each test file uses it's own framework, so they must be run individually.
+
+  ruby test/test_phocus.rb
+  ruby test/compat/test_test_unit.rb
+  ruby test/compat/test_context.rb
+  ...
+
+<tt>rake test_all</tt> will do just that.

data/test/compat/test_contest.rb

@@ -0,0 +1,49 @@
+require 'test/test_helper'
+require 'contest'
+require 'lib/phocus'
+
+class Test::Unit::TestCase
+  def setup
+    reset_phocused_classes(TestContestA, TestContestB, TestContestC)
+    reset_phocus
+  end
+end
+
+# should focus a method
+class TestContestA < Test::Unit::TestCase
+  test "foo" do
+    flunk "not focused"
+  end
+
+  focus
+  test "bar" do
+    assert true
+  end
+
+  test "baz" do
+    flunk "not focused"
+  end
+end
+
+# should focus methods across test classes
+class TestContestB < Test::Unit::TestCase
+  test "abc" do
+    flunk "not focused"
+  end
+
+  focus
+  test "def" do
+    assert true
+  end
+
+  focus
+  test "ghi" do
+    assert true
+  end
+end
+
+# should not complain when no methods are left after focusing
+class TestContestC < Test::Unit::TestCase
+  test "xyz" do
+  end
+end

data/test/compat/test_context.rb

@@ -0,0 +1,42 @@
+require 'test/test_helper'
+require 'context'
+require 'lib/phocus'
+
+# should focus a method
+class TestContextA < Test::Unit::TestCase
+  test "foo" do
+    flunk "not focused"
+  end
+
+  focus
+  test "bar" do
+    assert true
+  end
+
+  test "baz" do
+    flunk "not focused"
+  end
+end
+
+# should focus methods across test classes
+class TestContextB < Test::Unit::TestCase
+  test "abc" do
+    flunk "not focused"
+  end
+
+  focus
+  test "def" do
+    assert true
+  end
+
+  focus
+  test "ghi" do
+    assert true
+  end
+end
+
+# should not complain when no methods are left after focusing
+class TestContextC < Test::Unit::TestCase
+  test "xyz" do
+  end
+end

data/test/compat/test_minitest.rb

@@ -0,0 +1,50 @@
+require 'test/test_helper'
+require 'minitest/autorun'
+require 'lib/phocus'
+
+class MiniTest::Unit::TestCase
+  def setup
+    reset_phocused_classes(TestMiniTestA, TestMiniTestB, TestMiniTestC)
+    reset_phocus
+  end
+end
+
+# should focus a method
+class TestMiniTestA < MiniTest::Unit::TestCase
+  def test_foo
+    flunk "not focused"
+  end
+
+  focus
+  def test_bar
+    assert true
+  end
+
+  def test_baz
+    flunk "not focused"
+  end
+end
+
+# should focus methods across test classes
+class TestMiniTestB < MiniTest::Unit::TestCase
+  def test_abc
+    flunk "not focused"
+  end
+
+  focus
+  def test_def
+    assert true
+  end
+
+  focus
+  def test_ghi
+    assert true
+  end
+end
+
+# should not complain when no methods are left after focusing
+class TestMiniTestC < MiniTest::Unit::TestCase
+  def test_xyz
+    flunk "not focused"
+  end
+end

data/test/compat/test_shoulda.rb

@@ -0,0 +1,53 @@
+require 'test/test_helper'
+require 'test/unit'
+require 'shoulda'
+require 'lib/phocus'
+
+# testing shoulda/test_unit
+
+class Test::Unit::TestCase
+  def setup
+    reset_phocused_classes(TestShouldaA, TestShouldaB, TestShouldaC)
+    reset_phocus
+  end
+end
+
+# should focus a method
+class TestShouldaA < Test::Unit::TestCase
+  should "foo" do
+    flunk "not focused"
+  end
+
+  focus
+  should "bar" do
+    assert true
+  end
+
+  should "baz" do
+    flunk "not focused"
+  end
+end
+
+# should focus methods across test classes
+class TestShouldaB < Test::Unit::TestCase
+  should "abc" do
+    flunk "not focused"
+  end
+
+  focus
+  should "def" do
+    assert true
+  end
+
+  focus
+  should "ghi" do
+    assert true
+  end
+end
+
+# should not complain when no methods are left after focusing
+class TestShouldaC < Test::Unit::TestCase
+  should "xyz" do
+    flunk "not focused"
+  end
+end

data/test/compat/test_test_unit.rb

@@ -0,0 +1,50 @@
+require 'test/test_helper'
+require 'test/unit'
+require 'lib/phocus'
+
+class Test::Unit::TestCase
+  def setup
+    reset_phocused_classes(TestTestUnitA, TestTestUnitB, TestTestUnitC)
+    reset_phocus
+  end
+end
+
+# should focus a method
+class TestTestUnitA < Test::Unit::TestCase
+  def test_foo
+    flunk "not focused"
+  end
+
+  focus
+  def test_bar
+    assert true
+  end
+
+  def test_baz
+    flunk "not focused"
+  end
+end
+
+# should focus methods across test classes
+class TestTestUnitB < Test::Unit::TestCase
+  def test_abc
+    flunk "not focused"
+  end
+
+  focus
+  def test_def
+    assert true
+  end
+
+  focus
+  def test_ghi
+    assert true
+  end
+end
+
+# should not complain when no methods are left after focusing
+class TestTestUnitC < Test::Unit::TestCase
+  def test_xyz
+    flunk "not focused"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+require 'set'
+require 'rubygems'
+begin
+  require 'ruby-debug'
+rescue LoadError, RuntimeError
+end
+
+class Object
+  def self.metaclass
+    (class << self; self; end)
+  end
+end
+
+def reset_phocused_classes(*classes)
+  Array(classes).flatten.each do |klass|
+    klass.metaclass.class_eval do
+      class_variable_set(:@@__focused,    false )
+      class_variable_set(:@@__focus_next, false )
+      class_variable_set(:@@__test_methods,  {} )
+    end
+  end
+end
+
+def reset_phocus
+  Phocus.method_pattern = nil
+end

data/test/test_phocus.rb

@@ -0,0 +1,136 @@
+require 'test/test_helper'
+require 'expectations'
+require 'lib/phocus'
+
+class TestCase
+  include Phocus
+end
+class TestA < TestCase; end
+class TestB < TestCase; end
+
+def reset
+  klasses = [TestA, TestB]
+  reset_phocused_classes(*klasses)
+  klasses.each do |klass|
+    klass.class_eval do
+      instance_methods(false).each {|name| remove_method(name) }
+    end
+  end
+  reset_phocus
+end
+
+Expectations do
+
+  ## api
+
+  expect true do
+    reset
+    TestA.respond_to?(:focus)   &&
+    TestA.respond_to?(:focused) &&
+    TestA.respond_to?(:phocus)
+  end
+
+  ## pattern
+
+  # custom pattern for relevant methods.
+  # all other methods will be ignored by Phocus
+  # (i.e. they cannot be focused, nor will they ever be removed)
+  expect %w( test_baz test:bar).to_set do
+    reset
+    Phocus.method_pattern = /^test:/
+    class TestA
+      define_method(:'test:foo') {}
+      focus
+      define_method(:'test:bar') {}
+      define_method(:'test_baz') {}
+    end
+
+    TestA.instance_methods(false).to_set
+  end
+
+  ## focused tests
+
+  # only keeps focused method
+  expect %w( test_foo ).to_set do
+    reset
+    class TestA
+      focus
+      def test_foo() end
+      def test_bar() end
+    end
+
+    TestA.instance_methods(false).to_set
+  end
+
+  # keeps more than one focused methods
+  expect %w( test_foo test_bar ).to_set do
+    reset
+    class TestA
+      focus
+      def test_foo() end
+      focus
+      def test_bar() end
+      def test_baz() end
+    end
+
+    TestA.instance_methods(false).to_set
+  end
+
+  # focuses across subclasses
+  expect %w( test_foo ).to_set do
+    reset
+    class TestA
+      focus
+      def test_foo() end
+      def test_bar() end
+    end
+    class TestB
+      def test_abc() end
+    end
+
+    TestA.instance_methods(false).to_set +
+    TestB.instance_methods(false).to_set
+  end
+
+  # focuses more than one methods across subclasses
+  expect %w( test_foo test_def ).to_set do
+    reset
+    class TestA
+      focus
+      def test_foo() end
+      def test_bar() end
+    end
+    class TestB
+      def test_abc() end
+      focus
+      def test_def() end
+    end
+
+    TestA.instance_methods(false).to_set +
+    TestB.instance_methods(false).to_set
+  end
+
+  # non-test methods aren't touched
+  expect %w( test_foo helper ).to_set do
+    reset
+    class TestA
+      focus
+      def test_foo() end
+      def test_bar() end
+      def helper()   end
+    end
+
+    TestA.instance_methods(false).to_set
+  end
+
+  # test methods don't get removed if nothing is focused (control test)
+  expect %w( test_foo test_bar ).to_set do
+    reset
+    class TestA
+      def test_foo() end
+      def test_bar() end
+    end
+
+    TestA.instance_methods(false).to_set
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: phocus
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Martin Aumont
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-25 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Tell test/unit exactly which tests you want run. It will ignore all the other ones and let you concentrate on a few.
+email: mynyml@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- test/test_phocus.rb
+- test/compat/test_shoulda.rb
+- test/compat/test_context.rb
+- test/compat/test_contest.rb
+- test/compat/test_test_unit.rb
+- test/compat/test_minitest.rb
+- test/README
+- test/test_helper.rb
+- TODO
+- lib/phocus/autodetect.rb
+- lib/phocus.rb
+- phocus.gemspec
+- LICENSE
+- README
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Run focused tests on test/unit.
+test_files: []
+