alloy-kicker 1.9.0 → 1.9.1

data/README.rdoc

@@ -35,19 +35,4 @@ And for fun, ghetto-autotest:
 
 == Installation
 
-  $ sudo gem install alloy-kicker -s http://gems.github.com
-
-== TODO
-
-  15:12 sandbags: ideally i would like all events within a small window (e.g. 2s) to be batched into one
-  15:12 sandbags: depending upon whether what is being reported is "file X changed" or "some files in directory X" changed
-  15:12 sandbags: i forget the granularity FSEvents supports
-  15:13 alloy: Yeah the window can be changed, which is a good idea
-  15:13 alloy: FSEvents simply reports changes to files in dir X. nothing more
-  15:14 sandbags: btw.. what is your rationale for using "!" in method names?
-  15:14 alloy: So in this case we should simply keep the time at which an event occurs and then grep the dirs for files with an higher mtime
-  15:14 sandbags: works for me
-  15:16 alloy: Well the rationale in these cases was either it could raise something (validate) or it would run something external. But really it was just for kicks :)
-  15:16 alloy: It could be cleaned up, as I agree it doesn't help much
-  15:17 sandbags: i think it would be easy to grok without them
-  15:17 alloy: Yeah indeed
+  $ sudo gem install alloy-kicker -s http://gems.github.com

data/TODO.rdoc

@@ -0,0 +1,78 @@
+== For v2
+
+* Create 3 callback chains
+  * pre-process: for instance Exclude
+  * process: normal callbacks
+  * post-process: for instance the default 'could not handle' callback
+
+* Add -r option to require recipe files that come bundled with Kicker
+
+* Probably easier to let the user mutate the files array instead of having to return an array.
+
+* Might be best to create an array of Pathname's instead of simply file path strings.
+  Probably a subclass of Pathname with some Kicker specific helpers. (relative_path)
+
+* Also maybe add an options/attributes hash to the Pathname subclass onto whch the user
+  can add arbitrary attributes for if they spread handing over multiple callbacks.
+  But this will make callbacks dependent on each-other...
+
+* Add example .kick files. E.g.:
+  * remove files in specific dirs from the files stack (log, tmp etc)
+  * rewrites the paths for a specific app dir layout so that the JS tests are properly picked up.
+
+* Add Rails and jstest recipes from our rails app:
+
+    def relative_path(path)
+      path[(Dir.pwd.length + 1)..-1]
+    end
+  
+    # Regular Rails mappings
+    Kicker.callback = lambda do |kicker, files|
+      test_files = []
+    
+      files.delete_if do |file|
+        # Match any ruby test file and run it
+        if relative_path(file) =~ /^test\/.+_test\.rb$/
+          test_files << relative_path(file)
+      
+        # Match any file in app/ and map it to a test file
+        elsif match = relative_path(file).match(%r{^app/(\w+)([\w/]*)/([\w\.]+)\.\w+$})
+          type, namespace, file = match[1..3]
+        
+          dir = case type
+          when "models"
+            "unit"
+          when "concerns"
+            "unit/concerns"
+          when "controllers", "views"
+            "functional"
+          end
+        
+          if dir
+            if type == "views"
+              namespace = namespace.split('/')[1..-1]
+              file = "#{namespace.pop}_controller"
+            end
+          
+            test_files << File.join("test", dir, namespace, "#{file}_test.rb")
+          end
+        end
+      end
+    
+      kicker.execute_command "ruby -r #{test_files.join(' -r ')} -e ''" unless test_files.empty?
+      files
+    end
+
+    # Match javascript changes and run with HeadlessSquirrel
+    Kicker.callback = lambda do |kicker, files|
+      test_files = []
+    
+      files.delete_if do |file|
+        if relative_path(file) =~ %r{^test/javascripts/(\w+_test)\.(js|html)$}
+          test_files << "test/javascripts/#{$1}.html"
+        end
+      end
+    
+      kicker.execute_command "jstest #{test_files.join(' ')}" unless test_files.empty?
+      files
+    end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 1
 :minor: 9
-:patch: 0
+:patch: 1

data/lib/kicker.rb

@@ -40,10 +40,6 @@ class Kicker
     finished_processing!
   end
   
-  def callback_chain
-    self.class.callback_chain
-  end
-  
   def start
     validate_options!
     
@@ -81,7 +77,7 @@ class Kicker
   
   def process(events)
     unless (files = changed_files(events)).empty?
-      callback_chain.run(self, files)
+      full_chain.call(self, files)
       finished_processing!
     end
   end

data/lib/kicker/callback_chain.rb

@@ -3,19 +3,57 @@ class Kicker
     alias_method :append_callback,  :push
     alias_method :prepend_callback, :unshift
     
-    def run(kicker, files)
+    def call(kicker, files)
       each do |callback|
-        files = callback.call(kicker, files)
-        break if !files.is_a?(Array) || files.empty?
+        break if files.empty?
+        callback.call(kicker, files)
       end
     end
   end
   
-  def self.callback_chain
-    @callback_chain ||= CallbackChain.new
+  class << self
+    def pre_process_chain
+      @pre_process_chain ||= CallbackChain.new
+    end
+    
+    def process_chain
+      @process_chain ||= CallbackChain.new
+    end
+    
+    def post_process_chain
+      @post_process_chain ||= CallbackChain.new
+    end
+    
+    def full_chain
+      @full_chain ||= CallbackChain.new([pre_process_chain, process_chain, post_process_chain])
+    end
+    
+    def pre_process_callback=(callback)
+      pre_process_chain.append_callback(callback)
+    end
+    
+    def process_callback=(callback)
+      process_chain.append_callback(callback)
+    end
+    
+    def post_process_callback=(callback)
+      post_process_chain.prepend_callback(callback)
+    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 self.callback=(callback)
-    callback_chain.prepend_callback(callback)
+  def full_chain
+    self.class.full_chain
   end
 end

data/lib/kicker/recipes/could_not_handle_file.rb

@@ -1,7 +1,5 @@
-class Kicker
-  COULD_NOT_HANDLE_CALLBACK = lambda do |kicker, files|
-    kicker.log("Could not handle: #{files.join(', ')}")
-  end
-  
-  self.callback = COULD_NOT_HANDLE_CALLBACK
+Kicker.post_process_callback = lambda do |kicker, files|
+  kicker.log('')
+  kicker.log("Could not handle: #{files.join(', ')}")
+  kicker.log('')
 end

data/lib/kicker/recipes/execute_cli_command.rb

@@ -1,7 +1,5 @@
-class Kicker
-  option_parser.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
-    Kicker.callback = lambda do |kicker, _|
-      kicker.execute_command "sh -c #{command.inspect}"
-    end
+Kicker.option_parser.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
+  Kicker.process_callback = lambda do |kicker, _|
+    kicker.execute_command "sh -c #{command.inspect}"
   end
 end

data/lib/kicker/utils.rb

@@ -1,7 +1,7 @@
 class Kicker
   def execute_command(command)
-    log "Change occured. Executing command:"
-    growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command') if @use_growl
+    log "Change occured, executing command: #{command}"
+    growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', command) if @use_growl
     
     output = `#{command}`
     output.strip.split("\n").each { |line| log "  #{line}" }

data/lib/kicker/validate.rb

@@ -7,7 +7,7 @@ class Kicker
   end
   
   def validate_paths_and_command!
-    if callback_chain.length == 1
+    if process_chain.empty?
       puts OPTION_PARSER_CALLBACK.call(nil).help
       exit
     end

data/test/callback_chain_test.rb

@@ -1,18 +1,53 @@
 require File.expand_path('../test_helper', __FILE__)
 
-describe "Kicker, concerning its callback chain" do
-  it "should return the callback chain instance" do
-    Kicker.callback_chain.should.be.instance_of Kicker::CallbackChain
+describe "Kicker, concerning its callback chains" do
+  before do
+    @chains = [:pre_process_chain, :process_chain, :post_process_chain, :full_chain]
   end
   
-  it "should provide a shortcut method which prepends a callback" do
-    Kicker.callback = lambda { :from_callback }
-    Kicker.callback_chain.first.call.should == :from_callback
+  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({})
-    kicker.callback_chain.should.be Kicker.callback_chain
+    
+    @chains.each do |chain|
+      kicker.send(chain).should.be 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
+    
+    Kicker.pre_process_callback = lambda { :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
+    
+    Kicker.process_callback = lambda { :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
+    
+    Kicker.post_process_callback = lambda { :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
 
@@ -45,7 +80,7 @@ describe "An instance of Kicker::CallbackChain, concerning it's API" do
   end
 end
 
-describe "An instance of Kicker::CallbackChain, when running the chain" do
+describe "An instance of Kicker::CallbackChain, when calling the chain" do
   before do
     @kicker = Kicker.new({})
     
@@ -56,48 +91,69 @@ describe "An instance of Kicker::CallbackChain, when running the chain" do
   it "should call the callbacks from first to last" do
     @chain.append_callback lambda { @result << 1 }
     @chain.append_callback lambda { @result << 2 }
-    @chain.run(@kicker, [])
+    @chain.call(@kicker, %w{ file })
     @result.should == [1, 2]
   end
   
   it "should pass in the Kicker instance with each yield" do
     kicker = nil
     @chain.append_callback lambda { |x, _| kicker = x }
-    @chain.run(@kicker, [])
+    @chain.call(@kicker, %w{ file })
     kicker.should.be @kicker
   end
   
-  it "should pass the files array given to run to the first callback and pass the result array of that call to the next callback and so on" do
+  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|
-      @result.concat(files)
-      %w{ /file/3 /file/4 }
+      files.should.be array
+      files.concat(%w{ /file/2 })
     }
     
     @chain.append_callback lambda { |_, files|
+      files.should.be array
       @result.concat(files)
-      []
     }
     
-    @chain.run(@kicker, %w{ /file/1 /file/2 })
-    @result.should == %w{ /file/1 /file/2 /file/3 /file/4 }
+    @chain.call(@kicker, array)
+    @result.should == %w{ /file/1 /file/2 }
   end
   
-  it "should halt the callback chain once an empty array is returned from a callback" do
-    @chain.append_callback lambda { @result << 1; [] }
-    @chain.append_callback lambda { @result << 2 }
-    @chain.run(@kicker, %w{ /file/1 /file/2 })
+  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(@kicker, %w{ /file/1 /file/2 })
     @result.should == [1]
   end
   
-  it "should halt the callback chain if not an Array instance is returned from a callback" do
-    [nil, false, ''].each do |object|
-      @chain.clear
-      @result.clear
-      
-      @chain.append_callback lambda { @result << 1; object }
-      @chain.append_callback lambda { @result << 2 }
-      @chain.run(@kicker, %w{ /file/1 /file/2 })
-      @result.should == [1]
+  it "should not call any callback if the given array is empty" do
+    @chain.append_callback lambda { |_, files| @result << 1 }
+    @chain.call(@kicker, [])
+    @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 { |*args| kicker_and_files.call(*args); @result << 1 },
+      lambda { |*args| kicker_and_files.call(*args); @result << 2 }
+    ])
+    
+    chain2 = Kicker::CallbackChain.new([
+      lambda { |*args| kicker_and_files.call(*args); @result << 3 },
+      lambda { |*args| kicker_and_files.call(*args); @result << 4 }
+    ])
+    
+    @chain.append_callback chain1
+    @chain.append_callback chain2
+    
+    @chain.call(@kicker, array)
+    @result.should == [1, 2, 3, 4]
   end
 end

data/test/filesystem_change_test.rb

@@ -40,20 +40,20 @@ describe "Kicker, when a change occurs" do
     @kicker.send(:changed_files, events).should == [file1, file3]
   end
   
-  it "should run the callback chain with all changed files" do
+  it "should call the full_chain with all changed files" do
     files = %w{ /file/1 /file/2 }
     events = [event('/file/1'), event('/file/2')]
     
     @kicker.expects(:changed_files).with(events).returns(files)
-    @kicker.callback_chain.expects(:run).with(@kicker, files)
+    @kicker.full_chain.expects(:call).with(@kicker, files)
     @kicker.expects(:finished_processing!)
     
     @kicker.send(:process, events)
   end
   
-  it "should not run the callback chain if there were no changed files" do
+  it "should not call the full_chain if there were no changed files" do
     @kicker.stubs(:changed_files).returns([])
-    @kicker.callback_chain.expects(:run).never
+    @kicker.full_chain.expects(:call).never
     @kicker.expects(:finished_processing!).never
     
     @kicker.send(:process, [event()])

data/test/initialization_test.rb

@@ -51,9 +51,9 @@ describe "Kicker, when starting" do
     OSX.stubs(:CFRunLoopRun)
   end
   
-  it "should show the usage banner and exit when there is no extra callback defined" do
+  it "should show the usage banner and exit when there is no process_callback defined at all" do
     @kicker.stubs(:validate_paths_exist!)
-    Kicker.stubs(:callback_chain).returns([1])
+    Kicker.stubs(:process_chain).returns([])
     
     Kicker::OPTION_PARSER_CALLBACK.stubs(:call).returns(mock('OptionParser', :help => 'help'))
     @kicker.expects(:puts).with("help")

data/test/recipes/could_not_handle_file_test.rb

@@ -3,7 +3,11 @@ require File.expand_path('../../test_helper', __FILE__)
 describe "Kicker, concerning the default `could not handle file' callback" do
   it "should log that it could not handle the given files" do
     kicker = Kicker.new({})
+    
+    kicker.expects(:log).with('')
     kicker.expects(:log).with("Could not handle: /file/1, /file/2")
-    Kicker.callback_chain.last.call(kicker, %w{ /file/1 /file/2 })
+    kicker.expects(:log).with('')
+    
+    Kicker.post_process_chain.last.call(kicker, %w{ /file/1 /file/2 })
   end
 end

data/test/recipes/execute_cli_command_test.rb

@@ -2,19 +2,19 @@ require File.expand_path('../../test_helper', __FILE__)
 
 describe "Kicker, concerning the `execute a command-line' callback" do
   it "should parse the command and add the callback" do
-    before = Kicker.callback_chain.length
+    before = Kicker.process_chain.length
     
     Kicker.parse_options(%w{ -e ls })
-    Kicker.callback_chain.length.should == before + 1
+    Kicker.process_chain.length.should == before + 1
     
     Kicker.parse_options(%w{ --execute ls })
-    Kicker.callback_chain.length.should == before + 2
+    Kicker.process_chain.length.should == before + 2
   end
   
   it "should call execute_command with the given command" do
     Kicker.parse_options(%w{ -e ls })
     
-    callback = Kicker.callback_chain.first
+    callback = Kicker.process_chain.last
     callback.should.be.instance_of Proc
     
     kicker = Kicker.new({})

data/test/utils_test.rb

@@ -17,19 +17,19 @@ describe "A Kicker instance, concerning its utility methods" do
   it "should log the output of the command indented by 2 spaces and whether or not the command succeeded" do
     @kicker.stubs(:`).returns("line 1\nline 2")
     
-    @kicker.expects(:log).with('Change occured. Executing command:')
+    @kicker.expects(:log).with('Change occured, executing command: ls')
     @kicker.expects(:log).with('  line 1')
     @kicker.expects(:log).with('  line 2')
     @kicker.expects(:log).with('Command succeeded')
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
     
     @kicker.stubs(:last_command_succeeded?).returns(false)
     @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:log).with('Change occured. Executing command:')
+    @kicker.expects(:log).with('Change occured, executing command: ls')
     @kicker.expects(:log).with('  line 1')
     @kicker.expects(:log).with('  line 2')
     @kicker.expects(:log).with('Command failed (123)')
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
   end
   
   it "should send the Growl messages with the default click callback" do
@@ -40,15 +40,15 @@ describe "A Kicker instance, concerning its utility methods" do
     
     OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(2)
     
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
     @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
     
     @kicker.stubs(:last_command_succeeded?).returns(false)
     @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
     @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
   end
   
   it "should send the Growl messages with a click callback which executes the specified growl command when succeeded" do
@@ -61,14 +61,14 @@ describe "A Kicker instance, concerning its utility methods" do
     @kicker.expects(:system).with('ls -l').times(1)
     OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(1)
     
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
     @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
     
     @kicker.stubs(:last_command_succeeded?).returns(false)
     @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
     @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
-    @kicker.execute_command('')
+    @kicker.execute_command('ls')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: alloy-kicker
 version: !ruby/object:Gem::Version 
-  version: 1.9.0
+  version: 1.9.1
 platform: ruby
 authors: 
 - Eloy Duran
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-25 00:00:00 -07:00
+date: 2009-06-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
+- TODO.rdoc
 - VERSION.yml
 - bin/kicker
 - lib/kicker.rb