rdx 0.9.0.pre

data/lib/rdx/store.rb

@@ -0,0 +1,119 @@
+
+module RDX
+	
+	#
+	# Stores RDX data and handles acccess to it.
+	#
+	class Store
+		
+		attr_reader :runner
+		
+		attr_reader :source_files
+		
+		attr_reader :reportables
+		
+		attr_reader :eval_convention
+		
+		def initialize spec
+			init_conventions spec
+			init_directives spec
+			@source_files = []
+			@source_files_hash = Hash.new do |hsh,fname|
+				src = SourceFile.new(fname)
+				@source_files << src
+				hsh[fname] = src
+			end
+			@tests = []
+			@reportables = nil
+		end
+		
+		def init_conventions spec
+			@conventions = spec.conventions
+			@findable_conventions = @conventions.select(&:process_comment)
+			@eval_convention = @conventions.find{ |conv| conv.name == :eval } or
+				warn("Missing `eval' convention, using original one") && Convention[:eval]
+		end
+		
+		def init_directives spec
+			@directives = spec.directives
+			@implicit_directives = @directives.values.uniq.select(&:has_implicit?)
+		end
+		
+		def find_source_file file_name
+			@source_files_hash[file_name]
+		end
+		
+		def tests_no
+			@tests.size
+		end
+		
+		def add_test runnable
+			@tests << runnable if runnable.prepare_for_testing
+		end
+		
+		def passed?
+			!@tests.empty? and @tests.all?(&:passed?)
+		end
+		
+		def tests_before_require
+			@tests.select(&:before_require)
+		end
+		
+		def tests_after_require
+			@tests.reject(&:before_require)
+		end
+		
+		def dispose_bindings
+			@tests.each do |test|
+				test.binding = nil
+			end
+		end
+		
+		def directive name
+			name = Directive.validate_name name
+			@directives[name] or
+				raise Error, "Undefined directive `#{name}'"
+		end
+		
+		def build seed
+			return if @source_files_hash.nil?
+			@source_files_hash = nil
+			source_files.freeze.each(&:build)
+			srand seed
+			@tests.shuffle!
+			@test.freeze
+		end
+		
+		def register_reportable reportable, runnable
+			@reportables_hash[runnable.comment] << reportable
+		end
+	
+		def collect_reportables
+			return @reportables if @reportables
+			@reportables = source_files.sort.flat_map(&:collect_reportables)
+		end
+		
+		def find_convention_in text
+			return nil unless text =~ /\S/
+			result = nil
+			conv = @findable_conventions.find{ |conv| result = conv.call_process_comment(nil,text) }
+			return nil unless conv
+			yield(conv,result) if block_given?
+			return [conv, result]
+		end
+		
+		def scan_for_implicit_directives type, text
+			implicit_directives = []
+			@implicit_directives.each do |directive|
+				directive.find_implicit_in(type,text) do |param,l_no|
+					dir_str = directive.name
+					dir_str = Directive.join dir_str, param if param
+					implicit_directives << [:directive,dir_str,l_no]
+				end
+			end
+			return implicit_directives.sort_by!.with_index{ |(_,_,l_no),i| [l_no,i] }
+		end
+		
+	end
+	
+end

data/lib/rdx/task.rb

@@ -0,0 +1,361 @@
+
+require 'rdx'
+require 'rake/tasklib'
+
+
+class Module # :nodoc:
+	
+  alias const_missing_full_bt const_missing
+	private :const_missing_full_bt
+	# Remove Rake's frame
+  def const_missing(const_name)
+		const_missing_full_bt(const_name)
+	rescue NameError => exc
+		bt = exc.backtrace
+		bt.shift if bt.first.include?('/rake/ext/module.rb:')
+		bt.shift if bt.first.start_with?(__FILE__)
+		raise exc
+  end
+	
+end
+
+
+module RDX
+	
+	#
+	# Helps the building of command line options for running RDX.
+	#
+	class Task < Rake::TaskLib
+		
+	# :stopdoc:
+
+		@contents = []
+
+		def self.define_accessor name, &definition
+			attr_accessor name
+			@contents << definition
+		end
+		private_class_method :define_accessor
+
+		def self.apply_defaults_to task
+			finalize_procs = @contents.map do |definition|
+				task.instance_eval(&definition)
+			end
+			task.finalize_with finalize_procs
+		end
+		
+	# :startdoc:
+		
+		# Name of the taks.
+		attr_accessor :name
+		
+		# Description of the task.
+		attr_accessor :description
+		
+		# The Rake::FileList containing the files to be processed.
+		attr_accessor :files
+		
+		##
+		# :method:
+		# :call-seq:
+		#   extra_options
+		#   extra_options=array
+		# 
+		# The array of additional command line options.
+		#
+		define_accessor :extra_options do
+			@extra_options = []
+			lambda{ |opts| opts.concat extra_options.to_a }
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   verbose
+		#   verbose=val
+		# 
+		# Handles Options#verbose.
+		#
+		define_accessor :verbose do
+			@verbose = false
+			lambda{ |opts| opts << '-v' if verbose }
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   debug
+		#   debug=val
+		# 
+		# Handles Options#debug.
+		#
+		define_accessor :debug do
+			@debug = false
+			lambda{ |opts| opts << '-d' if debug }
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   dry_run
+		#   dry_run=val
+		# 
+		# Handles Options#dry_run.
+		#
+		define_accessor :dry_run do
+			@dry_run = false
+			lambda{ |opts| opts << '-y' if dry_run }
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   fast
+		#   fast=val
+		# 
+		# Handles Options#fast.
+		#
+		define_accessor :fast do
+			@fast = false
+			lambda{ |opts| opts << '-f' if fast }
+		end
+		# Will the documentation output be produced?
+		def doc_output
+			not fast
+		end
+		# Enables or disables the generation of documentation output.
+		def doc_output= val
+			self.fast = !val
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   lib_dirs
+		#   lib_dirs=array
+		# 
+		# Handles Options#lib_dirs.
+		# 
+		# Using Rake this is option is ruby-centred: if exists a +lib+ directory it will be added
+		# to this list.
+		#
+		define_accessor :lib_dirs do
+			@lib_dirs = []
+			@lib_dirs << 'lib' if File.directory?('lib')
+			lambda do |opts|
+				opts << '-I' << lib_dirs.shift.to_s until lib_dirs.empty? if lib_dirs
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   libs
+		#   libs=array
+		# 
+		# Handles Options#libs.
+		# 
+		define_accessor :libs do
+			@libs = nil
+			lambda do |opts|
+				opts << '-r' << libs.shift.to_s until libs.empty? if libs
+			end
+		end
+		# Requires the given _libs_ for the tests.
+		def require_libs *libs
+			self.libs ||= []
+			self.libs.concat libs.map(&:to_str)
+		end
+		alias require_lib require_libs
+		
+		##
+		# :method:
+		# :call-seq:
+		#   seed
+		#   seed=int
+		# 
+		# Handles Options#seed.
+		# 
+		define_accessor :seed do
+			@seed = nil
+			lambda{ |opts| opts << '-s' << seed.to_int.to_s if seed }
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   generator
+		#   generator=name
+		# 
+		# Handles Options#generator.
+		# 
+		# Currently it does nothing because only RDoc is supported as generator.
+		# 
+		define_accessor :generator do
+			@generator = nil
+			lambda do |opts|
+		#		opts << '-g' << generator if generator
+			end
+		end
+		def generator= generator # :nodoc:
+			# We should require the patch for that generator even if RDX won't run,
+			# to remove its directives, etc...
+			require "rdx/generator/#{generator}"
+			@generator = generator
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   generator_options
+		#   generator_options=array
+		# 
+		# Handles Options#generator_options.
+		# 
+		define_accessor :generator_options do
+			@generator_options = []
+			lambda do |opts|
+				opts << '-G' << generator_options.shift until generator_options.empty? if generator_options
+			end
+		end
+		
+		# Import options and files from the Rake::RDocTask given.
+		def rdoc_task= rdoc_task
+			require 'rdoc/task'
+			raise "Rake::RDocTask expected" unless rdoc_task.is_a?(RDoc::Task)
+			self.generator = 'rdoc'
+			generator_options.concat rdoc_task.option_list
+			files.add rdoc_task.rdoc_files
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   bash
+		#   bash=command
+		# 
+		# Handles Options#bash.
+		# 
+		define_accessor :bash do
+			@bash = nil
+			lambda do |opts|
+				opts << '--bash' << bash if bash
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   reporter
+		#   reporter=name
+		# 
+		# Handles Options#reporter.
+		# 
+		define_accessor :reporter do
+			@reporter = nil
+			lambda do |opts|
+				opts << '-R' << reporter if reporter
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   full_trace
+		#   full_trace=val
+		# 
+		# Show all reportables (including +Success+) in the report.
+		# 
+		define_accessor :full_trace do
+			@full_trace = false
+			lambda do |opts|
+				opts << '-t' if full_trace
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   show
+		#   show=array
+		# 
+		# Shows only the listed types of reportables in the report.
+		#
+		define_accessor :show do
+			@show = []
+			lambda do |opts|
+				opts << '--show' << show.shift.to_s until show.empty? if show
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   show
+		#   show=array
+		# 
+		# Hides the listed types of reportables in the report.
+		#
+		define_accessor :hide do
+			@hide = []
+			lambda do |opts|
+				opts << '--hide' << hide.shift.to_s until hide.empty? if hide
+			end
+		end
+		
+		##
+		# :method:
+		# :call-seq:
+		#   full_trace
+		#   full_trace=val
+		# 
+		# Don't show the warnings in the report if set to +false+.
+		# 
+		define_accessor :warnings do
+			@warnings = true
+			lambda do |opts|
+				opts << '--no-warnings' unless warnings
+			end
+		end
+		
+		#
+		# Defines a new RDX rake task with the given _name_.
+		# This instance is yielded to the given block;
+		# its methods allow to build the list of command line options.
+		#
+		def initialize name=:rdx
+			@name = name
+			@description = 'Generate documentation, extract examples and run them as tests'
+			@files = Rake::FileList.new
+			Task.apply_defaults_to self
+			yield self if block_given?
+			define
+		end
+		
+	# :stopdoc:
+		
+		def finalize_with finalize_procs
+			@finalize_procs = finalize_procs
+		end
+		
+	private
+		
+		def option_list
+			options = extra_options.dup
+			@finalize_procs.each{ |proc| proc.call(options) }
+			options
+		end
+		
+		def define
+			desc description
+			task name do
+				rdx = ARGV.shift
+				argv = option_list + ['--'] + files.to_a
+				$stderr.puts "#{rdx} #{argv.join ' '}" if Rake.application.options.trace
+				RDX.run(argv)
+			end
+		end
+		
+	end
+	
+end