nutshell-crm 0.0.1

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

@@ -0,0 +1,9 @@
+require 'rspec/expectations'
+
+module RSpec
+  module Core
+    module ExpectationFrameworkAdapter
+      include RSpec::Matchers
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'test/unit/assertions'
+
+module RSpec
+  module Core
+    module ExpectationFrameworkAdapter
+      include Test::Unit::Assertions
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+require 'rspec/core/extensions/kernel'
+require 'rspec/core/extensions/instance_eval_with_args'
+require 'rspec/core/extensions/module_eval_with_args'

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

@@ -0,0 +1,39 @@
+module RSpec
+  module Core
+    module Extensions
+      module InstanceEvalWithArgs
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class instead of global InstanceExecHelper module
+        # - this keeps it scoped to classes/modules that include this module
+        # - only necessary for ruby 1.8.6
+        def instance_eval_with_args(*args, &block)
+          return instance_exec(*args, &block) if respond_to?(:instance_exec)
+
+          # If there are no args and the block doesn't expect any, there's no
+          # need to fake instance_exec with our hack below.
+          # Notes:
+          #   * lambda { }.arity # => -1
+          #   * lambda { || }.arity # => 0
+          #   * lambda { |*a| }.arity # -1
+          return instance_eval(&block) if block.arity < 1 && args.size.zero?
+
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # If not already defined by ruby-debug, this implementation prints helpful
+    # message to STDERR when ruby-debug is not loaded.
+    def debugger(*args)
+      (RSpec.configuration.error_stream || $stderr).puts "\n***** debugger statement ignored, use -d or --debug option to enable debugging\n#{caller(0)[1]}"
+    end 
+  end
+end

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

@@ -0,0 +1,34 @@
+module RSpec
+  module Core
+    module Extensions
+      module ModuleEvalWithArgs
+        include InstanceEvalWithArgs
+
+        def module_eval_with_args(*args, &block)
+          # ruby > 1.8.6
+          return module_exec(*args, &block) if respond_to?(:module_exec)
+
+          # If there are no args and the block doesn't expect any, there's no
+          # need to fake module_exec with our hack below.
+          # Notes:
+          #   * lambda {      }.arity # => -1
+          #   * lambda { ||   }.arity # =>  0
+          #   * lambda { |*a| }.arity # => -1
+          return module_eval(&block) if block.arity < 1 && args.size.zero?
+
+          orig_singleton_methods = singleton_methods
+          instance_eval_with_args(*args, &block)
+
+          # The only difference between instance_eval and module_eval is static method defs.
+          #   * `def foo` in instance_eval defines a singleton method on the instance
+          #   * `def foo` in class/module_eval defines an instance method for the class/module
+          # Here we deal with this difference by defining an instance method for
+          # each new singleton method.
+          # This has the side effect of duplicating methods (all new class methods will
+          # become instance methods and vice versa), but I don't see a way around it...
+          (singleton_methods - orig_singleton_methods).each { |m| define_method(m, &method(m)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+require 'rspec/core/formatters/helpers'
+require 'stringio'
+
+module RSpec
+  module Core
+    module Formatters
+
+      class BaseFormatter
+        include Helpers
+        attr_accessor :example_group
+        attr_reader :duration, :examples, :output
+        attr_reader :example_count, :pending_count, :failure_count
+        attr_reader :failed_examples, :pending_examples
+
+        def self.relative_path(line)
+          line = line.sub(File.expand_path("."), ".")
+          line = line.sub(/\A([^:]+:\d+)$/, '\\1')
+          return nil if line == '-e:1'
+          line
+        end
+
+        def initialize(output)
+          @output = output || StringIO.new
+          @example_count = @pending_count = @failure_count = 0
+          @examples = []
+          @failed_examples = []
+          @pending_examples = []
+          @example_group = nil
+        end
+
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones)
+        #
+        # This will only be invoked once, and the next one to be invoked
+        # is #example_group_started
+        def start(example_count)
+          start_sync_output
+          @example_count = example_count
+        end
+
+        # This method is invoked at the beginning of the execution of each example group.
+        # +example_group+ is the example_group.
+        #
+        # The next method to be invoked after this is +example_passed+,
+        # +example_pending+, or +example_finished+
+        def example_group_started(example_group)
+          @example_group = example_group
+        end
+
+        # This method is invoked at the end of the execution of each example group.
+        # +example_group+ is the example_group.
+        def example_group_finished(example_group)
+        end
+
+        def example_started(example)
+          examples << example
+        end
+
+        def example_passed(example)
+        end
+
+        def example_pending(example)
+          @pending_examples << example
+        end
+
+        def example_failed(example)
+          @failed_examples << example
+        end
+
+        def message(message)
+        end
+
+        def stop
+        end
+
+        # This method is invoked after all of the examples have executed. The next method
+        # to be invoked after this one is #dump_failure (once for each failed example),
+        def start_dump
+        end
+
+        # Dumps detailed information about each example failure.
+        def dump_failures
+        end
+
+        # This method is invoked after the dumping of examples and failures.
+        def dump_summary(duration, example_count, failure_count, pending_count)
+          @duration = duration
+          @example_count = example_count
+          @failure_count = failure_count
+          @pending_count = pending_count
+        end
+
+        # This gets invoked after the summary if option is set to do so.
+        def dump_pending
+        end
+
+        # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
+        def close
+          restore_sync_output
+        end
+
+        def format_backtrace(backtrace, example)
+          return "" unless backtrace
+          return backtrace if example.metadata[:full_backtrace] == true
+
+          if at_exit_index = backtrace.index(RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE)
+            backtrace = backtrace[0, at_exit_index]
+          end
+
+          cleansed = backtrace.map { |line| backtrace_line(line) }.compact
+          cleansed.empty? ? backtrace : cleansed
+        end
+
+      protected
+
+        def configuration
+          RSpec.configuration
+        end
+
+        def backtrace_line(line)
+          return nil if configuration.cleaned_from_backtrace?(line)
+          self.class.relative_path(line)
+        end
+
+        def read_failed_line(exception, example)
+          unless matching_line = find_failed_line(exception.backtrace, example.file_path)
+            return "Unable to find matching line from backtrace"
+          end
+
+          file_path, line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)[1..2]
+
+          if File.exist?(file_path)
+            File.readlines(file_path)[line_number.to_i - 1]
+          else
+            "Unable to find #{file_path} to read failed line"
+          end
+        end
+
+        def find_failed_line(backtrace, path)
+          backtrace.detect { |line|
+            match = line.match(/(.+?):(\d+)(|:\d+)/)
+            match && match[1].downcase == path.downcase
+          }
+
+        end
+
+        def start_sync_output
+          @old_sync, output.sync = output.sync, true if output_supports_sync
+        end
+
+        def restore_sync_output
+          output.sync = @old_sync if output_supports_sync and !output.closed?
+        end
+
+        def output_supports_sync
+          output.respond_to?(:sync=)
+        end
+
+        def profile_examples?
+          configuration.profile_examples
+        end
+
+        def color_enabled?
+          configuration.color_enabled?
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+require 'rspec/core/formatters/base_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+
+      class BaseTextFormatter < BaseFormatter
+
+        def message(message)
+          output.puts message
+        end
+
+        def dump_failures
+          return if failed_examples.empty?
+          output.puts
+          output.puts "Failures:"
+          failed_examples.each_with_index do |example, index|
+            output.puts
+            dump_pending_example_fixed(example, index) || dump_failure(example, index)
+            dump_backtrace(example)
+          end
+        end
+
+        def colorise_summary(summary)
+          if failure_count == 0
+            if pending_count > 0
+              yellow(summary)
+            else
+              green(summary)
+            end
+          else
+            red(summary)
+          end
+        end
+
+        def dump_summary(duration, example_count, failure_count, pending_count)
+          super(duration, example_count, failure_count, pending_count)
+          # Don't print out profiled info if there are failures, it just clutters the output
+          dump_profile if profile_examples? && failure_count == 0
+          output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
+          output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
+          dump_commands_to_rerun_failed_examples
+        end
+
+        def dump_commands_to_rerun_failed_examples
+          return if failed_examples.empty?
+          output.puts
+          output.puts("Failed examples:")
+          output.puts
+
+          failed_examples.each do |example|
+            output.puts(red("rspec #{BaseFormatter::relative_path(example.location)}") + " " + cyan("# #{example.full_description}"))
+          end
+        end
+
+        def dump_profile
+          sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
+          output.puts "\nTop #{sorted_examples.size} slowest examples:\n"
+          sorted_examples.each do |example|
+            output.puts "  #{example.full_description}"
+            output.puts cyan("    #{red(format_seconds(example.execution_result[:run_time]))} #{red("seconds")} #{format_caller(example.location)}")
+          end
+        end
+
+        def summary_line(example_count, failure_count, pending_count)
+          summary = pluralize(example_count, "example")
+          summary << ", " << pluralize(failure_count, "failure")
+          summary << ", #{pending_count} pending" if pending_count > 0
+          summary
+        end
+
+        def dump_pending
+          unless pending_examples.empty?
+            output.puts
+            output.puts "Pending:"
+            pending_examples.each do |pending_example|
+              output.puts yellow("  #{pending_example.full_description}")
+              output.puts cyan("    # #{pending_example.execution_result[:pending_message]}")
+              output.puts cyan("    # #{format_caller(pending_example.location)}")
+              if pending_example.execution_result[:exception] \
+                && RSpec.configuration.show_failures_in_pending_blocks?
+                dump_failure_info(pending_example)
+                dump_backtrace(pending_example)
+              end
+            end
+          end
+        end
+
+        def close
+          output.close if IO === output && output != $stdout
+        end
+
+      protected
+
+        def color(text, color_code)
+          color_enabled? ? "#{color_code}#{text}\e[0m" : text
+        end
+
+        def bold(text)
+          color(text, "\e[1m")
+        end
+
+        def red(text)
+          color(text, "\e[31m")
+        end
+
+        def green(text)
+          color(text, "\e[32m")
+        end
+
+        def yellow(text)
+          color(text, "\e[33m")
+        end
+
+        def blue(text)
+          color(text, "\e[34m")
+        end
+
+        def magenta(text)
+          color(text, "\e[35m")
+        end
+
+        def cyan(text)
+          color(text, "\e[36m")
+        end
+
+        def white(text)
+          color(text, "\e[37m")
+        end
+
+        def short_padding
+          '  '
+        end
+
+        def long_padding
+          '     '
+        end
+
+      private
+
+        def pluralize(count, string)
+          "#{count} #{string}#{'s' unless count == 1}"
+        end
+
+        def format_caller(caller_info)
+          backtrace_line(caller_info.to_s.split(':in `block').first)
+        end
+
+        def dump_backtrace(example)
+          format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+            output.puts cyan("#{long_padding}# #{backtrace_info}")
+          end
+        end
+
+        def dump_pending_example_fixed(example, index)
+          if RSpec::Core::PendingExampleFixedError === example.execution_result[:exception]
+            output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
+            output.puts blue("#{long_padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised.")
+            true
+          end
+        end
+
+        def dump_failure(example, index)
+          output.puts "#{short_padding}#{index.next}) #{example.full_description}"
+          dump_failure_info(example)
+        end
+
+        def dump_failure_info(example)
+          exception = example.execution_result[:exception]
+          output.puts "#{long_padding}#{red("Failure/Error:")} #{red(read_failed_line(exception, example).strip)}"
+          output.puts "#{long_padding}#{red(exception.class.name << ":")}" unless exception.class.name =~ /RSpec/
+          exception.message.split("\n").each { |line| output.puts "#{long_padding}  #{red(line)}" } if exception.message
+
+          example.example_group.ancestors.push(example.example_group).each do |group|
+            if group.metadata[:shared_group_name]
+              output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
+                "#{backtrace_line(group.metadata[:example_group][:location])}"
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end