kicker 2.0.0

data/lib/kicker/callback_chain.rb

@@ -0,0 +1,77 @@
+class Kicker
+  class CallbackChain < Array
+    alias_method :append_callback,  :push
+    alias_method :prepend_callback, :unshift
+    
+    def call(files)
+      each do |callback|
+        break if files.empty?
+        callback.call(files)
+      end
+    end
+  end
+  
+  class << self
+    attr_writer :pre_process_chain
+    def pre_process_chain
+      @pre_process_chain ||= CallbackChain.new
+    end
+    
+    attr_writer :process_chain
+    def process_chain
+      @process_chain ||= CallbackChain.new
+    end
+    
+    attr_writer :post_process_chain
+    def post_process_chain
+      @post_process_chain ||= CallbackChain.new
+    end
+    
+    attr_writer :full_chain
+    def full_chain
+      @full_chain ||= CallbackChain.new([pre_process_chain, process_chain, post_process_chain])
+    end
+  end
+  
+  def pre_process_chain
+    self.class.pre_process_chain
+  end
+  
+  def process_chain
+    self.class.process_chain
+  end
+  
+  def post_process_chain
+    self.class.post_process_chain
+  end
+  
+  def full_chain
+    self.class.full_chain
+  end
+end
+
+module Kernel
+  # Adds a handler to the pre_process chain. This chain is ran before the
+  # process chain and is processed from first to last.
+  #
+  # Takes a +callback+ object that responds to <tt>#call</tt>, or a block.
+  def pre_process(callback = nil, &block)
+    Kicker.pre_process_chain.append_callback(block ? block : callback)
+  end
+  
+  # Adds a handler to the process chain. This chain is ran in between the
+  # pre_process and post_process chains. It is processed from first to last.
+  #
+  # Takes a +callback+ object that responds to <tt>#call</tt>, or a block.
+  def process(callback = nil, &block)
+    Kicker.process_chain.append_callback(block ? block : callback)
+  end
+  
+  # Adds a handler to the post_process chain. This chain is ran after the
+  # process chain and is processed from last to first.
+  #
+  # Takes a +callback+ object that responds to <tt>#call</tt>, or a block.
+  def post_process(callback = nil, &block)
+    Kicker.post_process_chain.prepend_callback(block ? block : callback)
+  end
+end

data/lib/kicker/core_ext.rb

@@ -0,0 +1,30 @@
+class Kicker
+  module ArrayExt
+    # Deletes elements from self for which the block evaluates to +true+. A new
+    # array is returned with those values the block returned. So basically, a
+    # combination of reject! and map.
+    #
+    #   a = [1,2,3]
+    #   b = a.take_and_map { |x| x * 2 if x == 2 }
+    #   b # => [4]
+    #   a # => [1, 3]
+    #
+    # 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)
+      took = []
+      reject! do |x|
+        if result = yield(x)
+          took << result
+        end
+      end
+      if flatten_and_compact
+        took.flatten!
+        took.compact!
+      end
+      took
+    end
+  end
+end
+
+Array.send(:include, Kicker::ArrayExt)

data/lib/kicker/growl.rb

@@ -0,0 +1,24 @@
+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)
+  end
+end

data/lib/kicker/options.rb

@@ -0,0 +1,49 @@
+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]"
+    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
+    
+    option_parser.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
+      options[:growl_command] = command
+    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)
+    end
+    
+    option_parser.on('-r', '--recipe [NAME]', 'A named recipe to load.') do |recipe|
+      (options[:recipes] ||= []) << recipe
+    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
+end

data/lib/kicker/recipes/could_not_handle_file.rb

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

data/lib/kicker/recipes/dot_kick.rb

@@ -0,0 +1,35 @@
+module ReloadDotKick #:nodoc
+  class << self
+    def save_state
+      @features_before_dot_kick = $LOADED_FEATURES.dup
+      @chains_before_dot_kick = Kicker.full_chain.map { |c| c.dup }
+    end
+    
+    def call(files)
+      if files.delete('.kick')
+        reset!
+        load '.kick'
+      end
+    end
+    
+    def reset!
+      remove_loaded_features!
+      reset_chains!
+    end
+    
+    def reset_chains!
+      Kicker.full_chain = nil
+      
+      chains = @chains_before_dot_kick.map { |c| c.dup }
+      Kicker.pre_process_chain, Kicker.process_chain, Kicker.post_process_chain = *chains
+    end
+    
+    def remove_loaded_features!
+      ($LOADED_FEATURES - @features_before_dot_kick).each do |feat|
+        $LOADED_FEATURES.delete(feat)
+      end
+    end
+  end
+end
+
+process ReloadDotKick

data/lib/kicker/recipes/execute_cli_command.rb

@@ -0,0 +1,6 @@
+Kicker.option_parser.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
+  pre_process do |files|
+    files.clear
+    execute "sh -c #{command.inspect}"
+  end
+end

data/lib/kicker/recipes/ignore.rb

@@ -0,0 +1,39 @@
+# A recipe which removes files from the files array, thus “ignoring” them.
+#
+# By default ignores logs, tmp, and svn and git files.
+#
+# See Kernel#ignore for info on how to ignore files.
+module Ignore
+  def self.call(files) #:nodoc:
+    files.reject! { |file| ignores.any? { |ignore| file =~ ignore } }
+  end
+  
+  def self.ignores #:nodoc:
+    @ignores ||= []
+  end
+  
+  def self.ignore(regexp_or_string) #:nodoc:
+    ignores << (regexp_or_string.is_a?(Regexp) ? regexp_or_string : /^#{regexp_or_string}$/)
+  end
+end
+
+module Kernel
+  # Adds +regexp_or_string+ as an ignore rule.
+  #
+  #   require 'ignore'
+  #
+  #   ignore /^data\//
+  #   ignore 'Rakefile'
+  #
+  # <em>Only available if the `ignore' recipe is required.</em>
+  def ignore(regexp_or_string)
+    Ignore.ignore(regexp_or_string)
+  end
+end
+
+pre_process Ignore
+
+ignore("tmp")
+ignore(/\w+\.log/)
+ignore(/\.(svn|git)\//)
+ignore("svn-commit.tmp")

data/lib/kicker/recipes/jstest.rb

@@ -0,0 +1,8 @@
+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

data/lib/kicker/recipes/rails.rb

@@ -0,0 +1,54 @@
+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"
+    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"
+    
+    # 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("test", dir, namespace, "#{file}_test.rb")
+        test_file if File.exist?(test_file)
+      end
+    end
+  end
+  
+  run_ruby_tests test_files
+end

data/lib/kicker/utils.rb

@@ -0,0 +1,71 @@
+class Kicker
+  module Utils #:nodoc:
+    extend self
+    
+    def execute(command)
+      @last_command = command
+      
+      log "Change occured, executing command: #{command}"
+      Kicker.growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', command) if Kicker.use_growl
+      
+      output = `#{command}`
+      output.strip.split("\n").each { |line| log "  #{line}" }
+      
+      log "Command #{last_command_succeeded? ? 'succeeded' : "failed (#{last_command_status})"}"
+      
+      if Kicker.use_growl
+        if last_command_succeeded?
+          callback = Kicker.growl_command.nil? ? GROWL_DEFAULT_CALLBACK : lambda { system(Kicker.growl_command) }
+          Kicker.growl(GROWL_NOTIFICATIONS[:succeeded], "Kicker: Command succeeded", output, &callback)
+        else
+          Kicker.growl(GROWL_NOTIFICATIONS[:failed], "Kicker: Command failed (#{last_command_status})", output, &GROWL_DEFAULT_CALLBACK)
+        end
+      end
+    end
+    
+    def last_command
+      @last_command
+    end
+    
+    def log(message)
+      puts "[#{Time.now}] #{message}"
+    end
+    
+    def run_ruby_tests(tests)
+      execute "ruby -r #{tests.join(' -r ')} -e ''" unless tests.empty?
+    end
+    
+    private
+    
+    def last_command_succeeded?
+      $?.success?
+    end
+    
+    def last_command_status
+      $?.to_i
+    end
+  end
+end
+
+module Kernel
+  # Prints a +message+ with timestamp to stdout.
+  def log(message)
+    Kicker::Utils.log(message)
+  end
+  
+  # Executes the +command+, logs the output, and optionally growls.
+  def execute(command)
+    Kicker::Utils.execute(command)
+  end
+  
+  # Returns the last executed command.
+  def last_command
+    Kicker::Utils.last_command
+  end
+  
+  # A convenience method that takes an array of Ruby test files and runs them
+  # collectively.
+  def run_ruby_tests(tests)
+    Kicker::Utils.run_ruby_tests(tests)
+  end
+end

data/lib/kicker/validate.rb

@@ -0,0 +1,24 @@
+class Kicker
+  private
+  
+  def validate_options!
+    validate_paths_and_command!
+    validate_paths_exist!
+  end
+  
+  def validate_paths_and_command!
+    if process_chain.empty? && pre_process_chain.empty?
+      puts OPTION_PARSER_CALLBACK.call(nil).help
+      exit
+    end
+  end
+  
+  def validate_paths_exist!
+    @paths.each do |path|
+      unless File.exist?(path)
+        puts "The given path `#{path}' does not exist"
+        exit 1
+      end
+    end
+  end
+end

data/test/callback_chain_test.rb

@@ -0,0 +1,150 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker, concerning its callback chains" do
+  before do
+    @chains = [:pre_process_chain, :process_chain, :post_process_chain, :full_chain]
+  end
+  
+  it "should return the callback chain instances" do
+    @chains.each do |chain|
+      Kicker.send(chain).should.be.instance_of Kicker::CallbackChain
+    end
+  end
+  
+  it "should be accessible by an instance" do
+    kicker = Kicker.new({})
+    
+    @chains.each do |chain|
+      kicker.send(chain).should == Kicker.send(chain)
+    end
+  end
+  
+  it "should provide a shortcut method which appends a callback to the pre-process chain" do
+    Kicker.pre_process_chain.expects(:append_callback).with do |callback|
+      callback.call == :from_callback
+    end
+    
+    pre_process { :from_callback }
+  end
+  
+  it "should provide a shortcut method which appends a callback to the process chain" do
+    Kicker.process_chain.expects(:append_callback).with do |callback|
+      callback.call == :from_callback
+    end
+    
+    process { :from_callback }
+  end
+  
+  it "should provide a shortcut method which prepends a callback to the post-process chain" do
+    Kicker.post_process_chain.expects(:prepend_callback).with do |callback|
+      callback.call == :from_callback
+    end
+    
+    post_process { :from_callback }
+  end
+  
+  it "should have assigned the chains to the `full_chain'" do
+    Kicker.full_chain.length.should == 3
+    Kicker.full_chain.each_with_index do |chain, index|
+      chain.should.be Kicker.send(@chains[index])
+    end
+  end
+end
+
+describe "Kicker::CallbackChain" do
+  it "should be a subclass of Array" do
+    Kicker::CallbackChain.superclass.should.be Array
+  end
+end
+
+describe "An instance of Kicker::CallbackChain, concerning it's API" do
+  before do
+    @chain = Kicker::CallbackChain.new
+    
+    @callback1 = lambda {}
+    @callback2 = lambda {}
+  end
+  
+  it "should append a callback" do
+    @chain << @callback1
+    @chain.append_callback(@callback2)
+    
+    @chain.should == [@callback1, @callback2]
+  end
+  
+  it "should prepend a callback" do
+    @chain << @callback1
+    @chain.prepend_callback(@callback2)
+    
+    @chain.should == [@callback2, @callback1]
+  end
+end
+
+describe "An instance of Kicker::CallbackChain, when calling the chain" do
+  before do
+    @chain = Kicker::CallbackChain.new
+    @result = []
+  end
+  
+  it "should call the callbacks from first to last" do
+    @chain.append_callback lambda { @result << 1 }
+    @chain.append_callback lambda { @result << 2 }
+    @chain.call(%w{ file })
+    @result.should == [1, 2]
+  end
+  
+  it "should pass the files array given to #call to each callback in the chain" do
+    array = %w{ /file/1 }
+    
+    @chain.append_callback lambda { |files|
+      files.should.be array
+      files.concat(%w{ /file/2 })
+    }
+    
+    @chain.append_callback lambda { |files|
+      files.should.be array
+      @result.concat(files)
+    }
+    
+    @chain.call(array)
+    @result.should == %w{ /file/1 /file/2 }
+  end
+  
+  it "should halt the callback chain once the given array is empty" do
+    @chain.append_callback lambda { |files| @result << 1; files.clear }
+    @chain.append_callback lambda { |files| @result << 2 }
+    @chain.call(%w{ /file/1 /file/2 })
+    @result.should == [1]
+  end
+  
+  it "should not call any callback if the given array is empty" do
+    @chain.append_callback lambda { |files| @result << 1 }
+    @chain.call([])
+    @result.should == []
+  end
+  
+  it "should work with a chain of chains as well" do
+    array = %w{ file }
+    
+    kicker_and_files = lambda do |kicker, files|
+      kicker.should.be @kicker
+      files.should.be array
+    end
+    
+    chain1 = Kicker::CallbackChain.new([
+      lambda { |files| files.should.be array; @result << 1 },
+      lambda { |files| files.should.be array; @result << 2 }
+    ])
+    
+    chain2 = Kicker::CallbackChain.new([
+      lambda { |files| files.should.be array; @result << 3 },
+      lambda { |files| files.should.be array; @result << 4 }
+    ])
+    
+    @chain.append_callback chain1
+    @chain.append_callback chain2
+    
+    @chain.call(array)
+    @result.should == [1, 2, 3, 4]
+  end
+end