infinity_test 0.1.0

data/lib/infinity_test.rb

@@ -0,0 +1,31 @@
+require 'infinity_test/dependencies'
+
+module InfinityTest
+  autoload :Application, 'infinity_test/application'
+  autoload :BinaryPath, 'infinity_test/binary_path'
+  autoload :Command, 'infinity_test/command'
+  autoload :Configuration, 'infinity_test/configuration'
+  autoload :ContinuousTesting, 'infinity_test/continuous_testing'
+  autoload :Options, 'infinity_test/options'
+  autoload :Rspec, 'infinity_test/rspec'
+  autoload :Runner, 'infinity_test/runner'
+  autoload :TestUnit, 'infinity_test/test_unit'
+
+  def self.application
+    @application ||= Application.new
+  end
+  
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  
+  def self.start!
+    Runner.new(Options.new(ARGV)).run!    
+  end
+  
+  module Notifications
+    autoload :Growl, 'infinity_test/notifications/growl'
+    autoload :LibNotify, 'infinity_test/notifications/lib_notify'
+  end
+
+end

data/lib/infinity_test/application.rb

@@ -0,0 +1,168 @@
+module InfinityTest
+  class Application
+    include Notifications
+    
+    attr_accessor :config, :library_directory_pattern
+    
+    # Initialize the Application object with the configuration instance to 
+    # load configuration and set properly
+    #
+    def initialize
+      @config = InfinityTest.configuration
+      @library_directory_pattern = "^lib/*/(.*)\.rb"
+    end
+    
+    # Load the Configuration file
+    #
+    # Load first global file in => ~/.infinity_test
+    # After load the project file => ./.infinity_test
+    #
+    # If the Project file has the same methods in the global, will override the configurations
+    #
+    # Example:
+    #
+    #  ~/.infinity_test -> infinity_test { notifications :growl }
+    #
+    #  ./.infinity_test -> infinity_test { notifications :lib_notify }  # High Priority
+    #
+    # After the load the Notifications Framework will be Lib Notify
+    #
+    def load_configuration_file
+      load_global_configuration    # Separate global and local configuration
+      load_project_configuration   # because it's more easy to test
+    end
+    
+    def sucess_image
+      config.sucess_image
+    end
+    
+    def failure_image
+      config.failure_image
+    end
+    
+    def pending_image
+      config.pending_image
+    end
+    
+    # Return the block object setting in the config file
+    #    
+    def before_callback
+      config.before_callback
+    end
+    
+    # Return the block object setting in the config file
+    #
+    def after_callback
+      config.after_callback
+    end
+    
+    # Return the rubies setting in the config file or the command line
+    #
+    def rubies
+      config.rubies
+    end
+    
+    def construct_commands
+      test_framework.construct_commands
+    end
+    
+    def test_directory_pattern
+      test_framework.test_directory_pattern
+    end
+    
+    # Return a instance of the test framework class
+    #
+    def test_framework
+      @test_framework ||= setting_test_framework
+    end
+    
+    # Return a instance of the Notification Framework class
+    #
+    def notification_framework
+      @notification_framework ||= setting_notification
+    end
+    
+    def run!(commands)
+      before_callback.call if before_callback
+      commands.each do |ruby_version, command|
+        puts; puts "* { :ruby => #{ruby_version} }"
+        puts command if verbose?
+        command = Command.new(:ruby_version => ruby_version, :command => command).run!
+        notify!(:results => command.results, :ruby_version => ruby_version)
+      end
+      after_callback.call if after_callback
+    end
+    
+    def notify!(options)
+      message = parse_results(options[:results])
+      notification_framework.notify(:title => options[:ruby_version], :message => message, :image => image_to_show)
+    end
+    
+    def parse_results(results)
+      test_framework.parse_results(results)
+    end
+
+    def image_to_show
+      if test_framework.failure?
+        failure_image
+      elsif test_framework.pending?
+        pending_image
+      else
+        sucess_image
+      end      
+    end
+    
+    def run_changed_lib_file(file)
+      file = File.basename(file[1])
+      files = test_framework.all_files.grep(/#{file}/i)
+      run_commands_for_file(files.join(' ')) unless files.empty?
+    end
+    
+    def run_changed_test_file(file)
+      run_commands_for_file(file)
+    end
+    
+    def run_commands_for_file(file)
+      commands = test_framework.construct_commands(file)
+      run!(commands)      
+    end
+    
+    def verbose?
+      config.verbose
+    end
+    
+    private
+    
+    def setting_test_framework
+      case config.test_framework
+      when :rspec
+        Rspec.new :rubies => rubies
+      when :test_unit
+        TestUnit.new :rubies => rubies
+      end
+    end
+    
+    def setting_notification
+      case config.notification_framework
+      when :growl
+        Growl.new
+      when :lib_notify
+        LibNotify.new
+      end
+    end
+
+    def load_global_configuration
+      load_file :file => File.expand_path('~/.infinity_test')
+    end
+    
+    def load_project_configuration
+      load_file :file => './.infinity_test'
+    end
+    
+    def load_file(options)
+      file = options[:file]
+      load(file) if File.exist?(file)
+    end
+
+  end
+end

data/lib/infinity_test/binary_path.rb

@@ -0,0 +1,21 @@
+module InfinityTest
+  module BinaryPath
+    
+    def rvm_bin_path(environment, binary)
+      "~/.rvm/gems/#{environment.expanded_name}/bin/#{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))
+    end
+    
+    def have_binary?(binary)
+      File.exist?(binary)
+    end
+    
+  end
+end

data/lib/infinity_test/command.rb

@@ -0,0 +1,57 @@
+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]
+      @results = []
+      @line = []
+    end
+
+    # Code taken in Autotest gem and change a little
+    #
+    def run!
+      old_sync = $stdout.sync
+      $stdout.sync = true
+      begin
+        open("| #{@command}", "r") do |file|
+          until file.eof? do
+            test_line = file.getc 
+            break unless test_line
+            putc(test_line)
+            @line.push(test_line)
+            push_in_the_results(test_line)
+          end
+        end
+      ensure
+        $stdout.sync = old_sync
+      end
+      @results = @results.join
+      self
+    end
+
+    # Push in the results the test line
+    # If have in the Ruby Enterpise Edition pack the numbers return. Join otherwise.
+    #
+    def push_in_the_results(test_line)
+      if end_of_line?(test_line)
+        @results.push(ree? ? @line.pack('c*') : @line.join)
+        @line.clear
+      end
+    end
+    
+    # Using Ruby Enterprise Edition?
+    #
+    def ree?
+      RVM::Environment.current_ruby_string =~ /ree/
+    end
+    
+    def end_of_line?(test_line)
+      test_line == ?\n
+    end
+    
+  end
+end

data/lib/infinity_test/configuration.rb

@@ -0,0 +1,157 @@
+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, :after_callback, :verbose
+    
+    IMAGES_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'images'))
+    
+    # Initialize the Configuration object that keeps the images, callbacks, rubies
+    # and the test framework
+    # 
+    def initialize
+      @default_dir_image = File.join(IMAGES_DIR, 'simpson')
+      @sucess_image  = 'sucess'
+      @failure_image = 'failure'
+      @pending_image = 'pending'
+      @test_framework = :test_unit
+      @verbose = false
+    end
+    
+    # Set the notification framework to use with Infinity Test.
+    # The supported Notification Frameworks are:
+    #
+    # * Growl
+    # * Lib-Notify
+    #
+    # Here is the example of little Domain Specific Language to use:
+    #
+    # notifications :growl do
+    #   # block
+    # end
+    #
+    def notifications(framework, &block)
+      raise NotificationFrameworkDontSupported, "Notification :#{framework} don't supported. The Frameworks supported are: #{SUPPORTED_FRAMEWORKS.join(',')}" unless SUPPORTED_FRAMEWORKS.include?(framework)
+      @notification_framework = framework
+      yield self if block_given?
+      self
+    end
+
+    # 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
+    #
+    # The Convention in images folder is to set sucess, failure and pending images, and
+    # Infinity test will work on these names in the notification framework
+    #
+    def show_images(options={})
+      switch_mode!(options[:mode]) if options[:mode]
+      @sucess_image  = setting_image(options[:sucess])  || search_image(@sucess_image)
+      @failure_image = setting_image(options[:failure]) || search_image(@failure_image)
+      @pending_image = setting_image(options[:pending]) || search_image(@pending_image)
+    end
+    
+    # Switch the image directory to show
+    #
+    def switch_mode!(mode)
+      case mode
+      when Symbol
+        @default_dir_image = File.join(IMAGES_DIR, mode.to_s)
+      when String
+        @default_dir_image = File.expand_path(File.join(mode))
+      end
+    end
+    
+    def setting_image(image)
+      image unless image.equal?(:default)
+    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 
+    # * ruby versions
+    # 
+    # 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
+    #
+    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
+    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 
+    # 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
+    #   clear :terminal
+    # end
+    #
+    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
+    #   # some code that I want to run after all the rubies run
+    # end
+    #
+    def after_run(&block)
+      @after_callback = block
+    end
+    
+    # Clear the terminal (Useful in the before callback)
+    #
+    def clear(option)
+      system('clear') if option == :terminal
+    end
+    
+  end
+end
+
+class NotificationFrameworkDontSupported < StandardError
+end
+
+def infinity_test(&block)
+  configuration = InfinityTest.configuration
+  configuration.instance_eval(&block)
+  configuration
+end

data/lib/infinity_test/continuous_testing.rb

@@ -0,0 +1,62 @@
+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
+
+    def run!(commands)
+      @application.run!(commands) unless commands.empty?
+    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
+    end
+
+    def add_rule(script, options={})
+      script.watch(options[:rule]) do |file|
+        @application.run_changed_test_file(file)
+      end
+    end
+    
+    def add_signal
+      Signal.trap 'INT' do
+        if @sent_an_int then
+           puts " Shutting down now"
+           exit
+        else
+           puts " Interrupt a second time to quit"
+           @sent_an_int = true
+           Kernel.sleep 1.1
+           run! @global_commands
+           @sent_an_int = false 
+        end       
+      end      
+    end
+    
+  end
+end