deckshuffler 0.0.2

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

@@ -0,0 +1,223 @@
+module Spec
+  module Runner
+    class Options
+      FILE_SORTERS = {
+        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
+      }
+
+      BUILT_IN_FORMATTERS = {
+        'specdoc'  => Formatter::SpecdocFormatter,
+        's'        => Formatter::SpecdocFormatter,
+        'html'     => Formatter::HtmlFormatter,
+        'h'        => Formatter::HtmlFormatter,
+        'rdoc'     => Formatter::RdocFormatter,
+        'r'        => Formatter::RdocFormatter,
+        'progress' => Formatter::ProgressBarFormatter,
+        'p'        => Formatter::ProgressBarFormatter,
+        'failing_examples' => Formatter::FailingExamplesFormatter,
+        'e'        => Formatter::FailingExamplesFormatter,
+        'failing_behaviours' => Formatter::FailingBehavioursFormatter,
+        'b'        => Formatter::FailingBehavioursFormatter
+      }
+
+      attr_accessor(
+        :backtrace_tweaker,
+        :context_lines,
+        :diff_format,
+        :dry_run,
+        :examples,
+        :failure_file,
+        :formatters,
+        :generate,
+        :heckle_runner,
+        :line_number,
+        :loadby,
+        :reporter,
+        :reverse,
+        :timeout,
+        :verbose,
+        # TODO: BT - Rename to something better
+        :runner_arg,
+        :error_stream,
+        :output_stream,
+        # TODO: BT - Figure out a better name
+        :current_argv
+      )
+      attr_reader :colour, :differ_class, :files, :behaviours
+
+      def initialize(error_stream, output_stream)
+        @error_stream = error_stream
+        @output_stream = output_stream
+        @backtrace_tweaker = QuietBacktraceTweaker.new
+        @examples = []
+        @formatters = []
+        @colour = false
+        @dry_run = false
+        @reporter = Reporter.new(self)
+        @context_lines = 3
+        @diff_format  = :unified
+        @files = []
+        @behaviours = []
+        @runner_arg = nil
+        @examples_run = false
+      end
+
+      def add_behaviour(behaviour)
+        @behaviours << behaviour
+      end
+
+      def run_examples
+        runner = custom_runner || BehaviourRunner.new(self)
+        success = runner.run
+        @examples_run = true
+        success
+      end
+
+      def examples_run?
+        @examples_run
+      end
+
+      def colour=(colour)
+        @colour = colour
+        begin; \
+          require 'Win32/Console/ANSI' if @colour && PLATFORM =~ /win32/; \
+        rescue LoadError ; \
+          raise "You must gem install win32console to use colour on Windows" ; \
+        end
+      end
+
+      def custom_runner?
+        return @runner_arg ? true : false
+      end
+
+      def custom_runner
+        return nil unless custom_runner?
+        klass_name, arg = split_at_colon(@runner_arg)
+        runner_type = load_class(klass_name, 'behaviour runner', '--runner')
+        return runner_type.new(self, arg)
+      end
+
+      def differ_class=(klass)
+        return unless klass
+        @differ_class = klass
+        Spec::Expectations.differ = self.differ_class.new(self)
+      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")
+        else
+          @examples = [example]
+        end
+      end
+
+      def parse_format(format_arg)
+        format, where = split_at_colon(format_arg)
+        # This funky regexp checks whether we have a FILE_NAME or not
+        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
+
+        formatter_type = BUILT_IN_FORMATTERS[format] || load_class(format, 'formatter', '--format')
+        create_formatter(formatter_type, where)
+      end
+
+      def create_formatter(formatter_type, where=@output_stream)
+        formatter = formatter_type.new(self, where)
+        @formatters << formatter
+        formatter
+      end
+
+      def parse_require(req)
+        req.split(",").each{|file| require file}
+      end
+
+      def parse_heckle(heckle)
+        heckle_require = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? 'spec/runner/heckle_runner_unsupported' : 'spec/runner/heckle_runner'
+        require heckle_require
+        @heckle_runner = HeckleRunner.new(heckle)
+      end
+
+      def split_at_colon(s)
+        if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/
+          arg = $2 == "" ? nil : $2
+          [$1, arg]
+        else
+          raise "Couldn't parse #{s.inspect}"
+        end
+      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 load_paths
+        paths.each do |path|
+          load path
+        end
+      end
+
+      def paths
+        result = []
+        sorted_files.each do |file|
+          if test ?d, file
+            result += Dir[File.expand_path("#{file}/**/*.rb")]
+          elsif test ?f, file
+            result << file
+          else
+            raise "File or directory not found: #{file}"
+          end
+        end
+        result
+      end
+
+      def number_of_examples
+        @behaviours.inject(0) {|sum, behaviour| sum + behaviour.number_of_examples}
+      end
+
+      protected
+      def sorted_files
+        return sorter ? files.sort(&sorter) : files
+      end
+
+      def sorter
+        FILE_SORTERS[loadby]
+      end
+
+      def default_differ
+        require 'spec/expectations/differs/default'
+        self.differ_class = Spec::Expectations::Differs::Default
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module Spec
+  module Runner
+    class Reporter
+      attr_reader :options
+      
+      def initialize(options)
+        @options = options
+        clear
+      end
+      
+      def add_behaviour(name)
+        formatters.each{|f| f.add_behaviour(name)}
+        @behaviour_names << name
+      end
+      
+      def example_started(example_definition)
+        formatters.each{|f| f.example_started(example_definition)}
+      end
+      
+      def example_finished(example_definition, error=nil, failure_location=nil, not_implemented = false)
+        @example_names << example_definition
+        
+        if not_implemented
+          example_pending(@behaviour_names.last, example_definition)
+        elsif error.nil?
+          example_passed(example_definition)
+        elsif Spec::DSL::ExamplePendingError === error
+          example_pending(@behaviour_names.last, example_definition, error.message)
+        else
+          example_failed(example_definition, error, failure_location)
+        end
+      end
+
+      def start(number_of_examples)
+        clear
+        @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_names.length, @failures.length, @pending_count)
+          f.close
+        end
+        @failures.length
+      end
+
+    private
+
+      def formatters
+        @options.formatters
+      end
+
+      def backtrace_tweaker
+        @options.backtrace_tweaker
+      end
+  
+      def clear
+        @behaviour_names = []
+        @failures = []
+        @pending_count = 0
+        @example_names = []
+        @start_time = nil
+        @end_time = nil
+      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(name)
+        formatters.each{|f| f.example_passed(name)}
+      end
+
+      def example_failed(name, error, failure_location)
+        backtrace_tweaker.tweak_backtrace(error, failure_location)
+        example_name = "#{@behaviour_names.last} #{name}"
+        failure = Failure.new(example_name, error)
+        @failures << failure
+        formatters.each{|f| f.example_failed(name, @failures.length, failure)}
+      end
+      
+      def example_pending(behaviour_name, example_name, message="Not Yet Implemented")
+        @pending_count += 1
+        formatters.each{|f| f.example_pending(behaviour_name, example_name, message)}
+      end
+      
+      class Failure
+        attr_reader :exception
+        
+        def initialize(example_name, exception)
+          @example_name = example_name
+          @exception = exception
+        end
+
+        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?
+          @exception.is_a?(Spec::DSL::PendingFixedError)
+        end
+
+        def expectation_not_met?
+          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+        end
+
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/runner/spec_parser.rb

@@ -0,0 +1,53 @@
+module Spec
+  module Runner
+    # Parses a spec file and finds the nearest example for a given line number.
+    class SpecParser
+      def spec_name_for(io, line_number)
+        source  = io.read
+        behaviour, behaviour_line = behaviour_at_line(source, line_number)
+        example, example_line = example_at_line(source, line_number)
+        if behaviour && example && (behaviour_line < example_line)
+          "#{behaviour} #{example}"
+        elsif behaviour
+          behaviour
+        else
+          nil
+        end
+      end
+
+    protected
+
+      def behaviour_at_line(source, line_number)
+        find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
+      end
+
+      def example_at_line(source, line_number)
+        find_above(source, line_number, /^\s*(specify|it)\s+(.*)\s+do/)
+      end
+
+      # Returns the context/describe or specify/it name and the line number
+      def find_above(source, line_number, pattern)
+        lines_above_reversed(source, line_number).each_with_index do |line, n|
+          return [parse_description($2), line_number-n] if line =~ pattern
+        end
+        nil
+      end
+
+      def lines_above_reversed(source, line_number)
+        lines = source.split("\n")
+        lines[0...line_number].reverse
+      end
+      
+      def parse_description(str)
+        return str[1..-2] if str =~ /^['"].*['"]$/
+        if matches = /^['"](.*)['"](,.*)?$/.match(str)
+          return ::Spec::DSL::BehaviourDescription.generate_description(matches[1])
+        end
+        if matches = /^(.*)\s*,\s*['"](.*)['"](,.*)?$/.match(str)
+          return ::Spec::DSL::BehaviourDescription.generate_description(matches[1], matches[2])
+        end
+        return str
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/story.rb

@@ -0,0 +1,10 @@
+require 'spec/story/documenter'
+require 'spec/story/extensions'
+require 'spec/story/given_scenario'
+require 'spec/story/reporter'
+require 'spec/story/runner'
+require 'spec/story/scenario'
+require 'spec/story/simple_step'
+require 'spec/story/step_mother'
+require 'spec/story/story'
+require 'spec/story/world'

data/vendor/plugins/rspec/lib/spec/story/documenter.rb

@@ -0,0 +1 @@
+require 'spec/story/documenter/plain_text_documenter.rb'

data/vendor/plugins/rspec/lib/spec/story/documenter/plain_text_documenter.rb

@@ -0,0 +1,43 @@
+module Spec
+  module Story
+    module Documenter
+      class PlainTextDocumenter
+        def initialize(out)
+          @out = out
+          @previous_type = nil
+        end
+        
+        def story_started(title, narrative)
+          @out << "Story: #{title}\n#{narrative}\n"
+        end
+        
+        def story_ended(title, narrative)
+          @out << "\n\n"
+        end
+        
+        def scenario_started(story_title, scenario_name)
+          @out << "\nScenario: #{scenario_name}\n"
+        end
+        
+        def found_step(type, description, *args)
+          args_txt = args.empty? ? "" : " #{args.join ','}"
+          if type == @previous_type
+            @out << "  And "
+          else
+            @out << "\n" << "  #{type.to_s.capitalize} "
+          end
+          @out << "#{description}#{args_txt}" << "\n"
+          if type == :'given scenario'
+            @previous_type = :given
+          else
+            @previous_type = type
+          end
+        end
+        
+        def method_missing(meth, *args, &block)
+          # ignore any other calls
+        end
+      end
+    end
+  end
+end