zeus 0.10.2 → 0.11.0

data/examples/zeus.json

@@ -12,9 +12,8 @@
           "generate": ["g"]
         },
         "test_environment": {
-          "testtask": [],
-          "test_helper": {"testrb": []},
-          "spec_helper": {"rspec": []}
+          "cucumber_environment": {"cucumber": []},
+          "test_helper": {"test": ["rspec", "testrb"]}
         }
       }
     }

data/lib/zeus.rb

@@ -76,9 +76,10 @@ module Zeus
       }
 
       Process.wait(pid)
-      code = $?.exitstatus
+      code = $?.exitstatus || 0
 
       local.write "#{code}\0"
+
       local.close
     end
 

data/lib/zeus/m.rb

@@ -0,0 +1,310 @@
+# This is very largely based on @qrush's M, but there are many modifications.
+
+# we need to load all dependencies up front, because bundler will
+# remove us from the load path soon.
+require "rubygems"
+require "zeus/m/test_collection"
+require "zeus/m/test_method"
+
+# the Gemfile may specify a version of method_source, but we also want to require it here.
+# To avoid possible "you've activated X; gemfile specifies Y" errors, we actually scan
+# Gemfile.lock for a specific version, and require exactly that version if present.
+gemfile_lock = ROOT_PATH + "/Gemfile.lock"
+if File.exists?(gemfile_lock)
+  version = File.read(ROOT_PATH + "/Gemfile.lock").
+    scan(/\bmethod_source\s*\(([\d\.]+)\)/).flatten[0]
+
+  gem "method_source", version if version
+end
+
+require 'method_source'
+
+module Zeus
+  #`m`  stands for metal, which is a better test/unit test runner that can run
+  #tests by line number.
+  #
+  #[![m ci](https://secure.travis-ci.org/qrush/m.png)](http://travis-ci.org/qrush/m)
+  #
+  #![Rush is a heavy metal band. Look it up on Wikipedia.](https://raw.github.com/qrush/m/master/rush.jpg)
+  #
+  #<sub>[Rush at the Bristol Colston Hall May 1979](http://www.flickr.com/photos/8507625@N02/3468299995/)</sub>
+  ### Install
+  #
+  ### Usage
+  #
+  #Basically, I was sick of using the `-n` flag to grab one test to run. Instead, I
+  #prefer how RSpec's test runner allows tests to be run by line number.
+  #
+  #Given this file:
+  #
+  #     $ cat -n test/example_test.rb
+  #      1	require 'test/unit'
+  #      2
+  #      3	class ExampleTest < Test::Unit::TestCase
+  #      4	  def test_apple
+  #      5	    assert_equal 1, 1
+  #      6	  end
+  #      7
+  #      8	  def test_banana
+  #      9	    assert_equal 1, 1
+  #     10	  end
+  #     11	end
+  #
+  #You can run a test by line number, using format `m TEST_FILE:LINE_NUMBER_OF_TEST`:
+  #
+  #     $ m test/example_test.rb:4
+  #     Run options: -n /test_apple/
+  #
+  #     # Running tests:
+  #
+  #     .
+  #
+  #     Finished tests in 0.000525s, 1904.7619 tests/s, 1904.7619 assertions/s.
+  #
+  #     1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+  #
+  #Hit the wrong line number? No problem, `m` helps you out:
+  #
+  #     $ m test/example_test.rb:2
+  #     No tests found on line 2. Valid tests to run:
+  #
+  #      test_apple: m test/examples/test_unit_example_test.rb:4
+  #     test_banana: m test/examples/test_unit_example_test.rb:8
+  #
+  #Want to run the whole test? Just leave off the line number.
+  #
+  #     $ m test/example_test.rb
+  #     Run options:
+  #
+  #     # Running tests:
+  #
+  #     ..
+  #
+  #     Finished tests in 0.001293s, 1546.7904 tests/s, 3093.5808 assertions/s.
+  #
+  #     1 tests, 2 assertions, 0 failures, 0 errors, 0 skips
+  #
+  #### Supports
+  #
+  #`m` works with a few Ruby test frameworks:
+  #
+  #* `Test::Unit`
+  #* `ActiveSupport::TestCase`
+  #* `MiniTest::Unit::TestCase`
+  #
+  ### License
+  #
+  #This gem is MIT licensed, please see `LICENSE` for more information.
+
+  ### M, your metal test runner
+  # Maybe this gem should have a longer name? Metal?
+  module M
+    VERSION = "1.2.1" unless defined?(VERSION)
+
+    # Accept arguments coming from bin/m and run tests.
+    def self.run(argv)
+      Runner.new(argv).run
+    end
+
+    ### Runner is in charge of running your tests.
+    # Instead of slamming all of this junk in an `M` class, it's here instead.
+    class Runner
+      def initialize(argv)
+        @argv = argv
+      end
+
+      # There's two steps to running our tests:
+      # 1. Parsing the given input for the tests we need to find (or groups of tests)
+      # 2. Run those tests we found that match what you wanted
+      def run
+        parse
+        execute
+      end
+
+      private
+
+      def parse
+        # With no arguments,
+        if @argv.empty?
+          # Just shell out to `rake test`.
+          require 'rake'
+          Rake::Task['test'].invoke
+          exit
+        else
+          parse_options! @argv
+
+          # Parse out ARGV, it should be coming in in a format like `test/test_file.rb:9`
+          _, line = @argv.first.split(':')
+          @line ||= line.nil? ? nil : line.to_i
+
+          @files = []
+          @argv.each do |arg|
+            add_file(arg)
+          end
+        end
+      end
+
+      def add_file(arg)
+        file = arg.split(':').first
+        if Dir.exist?(file)
+          files = Dir.glob("#{file}/**/*test*.rb")
+          @files.concat(files)
+        else
+          files = Dir.glob(file)
+          files == [] and abort "Couldn't find test file '#{file}'!"
+          @files.concat(files)
+        end
+      end
+
+      def parse_options!(argv)
+        require 'optparse'
+
+        OptionParser.new do |opts|
+          opts.banner  = 'Options:'
+          opts.version = M::VERSION
+
+          opts.on '-h', '--help', 'Display this help.' do
+            puts "Usage: m [OPTIONS] [FILES]\n\n", opts
+            exit
+          end
+
+          opts.on '--version', 'Display the version.' do
+            puts "m #{M::VERSION}"
+            exit
+          end
+
+          opts.on '-l', '--line LINE', Integer, 'Line number for file.' do |line|
+            @line = line
+          end
+
+          opts.parse! argv
+        end
+      end
+
+      def execute
+        # Locate tests to run that may be inside of this line. There could be more than one!
+        all_tests = tests
+        if @line
+          tests_to_run = all_tests.within(@line)
+        end
+
+        # If we didn't find any tests,
+        if tests_to_run == []
+          # Otherwise we found no tests on this line, so you need to pick one.
+          message = "No tests found on line #{@line}. Valid tests to run:\n\n"
+
+          # For every test ordered by line number,
+          # spit out the test name and line number where it starts,
+          tests.by_line_number do |test|
+            message << "#{sprintf("%0#{tests.column_size}s", test.name)}: zeus test #{@files[0]}:#{test.start_line}\n"
+          end
+
+          # fail like a good unix process should.
+          abort message
+        end
+
+        if @line
+          # assemble the regexp to run these tests,
+          test_names = tests_to_run.map(&:name).join('|')
+
+          # set up the args needed for the runner
+          test_arguments = ["-n", "/(#{test_names})/"]
+        else
+          test_arguments = []
+        end
+
+        # directly run the tests from here and exit with the status of the tests passing or failing
+        case framework
+        when :minitest
+          exit MiniTest::Unit.runner.run test_arguments
+        when :testunit1, :testunit2
+          exit Test::Unit::AutoRunner.run(false, nil, test_arguments)
+        else
+          not_supported
+        end
+      end
+
+      def framework
+        @framework ||= begin
+          if defined?(MiniTest)
+            :minitest
+          elsif defined?(Test)
+            if Test::Unit::TestCase.respond_to?(:test_suites)
+              :testunit2
+            else
+              :testunit1
+            end
+          end
+        end
+      end
+
+      # Finds all test suites in this test file, with test methods included.
+      def suites
+        # Since we're not using `ruby -Itest -Ilib` to run the tests, we need to add this directory to the `LOAD_PATH`
+        $:.unshift "./test", "./lib"
+
+        if framework == :testunit1
+          Test::Unit::TestCase.class_eval {
+            @@test_suites = {}
+            def self.inherited(klass)
+              @@test_suites[klass] = true
+            end
+            def self.test_suites
+              @@test_suites.keys
+            end
+            def self.test_methods
+              public_instance_methods(true).grep(/^test/).map(&:to_s)
+            end
+          }
+        end
+
+        begin
+          # Fire up the Ruby files. Let's hope they actually have tests.
+          @files.each { |f| load f }
+        rescue LoadError => e
+          # Fail with a happier error message instead of spitting out a backtrace from this gem
+          abort "Failed loading test file:\n#{e.message}"
+        end
+
+        # Figure out what test framework we're using
+        case framework
+        when :minitest
+          suites = MiniTest::Unit::TestCase.test_suites
+        when :testunit1, :testunit2
+          suites = Test::Unit::TestCase.test_suites
+        else
+          not_supported
+        end
+
+        # Use some janky internal APIs to group test methods by test suite.
+        suites.inject({}) do |suites, suite_class|
+          # End up with a hash of suite class name to an array of test methods, so we can later find them and ignore empty test suites
+          suites[suite_class] = suite_class.test_methods if suite_class.test_methods.size > 0
+          suites
+        end
+      end
+
+      # Shoves tests together in our custom container and collection classes.
+      # Memoize it since it's unnecessary to do this more than one for a given file.
+      def tests
+        @tests ||= begin
+          # With each suite and array of tests,
+          # and with each test method present in this test file,
+          # shove a new test method into this collection.
+          suites.inject(TestCollection.new) do |collection, (suite_class, test_methods)|
+            test_methods.each do |test_method|
+              find_locations = (@files.size == 1 && @line)
+              collection << TestMethod.create(suite_class, test_method, find_locations)
+            end
+            collection
+          end
+        end
+      end
+
+      # Fail loudly if this isn't supported
+      def not_supported
+        abort "This test framework is not supported! Please open up an issue at https://github.com/qrush/m !"
+      end
+    end
+  end
+end

data/lib/zeus/m/test_collection.rb

@@ -0,0 +1,45 @@
+require "forwardable"
+
+module Zeus
+  module M
+    ### Custom wrapper around an array of test methods
+    # In charge of some smart querying, filtering, sorting, etc on the the
+    # test methods
+    class TestCollection
+      include Enumerable
+      extend Forwardable
+      # This should act like an array, so forward some common methods over to the
+      # internal collection
+      def_delegators :@collection, :size, :<<, :each
+
+      def initialize(collection = nil)
+        @collection = collection || []
+      end
+
+      # Slice out tests that may be within the given line.
+      # Returns a new TestCollection with the results.
+      def within(line)
+        # Into a new collection, filter only the tests that...
+        self.class.new(select do |test|
+          # are within the given boundary for this method
+          # or include everything if the line given is nil (no line)
+          line.nil? || (test.start_line..test.end_line).include?(line)
+        end)
+      end
+
+      # Used to line up method names in `#sprintf` when `m` aborts
+      def column_size
+        # Boil down the collection of test methods to the name of the method's
+        # size, then find the largest one
+        @column_size ||= map { |test| test.name.to_s.size }.max
+      end
+
+      # Be considerate when printing out tests and pre-sort them by line number
+      def by_line_number(&block)
+        # On each member of the collection, sort by line number and yield
+        # the block into the sorted collection
+        sort_by(&:start_line).each(&block)
+      end
+    end
+  end
+end

data/lib/zeus/m/test_method.rb

@@ -0,0 +1,35 @@
+module Zeus
+  module M
+    ### Simple data structure for what a test method contains.
+    #
+    # Too lazy to make a class for this when it's really just a bag of data
+    # without any behavior.
+    #
+    # Includes the name of this method, what line on the file it begins on,
+    # and where it ends.
+    class TestMethod < Struct.new(:name, :start_line, :end_line)
+      # Set up a new test method for this test suite class
+      def self.create(suite_class, test_method, find_locations = true)
+        # Hopefully it's been defined as an instance method, so we'll need to
+        # look up the ruby Method instance for it
+        method = suite_class.instance_method(test_method)
+
+        if find_locations
+          # Ruby can find the starting line for us, so pull that out of the array
+          start_line = method.source_location.last
+
+          # Ruby can't find the end line however, and I'm too lazy to write
+          # a parser. Instead, `method_source` adds `Method#source` so we can
+          # deduce this ourselves.
+          #
+          # The end line should be the number of line breaks in the method source,
+          # added to the starting line and subtracted by one.
+          end_line = method.source.split("\n").size + start_line - 1
+        end
+
+        # Shove the given attributes into a new databag
+        new(test_method, start_line, end_line)
+      end
+    end
+  end
+end

data/lib/zeus/rails.rb

@@ -4,17 +4,80 @@ BOOT_PATH = File.expand_path('config/boot',  ROOT_PATH)
 APP_PATH  = File.expand_path('config/application',  ROOT_PATH)
 
 require 'zeus'
+require 'zeus/m'
 
 module Zeus
   class Rails < Plan
+    def deprecated
+      puts "Zeus 0.11.0 changed zeus.json. You'll have to rm zeus.json && zeus init."
+    end
+    alias_method :spec_helper, :deprecated
+    alias_method :testrb,      :deprecated
+    alias_method :rspec,       :deprecated
+
+
     def after_fork
       reconnect_activerecord
       restart_girl_friday
+      reconnect_redis
+    end
+
+    def _monkeypatch_rake
+      require 'rake/testtask'
+      Rake::TestTask.class_eval {
+
+        # Create the tasks defined by this task lib.
+        def define
+          desc "Run tests" + (@name==:test ? "" : " for #{@name}")
+          task @name do
+            # ruby "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}"
+            rails_env = ENV['RAILS_ENV']
+            rubyopt = ENV['RUBYOPT']
+            ENV['RAILS_ENV'] = nil
+            ENV['RUBYOPT'] = nil # bundler sets this to require bundler :|
+            puts "zeus test #{file_list_string}"
+            system "zeus test #{file_list_string}"
+            ENV['RAILS_ENV'] = rails_env
+            ENV['RUBYOPT'] = rubyopt
+          end
+          self
+        end
+
+        alias_method :_original_define, :define
+
+        def self.inherited(klass)
+          return unless klass.name == "TestTaskWithoutDescription"
+          klass.class_eval {
+            def self.method_added(sym)
+              class_eval do
+                if !@rails_hack_reversed
+                  @rails_hack_reversed = true
+                  alias_method :define, :_original_define
+                  def desc(*)
+                  end
+                end
+              end
+            end
+          }
+        end
+      }
     end
 
     def boot
+      _monkeypatch_rake
+
       require BOOT_PATH
-      require 'rails/all'
+      # config/application.rb normally requires 'rails/all'.
+      # Some 'alternative' ORMs such as Mongoid give instructions to switch this require
+      # out for a list of railties, not including ActiveRecord.
+      # We grep config/application.rb for all requires of rails/all or railties, and require them.
+      rails_components = File.read(APP_PATH + ".rb").
+        scan(/^\s*require\s*['"](.*railtie.*|rails\/all)['"]/).flatten
+
+      rails_components == ["rails/all"] if rails_components == []
+      rails_components.each do |component|
+        require component
+      end
     end
 
     def default_bundle
@@ -30,7 +93,6 @@ module Zeus
 
     def prerake
       require 'rake'
-      load 'Rakefile'
     end
 
     def rake
@@ -71,50 +133,39 @@ module Zeus
       $rails_rake_task = 'yup' # lie to skip eager loading
       ::Rails.application.require_environment!
       $rails_rake_task = nil
-      $LOAD_PATH.unshift(ROOT_PATH) unless $LOAD_PATH.include?(ROOT_PATH)
 
-      if Dir.exist?(ROOT_PATH + "/test")
-        test = File.join(ROOT_PATH, 'test')
-        $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
-      end
-
-      if Dir.exist?(ROOT_PATH + "/spec")
-        spec = File.join(ROOT_PATH, 'spec')
-        $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
-      end
+      $LOAD_PATH.unshift ".", "./lib", "./test", "./spec"
     end
 
     def test_helper
-      require 'test_helper'
-    end
-
-    def testrb
-      argv = ARGV
-
-      # try to find pattern by line using testrbl
-      if defined?(Testrbl) && argv.size == 1 and argv.first =~ /^\S+:\d+$/
-        file, line = argv.first.split(':')
-        argv = [file, '-n', "/#{Testrbl.send(:pattern_from_file, File.readlines(file), line)}/"]
-        puts "using -n '#{argv[2]}'" # let users copy/paste or adjust the pattern
+      if File.exists?(ROOT_PATH + "/spec/spec_helper.rb")
+        require 'spec_helper'
+      elsif File.exist?(ROOT_PATH + "/test/minitest_helper.rb")
+        require 'minitest_helper'
+      else
+        require 'test_helper'
       end
+    end
 
-      runner = Test::Unit::AutoRunner.new(true)
-      if runner.process_args(argv)
-        exit runner.run
+    def test
+      if defined?(RSpec)
+        exit RSpec::Core::Runner.run(ARGV)
       else
-        abort runner.options.banner + " tests..."
+        Zeus::M.run(ARGV)
       end
     end
 
-    def spec_helper
-      require 'spec_helper'
+    def cucumber_environment
+      require 'cucumber/rspec/disable_option_parser'
+      require 'cucumber/cli/main'
+      cucumber_runtime = Cucumber::Runtime.new
     end
 
-    def rspec
-      exit RSpec::Core::Runner.run(ARGV)
+    def cucumber
+      cucumber_main = Cucumber::Cli::Main.new(ARGV.dup)
+      exit cucumber_main.execute!(cucumber_runtime)
     end
 
-
     private
 
     def restart_girl_friday
@@ -131,6 +182,13 @@ module Zeus
       ActiveRecord::Base.establish_connection   rescue nil
     end
 
+    def reconnect_redis
+      return unless defined?(Redis::Client)
+      ObjectSpace.each_object(Redis::Client) do |client|
+        client.connect
+      end
+    end
+
   end
 end
 

data/zeus.gemspec

@@ -26,4 +26,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = version
   gem.license       = "MIT"
+
+  gem.add_dependency "method_source", ">= 0.6.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
-dependencies: []
+date: 2012-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.7
 description: Boot any rails app in under a second
 email:
 - burke@libbey.me
@@ -31,6 +47,9 @@ files:
 - ext/inotify-wrapper/inotify-wrapper.cpp
 - Gemfile
 - lib/zeus/load_tracking.rb
+- lib/zeus/m/test_collection.rb
+- lib/zeus/m/test_method.rb
+- lib/zeus/m.rb
 - lib/zeus/plan.rb
 - lib/zeus/rails.rb
 - lib/zeus.rb