infinity_test 0.2.0 → 1.0.0

data/lib/infinity_test/continuous_testing.rb

@@ -1,48 +1,26 @@
 module InfinityTest
   class ContinuousTesting
-    attr_accessor :application, :global_commands
-    
-    def initialize(options)
-      @application = options[:application]
-      @global_commands = @application.construct_commands
-    end
-    
-    # Start the Continuous Testing Server and begin to audit the files for changes
-    #
-    def start!
-      run!(@global_commands)
-      initialize_watchr!
-    end
+    attr_accessor :application, :watchr, :global_commands
 
-    def run!(commands)
-      @application.run!(commands) unless commands.empty?
+    def initialize
+      @application = InfinityTest.application
+      @watchr = InfinityTest.watchr
     end
 
     ##################
     # Watchr Methods #
-    #################
-    
+    ##################
+
     def initialize_watchr!
-      script = Watchr::Script.new
-      # add_rule script, :rule => @application.library_directory_pattern
-      watch_lib_folder(script, @application.library_directory_pattern)
-      add_rule script, :rule => @application.test_directory_pattern
       add_signal
-      Watchr::Controller.new(script, Watchr.handler.new).run
-    end
-    
-    def watch_lib_folder(script, library_directory_pattern)
-      script.watch(library_directory_pattern) do |file|
-        @application.run_changed_lib_file(file)
-      end
+      run_with_watchr!
     end
+    alias :start! :initialize_watchr!
 
-    def add_rule(script, options={})
-      script.watch(options[:rule]) do |file|
-        @application.run_changed_test_file(file)
-      end
+    def run_with_watchr!
+      Watchr::Controller.new(@watchr, Watchr.handler.new).run
     end
-    
+
     def add_signal
       Signal.trap 'INT' do
         if @sent_an_int then
@@ -52,11 +30,11 @@ module InfinityTest
            puts " Interrupt a second time to quit"
            @sent_an_int = true
            Kernel.sleep 1.1
-           run! @global_commands
-           @sent_an_int = false 
-        end       
-      end      
+           @application.run_global_commands!
+           @sent_an_int = false
+        end
+      end
     end
-    
+
   end
-end
+end

data/lib/infinity_test/dependencies.rb

@@ -1,45 +1,80 @@
+module InfinityTest
+  class Dependencies
+    
+    RVM_HOME_DIRECTORY = File.expand_path("~/.rvm/lib")
+    
+    RVM_SYSTEM_WIDE_DIRECTORY = "/usr/local/rvm/lib"
+    
+    RVM_LIBRARY_DIRECTORY = File.expand_path("~/.rvm/lib")
 
-RVM_LIBRARY_DIRECTORY = File.expand_path("~/.rvm/lib")
-
-#
-# Try to require the rvm in home folder
-# If not suceed raise a LoadError 
-# Try to see if the user has the RVM 1.0 or higher for the RVM Ruby API
-# If not raise a NameError
-#
-def require_home_rvm
-  $LOAD_PATH.unshift(RVM_LIBRARY_DIRECTORY) unless $LOAD_PATH.include?(RVM_LIBRARY_DIRECTORY)
-  require 'rvm'
-  RVM::Environment
-end
-
-# TODO: Make require with System Wide Install too
-#
-begin
-  require_home_rvm
-rescue LoadError, NameError
-  puts
-  puts "It appears that you have not installed the RVM in #{RVM_LIBRARY_DIRECTORY} or RVM is very old.\n"
-  puts "The RVM is installed?"
-  puts "If not, please see http://rvm.beginrescueend.com/rvm/install/"
-  puts "If so, try to run:"
-  puts "\t rvm update --head"
-  puts "If the error continues, please create an issue in http://github.com/tomas-stefano/infinity_test"
-  puts 'Thanks :)'
-  exit
-end
-
-def require_without_rubygems(options)
-  gem_name = options[:gem]
-  begin
-    require gem_name
-  rescue LoadError
-    require 'rubygems'
-    require gem_name
+    
+    class << self
+      
+      def require_rvm_ruby_api
+        require 'rvm'
+        RVM::Environment
+      end
+      
+      #
+      # Try to require the rvm in home folder
+      # If not suceed raise a LoadError
+      # Try to see if the user has the RVM 1.0 or higher for the RVM Ruby API
+      # If not raise a NameError
+      #
+      def require_home_rvm
+        $LOAD_PATH.unshift(RVM_HOME_DIRECTORY) unless $LOAD_PATH.include?(RVM_HOME_DIRECTORY)
+        require_rvm_ruby_api
+      end
+      
+      def require_rvm_system_wide
+        $LOAD_PATH.unshift(RVM_SYSTEM_WIDE_DIRECTORY) unless $LOAD_PATH.include?(RVM_SYSTEM_WIDE_DIRECTORY)
+        require_rvm_ruby_api
+      end
+      
+      def try_to_require_system_wide
+        begin
+          require_rvm_system_wide
+        rescue LoadError, NameError
+          print_info_about_rvm
+        end        
+      end
+      
+      def require_rvm
+        begin
+          require_home_rvm
+        rescue LoadError, NameError
+          try_to_require_system_wide
+        end
+      end
+      
+      def require_without_rubygems(options)
+        gem_name = options[:gem]
+        begin
+          require gem_name
+        rescue LoadError
+          require 'rubygems'
+          require gem_name
+        end
+      end
+      
+      def print_info_about_rvm
+        puts
+        puts "It appears that you have not installed the RVM library in #{RVM_HOME_DIRECTORY} or in #{RVM_SYSTEM_WIDE_DIRECTORY} or RVM is very old.\n"
+        puts "The RVM is installed?"
+        puts "If not, please see http://rvm.beginrescueend.com/rvm/install/"
+        puts "If so, try to run:"
+        puts "\t rvm update --head (or if you're using the head of rvm try: rvm get head)"
+        puts "\nIf the error continues, please create an issue in http://github.com/tomas-stefano/infinity_test"
+        puts 'Thanks :)'
+        puts
+        exit        
+      end
+      
+    end
   end
-end
 
-require_without_rubygems :gem => 'watchr'
-
-require 'ostruct'
+end
 
+InfinityTest::Dependencies.require_rvm
+InfinityTest::Dependencies.require_without_rubygems :gem => 'watchr'
+InfinityTest::Dependencies.require_without_rubygems :gem => 'notifiers'

data/lib/infinity_test/environment.rb

@@ -0,0 +1,15 @@
+module InfinityTest
+  module Environment
+
+    # Run in context of each Ruby Environment, and the Ruby Version
+    #
+    def environments(&block)
+      raise unless block_given?
+      RVM.environments(rubies).each do |environment|
+        ruby_version = environment.environment_name
+        block.call(environment, ruby_version)
+      end
+    end
+
+  end
+end

data/lib/infinity_test/heuristics.rb

@@ -0,0 +1,36 @@
+module InfinityTest
+  class Heuristics
+    attr_reader :patterns, :script
+
+    def initialize
+      @patterns = {}
+      @script = InfinityTest.watchr
+      @application = InfinityTest.application
+    end
+
+    def add(pattern, &block)
+      @patterns[pattern] = block
+      @script.watch(pattern, &block) # Watchr
+      @patterns
+    end
+
+    def remove(pattern)
+      if pattern == :all
+        @patterns.clear
+        @script.rules.clear
+      else
+        @patterns.delete(pattern)
+        @script.rules.delete_if { |rule| rule.pattern == pattern }
+      end
+    end
+
+    def all
+      @patterns.keys
+    end
+
+    def run(options)
+      @application.run_commands_for_file(@application.files_to_run!(options))
+    end
+
+  end
+end

data/lib/infinity_test/heuristics_helper.rb

@@ -0,0 +1,9 @@
+module InfinityTest
+  module HeuristicsHelper
+
+    def heuristics(&block)
+      InfinityTest.configuration.heuristics(&block)
+    end
+
+  end
+end

data/lib/infinity_test/options.rb

@@ -2,15 +2,14 @@ require 'optparse'
 
 module InfinityTest
   class Options < Hash
-        
+
     def initialize(arguments)
       super()
       @options = OptionParser.new do |options|
-        parse_rspec(options)
-        parse_test_unit(options)
-        parse_rubies(options)
-        parse_verbose(options)
-        options.banner = [ "Usage: infinity_test [options]", "Starts a continuous test server."].join("\n")        
+        [:test_unit, :rspec, :bacon, :rubygems, :rails, :rubies, :verbose, :patterns, :bundler, :version].each do |name|
+          send("parse_#{name}", options)
+        end
+        options.banner = [ "Usage: infinity_test [options]", "Starts a continuous test server."].join("\n")
         options.on_tail("--help", "You're looking at it.") do
           print options.help
           exit
@@ -18,35 +17,73 @@ module InfinityTest
       end
       @options.parse!(arguments.clone)
     end
-    
+
     def parse_rspec(options)
-      options.on('--rspec', 'Rspec Framework') do
+      options.on('--rspec', 'Test Framework: Rspec') do
         self[:test_framework] = :rspec
       end
     end
-    
+
     def parse_test_unit(options)
-      options.on('--test-unit', 'Test Unit') do
+      options.on('--test-unit', 'Test Framework: Test Unit [Default]') do
         self[:test_framework] = :test_unit
       end
     end
-    
+
+    def parse_bacon(options)
+      options.on('--bacon', 'Test Framework: Bacon') do
+        self[:test_framework] = :bacon
+      end
+    end
+
     def parse_rubies(options)
-      options.on('--rubies=rubies', 'Specify the Ruby Versions for Testing with several Rubies') do |versions|
+      options.on('--rubies=rubies', 'Specify the Ruby Versions for Testing with many Rubies') do |versions|
         self[:rubies] = versions
       end
     end
-    
+
     def parse_verbose(options)
-      options.on('--verbose', 'The Infinity Test dont print the commands. To print the command set this options!') do
+      options.on('--verbose', 'The Infinity Test dont print the commands', 'To print the commands set this option!') do
         self[:verbose] = true
       end
     end
-    
-    def rspec?
-      return true if self[:test_framework].equal?(:rspec)
-      false
+
+    def parse_rails(options)
+      options.on('--rails', 'Application Framework: Rails') do
+        self[:app_framework] = :rails
+      end
+    end
+
+    def parse_rubygems(options)
+      options.on('--rubygems', 'Application Framework: Rubygems (Default)') do
+        self[:app_framework] = :rubygems
+      end
+    end
+
+    # def parse_cucumber(options)
+    #   options.on('--cucumber', 'Run with the Cucumber too') do
+    #     self[:cucumber] = true
+    #   end
+    # end
+
+    def parse_patterns(options)
+      options.on('--heuristics', 'Show all the Default Patterns and added by #heuristics method and EXIT.') do
+        self[:show_heuristics?] = true
+      end
+    end
+
+    def parse_bundler(options)
+      options.on('--skip-bundler', "InfinityTest try to use bundler if Gemfile is present. If you don't want to use this convention, set this option.") do
+        self[:skip_bundler?] = true
+      end
     end
     
+    def parse_version(options)
+      options.on("--version", "Show version and exit") do
+        puts InfinityTest.version
+        exit
+      end
+    end
+
   end
-end
+end

data/lib/infinity_test/runner.rb

@@ -1,30 +1,38 @@
 module InfinityTest
   class Runner
-    attr_reader :commands, :options, :application
-    
-    def initialize(options)
-      @options = options
-      @commands = []
+    attr_reader :options, :application
+
+    def initialize(argv)
+      @options = Options.new(argv)
       @application = InfinityTest.application
     end
-    
+
     def run!
       load_configuration_file_or_read_the_options!
-      start_continuous_testing!
+      if @options[:show_heuristics?]
+        list_heuristics!
+      else
+        @application.run_global_commands!
+        start_continuous_testing!
+      end
+    end
+
+    def list_heuristics!
+      @application.heuristics.patterns.keys.each do |pattern|
+        puts %{- "#{pattern}"}
+      end
+      exit
     end
-    
+
     def load_configuration_file_or_read_the_options!
-      @application.load_configuration_file
-      @application.config.use(
-        :rubies => (options[:rubies] || @application.rubies),
-        :test_framework => (options[:test_framework] || @application.config.test_framework),
-        :verbose => options[:verbose] || @application.config.verbose
-      )
+      @application.load_configuration_file_or_read_the_options!(@options)
     end
-    
+
+    # Start Continuous Server using Watchr
+    #
     def start_continuous_testing!
-      InfinityTest::ContinuousTesting.new(:application => @application).start!
+      InfinityTest::ContinuousTesting.new.start!
     end
 
   end
-end
+end

data/lib/infinity_test/test_framework.rb

@@ -0,0 +1,109 @@
+module InfinityTest
+  class TestFramework
+    include InfinityTest::BinaryPath
+    include InfinityTest::Environment
+    include InfinityTest::Builder
+
+    binary :bundle
+
+    attr_accessor :application, :message, :rubies, :test_pattern
+
+    def initialize(options={})
+      @application = InfinityTest.application
+      @rubies = options[:rubies] || []
+    end
+
+    # Return all the files match by test_pattern
+    #
+    def all_files
+      Dir[@test_pattern].sort
+    end
+
+    def test_files
+      all_files.collect { |file| file }.join(' ')
+    end
+
+    def decide_files(file)
+      return file if file
+      test_files
+    end
+
+    # Method used in the subclasses of TestFramework
+    #
+    # Example:
+    #
+    #  class Rspec < TestFramework
+    #    parse_results :example => /(\d+) example/, :failure => /(\d+) failure/, :pending => /(\d+) pending/
+    #  end
+    #
+    # Then will create @examples, @failure and @pending instance variables with the values in the test result
+    #
+    # Or with Test::Unit:
+    #
+    #  class TestUnit < TestFramework
+    #    parse_results :tests => /(\d+) tests/, :assertions => /(\d+) assertions/, :failures => /(\d+) failures/, :errors => /(\d+) errors/
+    #  end
+    #
+    # Then will create @tests, @assertions, @failures and @errors instance variables with the values in the test result
+    #
+    def self.parse_results(patterns)
+      raise(ArgumentError, 'patterns should not be empty') if patterns.empty?
+      create_accessors(patterns)
+      define_method(:parse_results) do |results|
+        set_instances(:shell_result => test_message(results, patterns), :patterns => patterns)
+      end
+    end
+
+    # Create accessors for keys of the Hash passed in argument
+    #
+    # create_accessors({ :example => '...', :failure => '...'}) # => attr_accessor :example, :failure
+    #
+    def self.create_accessors(hash)
+      hash.keys.each do |attribute|
+        attr_accessor attribute
+      end
+    end
+
+    # Create the instance pass in the patterns options
+    #
+    # Useful for the parse results:
+    #  parse_results :tests => /.../, :assertions => /.../
+    #
+    # Then will create @tests ans @assertions (the keys of the Hash)
+    #
+    def create_pattern_instance_variables(patterns, shell_result)
+      patterns.each do |key, pattern|
+        number = shell_result[pattern, 1].to_i
+        instance_variable_set("@#{key}", number)
+      end
+      @message = shell_result.gsub(/\e\[\d+?m/, '') # Clean ANSIColor strings
+    end
+
+    # Return the message of the tests
+    #
+    # test_message('0 examples, 0 failures', { :example => /(\d) example/}) # => '0 examples, 0 failures'
+    # test_message('....\n4 examples, 0 failures', { :examples => /(\d) examples/}) # => '4 examples, 0 failures'
+    #
+    def test_message(output, patterns)
+      lines = output.split("\n")
+      final_result = []
+      patterns.each do |key, pattern|
+        final_result << lines.select { |line| line =~ pattern }
+      end
+      final_result.flatten.last
+    end
+
+    private
+
+      def set_instances(options)
+        shell_result, patterns = options[:shell_result], options[:patterns]
+        if shell_result
+          create_pattern_instance_variables(patterns, shell_result)
+        else
+          patterns.each { |instance, pattern| instance_variable_set("@#{instance}", 1) } # set all to 1 to show that an error occurred
+          @message = "An exception occurred"
+        end
+      end
+
+  end
+end