picolena 0.1.8 → 0.2.0

data/rails_plugins/rspec/lib/spec/runner/formatter/story/plain_text_formatter.rb

@@ -1,131 +0,0 @@
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      module Story
-        class PlainTextFormatter < BaseTextFormatter
-          def initialize(options, where)
-            super
-            @successful_scenario_count = 0
-            @pending_scenario_count = 0
-            @failed_scenarios = []
-            @pending_steps = []
-            @previous_type = nil
-          end
-
-          def run_started(count)
-            @count = count
-            @output.puts "Running #@count scenarios\n\n"
-          end
-
-          def story_started(title, narrative)
-            @current_story_title = title
-            @output.puts "Story: #{title}\n\n"
-            narrative.each_line do |line|
-              @output.print "  "
-              @output.print line
-            end
-          end
-
-          def story_ended(title, narrative)
-            @output.puts
-            @output.puts
-          end
-
-          def scenario_started(story_title, scenario_name)
-            @current_scenario_name = scenario_name
-            @scenario_already_failed = false
-            @output.print "\n\n  Scenario: #{scenario_name}"
-            @scenario_ok = true
-          end
-
-          def scenario_succeeded(story_title, scenario_name)
-            @successful_scenario_count += 1
-          end
-
-          def scenario_failed(story_title, scenario_name, err)
-            @options.backtrace_tweaker.tweak_backtrace(err)
-            @failed_scenarios << [story_title, scenario_name, err] unless @scenario_already_failed
-            @scenario_already_failed = true
-          end
-
-          def scenario_pending(story_title, scenario_name, msg)
-            @pending_scenario_count += 1 unless @scenario_already_failed
-            @scenario_already_failed = true
-          end
-
-          def run_ended
-            @output.puts "#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending"
-            unless @pending_steps.empty?
-              @output.puts "\nPending Steps:"
-              @pending_steps.each_with_index do |pending, i|
-                story_name, scenario_name, msg = pending
-                @output.puts "#{i+1}) #{story_name} (#{scenario_name}): #{msg}"
-              end
-            end
-            unless @failed_scenarios.empty?
-              @output.print "\nFAILURES:"
-              @failed_scenarios.each_with_index do |failure, i|
-                title, scenario_name, err = failure
-                @output.print %[
-    #{i+1}) #{title} (#{scenario_name}) FAILED
-    #{err.class}: #{err.message}
-    #{err.backtrace.join("\n")}
-]
-              end
-            end
-          end
-
-          def step_upcoming(type, description, *args)
-          end
-
-          def step_succeeded(type, description, *args)
-            found_step(type, description, false, *args)
-          end
-
-          def step_pending(type, description, *args)
-            found_step(type, description, false, *args)
-            @pending_steps << [@current_story_title, @current_scenario_name, description]
-            @output.print " (PENDING)"
-            @scenario_ok = false
-          end
-
-          def step_failed(type, description, *args)
-            found_step(type, description, true, *args)
-            @output.print red(@scenario_ok ? " (FAILED)" : " (SKIPPED)")
-            @scenario_ok = false
-          end
-
-          def collected_steps(steps)
-          end
-
-          def method_missing(sym, *args, &block) #:nodoc:
-            # noop - ignore unknown messages
-          end
-
-        private
-
-          def found_step(type, description, failed, *args)
-            desc_string = description.step_name
-            arg_regexp = description.arg_regexp
-            text = if(type == @previous_type)
-              "\n    And "
-            else
-              "\n\n    #{type.to_s.capitalize} "
-            end
-            i = -1
-            text << desc_string.gsub(arg_regexp) { |param| args[i+=1] }
-            @output.print(failed ? red(text) : green(text))
-
-            if type == :'given scenario'
-              @previous_type = :given
-            else
-              @previous_type = type
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec/runner/formatter/html_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      # Formats backtraces so they're clickable by TextMate
-      class TextMateFormatter < HtmlFormatter
-        def backtrace_line(line)
-          line.gsub(/([^:]*\.rb):(\d*)/) do
-            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-begin
-  require 'rubygems'
-  require 'heckle'
-rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
-
-module Spec
-  module Runner
-    # Creates a new Heckler configured to heckle all methods in the classes
-    # whose name matches +filter+
-    class HeckleRunner
-      def initialize(filter, heckle_class=Heckler)
-        @filter = filter
-        @heckle_class = heckle_class
-      end
-
-      # Runs all the example groups held by +rspec_options+ once for each of the
-      # methods in the matched classes.
-      def heckle_with
-        if @filter =~ /(.*)[#\.](.*)/
-          heckle_method($1, $2)
-        else
-          heckle_class_or_module(@filter)
-        end
-      end
-
-      def heckle_method(class_name, method_name)
-        verify_constant(class_name)
-        heckle = @heckle_class.new(class_name, method_name, rspec_options)
-        heckle.validate
-      end
-
-      def heckle_class_or_module(class_or_module_name)
-        verify_constant(class_or_module_name)
-        pattern = /^#{class_or_module_name}/
-        classes = []
-        ObjectSpace.each_object(Class) do |klass|
-          classes << klass if klass.name =~ pattern
-        end
-
-        classes.each do |klass|
-          klass.instance_methods(false).each do |method_name|
-            heckle = @heckle_class.new(klass.name, method_name, rspec_options)
-            heckle.validate
-          end
-        end
-      end
-
-      def verify_constant(name)
-        begin
-          # This is defined in Heckle
-          name.to_class
-        rescue
-          raise "Heckling failed - \"#{name}\" is not a known class or module"
-        end
-      end
-    end
-
-    #Supports Heckle 1.2 and prior (earlier versions used Heckle::Base)
-    class Heckler < (Heckle.const_defined?(:Base) ? Heckle::Base : Heckle)
-      def initialize(klass_name, method_name, rspec_options)
-        super(klass_name, method_name)
-        @rspec_options = rspec_options
-      end
-
-      def tests_pass?
-        success = @rspec_options.run_examples
-        success
-      end
-
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module Spec
-  module Runner
-    # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
-    class HeckleRunner
-      def initialize(filter)
-        raise "Heckle not supported on Windows"
-      end
-    end
-  end
-end

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

@@ -1,201 +0,0 @@
-require 'optparse'
-require 'stringio'
-
-module Spec
-  module Runner
-    class OptionParser < ::OptionParser
-      class << self
-        def parse(args, err, out)
-          parser = new(err, out)
-          parser.parse(args)
-          parser.options
-        end
-      end
-
-      attr_reader :options
-
-      OPTIONS = {
-        :pattern => ["-p", "--pattern [PATTERN]","Limit files loaded to those matching this pattern. Defaults to '**/*_spec.rb'",
-                                                 "Separate multiple patterns with commas.",
-                                                 "Applies only to directories named on the command line (files",
-                                                 "named explicitly on the command line will be loaded regardless)."],
-        :diff =>    ["-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
-                                             "Builtin formats: unified|u|context|c",
-                                             "You can also specify a custom differ class",
-                                             "(in which case you should also specify --require)"],
-        :colour =>  ["-c", "--colour", "--color", "Show coloured (red/green) output"],
-        :example => ["-e", "--example [NAME|FILE_NAME]",  "Execute example(s) with matching name(s). If the argument is",
-                                                          "the path to an existing file (typically generated by a previous",
-                                                          "run using --format failing_examples:file.txt), then the examples",
-                                                          "on each line of thatfile will be executed. If the file is empty,",
-                                                          "all examples will be run (as if --example was not specified).",
-                                                          " ",
-                                                          "If the argument is not an existing file, then it is treated as",
-                                                          "an example name directly, causing RSpec to run just the example",
-                                                          "matching that name"],
-        :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"],
-        :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviout or specification at given line.",
-                                                       "(does not work for dynamically generated specs)"],
-        :format => ["-f", "--format FORMAT[:WHERE]",  "Specifies what format to use for output. Specify WHERE to tell",
-                                                    "the formatter where to write the output. All built-in formats",
-                                                    "expect WHERE to be a file name, and will write to STDOUT if it's",
-                                                    "not specified. The --format option may be specified several times",
-                                                    "if you want several outputs",
-                                                    " ",
-                                                    "Builtin formats for examples: ",
-                                                    "progress|p               : Text progress",
-                                                    "profile|o                : Text progress with profiling of 10 slowest examples",
-                                                    "specdoc|s                : Example doc as text",
-                                                    "html|h                   : A nice HTML report",
-                                                    "failing_examples|e       : Write all failing examples - input for --example",
-                                                    "failing_example_groups|g : Write all failing example groups - input for --example",
-                                                    " ",
-                                                    "Builtin formats for stories: ",
-                                                    "plain|p              : Plain Text",
-                                                    "html|h               : A nice HTML report",
-                                                    " ",
-                                                    "FORMAT can also be the name of a custom formatter class",
-                                                    "(in which case you should also specify --require to load it)"],
-        :require => ["-r", "--require FILE", "Require FILE before running specs",
-                                          "Useful for loading custom formatters or other extensions.",
-                                          "If this option is used it must come before the others"],
-        :backtrace => ["-b", "--backtrace", "Output full backtrace"],
-        :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.",
-                                              "STRATEGY can currently only be 'mtime' (File modification time)",
-                                              "By default, spec files are loaded in alphabetical order if --loadby",
-                                              "is not specified."],
-        :reverse => ["-R", "--reverse", "Run examples in reverse order"],
-        :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
-                                              "specified time"],
-        :heckle => ["-H", "--heckle CODE", "If all examples pass, this will mutate the classes and methods",
-                                           "identified by CODE little by little and run all the examples again",
-                                           "for each mutation. The intent is that for each mutation, at least",
-                                           "one example *should* fail, and RSpec will tell you if this is not the",
-                                           "case. CODE should be either Some::Module, Some::Class or",
-                                           "Some::Fabulous#method}"],
-        :dry_run => ["-d", "--dry-run", "Invokes formatters without executing the examples."],
-        :options_file => ["-O", "--options PATH", "Read options from a file"],
-        :generate_options => ["-G", "--generate-options PATH", "Generate an options file for --options"],
-        :runner => ["-U", "--runner RUNNER", "Use a custom Runner."],
-        :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
-        :version => ["-v", "--version", "Show version"],
-        :help => ["-h", "--help", "You're looking at it"]
-      }
-
-      def initialize(err, out)
-        super()
-        @error_stream = err
-        @out_stream = out
-        @options = Options.new(@error_stream, @out_stream)
-
-        @file_factory = File
-
-        self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
-        self.separator ""
-        on(*OPTIONS[:pattern]) {|pattern| @options.filename_pattern = pattern}
-        on(*OPTIONS[:diff]) {|diff| @options.parse_diff(diff)}
-        on(*OPTIONS[:colour]) {@options.colour = true}
-        on(*OPTIONS[:example]) {|example| @options.parse_example(example)}
-        on(*OPTIONS[:specification]) {|example| @options.parse_example(example)}
-        on(*OPTIONS[:line]) {|line_number| @options.line_number = line_number.to_i}
-        on(*OPTIONS[:format]) {|format| @options.parse_format(format)}
-        on(*OPTIONS[:require]) {|requires| invoke_requires(requires)}
-        on(*OPTIONS[:backtrace]) {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
-        on(*OPTIONS[:loadby]) {|loadby| @options.loadby = loadby}
-        on(*OPTIONS[:reverse]) {@options.reverse = true}
-        on(*OPTIONS[:timeout]) {|timeout| @options.timeout = timeout.to_f}
-        on(*OPTIONS[:heckle]) {|heckle| @options.load_heckle_runner(heckle)}
-        on(*OPTIONS[:dry_run]) {@options.dry_run = true}
-        on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)}
-        on(*OPTIONS[:generate_options]) do |options_file|
-        end
-        on(*OPTIONS[:runner]) do |runner|
-          @options.user_input_for_runner = runner
-        end
-        on(*OPTIONS[:drb]) {}
-        on(*OPTIONS[:version]) {parse_version}
-        on_tail(*OPTIONS[:help]) {parse_help}
-      end
-
-      def order!(argv, &blk)
-        @argv = argv
-        @options.argv = @argv.dup
-        return if parse_generate_options
-        return if parse_drb
-
-        super(@argv) do |file|
-          @options.files << file
-          blk.call(file) if blk
-        end
-
-        @options
-      end
-
-      protected
-      def invoke_requires(requires)
-        requires.split(",").each do |file|
-          require file
-        end
-      end
-
-      def parse_options_file(options_file)
-        option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
-        @argv.push(*option_file_args)
-      end
-
-      def parse_generate_options
-        # Remove the --generate-options option and the argument before writing to file
-        options_file = nil
-        ['-G', '--generate-options'].each do |option|
-          if index = @argv.index(option)
-            @argv.delete_at(index)
-            options_file = @argv.delete_at(index)
-          end
-        end
-
-        if options_file
-          write_generated_options(options_file)
-          return true
-        else
-          return false
-        end
-      end
-
-      def write_generated_options(options_file)
-        File.open(options_file, 'w') do |io|
-          io.puts @argv.join("\n")
-        end
-        @out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:"
-        @out_stream.puts "spec --options #{options_file}"
-        @options.examples_should_not_be_run
-      end
-
-      def parse_drb
-        is_drb = false
-        argv = @options.argv
-        is_drb ||= argv.delete(OPTIONS[:drb][0])
-        is_drb ||= argv.delete(OPTIONS[:drb][1])
-        return nil unless is_drb
-        @options.examples_should_not_be_run
-        DrbCommandLine.run(
-          self.class.parse(argv, @error_stream, @out_stream)
-        )
-        true
-      end
-
-      def parse_version
-        @out_stream.puts ::Spec::VERSION::DESCRIPTION
-        exit if stdout?
-      end
-
-      def parse_help
-        @out_stream.puts self
-        exit if stdout?
-      end
-
-      def stdout?
-        @out_stream == $stdout
-      end
-    end
-  end
-end