infinity_test 0.2.0 → 1.0.0

data/lib/infinity_test/application_library/rails.rb

@@ -0,0 +1,94 @@
+module InfinityTest
+  module ApplicationLibrary
+    class Rails
+      include HeuristicsHelper
+      attr_accessor :lib_pattern,
+                    :test_pattern,
+                    :configuration_pattern,
+                    :routes_pattern,
+                    :fixtures_pattern,
+                    :controllers_pattern,
+                    :models_pattern,
+                    :helpers_pattern,
+                    :mailers_pattern,
+                    :application_controller_pattern,
+                    :application_helper_pattern
+
+      def initialize
+        @application = InfinityTest.application
+        resolve_patterns!
+      end
+
+      def add_heuristics!
+        rails = self
+        heuristics do
+
+          add(rails.application_controller_pattern) do |file|
+            run :all => :tests, :in_dir => :controllers
+          end
+
+          add(rails.application_helper_pattern) do |file|
+            run :all => :tests, :in_dir => [:helpers, :views]
+          end
+
+          add(rails.configuration_pattern) do |file|
+            run(:all => :tests)
+          end
+
+          add(rails.routes_pattern) do |file|
+            run(:all => :tests)
+          end
+
+          add(rails.controllers_pattern) do |file|
+            run :test_for => file, :in_dir => :controllers
+          end
+
+          add(rails.models_pattern) do |file|
+            run :test_for => file, :in_dir => :models
+          end
+
+          add(rails.helpers_pattern) do |file|
+            run :test_for => file, :in_dir => :helpers
+          end
+
+          add(rails.mailers_pattern) do |file|
+            run :test_for => file, :in_dir => :mailers
+          end
+
+          add(rails.lib_pattern) do |file|
+            run :test_for => file, :in_dir => :lib
+          end
+
+          add(rails.test_pattern) do |file|
+            run file
+          end
+
+          add(rails.fixtures_pattern) do |file|
+            run :all => :tests, :in_dir => :models
+          end
+
+        end
+      end
+
+      def resolve_patterns!
+        @configuration_pattern = "^config/application.rb"
+        @routes_pattern = "^config/routes\.rb"
+        @lib_pattern  = "^lib/*/(.*)\.rb"
+        if @application.using_test_unit?
+          @test_pattern = "^test/*/(.*)_test.rb"
+          @fixtures_pattern = "^test/fixtures/(.*).yml"
+        else
+          @test_pattern = "^spec/*/(.*)_spec.rb"
+          @fixtures_pattern = "^spec/fixtures/(.*).yml"
+        end
+        @controllers_pattern = "^app/controllers/(.*)\.rb"
+        @models_pattern = "^app/models/(.*)\.rb"
+        @helpers_pattern = "^app/helpers/(.*)\.rb"
+        @mailers_pattern = "^app/mailers/(.*)\.rb"
+        @application_controller_pattern = "^app/controllers/application_controller.rb"
+        @application_helper_pattern = "^app/helpers/application_helper.rb"
+      end
+
+    end
+  end
+end

data/lib/infinity_test/application_library/rubygems.rb

@@ -0,0 +1,43 @@
+module InfinityTest
+  module ApplicationLibrary
+    class RubyGems
+      include HeuristicsHelper
+      attr_accessor :lib_pattern, :test_pattern, :application, :test_helper_pattern
+
+      def initialize
+        @application  = InfinityTest.application
+        @lib_pattern  = "^lib/*/(.*)\.rb"
+        if @application.using_test_unit?
+          @test_pattern = "^test/*/(.*)_test.rb"
+          @test_helper_pattern = "^test/*/test_helper.rb"
+        else
+          @test_pattern = "^spec/*/(.*)_spec.rb"
+          @test_helper_pattern = "^spec/*/spec_helper.rb"
+        end
+      end
+
+      # Add Heuristics to send to Watchr Methods
+      # This methods aren't tested!
+      #
+      def add_heuristics!
+        rubygems = self
+        heuristics do
+
+          add(rubygems.lib_pattern) do |file|
+            run :test_for => file
+          end
+
+          add(rubygems.test_pattern) do |file|
+            run file
+          end
+
+          add(rubygems.test_helper_pattern) do |file|
+            run :all => :tests
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/infinity_test/binary_path.rb

@@ -1,21 +1,43 @@
 module InfinityTest
   module BinaryPath
-    
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, ClassMethods
+    end
+
     def rvm_bin_path(environment, binary)
-      "~/.rvm/gems/#{environment.expanded_name}/bin/#{binary}"
+      environment.path_for(binary)
     end
-    
+
     def print_message(gem_name, ruby_version)
       puts "\n Ruby => #{ruby_version}:  I searched the #{gem_name} binary path and I don't find nothing. You have the #{gem_name} installed in this version?"
     end
-    
+
     def search_binary(binary_name, options)
-      File.expand_path(rvm_bin_path(options[:environment], binary_name))
+      rvm_bin_path(options[:environment], binary_name)
     end
-    
+
     def have_binary?(binary)
       File.exist?(binary)
     end
-    
+
+    module ClassMethods
+
+      # Set the binary to search in the RVM binary folder
+      #
+      # binary :bundle
+      #
+      def binary(binary_name, options={})
+        method_sufix = options[:name] || binary_name
+        eval <<-EVAL
+          def search_#{method_sufix}(environment)
+            search_binary('#{binary_name}', :environment => environment)
+          end
+        EVAL
+      end
+
+    end
+
   end
-end
+end

data/lib/infinity_test/builder.rb

@@ -0,0 +1,56 @@
+module InfinityTest
+  module Builder
+
+    #
+    def construct_command(options)
+      binary_name, ruby_version, command, file, environment = resolve_options(options)
+      unless have_binary?(binary_name) || options[:skip_binary?]
+        print_message(binary_name, ruby_version)
+      else
+        command = "#{command} #{decide_files(file)}"
+        rvm_ruby_version = "rvm #{ruby_version} ruby"
+        if application.have_gemfile? and not application.skip_bundler?
+          run_with_bundler!(rvm_ruby_version, command, environment)
+        else
+          run_without_bundler!(rvm_ruby_version, command)
+        end
+      end
+    end
+
+    #
+    def run_with_bundler!(rvm_ruby_version, command, environment)
+      bundle_binary = search_bundle(environment)
+      unless have_binary?(bundle_binary)
+        print_message('bundle', environment.expanded_name)
+      else
+        %{#{rvm_ruby_version} #{bundle_binary} exec #{command}}
+      end
+    end
+
+    #
+    def run_without_bundler!(rvm_ruby_version, command)
+      %{#{rvm_ruby_version} #{command}}
+    end
+
+    #
+    # Contruct all the Commands for each ruby instance variable
+    # If don't want to run with many rubies, add the current ruby to the rubies instance
+    # and create the command with current ruby
+    #
+    def construct_commands(file=nil)
+      @rubies << RVM::Environment.current.environment_name if @rubies.empty?
+      construct_rubies_commands(file)
+    end
+
+    def resolve_options(options)
+      ruby_version = options[:for]
+      binary_name = options[:skip_binary?] ? '' : options[:binary]
+      load_path = %{-I"#{options[:load_path]}"} if options[:load_path]
+      environment = options[:environment]
+      file = options[:file]
+      command = [ binary_name, load_path].compact.join(' ')
+      [binary_name, ruby_version, command, file, environment]
+    end
+
+  end
+end

data/lib/infinity_test/command.rb

@@ -1,12 +1,13 @@
 module InfinityTest
   class Command
     attr_accessor :command, :results, :line, :ruby_version
-    
+
     # Create new Command object that receive the ruby_version and the command string
     #
     def initialize(options={})
       @command = options[:command]
       @ruby_version = options[:ruby_version]
+      @current_ruby_string = RVM::Environment.current_ruby_string
       @results = []
       @line = []
     end
@@ -15,19 +16,22 @@ module InfinityTest
     #
     def run!
       old_sync = $stdout.sync
-      $stdout.sync = true
+      $stdout.sync = true      
       begin
         open("| #{@command}", "r") do |file|
           until file.eof? do
-            test_line = file.getc 
-            break unless test_line
-            putc(test_line)
+            test_line = file.getc or break
+            if yarv?
+              print(test_line)
+            else
+              putc(test_line)
+            end
             @line.push(test_line)
             push_in_the_results(test_line)
           end
         end
       ensure
-        $stdout.sync = old_sync
+        $stdout.sync = old_sync      
       end
       @results = @results.join
       self
@@ -38,27 +42,17 @@ module InfinityTest
     # Join otherwise.
     #
     def push_in_the_results(test_line)
-      if end_of_line?(test_line)
-        @results.push((ree? or mri?) ? @line.pack('c*') : @line.join)
+      if test_line == ?\n
+        @results.push(yarv? ? @line.join : @line.pack('c*'))
         @line.clear
       end
     end
-    
-    # Using Ruby Enterprise Edition?
-    #
-    def ree?
-      RVM::Environment.current_ruby_string =~ /ree/
-    end
-    
-    # Using mri?
+
+    # Using yarv?
     #
-    def mri?
-      RVM::Environment.current_ruby_string =~ /ruby-1.8/
-    end
-    
-    def end_of_line?(test_line)
-      test_line == ?\n
+    def yarv?
+      @current_ruby_string =~ /ruby-1.9/
     end
-    
+
   end
-end
+end

data/lib/infinity_test/configuration.rb

@@ -1,34 +1,35 @@
 module InfinityTest
   class Configuration
-    
+
     SUPPORTED_FRAMEWORKS = [:growl, :lib_notify] # :snarl, :lib_notify
-    
-    attr_accessor :notification_framework, 
-                  :sucess_image, :failure_image, :pending_image, 
-                  :rubies, :test_framework, 
-                  :exceptions_to_ignore, 
-                  :before_callback, :before_each_ruby_callback,
-                  :after_callback, :after_each_ruby_callback,
-                  :verbose
-    
+
+    attr_accessor :notification_framework,
+    :sucess_image, :failure_image, :pending_image,
+    :rubies, :test_framework, :app_framework,
+    :exceptions_to_ignore, :cucumber,
+    :before_callback, :before_each_ruby_callback, :before_environment_callback,
+    :after_callback, :after_each_ruby_callback,
+    :verbose
+
     IMAGES_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'images'))
-    
+
     SUCESS  = 'sucess'
     FAILURE = 'failure'
     PENDING = 'pending'
-    
+
     # Initialize the Configuration object that keeps the images, callbacks, rubies
     # and the test framework
-    # 
+    #
     def initialize
       @default_dir_image = File.join(IMAGES_DIR, 'simpson')
       @test_framework = :test_unit
+      @app_framework = :rubygems
       @sucess_image  = search_image(SUCESS)
       @failure_image = search_image(FAILURE)
       @pending_image = search_image(PENDING)
       @verbose = false
     end
-    
+
     # Set the notification framework to use with Infinity Test.
     # The supported Notification Frameworks are:
     #
@@ -44,7 +45,8 @@ module InfinityTest
     # notifications :lib_notify
     #
     def notifications(framework, &block)
-      raise NotificationFrameworkDontSupported, "Notification :#{framework} don't supported. The Frameworks supported are: #{SUPPORTED_FRAMEWORKS.join(',')}" unless SUPPORTED_FRAMEWORKS.include?(framework)
+      message = "Notification :#{framework} don't supported. The Frameworks supported are: #{SUPPORTED_FRAMEWORKS.join(',')}"
+      raise NotificationFrameworkDontSupported, message unless SUPPORTED_FRAMEWORKS.include?(framework)
       @notification_framework = framework
       yield self if block_given?
       self
@@ -53,9 +55,9 @@ module InfinityTest
     # Set the Success and Failure image to show in the notification framework
     #
     #   show_images :failure => 'Users/tomas/images/my_custom_image.png', :sucess => 'custom_image.jpg'
-    # 
+    #
     # Or you cant set modes(directory) for show images (please see the images folder in => http://github.com/tomas-stefano/infinity_test/tree/master/images/ )
-    #  
+    #
     #  show_images :mode => :simpson # => This will show images in the folder http://github.com/tomas-stefano/infinity_test/tree/master/images/simpson
     #  show_images :mode => :street_fighter # => This will show images in folder http://github.com/tomas-stefano/infinity_test/tree/master/images/street_fighter
     #  show_images :mode => '~/My/Mode' # => This will show images in the '~/My/Mode' directory
@@ -69,7 +71,7 @@ module InfinityTest
       @failure_image = options[:failure] || search_image(FAILURE)
       @pending_image = options[:pending] || search_image(PENDING)
     end
-    
+
     # Switch the image directory to show
     #
     def switch_mode!(mode)
@@ -80,51 +82,78 @@ module InfinityTest
         @default_dir_image = File.expand_path(File.join(mode))
       end
     end
-    
+
     # Search the sucess, failure or pending images and return the first in the pattern
     #
     def search_image(file)
       Dir.glob(File.join(@default_dir_image, file) + '*').first
     end
-    
+
     # The options method to set:
     #
-    # * test framework 
+    # * test framework
     # * ruby versions
-    # 
+    # * verbose mode
+    # * app_framework
+    #
     # Here is the example of Little Domain Language:
     #
     # use :rubies => ['1.9.1', '1.9.2'], :test_framework => :rspec
     #
     # use :rubies => [ '1.8.7-p249', '1.9.2@rails3'], :test_framework => :test_unit
     #
+    # use :test_framework => :rspec, :app_framework => :rails
+    #
     def use(options={})
       rubies = options[:rubies]
       @rubies = (rubies.is_a?(Array) ? rubies.join(',') : rubies) || []
       @test_framework = options[:test_framework] || @test_framework
-      @verbose = options[:verbose] || @verbose
-      if options[:gemset]
-        @rubies = @rubies.split(',').collect { |ruby| 
-          ruby << "@#{options[:gemset]}" 
-        }.join(',')
-      end
+      @app_framework  = options[:app_framework]  || @app_framework
+      @verbose        = options[:verbose]        || @verbose
+      @cucumber       = options[:cucumber]
+      setting_gemset_for_each_rubies(options[:gemset]) if options[:gemset]
+    end
+
+    # Setting a gemset for each rubies
+    #
+    # setting_gemset_for_each_rubies('infinity_test') # => ['1.8.7@infinity_test', '1.9.2@infinity_test']
+    #
+    def setting_gemset_for_each_rubies(gemset)
+      @rubies = @rubies.split(',').collect { |ruby| ruby << "@#{gemset}" }.join(',')
+    end
+
+    # InfinityTest try to use bundler if Gemfile is present.
+    # This method tell to InfinityTest to not use this convention.
+    #
+    def skip_bundler!
+      @skip_bundler = true
     end
-    
+
+    # Return false if you want the InfinityTest run with bundler
+    #
+    def skip_bundler?
+      @skip_bundler ? true : false
+    end
+
+    def cucumber?
+      @cucumber
+    end
+
     # Method to use to ignore some dir/files changes
-    # 
+    #
     # Example:
     #
     # ignore :exceptions => %w(.svn .hg .git vendor tmp config rerun.txt)
     #
-    # This is useless right now in the Infinity Test because the library 
+    # This is useless right now in the Infinity Test because the library
     # only monitoring lib and test/spec/feature folder.
     #
     def ignore(options={})
       @exceptions_to_ignore = options[:exceptions] || []
     end
-    
+
     # Callback method to run anything you want, before the run the test suite command
-    # 
+    #
     # Example:
     #
     # before_run do
@@ -134,9 +163,9 @@ module InfinityTest
     def before_run(&block)
       @before_callback = block
     end
-    
+
     # Callback method to run anything you want, after the run the test suite command
-    # 
+    #
     # Example:
     #
     # after_run do
@@ -146,7 +175,7 @@ module InfinityTest
     def after_run(&block)
       @after_callback = block
     end
-    
+
     # Callback method to handle before or after all run and for each ruby too!
     #
     # Example:
@@ -167,9 +196,9 @@ module InfinityTest
     #
     #
     def before(hook=:all, &block)
-      setting_callback(hook, :all => :@before_callback, :each_ruby => :@before_each_ruby_callback, &block)
+      setting_callback(hook, :all => :@before_callback, :each_ruby => :@before_each_ruby_callback, :env => :@before_environment_callback, &block)
     end
-    
+
     # Callback method to handle before or after all run and for each ruby too!
     #
     # Example:
@@ -191,15 +220,39 @@ module InfinityTest
     def after(hook=:all, &block)
       setting_callback(hook, :all => :@after_callback, :each_ruby => :@after_each_ruby_callback, &block)
     end
-    
+
     # Clear the terminal (Useful in the before callback)
     #
     def clear(option)
       system('clear') if option == :terminal
     end
 
+    def replace_patterns(&block)
+      block.call(InfinityTest.application)
+      InfinityTest.application
+    end
+    alias :before_env :replace_patterns
+
+    # Added heuristics to the User application
+    #
+    def heuristics(&block)
+      @heuristics ||= Heuristics.new
+      @heuristics.instance_eval(&block)
+      @heuristics
+    end
+
+    # Set #watch methods (For more information see Watchr gem)
+    #
+    # If don't want the heuristics 'magic'
+    #
+    def watch(pattern, &block)
+      @script ||= InfinityTest.watchr
+      @script.watch(pattern, &block)
+      @script
+    end
+
     private
-    
+
     def setting_callback(hook, callback, &block)
       if hook == :all
         instance_variable_set(callback[:all], block)
@@ -207,7 +260,7 @@ module InfinityTest
         instance_variable_set(callback[:each_ruby], block)
       end
     end
-    
+
   end
 end
 
@@ -215,7 +268,6 @@ class NotificationFrameworkDontSupported < StandardError
 end
 
 def infinity_test(&block)
-  configuration = InfinityTest.configuration
-  configuration.instance_eval(&block)
-  configuration
+  InfinityTest.configuration.instance_eval(&block)
+  InfinityTest.configuration
 end