nutshell-crm 0.0.1

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

@@ -0,0 +1,32 @@
+require 'rspec/core/formatters/base_text_formatter'
+module RSpec
+  module Core
+    module Formatters
+
+      class ProgressFormatter < BaseTextFormatter
+
+        def example_passed(example)
+          super(example)
+          output.print green('.')
+        end
+
+        def example_pending(example)
+          super(example)
+          output.print yellow('*')
+        end
+
+        def example_failed(example)
+          super(example)
+          output.print red('F')
+        end
+
+        def start_dump
+          super()
+          output.puts
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module RSpec
+  module Core
+    module Formatters
+      # This class extracts code snippets by looking at the backtrace of the passed error
+      class SnippetExtractor
+        class NullConverter; def convert(code, pre); code; end; end
+        
+        begin
+          require 'syntax/convertors/html'
+          @@converter = Syntax::Convertors::HTML.for_syntax "ruby"
+        rescue LoadError => e
+          @@converter = NullConverter.new
+        end
+
+        def snippet(backtrace)
+          raw_code, line = snippet_for(backtrace[0])
+          highlighted = @@converter.convert(raw_code, false)
+          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
+          post_process(highlighted, line)
+        end
+
+        def snippet_for(error_line)
+          if error_line =~ /(.*):(\d+)/
+            file = $1
+            line = $2.to_i
+            [lines_around(file, line), line]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1]
+          end
+        end
+
+        def lines_around(file, line)
+          if File.file?(file)
+            lines = File.read(file).split("\n")
+            min = [0, line-3].max
+            max = [line+1, lines.length-1].min
+            selected_lines = []
+            selected_lines.join("\n")
+            lines[min..max].join("\n")
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        end
+
+        def post_process(highlighted, offending_line)
+          new_lines = []
+          highlighted.split("\n").each_with_index do |line, i|
+            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
+            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'cgi'
+require 'rspec/core/formatters/html_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+      # Formats backtraces so they're clickable by TextMate
+      class TextMateFormatter < HtmlFormatter
+        def backtrace_line(line, skip_textmate_conversion=false)
+          if skip_textmate_conversion
+            super(line)
+          else
+            format_backtrace_line_for_textmate(super(line))
+          end
+        end
+
+        def format_backtrace_line_for_textmate(line)
+          return nil unless line
+          CGI.escapeHTML(line).sub(/([^:]*\.e?rb):(\d*)/) do
+            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
+          end
+        end
+
+        def extra_failure_content(exception)
+          require 'rspec/core/formatters/snippet_extractor'
+          backtrace = exception.backtrace.map {|line| backtrace_line(line, :skip_textmate_conversion)}
+          backtrace.compact!
+          @snippet_extractor ||= SnippetExtractor.new
+          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+module RSpec
+  module Core
+    module Hooks
+      include MetadataHashBuilder::WithConfigWarning
+
+      class Hook
+        attr_reader :options
+
+        def initialize(options, &block)
+          @options = options
+          raise "no block given for #{display_name}" unless block
+          @block = block
+        end
+
+        def options_apply?(example_or_group)
+          example_or_group.all_apply?(options)
+        end
+
+        def to_proc
+          @block
+        end
+
+        def call
+          @block.call
+        end
+
+        def display_name
+          self.class.name.split('::').last.gsub('Hook','').downcase << " hook"
+        end
+      end
+
+      class BeforeHook < Hook
+        def run_in(example_group_instance)
+          if example_group_instance
+            example_group_instance.instance_eval(&self)
+          else
+            call
+          end
+        end
+      end
+
+      class AfterHook < Hook
+        def run_in(example_group_instance)
+          if example_group_instance
+            example_group_instance.instance_eval_with_rescue(&self)
+          else
+            call
+          end
+        end
+      end
+
+      class AroundHook < Hook
+        def call(wrapped_example)
+          @block.call(wrapped_example)
+        end
+      end
+
+      class HookCollection < Array
+        def find_hooks_for(example_or_group)
+          self.class.new(select {|hook| hook.options_apply?(example_or_group)})
+        end
+
+        def without_hooks_for(example_or_group)
+          self.class.new(reject {|hook| hook.options_apply?(example_or_group)})
+        end
+      end
+
+      class BeforeHooks < HookCollection
+        def run_all(example_group_instance)
+          each {|h| h.run_in(example_group_instance) } unless empty?
+        end
+
+        def run_all!(example_group_instance)
+          shift.run_in(example_group_instance) until empty?
+        end
+      end
+
+      class AfterHooks < HookCollection
+        def run_all(example_group_instance)
+          reverse.each {|h| h.run_in(example_group_instance) } 
+        end
+
+        def run_all!(example_group_instance)
+          pop.run_in(example_group_instance) until empty?
+        end
+      end
+
+      class AroundHooks < HookCollection; end
+
+      def hooks
+        @hooks ||= {
+          :around => { :each => AroundHooks.new },
+          :before => { :each => BeforeHooks.new, :all => BeforeHooks.new, :suite => BeforeHooks.new },
+          :after => { :each => AfterHooks.new, :all => AfterHooks.new, :suite => AfterHooks.new }
+        }
+      end
+
+      def before(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:before][scope] << BeforeHook.new(options, &block)
+      end
+
+      def after(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:after][scope] << AfterHook.new(options, &block)
+      end
+
+      def around(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:around][scope] << AroundHook.new(options, &block)
+      end
+
+      # Runs all of the blocks stored with the hook in the context of the
+      # example. If no example is provided, just calls the hook directly.
+      def run_hook(hook, scope, example_group_instance=nil)
+        hooks[hook][scope].run_all(example_group_instance)
+      end
+
+      # Just like run_hook, except it removes the blocks as it evalutes them,
+      # ensuring that they will only be run once.
+      def run_hook!(hook, scope, example_group_instance)
+        hooks[hook][scope].run_all!(example_group_instance)
+      end
+
+      def run_hook_filtered(hook, scope, group, example_group_instance, example = nil)
+        find_hook(hook, scope, group, example).run_all(example_group_instance)
+      end
+
+      def find_hook(hook, scope, example_group_class, example = nil)
+        found_hooks = hooks[hook][scope].find_hooks_for(example || example_group_class)
+
+        # ensure we don't re-run :all hooks that were applied to any of the parent groups
+        if scope == :all
+          super_klass = example_group_class.superclass
+          while super_klass != RSpec::Core::ExampleGroup
+            found_hooks = found_hooks.without_hooks_for(super_klass)
+            super_klass = super_klass.superclass
+          end
+        end
+
+        found_hooks
+      end
+
+    private
+
+      def scope_and_options_from(*args)
+        scope = if [:each, :all, :suite].include?(args.first)
+          args.shift
+        elsif args.any? { |a| a.is_a?(Symbol) }
+          raise ArgumentError.new("You must explicitly give a scope (:each, :all, or :suite) when using symbols as metadata for a hook.")
+        else
+          :each
+        end
+
+        options = build_metadata_hash_from(args)
+        return scope, options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module RSpec
+  module Core
+    module Let
+
+      module ClassMethods
+        # Generates a method whose return value is memoized
+        # after the first call.
+        #
+        # == Examples
+        #
+        #  describe Thing do
+        #    let(:thing) { Thing.new }
+        #
+        #    it "does something" do
+        #      # first invocation, executes block, memoizes and returns result
+        #      thing.do_something
+        #
+        #      # second invocation, returns the memoized value
+        #      thing.should be_something
+        #    end
+        #  end
+        def let(name, &block)
+          define_method(name) do
+            __memoized.fetch(name) {|k| __memoized[k] = instance_eval(&block) }
+          end
+        end
+
+        # Just like <tt>let()</tt>, except the block is invoked
+        # by an implicit <tt>before</tt> hook. This serves a dual
+        # purpose of setting up state and providing a memoized
+        # reference to that state.
+        #
+        # == Examples
+        #
+        #  class Thing
+        #    def self.count
+        #      @count ||= 0
+        #    end
+        #
+        #    def self.count=(val)
+        #      @count += val
+        #    end
+        #
+        #    def self.reset_count
+        #      @count = 0
+        #    end
+        #
+        #    def initialize
+        #      self.class.count += 1
+        #    end
+        #  end
+        #
+        #  describe Thing do
+        #    after(:each) { Thing.reset_count }
+        #
+        #    context "using let" do
+        #      let(:thing) { Thing.new }
+        #
+        #      it "is not invoked implicitly" do
+        #        Thing.count.should eq(0)
+        #      end
+        #
+        #      it "can be invoked explicitly" do
+        #        thing
+        #        Thing.count.should eq(1)
+        #      end
+        #    end
+        #
+        #    context "using let!" do
+        #      let!(:thing) { Thing.new }
+        #
+        #      it "is invoked implicitly" do
+        #        Thing.count.should eq(1)
+        #      end
+        #
+        #      it "returns memoized version on first invocation" do
+        #        thing
+        #        Thing.count.should eq(1)
+        #      end
+        #    end
+        #  end
+        def let!(name, &block)
+          let(name, &block)
+          before { __send__(name) }
+        end
+      end
+
+      module InstanceMethods
+        def __memoized
+          @__memoized ||= {}
+        end
+      end
+
+      def self.included(mod)
+        mod.extend ClassMethods
+        mod.__send__ :include, InstanceMethods
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+require 'rspec/core/ruby_project'
+
+RSpec::Core::RubyProject.add_to_load_path('lib', 'spec')

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

@@ -0,0 +1,229 @@
+module RSpec
+  module Core
+    class Metadata < Hash
+
+      # Used to extend metadata Hashes to support lazy evaluation of locations
+      # and descriptions.
+      module MetadataHash
+        def [](key)
+          return super if has_key?(key)
+          case key
+          when :location
+            store(:location, location)
+          when :file_path, :line_number
+            file_path, line_number = file_and_line_number
+            store(:file_path, file_path)
+            store(:line_number, line_number)
+            super
+          when :execution_result
+            store(:execution_result, {})
+          when :describes
+            store(:describes, described_class_for(self))
+          when :full_description
+            store(:full_description, full_description_for(self))
+          when :description
+            store(:description, build_description_from(*self[:description_args]))
+          else
+            super
+          end
+        end
+
+      private
+
+        def location
+          "#{self[:file_path]}:#{self[:line_number]}"
+        end
+
+        def file_and_line_number
+          first_caller_from_outside_rspec =~ /(.+?):(\d+)(|:\d+)/
+          return [$1, $2.to_i]
+        end
+
+        def first_caller_from_outside_rspec
+          self[:caller].detect {|l| l !~ /\/lib\/rspec\/core/}
+        end
+
+        def described_class_for(m)
+          m[:example_group][:describes]
+        end
+
+        def full_description_for(m)
+          build_description_from(m[:example_group][:full_description], *m[:description_args])
+        end
+
+        def build_description_from(*parts)
+          parts.map {|p| p.to_s}.reduce do |desc, p|
+            p =~ /^(#|::|\.)/ ? "#{desc}#{p}" : "#{desc} #{p}"
+          end || ""
+        end
+      end
+
+      module GroupMetadataHash
+        include MetadataHash
+
+        def described_class_for(*)
+          ancestors.each do |g|
+            return g[:describes] if g.has_key?(:describes)
+          end
+
+          ancestors.reverse.each do |g|
+            candidate = g[:description_args].first
+            return candidate unless String === candidate || Symbol === candidate
+          end
+
+          nil
+        end
+
+        def full_description_for(*)
+          build_description_from(*ancestors.reverse.map do |a|
+            a.has_key?(:full_description) ? a[:full_description] : a[:description_args]
+          end.flatten)
+        end
+
+      private
+
+        def ancestors
+          @ancestors ||= begin
+                           groups = [group = self]
+                           while group.has_key?(:example_group)
+                             groups << group[:example_group]
+                             group = group[:example_group]
+                           end
+                           groups
+                         end
+        end
+      end
+
+      def initialize(parent_group_metadata=nil)
+        if parent_group_metadata
+          update(parent_group_metadata)
+          store(:example_group, {:example_group => parent_group_metadata[:example_group]}.extend(GroupMetadataHash))
+        else
+          store(:example_group, {}.extend(GroupMetadataHash))
+        end
+
+        yield self if block_given?
+      end
+
+      def process(*args)
+        user_metadata = args.last.is_a?(Hash) ? args.pop : {}
+        ensure_valid_keys(user_metadata)
+
+        self[:example_group].store(:description_args, args)
+        self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
+
+        update(user_metadata)
+      end
+
+      def for_example(description, user_metadata)
+        dup.extend(MetadataHash).configure_for_example(description, user_metadata)
+      end
+
+      def any_apply?(filters)
+        filters.any? {|k,v| filter_applies?(k,v)}
+      end
+
+      def all_apply?(filters)
+        filters.all? {|k,v| filter_applies?(k,v)}
+      end
+
+      def filter_applies?(key, value, metadata=self)
+        case value
+        when Hash
+          if key == :locations
+            file_path     = (self[:example_group] || {})[:file_path]
+            expanded_path = file_path && File.expand_path( file_path )
+            if expanded_path && line_numbers = value[expanded_path]
+              filter_applies?(:line_numbers, line_numbers)
+            else
+              true
+            end
+          else
+            value.all? { |k, v| filter_applies?(k, v, metadata[key]) }
+          end
+        when Regexp
+          metadata[key] =~ value
+        when Proc
+          if value.arity == 2
+            # Pass the metadata hash to allow the proc to check if it even has the key.
+            # This is necessary for the implicit :if exclusion filter:
+            #   {            } # => run the example
+            #   { :if => nil } # => exclude the example
+            # The value of metadata[:if] is the same in these two cases but
+            # they need to be treated differently.
+            value.call(metadata[key], metadata) rescue false
+          else
+            value.call(metadata[key]) rescue false
+          end
+        when String
+          metadata[key].to_s == value.to_s
+        when Enumerable
+          if key == :line_numbers
+            preceding_declaration_lines = value.map{|v| world.preceding_declaration_line(v)}
+            !(relevant_line_numbers(metadata) & preceding_declaration_lines).empty?
+          else
+            metadata[key] == value
+          end
+        else
+          metadata[key].to_s == value.to_s
+        end
+      end
+
+    protected
+
+      def configure_for_example(description, user_metadata)
+        store(:description_args, [description])
+        store(:caller, user_metadata.delete(:caller) || caller)
+        update(user_metadata)
+      end
+
+    private
+
+      RESERVED_KEYS = [
+        :description,
+        :example_group,
+        :execution_result,
+        :file_path,
+        :full_description,
+        :line_number,
+        :location
+      ]
+
+      def ensure_valid_keys(user_metadata)
+        RESERVED_KEYS.each do |key|
+          if user_metadata.keys.include?(key)
+            raise <<-EOM
+#{"*"*50}
+:#{key} is not allowed
+
+RSpec reserves some hash keys for its own internal use,
+including :#{key}, which is used on:
+
+  #{caller(0)[4]}.
+
+Here are all of RSpec's reserved hash keys:
+
+  #{RESERVED_KEYS.join("\n  ")}
+#{"*"*50}
+EOM
+            raise ":#{key} is not allowed"
+          end
+        end
+      end
+
+      def world
+        RSpec.world
+      end
+
+      def relevant_line_numbers(metadata)
+        line_numbers = [metadata[:line_number]]
+        if metadata[:example_group]
+          line_numbers + relevant_line_numbers(metadata[:example_group])
+        else
+          line_numbers
+        end
+      end
+
+    end
+  end
+end