kicker 3.0.0 → 4.0.0.p1

data/lib/kicker/recipes/could_not_handle_file.rb

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

data/lib/kicker/recipes/dot_kick.rb

@@ -1,47 +0,0 @@
-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)
-      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!
-      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
-
-if ReloadDotKick.use?
-  startup do
-    pre_process ReloadDotKick
-    ReloadDotKick.save_state
-    ReloadDotKick.load!
-  end
-end

data/lib/kicker/recipes/execute_cli_command.rb

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

data/lib/kicker/recipes/ignore.rb

@@ -1,41 +0,0 @@
-# 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
-
-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,10 +0,0 @@
-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
-end

data/lib/kicker/recipes/rails.rb

@@ -1,109 +0,0 @@
-recipe :ruby
-
-class Kicker::Recipes::Rails < Kicker::Recipes::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) { Kicker::Recipes::Ruby.send(delegate) }
-    end
-
-    # 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
-      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/#{ActiveSupport::Inflector.singularize(model)}
-        unit/helpers/#{ActiveSupport::Inflector.pluralize(model)}_helper
-        functional/#{ActiveSupport::Inflector.pluralize(model)}_controller
-      }
-    else
-      %W{
-        models/#{ActiveSupport::Inflector.singularize(model)}
-        helpers/#{ActiveSupport::Inflector.pluralize(model)}_helper
-        controllers/#{ActiveSupport::Inflector.pluralize(model)}_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'
-        Kicker::Recipes::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 = Kicker::Recipes::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/inflector'
-
-  process Kicker::Recipes::Rails
-
-  # When changing the schema, prepare the test database.
-  process do |files|
-    execute 'rake db:test:prepare' if files.delete('db/schema.rb')
-  end
-end

data/lib/kicker/utils.rb

@@ -1,127 +0,0 @@
-require 'shellwords' if RUBY_VERSION >= "1.9"
-
-class Kicker
-  module Utils #:nodoc:
-    extend self
-
-    attr_accessor :should_clear_screen
-    alias_method :should_clear_screen?, :should_clear_screen
-
-    def perform_work(command_or_options)
-      if command_or_options.is_a?(Hash)
-        options = command_or_options
-      elsif command_or_options.is_a?(String)
-        options = { :command => command_or_options }
-      else
-        raise ArgumentError, "Should be a string or a hash."
-      end
-      job = Job.new(options)
-      will_execute_command(job)
-      yield job
-      did_execute_command(job)
-      job
-    end
-
-    def execute(command_or_options)
-      perform_work(command_or_options) do |job|
-        _execute(job)
-        yield job if block_given?
-      end
-    end
-
-    def log(message)
-      if Kicker.quiet
-        puts message
-      else
-        now = Time.now
-        puts "#{now.strftime('%H:%M:%S')}.#{now.usec.to_s[0,2]} | #{message}"
-      end
-    end
-
-    def clear_console!
-      puts(CLEAR) if Kicker.clear_console?
-    end
-
-    private
-
-    CLEAR = "\e[H\e[2J"
-
-    def _execute(job)
-      silent = Kicker.silent?
-      unless silent
-        puts
-        sync_before, $stdout.sync = $stdout.sync, true
-      end
-      output = ""
-      popen(job.command) do |io|
-        while str = io.read(1)
-          output << str
-          $stdout.print str unless silent
-        end
-      end
-      job.output = output.strip
-      job.exit_code = $?.exitstatus
-      job
-    ensure
-      unless silent
-        $stdout.sync = sync_before
-        puts("\n\n")
-      end
-    end
-
-    def popen(command, &block)
-      if RUBY_VERSION >= "1.9"
-        args = Shellwords.shellsplit(command)
-        args << { :err => [:child, :out] }
-        IO.popen(args, &block)
-      else
-        IO.popen("#{command} 2>&1", &block)
-      end
-    end
-
-    def will_execute_command(job)
-      puts(CLEAR) if Kicker.clear_console? && should_clear_screen?
-      @should_clear_screen = false
-
-      if message = job.print_before
-        log(message)
-      end
-
-      if notification = job.notify_before
-        Notification.notify(notification)
-      end
-    end
-
-    def did_execute_command(job)
-      if message = job.print_after
-        puts(message)
-      end
-
-      log(job.success? ? "Success" : "Failed (#{job.exit_code})")
-
-      if notification = job.notify_after
-        Notification.notify(notification)
-      end
-    end
-  end
-end
-
-module Kernel
-  # Prints a +message+ with timestamp to stdout.
-  def log(message)
-    Kicker::Utils.log(message)
-  end
-
-  # When you perform some work (like shelling out a command to run without
-  # using +execute+) you need to call this method, with a block in which you
-  # perform your work, which will take care of logging the work appropriately.
-  def perform_work(command, &block)
-    Kicker::Utils.perform_work(command, &block)
-  end
-
-  # Executes the +command+, logs the output, and optionally sends user
-  # notifications on Mac OS X (10.8 or higher).
-  def execute(command, &block)
-    Kicker::Utils.execute(command, &block)
-  end
-end