opal-rspec-cj 0.4.4

data/vendor_lib/rspec/core/configuration_options.rb

@@ -0,0 +1,143 @@
+require 'erb'
+require 'shellwords'
+
+module RSpec
+  module Core
+    # @private
+    class ConfigurationOptions
+      attr_reader :options
+
+      def initialize(args)
+        @args = args.map {|a|
+          a.sub("default_path", "default-path").sub("line_number",  "line-number")
+        }
+      end
+
+      def configure(config)
+        config.filter_manager = filter_manager
+
+        config.libs = options[:libs] || []
+        config.setup_load_path_and_require(options[:requires] || [])
+
+        process_options_into config
+        load_formatters_into config
+      end
+
+      def parse_options
+        @options = (file_options << command_line_options << env_options).
+          each {|opts|
+            filter_manager.include opts.delete(:inclusion_filter) if opts.has_key?(:inclusion_filter)
+            filter_manager.exclude opts.delete(:exclusion_filter) if opts.has_key?(:exclusion_filter)
+          }.
+          inject {|h, opts|
+            h.merge(opts) {|k, oldval, newval|
+              [:libs, :requires].include?(k) ? oldval + newval : newval
+            }
+          }
+      end
+
+      def drb_argv
+        DrbOptions.new(options, filter_manager).options
+      end
+
+      def filter_manager
+        @filter_manager ||= RSpec::configuration.filter_manager
+      end
+
+    private
+
+      UNFORCED_OPTIONS = [
+        :requires, :profile, :drb, :libs, :files_or_directories_to_run,
+        :line_numbers, :full_description, :full_backtrace, :tty
+      ].to_set
+
+      UNPROCESSABLE_OPTIONS = [:libs, :formatters, :requires].to_set
+
+      def force?(key)
+        !UNFORCED_OPTIONS.include?(key)
+      end
+
+      def order(keys, *ordered)
+        ordered.reverse.each do |key|
+          keys.unshift(key) if keys.delete(key)
+        end
+        keys
+      end
+
+      def process_options_into(config)
+        opts = options.reject { |k, _| UNPROCESSABLE_OPTIONS.include? k }
+
+        order(opts.keys, :default_path, :pattern).each do |key|
+          force?(key) ? config.force(key => opts[key]) : config.send("#{key}=", opts[key])
+        end
+      end
+
+      def load_formatters_into(config)
+        options[:formatters].each { |pair| config.add_formatter(*pair) } if options[:formatters]
+      end
+
+      def file_options
+        custom_options_file ? [custom_options] : [global_options, project_options, local_options]
+      end
+
+      def env_options
+        ENV["SPEC_OPTS"] ? Parser.parse!(Shellwords.split(ENV["SPEC_OPTS"])) : {}
+      end
+
+      def command_line_options
+        @command_line_options ||= Parser.parse!(@args).merge :files_or_directories_to_run => @args
+      end
+
+      def custom_options
+        options_from(custom_options_file)
+      end
+
+      def local_options
+        @local_options ||= options_from(local_options_file)
+      end
+
+      def project_options
+        @project_options ||= options_from(project_options_file)
+      end
+
+      def global_options
+        @global_options ||= options_from(global_options_file)
+      end
+
+      def options_from(path)
+        Parser.parse(args_from_options_file(path))
+      end
+
+      def args_from_options_file(path)
+        return [] unless path && File.exist?(path)
+        config_string = options_file_as_erb_string(path)
+        FlatMap.flat_map(config_string.split(/\n+/), &:shellsplit)
+      end
+
+      def options_file_as_erb_string(path)
+        ERB.new(File.read(path), nil, '-').result(binding)
+      end
+
+      def custom_options_file
+        command_line_options[:custom_options_file]
+      end
+
+      def project_options_file
+        ".rspec"
+      end
+
+      def local_options_file
+        ".rspec-local"
+      end
+
+      def global_options_file
+        begin
+          File.join(File.expand_path("~"), ".rspec")
+        rescue ArgumentError
+          RSpec.warning "Unable to find ~/.rspec because the HOME environment variable is not set"
+          nil
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/drb_command_line.rb

@@ -0,0 +1,26 @@
+require 'drb/drb'
+require 'rspec/core/drb_options'
+
+module RSpec
+  module Core
+    class DRbCommandLine
+      def initialize(options)
+        @options = options
+      end
+
+      def drb_port
+        @options.options[:drb_port] || ENV['RSPEC_DRB'] || 8989
+      end
+
+      def run(err, out)
+        begin
+          DRb.start_service("druby://localhost:0")
+        rescue SocketError, Errno::EADDRNOTAVAIL
+          DRb.start_service("druby://:0")
+        end
+        spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{drb_port}")
+        spec_server.run(@options.drb_argv, err, out)
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/drb_options.rb

@@ -0,0 +1,87 @@
+# Builds command line arguments to pass to the rspec command over DRb
+
+module RSpec::Core
+  # @private
+  class DrbOptions
+    def initialize(submitted_options, filter_manager)
+      @submitted_options = submitted_options
+      @filter_manager = filter_manager
+    end
+
+    def options
+      argv = []
+      argv << "--color"        if @submitted_options[:color]
+      argv << "--profile"      if @submitted_options[:profile_examples]
+      argv << "--backtrace"    if @submitted_options[:full_backtrace]
+      argv << "--tty"          if @submitted_options[:tty]
+      argv << "--fail-fast"    if @submitted_options[:fail_fast]
+      argv << "--options"      << @submitted_options[:custom_options_file] if @submitted_options[:custom_options_file]
+      argv << "--order"        << @submitted_options[:order]               if @submitted_options[:order]
+
+      add_failure_exit_code(argv)
+      add_full_description(argv)
+      add_line_numbers(argv)
+      add_filter(argv, :inclusion, @filter_manager.inclusions)
+      add_filter(argv, :exclusion, @filter_manager.exclusions)
+      add_formatters(argv)
+      add_libs(argv)
+      add_requires(argv)
+
+      argv + @submitted_options[:files_or_directories_to_run]
+    end
+
+    def add_failure_exit_code(argv)
+      if @submitted_options[:failure_exit_code]
+        argv << "--failure-exit-code" << @submitted_options[:failure_exit_code].to_s
+      end
+    end
+
+    def add_full_description(argv)
+      if @submitted_options[:full_description]
+        # The argument to --example is regexp-escaped before being stuffed
+        # into a regexp when received for the first time (see OptionParser).
+        # Hence, merely grabbing the source of this regexp will retain the
+        # backslashes, so we must remove them.
+        @submitted_options[:full_description].each do |description|
+          argv << "--example" << description.source.delete('\\')
+        end
+      end
+    end
+
+    def add_line_numbers(argv)
+      if @submitted_options[:line_numbers]
+        argv.push(*@submitted_options[:line_numbers].inject([]){|a,l| a << "--line_number" << l})
+      end
+    end
+
+    CONDITIONAL_FILTERS = [:if, :unless]
+
+    def add_filter(argv, name, hash)
+      hash.each_pair do |k, v|
+        next if CONDITIONAL_FILTERS.include?(k)
+        tag = name == :inclusion ? k.to_s : "~#{k}"
+        tag << ":#{v}" if v.is_a?(String)
+        argv << "--tag" << tag
+      end unless hash.empty?
+    end
+
+    def add_formatters(argv)
+      @submitted_options[:formatters].each do |pair|
+        argv << "--format" << pair[0]
+        argv << "--out" << pair[1] if pair[1]
+      end if @submitted_options[:formatters]
+    end
+
+    def add_libs(argv)
+      @submitted_options[:libs].each do |path|
+        argv << "-I" << path
+      end if @submitted_options[:libs]
+    end
+
+    def add_requires(argv)
+      @submitted_options[:requires].each do |path|
+        argv << "--require" << path
+      end if @submitted_options[:requires]
+    end
+  end
+end

data/vendor_lib/rspec/core/dsl.rb

@@ -0,0 +1,26 @@
+module RSpec
+  module Core
+    # Adds the `describe` method to the top-level namespace.
+    module DSL
+      # Generates a subclass of {ExampleGroup}
+      #
+      # ## Examples:
+      #
+      #     describe "something" do
+      #       it "does something" do
+      #         # example code goes here
+      #       end
+      #     end
+      #
+      # @see ExampleGroup
+      # @see ExampleGroup.describe
+      def describe(*args, &example_group_block)
+        RSpec::Core::ExampleGroup.describe(*args, &example_group_block).register
+      end
+    end
+  end
+end
+
+extend RSpec::Core::DSL
+Module.send(:include, RSpec::Core::DSL)
+

data/vendor_lib/rspec/core/example.rb

@@ -0,0 +1,312 @@
+module RSpec
+  module Core
+    # Wrapper for an instance of a subclass of {ExampleGroup}. An instance of
+    # `Example` is returned by the {ExampleGroup#example example} method
+    # exposed to examples, {Hooks#before before} and {Hooks#after after} hooks,
+    # and yielded to {Hooks#around around} hooks.
+    #
+    # Useful for configuring logging and/or taking some action based
+    # on the state of an example's metadata.
+    #
+    # @example
+    #
+    #     RSpec.configure do |config|
+    #       config.before do
+    #         log example.description
+    #       end
+    #
+    #       config.after do
+    #         log example.description
+    #       end
+    #
+    #       config.around do |ex|
+    #         log example.description
+    #         ex.run
+    #       end
+    #     end
+    #
+    #     shared_examples "auditable" do
+    #       it "does something" do
+    #         log "#{example.full_description}: #{auditable.inspect}"
+    #         auditable.should do_something
+    #       end
+    #     end
+    #
+    # @see ExampleGroup
+    class Example
+      # @private
+      #
+      # Used to define methods that delegate to this example's metadata
+      def self.delegate_to_metadata(*keys)
+        keys.each { |key| define_method(key) { @metadata[key] } }
+      end
+
+      delegate_to_metadata :full_description, :execution_result, :file_path, :pending, :location
+
+      # Returns the string submitted to `example` or its aliases (e.g.
+      # `specify`, `it`, etc).  If no string is submitted (e.g. `it { should
+      # do_something }`) it returns the message generated by the matcher if
+      # there is one, otherwise returns a message including the location of the
+      # example.
+      def description
+        description = metadata[:description].to_s.empty? ? "example at #{location}" : metadata[:description]
+        RSpec.configuration.format_docstrings_block.call(description)
+      end
+
+      # @attr_reader
+      #
+      # Returns the first exception raised in the context of running this
+      # example (nil if no exception is raised)
+      attr_reader :exception
+
+      # @attr_reader
+      #
+      # Returns the metadata object associated with this example.
+      attr_reader :metadata
+
+      # @attr_reader
+      # @private
+      #
+      # Returns the example_group_instance that provides the context for
+      # running this example.
+      attr_reader :example_group_instance
+
+      # Creates a new instance of Example.
+      # @param example_group_class the subclass of ExampleGroup in which this Example is declared
+      # @param description the String passed to the `it` method (or alias)
+      # @param metadata additional args passed to `it` to be used as metadata
+      # @param example_block the block of code that represents the example
+      def initialize(example_group_class, description, metadata, example_block=nil)
+        @example_group_class, @options, @example_block = example_group_class, metadata, example_block
+        @metadata  = @example_group_class.metadata.for_example(description, metadata)
+        @example_group_instance = @exception = nil
+        @pending_declared_in_example = false
+      end
+
+      # @deprecated access options via metadata instead
+      def options
+        @options
+      end
+
+      # Returns the example group class that provides the context for running
+      # this example.
+      def example_group
+        @example_group_class
+      end
+
+      alias_method :pending?, :pending
+
+      # @api private
+      # instance_evals the block passed to the constructor in the context of
+      # the instance of {ExampleGroup}.
+      # @param example_group_instance the instance of an ExampleGroup subclass
+      def run(example_group_instance, reporter)
+        @example_group_instance = example_group_instance
+        RSpec.current_example = self
+
+        start(reporter)
+
+        begin
+          unless pending || RSpec.configuration.dry_run?
+            with_around_each_hooks do
+              begin
+                run_before_each
+                @example_group_instance.instance_exec(self, &@example_block)
+              rescue Pending::PendingDeclaredInExample => e
+                @pending_declared_in_example = e.message
+              rescue Exception => e
+                set_exception(e)
+              ensure
+                run_after_each
+              end
+            end
+          end
+        rescue Exception => e
+          set_exception(e)
+        ensure
+          @example_group_instance.instance_variables.each do |ivar|
+            @example_group_instance.instance_variable_set(ivar, nil)
+          end
+          @example_group_instance = nil
+
+          begin
+            assign_generated_description
+          rescue Exception => e
+            set_exception(e, "while assigning the example description")
+          end
+        end
+
+        finish(reporter)
+      ensure
+        RSpec.current_example = nil
+      end
+
+      # Wraps a `Proc` and exposes a `run` method for use in {Hooks#around
+      # around} hooks.
+      #
+      # @note Procsy, itself, is not a public API, but we're documenting it
+      #   here to document how to interact with the object yielded to an
+      #   `around` hook.
+      #
+      # @example
+      #
+      #     RSpec.configure do |c|
+      #       c.around do |ex| # Procsy which wraps the example
+      #         if ex.metadata[:key] == :some_value && some_global_condition
+      #           raise "some message"
+      #         end
+      #         ex.run         # run delegates to ex.call
+      #       end
+      #     end
+      class Procsy
+        # The `metadata` of the {Example} instance.
+        attr_reader :metadata
+
+        Proc.public_instance_methods(false).each do |name|
+          define_method(name) { |*a, &b| @proc.__send__(name, *a, &b) }
+        end
+        alias run call
+
+        def initialize(metadata, &block)
+          @metadata = metadata
+          @proc = block
+        end
+
+        # @api private
+        def wrap(&block)
+          self.class.new(metadata, &block)
+        end
+      end
+
+      # @private
+      def any_apply?(filters)
+        metadata.any_apply?(filters)
+      end
+
+      # @private
+      def all_apply?(filters)
+        @metadata.all_apply?(filters) || @example_group_class.all_apply?(filters)
+      end
+
+      # @private
+      def around_each_hooks
+        @around_each_hooks ||= example_group.around_each_hooks_for(self)
+      end
+
+      # @private
+      #
+      # Used internally to set an exception in an after hook, which
+      # captures the exception but doesn't raise it.
+      def set_exception(exception, context=nil)
+        if @exception && context != :dont_print
+          # An error has already been set; we don't want to override it,
+          # but we also don't want silence the error, so let's print it.
+          msg = <<-EOS
+
+An error occurred #{context}
+  #{exception.class}: #{exception.message}
+  occurred at #{exception.backtrace.first}
+
+          EOS
+          RSpec.configuration.reporter.message(msg)
+        end
+
+        @exception ||= exception
+      end
+
+      # @private
+      #
+      # Used internally to set an exception and fail without actually executing
+      # the example when an exception is raised in before(:all).
+      def fail_with_exception(reporter, exception)
+        start(reporter)
+        set_exception(exception)
+        finish(reporter)
+      end
+
+      # @private
+      def instance_exec_with_rescue(context = nil, &block)
+        @example_group_instance.instance_exec_with_rescue(self, context, &block)
+      end
+
+      # @private
+      def instance_exec(*args, &block)
+        @example_group_instance.instance_exec(*args, &block)
+      end
+
+    private
+
+      def with_around_each_hooks(&block)
+        if around_each_hooks.empty?
+          yield
+        else
+          @example_group_class.run_around_each_hooks(self, Procsy.new(metadata, &block))
+        end
+      rescue Exception => e
+        set_exception(e, "in an around(:each) hook")
+      end
+
+      def start(reporter)
+        reporter.example_started(self)
+        record :started_at => RSpec::Core::Time.now
+      end
+
+      def finish(reporter)
+        if @exception
+          record_finished 'failed', :exception => @exception
+          reporter.example_failed self
+          false
+        elsif @pending_declared_in_example
+          record_finished 'pending', :pending_message => @pending_declared_in_example
+          reporter.example_pending self
+          true
+        elsif pending
+          record_finished 'pending', :pending_message => String === pending ? pending : Pending::NO_REASON_GIVEN
+          reporter.example_pending self
+          true
+        else
+          record_finished 'passed'
+          reporter.example_passed self
+          true
+        end
+      end
+
+      def record_finished(status, results={})
+        finished_at = RSpec::Core::Time.now
+        record results.merge(:status => status, :finished_at => finished_at, :run_time => (finished_at - execution_result[:started_at]).to_f)
+      end
+
+      def run_before_each
+        @example_group_instance.setup_mocks_for_rspec
+        @example_group_class.run_before_each_hooks(self)
+      end
+
+      def run_after_each
+        @example_group_class.run_after_each_hooks(self)
+        verify_mocks
+      rescue Exception => e
+        set_exception(e, "in an after(:each) hook")
+      ensure
+        @example_group_instance.teardown_mocks_for_rspec
+      end
+
+      def verify_mocks
+        @example_group_instance.verify_mocks_for_rspec
+      rescue Exception => e
+        set_exception(e, :dont_print)
+      end
+
+      def assign_generated_description
+        return unless RSpec.configuration.expecting_with_rspec?
+        if metadata[:description_args].empty? and !pending?
+          metadata[:description_args] << RSpec::Matchers.generated_description
+        end
+        RSpec::Matchers.clear_generated_description
+      end
+
+      def record(results={})
+        execution_result.update(results)
+      end
+    end
+  end
+end