spec_run_queue 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in spec_run_queue.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,44 @@
+WHAT
+====
+
+spec_run_queue lets you build a lightweight queue watcher to watch for commands to run specs for your project.
+
+On projects with a slow test suite, I don't like waiting for an autotest-like setup to complete a full spec run of a file.  Also, I don't like watching my editor lock up waiting for a spec run to finish.
+
+My development flow on such files tends to be 1) write a new spec example 2) run a focused example 3) repeat a few times 4) run the full spec
+
+The runner works by doing a blocking queue read, until it receives a YAML dump of a hash like
+
+    { :target => "spec/models/foo_spec.rb"  }
+
+or
+
+    { :target => "spec/models/bar_spec.rb", :line => 42 }
+
+and then runs the command, via backticks, in the shell.  Summary results from the run are sent to the Notifier#notify method for notifiers you have setup.
+
+NOTIFIERS
+=========
+
+Notifiers must provide at least one instane method, <tt>notify</tt>, which processes the output from the spec run.  Currently, there are two runners, Stdout, and Growl.  Stdout prints the results from the run to the terminal window, while growl sends a brief pass/fail summary to growl.
+
+
+USAGE
+=====
+
+In your project root, run
+
+    redis_runner [1|2]
+
+where 1 or 2 indicates the major version of rspec you are using for the project.
+
+
+In order to trigger a queue run, you need your editor to insert a YAML dump of the instructions described above to the queue.
+
+
+TODO
+====
+
+* Genericify and configure the runner
+* Include code or a plugin for the vim script I'm using to inject instructions into the queue
+* Investigate a custom rspec runner in place of the current shell execution method

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/redis_runner

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+#TODO make this more generic and configurable
+
+require 'spec_run_queue'
+require 'spec_run_queue/queue/redis'
+require 'spec_run_queue/notifier/growl'
+require 'spec_run_queue/notifier/stdout'
+
+rspec_major_version = ARGV.shift
+unless rspec_major_version
+  $stderr.puts "please specify 1 or 2 for rspec version"
+  exit -1
+end
+
+runner = SpecRunQueue::SystemRunner.new(rspec_major_version)
+runner.add_notifier SpecRunQueue::Notifier::Growl.new(:password => "gr0wl")
+runner.add_notifier SpecRunQueue::Notifier::Stdout.new()
+
+queue = SpecRunQueue::Queue::Redis.new(runner)
+queue.run
+

data/lib/spec_run_queue/notifier/base.rb

@@ -0,0 +1,21 @@
+module SpecRunQueue
+  module Notifier
+    class Base
+      attr_reader :config, :message
+
+      def initialize(config = {})
+        @config = config
+      end    
+
+      def notify(message, options = {})
+        @message = message
+      end
+
+      private
+
+      def failed?
+        message !~ /\s+0\s+failure/
+      end
+    end
+  end
+end

data/lib/spec_run_queue/notifier/growl.rb

@@ -0,0 +1,37 @@
+module SpecRunQueue
+  module Notifier
+    class Growl < Base
+      def notify(message, options = {})
+        super
+        message = options[:use_full_message] ? message : short_message
+        growl.notify "rspec-growl Notification", "rspec-growl", message, priority
+      end
+
+      private
+
+      def priority
+        failed? ? fail_priority : pass_priority
+      end
+
+      def fail_priority
+        config[:fail_priority] || 1
+      end
+
+      def pass_priority
+        config[:pass_priority] || -2 
+      end
+
+      def growl
+        @growl ||= Growl.new "127.0.0.1", "rspec-growl", ["rspec-growl Notification"], nil, config[:password]
+      end
+
+      def short_message
+        if message =~ /0 failure/
+          "specs passed"
+        elsif message =~ /(\d+\s+failures?)/
+          $1
+        end
+      end
+    end
+  end
+end

data/lib/spec_run_queue/notifier/stdout.rb

@@ -0,0 +1,10 @@
+module SpecRunQueue
+  module Notifier
+    class Stdout < Base
+      def notify(message, options = {})
+        super
+        puts message
+      end
+    end
+  end
+end

data/lib/spec_run_queue/queue/base.rb

@@ -0,0 +1,35 @@
+module SpecRunQueue
+  module Queue
+    class Base
+      attr_reader :runner
+
+      def initialize(runner)
+        @runner = runner
+        connect
+        reset_queue
+      end
+
+      def run
+        while (raw_instruction = queue_fetch)
+          instruction = YAML.load(raw_instruction[1])
+          runner.run_spec(instruction)
+        end
+      end
+
+      private
+
+      def connect
+        raise "Abstract method"
+      end
+
+      def reset_queue
+        raise "Abstract method"
+      end
+
+      def queue_fetch
+        raise "Abstract method"
+      end
+    end
+  end
+end
+

data/lib/spec_run_queue/queue/redis.rb

@@ -0,0 +1,27 @@
+require 'redis'
+
+module SpecRunQueue
+  module Queue
+    class Redis < Base
+      attr_reader :redis
+
+      def self.queue_key
+        "rspec" 
+      end
+
+      private
+
+      def connect
+        @redis = ::Redis.new
+      end
+
+      def reset_queue
+        redis.del self.class.queue_key
+      end
+
+      def queue_fetch
+        redis.blpop self.class.queue_key, 0 
+      end
+    end
+  end
+end

data/lib/spec_run_queue/system_runner.rb

@@ -0,0 +1,64 @@
+module SpecRunQueue
+  class SystemRunner
+    attr_reader :version, :options, :notifiers
+
+    def initialize(version, options = {})
+      @version = version.to_i
+      @options = options
+    end
+
+    def rspec_bin
+      if version == 1
+        options[:spec_bin] || "spec"
+      elsif version == 2
+        options[:rspec_bin] || "rspec"
+      else
+        raise "Couldn't determine rspec bin'"
+      end
+    end
+
+    def add_notifier(notifier)
+      @notifiers ||= []
+      @notifiers << notifier
+    end
+
+    def run_spec(instruction)
+      unless sane_instruction?(instruction)
+        $stderr.puts "Insane instruction #{instruction.inspect}"
+        return
+      end
+
+      begin
+        cmd = "#{rspec_bin} -f progress --drb" 
+        cmd << " -l #{instruction[:line]}" if instruction[:line]
+        cmd << " #{instruction[:target]}"
+        output = run_cmd(cmd)
+
+        output_to_notifiers(output)
+      rescue => e
+        shutdown_message = "Exception #{e.class} occurred, shutting down"
+        output_to_notifiers(shutdown_message, :use_full_message => true)
+        sleep(1)
+        raise e
+      end
+    end
+
+    private
+
+    def run_cmd(cmd)
+      `#{cmd}`
+    end
+
+    def output_to_notifiers(output, options = {})
+      notifiers.each do |notifier|
+        notifier.notify(output, options)
+      end
+    end
+
+    def sane_instruction?(instruction)
+      # Line must be numeric or nil, and the target must be a path to a spec file
+      (instruction[:line].nil? || instruction[:line].to_s =~ /^\d+$/) && 
+        (instruction[:target] =~ /^[a-z0-9_\-\/]+_spec\.rb$/)
+    end
+  end
+end

data/lib/spec_run_queue/version.rb

@@ -0,0 +1,3 @@
+module SpecRunQueue
+  VERSION = "0.0.1"
+end

data/lib/spec_run_queue.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'yaml'
+require 'ruby-growl'
+
+module SpecRunQueue
+end
+
+require 'spec_run_queue/queue/base'
+require 'spec_run_queue/notifier/base'
+require 'spec_run_queue/system_runner'

data/spec/notifier/base_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class FooNotifier < SpecRunQueue::Notifier::Base
+  def notify(message, options = {})
+    super
+    some_callout unless failed?
+  end
+
+  def some_callout
+  end
+end
+
+describe "Base" do
+  let(:notifier) { @notifier ||= FooNotifier.new() }
+
+  before(:each) do
+    @foo_notifier = FooNotifier.new
+  end
+  
+  it "should store the config" do
+    config = { :foo => :bar }
+    notifier = FooNotifier.new(config)
+    notifier.config.should == config
+  end
+
+  it "should be considered failed if the message doesn't match '0 failure'" do
+    notifier.should_not_receive(:some_callout)
+    notifier.notify('13 examples, 2 failures')
+  end
+
+  it "should not be consider failed if the message doesn't match '0 failure'" do
+    notifier.should_receive(:some_callout)
+    notifier.notify('13 examples, 0 failures')
+  end
+
+  describe "notify" do
+    it "should assign the message" do
+      message = '13 examples, 0 failures'
+      notifier.notify(message)
+      notifier.message.should == message
+    end
+  end
+end

data/spec/notifier/growl_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'spec_run_queue/notifier/growl'
+
+describe SpecRunQueue::Notifier::Growl do
+  before(:each) do
+    @message = "13 examples, 0 failures"
+    @fail_message = "12 examples, 1 failure"
+    @growl_mock = mock("Growl", :notify => true)
+    @notifier = SpecRunQueue::Notifier::Growl.new(:password => "secret")
+    @notifier.stub!(:growl).and_return(@growl_mock)
+  end
+
+  describe "notify" do
+    it "should assign the message" do
+      @notifier.notify(@message)
+      @notifier.message.should == @message
+    end
+
+    context "with a failure message" do
+      it "should send growl the expected message" do
+        @growl_mock.should_receive(:notify).with('rspec-growl Notification', 'rspec-growl', '1 failure', 1)
+        @notifier.notify(@fail_message)
+      end
+    end
+
+    context "with a passing message" do
+      it "should send growl the expected message" do
+        @growl_mock.should_receive(:notify).with('rspec-growl Notification', 'rspec-growl', 'specs passed', -2)
+        @notifier.notify(@message)
+      end
+    end
+
+    context "when instruction to use the full message" do
+      it "should send growl the full message" do
+        @growl_mock.should_receive(:notify).with('rspec-growl Notification', 'rspec-growl', 'the full message', 1)
+        @notifier.notify("the full message", :use_full_message => true)
+      end
+    end
+  end
+end

data/spec/notifier/stdout_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'spec_run_queue/notifier/stdout'
+
+describe SpecRunQueue::Notifier::Stdout do
+  before(:each) do
+    @message = "spec message"
+    @notifier = SpecRunQueue::Notifier::Stdout.new 
+  end
+
+  describe "notify" do
+
+    it "should assign the message" do
+      @notifier.notify(@message)
+      @notifier.message.should == @message
+    end
+
+    it "should puts the message" do
+      @notifier.should_receive(:puts).with(@message)
+      @notifier.notify(@message)
+    end
+  end
+end

data/spec/queue/base_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+class SpecBase < SpecRunQueue::Queue::Base
+  attr_accessor :connect_called, :reset_queue_called
+
+  def connect
+    self.connect_called = true
+  end
+
+  def reset_queue
+    self.reset_queue_called = true
+  end
+end
+
+describe "Base" do
+  let(:runner) { @runner ||= mock("Runner", :run_spec => true) }
+  let(:spec_base) { @spec_base ||= SpecBase.new(runner) }
+
+  describe "initilization" do
+    it "should set the runner" do
+      spec_base.runner.should == runner
+    end
+
+    it "should call to connect" do
+      spec_base.connect_called.should be_true
+    end
+
+    it "should reset the queue" do
+      spec_base.reset_queue_called.should be_true
+    end
+  end
+
+  describe "running of the queue" do
+    before(:each) do
+      @first_raw_instruction = YAML.dump({ :target => "foo_spec.rb" })
+      @second_raw_instruction = YAML.dump({ :target => "bar_spec.rb", :line => 42 })
+    end
+
+    it "should fetch raw instructions from the queue" do
+      spec_base.should_receive(:queue_fetch).and_return(nil)
+      spec_base.run
+    end
+
+    it "should parse each raw instruction as yaml" do
+      spec_base.stub!(:queue_fetch).and_return(["rspec", @first_raw_instruction], ["rspec", @second_raw_instruction], nil)
+      YAML.should_receive(:load).with(@first_raw_instruction).ordered
+      YAML.should_receive(:load).with(@second_raw_instruction).ordered
+      spec_base.run
+    end
+
+    it "should pass the parsed instruction to runner.run_spec" do
+      spec_base.stub!(:queue_fetch).and_return(["rspec", @first_raw_instruction], ["rspec", @second_raw_instruction], nil)
+      runner.should_receive(:run_spec).with({ :target => "foo_spec.rb" }).ordered
+      runner.should_receive(:run_spec).with({ :target => "bar_spec.rb", :line => 42 }).ordered
+      spec_base.run
+    end
+  end
+end
+

data/spec/queue/redis_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'spec_run_queue/queue/redis'
+
+describe SpecRunQueue::Queue::Redis do
+  before(:each) do
+    @redis_mock = mock("Redis", :del => true, :blpop => true)
+    ::Redis.stub!(:new).and_return(@redis_mock)
+    @runner_mock = mock("Runner")
+    @redis_queue = SpecRunQueue::Queue::Redis.new(@runner_mock)
+  end
+
+  it "should have 'rspec' as the key" do
+    SpecRunQueue::Queue::Redis.queue_key.should == "rspec"
+  end
+
+  it "should reset the queue by deleting the queue key" do
+    @redis_mock.should_receive(:del).with("rspec")
+    SpecRunQueue::Queue::Redis.new(@runner_mock)
+  end
+
+  it "should blpop instructions off the redis queue" do
+    @redis_mock.should_receive(:blpop).with("rspec", 0).and_return(nil)
+    @redis_queue.run
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "spec_run_queue"

data/spec/system_runner_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe SpecRunQueue::SystemRunner do
+  let(:foo_notifier) { @foo_notifier ||= mock("FooNotifier", :notify => true) }
+  let(:bar_notifier) { @bar_notifier ||= mock("BarNotifier", :notify => true) }
+  let(:runner) { @runner ||= 
+    begin
+      runner = SpecRunQueue::SystemRunner.new(1)
+      runner.add_notifier(foo_notifier)
+      runner.add_notifier(bar_notifier)
+      runner 
+    end
+  }
+
+  describe "initializing" do
+    it "should set the version" do
+      runner = SpecRunQueue::SystemRunner.new(1, { :password => "foo" })
+      runner.version.should == 1
+    end
+
+    it "should set the options" do
+      runner = SpecRunQueue::SystemRunner.new(1, { :password => "foo" })
+      runner.options.should == { :password => "foo" }
+    end
+  end
+  
+  describe "getting the rspec binary" do
+    it "for version 1 is spec by default" do
+      runner = SpecRunQueue::SystemRunner.new(1)
+      runner.rspec_bin.should == "spec"
+    end
+
+    it "for varsion 2 is rspec by default" do
+      runner = SpecRunQueue::SystemRunner.new(2)
+      runner.rspec_bin.should == "rspec"
+    end
+  end
+
+  describe "adding a notifier" do
+    it "should append the notifier onto the notifiers list" do
+      runner = SpecRunQueue::SystemRunner.new(1)
+      foo_notifier = mock("FooNotifier")
+      runner.add_notifier(foo_notifier)
+      bar_notifier = mock("BarNotifier")
+      runner.add_notifier(bar_notifier)
+      runner.notifiers.should == [foo_notifier, bar_notifier]
+    end
+  end
+
+  describe "running a spec" do
+    it "should not run a spec if it's not a safe target" do
+      runner.should_not_receive(:run_cmd)
+      runner.run_spec(:target => "ls /tmp")
+      runner.run_spec(:target => "ls /tmp;foo_spec.rb")
+    end
+
+    it "should not run a spec if the target doesn't end in _spec.rb" do
+      runner.should_not_receive(:run_cmd)
+      runner.run_spec(:target => "spec/foo.rb")
+    end
+
+    it "should not run a spec if the line number doesn't look like a number" do
+      runner.should_not_receive(:run_cmd)
+      runner.run_spec(:target => "foo_spec.rb", :line => "foo")
+    end
+
+    it "should call to run the spec" do
+      runner.should_receive(:run_cmd).with("spec -f progress --drb foo_spec.rb")
+      runner.run_spec(:target => "foo_spec.rb")
+    end
+
+    it "should send the output from the run to all the notifiers" do
+      runner.should_receive(:run_cmd).with("spec -f progress --drb foo_spec.rb").and_return("spec output")
+      foo_notifier.should_receive(:notify).with("spec output", {})
+      bar_notifier.should_receive(:notify).with("spec output", {})
+      runner.run_spec(:target => "foo_spec.rb")
+    end
+
+    context "with a line number" do
+     it "should call to run the spec using the -l flag" do
+      runner.should_receive(:run_cmd).with("spec -f progress --drb -l 42 foo_spec.rb")
+      runner.run_spec(:target => "foo_spec.rb", :line => 42)
+     end
+    end
+  end
+end

data/spec_run_queue.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "spec_run_queue/version"
+
+Gem::Specification.new do |s|
+  s.name        = "spec_run_queue"
+  s.version     = SpecRunQueue::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Brendon Murphy"]
+  s.email       = ["xternal1+github@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Use a queue to run specs outside your editor}
+  s.description = %q{Use a queue to run specs outside your editor}
+
+  s.rubyforge_project = "spec_run_queue"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = ["redis_runner"]
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: spec_run_queue
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brendon Murphy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-24 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Use a queue to run specs outside your editor
+email: 
+- xternal1+github@gmail.com
+executables: 
+- redis_runner
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/redis_runner
+- lib/spec_run_queue.rb
+- lib/spec_run_queue/notifier/base.rb
+- lib/spec_run_queue/notifier/growl.rb
+- lib/spec_run_queue/notifier/stdout.rb
+- lib/spec_run_queue/queue/base.rb
+- lib/spec_run_queue/queue/redis.rb
+- lib/spec_run_queue/system_runner.rb
+- lib/spec_run_queue/version.rb
+- spec/notifier/base_spec.rb
+- spec/notifier/growl_spec.rb
+- spec/notifier/stdout_spec.rb
+- spec/queue/base_spec.rb
+- spec/queue/redis_spec.rb
+- spec/spec_helper.rb
+- spec/system_runner_spec.rb
+- spec_run_queue.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: spec_run_queue
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Use a queue to run specs outside your editor
+test_files: 
+- spec/notifier/base_spec.rb
+- spec/notifier/growl_spec.rb
+- spec/notifier/stdout_spec.rb
+- spec/queue/base_spec.rb
+- spec/queue/redis_spec.rb
+- spec/spec_helper.rb
+- spec/system_runner_spec.rb