rdx 0.9.0.pre → 0.9.0.pre.1

data/lib/rdx/assertions.rb

@@ -3,8 +3,9 @@ module RDX
 	
 	#
 	# RDX uses the assertions of the standard testing framework of ruby, +Minitest+.
-	# This module adapt its functionality to RDX's needs.
-	# The most important new features are:
+	# This module adapt its functionality to RDX's needs,
+	# providing a layer of compatibility between all +Minitest+'s versions.
+	# Moreover new features are available. The most important ones are:
 	# * #assert_equal_numeric: more powerful than +assert_equal+ if +Numeric+ are involved;
 	# * #assert_string_match: perfect when comparing an actual +String+ with an expected +String+ or +Regexp+;
 	# * #assert_msg_raised: checks the exception message in alternative of or along to the exception class;
@@ -20,16 +21,14 @@ module RDX
 		begin
 			gem 'minitest', '>= 5.0'
 			require 'minitest/assertions'
+			include Minitest::Assertions
 		rescue Gem::LoadError
 			gem 'minitest'
 			require 'minitest/unit'
-			::Minitest = ::MiniTest unless Object.const_defined?(:Minitest) # For minitest < 2.12
+			mt = Object.const_defined?(:Minitest) ? Minitest : MiniTest # For minitest < 2.12
+			include mt::Assertions # :nodoc:
 		end
 		
-		include Minitest::Assertions
-		
-		extend self
-		
 		PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit] # :nodoc:
 		
 		# Doesn't count assertions (done in CodeObject::Runnable#trace_assertion).
@@ -246,7 +245,7 @@ module RDX
 			assert_output_but normalize, '', '', out_msg, err_msg, &blk
 		end
 		
-		# Overrided to implicitly call #normalize_values.
+		# Overridden to implicitly call #normalize_values.
 		def assert_silent *args, &blk
 			assert_silent_but nil, *args, &blk
 		end
@@ -375,7 +374,7 @@ module RDX
 		
 		#
 		# Returns _exp_ and _act_ in an +Array+ normalized through the block given.
-		# This method can be overridded to modify the normalization.
+		# This method can be overridden to modify the normalization.
 		#
 		def normalize_values exp, act, &normalize
 			if normalize

data/lib/rdx/binding.rb

@@ -62,7 +62,7 @@ module RDX
 		# * +include+ and +define_method+ are redefined to better reproduce this environment.
 		# 
 		# These lead to the fact that almost all new definitions - intentional top-level constants and global
-		# variables are excluded - are restricted to that binding. All of this without sacrifycing efficiency.
+		# variables are excluded - are restricted to that binding. All of this without sacrificing efficiency.
 		# 
 		# :rdx: toplevel
 		# 
@@ -95,7 +95,7 @@ module RDX
 		#   $global_var       # => true
 		#   # Clean up:
 		#   Object.send :remove_const, :TOP_LEVEL_CONST # => true
-		#   $global_var = nil   # Even if it isn't truely removed...
+		#   $global_var = nil   # Even if it isn't truly removed...
 		# 
 		# These features makes #pseudo_toplevel_binding the favourite by RDX.
 		#

data/lib/rdx/comment.rb

@@ -67,13 +67,17 @@ module RDX
 			examples.select(&:active?)
 		end
 		
-		#
-		# :category: API
+	#
+	# :section: API
+	#
+		
 		# 
 		# Disables the directives of the given _names_ that are +implicit?+ in _section_.
 		# If no name is given, all of them are disabled.
+		# If _section_ is +nil+, nothing will happen.
 		#
 		def disable_implicit_directives_in section, *names
+			return if section.nil?
 			implicit_dirs = directives.select{ |dir| dir.implicit?(section) }
 			unless names.empty?
 				names.map!{ |dir_name| store.directive(dir_name) } # directive classes
@@ -83,8 +87,6 @@ module RDX
 		end
 		
 		#
-		# :category: API
-		# 
 		# Disables the directives of the given _names_ that are +implicit?+ in this comment.
 		# If no name is given, all of them are disabled.
 		#
@@ -320,7 +322,7 @@ module RDX
 		end
 		
 		#
-		# Every commment seen by the parser is checked for the presence of conventions:
+		# Every comment seen by the parser is checked for the presence of conventions:
 		# if they are in places where they will not be executed a warning will be generated.
 		# This is done in text sections (see PlainText#check_missing_conventions) and in
 		# examples that won't be part of the documentation output (see Example#check_non_documenting).

data/lib/rdx/convention.rb

@@ -24,7 +24,7 @@ module RDX
 	# 
 	# == A tour on the existing conventions
 	# 
-	# The most important *default* conventions (and some derivates for literals) currently are:
+	# The most important *default* conventions (and some derivatives for literals) currently are:
 	# * ::result_eval: checks the result
 	#     [1,2,3].pop(2)        # => [2,3]
 	# * ::output_literal: checks the output
@@ -269,7 +269,7 @@ module RDX
 		# #process_statement and #process_expectation) and is executed in the context of
 		# (with +self+ as) the corresponding Example - class that includes the Assertion module,
 		# providing full access to Minitest framework. This allows to customize the assertion methods
-		# for only some examples (through some directives), but mantains an unified and coherent
+		# for only some examples (through some directives), but maintains an unified and coherent
 		# behaviour between statements inside it.
 		#
 		define_processor :process_assertion
@@ -309,6 +309,7 @@ module RDX
 		def use_with(*args,&blk)
 			if @configuration
 				@configuration.call(*args,&blk)
+				# TODO: handle derivative conventions
 			elsif !args.empty? || blk
 				raise "#{self} does not accept a configuration"
 			end
@@ -544,7 +545,7 @@ module RDX
 		#   Both the strings +a+ and +b+ have the same content;
 		#   if the <tt>=></tt> prompt always maps to an +assert_equal+ the assertion would pass...
 		#   But it's really what we mean, what we want to bring out from the example?
-		#   That sounds much more like "it returns the object _labelled_ +a+"
+		#   That sounds much more like "it returns the object _referenced_ _by_ +a+"
 		#   then "it returns an object _equal_ _to_ +a+".
 		# 
 		# Expectation format::
@@ -837,7 +838,7 @@ module RDX
 		#     #   'a' => 2
 		#     # }   # does these spaces really matter? And the order in which pairs are listed?
 		#     File.expand_path 'a' #=> "#{Dir.pwd}/a" # interpolation of values not allowed
-		#     (1..1000).first 100  #=> (1..100).to_a  # shorthands not allowed
+		#     (1..1000).first 100  #=> (1..100).to_a  # shorthand not allowed
 		#     "abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
 		#                                             # the second string should be: " \0\0"
 		#     
@@ -870,7 +871,7 @@ module RDX
 		# :singleton-method:
 		#
 		# Derived from ::result_inspect::
-		#   The aim is to reduce discrepances due to float calculations and representations,
+		#   The aim is to reduce discrepancies due to float calculations and representations,
 		#   one of the things that ::result_numeric does for ::result_eval (but
 		#   here this is done in strings).
 		#
@@ -1022,7 +1023,7 @@ module RDX
 		# Description::
 		#   Recognizes the class and the message of the exception raised by the statement.
 		#   The message is interpreted literally, without any evaluation:
-		#   to remove little discrepances Text#normalize_exception_message is used.
+		#   to remove little discrepancies Text#normalize_exception_message is used.
 		#   The class (if given), message and +false+ are sent to Assertions#assert_msg_raised.
 		#   
 		#     1.odd?(true)       # raises ArgumentError: wrong number of arguments (1 for 0)
@@ -1060,7 +1061,7 @@ module RDX
 		# 
 		# Description::
 		#   Recognizes the class and the message of the exception raised by the statement.
-		#   The message is evalued, thus avoiding any sort of levellation: this enables
+		#   The message is evalued, thus avoiding any sort of levelling: this enables
 		#   a more formal approach in contrast to ::error_literal.
 		#   The class (if given) and message are sent to Assertions#assert_msg_raised.
 		#   
@@ -1079,7 +1080,7 @@ module RDX
 			process_statement{ |code| lambda{ eval(code) } }
 			process_expectation do |content|
 				cls,msg = Text.split_exception_string(content,:class_message)
-				# :message_class is not allowed, since a valid statement can end with a parhentesis...
+				# :message_class is not allowed, since a valid statement can end with a parenthesis...
 				cls &&= toplevel_scope.const_get(cls)
 				msg &&= eval(msg)
 				[cls,msg]
@@ -1139,7 +1140,7 @@ module RDX
 		#   * we don't care about the result obtained, but we have anyhow to evaluate the code;
 		#   * we do care about it, but other conventions aren't suitable in these circumstances.
 		# 
-		#   The latter situation is more intresting.
+		#   The latter situation is more interesting.
 		#   Consider the following (from <tt>time.c</tt>):
 		#   
 		#     t = Time.now   # 2007-11-19 08:18:31 -0600

data/lib/rdx/directive.rb

@@ -19,11 +19,11 @@ module RDX
 	# 
 	# There are many directives, subdivided for functionality:
 	# * Activation/Deactivation: like ::on, ::off, ::skip, ::if, ::lazy;
-	# * Input/Output/Error: the most useful is ::stdout;
-	# * Context change: they can change the binding, current directory, execution in time
-	#   (like ::setup and ::teardown), simulate a ::bash session;
+	# * Input/Output/Error: the most useful are ::stdout and ::write_file;
+	# * Context change: they can change the binding (::new_binding, ::toplevel), current directory (::in_tmpdir),
+	#   execution in time (::setup and ::teardown), simulate a ::bash session;
 	# * Assertion customization: to mention ::float
-	# * Miscellanous: insert comments, ::disable_warnings, ...
+	# * Miscellaneous: insert comments (::#), ::disable_warnings, ...
 	# All the directives already defined are documented as Directive's class methods
 	# (even if technically they aren't) in the relative sections.
 	# 
@@ -57,7 +57,7 @@ module RDX
 	# For this reason the class methods are used to define the behaviour of the directive
 	# (the most important is ::define), while the instance ones allow to query
 	# informations about their status (the #parameter, if it's #implicit?, some stored #metadata)
-	# and retrive neighbour sections in the comment (the most used is #next_example).
+	# and retrieve neighbour sections in the comment (the most used is #next_example).
 	#
 	class Directive < CodeObject
 		
@@ -146,18 +146,27 @@ module RDX
 			# without changing the block's context.
 			# 
 			# In both ways, you should use the instance methods of Directive to access its
-			# its status and retrive neighbour sections. At this point you will need the API
+			# its status and retrieve neighbour sections. At this point you will need the API
 			# provided by the CodeObject class and its descendants - mainly the Example one -
 			# to shape their behaviour to your needs.
+			# 
+			# *Note*: explicit and implicit directives won't conflict on the same example
+			# thanks to #hide_implicit_similar.
 			#
 			def define &execution
 				if execution.arity == 0
 					define_method :execute do
-						trace_execution{ instance_eval(&execution) }
+						trace_execution do
+							hide_implicit_similar unless implicit?
+							instance_eval(&execution)
+						end
 					end
 				else
 					define_method :execute do
-						trace_execution{ execution.call(self) }
+						trace_execution do
+							hide_implicit_similar unless implicit?
+							execution.call(self)
+						end
 					end
 				end
 			end
@@ -165,7 +174,7 @@ module RDX
 			#
 			# :category: Internal
 			# 
-			# Registers the given block as a configuration for the implicit recognization:
+			# Registers the given block as a configuration for the implicit recognition:
 			# this centralizes the building procedure, allowing the user to supply
 			# (through ::use_implicit_with) only the desired parameters - often some particular
 			# pattern or word. The block should call ::find_in_text or ::find_in_example.
@@ -204,7 +213,7 @@ module RDX
 			end
 			
 			#
-			# Restores the default configuration for the implicit recognization of this
+			# Restores the default configuration for the implicit recognition of this
 			# directive. First calls ::clear_implicit_patterns, then
 			# calls the block supplied to ::configure_implicit without parameters
 			# (so its arity should allow this).
@@ -403,6 +412,20 @@ module RDX
 			in_sections.find{ |sec| sec.line_range.cover?(self.line_no) }
 		end
 		
+	#
+	# :section: Internal
+	# 
+		
+		# 
+		# This method will be called whenever an explicit directive is used.
+		# Implicit ones of the same type are disabled from the #next_example,
+		# so that they won't interfere.
+		#
+		def hide_implicit_similar # :doc:
+			comment.disable_implicit_directives_in next_examples.first, self.name
+		end
+		private :hide_implicit_similar
+		
 	#
 	# :section: API
 	#
@@ -433,7 +456,7 @@ module RDX
 		
 		def section_index # :nodoc:
 			@section_index ||= comment.sections.find_index{ |sec| sec.line_no >= self.line_no } ||
-				comment.sections.size-1
+				comment.sections.size
 		end
 		private :section_index
 		
@@ -606,7 +629,7 @@ module RDX
 		#   
 		# Note::
 		#   This may also be used in a non-documenting comment (see Comment#documenting),
-		#   with the purpouse of executing additional examples other than the ones in the documentation output.
+		#   with the purpose of executing additional examples other than the ones in the documentation output.
 		#
 		define_directive 'on' do
 			next_examples{ |ex| ex.activate true }
@@ -621,7 +644,7 @@ module RDX
 		# Turns off execution of examples (see the ::on directive for an example).
 		# 
 		# Note::
-		#   If the parameter is (or starts with) a hypen, only the immediately following
+		#   If the parameter is (or starts with) a hyphen, only the immediately following
 		#   example is deactivated; the execution will continue regularly,
 		#   according to the effect of other directives after it.
 		#
@@ -736,7 +759,7 @@ module RDX
 		#   is_slow
 		# 
 		# Run the next example only when necessary (see Example#lazy).
-		# This directive is often used when the example shows performance penalities.
+		# This directive is often used when the example shows performance penalties.
 		# 
 		# An example (from <tt>re.rdoc</tt>):
 		# :rdx: off
@@ -766,7 +789,7 @@ module RDX
 		#   stdout
 		#   output
 		# 
-		# Interprets the next example as the expected output of the previuos one
+		# Interprets the next example as the expected output of the previous one
 		# (see Example#produces_on_stdout).
 		# 
 		# Implicit detection::
@@ -784,7 +807,7 @@ module RDX
 		# 
 		# Note::
 		#   If the output is only one line it can be passed as a parameter to this directive
-		#   (and it's probably described in a text section)
+		#   (and it's probably described in a text section).
 		#
 		define_directive 'stdout' do |dir|
 			dir.define do
@@ -804,7 +827,7 @@ module RDX
 		# :call-seq:
 		#   indicative_output
 		#   
-		# Ignores the next example and the output produced by the previuos one.
+		# Ignores the next example and the output produced by the previous one.
 		# 
 		# An example:
 		#   #
@@ -832,7 +855,7 @@ module RDX
 		# :call-seq:
 		#   stderr
 		#   
-		# Interprets the next example as the expected output of the previuos one
+		# Interprets the next example as the expected output of the previous one
 		# (see Example#produces_on_stderr).
 		# 
 		# An example (from <tt>enumerator.c</tt>):
@@ -984,7 +1007,7 @@ module RDX
 		#   #   f.puts 'line 1'
 		#   #   f.puts 'line 2'
 		#   #   f.puts 'line 1000' # 1,2,3 was boring...
-		#   # Now the file +out+ will contian:
+		#   # Now the file +out+ will contain:
 		#   # :rdx: check_file out
 		#   #   line 1
 		#   #   line 2
@@ -1069,7 +1092,7 @@ module RDX
 		#   rb_struct_s_def(int argc, VALUE *argv, VALUE klass)
 		#   
 		# Note::
-		#   It's user's responsibilty to clean up all the necessary
+		#   It's user's responsibility to clean up all the necessary
 		#   (usually using private rdx sections).
 		#
 		define_directive 'toplevel' do
@@ -1205,14 +1228,14 @@ module RDX
 		##
 		# :singleton-method:
 		# :call-seq:
-		#   bash default_prompt=/\$\s/, continuation_prompt=/>\s/
+		#   bash default_prompt=/\$\s/, continuation_prompt=/>\s/, output_prompt=""
 		#   
 		# Interprets the next example as a bash command-line session
 		# (see Example#on_bash_mode).
 		# 
 		# Implicit detection::
 		#   Recognized in an example that begins with the default prompt (the predefined
-		#   isn't syntattically correct in Ruby, so we can safely avoid ambiguous situations).
+		#   isn't syntactically correct in Ruby, so we can safely avoid ambiguous situations).
 		# 
 		#   An example (from <tt>optparse.rb</tt>):
 		#     # [...]
@@ -1227,8 +1250,8 @@ module RDX
 		#     class OptionParser; end
 		#   
 		# Note::
-		#   If the output includes the default or continuation prompt you should change
-		#   them (or supply +nil+ if you don't want) with the explicit directive:
+		#   You can use the explicit directive to change values for all these prompts
+		#   (or supply +nil+ if you want to keep the default).
 		#   :rdx: off
 		#     # This is the result in the command line (<tt>" </tt> is the continuation prompt):
 		#     # :rdx: bash nil, '" '
@@ -1241,11 +1264,13 @@ module RDX
 		define_directive 'bash' do |dir|
 			dir.metadata[:default_prompt]      = /\$\s/
 			dir.metadata[:continuation_prompt] = />\s/
+			dir.metadata[:output_prompt]       = ''
 			dir.define do
-				default_prompt,continuation_prompt = param && eval("[#{param}]")
+				default_prompt,continuation_prompt,output_prompt = param && eval("[#{param}]")
 				default_prompt      ||= metadata[:default_prompt]
 				continuation_prompt ||= metadata[:continuation_prompt]
-				next_example.on_bash_mode default_prompt, continuation_prompt
+				output_prompt       ||= metadata[:output_prompt]
+				next_example.on_bash_mode default_prompt, continuation_prompt, output_prompt
 			end
 			dir.configure_implicit do |prompt=dir.metadata[:default_prompt]|
 				prompt = prompt.is_a?(Regexp) ? prompt.to_s : Regexp.escape(prompt.to_str)

data/lib/rdx/example.rb

@@ -54,7 +54,7 @@ module RDX
 			not @active.nil?
 		end
 		
-		# Will this example be runned?
+		# Will this example be run?
 		def active?
 			@active
 		end
@@ -63,6 +63,67 @@ module RDX
 	# :section: API
 	#
 		
+		#
+		# :call-seq:
+		#   enhance_normalization{ |exp,act| ... -> [new_exp,new_act] }
+		#
+		# Prepends the block processor (which receives and should return _exp_ and _act_)
+		# to the actual #normalize_values method, allowing to enhance its functionality.
+		# 
+		#-- rdx
+		#   an_example = RDX::Example.allocate
+		#   def an_example.normalize_values(exp,act); p [exp,act]; end
+		#++
+		#   an_example.enhance_normalization do |exp,act|   #   <- receives the values to be compared
+		#     #   -> Add your customization here! <-
+		#     # say that don't want to see differences in floats:
+		#     new_exp = new_act = 0.0 if exp.is_a?(Float) && act.is_a?(Float)
+		#     [new_exp, new_act]                         #   <- return them (from the block) in a two-element array
+		#     # After this block the regular normalize_values is called
+		#   end
+		#-- rdx
+		# :rdx:
+		#   an_example.normalize_values(1.99,2.0) #=> [0.0, 0.0]
+		# :rdx: output [0.0, 0.0]
+		#++
+		#
+		def enhance_normalization &enhancement
+			orig_level = method(:normalize_values)
+			define_singleton_method :normalize_values do |exp,act,&normalizing_proc|
+				exp,act = enhancement.call(exp,act).to_ary
+				orig_level.call exp, act, &normalizing_proc
+			end
+		end
+		
+		#
+		# :call-seq:
+		#   enhance_running{ |orig_run| ... orig_run.call ... }
+		#
+		# Replaces the #run method with the given block.
+		# This receives the original +Method+ as a block parameter,
+		# allowing to call it somewhere (although this is not necessary).
+		# 
+		#-- rdx
+		#   an_example = RDX::Example.allocate
+		#   def an_example.run; puts "out"; end
+		#++
+		#   an_example.enhance_running do |orig_run|   #   <- receives the original method
+		#     #   -> This block will become the new run method <-
+		#     # say that we want to discard $stdout and $stderr:
+		#     RDX::Util.change_ostreams nil, nil do   # check out the documentation if you want...
+		#       orig_run.call   #   <- the original method gets wrapped in this block
+		#     end
+		#   end
+		#-- rdx
+		#   an_example.run # >> ""
+		#
+		def enhance_running &enhancement #! rename
+			orig_run = method(:run)
+			define_singleton_method :run do
+				enhancement.call(orig_run)
+			end
+		end
+		
 		# Returns +true+. This method should be used instead of _section_<tt>.is_a?(Example)</tt>.
 		def example?
 			true
@@ -116,36 +177,6 @@ module RDX
 			super msg, type, comment.location(l_no)
 		end
 		
-		#
-		# Marks this example as deliberately buggy. This means that:
-		# * failures and errors are ordinary: they are not reported;
-		# * successes are unexpected: a warning of type +bug+ will
-		#   be reported along with the success.
-		#
-		def is_buggy
-			activate
-			dont_register = lambda{ |*| }
-			define_singleton_method :build_children do
-				super()
-				define_singleton_method :register_failure, dont_register
-				define_singleton_method :register_error, dont_register
-				define_singleton_method :register_success do |*args|
-					warn 'Bug not detected: the assertion passes', :bug
-					super(*args)
-				end
-				statements.each do |stmnt|
-					stmnt.define_singleton_method :register_error, dont_register
-				end
-				statements.flat_map(&:children).each do |expct|
-					expct.define_singleton_method :register_failure, dont_register
-					expct.define_singleton_method :register_success do |*args|
-						warn 'Bug not detected: the assertion passes', :bug if assertion?
-						super(*args)
-					end
-				end
-			end
-		end
-		
 		# Activates this example and calls +super+.
 		def run_in_tmpdir
 			activate
@@ -188,15 +219,14 @@ module RDX
 				output.deactivate!
 				output = output.text
 			end
-			orig_level = method(:normalize_values)
-			define_singleton_method :normalize_values do |exp,act,&normalize|
+			enhance_normalization do |exp,act|
 				if act.is_a?(String)
 					act = act.dup
 					act.gsub! /^#{Regexp.escape file_name}:(\d+): (?=warning: )/ do |matched|
 						line_range.cover?($1.to_i) ? '' : matched
 					end
 				end
-				orig_level.call(exp,act,&normalize)
+				[exp,act]
 			end
 			set_output nil, output, l_no
 		end
@@ -210,11 +240,10 @@ module RDX
 		#
 		def set_output stdout, stderr, l_no=nil
 			l_no ||= relative_line_no
-			orig_run = method(:run)
 			normalize = Text.method(:normalize_output).to_proc
-			define_singleton_method :run do
+			enhance_running do |orig_running|
 				trace_assertion :multiline_output_literal, comment.location(l_no) do
-					assert_output_but(normalize,stdout,stderr){ orig_run.call }
+					assert_output_but normalize, stdout, stderr, &orig_running
 				end
 			end
 			return self
@@ -230,9 +259,8 @@ module RDX
 				input.deactivate!
 				input = input.text
 			end
-			orig_run = method(:run)
-			define_singleton_method :run do
-				RDX::Util.change_stdin(input){ orig_run.call }
+			enhance_running do |orig_running|
+				RDX::Util.change_stdin input, &orig_running
 			end
 			return self
 		end
@@ -262,13 +290,10 @@ module RDX
 			end
 			cls = toplevel_scope.const_get(cls) if cls.is_a?(String)
 			l_no ||= relative_line_no
-			orig_run = method(:run)
 			normalize = Text.method(:normalize_exception_message).to_proc
-			define_singleton_method :run do
+			enhance_running do |orig_running|
 				trace_assertion :error_literal, comment.location(l_no) do
-					assert_msg_raised_but normalize, msg, false, *cls do
-						orig_run.call
-					end
+					assert_msg_raised_but normalize, msg, false, *cls, &orig_running
 				end
 			end
 			return self
@@ -309,7 +334,7 @@ module RDX
 			return self
 		end
 		
-		# Run this exemple in a full independent way from the parent comment.
+		# Run this example in a full independent way from the parent comment.
 		def separate_from_comment
 			deactivate!            # will be deleted for sure from the comment
 			build
@@ -337,15 +362,15 @@ module RDX
 		# 
 		# Since this example is not executed #check_convention_patterns is called.
 		#
-		def write_to_file fname, l_no=relative_line_no
+		def write_to_file fname, l_no=nil, perform_convention_check=true
 			activate
 			fname = Pathname(fname)
 			raise 'Absolute location not allowed' if fname.absolute?
 			l_no ||= relative_line_no
-			check_convention_patterns 'example not executable'
+			check_convention_patterns 'example not executable' if perform_convention_check
 			comment.run_in_tmpdir
 			skip_building
-			define_singleton_method :run do
+			enhance_running do
 				trace_execution comment.location(l_no) do
 					content = self.text.dup
 					content = yield(content) if block_given?
@@ -373,7 +398,7 @@ module RDX
 			comment.run_in_tmpdir
 			normalize = Text.method(:normalize_output).to_proc
 			skip_building
-			define_singleton_method :run do
+			enhance_running do
 				trace_assertion :file_content, comment.location(l_no) do
 					act = fname.read
 					exp = self.text
@@ -401,13 +426,12 @@ module RDX
 					super(exp,act,*args,&blk)
 				end
 			end
-			orig_level = method :normalize_values
-			define_singleton_method :normalize_values do |exp,act,&normalize|
+			enhance_normalization do |exp,act|
 				if exp.is_a?(String) && act.is_a?(String)
 					exp = Text.normalize_floats(exp,digits)
 					act = Text.normalize_floats(act,digits)
 				end
-				orig_level.call(exp,act,&normalize)
+				[exp,act]
 			end
 		end
 
@@ -419,33 +443,33 @@ module RDX
 		#
 		def on_indicative_numbers_mode
 			activate
-			orig_level = method :normalize_values
-			define_singleton_method :normalize_values do |exp,act,&normalize|
+			enhance_normalization do |exp,act|
 				if exp.is_a?(Numeric) && act.is_a?(Numeric)
 					exp = act = 0
 				elsif exp.is_a?(String) && act.is_a?(String)
 					exp = Text.generalize_numerics(exp)
 					act = Text.generalize_numerics(act)
 				end
-				orig_level.call(exp,act,&normalize)
+				[exp,act]
 			end
 		end
 		
 		class Bash # :nodoc:
 			require 'open3'
 			class << self
-				# The system +bash+ command used by Directive::bash.
+				# The +bash+ system command used by Directive::bash.
 				attr_accessor :bash
 			end
 			self.bash = 'bash'
-			attr_reader :example, :default_prompt, :continuation_prompt
-			private :example, :default_prompt, :continuation_prompt
-			def initialize example, default_prompt, continuation_prompt
-				@example = example
-				@default_prompt      = build_prompt default_prompt
-				@continuation_prompt = build_prompt continuation_prompt
+			attr_reader :default_prompt, :continuation_prompt, :output_prompt
+			private :default_prompt, :continuation_prompt
+			def initialize default_prompt, continuation_prompt, output_prompt
+				@default_prompt      = build_prompt(default_prompt)
+				@continuation_prompt = build_prompt(continuation_prompt)
+				@output_prompt       = build_prompt(output_prompt.to_str)
 			end
 			def parse code
+				code = Text.strip_newlines(code,false)
 				result = [] # [input,input_l_no,output,output_l_no]
 				prev_status = nil
 				code.each_line.with_index do |line,l_no|
@@ -465,6 +489,8 @@ module RDX
 							raise ParseError.new "Default prompt `#{default_prompt}' not detected", l_no
 						end
 						current_elem[2] << line
+					else
+						raise ParseError.new "Unknown line `#{line}': no prompt detected", l_no
 					end
 					prev_status = status
 				end
@@ -500,7 +526,7 @@ module RDX
 					:start_input
 				elsif line.slice!(continuation_prompt)
 					:cont_input
-				else
+				elsif line.slice!(output_prompt)
 					:output
 				end
 			end
@@ -513,19 +539,19 @@ module RDX
 		# The execution is interpreted according to the beginning of each line:
 		# * _default_prompt_ starts a new bash command;
 		# * _continuation_prompt_ continues the current command;
-		# * otherwise specifies the output of the current command
+		# * _output_prompt_ specifies the output of the current command
 		#   (differences are reduced through Text#normalize_output).
 		#
-		def on_bash_mode default_prompt, continuation_prompt
+		def on_bash_mode default_prompt, continuation_prompt, output_prompt
 			activate
 			comment.run_in_tmpdir
-			bash = Bash.new self, default_prompt, continuation_prompt
+			bash = Bash.new default_prompt, continuation_prompt, output_prompt
 			io = nil
 			define_singleton_method :build_self do
 				io = bash.parse text
 			end
 			normalize = Text.method(:normalize_output).to_proc
-			define_singleton_method :run do
+			enhance_running do
 				return unless io
 				io.each do |input,input_l_no,exp_out,out_l_no|
 					begin