spackle 0.0.1

data/lib/spackle.rb

@@ -0,0 +1,104 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
+
+require 'spackle/configuration'
+require 'spackle/error'
+require 'spackle/output'
+require 'spackle/spec' if defined? Spec
+require 'spackle/helpers/ruby_project_root'
+
+module Spackle
+  class << self
+    def already_initialized?
+      @already_initialized == true
+    end
+
+    def callback_command
+      Spackle.configuration.callback_command 
+    end
+
+    def configuration
+      @configuration ||= Spackle::Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end    
+
+    def error_formatter_class
+      class_name = configuration.error_formatter.to_s.
+        split("_").collect { |w| w.capitalize }.join
+      begin
+        eval("Spackle::Output::#{class_name}")
+      rescue SyntaxError
+        raise RuntimeError.new("Spackle Error: no configuration for error_formatter_class -- have you configured Spackle with a .spackle file?")
+      rescue NameError
+        raise RuntimeError.new("Spackle Error: Cannot find Spackle::Output::#{class_name} -- have you configured Spackle with a .spackle file?")
+      end
+    end
+
+    def init(options = {})      
+      return if already_initialized?
+
+      @already_initialized = true
+      load_config
+      File.unlink(spackle_file) if File.exists?(spackle_file)
+
+      case options[:with]
+      when :spec_formatter
+        ::Spec::Runner.options.parse_format "Spackle::Spec::SpackleFormatter:/dev/null"
+      end
+    end
+
+    def load_config
+      load_config_from_dotfile 
+    end
+
+    def load_config_from_dotfile
+      config_files = []
+      
+      if ENV['SPACKLE_CONFIG']
+        # SPACKLE_CONFIG is mostly intended for use with the integration tests
+        config_files << File.expand_path(ENV['SPACKLE_CONFIG']) 
+      else
+        config_files << File.expand_path("~/.spackle") 
+
+        project_root = Spackle::Helpers::RubyProjectRoot.search Dir.pwd
+        if project_root
+          config_files << File.join(project_root, ".spackle")
+        end
+      end
+
+      config_files.inject(false) do |config_loaded, file|
+        if File.exists? file
+          load file 
+          config_loaded = true
+        end
+        config_loaded
+      end
+    end
+
+    def spackle_file
+      projectname = Spackle::Helpers::RubyProjectRoot.search Dir.pwd
+      projectname = File.basename(projectname) + ".spackle" if projectname
+      filename = configuration.spackle_file || projectname || "default.spackle"
+
+      File.join(tempdir, filename)      
+    end
+
+    def tempdir
+      configuration.tempdir || '/tmp'
+    end
+
+    def test_finished(errors)
+      return unless configuration.error_formatter
+      File.open( spackle_file, "w", 0600 ) do |f|
+        errors.each do |error|
+          f.write error_formatter_class.format(error)
+        end
+      end
+      system(configuration.callback_command, spackle_file) if configuration.callback_command
+    end
+
+        
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This matcher is necessary because the expected/actual strings look just
+# like bits of regular Ruby backtraces, which apparently is how autotest
+# figures out which files to test. Outputting bits of the backtraces from
+# the testapp's test harness mightily confuses an autotest running Spackle.
+Spec::Matchers.define :have_spackle do |expected|
+  match do |actual|
+    actual.spackle_output == expected
+  end
+
+  def sanitize(str)
+    str.gsub(/_spec.rb/, '_s_p_e_c_dot_r_b')
+  end
+
+  failure_message_for_should do |actual|
+    <<-EOF
+Expected spackles to match, but they didn't! Note that the "expected"
+and "got" below have been transformed so autotest doesn't get confused
+and blow up. See spec/integration_spec.rb for details.
+COMMAND
+#{actual.command}
+EXPECTED:
+#{sanitize expected }
+GOT:
+#{sanitize actual.spackle_output}
+    EOF
+  end
+end
+
+
+if ENV['INTEGRATE_SPACKLE']
+
+  # -- expected spackles --------------------------------------------------- 
+FAILING_WORKING_CLASS = <<EOF  
+./spec/failing_working_class_spec.rb:9: expected false, got true
+EOF
+
+ERROR_RAISER = <<EOF
+./spec/error_raiser_spec.rb:9: an unhandled error
+EOF
+
+MISSING_END = <<EOF
+EOF
+
+METHOD_TYPO = <<EOF
+./spec/method_typo_spec.rb:9: undefined method `sirt' for [3, 1, 2]:Array
+EOF
+  # ------------------------------------------------------------------------
+
+  DOT_SPACKLE = '/tmp/dot_spackle'
+
+  describe "integration" do
+    before do
+      @harness = TestAppHelper::Spec.new
+    end
+
+
+    it "running passing_working_class should return no output" do
+      @harness.run(:passing_working_class)
+      @harness.spackle_output.should be_empty
+    end
+
+    it "running failing_working_class should return a spackle" do
+      @harness.run(:failing_working_class)
+      @harness.should have_spackle(FAILING_WORKING_CLASS)
+    end
+
+    it "running error_raiser should return a spackle" do
+      @harness.run(:error_raiser)
+      @harness.should have_spackle(ERROR_RAISER)
+    end
+
+    it "running missing_end should return a spackle" do
+      @harness.run(:missing_end)
+      @harness.spackle_output.should be_empty
+    end
+
+    it "running method_typo should return a spackle" do
+      @harness.run(:method_typo)
+      @harness.should have_spackle(METHOD_TYPO)
+    end
+  end
+end

data/spec/spackle/commandline_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'spackle/commandline'
+module Spackle
+  describe Commandline do
+    describe "--install option" do
+      before do
+        Commandline.stub! :show_error
+      end
+
+      it "should call install with the argument" do
+        Commandline.should_receive(:install).with("foo")
+        result = Commandline.parse(%w(--install foo))
+      end
+
+      it "should return 1 and output an error if the argument is unrecognized" do
+        lambda {
+          Commandline.parse(%w(--install foo)).should == 1
+        }.should raise_error(RuntimeError, /unrecognized/i)
+      end
+
+      describe "for vim" do
+        it "should copy the plugin" do
+          Commandline.should_receive(:puts)
+          FileUtils.should_receive(:copy).with(/spackle.vim$/, /plugin$/)
+          Commandline.parse %w(--install vim)
+        end
+
+        it "should raise an error if the destination dir doesn't exist" do
+          File.stub! :directory? => false
+          lambda {
+            Commandline.parse %w(--install vim) 
+          }.should raise_error(RuntimeError, /directory/)
+        end
+      end
+
+      it "should raise an error if it receives unrecognized options" do
+        lambda {
+          Commandline.parse %w(something unexpected)
+        }.should raise_error
+      end
+
+
+
+    end
+  end
+
+end

data/spec/spackle/configuration_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Spackle
+  describe Configuration do
+    before do
+      @subject = Spackle::Configuration.new
+    end
+
+    it { should respond_to(:callback_command=) }
+    it { should respond_to(:callback_command) }
+    it { should respond_to(:tempdir=) }
+    it { should respond_to(:tempdir) }
+    it { should respond_to(:error_formatter=) }
+    it { should respond_to(:error_formatter) }
+    it { should respond_to(:spackle_file=) }
+    it { should respond_to(:spackle_file) }
+
+    it { should respond_to(:set_defaults_for) }
+
+    it "should raise an error if defaults_for receives an unrecognized argument" do
+      lambda {
+        @subject.set_defaults_for :something_invalid
+      }.should raise_error(ArgumentError)
+    end
+
+    describe "defaults for vim" do
+      before do
+        @subject.set_defaults_for :vim
+      end
+
+      it "should set the editor to spackle-vim-load-quickfix" do
+        @subject.callback_command.should == "spackle-vim-load-quickfix"
+      end
+
+      it "should set the error formatter to :vim_quickfix" do
+        @subject.error_formatter.should == :vim_quickfix
+      end
+    end
+
+
+  end
+end
+

data/spec/spackle/error_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Spackle
+  describe Error do
+    before do
+      @subject = Error.new("message")
+    end
+
+    it "should store the message" do
+      @subject.message.should == "message"
+    end
+
+    it "should have an empty backtrace" do
+      @subject.backtrace.should be_empty
+    end
+
+    it "should allow adding errors by file and line" do
+      file = "foo/bar/baz.rb"
+      line = 123
+      @subject.add_error file, line
+      @subject.backtrace.should have(1).errors
+      @subject.backtrace.first.file.should == file
+      @subject.backtrace.first.line.should == line
+    end
+
+    it "should allow adding errors using a block" do
+      @subject = Error.new("message") do |e|
+        e.add_error "foo/bar", 12
+        e.add_error "bubba/flubba", 23
+      end
+      @subject.backtrace.should have(2).errors
+    end
+  end
+end

data/spec/spackle/output/base_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Spackle::Output
+  describe Base do
+    before do
+      @error = spackle_error_fixture
+    end
+
+    describe "instance" do
+      before do
+        @subject = Base.new spackle_error_fixture
+      end
+
+      it "should call format_backtrace_line" do
+        line_count = spackle_error_fixture.backtrace.size
+        @subject.should_receive(:format_backtrace_line).exactly(line_count).times
+        @subject.format
+      end
+
+      it "should return the formatted output" do
+        @subject.stub!(:format_backtrace_line).and_return("foo")
+        @subject.format.should == "foo\n" * 3
+      end
+    end
+
+    describe "instantiating" do
+      it "should use Spackle's default error if none specified" do
+        Spackle.should_receive(:current_error).and_return(@error)
+        Base.new.error.should == @error
+      end
+    end
+
+    describe "#format class method" do
+      before do
+        @instance = mock("instance")
+      end
+
+      it "should initialize and return formatted lines" do
+        Base.should_receive(:new).with(@error).and_return(@instance)
+        @instance.should_receive :format
+        Base.format @error
+      end
+
+      it "should use Spackle's default error if none specified" do
+        Base.should_receive(:new).with(@error).and_return(@instance)
+        Spackle.should_receive(:current_error).and_return(@error)
+        @instance.stub!(:format)
+        Base.format
+      end
+    end
+  end
+end
+

data/spec/spackle/output/vim_quickfix_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Spackle::Output
+  describe VimQuickfix do
+    before do
+      Spackle.stub!(:current_error)
+    end
+    it "should format errors in 'path:line: message' format" do
+      VimQuickfix.new.format_backtrace_line("message", "file", "123").should == "file:123: message"
+    end
+
+    it "should strip newlines from messages" do
+      VimQuickfix.new.format_backtrace_line("many\nlines", "ignore", "ignore").should_not match(/\n/)
+    end
+
+    it "should integrate with Base and return a nice quickfix!" do
+      VimQuickfix.format( spackle_error_fixture ).should  == <<-EOF
+/clutzy/child/waving/arms:1: CATASTROPHE: the milk was spilled! Begin crying? [Y/n]
+/cupboard/shelf/glass:350: CATASTROPHE: the milk was spilled! Begin crying? [Y/n]
+/fridge/shelf/jug/milk:4: CATASTROPHE: the milk was spilled! Begin crying? [Y/n]
+      EOF
+    end
+  end
+end
+

data/spec/spackle/spec/base_formatter_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+module Spackle::Spec
+  describe BaseFormatter do
+    it "should initialize errors to an empty array" do
+      BaseFormatter.new(nil,nil).errors.should == []
+    end
+    
+    it "should notify Spackle of the finished test along with the errors on close" do
+      Spackle.should_receive(:test_finished).with([])
+      BaseFormatter.new(nil,nil).close
+    end
+  end
+end
+

data/spec/spackle/spec/spackle_formatter_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+module Spackle::Spec
+  describe SpackleFormatter do
+    before do      
+      @output = StringIO.new
+      @subject = SpackleFormatter.new({}, @output) 
+    end
+
+    describe "example_failed" do
+      before do
+        @error = mock("error", :add_error => nil)
+        Spackle::Error.stub!(:new).and_return @error
+
+        Spackle.stub!(:format_error)
+
+        @exception = mock "exception", {
+          :message => "a message",
+          :backtrace => [ 
+            "some/path/to/file:123",
+            "another/path/to/file:345"
+          ]
+        }
+        @failure = mock "failure", { :exception => @exception }
+      end
+
+      def example_failed
+        @subject.example_failed("example", "counter", @failure)
+      end
+
+      it "should create an error with the message" do
+        Spackle::Error.should_receive(:new).with("a message").and_return(@error)
+        example_failed
+      end
+
+      it "should add two entries to the error" do
+        @error.should_receive(:add_error).exactly(2).times
+        example_failed
+      end
+      
+      it "should add errors by file and line number" do
+        @error.should_receive(:add_error) do |file, line|
+          correct_args =
+            (file == "some/path/to/file" && line = "123") ||
+            (file == "another/path/to/file" && line = "345")
+          correct_args.should be_true
+        end
+        example_failed
+      end
+
+      it "should append the to the errors format" do
+        example_failed
+        @subject.errors.last.should == @error
+      end
+    end
+  end
+end
+

data/spec/spackle_error_fixture.rb

@@ -0,0 +1,10 @@
+module SpackleErrorFixture
+  def spackle_error_fixture
+    Spackle::Error.new "CATASTROPHE: the milk was spilled! Begin crying? [Y/n]" do |e|
+      e.add_error "/clutzy/child/waving/arms", 1
+      e.add_error "/cupboard/shelf/glass", 350
+      e.add_error "/fridge/shelf/jug/milk", 4
+    end
+  end
+end
+

data/spec/spackle_spec.rb

@@ -0,0 +1,203 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class Spackle::Output::SomeClass
+  def self.format(*args)
+  end
+end
+
+
+describe Spackle do
+  it "should be configurable" do
+    config = Spackle.configuration
+    config.should == Spackle.configuration
+    Spackle.configure do |c|
+      c.should == config
+    end
+  end
+
+  describe "load_config_from_dotfile" do
+    before do
+      Spackle.stub!(:load)
+    end
+
+    it "should return false if a config file was found" do
+      File.stub(:exists?).and_return false
+      Spackle.load_config_from_dotfile.should be_false
+    end
+
+    it "should return true if a config file was found" do
+      File.stub(:exists?).and_return true
+      Spackle.load_config_from_dotfile.should be_true
+    end
+
+    it "should check for a .spackle file in the project root directory" do
+      Spackle::Helpers::RubyProjectRoot.should_receive(:search).and_return("/some/dir/project")
+      File.should_receive(:exists?).with any_args()
+      File.should_receive(:exists?).with("/some/dir/project/.spackle").and_return(true)
+      Spackle.load_config_from_dotfile.should be_true
+    end
+  end
+
+
+  describe "loading configuration" do
+    it "should have nil for the callback command if no config found" do
+      Spackle.stub(:load_config_from_dotfile).and_return(false) 
+      Spackle.load_config
+      Spackle.configuration.callback_command.should be_nil
+    end
+
+    it "should not use the vim defaults when a config file is found" do
+      Spackle.configuration.should_not_receive(:set_defaults_for).with(:vim)
+      Spackle.stub(:load_config_from_dotfile).and_return(true) 
+      Spackle.load_config
+    end
+  end
+
+
+  describe "tempdir" do
+    it "should default to /tmp" do
+      Spackle.tempdir.should == "/tmp"
+    end
+
+    it "should use the configured tempdir" do
+      Spackle.configuration.tempdir = "my_tempdir"
+      Spackle.tempdir.should == "my_tempdir"
+    end
+  end
+
+  describe "spackle_file" do
+    it "should return the tempdir" do
+      Spackle.stub!(:tempdir).and_return("/temp")
+      Spackle.spackle_file.should match(%r{^/temp/.+})
+    end
+
+    it "should end with the Configuration's spackle_file if specified" do
+      Spackle.configuration.spackle_file = "my_spackle"
+      Spackle.spackle_file.should match(%r(/my_spackle$))
+    end
+
+    describe "when no configured spackle_file" do
+      before do
+        Spackle.configuration.spackle_file = nil
+      end
+
+      it "should end with default.spackle if no project root detected" do
+        Spackle::Helpers::RubyProjectRoot.stub! :search => nil
+        Spackle.spackle_file.should match(%r(/default\.spackle$))
+      end
+
+      it "should be named after the project root if detected" do
+        Spackle::Helpers::RubyProjectRoot.should_receive(:search).and_return("/some/dir/project")
+        Spackle.spackle_file.should match(%r(/project\.spackle$))
+      end
+      
+    end
+
+  end
+
+  describe "formatter_class" do
+    it "should convert the configuration's error_formatter to a class" do
+      Spackle.configuration.error_formatter = :some_class
+      Spackle.error_formatter_class.should == Spackle::Output::SomeClass
+    end
+
+    it "should raise a helpful error if no matching class can be found" do
+      Spackle.configuration.error_formatter = :not_existing
+      lambda {
+        Spackle.error_formatter_class
+      }.should raise_error(RuntimeError, /\.spackle/)
+    end
+  end
+
+  describe "test_finished" do
+    before do
+      @errors = [ spackle_error_fixture ]
+      @formatter = mock("formatter", :format => "string")
+      @file = StringIO.new
+      File.stub!(:open).and_yield(@file)
+      Spackle.stub!(
+        :error_formatter_class => @formatter,
+        :system => true,
+        :spackle_file => @spackle_file
+      )
+      Spackle.configuration.error_formatter = :something
+    end
+
+    it "should write the output to the spackle_file if defined" do
+    end
+
+    it "should not write the spackle_file if the error_formatter is undefined" do
+      Spackle.configuration.error_formatter = nil
+      File.should_not_receive(:open)
+      Spackle.test_finished @errors
+    end
+
+    it "should invoke the callback_command if defined" do
+      Spackle.configuration.callback_command = '/bin/true'
+      Spackle.should_receive(:system).with('/bin/true', @spackle_file)
+      Spackle.test_finished @errors
+    end
+
+    it "should not invoke the callback_command if none defined" do
+      Spackle.configuration.callback_command = nil
+      Spackle.should_not_receive(:system)
+      Spackle.test_finished @errors
+    end
+
+    it "should format the errors" do
+      @formatter.should_receive(:format).with(@errors[0])
+      Spackle.test_finished @errors
+    end
+
+    it "should write formatted output to file" do
+      @file.should_receive(:write).with("string")
+      Spackle.test_finished @errors
+    end
+  end
+
+  describe "init" do
+    before do
+      Spackle.stub! :load_config => true,
+                    :spackle_file => true,
+                    :already_initialized? => false
+      File.stub!    :unlink => true,
+                    :exists? => false
+    end
+    
+    it "should only init once" do
+      Spackle.should_receive(:load_config).exactly(1).times
+      Spackle.init
+      Spackle.stub! :already_initialized? => true
+      Spackle.should_not_receive(:load_config)
+      Spackle.init
+    end
+
+    it "should delete the old file, if it exists" do
+      Spackle.stub! :spackle_file => "file"
+      File.should_receive(:exists?).with("file").and_return(true)
+      File.should_receive(:unlink).with("file")
+      Spackle.init
+    end
+
+    it "should not delete the old file unless it exists" do
+      Spackle.stub! :spackle_file => "file"
+      File.should_receive(:exists?).with("file").and_return(false)
+      File.should_not_receive(:unlink).with("file")
+      Spackle.init
+    end
+
+    it "should load the config" do
+      Spackle.should_receive :load_config
+      Spackle.init
+    end
+
+    it "should insert the RSpec formatter if :with => :spec_formatter specified" do
+      Spec::Runner.options.should_receive(:parse_format).with /Spackle::Spec::SpackleFormatter/
+      Spackle.init :with => :spec_formatter
+    end
+
+
+  end
+
+end
+

data/spec/spec.opts

@@ -0,0 +1 @@
+--color