kicker 2.1.0 → 2.2.0

data/lib/kicker/core_ext.rb

@@ -9,11 +9,19 @@ class Kicker
     #   b # => [4]
     #   a # => [1, 3]
     #
+    # If +pattern+ is specified then files matching the pattern will be taken.
+    #
+    #   a = [ 'bar', 'foo/bar' ]
+    #   b = a.take_and_map('*/bar') { |x| x }
+    #   b # => ['foo/bar']
+    #   a # => ['bar']
+    #
     # If +flatten_and_compact+ is +true+, the result array will be flattened
     # and compacted. The default is +true+.
-    def take_and_map(flatten_and_compact = true)
+    def take_and_map(pattern = nil, flatten_and_compact = true)
       took = []
       reject! do |x|
+        next if pattern and !File.fnmatch?(pattern, x)
         if result = yield(x)
           took << result
         end

data/lib/kicker/growl.rb

@@ -1,24 +1,59 @@
 require 'growlnotifier/growl_helpers'
 
 class Kicker
-  class << self
-    include Growl
-    attr_accessor :use_growl, :growl_command
-  end
-  
-  GROWL_NOTIFICATIONS = {
-    :change => 'Change occured',
-    :succeeded => 'Command succeeded',
-    :failed => 'Command failed'
-  }
-  
-  GROWL_DEFAULT_CALLBACK = lambda do
-    OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
-  end
-  
-  private
-  
-  def start_growl!
-    Growl::Notifier.sharedInstance.register('Kicker', Kicker::GROWL_NOTIFICATIONS.values)
+  module Growl #:nodoc:
+    NOTIFICATIONS = {
+      :change => 'Change occured',
+      :succeeded => 'Command succeeded',
+      :failed => 'Command failed'
+    }
+    
+    DEFAULT_CALLBACK = lambda do
+      OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
+    end
+    
+    class << self
+      include ::Growl
+      attr_accessor :use, :command
+      
+      Growl.use = true
+      Growl.command = nil
+      
+      def use?
+        @use
+      end
+      
+      def notifications
+        NOTIFICATIONS
+      end
+      
+      def start!
+        ::Growl::Notifier.sharedInstance.register('Kicker', NOTIFICATIONS.values)
+      end
+      
+      def change_occured(status)
+        growl(notifications[:change], 'Kicker: Executing', status.call(:growl) || status.command)
+      end
+      
+      def command_callback
+        lambda { system(command) } if command
+      end
+      
+      def result(status)
+        status.success? ? succeeded(status) : failed(status)
+      end
+      
+      def succeeded(status)
+        callback = command_callback || DEFAULT_CALLBACK
+        body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
+        growl(notifications[:succeeded], "Kicker: Success", body, &callback)
+      end
+      
+      def failed(status)
+        message = "Kicker: Failed (#{status.exit_code})"
+        body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
+        growl(notifications[:failed], message, body, &DEFAULT_CALLBACK)
+      end
+    end
   end
 end

data/lib/kicker/log_status_helper.rb

@@ -0,0 +1,38 @@
+class Kicker
+  class LogStatusHelper
+    attr_reader :command, :output, :exit_code
+    
+    def initialize(proc, command)
+      @proc, @command, @output, @success = proc, command
+    end
+    
+    def result(output, success, exit_code)
+      @output, @success, @exit_code = output, success, exit_code
+    end
+    
+    def call(logger_type)
+      @logger_type = logger_type
+      @proc.call(self) if @proc
+    end
+    
+    def stdout?
+      @logger_type == :stdout
+    end
+    
+    def growl?
+      @logger_type == :growl
+    end
+    
+    def before?
+      @output.nil?
+    end
+    
+    def after?
+      !before?
+    end
+    
+    def success?
+      @success
+    end
+  end
+end

data/lib/kicker/options.rb

@@ -1,49 +1,74 @@
 require 'optparse'
 
 class Kicker
-  DONT_SHOW_RECIPES = %w{ could_not_handle_file execute_cli_command dot_kick }
-  
-  def self.recipes_for_display
-    [RECIPES_DIR, USER_RECIPES_DIR].map do |dir|
-      Dir.glob("#{dir}/*.rb").map { |f| File.basename(f, '.rb') }
-    end.flatten - DONT_SHOW_RECIPES
-  end
-  
-  def self.option_parser
-    @option_parser ||= OptionParser.new do |opt|
-      opt.banner = "Usage: #{$0} [options] [paths to watch]"
+  class << self
+    attr_accessor :latency, :paths, :silent, :quiet
+    
+    def silent?
+      @silent
+    end
+    
+    def quiet?
+      @quiet
     end
   end
   
-  OPTION_PARSER_CALLBACK = lambda do |options|
-    option_parser.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
-      options[:growl] = growl
-    end
+  self.latency = 1
+  self.paths = %w{ . }
+  self.silent = false
+  self.quiet = false
+  
+  module Options #:nodoc:
+    DONT_SHOW_RECIPES = %w{ could_not_handle_file execute_cli_command dot_kick }
     
-    option_parser.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
-      options[:growl_command] = command
+    def self.recipes_for_display
+      Kicker::Recipes.recipe_files.map { |f| File.basename(f, '.rb') } - DONT_SHOW_RECIPES
     end
     
-    option_parser.on('-l', '--latency [FLOAT]', "The time to collect file change events before acting on them. Defaults to 1 second.") do |latency|
-      options[:latency] = Float(latency)
+    def self.parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner =  "Usage: #{$0} [options] [paths to watch]"
+        opt.separator " "
+        opt.separator "  Available recipes: #{recipes_for_display.join(", ")}."
+        opt.separator " "
+        
+        opt.on('-s', '--silent', 'Keep output to a minimum.') do |silent|
+          Kicker.silent = true
+        end
+        
+        opt.on('-q', '--quiet', "Quiet output. Don't print timestamps when logging.") do |quiet|
+          Kicker.silent = Kicker.quiet = true
+        end
+        
+        opt.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
+          Kicker::Growl.use = growl
+        end
+        
+        opt.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
+          Kicker::Growl.command = command
+        end
+        
+        opt.on('-l', '--latency [FLOAT]', "The time to collect file change events before acting on them. Defaults to #{Kicker.latency} second.") do |latency|
+          Kicker.latency = Float(latency)
+        end
+        
+        opt.on('-r', '--recipe [NAME]', 'A named recipe to load.') do |name|
+          recipe(name)
+        end
+      end
     end
     
-    option_parser.on('-r', '--recipe [NAME]', 'A named recipe to load.') do |recipe|
-      (options[:recipes] ||= []) << recipe
+    def self.parse(argv)
+      parser.parse!(argv)
+      Kicker.paths = argv unless argv.empty?
     end
-    
-    option_parser.separator " "
-    option_parser.separator "  Available recipes:"
-    Kicker.recipes_for_display.each { |recipe| option_parser.separator "    - #{recipe}" }
-    
-    option_parser
   end
-  
-  def self.parse_options(argv)
-    argv = argv.dup
-    options = { :growl => true }
-    OPTION_PARSER_CALLBACK.call(options).parse!(argv)
-    options[:paths] = argv unless argv.empty?
-    options
+end
+
+module Kernel
+  # Returns the global OptionParser instance that recipes can use to add
+  # options.
+  def options
+    Kicker::Options.parser
   end
 end

data/lib/kicker/recipes.rb

@@ -0,0 +1,58 @@
+RECIPES_DIR      = File.expand_path('../recipes', __FILE__)
+USER_RECIPES_DIR = File.expand_path('~/.kick')
+
+$:.unshift(RECIPES_DIR)
+$:.unshift(USER_RECIPES_DIR) if File.exist?(USER_RECIPES_DIR)
+
+module Kernel
+  # If only given a <tt>name</tt>, the specified recipe will be loaded. For
+  # instance, the following, in a <tt>.kick</tt> file, will load the Rails
+  # recipe:
+  #
+  #   recipe :rails
+  #
+  # However, this same method is used to define a callback that is called _if_
+  # the recipe is loaded. For instance, the following, in a recipe file, will
+  # be called if the recipe is actually used:
+  #
+  #   recipe :rails do
+  #     # Load anything needed for the recipe.
+  #     process do
+  #       # ...
+  #     end
+  #   end
+  def recipe(name, &block)
+    Kicker::Recipes.recipe(name, &block)
+  end
+end
+
+class Kicker
+  module Recipes #:nodoc:
+    class << self
+      def recipes
+        @recipes ||= {}
+      end
+      
+      def recipe(name, &block)
+        name = name.to_sym
+        if block_given?
+          recipes[name] = block
+        else
+          if recipe = recipes[name]
+            recipe.call
+          else
+            raise LoadError, "Recipe `#{name}' does not exist."
+          end
+        end
+      end
+      
+      def recipe_files
+        Dir.glob(File.join(RECIPES_DIR, '*.rb')) + Dir.glob(File.join(USER_RECIPES_DIR, '*.rb'))
+      end
+    end
+    
+    # We don't want this option to show up at the end
+    require 'execute_cli_command'
+    recipe_files.each { |file| require file }
+  end
+end

data/lib/kicker/recipes/could_not_handle_file.rb

@@ -1,5 +1,7 @@
 post_process do |files|
-  log('')
-  log("Could not handle: #{files.join(', ')}")
-  log('')
+  unless Kicker.silent?
+    log('')
+    log("Could not handle: #{files.join(', ')}")
+    log('')
+  end
 end

data/lib/kicker/recipes/dot_kick.rb

@@ -6,15 +6,21 @@ module ReloadDotKick #:nodoc
     end
     
     def call(files)
-      if files.delete('.kick')
-        reset!
-        load '.kick'
-      end
+      reset! if files.delete('.kick')
+    end
+    
+    def use?
+      File.exist?('.kick')
+    end
+    
+    def load!
+      load '.kick'
     end
     
     def reset!
       remove_loaded_features!
       reset_chains!
+      load!
     end
     
     def reset_chains!
@@ -32,4 +38,10 @@ module ReloadDotKick #:nodoc
   end
 end
 
-process ReloadDotKick
+if ReloadDotKick.use?
+  startup do
+    pre_process ReloadDotKick
+    ReloadDotKick.save_state
+    ReloadDotKick.load!
+  end
+end

data/lib/kicker/recipes/execute_cli_command.rb

@@ -1,4 +1,4 @@
-Kicker.option_parser.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
+options.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
   callback = lambda do |files|
     files.clear
     execute "sh -c #{command.inspect}"

data/lib/kicker/recipes/ignore.rb

@@ -31,9 +31,11 @@ module Kernel
   end
 end
 
-pre_process Ignore
-
-ignore("tmp")
-ignore(/\w+\.log/)
-ignore(/\.(svn|git)\//)
-ignore("svn-commit.tmp")
+recipe :ignore do
+  pre_process Ignore
+  
+  ignore("tmp")
+  ignore(/\w+\.log/)
+  ignore(/\.(svn|git)\//)
+  ignore("svn-commit.tmp")
+end

data/lib/kicker/recipes/jstest.rb

@@ -1,8 +1,10 @@
-process do |files|
-  test_files = files.take_and_map do |file|
-    if file =~ %r{^(test|public)/javascripts/(\w+?)(_test)*\.(js|html)$}
-      "test/javascripts/#{$2}_test.html"
+recipe :jstest do
+  process do |files|
+    test_files = files.take_and_map do |file|
+      if file =~ %r{^(test|public)/javascripts/(\w+?)(_test)*\.(js|html)$}
+        "test/javascripts/#{$2}_test.html"
+      end
     end
+    execute "jstest #{test_files.join(' ')}" unless test_files.empty?
   end
-  execute "jstest #{test_files.join(' ')}" unless test_files.empty?
 end

data/lib/kicker/recipes/rails.rb

@@ -1,54 +1,119 @@
-module Rails
-  # Maps +type+, for instance `models', to a test directory.
-  def self.type_to_test_dir(type)
-    case type
-    when "models"
-      "unit"
-    when "concerns"
-      "unit/concerns"
-    when "controllers", "views"
-      "functional"
-    when "helpers"
-      "unit/helpers"
+# Need to define these modules, because AS breaks if these aren't defined. Need to fix that in AS...
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      module Inflections #:nodoc:
+      end
     end
   end
-  
-  # Returns an array consiting of all functional tests.
-  def self.all_functional_tests
-    Dir.glob("test/functional/**/*_test.rb")
-  end
 end
 
-process do |files|
-  test_files = files.take_and_map do |file|
-    case file
-    # Match any ruby test file and run it
-    when /^test\/.+_test\.rb$/
-      file
-    
-    # Run all functional tests when routes.rb is saved
-    when 'config/routes.rb'
-      Rails.all_functional_tests
-    
-    # Match lib/*
-    when /^(lib\/.+)\.rb$/
-      "test/#{$1}_test.rb"
+require 'ruby'
+
+class Rails < Ruby
+  class << self
+    # Call these options on the Ruby class which takes the cli options.
+    %w{ test_type runner_bin test_cases_root test_options }.each do |delegate|
+      define_method(delegate) { Ruby.send(delegate) }
+    end
     
-    # Match any file in app/ and map it to a test file
-    when %r{^app/(\w+)([\w/]*)/([\w\.]+)\.\w+$}
-      type, namespace, file = $1, $2, $3
-      
-      if dir = Rails.type_to_test_dir(type)
-        if type == "views"
-          namespace = namespace.split('/')[1..-1]
-          file = "#{namespace.pop}_controller"
+    # Maps +type+, for instance `models', to a test directory.
+    def type_to_test_dir(type)
+      if test_type == 'test'
+        case type
+        when "models"
+          "unit"
+        when "concerns"
+          "unit/concerns"
+        when "controllers", "views"
+          "functional"
+        when "helpers"
+          "unit/helpers"
+        end
+      elsif test_type == 'spec'
+        case type
+        when "models"
+          "models"
+        when "concerns"
+          "models/concerns"
+        when "controllers", "views"
+          "controllers"
+        when "helpers"
+          "helpers"
         end
-        
-        test_file = File.join("test", dir, namespace, "#{file}_test.rb")
-        test_file if File.exist?(test_file)
       end
     end
+
+    # Returns an array consiting of all controller tests.
+    def all_controller_tests
+      if test_type == 'test'
+        Dir.glob("#{test_cases_root}/functional/**/*_test.rb")
+      else
+        Dir.glob("#{test_cases_root}/controllers/**/*_spec.rb")
+      end
+    end
+  end
+  
+  # Returns an array of all tests related to the given model.
+  def tests_for_model(model)
+    if test_type == 'test'
+      %W{
+        unit/#{model.singularize}
+        unit/helpers/#{model.pluralize}_helper
+        functional/#{model.pluralize}_controller
+      }
+    else
+      %W{
+        models/#{model.singularize}
+        helpers/#{model.pluralize}_helper
+        controllers/#{model.pluralize}_controller
+      }
+    end.map { |f| test_file f }
+  end
+  
+  def handle!
+    @tests.concat(@files.take_and_map do |file|
+      case file
+      # Run all functional tests when routes.rb is saved
+      when 'config/routes.rb'
+        Rails.all_controller_tests
+      
+      # Match lib/*
+      when /^(lib\/.+)\.rb$/
+        test_file($1)
+      
+      # Map fixtures to their related tests
+      when %r{^#{test_cases_root}/fixtures/(\w+)\.yml$}
+        tests_for_model($1)
+      
+      # Match any file in app/ and map it to a test file
+      when %r{^app/(\w+)([\w/]*)/([\w\.]+)\.\w+$}
+        type, namespace, file = $1, $2, $3
+        
+        if dir = Rails.type_to_test_dir(type)
+          if type == "views"
+            namespace = namespace.split('/')[1..-1]
+            file = "#{namespace.pop}_controller"
+          end
+          
+          test_file File.join(dir, namespace, file)
+        end
+      end
+    end)
+    
+    # And let the Ruby handler match other stuff.
+    super
   end
+end
+
+recipe :rails do
+  require 'rubygems' rescue LoadError
+  require 'active_support/core_ext/string'
+  
+  process Rails
   
-  run_ruby_tests test_files
+  # When changing the schema, prepare the test database.
+  process do |files|
+    execute 'rake db:test:prepare' if files.delete('db/schema.rb')
+  end
 end