dxruby_rp5 0.0.1

data/spec/vendor/rspec-core-2.14.7/lib/rspec/core/option_parser.rb

@@ -0,0 +1,219 @@
+# http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html
+require 'optparse'
+
+module RSpec::Core
+  class Parser
+    def self.parse!(args)
+      new.parse!(args)
+    end
+
+    class << self
+      alias_method :parse, :parse!
+    end
+
+    def parse!(args)
+      return {} if args.empty?
+
+      convert_deprecated_args(args)
+
+      options = args.delete('--tty') ? {:tty => true} : {}
+      begin
+        parser(options).parse!(args)
+      rescue OptionParser::InvalidOption => e
+        abort "#{e.message}\n\nPlease use --help for a listing of valid options"
+      end
+
+      options
+    end
+
+    def convert_deprecated_args(args)
+      args.map! { |arg|
+        case arg
+        when "--formatter"
+          RSpec.deprecate("the --formatter option", :replacement => "-f or --format")
+          "--format"
+        when "--default_path"
+          "--default-path"
+        when "--line_number"
+          "--line-number"
+        else
+          arg
+        end
+      }
+    end
+
+    alias_method :parse, :parse!
+
+    def parser(options)
+      OptionParser.new do |parser|
+        parser.banner = "Usage: rspec [options] [files or directories]\n\n"
+
+        parser.on('-I PATH', 'Specify PATH to add to $LOAD_PATH (may be used more than once).') do |dir|
+          options[:libs] ||= []
+          options[:libs] << dir
+        end
+
+        parser.on('-r', '--require PATH', 'Require a file.') do |path|
+          options[:requires] ||= []
+          options[:requires] << path
+        end
+
+        parser.on('-O', '--options PATH', 'Specify the path to a custom options file.') do |path|
+          options[:custom_options_file] = path
+        end
+
+        parser.on('--order TYPE[:SEED]', 'Run examples by the specified order type.',
+                  '  [default] files are ordered based on the underlying file',
+                  '            system\'s order',
+                  '  [rand]    randomize the order of files, groups and examples',
+                  '  [random]  alias for rand',
+                  '  [random:SEED] e.g. --order random:123') do |o|
+          options[:order] = o
+        end
+
+        parser.on('--seed SEED', Integer, 'Equivalent of --order rand:SEED.') do |seed|
+          options[:order] = "rand:#{seed}"
+        end
+
+        parser.on('-d', '--debugger', 'Enable debugging.') do |o|
+          options[:debug] = true
+        end
+
+        parser.on('--fail-fast', 'Abort the run on first failure.') do |o|
+          options[:fail_fast] = true
+        end
+
+        parser.on('--failure-exit-code CODE', Integer, 'Override the exit code used when there are failing specs.') do |code|
+          options[:failure_exit_code] = code
+        end
+
+        parser.on('-X', '--[no-]drb', 'Run examples via DRb.') do |o|
+          options[:drb] = o
+        end
+
+        parser.on('--drb-port PORT', 'Port to connect to the DRb server.') do |o|
+          options[:drb_port] = o.to_i
+        end
+
+        parser.on('--init', 'Initialize your project with RSpec.') do |cmd|
+          ProjectInitializer.new(cmd).run
+          exit
+        end
+
+        parser.on('--configure', 'Deprecated. Use --init instead.') do |cmd|
+          warn "--configure is deprecated with no effect. Use --init instead."
+          exit
+        end
+
+        parser.separator("\n  **** Output ****\n\n")
+
+        parser.on('-f', '--format FORMATTER', 'Choose a formatter.',
+                '  [p]rogress (default - dots)',
+                '  [d]ocumentation (group and example names)',
+                '  [h]tml',
+                '  [t]extmate',
+                '  [j]son',
+                '  custom formatter class name') do |o|
+          options[:formatters] ||= []
+          options[:formatters] << [o]
+        end
+
+        parser.on('-o', '--out FILE',
+                  'Write output to a file instead of $stdout. This option applies',
+                  '  to the previously specified --format, or the default format',
+                  '  if no format is specified.'
+                 ) do |o|
+          options[:formatters] ||= [['progress']]
+          options[:formatters].last << o
+        end
+
+        parser.on('-b', '--backtrace', 'Enable full backtrace.') do |o|
+          options[:full_backtrace] = true
+        end
+
+        parser.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output.') do |o|
+          options[:color] = o
+        end
+
+        parser.on('-p', '--[no-]profile [COUNT]', 'Enable profiling of examples and list the slowest examples (default: 10).') do |argument|
+          options[:profile_examples] = if argument.nil?
+                                         true
+                                       elsif argument == false
+                                         false
+                                       else
+                                         begin
+                                           Integer(argument)
+                                         rescue ArgumentError
+                                           Kernel.warn "Non integer specified as profile count, seperate " +
+                                                       "your path from options with -- e.g. " +
+                                                       "`rspec --profile -- #{argument}`"
+                                           true
+                                         end
+                                       end
+        end
+
+        parser.on('-w', '--warnings', 'Enable ruby warnings') do
+          options[:warnings] = true
+        end
+
+        parser.separator <<-FILTERING
+
+  **** Filtering/tags ****
+
+    In addition to the following options for selecting specific files, groups,
+    or examples, you can select a single example by appending the line number to
+    the filename:
+
+      rspec path/to/a_spec.rb:37
+
+FILTERING
+
+        parser.on('-P', '--pattern PATTERN', 'Load files matching pattern (default: "spec/**/*_spec.rb").') do |o|
+          options[:pattern] = o
+        end
+
+        parser.on('-e', '--example STRING', "Run examples whose full nested names include STRING (may be",
+                                            "  used more than once)") do |o|
+          (options[:full_description] ||= []) << Regexp.compile(Regexp.escape(o))
+        end
+
+        parser.on('-l', '--line-number LINE', 'Specify line number of an example or group (may be',
+                                              '  used more than once).') do |o|
+          (options[:line_numbers] ||= []) << o
+        end
+
+        parser.on('-t', '--tag TAG[:VALUE]',
+                  'Run examples with the specified tag, or exclude examples',
+                  'by adding ~ before the tag.',
+                  '  - e.g. ~slow',
+                  '  - TAG is always converted to a symbol') do |tag|
+          filter_type = tag =~ /^~/ ? :exclusion_filter : :inclusion_filter
+
+          name,value = tag.gsub(/^(~@|~|@)/, '').split(':')
+          name = name.to_sym
+
+          options[filter_type] ||= {}
+          options[filter_type][name] = value.nil? ? true : eval(value) rescue value
+        end
+
+        parser.on('--default-path PATH', 'Set the default path where RSpec looks for examples (can',
+                                         '  be a path to a file or a directory).') do |path|
+          options[:default_path] = path
+        end
+
+        parser.separator("\n  **** Utility ****\n\n")
+
+        parser.on('-v', '--version', 'Display the version.') do
+          puts RSpec::Core::Version::STRING
+          exit
+        end
+
+        parser.on_tail('-h', '--help', "You're looking at it.") do
+          puts parser
+          exit
+        end
+
+      end
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/lib/rspec/core/pending.rb

@@ -0,0 +1,113 @@
+module RSpec
+  module Core
+    module Pending
+      class PendingDeclaredInExample < StandardError; end
+
+      # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
+      # will report unmet RSpec expectations as failures rather than errors.
+      begin
+        class PendingExampleFixedError < Test::Unit::AssertionFailedError; end
+      rescue
+        class PendingExampleFixedError < StandardError; end
+      end
+
+      NO_REASON_GIVEN = 'No reason given'
+      NOT_YET_IMPLEMENTED = 'Not yet implemented'
+
+      # @overload pending()
+      # @overload pending(message)
+      # @overload pending(message, &block)
+      #
+      # Stops execution of an example, and reports it as pending. Takes an
+      # optional message and block.
+      #
+      # @param [String] message optional message to add to the summary report.
+      # @param [Block] block optional block. If it fails, the example is
+      #   reported as pending. If it executes cleanly the example fails.
+      #
+      # @example
+      #
+      #     describe "an example" do
+      #       # reported as "Pending: no reason given"
+      #       it "is pending with no message" do
+      #         pending
+      #         this_does_not_get_executed
+      #       end
+      #
+      #       # reported as "Pending: something else getting finished"
+      #       it "is pending with a custom message" do
+      #         pending("something else getting finished")
+      #         this_does_not_get_executed
+      #       end
+      #
+      #       # reported as "Pending: something else getting finished"
+      #       it "is pending with a failing block" do
+      #         pending("something else getting finished") do
+      #           raise "this is the failure"
+      #         end
+      #       end
+      #
+      #       # reported as failure, saying we expected the block to fail but
+      #       # it passed.
+      #       it "is pending with a passing block" do
+      #         pending("something else getting finished") do
+      #           true.should be(true)
+      #         end
+      #       end
+      #     end
+      #
+      # @note `before(:each)` hooks are eval'd when you use the `pending`
+      #   method within an example. If you want to declare an example `pending`
+      #   and bypass the `before` hooks as well, you can pass `:pending => true`
+      #   to the `it` method:
+      #
+      #       it "does something", :pending => true do
+      #         # ...
+      #       end
+      #
+      #   or pass `:pending => "something else getting finished"` to add a
+      #   message to the summary report:
+      #
+      #       it "does something", :pending => "something else getting finished" do
+      #         # ...
+      #       end
+      def pending(*args)
+        return self.class.before(:each) { pending(*args) } unless example
+
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        message = args.first || NO_REASON_GIVEN
+
+        if options[:unless] || (options.has_key?(:if) && !options[:if])
+          return block_given? ? yield : nil
+        end
+
+        example.metadata[:pending] = true
+        example.metadata[:execution_result][:pending_message] = message
+        example.execution_result[:pending_fixed] = false
+        if block_given?
+          begin
+            result = begin
+                       yield
+                       example.example_group_instance.instance_eval { verify_mocks_for_rspec }
+                       true
+                     end
+            example.metadata[:pending] = false
+          rescue Exception => e
+            example.execution_result[:exception] = e
+          ensure
+            teardown_mocks_for_rspec
+          end
+          if result
+            example.execution_result[:pending_fixed] = true
+            raise PendingExampleFixedError.new
+          end
+        end
+        raise PendingDeclaredInExample.new(message)
+      end
+    end
+
+    # Alias the error for compatibility with extension gems (e.g. formatters)
+    # that depend on the const name of the error in RSpec <= 2.8.
+    PendingExampleFixedError = Pending::PendingExampleFixedError
+  end
+end

data/spec/vendor/rspec-core-2.14.7/lib/rspec/core/project_initializer.rb

@@ -0,0 +1,86 @@
+module RSpec
+  module Core
+    class ProjectInitializer
+      def initialize(arg=nil)
+        @arg = arg
+      end
+
+      def run
+        create_spec_helper_file
+        create_dot_rspec_file
+        delete_if_confirmed("autotest/discover.rb", <<-MESSAGE)
+  RSpec registers its own discover.rb with Autotest, so autotest/discover.rb is
+  no longer needed.
+        MESSAGE
+
+        delete_if_confirmed("lib/tasks/rspec.rake", <<-MESSAGE)
+  If the file in lib/tasks/rspec.rake is the one generated by rspec-rails-1x,
+  you can get rid of it, as it is no longer needed with rspec-2.
+        MESSAGE
+      end
+
+      def create_dot_rspec_file
+        if File.exist?('.rspec')
+          report_exists('.rspec')
+        else
+          report_creating('.rspec')
+          File.open('.rspec','w') do |f|
+            f.write <<-CONTENT
+--color
+--format progress
+CONTENT
+          end
+        end
+      end
+
+      def create_spec_helper_file
+        if File.exist?('spec/spec_helper.rb')
+          report_exists("spec/spec_helper.rb")
+        else
+          report_creating("spec/spec_helper.rb")
+          FileUtils.mkdir_p('spec')
+          File.open('spec/spec_helper.rb','w') do |f|
+            f.write <<-CONTENT
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+CONTENT
+          end
+        end
+      end
+
+      def delete_if_confirmed(path, message)
+        if File.exist?(path)
+          puts
+          puts message
+          puts
+          puts "  delete   #{path}? [y/n]"
+          FileUtils.rm_rf(path) if gets =~ /y/i
+        end
+      end
+
+      def report_exists(file)
+        puts "   exist   #{file}"
+      end
+
+      def report_creating(file)
+        puts "  create   #{file}"
+      end
+
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/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