puppet 0.23.2 → 0.24.0

data/test/lib/spec/runner/heckle_runner_win.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/test/lib/spec/runner/option_parser.rb

@@ -1,224 +0,0 @@
-require 'ostruct'
-require 'optparse'
-require 'spec/runner/spec_parser'
-require 'spec/runner/formatter'
-require 'spec/runner/backtrace_tweaker'
-require 'spec/runner/reporter'
-require 'spec/runner/context_runner'
-
-module Spec
-  module Runner
-    class OptionParser
-      def initialize
-        @spec_parser = SpecParser.new
-        @file_factory = File
-      end
-
-      def create_context_runner(args, err, out, warn_if_no_files)
-        options = parse(args, err, out, warn_if_no_files)
-        # Some exit points in parse (--generate-options, --drb) don't return the options, 
-        # but hand over control. In that case we don't want to continue.
-        return nil unless options.is_a?(OpenStruct)
-
-        formatter = options.formatter_type.new(options.out, options.dry_run, options.colour)
-        options.reporter = Reporter.new(formatter, options.backtrace_tweaker) 
-
-        # this doesn't really belong here.
-        # it should, but the way things are coupled, it doesn't
-        if options.differ_class
-          Spec::Expectations.differ = options.differ_class.new(options.diff_format, options.context_lines, options.colour)
-        end
-
-        unless options.generate
-          ContextRunner.new(options)  
-        end
-      end
-
-      def parse(args, err, out, warn_if_no_files)
-        options_file = nil
-        args_copy = args.dup
-        options = OpenStruct.new
-        options.out = (out == STDOUT ? Kernel : out)
-        options.formatter_type = Formatter::ProgressBarFormatter
-        options.backtrace_tweaker = QuietBacktraceTweaker.new
-        options.spec_name = nil
-
-        opts = ::OptionParser.new do |opts|
-          opts.banner = "Usage: spec [options] (FILE|DIRECTORY|GLOB)+"
-          opts.separator ""
-
-          opts.on("-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)") do |format|
-
-            # TODO make context_lines settable
-            options.context_lines = 3
-
-            case format
-              when 'context', 'c'
-                options.diff_format  = :context
-              when 'unified', 'u', '', nil
-                options.diff_format  = :unified
-            end
-
-            if [:context,:unified].include? options.diff_format
-              require 'spec/expectations/differs/default'
-              options.differ_class = Spec::Expectations::Differs::Default
-            else
-              begin
-                options.diff_format  = :custom
-                options.differ_class = eval(format)
-              rescue NameError
-                err.puts "Couldn't find differ class #{format}"
-                err.puts "Make sure the --require option is specified *before* --diff"
-                exit if out == $stdout
-              end
-            end
-
-          end
-          
-          opts.on("-c", "--colour", "--color", "Show coloured (red/green) output") do
-            options.colour = true
-          end
-          
-          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute context or specification with matching name") do |spec_name|
-            options.spec_name = spec_name
-          end
-          
-          opts.on("-l", "--line LINE_NUMBER", Integer, "Execute context or specification at given line") do |line_number|
-            options.line_number = line_number.to_i
-          end
-
-          opts.on("-f", "--format FORMAT", "Builtin formats: specdoc|s|rdoc|r|html|h", 
-                                           "You can also specify a custom formatter class",
-                                           "(in which case you should also specify --require)") do |format|
-            case format
-              when 'specdoc', 's'
-                options.formatter_type = Formatter::SpecdocFormatter
-              when 'html', 'h'
-                options.formatter_type = Formatter::HtmlFormatter
-              when 'rdoc', 'r'
-                options.formatter_type = Formatter::RdocFormatter
-                options.dry_run = true
-            else
-              begin
-                options.formatter_type = eval(format)
-              rescue NameError
-                err.puts "Couldn't find formatter class #{format}"
-                err.puts "Make sure the --require option is specified *before* --format"
-                exit if out == $stdout
-              end
-            end
-          end
-
-          opts.on("-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") do |req|
-            req.split(",").each{|file| require file}
-          end
-          
-          opts.on("-b", "--backtrace", "Output full backtrace") do
-            options.backtrace_tweaker = NoisyBacktraceTweaker.new
-          end
-
-          opts.on("-H", "--heckle CODE", "If all specs pass, this will run your specs many times, mutating",
-                                         "the specced code a little each time. The intent is that specs",
-                                         "*should* fail, and RSpec will tell you if they don't.",
-                                         "CODE should be either Some::Module, Some::Class or Some::Fabulous#method}") do |heckle|
-            heckle_runner = PLATFORM == 'i386-mswin32' ? 'spec/runner/heckle_runner_win' : 'spec/runner/heckle_runner'
-            require heckle_runner
-            options.heckle_runner = HeckleRunner.new(heckle)
-          end
-          
-          opts.on("-d", "--dry-run", "Don't execute specs") do
-            options.dry_run = true
-          end
-          
-          opts.on("-o", "--out OUTPUT_FILE", "Path to output file (defaults to STDOUT)") do |out_file|
-            options.out = File.new(out_file, 'w')
-          end
-          
-          opts.on("-O", "--options PATH", "Read options from a file") do |options_file|
-            # Remove the --options option and the argument before writing to file
-            index = args_copy.index("-O") || args_copy.index("--options")
-            args_copy.delete_at(index)
-            args_copy.delete_at(index)
-
-            new_args = args_copy + IO.readlines(options_file).each {|s| s.chomp!}
-            return CommandLine.run(new_args, err, out, true, warn_if_no_files)
-          end
-
-          opts.on("-G", "--generate-options PATH", "Generate an options file for --options") do |options_file|
-            # Remove the --generate-options option and the argument before writing to file
-            index = args_copy.index("-G") || args_copy.index("--generate-options")
-            args_copy.delete_at(index)
-            args_copy.delete_at(index)
-
-            File.open(options_file, 'w') do |io|
-              io.puts args_copy.join("\n")
-            end
-            out.puts "\nOptions written to #{options_file}. You can now use these options with:"
-            out.puts "spec --options #{options_file}"
-            options.generate = true
-          end
-          
-          opts.on("-X", "--drb", "Run specs via DRb. (For example against script/rails_spec_server)") do |options_file|
-            # Remove the --options option and the argument before writing to file
-            index = args_copy.index("-X") || args_copy.index("--drb")
-            args_copy.delete_at(index)
-
-            return DrbCommandLine.run(args_copy, err, out, true, warn_if_no_files)
-          end
-
-          opts.on("-v", "--version", "Show version") do
-            out.puts ::Spec::VERSION::DESCRIPTION
-            exit if out == $stdout
-          end
-
-          opts.on_tail("-h", "--help", "You're looking at it") do
-            out.puts opts
-            exit if out == $stdout
-          end
-          
-        end
-        opts.parse!(args)
-
-        if args.empty? && warn_if_no_files
-          err.puts "No files specified."
-          err.puts opts
-          exit(6) if err == $stderr
-        end
-
-        if options.line_number
-          set_spec_from_line_number(options, args, err)
-        end
-
-        options
-      end
-      
-      def set_spec_from_line_number(options, args, err)
-        unless options.spec_name
-          if args.length == 1
-            if @file_factory.file?(args[0])
-              source = @file_factory.open(args[0])
-              options.spec_name = @spec_parser.spec_name_for(source, options.line_number)
-            elsif @file_factory.directory?(args[0])
-              err.puts "You must specify one file, not a directory when using the --line option"
-              exit(1) if err == $stderr
-            else
-              err.puts "#{args[0]} does not exist"
-              exit(2) if err == $stderr
-            end
-          else
-            err.puts "Only one file can be specified when using the --line option: #{args.inspect}"
-            exit(3) if err == $stderr
-          end
-        else
-          err.puts "You cannot use both --line and --spec"
-          exit(4) if err == $stderr
-        end
-      end
-    end
-  end
-end

data/test/lib/spec/runner/reporter.rb

@@ -1,105 +0,0 @@
-module Spec
-  module Runner
-    class Reporter
-      
-      def initialize(formatter, backtrace_tweaker)
-        @formatter = formatter
-        @backtrace_tweaker = backtrace_tweaker
-        clear!
-      end
-      
-      def add_context(name)
-        #TODO - @context_names.empty? tells the formatter whether this is the first context or not - that's a little slippery
-        @formatter.add_context(name, @context_names.empty?)
-        @context_names << name
-      end
-      
-      def spec_started(name)
-        @spec_names << name
-        @formatter.spec_started(name)
-      end
-      
-      def spec_finished(name, error=nil, failure_location=nil)
-        if error.nil?
-          spec_passed(name)
-        else
-          @backtrace_tweaker.tweak_backtrace(error, failure_location)
-          spec_failed(name, Failure.new(@context_names.last, name, error))
-        end
-      end
-
-      def start(number_of_specs)
-        clear!
-        @start_time = Time.new
-        @formatter.start(number_of_specs)
-      end
-  
-      def end
-        @end_time = Time.new
-      end
-  
-      # Dumps the summary and returns the total number of failures
-      def dump
-        @formatter.start_dump
-        dump_failures
-        @formatter.dump_summary(duration, @spec_names.length, @failures.length)
-        @failures.length
-      end
-
-      private
-  
-      def clear!
-        @context_names = []
-        @failures = []
-        @spec_names = []
-        @start_time = nil
-        @end_time = nil
-      end
-  
-      def dump_failures
-        return if @failures.empty?
-        @failures.inject(1) do |index, failure|
-          @formatter.dump_failure(index, failure)
-          index + 1
-        end
-      end
-
-      def duration
-        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
-        return "0.0"
-      end
-
-      def spec_passed(name)
-        @formatter.spec_passed(name)
-      end
-
-      def spec_failed(name, failure)
-        @failures << failure
-        @formatter.spec_failed(name, @failures.length, failure)
-      end
-
-      class Failure
-        attr_reader :exception
-        
-        def initialize(context_name, spec_name, exception)
-          @context_name = context_name
-          @spec_name = spec_name
-          @exception = exception
-        end
-
-        def header
-          if expectation_not_met?
-            "'#{@context_name} #{@spec_name}' FAILED"
-          else
-            "#{@exception.class.name} in '#{@context_name} #{@spec_name}'"
-          end
-        end
-        
-        def expectation_not_met?
-          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
-        end
-
-      end
-    end
-  end
-end

data/test/lib/spec/runner/spec_matcher.rb

@@ -1,25 +0,0 @@
-module Spec
-  module Runner
-    class SpecMatcher
-
-      attr_writer :spec_desc
-      def initialize(context_desc, spec_desc=nil)
-        @context_desc = context_desc
-        @spec_desc = spec_desc
-      end
-      
-      def matches?(desc)
-        desc =~ /(^#{context_regexp} #{spec_regexp}$|^#{context_regexp}$|^#{spec_regexp}$)/
-      end
-      
-      private
-        def context_regexp
-          Regexp.escape(@context_desc)
-        end
-        
-        def spec_regexp
-          Regexp.escape(@spec_desc)
-        end
-    end
-  end
-end

data/test/lib/spec/runner/spec_parser.rb

@@ -1,41 +0,0 @@
-module Spec
-  module Runner
-    # Parses a spec file and finds the nearest spec for a given line number.
-    class SpecParser
-      def spec_name_for(io, line_number)
-        source  = io.read
-        context = context_at_line(source, line_number)
-        spec    = spec_at_line(source, line_number)
-        if context && spec
-          "#{context} #{spec}"
-        elsif context
-          context
-        else
-          nil
-        end
-      end
-
-    protected
-
-      def context_at_line(source, line_number)
-        find_above(source, line_number, /^\s*context\s+['|"](.*)['|"]/)
-      end
-
-      def spec_at_line(source, line_number)
-        find_above(source, line_number, /^\s*specify\s+['|"](.*)['|"]/)
-      end
-
-      def find_above(source, line_number, pattern)
-        lines_above_reversed(source, line_number).each do |line| 
-          return $1 if line =~ pattern
-        end
-        nil
-      end
-
-      def lines_above_reversed(source, line_number)
-        lines = source.split("\n")
-      	lines[0...line_number].reverse
-      end
-    end
-  end
-end

data/test/lib/spec/runner/spec_should_raise_handler.rb

@@ -1,74 +0,0 @@
-module Spec
-  module Runner
-    class SpecShouldRaiseHandler
-      def initialize(file_and_line_number, opts)
-        @file_and_line_number = file_and_line_number
-        @options = opts
-        @expected_error_class = determine_error_class(opts)
-        @expected_error_message = determine_error_message(opts)
-      end
-  
-      def determine_error_class(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Class)
-            return candidate
-          elsif candidate.is_a?(Array)
-            return candidate[0]
-          else
-            return Exception
-          end
-        end
-      end
-  
-      def determine_error_message(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Array)
-            return candidate[1]
-          end
-        end
-        return nil
-      end
-  
-      def build_message(exception=nil)
-        if @expected_error_message.nil?
-          message = "specify block expected #{@expected_error_class.to_s}"
-        else
-          message = "specify block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
-        end
-        message << " but raised #{exception.inspect}" if exception
-        message << " but nothing was raised" unless exception
-        message << "\n"
-        message << @file_and_line_number
-      end
-  
-      def error_matches?(error)
-        return false unless error.kind_of?(@expected_error_class)
-        unless @expected_error_message.nil?
-          if @expected_error_message.is_a?(Regexp)
-            return false unless error.message =~ @expected_error_message
-          else
-            return false unless error.message == @expected_error_message
-          end
-        end
-        return true
-      end
-
-      def handle(errors)
-        if @expected_error_class
-          if errors.empty?
-            errors << Spec::Expectations::ExpectationNotMetError.new(build_message)
-          else
-            error_to_remove = errors.detect do |error|
-              error_matches?(error)
-            end
-            if error_to_remove.nil?
-              errors.insert(0,Spec::Expectations::ExpectationNotMetError.new(build_message(errors[0])))
-            else
-              errors.delete(error_to_remove)
-            end
-          end
-        end
-      end
-    end
-  end
-end