picolena 0.1.8 → 0.2.0

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

@@ -1,286 +0,0 @@
-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
-               'specdoc' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
-                     's' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
-                  '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']
-      }
-
-      STORY_FORMATTERS = {
-        'plain' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
-            'p' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
-         'html' => ['spec/runner/formatter/story/html_formatter',       'Formatter::Story::HtmlFormatter'],
-            'h' => ['spec/runner/formatter/story/html_formatter',       'Formatter::Story::HtmlFormatter']
-      }
-
-      attr_accessor(
-        :filename_pattern,
-        :backtrace_tweaker,
-        :context_lines,
-        :diff_format,
-        :dry_run,
-        :profile,
-        :examples,
-        :heckle_runner,
-        :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, :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
-        @reporter = Reporter.new(self)
-        @context_lines = 3
-        @diff_format  = :unified
-        @files = []
-        @example_groups = []
-        @examples_run = false
-        @examples_should_be_run = nil
-        @user_input_for_runner = nil
-      end
-
-      def add_example_group(example_group)
-        @example_groups << example_group
-      end
-
-      def remove_example_group(example_group)
-        @example_groups.delete(example_group)
-      end
-
-      def run_examples
-        return true unless examples_should_be_run?
-        runner = custom_runner || ExampleGroupRunner.new(self)
-
-        runner.load_files(files_to_load)
-        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
-      end
-
-      def examples_run?
-        @examples_run
-      end
-
-      def examples_should_not_be_run
-        @examples_should_be_run = false
-      end
-
-      def colour=(colour)
-        @colour = colour
-        if @colour && RUBY_PLATFORM =~ /win32/ ;\
-          begin ;\
-            require 'rubygems' ;\
-            require 'Win32/Console/ANSI' ;\
-          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")
-        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 story_formatters
-        @format_options ||= [['plain', @output_stream]]
-        @formatters ||= load_formatters(@format_options, STORY_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(self, where)
-        end
-      end
-
-      def load_heckle_runner(heckle)
-        suffix = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? '_unsupported' : ''
-        require "spec/runner/heckle_runner#{suffix}"
-        @heckle_runner = HeckleRunner.new(heckle)
-      end
-
-      def number_of_examples
-        @example_groups.inject(0) do |sum, example_group|
-          sum + example_group.number_of_examples
-        end
-      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
-
-      protected
-      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, 'behaviour runner', '--runner')
-        return runner_type.new(self, arg)
-      end
-
-      def custom_runner?
-        return user_input_for_runner ? true : false
-      end
-
-      def heckle
-        returns = self.heckle_runner.heckle_with
-        self.heckle_runner = nil
-        returns
-      end
-
-      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
-
-      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 using the --line option"
-              exit(1) if stderr?
-            else
-              example = SpecParser.new.spec_name_for(files[0], line_number)
-              @examples = [example]
-            end
-          else
-            error_stream.puts "Only one file can be specified when using the --line option: #{files.inspect}"
-            exit(3) if stderr?
-          end
-        else
-          error_stream.puts "You cannot use both --line and --example"
-          exit(4) if stderr?
-        end
-      end
-
-      def stderr?
-        @error_stream == $stderr
-      end
-    end
-  end
-end

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

@@ -1,143 +0,0 @@
-module Spec
-  module Runner
-    class Reporter
-      attr_reader :options, :example_groups
-
-      def initialize(options)
-        @options = options
-        @options.reporter = self
-        clear
-      end
-
-      def add_example_group(example_group)
-        formatters.each do |f|
-          f.add_example_group(example_group)
-        end
-        example_groups << example_group
-      end
-
-      def example_started(example)
-        formatters.each{|f| f.example_started(example)}
-      end
-
-      def example_finished(example, error=nil)
-        @examples << example
-
-        if error.nil?
-          example_passed(example)
-        elsif Spec::Example::ExamplePendingError === error
-          example_pending(example_groups.last, example, error.message)
-        else
-          example_failed(example, error)
-        end
-      end
-
-      def failure(example, error)
-        backtrace_tweaker.tweak_backtrace(error)
-        example_name = "#{example_groups.last.description} #{example.description}"
-        failure = Failure.new(example_name, error)
-        @failures << failure
-        formatters.each do |f|
-          f.example_failed(example, @failures.length, failure)
-        end
-      end
-      alias_method :example_failed, :failure
-
-      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, @examples.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
-        @example_groups = []
-        @failures = []
-        @pending_count = 0
-        @examples = []
-        @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(example)
-        formatters.each{|f| f.example_passed(example)}
-      end
-
-      def example_pending(example_group, example, message="Not Yet Implemented")
-        @pending_count += 1
-        formatters.each do |f|
-          f.example_pending(example_group.description, example, message)
-        end
-      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::Example::PendingExampleFixedError)
-        end
-
-        def expectation_not_met?
-          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
-        end
-
-      end
-    end
-  end
-end

data/rails_plugins/rspec/lib/spec/runner/spec_parser.rb

@@ -1,71 +0,0 @@
-module Spec
-  module Runner
-    # Parses a spec file and finds the nearest example for a given line number.
-    class SpecParser
-      attr_reader :best_match
-
-      def initialize
-        @best_match = {}
-      end
-
-      def spec_name_for(file, line_number)
-        best_match.clear
-        file = File.expand_path(file)
-        rspec_options.example_groups.each do |example_group|
-          consider_example_groups_for_best_match example_group, file, line_number
-
-          example_group.examples.each do |example|
-            consider_example_for_best_match example, example_group, file, line_number
-          end
-        end
-        if best_match[:example_group]
-          if best_match[:example]
-            "#{best_match[:example_group].description} #{best_match[:example].description}"
-          else
-            best_match[:example_group].description
-          end
-        else
-          nil
-        end
-      end
-
-    protected
-
-      def consider_example_groups_for_best_match(example_group, file, line_number)
-        parsed_backtrace = parse_backtrace(example_group.registration_backtrace)
-        parsed_backtrace.each do |example_file, example_line|
-          if is_best_match?(file, line_number, example_file, example_line)
-            best_match.clear
-            best_match[:example_group] = example_group
-            best_match[:line] = example_line
-          end
-        end
-      end
-
-      def consider_example_for_best_match(example, example_group, file, line_number)
-        parsed_backtrace = parse_backtrace(example.implementation_backtrace)
-        parsed_backtrace.each do |example_file, example_line|
-          if is_best_match?(file, line_number, example_file, example_line)
-            best_match.clear
-            best_match[:example_group] = example_group
-            best_match[:example] = example
-            best_match[:line] = example_line
-          end
-        end
-      end
-
-      def is_best_match?(file, line_number, example_file, example_line)
-        file == File.expand_path(example_file) &&
-        example_line <= line_number &&
-        example_line > best_match[:line].to_i
-      end
-
-      def parse_backtrace(backtrace)
-        backtrace.collect do |trace_line|
-          split_line = trace_line.split(':')
-          [split_line[0], Integer(split_line[1])]
-        end
-      end
-    end
-  end
-end

data/rails_plugins/rspec/lib/spec/runner.rb

@@ -1,202 +0,0 @@
-require 'spec/runner/options'
-require 'spec/runner/option_parser'
-require 'spec/runner/example_group_runner'
-require 'spec/runner/command_line'
-require 'spec/runner/drb_command_line'
-require 'spec/runner/backtrace_tweaker'
-require 'spec/runner/reporter'
-require 'spec/runner/spec_parser'
-require 'spec/runner/class_and_arguments_parser'
-
-module Spec
-  # == ExampleGroups and Examples
-  #
-  # Rather than expressing examples in classes, RSpec uses a custom DSLL (DSL light) to
-  # describe groups of examples.
-  #
-  # A ExampleGroup is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
-  # in which you will run your executable example - a set of known objects in a known starting state.
-  # We begin be describing
-  #
-  #   describe Account do
-  #
-  #     before do
-  #       @account = Account.new
-  #     end
-  #
-  #     it "should have a balance of $0" do
-  #       @account.balance.should == Money.new(0, :dollars)
-  #     end
-  #
-  #   end
-  #
-  # We use the before block to set up the Example (given), and then the #it method to
-  # hold the example code that expresses the event (when) and the expected outcome (then).
-  #
-  # == Helper Methods
-  #
-  # A primary goal of RSpec is to keep the examples clear. We therefore prefer
-  # less indirection than you might see in xUnit examples and in well factored, DRY production code. We feel
-  # that duplication is OK if removing it makes it harder to understand an example without
-  # having to look elsewhere to understand its context.
-  #
-  # That said, RSpec does support some level of encapsulating common code in helper
-  # methods that can exist within a context or within an included module.
-  #
-  # == Setup and Teardown
-  #
-  # You can use before and after within a Example. Both methods take an optional
-  # scope argument so you can run the block before :each example or before :all examples
-  #
-  #   describe "..." do
-  #     before :all do
-  #       ...
-  #     end
-  #
-  #     before :each do
-  #       ...
-  #     end
-  #
-  #     it "should do something" do
-  #       ...
-  #     end
-  #
-  #     it "should do something else" do
-  #       ...
-  #     end
-  #
-  #     after :each do
-  #       ...
-  #     end
-  #
-  #     after :all do
-  #       ...
-  #     end
-  #
-  #   end
-  #
-  # The <tt>before :each</tt> block will run before each of the examples, once for each example. Likewise,
-  # the <tt>after :each</tt> block will run after each of the examples.
-  #
-  # It is also possible to specify a <tt>before :all</tt> and <tt>after :all</tt>
-  # block that will run only once for each behaviour, respectively before the first <code>before :each</code>
-  # and after the last <code>after :each</code>. The use of these is generally discouraged, because it
-  # introduces dependencies between the examples. Still, it might prove useful for very expensive operations
-  # if you know what you are doing.
-  #
-  # == Local helper methods
-  #
-  # You can include local helper methods by simply expressing them within a context:
-  #
-  #   describe "..." do
-  #
-  #     it "..." do
-  #       helper_method
-  #     end
-  #
-  #     def helper_method
-  #       ...
-  #     end
-  #
-  #   end
-  #
-  # == Included helper methods
-  #
-  # You can include helper methods in multiple contexts by expressing them within
-  # a module, and then including that module in your context:
-  #
-  #   module AccountExampleHelperMethods
-  #     def helper_method
-  #       ...
-  #     end
-  #   end
-  #
-  #   describe "A new account" do
-  #     include AccountExampleHelperMethods
-  #     before do
-  #       @account = Account.new
-  #     end
-  #
-  #     it "should have a balance of $0" do
-  #       helper_method
-  #       @account.balance.should eql(Money.new(0, :dollars))
-  #     end
-  #   end
-  #
-  # == Shared Example Groups
-  #
-  # You can define a shared Example Group, that may be used on other groups
-  #
-  #  share_examples_for "All Editions" do
-  #    it "all editions behaviour" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like "All Editions"
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # You can also assign the shared group to a module and include that
-  #
-  #  share_as :AllEditions do
-  #    it "should do all editions stuff" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like AllEditions
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # And, for those of you who prefer to use something more like Ruby, you
-  # can just include the module directly
-  #
-  #  describe SmallEdition do
-  #    include AllEditions
-  #
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  module Runner
-    class << self
-      def configuration # :nodoc:
-        @configuration ||= Spec::Example::Configuration.new
-      end
-
-      # Use this to configure various configurable aspects of
-      # RSpec:
-      #
-      #   Spec::Runner.configure do |configuration|
-      #     # Configure RSpec here
-      #   end
-      #
-      # The yielded <tt>configuration</tt> object is a
-      # Spec::Example::Configuration instance. See its RDoc
-      # for details about what you can do with it.
-      #
-      def configure
-        yield configuration
-      end
-
-      def register_at_exit_hook # :nodoc:
-        $spec_runner_at_exit_hook_registered ||= nil
-        unless $spec_runner_at_exit_hook_registered
-          at_exit do
-            unless $! || Spec.run?; \
-              success = Spec.run; \
-              exit success if Spec.exit?; \
-            end
-          end
-          $spec_runner_at_exit_hook_registered = true
-        end
-      end
-
-    end
-  end
-end