infinity_test 1.0.3 → 2.0.0.rc2

data/lib/infinity_test/core/base.rb

@@ -0,0 +1,369 @@
+module InfinityTest
+  module Core
+    class Base
+      # Specify the Ruby Version Manager to run
+      cattr_accessor :strategy
+      # ==== Options
+      # * :rvm
+      # * :rbenv
+      # * :ruby_normal (Use when don't pass any rubies to run)
+      # * :auto_discover(defaults)
+      self.strategy = :auto_discover
+
+      # Specify Ruby version(s) to test against
+      #
+      # ==== Examples
+      # rubies = %w(ree jruby)
+      #
+      cattr_accessor :rubies
+      self.rubies = []
+
+      # Options to include in the command.
+      #
+      cattr_accessor :specific_options
+      self.specific_options = ''
+
+      # Test Framework to use RSpec, Test::Unit or AutoDiscover(defaults)
+      # ==== Options
+      # * :rspec
+      # * :test_unit (Test unit here apply to this two libs: test/unit and minitest)
+      # * :auto_discover (default)
+      #
+      # This will load a class constantized by name.
+      #
+      cattr_accessor :test_framework
+      self.test_framework = :auto_discover
+
+      # Framework to know the folders and files that need to monitoring by the observer.
+      #
+      # ==== Options
+      # * :rails
+      # * :rubygems
+      # * :auto_discover(defaults)
+      #
+      # This will load a exactly a class constantize by name.
+      #
+      cattr_accessor :framework
+      self.framework = :auto_discover
+
+      # Framework to observe and watch the dirs for file changes.
+      #
+      # ==== Options
+      #  * :listen (default) - Event-driven, uses native OS notifications
+      #  * :filewatcher - Polling-based, works everywhere including VMs/NFS
+      #
+      cattr_accessor :observer
+      self.observer = :listen
+
+      # Ignore test files.
+      #
+      # ==== Examples
+      #   ignore_test_files = [ 'spec/generators/controller_generator_spec.rb' ]
+      #
+      cattr_accessor :ignore_test_files
+      self.ignore_test_files = []
+
+      # Ignore test folders.
+      #
+      # ==== Examples
+      #   # Imagine that you don't want to run integration specs.
+      #   ignore_test_folders = [ 'spec/integration' ]
+      #
+      cattr_accessor :ignore_test_folders
+      self.ignore_test_folders = []
+
+      # Verbose Mode. Print commands before executing them.
+      #
+      cattr_accessor :verbose
+      self.verbose = true
+
+      # Set the notification framework to use with Infinity Test.
+      #
+      # ==== Options
+      # * :auto_discover (default) - Automatically detect available notifier
+      # * :terminal_notifier - macOS terminal-notifier
+      # * :osascript - macOS built-in notifications
+      # * :notify_send - Linux/BSD libnotify
+      # * :dunstify - Linux/BSD dunst
+      #
+      cattr_writer :notifications
+      self.notifications = :auto_discover
+
+      # You can set directory to show images matched by the convention names.
+      # => http://github.com/tomas-stefano/infinity_test/tree/master/images/ )
+      #
+      # Infinity test will work on these names in the notification framework:
+      #
+      # * success (png, gif, jpeg)
+      # * failure (png, gif, jpeg)
+      # * pending (png, gif, jpeg)
+      #
+      cattr_accessor :mode
+
+      #
+      # => This will show images in the folder:
+      # http://github.com/tomas-stefano/infinity_test/tree/master/images/simpson
+      #
+      self.mode = :simpson
+
+      # Success Image to show after the tests run.
+      #
+      cattr_accessor :success_image
+
+      # Pending Image to show after the tests run.
+      #
+      cattr_accessor :pending_image
+
+      # Failure Image to show after the tests run.
+      #
+      cattr_accessor :failure_image
+
+      # Use a specific gemset for each ruby.
+      # OBS.: This only will work for RVM strategy.
+      #
+      cattr_accessor :gemset
+
+      # InfinityTest try to use bundler if Gemfile is present.
+      # Set to false if you don't want use bundler.
+      #
+      cattr_accessor :bundler
+      self.bundler = true
+
+      # Callbacks accessor to handle before or after all run and for each ruby!
+      cattr_accessor :callbacks
+      self.callbacks = []
+
+      # Run the observer to monitor files.
+      # If set to false will just <b>Run tests and exit</b>.
+      # Defaults to true: run tests and monitoring the files.
+      #
+      cattr_accessor :infinity_and_beyond
+      self.infinity_and_beyond = true
+
+      # Skip running tests on startup, only watch for file changes.
+      # Useful for large applications where you want to start watching quickly.
+      #
+      cattr_accessor :just_watch
+      self.just_watch = false
+
+      # Focus mode for running specific tests.
+      #
+      # ==== Options
+      # * nil - Run all tests (default)
+      # * :failures - Run only previously failed tests
+      # * String - Run only the specified file/pattern
+      #
+      cattr_accessor :focus
+      self.focus = nil
+
+      # The extension files that Infinity Test will search.
+      # You can observe python, erlang, etc files.
+      #
+      cattr_accessor :extension
+      self.extension = :rb
+
+      # Setup Infinity Test passing the ruby versions and others setting.
+      # <b>See the class accessors for more information.</b>
+      #
+      # ==== Examples
+      #
+      #  InfinityTest::Base.setup do |config|
+      #    config.strategy = :rbenv
+      #    config.rubies   = %w(ree jruby rbx 1.9.2)
+      #  end
+      #
+      def self.setup
+        yield self
+      end
+
+      # Receives a object that quacks like InfinityTest::Options and do the merge with self(Base class).
+      #
+      def self.merge!(options)
+        ConfigurationMerge.new(self, options).merge!
+      end
+
+      def self.start_continuous_test_server
+        continuous_test_server.start
+      end
+
+      def self.continuous_test_server
+        @continuous_test_server ||= ContinuousTestServer.new(self)
+      end
+
+      # Just a shortcut to bundler class accessor.
+      #
+      def self.using_bundler?
+        bundler
+      end
+
+      # Just a shortcut to bundler class accessor.
+      #
+      def self.verbose?
+        verbose
+      end
+
+      # Callback method to handle before all run and for each ruby too!
+      #
+      # ==== Examples
+      #
+      #   before(:all) do
+      #     # ...
+      #   end
+      #
+      #   before(:each_ruby) do |environment|
+      #     # ...
+      #   end
+      #
+      #   before do # if you pass not then will use :all option
+      #     # ...
+      #   end
+      #
+      def self.before(scope = :all, &block)
+        callback = Callback.new(:before, scope, &block)
+        callbacks.push(callback)
+        callback
+      end
+
+      # Callback method to handle after all run and for each ruby too!
+      #
+      # ==== Examples
+      #
+      #   after(:all) do
+      #     # ...
+      #   end
+      #
+      #   after(:each_ruby) do
+      #     # ...
+      #   end
+      #
+      #   after do # if you pass not then will use :all option
+      #     # ...
+      #   end
+      #
+      def self.after(scope = :all, &block)
+        callback = Callback.new(:after, scope, &block)
+        callbacks.push(callback)
+        callback
+      end
+
+      # Run all before callbacks for the given scope
+      #
+      def self.run_before_callbacks(scope = :all, environment = nil)
+        callbacks.select { |c| c.before? && c.scope == scope }.each do |callback|
+          callback.call(environment)
+        end
+      end
+
+      # Run all after callbacks for the given scope
+      #
+      def self.run_after_callbacks(scope = :all, environment = nil)
+        callbacks.select { |c| c.after? && c.scope == scope }.each do |callback|
+          callback.call(environment)
+        end
+      end
+
+      # Clear all registered callbacks
+      #
+      def self.clear_callbacks!
+        self.callbacks = []
+      end
+
+      # Clear the terminal (Useful in the before callback)
+      #
+      def self.clear_terminal
+        system('clear')
+      end
+
+      ###### This methods will be removed in the Infinity Test v2.0.1 or 2.0.2 ######
+
+      # <b>DEPRECATED:</b> Please use <tt>.notification=</tt> instead.
+      #
+      def self.notifications(notification_name = nil, &block)
+        if notification_name.blank?
+          self.class_variable_get(:@@notifications)
+        else
+          message = <<-MESSAGE
+            .notifications is DEPRECATED.
+            Use this instead:
+              InfinityTest.setup do |config|
+                config.notifications = :dunstify
+              end
+          MESSAGE
+          ActiveSupport::Deprecation.new.warn(message)
+          self.notifications = notification_name
+          self.instance_eval(&block) if block_given?
+        end
+      end
+
+      # <b>DEPRECATED:</b> Please use:
+      # <tt>success_image=</tt> or
+      # <tt>pending_image=</tt> or
+      # <tt>failure_image=</tt> or
+      # <tt>mode=</tt> instead.
+      #
+      def self.show_images(options)
+        message = <<-MESSAGE
+          .show_images is DEPRECATED.
+          Use this instead:
+           InfinityTest.setup do |config|
+             config.success_image = 'some_image.png'
+             config.pending_image = 'some_image.png'
+             config.failure_image = 'some_image.png'
+             config.mode          = 'infinity_test_dir_that_contain_images'
+           end
+        MESSAGE
+        ActiveSupport::Deprecation.new.warn(message)
+        self.success_image = options[:success_image] || options[:sucess_image] if options[:success_image].present? || options[:sucess_image].present? # for fail typo in earlier versions.
+        self.pending_image = options[:pending_image] if options[:pending_image].present?
+        self.failure_image = options[:failure_image] if options[:failure_image].present?
+        self.mode = options[:mode] if options[:mode].present?
+      end
+
+      # <b>DEPRECATED:</b> Please use:
+      # .rubies = or
+      # .specific_options = or
+      # .test_framework = or
+      # .framework = or
+      # .verbose = or
+      # .gemset = instead
+      #
+      def self.use(options)
+        message = <<-MESSAGE
+          .use is DEPRECATED.
+          Use this instead:
+            InfinityTest.setup do |config|
+              config.rubies           = %w(2.0 jruby)
+              config.specific_options = '-J'
+              config.test_framework   = :rspec
+              config.framework        = :padrino
+              config.verbose          = true
+              config.gemset           = :some_gemset
+            end
+        MESSAGE
+        ActiveSupport::Deprecation.new.warn(message)
+        self.rubies = options[:rubies] if options[:rubies].present?
+        self.specific_options = options[:specific_options] if options[:specific_options].present?
+        self.test_framework = options[:test_framework] if options[:test_framework].present?
+        self.framework = options[:app_framework] if options[:app_framework].present?
+        self.verbose = options[:verbose] unless options[:verbose].nil?
+        self.gemset = options[:gemset] if options[:gemset].present?
+      end
+
+      # <b>DEPRECATED:</b> Please use .clear_terminal instead.
+      #
+      def self.clear(option)
+        message = '.clear(:terminal) is DEPRECATED. Please use .clear_terminal instead.'
+        ActiveSupport::Deprecation.new.warn(message)
+        clear_terminal
+      end
+
+      def self.heuristics(&block)
+        # There is a spec pending.
+      end
+
+      def self.replace_patterns(&block)
+        # There is a spec pending.
+      end
+    end
+  end
+end

data/lib/infinity_test/core/callback.rb

@@ -0,0 +1,59 @@
+module InfinityTest
+  module Core
+    class Callback
+      attr_reader :scope, :block, :type
+
+      VALID_SCOPES = [:all, :each_ruby].freeze
+
+      # Create a new callback
+      #
+      # @param type [Symbol] :before or :after
+      # @param scope [Symbol] :all or :each_ruby (defaults to :all)
+      # @param block [Proc] The block to execute
+      #
+      def initialize(type, scope = :all, &block)
+        @type  = type
+        @scope = scope || :all
+        @block = block
+
+        validate_scope!
+      end
+
+      # Execute the callback block
+      #
+      # @param environment [Hash] Optional environment info passed to the block
+      #
+      def call(environment = nil)
+        if block.arity > 0
+          block.call(environment)
+        else
+          block.call
+        end
+      end
+
+      def before?
+        type == :before
+      end
+
+      def after?
+        type == :after
+      end
+
+      def all?
+        scope == :all
+      end
+
+      def each_ruby?
+        scope == :each_ruby
+      end
+
+      private
+
+      def validate_scope!
+        unless VALID_SCOPES.include?(scope)
+          raise ArgumentError, "Invalid callback scope: #{scope}. Valid scopes are: #{VALID_SCOPES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/core/changed_file.rb

@@ -0,0 +1,13 @@
+module InfinityTest
+  module Core
+    class ChangedFile
+      attr_accessor :match_data, :name, :path
+
+      def initialize(match_data)
+        @match_data = match_data
+        @name       = match_data.to_s
+        @path       = match_data[1]
+      end
+    end
+  end
+end

data/lib/infinity_test/core/command_builder.rb

@@ -0,0 +1,48 @@
+module InfinityTest
+  module Core
+    class CommandBuilder < String
+      # Just Syntax Sugar to add the keyword in the command
+      #
+      def add(command)
+        self << " #{command.to_s}"
+        self
+      end
+
+      # Put a double-dash in the command option.
+      #
+      def opt(command_option)
+        self << " --#{command_option}"
+        self
+      end
+
+      # Put one dash in the command option
+      #
+      def option(command_option)
+        self << " -#{command_option}"
+        self
+      end
+
+      # An Object that respond to all methods.
+      #
+      def respond_to?(method_name)
+        true
+      end
+
+      # Everytime will call a method will append to self.
+      #
+      # ==== Examples
+      #
+      #   command.bundle.exec.rspec.spec
+      #   command.bundle.install
+      #
+      def method_missing(method_name, *args, &block)
+        if self.empty?
+          self << "#{method_name.to_s}"
+        else
+          self << " #{method_name.to_s}"
+        end
+        self
+      end
+    end
+  end
+end

data/lib/infinity_test/core/command_runner.rb

@@ -0,0 +1,38 @@
+require 'pty'
+
+module InfinityTest
+  module Core
+    class CommandRunner < String
+      attr_accessor :command
+
+      def initialize(command)
+        @command = command
+
+        super(run!)
+      end
+
+      def run!
+        output = []
+        old_sync = $stdout.sync
+        $stdout.sync = true
+
+        begin
+          PTY.spawn(@command) do |stdout, _stdin, _pid|
+            stdout.each_char do |char|
+              print char
+              output << char
+            end
+          end
+        rescue PTY::ChildExited
+          # Command finished
+        rescue Errno::EIO
+          # End of output
+        ensure
+          $stdout.sync = old_sync
+        end
+
+        output.join
+      end
+    end
+  end
+end

data/lib/infinity_test/core/configuration_merge.rb

@@ -0,0 +1,37 @@
+module InfinityTest
+  module Core
+    class ConfigurationMerge
+      attr_accessor :base, :options
+
+      delegate :strategy, :rubies, :test_framework, :framework, :to => :options
+      delegate :specific_options, :infinity_and_beyond, :verbose, :bundler, :to => :options
+      delegate :notifications, :mode, :just_watch, :focus, :to => :options
+
+      def initialize(base, options)
+        @base = base
+        @options = options
+      end
+
+      # Execute the merge between base and command line options
+      #
+      # === Returns
+      # <Core::BaseClass>: The infinity test core base class.
+      #
+      def merge!
+        @base.strategy            = strategy if strategy.present?
+        @base.rubies              = rubies unless rubies.nil?
+        @base.specific_options    = specific_options if specific_options.present?
+        @base.test_framework      = test_framework if test_framework.present?
+        @base.framework           = framework if framework.present?
+        @base.infinity_and_beyond = infinity_and_beyond unless infinity_and_beyond.nil?
+        @base.verbose             = verbose unless verbose.nil?
+        @base.bundler             = bundler unless bundler.nil?
+        @base.notifications       = notifications if notifications.present?
+        @base.mode                = mode if mode.present?
+        @base.just_watch          = just_watch unless just_watch.nil?
+        @base.focus               = focus if focus.present?
+        @base
+      end
+    end
+  end
+end

data/lib/infinity_test/core/continuous_test_server.rb

@@ -0,0 +1,124 @@
+module InfinityTest
+  module Core
+    class ContinuousTestServer
+      attr_reader :base
+      delegate :binary, :test_files, to: :test_framework
+      delegate :infinity_and_beyond, :notifications, :extension, :just_watch, :focus, to: :base
+
+      def initialize(base)
+        @base = base
+      end
+
+      def start
+        print_banner
+        run_strategy unless just_watch
+        start_observer
+      end
+
+      # Print startup banner showing detected configuration.
+      # Only shows when verbose mode is enabled.
+      #
+      def print_banner
+        return unless Base.verbose?
+
+        puts "\e[96m"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        puts "  InfinityTest - To Infinity and Beyond!"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        puts "  Framework:      #{base.framework}"
+        puts "  Test Framework: #{base.test_framework}"
+        puts "  Strategy:       #{base.strategy}"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\e[0m"
+        puts
+      end
+
+      # Run strategy based on the choosed ruby strategy.
+      #
+      def run_strategy
+        Base.run_before_callbacks(:all)
+
+        apply_focus if focus.present?
+        notify(strategy.run)
+
+        Base.run_after_callbacks(:all)
+      ensure
+        clear_focus
+      end
+
+      # Apply focus filter to test files
+      #
+      def apply_focus
+        case focus
+        when :failures
+          test_framework.test_files = last_failed_files if last_failed_files.present?
+        when String
+          test_framework.test_files = focus if File.exist?(focus)
+        end
+      end
+
+      # Clear focus after running tests
+      #
+      def clear_focus
+        test_framework.test_files = nil
+      end
+
+      # Track last failed test files (stored in .infinity_test_failures)
+      #
+      def last_failed_files
+        failures_file = '.infinity_test_failures'
+        return nil unless File.exist?(failures_file)
+        File.read(failures_file).split("\n").select { |f| File.exist?(f) }.join(' ')
+      end
+
+      # Re run strategy changed the changed files.
+      #
+      def rerun_strategy(files)
+        test_framework.test_files = files
+        run_strategy
+      ensure
+        test_framework.test_files = nil
+      end
+
+      def notify(strategy_result)
+        if notifications.present?
+          test_framework.test_message = strategy_result
+
+          Core::Notifier.new(library: notifications, test_framework: test_framework).notify
+        end
+      end
+
+      # Start to monitoring files in the project.
+      #
+      def start_observer
+        if infinity_and_beyond.present?
+          framework.heuristics!
+          observer.start!
+        end
+      end
+
+      # Returns the instance for the configured strategy.
+      #
+      def strategy
+        @strategy ||= "InfinityTest::Strategy::#{base.strategy.to_s.classify}".constantize.new(self)
+      end
+
+      # Return a cached test framework instance.
+      #
+      def test_framework
+        @test_framework ||= "::InfinityTest::TestFramework::#{base.test_framework.to_s.classify}".constantize.new
+      end
+
+      # Return a framework instance based on the base framework accessor.
+      #
+      def framework
+        @framework ||= "::InfinityTest::Framework::#{base.framework.to_s.camelize}".constantize.new(self)
+      end
+
+      # Return a cached observer instance by the observer accessor.
+      #
+      def observer
+        @observer ||= "::InfinityTest::Observer::#{base.observer.to_s.classify}".constantize.new(self)
+      end
+    end
+  end
+end