nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-core-2.7.1/lib/rspec/core/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Core
+    module Version
+      STRING = '2.7.1'
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/lib/rspec/core/world.rb

@@ -0,0 +1,150 @@
+module RSpec
+  module Core
+    class World
+
+      module Describable
+        PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+        PROJECT_DIR = File.expand_path('.')
+
+        def description
+          reject { |k, v| RSpec::Core::Configuration::CONDITIONAL_FILTERS[k] == v }.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+        end
+
+        def empty_without_conditional_filters?
+          reject { |k, v| RSpec::Core::Configuration::CONDITIONAL_FILTERS[k] == v }.empty?
+        end
+
+        def reject
+          super rescue {}
+        end
+
+        def empty?
+          super rescue false
+        end
+      end
+
+      include RSpec::Core::Hooks
+
+      attr_reader :example_groups, :filtered_examples, :wants_to_quit
+      attr_writer :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = []
+        @filtered_examples = Hash.new { |hash,group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = apply_exclusion_filters(examples, exclusion_filter)
+            examples = apply_inclusion_filters(examples, inclusion_filter)
+            examples.uniq
+          end
+        }
+      end
+
+      def reset
+        example_groups.clear
+      end
+
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
+      def inclusion_filter
+        @configuration.inclusion_filter.extend(Describable)
+      end
+
+      def exclusion_filter
+        @configuration.exclusion_filter.extend(Describable)
+      end
+
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      def shared_example_groups
+        @shared_example_groups ||= {}
+      end
+
+      def example_count
+        example_groups.collect {|g| g.descendants}.flatten.inject(0) { |sum, g| sum += g.filtered_examples.size }
+      end
+
+      def apply_inclusion_filters(examples, filters)
+        filters.empty? ? examples : examples.select {|e| e.metadata.any_apply?(filters)}
+      end
+
+      alias_method :find, :apply_inclusion_filters
+
+      def apply_exclusion_filters(examples, filters)
+        filters.empty? ? examples : examples.reject {|e| e.metadata.any_apply?(filters)}
+      end
+
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      def reporter
+        @configuration.reporter
+      end
+
+      def announce_filters
+        filter_announcements = []
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message( "No examples matched #{inclusion_filter.description}. Running all.")
+          filtered_examples.clear
+          @configuration.clear_inclusion_filter
+        end
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        if example_count.zero?
+          example_groups.clear
+          if filter_announcements.empty?
+            reporter.message("No examples found.")
+          elsif !inclusion_filter.empty?
+            message = "No examples matched #{inclusion_filter.description}."
+            if @configuration.run_all_when_everything_filtered?
+              message << " Running all."
+            end
+            reporter.message(message)
+          elsif !exclusion_filter.empty?
+            reporter.message(
+              "No examples were matched. Perhaps #{exclusion_filter.description} is excluding everything?")
+          end
+        elsif !filter_announcements.empty?
+          reporter.message("Run filtered #{filter_announcements.join(', ')}")
+        end
+      end
+
+      def announce_inclusion_filter(announcements)
+        unless inclusion_filter.empty?
+          announcements << "including #{inclusion_filter.description}"
+        end
+      end
+
+      def announce_exclusion_filter(announcements)
+        unless exclusion_filter.empty_without_conditional_filters?
+          announcements << "excluding #{exclusion_filter.description}"
+        end
+      end
+
+      def find_hook(hook, scope, group, example = nil)
+        @configuration.find_hook(hook, scope, group, example)
+      end
+
+    private
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/lib/rspec/monkey.rb

@@ -0,0 +1 @@
+require "rspec/monkey/spork/test_framework/rspec.rb"

data/vendor/bundle/gems/rspec-core-2.7.1/lib/rspec/monkey/spork/test_framework/rspec.rb

@@ -0,0 +1,8 @@
+# TODO (2011-05-08) - remove this as soon as spork 0.9.0 is released
+if defined?(Spork::TestFramework::RSpec)
+  class Spork::TestFramework::RSpec < Spork::TestFramework
+    def run_tests(argv, err, out)
+      ::RSpec::Core::CommandLine.new(argv).run(err, out)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/autotest/discover_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "autotest/discover.rb" do
+  context "with ./.rspec present" do
+    it "adds 'rspec2' to the list of discoveries" do
+      File.stub(:exist?).with("./.rspec") { true }
+      Autotest.should_receive(:add_discovery)
+      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
+    end
+  end
+
+  context "with ./.rspec absent" do
+    it "does not add 'rspec2' to the list of discoveries" do
+      File.stub(:exist?) { false }
+      Autotest.should_not_receive(:add_discovery)
+      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/autotest/failed_results_re_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe "failed_results_re for autotest" do
+  def run_example
+    group = RSpec::Core::ExampleGroup.describe("group")
+    example = group.example("example") { yield }
+    io = StringIO.new
+    formatter = RSpec::Core::Formatters::BaseTextFormatter.new(io)
+    reporter = RSpec::Core::Reporter.new(formatter)
+
+    group.run(reporter)
+    reporter.report(1) {}
+    io.string
+  end
+
+  shared_examples "autotest failed_results_re" do
+    it "matches a failure" do
+      output = run_example { fail }
+      output.should match(Autotest::Rspec2.new.failed_results_re)
+      output.should include(__FILE__.sub(File.expand_path('.'),'.'))
+    end
+
+    it "does not match when there are no failures" do
+      output = run_example { } # pass
+      output.should_not match(Autotest::Rspec2.new.failed_results_re)
+      output.should_not include(__FILE__.sub(File.expand_path('.'),'.'))
+    end
+  end
+
+  context "with color enabled" do
+    before do
+      RSpec.configuration.stub(:color_enabled? => true)
+    end
+
+    include_examples "autotest failed_results_re"
+  end
+
+  context "with color disabled " do
+    before do
+      RSpec.configuration.stub(:color_enabled? => false)
+    end
+
+    include_examples "autotest failed_results_re"
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/autotest/rspec_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Autotest::Rspec2 do
+  let(:rspec_autotest) { Autotest::Rspec2.new }
+  let(:spec_cmd) { File.expand_path("../../../exe/rspec", __FILE__) }
+  let(:ruby_cmd) { "ruby" }
+
+  before do
+    File.stub(:exist?) { false }
+  end
+
+  it "uses autotest's prefix" do
+    rspec_autotest.prefix = "this is the prefix "
+    rspec_autotest.
+      make_test_cmd({'a' => 'b'}).should match(/this is the prefix/)
+  end
+
+  describe "commands" do
+    before do
+      rspec_autotest.stub(:ruby => ruby_cmd)
+      files = %w[file_one file_two]
+      @files_to_test = {
+        files[0] => [],
+        files[1] => []
+      }
+      # this is not the inner representation of Autotest!
+      rspec_autotest.files_to_test = @files_to_test
+      @to_test = files.map { |f| File.expand_path(f) }.join ' '
+    end
+
+    it "makes the appropriate test command" do
+      actual_command = rspec_autotest.make_test_cmd(@files_to_test)
+      expected_command = /#{ruby_cmd}.*#{spec_cmd} (.*)/
+
+      actual_command.should match(expected_command)
+
+      actual_command =~ expected_command
+      $1.should =~ /#{File.expand_path('file_one')}/
+      $1.should =~ /#{File.expand_path('file_two')}/
+    end
+
+    it "returns a blank command for no files" do
+      rspec_autotest.make_test_cmd({}).should eq('')
+    end
+
+    it "quotes the paths of files to test" do
+      cmd = rspec_autotest.make_test_cmd(@files_to_test)
+      @files_to_test.keys.each do |file_to_test|
+        cmd.should match(/'#{File.expand_path(file_to_test)}'/)
+      end
+    end
+
+    it "gives '--tty' to #{Autotest::Rspec2::RSPEC_EXECUTABLE}, not '--autotest'" do
+      cmd = rspec_autotest.make_test_cmd(@files_to_test)
+      cmd.should match(' --tty ')
+      cmd.should_not match(' --autotest ')
+    end
+  end
+
+  describe "mappings" do
+    before do
+      @lib_file = "lib/something.rb"
+      @spec_file = "spec/something_spec.rb"
+      rspec_autotest.hook :initialize
+    end
+
+    it "finds the spec file for a given lib file" do
+      rspec_autotest.should map_specs([@spec_file]).to(@lib_file)
+    end
+
+    it "finds the spec file if given a spec file" do
+      rspec_autotest.should map_specs([@spec_file]).to(@spec_file)
+    end
+
+    it "ignores files in spec dir that aren't specs" do
+      rspec_autotest.should map_specs([]).to("spec/spec_helper.rb")
+    end
+
+    it "ignores untracked files (in @file)"  do
+      rspec_autotest.should map_specs([]).to("lib/untracked_file")
+    end
+  end
+
+  describe "consolidating failures" do
+    let(:subject_file) { "lib/autotest/some.rb" }
+    let(:spec_file)    { "spec/autotest/some_spec.rb" }
+
+    it "returns no failures if no failures were given in the output" do
+      rspec_autotest.consolidate_failures([[]]).should eq({})
+    end
+
+    it "returns a hash with the spec filename => spec name for each failure or error" do
+      failures = [ [ "false should be false", spec_file ] ]
+      rspec_autotest.consolidate_failures(failures).should eq({
+        spec_file => ["false should be false"]
+      })
+    end
+
+    context "when subject file appears before the spec file in the backtrace" do
+      let(:failures) do
+        [ [ "false should be false", "#{subject_file}:143:\n#{spec_file}:203:" ] ]
+      end
+
+      it "excludes the subject file" do
+        rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
+      end
+
+      it "includes the spec file" do
+        rspec_autotest.consolidate_failures(failures).keys.should include(spec_file)
+      end
+    end
+  end
+
+  describe "normalizing file names" do
+    it "ensures that a single file appears in files_to_test only once" do
+      @files_to_test = {}
+      ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file|
+        @files_to_test[file] = []
+      end
+      rspec_autotest.normalize(@files_to_test).should have(1).file
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/command_line_configuration_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec::Core
+  describe CommandLineConfiguration do
+    describe '#run' do
+      context 'given autotest command' do
+        let(:config) { CommandLineConfiguration.new('autotest') }
+
+        it 'calls Autotest.generate' do
+          CommandLineConfiguration::Autotest.should_receive(:generate)
+          config.run
+        end
+      end
+
+      context 'given unsupported command' do
+        let(:config) { CommandLineConfiguration.new('unsupported') }
+
+        it 'raises ArgumentError' do
+          lambda { config.run }.should(
+            raise_error(ArgumentError, /"unsupported" is not valid/)
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/command_line_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+require "stringio"
+require 'tmpdir'
+
+module RSpec::Core
+  describe CommandLine do
+
+    describe "#run" do
+      include_context "spec files"
+
+      let(:out)    { StringIO.new }
+      let(:err)    { StringIO.new }
+
+      def command_line(args)
+        RSpec::Core::CommandLine.new(config_options(args))
+      end
+
+      def config_options(argv=[])
+        options = RSpec::Core::ConfigurationOptions.new(argv)
+        options.parse_options
+        options
+      end
+
+      it "returns 0 if spec passes" do
+        err, out = StringIO.new, StringIO.new
+        result = command_line([passing_spec_filename]).run(err, out)
+        result.should be(0)
+      end
+
+      it "returns 1 if spec fails" do
+        err, out = StringIO.new, StringIO.new
+        result = command_line([failing_spec_filename]).run(err, out)
+        result.should be(1)
+      end
+
+      it "returns 2 if spec fails and --failure-exit-code is 2" do
+        err, out = StringIO.new, StringIO.new
+        result = command_line([failing_spec_filename, "--failure-exit-code", "2"]).run(err, out)
+        result.should be(2)
+      end
+    end
+
+    context "given an Array of options" do
+      it "assigns ConfigurationOptions built from Array to @options" do
+        config_options = ConfigurationOptions.new(%w[--color])
+        config_options.parse_options
+
+        array_options = %w[--color]
+        command_line = CommandLine.new(array_options)
+        command_line.instance_eval { @options.options }.should eq(config_options.options)
+      end
+    end
+
+    context "given a ConfigurationOptions object" do
+      it "assigns it to @options" do
+        config_options = ConfigurationOptions.new(%w[--color])
+        config_options.parse_options
+        command_line = CommandLine.new(config_options)
+        command_line.instance_eval { @options }.should be(config_options)
+      end
+    end
+
+    describe "#run" do
+      let(:config_options) do
+        config_options = ConfigurationOptions.new(%w[--color])
+        config_options.parse_options
+        config_options
+      end
+
+      let(:config) do
+        RSpec::Core::Configuration.new
+      end
+
+      let(:world) do
+        RSpec::Core::World.new
+      end
+
+      let(:command_line) do
+        CommandLine.new(config_options, config, world)
+      end
+
+      let(:out) { ::StringIO.new }
+      let(:err) { ::StringIO.new }
+
+      before do
+        config.stub(:run_hook)
+
+        config.should_receive(:load_spec_files)
+
+        world.should_receive(:announce_inclusion_filter)
+        world.should_receive(:announce_exclusion_filter)
+      end
+
+      it "configures streams before command line options" do
+        # this is necessary to ensure that color works correctly on windows
+        config.should_receive(:error_stream=).ordered
+        config.should_receive(:output_stream=).ordered
+        config.should_receive(:color_enabled=).ordered
+        command_line.run(err, out) rescue nil
+      end
+
+      it "runs before suite hooks" do
+        config.should_receive(:run_hook).with(:before, :suite)
+        command_line.run(err, out)
+      end
+
+      it "runs after suite hooks" do
+        config.should_receive(:run_hook).with(:after, :suite)
+        command_line.run(err, out)
+      end
+
+      it "runs after suite hooks even after an error" do
+        after_suite_called = false
+        config.stub(:run_hook) do |*args|
+          case args.first
+          when :before
+            raise "this error"
+          when :after
+            after_suite_called = true
+          end
+        end
+        expect do
+          command_line.run(err, out)
+        end.to raise_error
+        after_suite_called.should be_true
+      end
+
+    end
+
+    describe "#run with custom output" do
+      let(:config_options) do
+        config_options = ConfigurationOptions.new(%w[--color])
+        config_options.parse_options
+        config_options
+      end
+
+      let(:command_line) do
+        CommandLine.new(config_options, config)
+      end
+
+      let(:output_file_path) do
+        Dir.tmpdir + "/command_line_spec_output.txt"
+      end
+
+      let(:output_file) do
+        File.new(output_file_path, 'w')
+      end
+
+      let(:config) do
+        config = RSpec::Core::Configuration.new
+        config.output_stream = output_file
+        config
+      end
+
+      let(:out) { ::StringIO.new }
+
+      before do
+        config.stub(:run_hook)
+        config.stub(:files_to_run) { [] }
+      end
+
+      it "doesn't override output_stream" do
+        command_line.run(out, out)
+        command_line.instance_eval { @configuration.output_stream }.should eql(output_file)
+      end
+    end
+
+  end
+end