rango 0.1.pre → 0.1.0

data/vendor/rspec/lib/spec/runner/options.rb

@@ -1,400 +0,0 @@
-require 'ostruct'
-
-module Spec
-  module Runner
-    class Options
-      FILE_SORTERS = {
-        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
-      }
-
-      EXAMPLE_FORMATTERS = { # Load these lazily for better speed
-                'silent' => ['spec/runner/formatter/silent_formatter',                 'Formatter::SilentFormatter'],
-                     'l' => ['spec/runner/formatter/silent_formatter',                 'Formatter::SilentFormatter'],
-               'specdoc' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
-                     's' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
-                'nested' => ['spec/runner/formatter/nested_text_formatter',            'Formatter::NestedTextFormatter'],
-                     'n' => ['spec/runner/formatter/nested_text_formatter',            'Formatter::NestedTextFormatter'],
-                  'html' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
-                     'h' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
-              'progress' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
-                     'p' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
-      'failing_examples' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
-                     'e' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
-'failing_example_groups' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
-                     'g' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
-               'profile' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
-                     'o' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
-              'textmate' => ['spec/runner/formatter/text_mate_formatter',              'Formatter::TextMateFormatter']
-      }
-
-      attr_accessor(
-        :autospec, # hack to tell
-        :filename_pattern,
-        :backtrace_tweaker,
-        :context_lines,
-        :diff_format,
-        :dry_run,
-        :profile,
-        :heckle_runner,
-        :debug,
-        :line_number,
-        :loadby,
-        :reporter,
-        :reverse,
-        :timeout,
-        :verbose,
-        :user_input_for_runner,
-        :error_stream,
-        :output_stream,
-        # TODO: BT - Figure out a better name
-        :argv
-      )
-      attr_reader :colour, :differ_class, :files, :examples, :example_groups
-
-      def initialize(error_stream, output_stream)
-        @error_stream = error_stream
-        @output_stream = output_stream
-        @filename_pattern = "**/*_spec.rb"
-        @backtrace_tweaker = QuietBacktraceTweaker.new
-        @examples = []
-        @colour = false
-        @profile = false
-        @dry_run = false
-        @debug = false
-        @reporter = Reporter.new(self)
-        @context_lines = 3
-        @diff_format  = :unified
-        @files = []
-        @example_groups = []
-        @result = nil
-        @examples_run = false
-        @examples_should_be_run = nil
-        @user_input_for_runner = nil
-        @after_suite_parts = []
-        @files_loaded = false
-        @out_used = nil
-      end
-
-      def add_example_group(example_group)
-        @example_groups << example_group
-      end
-
-      def line_number_requested?
-        !!line_number
-      end
-
-      def example_line
-        Spec::Runner::LineNumberQuery.new(self).example_line_for(files.first, line_number)
-      end
-
-      def remove_example_group(example_group)
-        @example_groups.delete(example_group)
-      end
-
-      def require_ruby_debug
-        require 'rubygems' unless ENV['NO_RUBYGEMS']
-        require 'ruby-debug'
-      end
-
-      def project_root # :nodoc:
-        require 'pathname'
-        @project_root ||= determine_project_root
-      end
-
-      def determine_project_root # :nodoc:
-        # This is borrowed (slightly modified) from Scott Taylors
-        # project_path project:
-        #   http://github.com/smtlaissezfaire/project_path
-        Pathname(File.expand_path('.')).ascend do |path|
-          if File.exists?(File.join(path, "spec"))
-            return path
-          end
-        end
-      end
-
-      def add_dir_from_project_root_to_load_path(dir, load_path=$LOAD_PATH) # :nodoc:
-        return if project_root.nil?
-        full_dir = File.join(project_root, dir)
-        load_path.unshift full_dir unless load_path.include?(full_dir)
-      end
-
-      def run_examples
-        require_ruby_debug if debug
-        return true unless examples_should_be_run?
-        success = true
-        begin
-          runner = custom_runner || ExampleGroupRunner.new(self)
-
-          unless @files_loaded
-            ['spec','lib'].each do |dir|
-              add_dir_from_project_root_to_load_path(dir)
-            end
-            runner.load_files(files_to_load)
-            @files_loaded = true
-          end
-
-          define_predicate_matchers
-          plugin_mock_framework
-          ignore_backtrace_patterns
-
-          # TODO - this has to happen after the files get loaded,
-          # otherwise the before_suite_parts are not populated
-          # from the configuration. There is no spec for this
-          # directly, but features/before_and_after_blocks/before_and_after_blocks.story
-          # will fail if this happens before the files are loaded.
-          before_suite_parts.each { |part| part.call }
-
-          if example_groups.empty?
-            true
-          else
-            set_spec_from_line_number if line_number
-            success = runner.run
-            @examples_run = true
-            heckle if heckle_runner
-            success
-          end
-        ensure
-          after_suite_parts.each do |part|
-            part.arity < 1 ? part.call : part.call(success)
-          end
-        end
-      end
-
-      def before_suite_parts
-        Spec::Example::BeforeAndAfterHooks.before_suite_parts
-      end
-
-      def after_suite_parts
-        Spec::Example::BeforeAndAfterHooks.after_suite_parts
-      end
-
-      def examples_run?
-        @examples_run
-      end
-
-      def examples_should_not_be_run
-        @examples_should_be_run = false
-      end
-
-      def mock_framework
-        # TODO - don't like this dependency - perhaps store this in here instead?
-        Spec::Runner.configuration.mock_framework
-      end
-
-      def colour=(colour)
-        @colour = colour
-        if @colour && RUBY_PLATFORM =~ /mswin|mingw/ ;\
-          begin ;\
-            replace_output = @output_stream.equal?($stdout) ;\
-            require 'rubygems' unless ENV['NO_RUBYGEMS'] ;\
-            require 'Win32/Console/ANSI' ;\
-            @output_stream = $stdout if replace_output ;\
-          rescue LoadError ;\
-            warn "You must 'gem install win32console' to use colour on Windows" ;\
-            @colour = false ;\
-          end
-        end
-      end
-
-      def parse_diff(format)
-        case format
-        when :context, 'context', 'c'
-          @diff_format  = :context
-          default_differ
-        when :unified, 'unified', 'u', '', nil
-          @diff_format  = :unified
-          default_differ
-        else
-          @diff_format  = :custom
-          self.differ_class = load_class(format, 'differ', '--diff')
-        end
-      end
-
-      def parse_example(example)
-        if(File.file?(example))
-          @examples = [File.open(example).read.split("\n")].flatten
-        else
-          @examples = [example]
-        end
-      end
-
-      def parse_format(format_arg)
-        format, where = ClassAndArgumentsParser.parse(format_arg)
-        unless where
-          raise "When using several --format options only one of them can be without a file" if @out_used
-          where = @output_stream
-          @out_used = true
-        end
-        @format_options ||= []
-        @format_options << [format, where]
-      end
-
-      def formatters
-        @format_options ||= [['progress', @output_stream]]
-        @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS)
-      end
-
-      def load_formatters(format_options, formatters)
-        format_options.map do |format, where|
-          formatter_type = if formatters[format]
-            require formatters[format][0]
-            eval(formatters[format][1], binding, __FILE__, __LINE__)
-          else
-            load_class(format, 'formatter', '--format')
-          end
-          formatter_type.new(formatter_options, where)
-        end
-      end
-
-      def formatter_options
-        @formatter_options ||= OpenStruct.new(
-          :colour   => colour,
-          :autospec => autospec,
-          :dry_run  => dry_run
-        )
-      end
-
-      def which_heckle_runner
-        ([/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} || Spec::Ruby.version.to_f == 1.9) ? "spec/runner/heckle_runner_unsupported" : "spec/runner/heckle_runner"
-      end
-
-      def load_heckle_runner(heckle)
-        @format_options ||= [['silent', @output_stream]]
-        require which_heckle_runner
-        @heckle_runner = ::Spec::Runner::HeckleRunner.new(heckle)
-      end
-
-      def number_of_examples
-        return examples.size unless examples.empty?
-        @example_groups.inject(0) {|sum, group| sum + group.number_of_examples}
-      end
-
-      def files_to_load
-        result = []
-        sorted_files.each do |file|
-          if File.directory?(file)
-            filename_pattern.split(",").each do |pattern|
-              result += Dir[File.expand_path("#{file}/#{pattern.strip}")]
-            end
-          elsif File.file?(file)
-            result << file
-          else
-            raise "File or directory not found: #{file}"
-          end
-        end
-        result
-      end
-
-      def dry_run?
-        @dry_run == true
-      end
-
-    protected
-
-      def define_predicate_matchers
-        Spec::Runner.configuration.predicate_matchers.each_pair do |matcher_method, method_on_object|
-          Spec::Example::ExampleMethods::__send__ :define_method, matcher_method do |*args|
-            eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
-          end
-        end
-      end
-
-      def plugin_mock_framework
-        case mock_framework
-        when Module
-          Spec::Example::ExampleMethods.__send__ :include, mock_framework
-        else
-          require mock_framework
-          Spec::Example::ExampleMethods.__send__ :include, Spec::Adapters::MockFramework
-        end
-      end
-
-      def ignore_backtrace_patterns
-        @backtrace_tweaker.ignore_patterns Spec::Runner.configuration.ignored_backtrace_patterns
-      end
-
-      def examples_should_be_run?
-        return @examples_should_be_run unless @examples_should_be_run.nil?
-        @examples_should_be_run = true
-      end
-
-      def differ_class=(klass)
-        return unless klass
-        @differ_class = klass
-        Spec::Expectations.differ = self.differ_class.new(self)
-      end
-
-      def load_class(name, kind, option)
-        if name =~ /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
-          arg = $2 == "" ? nil : $2
-          [$1, arg]
-        else
-          m = "#{name.inspect} is not a valid class name"
-          @error_stream.puts m
-          raise m
-        end
-        begin
-          eval(name, binding, __FILE__, __LINE__)
-        rescue NameError => e
-          @error_stream.puts "Couldn't find #{kind} class #{name}"
-          @error_stream.puts "Make sure the --require option is specified *before* #{option}"
-          if $_spec_spec ; raise e ; else exit(1) ; end
-        end
-      end
-
-      def custom_runner
-        return nil unless custom_runner?
-        klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner)
-        runner_type = load_class(klass_name, 'example group runner', '--runner')
-        return runner_type.new(self, arg)
-      end
-
-      def custom_runner?
-        return user_input_for_runner ? true : false
-      end
-
-      def heckle
-        heckle_runner = self.heckle_runner
-        self.heckle_runner = nil
-        heckle_runner.heckle_with
-      end
-
-      def sorted_files
-        return sorter ? files.sort(&sorter) : files
-      end
-
-      def sorter
-        FILE_SORTERS[loadby]
-      end
-
-      def default_differ
-        require 'spec/runner/differs/default'
-        self.differ_class = ::Spec::Expectations::Differs::Default
-      end
-
-      def set_spec_from_line_number
-        if examples.empty?
-          if files.length == 1
-            if File.directory?(files[0])
-              error_stream.puts "You must specify one file, not a directory when providing a line number"
-              exit(1) if stderr?
-            else
-              example = LineNumberQuery.new(self).spec_name_for(files[0], line_number)
-              @examples = [example]
-            end
-          else
-            error_stream.puts "Only one file can be specified when providing a line number: #{files.inspect}"
-            exit(3) if stderr?
-          end
-        else
-          error_stream.puts "You cannot use --example and specify a line number"
-          exit(4) if stderr?
-        end
-      end
-
-      def stderr?
-        @error_stream == $stderr
-      end
-    end
-  end
-end

data/vendor/rspec/lib/spec/runner/reporter.rb

@@ -1,171 +0,0 @@
-module Spec
-  module Runner
-    class Reporter
-      attr_reader :options
-      
-      def initialize(options)
-        @options = options
-        @options.reporter = self
-        @failures = []
-        @pending_count = 0
-        @example_count = 0
-        @start_time = nil
-        @end_time = nil
-      end
-      
-      def example_group_started(example_group)
-        @example_group = example_group
-        formatters.each do |f|
-          f.example_group_started(example_group)
-        end
-      end
-      
-      def example_started(example)
-        formatters.each{|f| f.example_started(example)}
-      end
-      
-      def example_finished(example, error=nil)
-        @example_count += 1
-        
-        if error.nil?
-          example_passed(example)
-        elsif Spec::Example::ExamplePendingError === error
-          example_pending(example, example.location, error.message)
-        else
-          example_failed(example, error)
-        end
-      end
-
-      def example_failed(example, error)
-        backtrace_tweaker.tweak_backtrace(error)
-        failure = Failure.new(@example_group.description, example.description, error)
-        @failures << failure
-        formatters.each do |f|
-          f.example_failed(example, @failures.length, failure)
-        end
-      end
-
-      def start(number_of_examples)
-        @start_time = Time.new
-        formatters.each{|f| f.start(number_of_examples)}
-      end
-  
-      def end
-        @end_time = Time.new
-      end
-  
-      # Dumps the summary and returns the total number of failures
-      def dump
-        formatters.each{|f| f.start_dump}
-        dump_pending
-        dump_failures
-        formatters.each do |f|
-          f.dump_summary(duration, @example_count, @failures.length, @pending_count)
-          f.close
-        end
-        @failures.length
-      end
-
-      class Failure
-        def initialize(group_description, example_description, exception)  # :nodoc:
-          @example_name = "#{group_description} #{example_description}"
-          @exception = exception
-        end
-        
-        # The Exception object raised
-        attr_reader :exception
-        
-        # Header messsage for reporting this failure, including the name of the
-        # example and an indicator of the type of failure. FAILED indicates a
-        # failed expectation. FIXED indicates a pending example that passes, and
-        # no longer needs to be pending. RuntimeError indicates that a
-        # RuntimeError occured.
-        # 
-        # == Examples
-        #
-        #   'A new account should have a zero balance' FAILED
-        #   'A new account should have a zero balance' FIXED
-        #   RuntimeError in 'A new account should have a zero balance'
-        def header
-          if expectation_not_met?
-            "'#{@example_name}' FAILED"
-          elsif pending_fixed?
-            "'#{@example_name}' FIXED"
-          else
-            "#{@exception.class.name} in '#{@example_name}'"
-          end
-        end
-        
-        def pending_fixed? # :nodoc:
-          @exception.is_a?(Spec::Example::PendingExampleFixedError)
-        end
-
-        def expectation_not_met?  # :nodoc:
-          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
-        end
-      end
-
-    private
-
-      def formatters
-        @options.formatters
-      end
-
-      def backtrace_tweaker
-        @options.backtrace_tweaker
-      end
-  
-      def dump_failures
-        return if @failures.empty?
-        @failures.inject(1) do |index, failure|
-          formatters.each{|f| f.dump_failure(index, failure)}
-          index + 1
-        end
-      end
-
-      def dump_pending
-        formatters.each{|f| f.dump_pending}
-      end
-
-      def duration
-        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
-        return "0.0"
-      end
-      
-      def example_passed(example)
-        formatters.each{|f| f.example_passed(example)}
-      end
-
-      EXAMPLE_PENDING_DEPRECATION_WARNING = <<-WARNING
-
-*********************************************************************
-DEPRECATION WARNING: RSpec's formatters have changed example_pending
-to accept two arguments instead of three. Please see the rdoc
-for Spec::Runner::Formatter::BaseFormatter#example_pending
-for more information.
-  
-Please update any custom formatters to accept only two arguments
-to example_pending. Support for example_pending with two arguments
-and this warning message will be removed after the RSpec 2.0 release.
-*********************************************************************      
-WARNING
-      
-      def example_pending(example, ignore, message="Not Yet Implemented")
-        @pending_count += 1
-        formatters.each do |formatter|
-          if formatter_uses_deprecated_example_pending_method?(formatter)
-            Spec.warn EXAMPLE_PENDING_DEPRECATION_WARNING
-            formatter.example_pending(example, message, example.location)
-          else
-            formatter.example_pending(example, message)
-          end
-        end
-      end
-      
-      def formatter_uses_deprecated_example_pending_method?(formatter)
-        formatter.method(:example_pending).arity == 3
-      end
-      
-    end
-  end
-end