clickable_link 0.0.1 → 0.0.2

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/compatibility.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.constants.each do |c|
+  if Class === (klass = RSpec::Matchers.const_get(c))
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
+      klass.class_eval do
+        alias_method :failure_message, :failure_message_for_should
+      end
+    end
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
+      klass.class_eval do
+        alias_method :negative_failure_message, :failure_message_for_should_not
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/configuration.rb

@@ -0,0 +1,108 @@
+require 'rspec/expectations/syntax'
+
+module RSpec
+  module Matchers
+    # Provides configuration options for rspec-expectations.
+    class Configuration
+      # Configures the supported syntax.
+      # @param [Array<Symbol>, Symbol] values the syntaxes to enable
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.expect_with :rspec do |c|
+      #       c.syntax = :should
+      #       # or
+      #       c.syntax = :expect
+      #       # or
+      #       c.syntax = [:should, :expect]
+      #     end
+      #   end
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Expectations::Syntax.enable_expect
+        else
+          Expectations::Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Expectations::Syntax.enable_should
+        else
+          Expectations::Syntax.disable_should
+        end
+      end
+
+      # The list of configured syntaxes.
+      # @return [Array<Symbol>] the list of configured syntaxes.
+      def syntax
+        syntaxes = []
+        syntaxes << :should if Expectations::Syntax.should_enabled?
+        syntaxes << :expect if Expectations::Syntax.expect_enabled?
+        syntaxes
+      end
+
+      # color config for expectations
+      # fallback if rspec core not available
+      if ::RSpec.respond_to?(:configuration)
+        def color?
+          ::RSpec.configuration.color_enabled?
+        end
+      else
+        attr_writer :color
+        def color?
+          @color
+        end
+      end
+
+      # Adds `should` and `should_not` to the given classes
+      # or modules. This can be used to ensure `should` works
+      # properly on things like proxy objects (particular
+      # `Delegator`-subclassed objects on 1.8).
+      #
+      # @param [Array<Module>] modules the list of classes or modules
+      #   to add `should` and `should_not` to.
+      def add_should_and_should_not_to(*modules)
+        modules.each do |mod|
+          Expectations::Syntax.enable_should(mod)
+        end
+      end
+
+      # Sets or gets the backtrace formatter. The backtrace formatter should
+      # implement `#format_backtrace(Array<String>)`. This is used
+      # to format backtraces of errors handled by the `raise_error`
+      # matcher.
+      #
+      # If you are using rspec-core, rspec-core's backtrace formatting
+      # will be used (including respecting the presence or absence of
+      # the `--backtrace` option).
+      #
+      # @overload backtrace_formatter
+      #   @return [#format_backtrace] the backtrace formatter
+      # @overload backtrace_formatter=
+      #   @param value [#format_backtrace] sets the backtrace formatter
+      attr_writer :backtrace_formatter
+      def backtrace_formatter
+        @backtrace_formatter ||= if defined?(::RSpec::Core::BacktraceFormatter)
+          ::RSpec::Core::BacktraceFormatter
+        else
+          NullBacktraceFormatter
+        end
+      end
+
+      # @api private
+      NullBacktraceFormatter = Module.new do
+        def self.format_backtrace(backtrace)
+          backtrace
+        end
+      end
+    end
+
+    # The configuration object
+    # @return [RSpec::Matchers::Configuration] the configuration object
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # set default syntax
+    configuration.syntax = [:expect, :should]
+  end
+end
+

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/dsl.rb

@@ -0,0 +1,24 @@
+module RSpec
+  module Matchers
+    module DSL
+      # Defines a custom matcher.
+      # @see RSpec::Matchers
+      def define(name, &declarations)
+        matcher_template = RSpec::Matchers::DSL::Matcher.new(name, &declarations)
+        define_method name do |*expected|
+          matcher = matcher_template.for_expected(*expected)
+          matcher.matcher_execution_context = @matcher_execution_context ||= self
+          matcher
+        end
+      end
+
+      alias_method :matcher, :define
+
+      if RSpec.respond_to?(:configure)
+        RSpec.configure {|c| c.extend self}
+      end
+    end
+  end
+end
+
+RSpec::Matchers.extend RSpec::Matchers::DSL

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/extensions/instance_eval_with_args.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    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.empty?
+
+          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/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/generated_descriptions.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Matchers
+    class << self
+      attr_accessor :last_matcher, :last_should
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
+    end
+
+  private
+
+    def self.last_description
+      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
+When you call a matcher in an example without a String, like this:
+
+specify { object.should matcher }
+
+or this:
+
+it { should matcher }
+
+RSpec expects the matcher to have a #description method. You should either
+add a String to the example this matcher is being used in, or give it a
+description method. Then you won't have to suffer this lengthy warning again.
+MESSAGE
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-expectations-2.14.2/lib/rspec/matchers/matcher.rb

@@ -0,0 +1,300 @@
+require 'set'
+
+module RSpec
+  module Matchers
+    module DSL
+      # Provides the context in which the block passed to RSpec::Matchers.define
+      # will be evaluated.
+      class Matcher
+        include RSpec::Matchers::Extensions::InstanceEvalWithArgs
+        include RSpec::Matchers::Pretty
+        include RSpec::Matchers
+
+        attr_reader :expected, :actual, :rescued_exception
+        attr_accessor :matcher_execution_context
+
+        # @api private
+        def initialize(name, &declarations)
+          @name         = name
+          @declarations = declarations
+          @actual       = nil
+          @diffable     = false
+          @expected_exception, @rescued_exception = nil, nil
+          @match_for_should_not_block = nil
+          @messages = {}
+        end
+
+        PERSISTENT_INSTANCE_VARIABLES = [
+          :@name, :@declarations, :@diffable,
+          :@match_block, :@match_for_should_not_block,
+          :@expected_exception
+        ].to_set
+
+        # @api private
+        def for_expected(*expected)
+          @expected = expected
+          dup.instance_eval do
+            instance_variables.map {|ivar| ivar.intern}.each do |ivar|
+              instance_variable_set(ivar, nil) unless (PERSISTENT_INSTANCE_VARIABLES + [:@expected]).include?(ivar)
+            end
+            @messages = {}
+            making_declared_methods_public do
+              instance_eval_with_args(*@expected, &@declarations)
+            end
+            self
+          end
+        end
+
+        # @api private
+        # Used internally by +should+ and +should_not+.
+        def matches?(actual)
+          @actual = actual
+          if @expected_exception
+            begin
+              instance_eval_with_args(actual, &@match_block)
+              true
+            rescue @expected_exception => @rescued_exception
+              false
+            end
+          else
+            begin
+              instance_eval_with_args(actual, &@match_block)
+            rescue RSpec::Expectations::ExpectationNotMetError
+              false
+            end
+          end
+        end
+
+        # Stores the block that is used to determine whether this matcher passes
+        # or fails. The block should return a boolean value. When the matcher is
+        # passed to `should` and the block returns `true`, then the expectation
+        # passes. Similarly, when the matcher is passed to `should_not` and the
+        # block returns `false`, then the expectation passes.
+        #
+        # Use `match_for_should` when used in conjuntion with
+        # `match_for_should_not`.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :be_even do
+        #       match do |actual|
+        #         actual.even?
+        #       end
+        #     end
+        #
+        #     4.should be_even     # passes
+        #     3.should_not be_even # passes
+        #     3.should be_even     # fails
+        #     4.should_not be_even # fails
+        #
+        # @yield [Object] actual the actual value (or receiver of should)
+        def match(&block)
+          @match_block = block
+        end
+
+        alias_method :match_for_should, :match
+
+        # Use this to define the block for a negative expectation (`should_not`)
+        # when the positive and negative forms require different handling. This
+        # is rarely necessary, but can be helpful, for example, when specifying
+        # asynchronous processes that require different timeouts.
+        #
+        # @yield [Object] actual the actual value (or receiver of should)
+        def match_for_should_not(&block)
+          @match_for_should_not_block = block
+        end
+
+        # Use this instead of `match` when the block will raise an exception
+        # rather than returning false to indicate a failure.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
+        #       match_unless_raises ValidationException do |validator|
+        #         validator.validate(candidate_address)
+        #       end
+        #     end
+        #
+        #     email_validator.should accept_as_valid("person@company.com")
+        def match_unless_raises(exception=Exception, &block)
+          @expected_exception = exception
+          match(&block)
+        end
+
+        # Customize the failure messsage to use when this matcher is invoked with
+        # `should`. Only use this when the message generated by default doesn't
+        # suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { ... }
+        #
+        #       failure_message_for_should do |actual|
+        #         "Expected strength of #{expected}, but had #{actual.strength}"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object
+        def failure_message_for_should(&block)
+          cache_or_call_cached(:failure_message_for_should, &block)
+        end
+
+        # Customize the failure messsage to use when this matcher is invoked with
+        # `should_not`. Only use this when the message generated by default
+        # doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { ... }
+        #
+        #       failure_message_for_should_not do |actual|
+        #         "Expected not to have strength of #{expected}, but did"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object
+        # @yield [Object] actual the actual object
+        def failure_message_for_should_not(&block)
+          cache_or_call_cached(:failure_message_for_should_not, &block)
+        end
+
+
+        # Customize the description to use for one-liners.  Only use this when
+        # the description generated by default doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :qualify_for do |expected|
+        #       match { ... }
+        #
+        #       description do
+        #         "qualify for #{expected}"
+        #       end
+        #     end
+        def description(&block)
+          cache_or_call_cached(:description, &block)
+        end
+
+        # Tells the matcher to diff the actual and expected values in the failure
+        # message.
+        def diffable
+          @diffable = true
+        end
+
+        # Convenience for defining methods on this matcher to create a fluent
+        # interface. The trick about fluent interfaces is that each method must
+        # return self in order to chain methods together. `chain` handles that
+        # for you.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_errors_on do |key|
+        #       chain :with do |message|
+        #         @message = message
+        #       end
+        #
+        #       match do |actual|
+        #         actual.errors[key] == @message
+        #       end
+        #     end
+        #
+        #     minor.should have_errors_on(:age).with("Not old enough to participate")
+        def chain(method, &block)
+          define_method method do |*args|
+            block.call(*args)
+            self
+          end
+        end
+
+        # @api private
+        # Used internally by objects returns by +should+ and +should_not+.
+        def diffable?
+          @diffable
+        end
+
+        # @api private
+        # Used internally by +should_not+
+        def does_not_match?(actual)
+          @actual = actual
+          @match_for_should_not_block ?
+            instance_eval_with_args(actual, &@match_for_should_not_block) :
+            !matches?(actual)
+        end
+
+        def respond_to?(method, include_private=false)
+          super || matcher_execution_context.respond_to?(method, include_private)
+        end
+
+        private
+
+        def method_missing(method, *args, &block)
+          if matcher_execution_context.respond_to?(method)
+            matcher_execution_context.__send__ method, *args, &block
+          else
+            super(method, *args, &block)
+          end
+        end
+
+        def include(*args)
+          singleton_class.__send__(:include, *args)
+        end
+
+        def define_method(name, &block)
+          singleton_class.__send__(:define_method, name, &block)
+        end
+
+        def making_declared_methods_public
+          # Our home-grown instance_exec in ruby 1.8.6 results in any methods
+          # declared in the block eval'd by instance_exec in the block to which we
+          # are yielding here are scoped private. This is NOT the case for Ruby
+          # 1.8.7 or 1.9.
+          #
+          # Also, due some crazy scoping that I don't understand, these methods
+          # are actually available in the specs (something about the matcher being
+          # defined in the scope of RSpec::Matchers or within an example), so not
+          # doing the following will not cause specs to fail, but they *will*
+          # cause features to fail and that will make users unhappy. So don't.
+          orig_private_methods = private_methods
+          yield
+          (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
+        end
+
+        def cache_or_call_cached(key, &block)
+          block ? cache(key, &block) : call_cached(key)
+        end
+
+        def cache(key, &block)
+          @messages[key] = block
+        end
+
+        def call_cached(key)
+          if @messages.has_key?(key)
+            @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
+          else
+            __send__("default_#{key}")
+          end
+        end
+
+        def default_description
+          "#{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def default_failure_message_for_should
+          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def default_failure_message_for_should_not
+          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        unless method_defined?(:singleton_class)
+          def singleton_class
+            class << self; self; end
+          end
+        end
+      end
+    end
+  end
+end