clickable_link 0.0.1 → 0.0.2

data/vendor/bundle/ruby/1.9.1/gems/rspec-core-2.14.5/lib/rspec/core/rake_task.rb

@@ -0,0 +1,206 @@
+require 'rspec/core/backward_compatibility'
+require 'rake'
+require 'rake/tasklib'
+require 'shellwords'
+
+module RSpec
+  module Core
+    class RakeTask < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      # Name of task.
+      #
+      # default:
+      #   :spec
+      attr_accessor :name
+
+      # Glob pattern to match files.
+      #
+      # default:
+      #   'spec/**/*_spec.rb'
+      attr_accessor :pattern
+
+      # @deprecated
+      # Has no effect. The rake task now checks ENV['BUNDLE_GEMFILE'] instead.
+      def skip_bundler=(*)
+        deprecate("RSpec::Core::RakeTask#skip_bundler=")
+      end
+
+      # @deprecated
+      # Has no effect. The rake task now checks ENV['BUNDLE_GEMFILE'] instead.
+      def gemfile=(*)
+        deprecate("RSpec::Core::RakeTask#gemfile=", :replacement => 'ENV["BUNDLE_GEMFILE"]')
+      end
+
+      # @deprecated
+      # Use ruby_opts="-w" instead.
+      #
+      # When true, requests that the specs be run with the warning flag set.
+      # e.g. "ruby -w"
+      #
+      # default:
+      #   false
+      def warning=(true_or_false)
+        deprecate("RSpec::Core::RakeTask#warning=", :replacement => 'ruby_opts="-w"')
+        @warning = true_or_false
+      end
+
+      # Whether or not to fail Rake when an error occurs (typically when examples fail).
+      #
+      # default:
+      #   true
+      attr_accessor :fail_on_error
+
+      # A message to print to stderr when there are failures.
+      attr_accessor :failure_message
+
+      # Use verbose output. If this is set to true, the task will print the
+      # executed spec command to stdout.
+      #
+      # default:
+      #   true
+      attr_accessor :verbose
+
+      # Use rcov for code coverage?
+      #
+      # Due to the many ways `rcov` can run, if this option is enabled, it is
+      # required that `require 'rspec/autorun'` appears in `spec_helper`.rb
+      #
+      # default:
+      #   false
+      attr_accessor :rcov
+
+      # Path to rcov.
+      #
+      # default:
+      #   'rcov'
+      attr_accessor :rcov_path
+
+      # Command line options to pass to rcov.
+      #
+      # default:
+      #   nil
+      attr_accessor :rcov_opts
+
+      # Command line options to pass to ruby.
+      #
+      # default:
+      #   nil
+      attr_accessor :ruby_opts
+
+      # Path to rspec
+      #
+      # default:
+      #   'rspec'
+      attr_accessor :rspec_path
+
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      attr_accessor :rspec_opts
+
+      # @deprecated
+      # Use rspec_opts instead.
+      #
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      def spec_opts=(opts)
+        deprecate('RSpec::Core::RakeTask#spec_opts=', :replacement => 'rspec_opts=')
+        @rspec_opts = opts
+      end
+
+      def initialize(*args, &task_block)
+        setup_ivars(args)
+
+        desc "Run RSpec code examples" unless ::Rake.application.last_comment
+
+        task name, *args do |_, task_args|
+          RakeFileUtils.send(:verbose, verbose) do
+            task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
+            run_task verbose
+          end
+        end
+      end
+
+      def setup_ivars(args)
+        @name = args.shift || :spec
+        @rcov_opts, @ruby_opts, @rspec_opts = nil, nil, nil
+        @warning, @rcov = false, false
+        @verbose, @fail_on_error = true, true
+
+        @rcov_path  = 'rcov'
+        @rspec_path = 'rspec'
+        @pattern    = './spec{,/*/**}/*_spec.rb'
+      end
+
+      def run_task(verbose)
+        command = spec_command
+
+        begin
+          puts command if verbose
+          success = system(command)
+        rescue
+          puts failure_message if failure_message
+        end
+        abort("#{command} failed") if fail_on_error unless success
+      end
+
+    private
+
+      if "".respond_to?(:shellescape)
+        def shellescape(string)
+          string.shellescape
+        end
+      else # 1.8.6's shellwords doesn't provide shellescape :(.
+        def shellescape(string)
+          string.gsub(/"/, '\"').gsub(/'/, "\\\\'")
+        end
+      end
+
+      def files_to_run
+        if ENV['SPEC']
+          FileList[ ENV['SPEC'] ].sort
+        else
+          FileList[ pattern ].sort.map { |f| shellescape(f) }
+        end
+      end
+
+      def spec_command
+        cmd_parts = []
+        cmd_parts << RUBY
+        cmd_parts << ruby_opts
+        cmd_parts << "-w" if @warning
+        cmd_parts << "-S" << runner
+        cmd_parts << "-Ispec:lib" << rcov_opts if rcov
+        cmd_parts << files_to_run
+        cmd_parts << "--" if rcov && rspec_opts
+        cmd_parts << rspec_opts
+        cmd_parts.flatten.reject(&blank).join(" ")
+      end
+
+      def runner
+        rcov ? rcov_path : rspec_path
+      end
+
+      def blank
+        lambda {|s| s.nil? || s == ""}
+      end
+
+      def deprecate deprecated, opts = {}
+        # unless RSpec is loaded, deprecate won't work (simply requiring the
+        # deprecate file isn't enough) so this is a check for "is rspec already
+        # loaded?" "ok use the main deprecate hook" otherwise "simple fallback"
+        # Note that we don't need rspec to be loaded for the rake task to work
+        if RSpec.respond_to?(:deprecate)
+          RSpec.deprecate deprecated, opts
+        else
+          warn "DEPRECATION: #{deprecated} is deprecated."
+        end
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-core-2.14.5/lib/rspec/core/reporter.rb

@@ -0,0 +1,132 @@
+module RSpec::Core
+  class Reporter
+    NOTIFICATIONS = %W[start message example_group_started example_group_finished example_started
+                       example_passed example_failed example_pending start_dump dump_pending
+                       dump_failures dump_summary seed close stop deprecation deprecation_summary].map { |n| n.to_sym }
+
+    def initialize(*formatters)
+      @listeners = Hash.new { |h,k| h[k] = [] }
+      formatters.each do |formatter|
+        register_listener(formatter, *NOTIFICATIONS)
+      end
+      @example_count = @failure_count = @pending_count = 0
+      @duration = @start = nil
+    end
+
+    # @api
+    # @param [Object] An obect that wishes to be notified of reporter events
+    # @param [Array] Array of symbols represents the events a listener wishes to subscribe too
+    #
+    # Registers a listener to a list of notifications. The reporter will send notification of
+    # events to all registered listeners
+    def register_listener(listener, *notifications)
+      notifications.each do |notification|
+        @listeners[notification.to_sym] << listener if listener.respond_to?(notification)
+      end
+      true
+    end
+
+    def registered_listeners(notification)
+      @listeners[notification]
+    end
+
+    # @api
+    # @overload report(count, &block)
+    # @overload report(count, seed, &block)
+    # @param [Integer] count the number of examples being run
+    # @param [Integer] seed the seed used to randomize the spec run
+    # @param [Block] block yields itself for further reporting.
+    #
+    # Initializes the report run and yields itself for further reporting. The
+    # block is required, so that the reporter can manage cleaning up after the
+    # run.
+    #
+    # ### Warning:
+    #
+    # The `seed` argument is an internal API and is not guaranteed to be
+    # supported in the future.
+    #
+    # @example
+    #
+    #     reporter.report(group.examples.size) do |r|
+    #       example_groups.map {|g| g.run(r) }
+    #     end
+    #
+    def report(expected_example_count, seed=nil)
+      start(expected_example_count)
+      begin
+        yield self
+      ensure
+        finish(seed)
+      end
+    end
+
+    def start(expected_example_count)
+      @start = RSpec::Core::Time.now
+      notify :start, expected_example_count
+    end
+
+    def message(message)
+      notify :message, message
+    end
+
+    def example_group_started(group)
+      notify :example_group_started, group unless group.descendant_filtered_examples.empty?
+    end
+
+    def example_group_finished(group)
+      notify :example_group_finished, group unless group.descendant_filtered_examples.empty?
+    end
+
+    def example_started(example)
+      @example_count += 1
+      notify :example_started, example
+    end
+
+    def example_passed(example)
+      notify :example_passed, example
+    end
+
+    def example_failed(example)
+      @failure_count += 1
+      notify :example_failed, example
+    end
+
+    def example_pending(example)
+      @pending_count += 1
+      notify :example_pending, example
+    end
+
+    def deprecation(message)
+      notify :deprecation, message
+    end
+
+    def finish(seed)
+      begin
+        stop
+        notify :start_dump
+        notify :dump_pending
+        notify :dump_failures
+        notify :dump_summary, @duration, @example_count, @failure_count, @pending_count
+        notify :deprecation_summary
+        notify :seed, seed if seed
+      ensure
+        notify :close
+      end
+    end
+
+    alias_method :abort, :finish
+
+    def stop
+      @duration = (RSpec::Core::Time.now - @start).to_f if @start
+      notify :stop
+    end
+
+    def notify(event, *args, &block)
+      registered_listeners(event).each do |formatter|
+        formatter.send(event, *args, &block)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-core-2.14.5/lib/rspec/core/ruby_project.rb

@@ -0,0 +1,44 @@
+# This is borrowed (slightly modified) from Scott Taylor's
+# project_path project:
+#   http://github.com/smtlaissezfaire/project_path
+
+require 'pathname'
+
+module RSpec
+  module Core
+    module RubyProject
+      def add_to_load_path(*dirs)
+        dirs.map {|dir| add_dir_to_load_path(File.join(root, dir))}
+      end
+
+      def add_dir_to_load_path(dir)
+        $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+      end
+
+      def root
+        @project_root ||= determine_root
+      end
+
+      def determine_root
+        find_first_parent_containing('spec') || '.'
+      end
+
+      def find_first_parent_containing(dir)
+        ascend_until {|path| File.exists?(File.join(path, dir))}
+      end
+
+      def ascend_until
+        Pathname(File.expand_path('.')).ascend do |path|
+          return path if yield(path)
+        end
+      end
+
+      module_function :add_to_load_path
+      module_function :add_dir_to_load_path
+      module_function :root
+      module_function :determine_root
+      module_function :find_first_parent_containing
+      module_function :ascend_until
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rspec-core-2.14.5/lib/rspec/core/runner.rb

@@ -0,0 +1,87 @@
+module RSpec
+  module Core
+    class Runner
+
+      # Register an at_exit hook that runs the suite.
+      def self.autorun
+        return if autorun_disabled? || installed_at_exit? || running_in_drb?
+        at_exit do
+          # Don't bother running any specs and just let the program terminate
+          # if we got here due to an unrescued exception (anything other than
+          # SystemExit, which is raised when somebody calls Kernel#exit).
+          next unless $!.nil? || $!.kind_of?(SystemExit)
+
+          # We got here because either the end of the program was reached or
+          # somebody called Kernel#exit.  Run the specs and then override any
+          # existing exit status with RSpec's exit status if any specs failed.
+          status = run(ARGV, $stderr, $stdout).to_i
+          exit status if status != 0
+        end
+        @installed_at_exit = true
+      end
+      AT_EXIT_HOOK_BACKTRACE_LINE = "#{__FILE__}:#{__LINE__ - 2}:in `autorun'"
+
+      def self.disable_autorun!
+        @autorun_disabled = true
+      end
+
+      def self.autorun_disabled?
+        @autorun_disabled ||= false
+      end
+
+      def self.installed_at_exit?
+        @installed_at_exit ||= false
+      end
+
+      def self.running_in_drb?
+        defined?(DRb) &&
+        (DRb.current_server rescue false) &&
+         DRb.current_server.uri =~ /druby\:\/\/127.0.0.1\:/
+      end
+
+      def self.trap_interrupt
+        trap('INT') do
+          exit!(1) if RSpec.wants_to_quit
+          RSpec.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+
+      # Run a suite of RSpec examples.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like spec_helper.rb to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # #### Parameters
+      # * +args+ - an array of command-line-supported arguments
+      # * +err+ - error stream (Default: $stderr)
+      # * +out+ - output stream (Default: $stdout)
+      #
+      # #### Returns
+      # * +Fixnum+ - exit status code (0/1)
+      def self.run(args, err=$stderr, out=$stdout)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+        options.parse_options
+
+        if options.options[:drb]
+          require 'rspec/core/drb_command_line'
+          begin
+            DRbCommandLine.new(options).run(err, out)
+          rescue DRb::DRbConnError
+            err.puts "No DRb server is running. Running in local process instead ..."
+            CommandLine.new(options).run(err, out)
+          end
+        else
+          CommandLine.new(options).run(err, out)
+        end
+      ensure
+        RSpec.reset
+      end
+    end
+  end
+end