baretest 0.2.4 → 0.4.0.pre1

data/lib/baretest/formatter.rb

@@ -0,0 +1,58 @@
+#--
+# Copyright 2009-2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+
+  # Extend Formatters that have custom options with this module to gain
+  # convenience methods to define the custom options.
+  # See Command's documentation for more information.
+  module Formatter
+
+    # Invoke Formatter#initialize_options
+    def self.extended(obj) # :nodoc:
+      obj.initialize_options
+    end
+
+    # Provides access to the command/options/arguments related information.
+    attr_reader :command
+
+    # Initialize some instance variables needed for the DSL.
+    def initialize_options # :nodoc:
+      @command = {
+        :option_defaults => {},
+        :elements        => [],
+      }
+    end
+
+    # Define default values for options.
+    # Example:
+    #   option_defaults :colors => false,
+    #                   :indent => 3
+    def option_defaults(defaults={})
+      @command[:option_defaults].update(defaults)
+    end
+
+    # Inject a piece of text into the helptext.
+    def text(*args)
+      @command[:elements] << [:text, args]
+    end
+
+    # Use an env-variable and map it to an option.
+    # Example:
+    #   env_option :indent, "INDENT"
+    def env_option(*args)
+      @command[:elements] << [:env_option, args]
+    end
+
+    # Define a formatter-specific option.
+    # See Command::Definition#option
+    def option(*args)
+      @command[:elements] << [:option, args]
+    end
+  end
+end

data/lib/baretest/invalidselectors.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright 2009-2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+
+  # Raised by BareTest.process_selectors if one or more invalid selectors are
+  # passed in.
+  class InvalidSelectors < StandardError
+
+    # The selectors that are invalid
+    attr_reader :selectors
+
+    # Generates a standard message
+    def initialize(selectors) # :nodoc:
+      @selectors = selectors
+      super("Invalid selectors: #{selectors.join(', ')}")
+    end
+  end
+end

data/lib/baretest/irb_mode.rb

@@ -24,6 +24,17 @@ module BareTest
   # See BareTest::IRBMode::AssertionContext for some methods IRBMode adds to Assertion for
   # use within the irb session.
   module IRBMode # :nodoc:
+    RemoveGlobals = %w[
+      $! $" $$ $& $' $* $+ $, $-0 $-F $-I $-K $-a $-d $-i $-l $-p $-v $-w $. $/
+      $0 $: $; $< $= $> $? $@ $FS $NR $OFS $ORS $PID $RS $\\ $_ $` $~
+      $ARGV $CHILD_STATUS $DEBUG $DEFAULT_INPUT $DEFAULT_OUTPUT $ERROR_INFO
+      $ERROR_POSITION $FIELD_SEPARATOR $FILENAME $IGNORECASE $INPUT_LINE_NUMBER
+      $INPUT_RECORD_SEPARATOR $KCODE $LAST_MATCH_INFO $LAST_PAREN_MATCH
+      $LAST_READ_LINE $LOADED_FEATURES $LOAD_PATH $MATCH $OUTPUT_FIELD_SEPARATOR
+      $OUTPUT_RECORD_SEPARATOR $POSTMATCH $PREMATCH $PROCESS_ID $PROGRAM_NAME
+      $SAFE $VERBOSE $stderr $stdin $stdout
+    ]
+
     @irb_setup = false
 
     def self.irb_setup! # :nodoc:
@@ -38,35 +49,52 @@ module BareTest
     # Adds several methods over plain Assertion.
     module IRBContext
 
-      attr_accessor :__original__
+      # Provides access the assertions' original status
+      attr_accessor :__status__
 
       # Prints a list of available helper methods
       def help
         puts "Available methods:",
-             "s!          - the original assertions' status",
-             "e!          - prints the error message and full backtrace",
-             "em!         - prints the error message",
-             "bt!         - prints the full backtrace",
-             "iv!         - lists all available instance variables",
-             "cv!         - lists all available class variables",
-             "gv!         - lists all available global variables",
-             "file        - the file this assertion was defined in",
-             "line        - the line number in the file where this assertion's definition starts",
-             "nesting     - a >-separated list of suite descriptions this assertion is nested in",
-             "description - this assertion's description",
-             "code        - the code of this assertion",
+             "s!           - the assertions' original status",
+             "sc!          - the assertions' original status code",
+             "e!           - prints the error message and full backtrace",
+             "em!          - prints the error message",
+             "bt!          - prints the full backtrace",
+             "lv!          - lists all available local variables",
+             "iv!          - lists all available instance variables",
+             "cv!          - lists all available class variables",
+             "gv!          - lists all available global variables, per default dropping rubys",
+             "               standard globals (use gv!(false) to avoid that)",
+             "file!        - the file this assertion was defined in",
+             "line!        - the line number in the file where this assertion's definition",
+             "               starts",
+             "nesting!     - a >-separated list of suite descriptions this assertion is nested",
+             "description! - this assertion's description",
+             "code!        - the code of this assertion",
              #"restart! - Restart this irb session, resetting everything",
-             "irb_help    - irb's original help",
-             "help        - this text you're reading right now"
+             "irb_help     - irb's original help",
+             "q            - Quit - alias to irb's exit",
+             "help         - this text you're reading right now"
       end
+      alias help! help
 
       def to_s # :nodoc:
         "Context"
       end
 
+      # Quit - an alias to irb's exit
+      def q
+        exit
+      end
+
       # Returns the original assertion's status
       def s!
-        p @__original__.status
+        @__status__
+      end
+
+      # Returns the original assertion's status code
+      def sc!
+        @__status__.status
       end
 
       # Prints the original assertion's error message and backtrace
@@ -77,20 +105,20 @@ module BareTest
 
       # Prints the original assertion's error message
       def em!
-        if @__original__.exception then
-          puts @__original__.exception.message
-        elsif @__original__.reason
-          puts @__original__.reason
+        if @__status__.exception then
+          puts @__status__.exception.message
+        elsif @__status__.failure_reason
+          puts @__status__.failure_reason
         else
-          puts "No exception occurred, therefore no error message is available"
+          puts "No exception or failure reason available"
         end
       end
 
       # Prints the original assertion's backtrace
       def bt!(size=nil)
-        if @__original__.exception then
+        if @__status__.exception then
           size ||= caller.size+3
-          puts @__original__.exception.backtrace[0..-size]
+          puts @__status__.exception.backtrace[0..-size]
         else
           puts "No exception occurred, therefore no backtrace is available"
         end
@@ -107,31 +135,47 @@ module BareTest
       end
 
       # Returns an array of all global variable names
-      def gv!
-        puts *global_variables.sort
+      def gv!(remove_standard=true)
+        puts *(global_variables-(remove_standard ? IRBMode::RemoveGlobals : [])).sort
+      end
+
+      # Returns the original assertion's file
+      def file!
+        puts @__assertion__.file
+      end
+
+      # Returns the original assertion's line
+      def line!
+        puts @__assertion__.line
+      end
+
+      # Returns the original assertion's line
+      def open!
+        `bbedit '#{@__assertion__.file}:#{@__assertion__.line}'`
       end
 
       # Prints a string of the original assertion's nesting within suites
-      def description
-        puts @__original__.description
+      def description!
+        puts @__assertion__.description
       end
 
       # Prints a string of the original assertion's nesting within suites
-      def nesting
-        puts @__original__.suite.ancestors[0..-2].reverse.map { |s| s.description }.join(' > ')
+      def nesting!
+        puts @__assertion__.suite.ancestors[0..-2].reverse.map { |s| s.description }.join(' > ')
       end
 
       # Prints the code of the assertion
       # Be aware that this relies on your code being properly indented.
       def code!
-        if code = @__original__.code then
-          puts(insert_line_numbers(code, @__original__.line-1))
+        if code = @__assertion__.code then
+          puts(insert_line_numbers(code, @__assertion__.line-1))
         else
           puts "Code could not be extracted"
         end
       end
 
-      def insert_line_numbers(code, start_line=1)
+      # Prepend the line number in front of ever line
+      def insert_line_numbers(code, start_line=1) # :nodoc:
         digits       = Math.log10(start_line+code.count("\n")).floor+1
         current_line = start_line-1
         code.gsub(/^/) { sprintf '  %0*d  ', digits, current_line+=1 }
@@ -152,48 +196,50 @@ module BareTest
     # Formatter callback.
     # Invoked once for every assertion.
     # Gets the assertion to run as single argument.
-    def run_test(assertion, setup)
+    def run_test(assertion, with_setup)
       rv = super
       # drop into irb if assertion failed
       case rv.status
         when :failure
-          start_irb_failure_mode(assertion)
-          irb_mode_for_assertion(assertion)
-          stop_irb_mode(assertion)
+          start_irb_failure_mode(assertion, rv)
+          irb_mode_for_assertion(assertion, rv, with_setup)
+          stop_irb_mode
         when :error
-          start_irb_error_mode(assertion)
-          irb_mode_for_assertion(assertion)
-          stop_irb_mode(assertion)
+          start_irb_error_mode(assertion, rv)
+          irb_mode_for_assertion(assertion, rv, with_setup)
+          stop_irb_mode
+        # with other states, irb-mode is not started
       end
 
       rv
     end
 
     # Invoked when we have to drop into irb mode due to a failure
-    def start_irb_failure_mode(assertion) # :nodoc:
+    def start_irb_failure_mode(assertion, status) # :nodoc:
       ancestry = assertion.suite.ancestors.reverse.map { |suite| suite.description }
 
       puts
-      puts "#{assertion.status.to_s.capitalize} in:  #{ancestry[1..-1].join(' > ')}"
+      puts "#{status.status.to_s.capitalize} in:  #{ancestry[1..-1].join(' > ')}"
       puts "Description: #{assertion.description}"
       if file = assertion.file then
-        code  = irb_code_reindented(file, assertion.line-1,20)
+        code  = irb_code_reindented(file, assertion.line-1,25)
         match = code.match(/\n^  [^ ]/)
-        code[-(match.post_match.size-3)..-1] = ""
+        code[-(match.post_match.size-3)..-1] = "" if match
+        code << "\n... (only showing first 25 lines)" unless match
         assertion.code = code
         puts "Code (#{file}):", insert_line_numbers(code, assertion.line-1)
       end
     end
 
     # Invoked when we have to drop into irb mode due to an error
-    def start_irb_error_mode(assertion) # :nodoc:
+    def start_irb_error_mode(assertion, status) # :nodoc:
       ancestry = assertion.suite.ancestors.reverse.map { |suite| suite.description }
 
       puts
-      puts "#{assertion.status.to_s.capitalize} in:    #{ancestry[1..-1].join(' > ')}"
+      puts "#{status.status.to_s.capitalize} in:    #{ancestry[1..-1].join(' > ')}"
       puts "Description: #{assertion.description}"
-      puts "Exception:   #{assertion.exception} in file #{assertion.exception.backtrace.first}"
-      if assertion.file && match = assertion.exception.backtrace.first.match(/^([^:]+):(\d+)(?:$|:in .*)/) then
+      puts "Exception:   #{status.exception} in file #{status.exception.backtrace.first}"
+      if assertion.file && match = status.exception.backtrace.first.match(/^([^:]+):(\d+)(?:$|:in .*)/) then
         file, line = match.captures
         file = File.expand_path(file)
         if assertion.file == file then
@@ -225,13 +271,11 @@ module BareTest
     # Drop into an irb shell in the context of the assertion passed as an argument.
     # Uses Assertion#clean_copy(AssertionContext) to create the context.
     # Adds the code into irb's history.
-    def irb_mode_for_assertion(original_assertion) # :nodoc:
-      assertion = original_assertion.clone
-      assertion.reset
-      irb_context = assertion.context
+    def irb_mode_for_assertion(assertion, status, with_setup) # :nodoc:
+      irb_context = ::BareTest::Assertion::Context.new(assertion)
       irb_context.extend IRBContext
-      irb_context.__original__ = original_assertion
-      assertion.setup
+      irb_context.__status__ = status
+      assertion.execute_phase(:setup, irb_context, with_setup.map { |s| s.block })
 
       $stdout = StringIO.new # HAX - silencing 'irb: warn: can't alias help from irb_help.' - find a better way
       irb = IRB::Irb.new(IRB::WorkSpace.new(irb_context))
@@ -243,21 +287,19 @@ module BareTest
 
       trap("SIGINT") do irb.signal_handle end
 
-      if code = original_assertion.code then
+      if code = assertion.code then
         #irb_context.code = code
         Readline::HISTORY.push(*code.split("\n")[1..-2])
       end
 
       catch(:IRB_EXIT) do irb.eval_input end
 
-      assertion.teardown
+      assertion.execute_phase(:teardown, irb_context, assertion.suite.ancestry_teardown)
     end
 
     # Invoked when we leave the irb session
-    def stop_irb_mode(assertion) # :nodoc:
+    def stop_irb_mode # :nodoc:
       puts
-      super
-    rescue NoMethodError # HAX, not happy about that. necessary due to order of extend
     end
   end
 end

data/lib/baretest/persistence.rb

@@ -0,0 +1,94 @@
+#--
+# Copyright 2009-2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/uid'
+require 'yaml'
+require 'fileutils'
+
+
+
+module BareTest
+
+  class Persistence
+
+    # The default storage path base (~/.baretest)
+    def self.storage_path
+      File.expand_path('~/.baretest')
+    end
+
+    # BareTest uses a file of the form '.baretest_id_*' (where * is a 32 digits
+    # long hex) to uniquely identify a project. This ID is then used to
+    # associate stored data with the project.
+    def self.determine_project_id(project_dir)
+      found = Dir.glob("#{project_dir}/.baretest_id_*") { |path|
+        break $1 if File.file?(path) && path =~ /id_([A-Fa-f0-9]{32})$/
+      }
+      unless found then
+        found = UID.hex_uid
+        File.open(".baretest_id_#{found}", "w") {} # no File::touch, evil
+      end
+
+      found
+    end
+
+    # The directory this Persistence instance stores its data
+    attr_reader :storage_dir
+
+    # The directory of the project this Persistence instance is attached to
+    attr_reader :project_dir
+
+    # The id of the project this Persistence instance is attached to
+    attr_reader :project_id
+
+    # Arguments:
+    # project_dir:: The directory of the project
+    # storage_dir:: The directory where this Persistence instance should store
+    #               its data
+    def initialize(project_dir=nil, storage_dir=nil)
+      @storage_dir = File.expand_path(storage_dir || self.class.storage_path)
+      @project_dir = File.expand_path(project_dir || ".")
+      @project_id  = self.class.determine_project_id(@project_dir)
+    end
+
+    # Stores data to a file.
+    #
+    # === Arguments
+    # filename:: A relative path. Directories are created on the fly if
+    #            necessary. Must not be an absolute path. The path is relative
+    #            to Persistence#storage_dir
+    # data::     The data to store. Anything that can be serialized by YAML.
+    #            This excludes IOs and Procs.
+    def store(filename, data)
+      raise "Invalid filename: #{filename}" unless filename =~ %r{\A[A-Za-z0-9_-][A-Za-z0-9_-]*\z}
+      dir = "#{@storage_dir}/#{@project_id}"
+      FileUtils.mkdir_p(dir)
+      File.open("#{dir}/#{filename}.yaml", "w") do |fh|
+        fh.write(data.to_yaml)
+      end
+    end
+
+    # Reads and deserializes the data in a given filename.
+    # filename:: A relative path. Directories are created on the fly if
+    #            necessary. Must not be an absolute path. The path is relative
+    #            to Persistence#storage_dir
+    # default::  The value to return in case the file does not exist.
+    #            Alternatively you can pass a block that calculates the default.
+    def read(filename, default=nil)
+      raise "Invalid filename: #{filename}" if filename =~ %r{\A\.\./|/\.\./\z}
+      path = "#{@storage_dir}/#{@project_id}/#{filename}.yaml"
+
+      if File.exist?(path)
+        YAML.load_file(path)
+      elsif block_given?
+        yield
+      else
+        default
+      end
+    end
+  end
+end