jnunemaker-matchy-0.4.0/0000755000175200017520000000000012046776553014732 5ustar nandajanandajajnunemaker-matchy-0.4.0/countloc.rb0000644000175200017520000000232212046776553017104 0ustar nandajanandaja# This is here because OptionsParser is SO slow. def extract_path(argv) if argv[1].nil? if argv[0] =~ /-a/ return "/**/*.rb" elsif argv[0] if argv[0] =~ /\.rb$/ return argv[0] end return argv[0] + "/**/*.rb" else return "/**/*.rb" end elsif argv[1] =~ /\.rb$/ return argv[1] else return argv[1] + "/**/*.rb" end end def all? ARGV.join =~ /-a/ end def comment?(line) line =~ /^\s*#/ end def blank?(line) line =~ /^\s*$/ end def puke(header, locs, comments, blanks) puts header + ":" puts "#{locs} loc" puts "#{comments} lines of comments" puts "#{blanks} blank lines" end dir = File.dirname(__FILE__) full_path = File.join(dir,extract_path(ARGV)) gloc = gcmts = gblanks = 0 Dir[File.expand_path("#{full_path}")].uniq.each do |file| if file =~ /.*\.rb$/ loc = cmts = blanks = 0 File.open(file, "r") do |f| while f.gets if comment?($_) cmts += 1 elsif blank?($_) blanks += 1 else loc += 1 end end end gcmts += cmts gloc += loc gblanks += blanks puke(file, loc, cmts, blanks) if all? end end puke("Total", gloc, gcmts, gblanks) jnunemaker-matchy-0.4.0/setup.rb0000644000175200017520000010650212046776553016423 0ustar nandajanandaja# # setup.rb # # Copyright (c) 2000-2005 Minero Aoki # # This program is free software. # You can distribute/modify this program under the terms of # the GNU LGPL, Lesser General Public License version 2.1. # unless Enumerable.method_defined?(:map) # Ruby 1.4.6 module Enumerable alias map collect end end unless File.respond_to?(:read) # Ruby 1.6 def File.read(fname) open(fname) {|f| return f.read } end end unless Errno.const_defined?(:ENOTEMPTY) # Windows? module Errno class ENOTEMPTY # We do not raise this exception, implementation is not needed. end end end def File.binread(fname) open(fname, 'rb') {|f| return f.read } end # for corrupted Windows' stat(2) def File.dir?(path) File.directory?((path[-1,1] == '/') ? path : path + '/') end class ConfigTable include Enumerable def initialize(rbconfig) @rbconfig = rbconfig @items = [] @table = {} # options @install_prefix = nil @config_opt = nil @verbose = true @no_harm = false end attr_accessor :install_prefix attr_accessor :config_opt attr_writer :verbose def verbose? @verbose end attr_writer :no_harm def no_harm? @no_harm end def [](key) lookup(key).resolve(self) end def []=(key, val) lookup(key).set val end def names @items.map {|i| i.name } end def each(&block) @items.each(&block) end def key?(name) @table.key?(name) end def lookup(name) @table[name] or setup_rb_error "no such config item: #{name}" end def add(item) @items.push item @table[item.name] = item end def remove(name) item = lookup(name) @items.delete_if {|i| i.name == name } @table.delete_if {|name, i| i.name == name } item end def load_script(path, inst = nil) if File.file?(path) MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path end end def savefile '.config' end def load_savefile begin File.foreach(savefile()) do |line| k, v = *line.split(/=/, 2) self[k] = v.strip end rescue Errno::ENOENT setup_rb_error $!.message + "\n#{File.basename($0)} config first" end end def save @items.each {|i| i.value } File.open(savefile(), 'w') {|f| @items.each do |i| f.printf "%s=%s\n", i.name, i.value if i.value? and i.value end } end def load_standard_entries standard_entries(@rbconfig).each do |ent| add ent end end def standard_entries(rbconfig) c = rbconfig rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT']) major = c['MAJOR'].to_i minor = c['MINOR'].to_i teeny = c['TEENY'].to_i version = "#{major}.#{minor}" # ruby ver. >= 1.4.4? newpath_p = ((major >= 2) or ((major == 1) and ((minor >= 5) or ((minor == 4) and (teeny >= 4))))) if c['rubylibdir'] # V > 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = c['rubylibdir'] librubyverarch = c['archdir'] siteruby = c['sitedir'] siterubyver = c['sitelibdir'] siterubyverarch = c['sitearchdir'] elsif newpath_p # 1.4.4 <= V <= 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = c['sitedir'] siterubyver = "$siteruby/#{version}" siterubyverarch = "$siterubyver/#{c['arch']}" else # V < 1.4.4 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby" siterubyver = siteruby siterubyverarch = "$siterubyver/#{c['arch']}" end parameterize = lambda {|path| path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix') } if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } makeprog = arg.sub(/'/, '').split(/=/, 2)[1] else makeprog = 'make' end [ ExecItem.new('installdirs', 'std/site/home', 'std: install under libruby; site: install under site_ruby; home: install under $HOME')\ {|val, table| case val when 'std' table['rbdir'] = '$librubyver' table['sodir'] = '$librubyverarch' when 'site' table['rbdir'] = '$siterubyver' table['sodir'] = '$siterubyverarch' when 'home' setup_rb_error '$HOME was not set' unless ENV['HOME'] table['prefix'] = ENV['HOME'] table['rbdir'] = '$libdir/ruby' table['sodir'] = '$libdir/ruby' end }, PathItem.new('prefix', 'path', c['prefix'], 'path prefix of target environment'), PathItem.new('bindir', 'path', parameterize.call(c['bindir']), 'the directory for commands'), PathItem.new('libdir', 'path', parameterize.call(c['libdir']), 'the directory for libraries'), PathItem.new('datadir', 'path', parameterize.call(c['datadir']), 'the directory for shared data'), PathItem.new('mandir', 'path', parameterize.call(c['mandir']), 'the directory for man pages'), PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']), 'the directory for system configuration files'), PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']), 'the directory for local state data'), PathItem.new('libruby', 'path', libruby, 'the directory for ruby libraries'), PathItem.new('librubyver', 'path', librubyver, 'the directory for standard ruby libraries'), PathItem.new('librubyverarch', 'path', librubyverarch, 'the directory for standard ruby extensions'), PathItem.new('siteruby', 'path', siteruby, 'the directory for version-independent aux ruby libraries'), PathItem.new('siterubyver', 'path', siterubyver, 'the directory for aux ruby libraries'), PathItem.new('siterubyverarch', 'path', siterubyverarch, 'the directory for aux ruby binaries'), PathItem.new('rbdir', 'path', '$siterubyver', 'the directory for ruby scripts'), PathItem.new('sodir', 'path', '$siterubyverarch', 'the directory for ruby extentions'), PathItem.new('rubypath', 'path', rubypath, 'the path to set to #! line'), ProgramItem.new('rubyprog', 'name', rubypath, 'the ruby program using for installation'), ProgramItem.new('makeprog', 'name', makeprog, 'the make program to compile ruby extentions'), SelectItem.new('shebang', 'all/ruby/never', 'ruby', 'shebang line (#!) editing mode'), BoolItem.new('without-ext', 'yes/no', 'no', 'does not compile/install ruby extentions') ] end private :standard_entries def load_multipackage_entries multipackage_entries().each do |ent| add ent end end def multipackage_entries [ PackageSelectionItem.new('with', 'name,name...', '', 'ALL', 'package names that you want to install'), PackageSelectionItem.new('without', 'name,name...', '', 'NONE', 'package names that you do not want to install') ] end private :multipackage_entries ALIASES = { 'std-ruby' => 'librubyver', 'stdruby' => 'librubyver', 'rubylibdir' => 'librubyver', 'archdir' => 'librubyverarch', 'site-ruby-common' => 'siteruby', # For backward compatibility 'site-ruby' => 'siterubyver', # For backward compatibility 'bin-dir' => 'bindir', 'bin-dir' => 'bindir', 'rb-dir' => 'rbdir', 'so-dir' => 'sodir', 'data-dir' => 'datadir', 'ruby-path' => 'rubypath', 'ruby-prog' => 'rubyprog', 'ruby' => 'rubyprog', 'make-prog' => 'makeprog', 'make' => 'makeprog' } def fixup ALIASES.each do |ali, name| @table[ali] = @table[name] end @items.freeze @table.freeze @options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/ end def parse_opt(opt) m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}" m.to_a[1,2] end def dllext @rbconfig['DLEXT'] end def value_config?(name) lookup(name).value? end class Item def initialize(name, template, default, desc) @name = name.freeze @template = template @value = default @default = default @description = desc end attr_reader :name attr_reader :description attr_accessor :default alias help_default default def help_opt "--#{@name}=#{@template}" end def value? true end def value @value end def resolve(table) @value.gsub(%r<\$([^/]+)>) { table[$1] } end def set(val) @value = check(val) end private def check(val) setup_rb_error "config: --#{name} requires argument" unless val val end end class BoolItem < Item def config_type 'bool' end def help_opt "--#{@name}" end private def check(val) return 'yes' unless val case val when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes' when /\An(o)?\z/i, /\Af(alse)\z/i then 'no' else setup_rb_error "config: --#{@name} accepts only yes/no for argument" end end end class PathItem < Item def config_type 'path' end private def check(path) setup_rb_error "config: --#{@name} requires argument" unless path path[0,1] == '$' ? path : File.expand_path(path) end end class ProgramItem < Item def config_type 'program' end end class SelectItem < Item def initialize(name, selection, default, desc) super @ok = selection.split('/') end def config_type 'select' end private def check(val) unless @ok.include?(val.strip) setup_rb_error "config: use --#{@name}=#{@template} (#{val})" end val.strip end end class ExecItem < Item def initialize(name, selection, desc, &block) super name, selection, nil, desc @ok = selection.split('/') @action = block end def config_type 'exec' end def value? false end def resolve(table) setup_rb_error "$#{name()} wrongly used as option value" end undef set def evaluate(val, table) v = val.strip.downcase unless @ok.include?(v) setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})" end @action.call v, table end end class PackageSelectionItem < Item def initialize(name, template, default, help_default, desc) super name, template, default, desc @help_default = help_default end attr_reader :help_default def config_type 'package' end private def check(val) unless File.dir?("packages/#{val}") setup_rb_error "config: no such package: #{val}" end val end end class MetaConfigEnvironment def initialize(config, installer) @config = config @installer = installer end def config_names @config.names end def config?(name) @config.key?(name) end def bool_config?(name) @config.lookup(name).config_type == 'bool' end def path_config?(name) @config.lookup(name).config_type == 'path' end def value_config?(name) @config.lookup(name).config_type != 'exec' end def add_config(item) @config.add item end def add_bool_config(name, default, desc) @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc) end def add_path_config(name, default, desc) @config.add PathItem.new(name, 'path', default, desc) end def set_config_default(name, default) @config.lookup(name).default = default end def remove_config(name) @config.remove(name) end # For only multipackage def packages raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer @installer.packages end # For only multipackage def declare_packages(list) raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer @installer.packages = list end end end # class ConfigTable # This module requires: #verbose?, #no_harm? module FileOperations def mkdir_p(dirname, prefix = nil) dirname = prefix + File.expand_path(dirname) if prefix $stderr.puts "mkdir -p #{dirname}" if verbose? return if no_harm? # Does not check '/', it's too abnormal. dirs = File.expand_path(dirname).split(%r<(?=/)>) if /\A[a-z]:\z/i =~ dirs[0] disk = dirs.shift dirs[0] = disk + dirs[0] end dirs.each_index do |idx| path = dirs[0..idx].join('') Dir.mkdir path unless File.dir?(path) end end def rm_f(path) $stderr.puts "rm -f #{path}" if verbose? return if no_harm? force_remove_file path end def rm_rf(path) $stderr.puts "rm -rf #{path}" if verbose? return if no_harm? remove_tree path end def remove_tree(path) if File.symlink?(path) remove_file path elsif File.dir?(path) remove_tree0 path else force_remove_file path end end def remove_tree0(path) Dir.foreach(path) do |ent| next if ent == '.' next if ent == '..' entpath = "#{path}/#{ent}" if File.symlink?(entpath) remove_file entpath elsif File.dir?(entpath) remove_tree0 entpath else force_remove_file entpath end end begin Dir.rmdir path rescue Errno::ENOTEMPTY # directory may not be empty end end def move_file(src, dest) force_remove_file dest begin File.rename src, dest rescue File.open(dest, 'wb') {|f| f.write File.binread(src) } File.chmod File.stat(src).mode, dest File.unlink src end end def force_remove_file(path) begin remove_file path rescue end end def remove_file(path) File.chmod 0777, path File.unlink path end def install(from, dest, mode, prefix = nil) $stderr.puts "install #{from} #{dest}" if verbose? return if no_harm? realdest = prefix ? prefix + File.expand_path(dest) : dest realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) str = File.binread(from) if diff?(str, realdest) verbose_off { rm_f realdest if File.exist?(realdest) } File.open(realdest, 'wb') {|f| f.write str } File.chmod mode, realdest File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| if prefix f.puts realdest.sub(prefix, '') else f.puts realdest end } end end def diff?(new_content, path) return true unless File.exist?(path) new_content != File.binread(path) end def command(*args) $stderr.puts args.join(' ') if verbose? system(*args) or raise RuntimeError, "system(#{args.map{|a| a.inspect }.join(' ')}) failed" end def ruby(*args) command config('rubyprog'), *args end def make(task = nil) command(*[config('makeprog'), task].compact) end def extdir?(dir) File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb") end def files_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.file?("#{dir}/#{ent}") } } end DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn ) def directories_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT } end end # This module requires: #srcdir_root, #objdir_root, #relpath module HookScriptAPI def get_config(key) @config[key] end alias config get_config # obsolete: use metaconfig to change configuration def set_config(key, val) @config[key] = val end # # srcdir/objdir (works only in the package directory) # def curr_srcdir "#{srcdir_root()}/#{relpath()}" end def curr_objdir "#{objdir_root()}/#{relpath()}" end def srcfile(path) "#{curr_srcdir()}/#{path}" end def srcexist?(path) File.exist?(srcfile(path)) end def srcdirectory?(path) File.dir?(srcfile(path)) end def srcfile?(path) File.file?(srcfile(path)) end def srcentries(path = '.') Dir.open("#{curr_srcdir()}/#{path}") {|d| return d.to_a - %w(. ..) } end def srcfiles(path = '.') srcentries(path).select {|fname| File.file?(File.join(curr_srcdir(), path, fname)) } end def srcdirectories(path = '.') srcentries(path).select {|fname| File.dir?(File.join(curr_srcdir(), path, fname)) } end end class ToplevelInstaller Version = '3.4.1' Copyright = 'Copyright (c) 2000-2005 Minero Aoki' TASKS = [ [ 'all', 'do config, setup, then install' ], [ 'config', 'saves your configurations' ], [ 'show', 'shows current configuration' ], [ 'setup', 'compiles ruby extentions and others' ], [ 'install', 'installs files' ], [ 'test', 'run all tests in test/' ], [ 'clean', "does `make clean' for each extention" ], [ 'distclean',"does `make distclean' for each extention" ] ] def ToplevelInstaller.invoke config = ConfigTable.new(load_rbconfig()) config.load_standard_entries config.load_multipackage_entries if multipackage? config.fixup klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller) klass.new(File.dirname($0), config).invoke end def ToplevelInstaller.multipackage? File.dir?(File.dirname($0) + '/packages') end def ToplevelInstaller.load_rbconfig if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } ARGV.delete(arg) load File.expand_path(arg.split(/=/, 2)[1]) $".push 'rbconfig.rb' else require 'rbconfig' end ::Config::CONFIG end def initialize(ardir_root, config) @ardir = File.expand_path(ardir_root) @config = config # cache @valid_task_re = nil end def config(key) @config[key] end def inspect "#<#{self.class} #{__id__()}>" end def invoke run_metaconfigs case task = parsearg_global() when nil, 'all' parsearg_config init_installers exec_config exec_setup exec_install else case task when 'config', 'test' ; when 'clean', 'distclean' @config.load_savefile if File.exist?(@config.savefile) else @config.load_savefile end __send__ "parsearg_#{task}" init_installers __send__ "exec_#{task}" end end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig" end def init_installers @installer = Installer.new(@config, @ardir, File.expand_path('.')) end # # Hook Script API bases # def srcdir_root @ardir end def objdir_root '.' end def relpath '.' end # # Option Parsing # def parsearg_global while arg = ARGV.shift case arg when /\A\w+\z/ setup_rb_error "invalid task: #{arg}" unless valid_task?(arg) return arg when '-q', '--quiet' @config.verbose = false when '--verbose' @config.verbose = true when '--help' print_usage $stdout exit 0 when '--version' puts "#{File.basename($0)} version #{Version}" exit 0 when '--copyright' puts Copyright exit 0 else setup_rb_error "unknown global option '#{arg}'" end end nil end def valid_task?(t) valid_task_re() =~ t end def valid_task_re @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/ end def parsearg_no_options unless ARGV.empty? task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1) setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}" end end alias parsearg_show parsearg_no_options alias parsearg_setup parsearg_no_options alias parsearg_test parsearg_no_options alias parsearg_clean parsearg_no_options alias parsearg_distclean parsearg_no_options def parsearg_config evalopt = [] set = [] @config.config_opt = [] while i = ARGV.shift if /\A--?\z/ =~ i @config.config_opt = ARGV.dup break end name, value = *@config.parse_opt(i) if @config.value_config?(name) @config[name] = value else evalopt.push [name, value] end set.push name end evalopt.each do |name, value| @config.lookup(name).evaluate value, @config end # Check if configuration is valid set.each do |n| @config[n] if @config.value_config?(n) end end def parsearg_install @config.no_harm = false @config.install_prefix = '' while a = ARGV.shift case a when '--no-harm' @config.no_harm = true when /\A--prefix=/ path = a.split(/=/, 2)[1] path = File.expand_path(path) unless path[0,1] == '/' @config.install_prefix = path else setup_rb_error "install: unknown option #{a}" end end end def print_usage(out) out.puts 'Typical Installation Procedure:' out.puts " $ ruby #{File.basename $0} config" out.puts " $ ruby #{File.basename $0} setup" out.puts " # ruby #{File.basename $0} install (may require root privilege)" out.puts out.puts 'Detailed Usage:' out.puts " ruby #{File.basename $0} " out.puts " ruby #{File.basename $0} [] []" fmt = " %-24s %s\n" out.puts out.puts 'Global options:' out.printf fmt, '-q,--quiet', 'suppress message outputs' out.printf fmt, ' --verbose', 'output messages verbosely' out.printf fmt, ' --help', 'print this message' out.printf fmt, ' --version', 'print version and quit' out.printf fmt, ' --copyright', 'print copyright and quit' out.puts out.puts 'Tasks:' TASKS.each do |name, desc| out.printf fmt, name, desc end fmt = " %-24s %s [%s]\n" out.puts out.puts 'Options for CONFIG or ALL:' @config.each do |item| out.printf fmt, item.help_opt, item.description, item.help_default end out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's" out.puts out.puts 'Options for INSTALL:' out.printf fmt, '--no-harm', 'only display what to do if given', 'off' out.printf fmt, '--prefix=path', 'install path prefix', '' out.puts end # # Task Handlers # def exec_config @installer.exec_config @config.save # must be final end def exec_setup @installer.exec_setup end def exec_install @installer.exec_install end def exec_test @installer.exec_test end def exec_show @config.each do |i| printf "%-20s %s\n", i.name, i.value if i.value? end end def exec_clean @installer.exec_clean end def exec_distclean @installer.exec_distclean end end # class ToplevelInstaller class ToplevelInstallerMulti < ToplevelInstaller include FileOperations def initialize(ardir_root, config) super @packages = directories_of("#{@ardir}/packages") raise 'no package exists' if @packages.empty? @root_installer = Installer.new(@config, @ardir, File.expand_path('.')) end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig", self @packages.each do |name| @config.load_script "#{@ardir}/packages/#{name}/metaconfig" end end attr_reader :packages def packages=(list) raise 'package list is empty' if list.empty? list.each do |name| raise "directory packages/#{name} does not exist"\ unless File.dir?("#{@ardir}/packages/#{name}") end @packages = list end def init_installers @installers = {} @packages.each do |pack| @installers[pack] = Installer.new(@config, "#{@ardir}/packages/#{pack}", "packages/#{pack}") end with = extract_selection(config('with')) without = extract_selection(config('without')) @selected = @installers.keys.select {|name| (with.empty? or with.include?(name)) \ and not without.include?(name) } end def extract_selection(list) a = list.split(/,/) a.each do |name| setup_rb_error "no such package: #{name}" unless @installers.key?(name) end a end def print_usage(f) super f.puts 'Inluded packages:' f.puts ' ' + @packages.sort.join(' ') f.puts end # # Task Handlers # def exec_config run_hook 'pre-config' each_selected_installers {|inst| inst.exec_config } run_hook 'post-config' @config.save # must be final end def exec_setup run_hook 'pre-setup' each_selected_installers {|inst| inst.exec_setup } run_hook 'post-setup' end def exec_install run_hook 'pre-install' each_selected_installers {|inst| inst.exec_install } run_hook 'post-install' end def exec_test run_hook 'pre-test' each_selected_installers {|inst| inst.exec_test } run_hook 'post-test' end def exec_clean rm_f @config.savefile run_hook 'pre-clean' each_selected_installers {|inst| inst.exec_clean } run_hook 'post-clean' end def exec_distclean rm_f @config.savefile run_hook 'pre-distclean' each_selected_installers {|inst| inst.exec_distclean } run_hook 'post-distclean' end # # lib # def each_selected_installers Dir.mkdir 'packages' unless File.dir?('packages') @selected.each do |pack| $stderr.puts "Processing the package `#{pack}' ..." if verbose? Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") Dir.chdir "packages/#{pack}" yield @installers[pack] Dir.chdir '../..' end end def run_hook(id) @root_installer.run_hook id end # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end end # class ToplevelInstallerMulti class Installer FILETYPES = %w( bin lib ext data conf man ) include FileOperations include HookScriptAPI def initialize(config, srcroot, objroot) @config = config @srcdir = File.expand_path(srcroot) @objdir = File.expand_path(objroot) @currdir = '.' end def inspect "#<#{self.class} #{File.basename(@srcdir)}>" end def noop(rel) end # # Hook Script API base methods # def srcdir_root @srcdir end def objdir_root @objdir end def relpath @currdir end # # Config Access # # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end def verbose_off begin save, @config.verbose = @config.verbose?, false yield ensure @config.verbose = save end end # # TASK config # def exec_config exec_task_traverse 'config' end alias config_dir_bin noop alias config_dir_lib noop def config_dir_ext(rel) extconf if extdir?(curr_srcdir()) end alias config_dir_data noop alias config_dir_conf noop alias config_dir_man noop def extconf ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt end # # TASK setup # def exec_setup exec_task_traverse 'setup' end def setup_dir_bin(rel) files_of(curr_srcdir()).each do |fname| update_shebang_line "#{curr_srcdir()}/#{fname}" end end alias setup_dir_lib noop def setup_dir_ext(rel) make if extdir?(curr_srcdir()) end alias setup_dir_data noop alias setup_dir_conf noop alias setup_dir_man noop def update_shebang_line(path) return if no_harm? return if config('shebang') == 'never' old = Shebang.load(path) if old $stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1 new = new_shebang(old) return if new.to_s == old.to_s else return unless config('shebang') == 'all' new = Shebang.new(config('rubypath')) end $stderr.puts "updating shebang: #{File.basename(path)}" if verbose? open_atomic_writer(path) {|output| File.open(path, 'rb') {|f| f.gets if old # discard output.puts new.to_s output.print f.read } } end def new_shebang(old) if /\Aruby/ =~ File.basename(old.cmd) Shebang.new(config('rubypath'), old.args) elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby' Shebang.new(config('rubypath'), old.args[1..-1]) else return old unless config('shebang') == 'all' Shebang.new(config('rubypath')) end end def open_atomic_writer(path, &block) tmpfile = File.basename(path) + '.tmp' begin File.open(tmpfile, 'wb', &block) File.rename tmpfile, File.basename(path) ensure File.unlink tmpfile if File.exist?(tmpfile) end end class Shebang def Shebang.load(path) line = nil File.open(path) {|f| line = f.gets } return nil unless /\A#!/ =~ line parse(line) end def Shebang.parse(line) cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ') new(cmd, args) end def initialize(cmd, args = []) @cmd = cmd @args = args end attr_reader :cmd attr_reader :args def to_s "#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}") end end # # TASK install # def exec_install rm_f 'InstalledFiles' exec_task_traverse 'install' end def install_dir_bin(rel) install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755 end def install_dir_lib(rel) install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644 end def install_dir_ext(rel) return unless extdir?(curr_srcdir()) install_files rubyextentions('.'), "#{config('sodir')}/#{File.dirname(rel)}", 0555 end def install_dir_data(rel) install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644 end def install_dir_conf(rel) # FIXME: should not remove current config files # (rename previous file to .old/.org) install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644 end def install_dir_man(rel) install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644 end def install_files(list, dest, mode) mkdir_p dest, @config.install_prefix list.each do |fname| install fname, dest, mode, @config.install_prefix end end def libfiles glob_reject(%w(*.y *.output), targetfiles()) end def rubyextentions(dir) ents = glob_select("*.#{@config.dllext}", targetfiles()) if ents.empty? setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first" end ents end def targetfiles mapdir(existfiles() - hookfiles()) end def mapdir(ents) ents.map {|ent| if File.exist?(ent) then ent # objdir else "#{curr_srcdir()}/#{ent}" # srcdir end } end # picked up many entries from cvs-1.11.1/src/ignore.c JUNK_FILES = %w( core RCSLOG tags TAGS .make.state .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$ *.org *.in .* ) def existfiles glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.'))) end def hookfiles %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| %w( config setup install clean ).map {|t| sprintf(fmt, t) } }.flatten end def glob_select(pat, ents) re = globs2re([pat]) ents.select {|ent| re =~ ent } end def glob_reject(pats, ents) re = globs2re(pats) ents.reject {|ent| re =~ ent } end GLOB2REGEX = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*' } def globs2re(pats) /\A(?:#{ pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|') })\z/ end # # TASK test # TESTDIR = 'test' def exec_test unless File.directory?('test') $stderr.puts 'no test in this package' if verbose? return end $stderr.puts 'Running tests...' if verbose? begin require 'test/unit' rescue LoadError setup_rb_error 'test/unit cannot loaded. You need Ruby 1.8 or later to invoke this task.' end runner = Test::Unit::AutoRunner.new(true) runner.to_run << TESTDIR runner.run end # # TASK clean # def exec_clean exec_task_traverse 'clean' rm_f @config.savefile rm_f 'InstalledFiles' end alias clean_dir_bin noop alias clean_dir_lib noop alias clean_dir_data noop alias clean_dir_conf noop alias clean_dir_man noop def clean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'clean' if File.file?('Makefile') end # # TASK distclean # def exec_distclean exec_task_traverse 'distclean' rm_f @config.savefile rm_f 'InstalledFiles' end alias distclean_dir_bin noop alias distclean_dir_lib noop def distclean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'distclean' if File.file?('Makefile') end alias distclean_dir_data noop alias distclean_dir_conf noop alias distclean_dir_man noop # # Traversing # def exec_task_traverse(task) run_hook "pre-#{task}" FILETYPES.each do |type| if type == 'ext' and config('without-ext') == 'yes' $stderr.puts 'skipping ext/* by user option' if verbose? next end traverse task, type, "#{task}_dir_#{type}" end run_hook "post-#{task}" end def traverse(task, rel, mid) dive_into(rel) { run_hook "pre-#{task}" __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') directories_of(curr_srcdir()).each do |d| traverse task, "#{rel}/#{d}", mid end run_hook "post-#{task}" } end def dive_into(rel) return unless File.dir?("#{@srcdir}/#{rel}") dir = File.basename(rel) Dir.mkdir dir unless File.dir?(dir) prevdir = Dir.pwd Dir.chdir dir $stderr.puts '---> ' + rel if verbose? @currdir = rel yield Dir.chdir prevdir $stderr.puts '<--- ' + rel if verbose? @currdir = File.dirname(rel) end def run_hook(id) path = [ "#{curr_srcdir()}/#{id}", "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) } return unless path begin instance_eval File.read(path), path, 1 rescue raise if $DEBUG setup_rb_error "hook #{path} failed:\n" + $!.message end end end # class Installer class SetupError < StandardError; end def setup_rb_error(msg) raise SetupError, msg end if $0 == __FILE__ begin ToplevelInstaller.invoke rescue SetupError raise if $DEBUG $stderr.puts $!.message $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." exit 1 end end jnunemaker-matchy-0.4.0/License.txt0000644000175200017520000000204212046776553017053 0ustar nandajanandajaCopyright (c) 2008 Jeremy McAnally Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.jnunemaker-matchy-0.4.0/PostInstall.txt0000644000175200017520000000024312046776553017746 0ustar nandajanandaja For more information on matchy, see http://matchy.rubyforge.org NOTE: Change this information in PostInstall.txt You can also delete it if you don't want it. jnunemaker-matchy-0.4.0/matchy.gemspec0000644000175200017520000000432012046776553017563 0ustar nandajanandajaGem::Specification.new do |s| s.name = %q{jnunemaker-matchy} s.version = "0.4.0" s.authors = ["Jeremy McAnally"] s.date = %q{2009-03-23} s.description = %q{RSpec-esque matchers for use in Test::Unit} s.email = ["jeremy@entp.com"] s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"] s.files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "config/hoe.rb", "config/requirements.rb", "countloc.rb", "lib/matchy.rb", "lib/matchy/built_in/change_expectations.rb", "lib/matchy/built_in/enumerable_expectations.rb", "lib/matchy/built_in/error_expectations.rb", "lib/matchy/built_in/operator_expectations.rb", "lib/matchy/built_in/truth_expectations.rb", "lib/matchy/custom_matcher.rb", "lib/matchy/expectation_builder.rb", "lib/matchy/matcher_builder.rb", "lib/matchy/modals.rb", "lib/matchy/version.rb", "matchy.gemspec", "setup.rb", "tasks/deployment.rake", "tasks/environment.rake", "test/all.rb", "test/ruby1.9.compatibility_tests.rb", "test/test_change_expectation.rb", "test/test_custom_matcher.rb", "test/test_enumerable_expectations.rb", "test/test_error_expectations.rb", "test/test_expectation_builder.rb", "test/test_helper.rb", "test/test_matcher_builder.rb", "test/test_modals.rb", "test/test_operator_expectations.rb", "test/test_truth_expectations.rb"] s.has_rdoc = true s.homepage = %q{http://matchy.rubyforge.org} s.post_install_message = %q{ For more information on matchy, see http://matchy.rubyforge.org NOTE: Change this information in PostInstall.txt You can also delete it if you don't want it. } s.rdoc_options = ["--main", "README.rdoc"] s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"] s.require_paths = ["lib"] s.rubyforge_project = %q{matchy} s.rubygems_version = %q{1.3.1} s.summary = %q{RSpec-esque matchers for use in Test::Unit} s.test_files = ["test/test_change_expectation.rb", "test/test_custom_matcher.rb", "test/test_enumerable_expectations.rb", "test/test_error_expectations.rb", "test/test_expectation_builder.rb", "test/test_helper.rb", "test/test_matcher_builder.rb", "test/test_modals.rb", "test/test_operator_expectations.rb", "test/test_truth_expectations.rb"] endjnunemaker-matchy-0.4.0/Rakefile0000644000175200017520000000021312046776553016373 0ustar nandajanandajarequire 'config/requirements' require 'config/hoe' # setup Hoe + all gem configuration Dir['tasks/**/*.rake'].each { |rake| load rake }jnunemaker-matchy-0.4.0/metadata.yml0000644000175200017520000000476312046776553017247 0ustar nandajanandaja--- !ruby/object:Gem::Specification name: jnunemaker-matchy version: !ruby/object:Gem::Version version: 0.4.0 platform: ruby authors: - Jeremy McAnally autorequire: bindir: bin cert_chain: [] date: 2009-03-23 00:00:00 -04:00 default_executable: dependencies: [] description: RSpec-esque matchers for use in Test::Unit email: - jeremy@entp.com executables: [] extensions: [] extra_rdoc_files: - History.txt - Manifest.txt - README.rdoc files: - History.txt - License.txt - Manifest.txt - PostInstall.txt - README.rdoc - Rakefile - config/hoe.rb - config/requirements.rb - countloc.rb - lib/matchy.rb - lib/matchy/built_in/change_expectations.rb - lib/matchy/built_in/enumerable_expectations.rb - lib/matchy/built_in/error_expectations.rb - lib/matchy/built_in/operator_expectations.rb - lib/matchy/built_in/truth_expectations.rb - lib/matchy/custom_matcher.rb - lib/matchy/expectation_builder.rb - lib/matchy/matcher_builder.rb - lib/matchy/modals.rb - lib/matchy/version.rb - matchy.gemspec - setup.rb - tasks/deployment.rake - tasks/environment.rake - test/all.rb - test/ruby1.9.compatibility_tests.rb - test/test_change_expectation.rb - test/test_custom_matcher.rb - test/test_enumerable_expectations.rb - test/test_error_expectations.rb - test/test_expectation_builder.rb - test/test_helper.rb - test/test_matcher_builder.rb - test/test_modals.rb - test/test_operator_expectations.rb - test/test_truth_expectations.rb has_rdoc: true homepage: http://matchy.rubyforge.org licenses: [] post_install_message: |+ For more information on matchy, see http://matchy.rubyforge.org NOTE: Change this information in PostInstall.txt You can also delete it if you don't want it. rdoc_options: - --main - README.rdoc require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: "0" version: required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: "0" version: requirements: [] rubyforge_project: matchy rubygems_version: 1.3.5 signing_key: specification_version: 3 summary: RSpec-esque matchers for use in Test::Unit test_files: - test/test_change_expectation.rb - test/test_custom_matcher.rb - test/test_enumerable_expectations.rb - test/test_error_expectations.rb - test/test_expectation_builder.rb - test/test_helper.rb - test/test_matcher_builder.rb - test/test_modals.rb - test/test_operator_expectations.rb - test/test_truth_expectations.rb jnunemaker-matchy-0.4.0/test/0000755000175200017520000000000012046776553015711 5ustar nandajanandajajnunemaker-matchy-0.4.0/test/test_expectation_builder.rb0000644000175200017520000000133512046776553023330 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestExpectationBuilder < Test::Unit::TestCase def setup @obj = Object.new end def test_should exp = Matchy::ExpectationBuilder.build_expectation(true, nil, @obj) exp.send(:==, @obj) end def test_should_fails expect_1 = Matchy::ExpectationBuilder.build_expectation(true, nil, 1) lambda {expect_1.send(:==, 2)}.should raise_error end def test_should_not exp = Matchy::ExpectationBuilder.build_expectation(false, nil, @obj) exp.send(:==, 1) end def test_should_not_fails expect_not_1 = Matchy::ExpectationBuilder.build_expectation(false, nil, 1) lambda {expect_not_1.send(:==, 1)}.should raise_error end endjnunemaker-matchy-0.4.0/test/test_modals.rb0000644000175200017520000000145012046776553020554 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestModals < Test::Unit::TestCase def setup @expectation = build_matcher() {|r,m,a| true} @bad_expectation = build_matcher() {|r,m,a| false} end def test_should 3.should(@expectation) end def test_will 3.will(@expectation) end def test_should_not 3.should_not(@bad_expectation) end def test_will_not 3.will_not(@bad_expectation) end def test_wont 3.wont(@bad_expectation) end def test_should_operator_expectation_returned obj = 3.should assert_equal Matchy::Expectations::OperatorExpectation, obj.class end def test_should_not_operator_expectation_returned obj = 3.should_not assert_equal Matchy::Expectations::OperatorExpectation, obj.class end end jnunemaker-matchy-0.4.0/test/test_matcher_builder.rb0000644000175200017520000000462112046776553022431 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestMatcherBuilder < Test::Unit::TestCase include Matchy::MatcherBuilder def setup @obj = Object.new end def test_matcher_responds_to_matches block = lambda {|given, matcher, args| true} build_matcher(:m, &block).should respond_to(:matches?) end def test_fail_positive block = lambda {|given, matcher, args| false} lambda {@obj.should build_matcher(:m, &block)}.should raise_error end def test_pass_positive block = lambda {|given, matcher, args| true} @obj.should build_matcher(:m, &block) end def test_fail_negative block = lambda {|given, matcher, args| true} lambda {@obj.should_not build_matcher(:m, &block)}.should raise_error end def test_pass_negative block = lambda {|given, matcher, args| false} @obj.should_not build_matcher(:m, &block) end def test_takes_arguments block = lambda {|given, matcher, args| $args = args; true} @obj.should build_matcher(:m,[1,2,3], &block) $args.should eql([1,2,3]) end def test_received_method block = lambda {|given, matcher, args| $chained_messages = matcher.chained_messages; true} @obj.should build_matcher(:m, &block).method1 $chained_messages[0].name.should eql(:method1) end def test_received_method_takes_args block = lambda {|given, matcher, args| $chained_messages = matcher.chained_messages; true} @obj.should build_matcher(:m, &block).method1(1,2,3) $chained_messages[0].args.should eql([1,2,3]) end def test_received_method_takes_block block = lambda {|given, matcher, args| $chained_messages = matcher.chained_messages; true} @obj.should build_matcher(:m, &block).method1 { "Hello, World!"} $chained_messages[0].block.call.should eql("Hello, World!") end def test_received_method_chained block = lambda {|given, matcher, args| $chained_messages = matcher.chained_messages; true} @obj.should build_matcher(:m, &block).method1(1,2,3) { "Hello, World!"}. method2(4,5,6) { "Hello chained messages" } $chained_messages[0].name.should eql(:method1) $chained_messages[1].name.should eql(:method2) $chained_messages[0].args.should eql([1,2,3]) $chained_messages[1].args.should eql([4,5,6]) $chained_messages[0].block.call.should eql("Hello, World!") $chained_messages[1].block.call.should eql("Hello chained messages") end end jnunemaker-matchy-0.4.0/test/test_custom_matcher.rb0000644000175200017520000000565312046776553022323 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestCustomMatcher < Test::Unit::TestCase class Foo < Struct.new(:valid) def valid? valid == true end def items [1,2,3] end end custom_matcher :matcher_true do |receiver, matcher, args| true end custom_matcher :matcher_false do |receiver, matcher, args| false end def test_defines_method self.class.class_eval do custom_matcher :matcher_method do |receiver, matcher, args| true end end self.should respond_to(:matcher_method) end def test_pass_positive 1.should matcher_true end def test_fail_positive lambda { 1.should matcher_false }.should raise_error end def test_pass_negative 1.should_not matcher_false end def test_fail_negative lambda { 1.should_not matcher_true }.should raise_error end def test_arguments actual_args = [] self.class.class_eval do custom_matcher :matcher do |receiver, matcher, args| actual_args = args true end end 1.should matcher(1,2,3) actual_args.should == [1,2,3] end def test_receiver actual_receiver = nil self.class.class_eval do custom_matcher :matcher do |receiver, matcher, args| actual_receiver = receiver true end end receiver = 1 receiver.should matcher actual_receiver.should == receiver end def test_calling_receiver_method self.class.class_eval do custom_matcher :be_nil do |receiver, matcher, args| receiver.nil? end end nil.should be_nil lambda { nil.should_not be_nil }.should raise_error 'foo'.should_not be_nil lambda { 'foo'.should be_nil }.should raise_error end def test_matcher self.class.class_eval do custom_matcher :be_valid do |receiver, matcher, args| matcher.positive_failure_message = "Expected to be valid but wasn't" matcher.negative_failure_message = "Expected to not be valid but was" receiver.valid? end end foo = Foo.new foo.valid = false lambda { foo.should be_valid }.should raise_error("Expected to be valid but wasn't.") foo.valid = true lambda { foo.should_not be_valid }.should raise_error("Expected to not be valid but was.") end def test_matcher_with_chained_messages self.class.class_eval do custom_matcher :have do |receiver, matcher, args| count = args[0] something = matcher.chained_messages[0].name actual = receiver.send(something).size matcher.positive_failure_message = "Expected #{receiver} to have #{actual} #{something}, but found #{count} " actual == count end end foo = Foo.new foo.should have(3).items lambda { foo.should have(2).items }.should raise_error end end jnunemaker-matchy-0.4.0/test/test_change_expectation.rb0000644000175200017520000000245612046776553023134 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestChangeExpectations < Test::Unit::TestCase def test_change var = 1 lambda {var += 1}.should change {var} end def test_change_fails var = 1 lambda do lambda { }.should change {var} end.should raise_error end def test_change_by var = 1 lambda {var += 1}.should change {var}.by(1) end def test_change_by_fails var = 1 lambda do lambda {var += 2}.should change {var}.by(1) end.should raise_error end def test_change_by_at_least var = 1 lambda {var += 1}.should change {var}.by_at_least(1) end def test_change_by_at_least_fails var = 1 lambda do lambda {var += 0.9}.should change {var}.by_at_least(1) end.should raise_error end def test_change_by_at_most var = 1 lambda {var += 1}.should change {var}.by_at_most(1) end def test_change_by_at_most_fails var = 1 lambda do lambda {var += 1.1}.should change {var}.by_at_most(1) end.should raise_error end def test_change_from_to var = 1 lambda {var += 1}.should change {var}.from(1).to(2) end def test_change_from_to_fails var = 1 lambda do lambda {var += 1.1}.should change {var}.from(1).to(2) end.should raise_error end endjnunemaker-matchy-0.4.0/test/ruby1.9.compatibility_tests.rb0000644000175200017520000003044012046776553023542 0ustar nandajanandaja# Eval this file with ruby 1.9 require 'test/unit' require File.dirname(__FILE__) + '/../lib/matchy.rb' class TestAThing < Test::Unit::TestCase def setup @obj = Object.new end # == def test_operator_eql_eql 1.should == 1 end def test_operator_eql_eql_fails lambda {1.should == 2}.should raise_error end def test_operator_eql_eql_negative 1.should_not == 2 end def test_operator_eql_eql_negative_fails lambda {1.should_not == 1}.should raise_error end # === def test_operator_eql_eql_eql 1.should === 1 end def test_operator_eql_eql_eql_fails lambda {1.should === 2}.should raise_error end def test_operator_eql_eql_eql_negative 1.should_not === 2 end def test_operator_eql_eql_eql_negative_fails lambda {1.should_not === 1}.should raise_error end # =~ def test_operator_eql_match "string".should =~ /in/ end def test_operator_eql_match_fails lambda {"string".should =~ /an/}.should raise_error end def test_operator_eql_match_negative "string".should_not =~ /an/ end def test_operator_eql_match_negative_fails lambda {"string".should_not =~ /in/}.should raise_error end # <= def test_operator_lt_eql 1.should <= 2 end def test_operator_lt_eql_fails lambda {1.should <= 0}.should raise_error end def test_operator_lt_eql_negative 1.should_not <= 0 end def test_operator_lt_eql_negative_fails lambda {1.should_not <= 2}.should raise_error end # >= def test_operator_gt_eql 1.should >= 0 end def test_operator_gt_eql_fails lambda {1.should >= 2}.should raise_error end def test_operator_gt_eql_negative 1.should_not >= 2 end def test_operator_gt_eql_negative_fails lambda {1.should_not >= 0}.should raise_error end # < def test_operator_lt 1.should < 2 end def test_operator_lt_fails lambda {1.should < 0}.should raise_error end def test_operator_lt_negative 1.should_not < 0 end def test_operator_lt_negative_fails lambda {1.should_not < 2}.should raise_error end # > def test_operator_gt 1.should > 0 end def test_operator_gt_fails lambda {1.should > 2}.should raise_error end def test_operator_gt_negative 1.should_not > 2 end def test_operator_gt_negative_fails lambda {1.should_not > 0}.should raise_error end # be() def test_be 1.should be(1) end def test_be_fails lambda {1.should be(2)}.should raise_error end def test_be_negative 1.should_not be(2) end def test_be_negative_fails lambda {1.should_not be(1)}.should raise_error end # be_something def test_positive_be_something_method_missing_pass def @obj.something? true end @obj.should be_something end def test_positive_be_something_method_missing_fails def @obj.something? false end lambda {@obj.should be_something}.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_be_something_method_missing_pass def @obj.something? false end @obj.should_not be_something end def test_negative_be_something_method_missing_fails def @obj.something? true end lambda {@obj.should_not be_something}.should raise_error(Test::Unit::AssertionFailedError) end def test_be_something_method_missing_fail_message obj = "foo" def obj.something? true end matcher_obj = be_something obj.should matcher_obj matcher_obj.failure_message.should be("Expected \"foo\" to return true for something?, with 'no args'.") end def test_be_something_method_missing_negative_fail_message obj = "foo" def obj.something? false end matcher_obj = be_something obj.should_not matcher_obj matcher_obj.negative_failure_message.should =~ /Expected \"foo\" to not return true for something?/ end # be_something(arg) def test_positive_be_something_with_arg_method_missing_pass def @obj.something?(arg) true end @obj.should be_something(1) end def test_positive_be_something_with_arg_method_missing_fails def @obj.something?(arg) false end lambda {@obj.should be_something(1)}.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_be_something_method_missing_pass def @obj.something?(arg) false end @obj.should_not be_something(1) end def test_negative_be_something_method_missing_fails def @obj.something?(arg) true end lambda {@obj.should_not be_something(1)}.should raise_error(Test::Unit::AssertionFailedError) end def test_be_something_method_missing_fail_message obj = "foo" def obj.something?(arg) true end matcher_obj = be_something(1) obj.should matcher_obj matcher_obj.failure_message.should be("Expected \"foo\" to return true for something?, with '1'.") end def test_be_something_method_missing_negative_fail_message obj = "foo" def obj.something?(arg) false end matcher_obj = be_something(1) obj.should_not matcher_obj matcher_obj.negative_failure_message.should be("Expected \"foo\" to not return true for something?, with '1'.") end # change def test_change var = 1 lambda {var += 1}.should change {var} end def test_change_fails var = 1 lambda do lambda { }.should change {var} end.should raise_error end def test_change_by var = 1 lambda {var += 1}.should change {var}.by(1) end def test_change_by_fails var = 1 lambda do lambda {var += 2}.should change {var}.by(1) end.should raise_error end def test_change_by_at_least var = 1 lambda {var += 1}.should change {var}.by_at_least(1) end def test_change_by_at_least_fails var = 1 lambda do lambda {var += 0.9}.should change {var}.by_at_least(1) end.should raise_error end def test_change_by_at_most var = 1 lambda {var += 1}.should change {var}.by_at_most(1) end def test_change_by_at_most_fails var = 1 lambda do lambda {var += 1.1}.should change {var}.by_at_most(1) end.should raise_error end def test_change_from_to var = 1 lambda {var += 1}.should change {var}.from(1).to(2) end def test_change_from_to_fails var = 1 lambda do lambda {var += 1.1}.should change {var}.from(1).to(2) end.should raise_error end # include/exclude def test_include [1,2,3,4].should include(4) end def test_include_fail lambda { [1,2,3,4].should include(6) }.should raise_error(Test::Unit::AssertionFailedError) end def test_exclude [1,2,3,4].should exclude(9) end def test_exclude_fail lambda { [1,2,3,4].should exclude(4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_multi_include [1,2,3,4].should include(1,2) end def test_multi_include_fail lambda { [1,2,3,4].should include(6,7,8) }.should raise_error(Test::Unit::AssertionFailedError) end def test_multi_exclude [1,2,3,4].should exclude(13,14) end def test_multi_exclude_fail lambda { [1,2,3,4].should exclude(2,3,4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_include [1,2,3,4].should_not include(9) end def test_negative_include_fail lambda { [1,2,3,4].should_not include(4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_exclude [1,2,3,4].should_not exclude(3) end def test_negative_exclude_fail lambda { [1,2,3,4].should_not exclude(6,7) }.should raise_error(Test::Unit::AssertionFailedError) end def test_include_fail_message obj = include(1) obj.matches?([4,5,6]) obj.failure_message.should be("Expected [4, 5, 6] to include [1].") end def test_include_negative_fail_message obj = include(1) obj.matches?([4,5,6]) obj.negative_failure_message.should be("Expected [4, 5, 6] to not include [1].") end def test_exclude_fail_message obj = exclude(4) obj.matches?([4,5,6]) obj.failure_message.should be("Expected [4, 5, 6] to exclude [4].") end def test_exclude_negative_fail_message obj = exclude(4) obj.matches?([4,5,6]) obj.negative_failure_message.should be("Expected [4, 5, 6] to not exclude [4].") end # raise_error def test_raises_error lambda { raise "FAIL" }.should raise_error end def test_raises_error_fail lambda { lambda { "WIN" }.should raise_error }.should raise_error(Test::Unit::AssertionFailedError) end def test_raise_error_negative_raises_error lambda { "WIN" }.should_not raise_error end def test_raise_error_negative_raises_error_fail lambda { lambda { raise "FAIL" }.should_not raise_error }.should raise_error(Test::Unit::AssertionFailedError) end def test_raise_error_raises_specific_error lambda { raise TypeError }.should raise_error(TypeError) end def test_raise_error_raises_specific_error_fail_with_no_error lambda { lambda { "WIN" }.should raise_error(TypeError) }.should raise_error(Test::Unit::AssertionFailedError) end def test_raise_error_raises_specific_error_fail_with_different_error lambda { lambda { raise StandardError }.should raise_error(TypeError) }.should raise_error(Test::Unit::AssertionFailedError) end def test_raise_error_error_fail_message obj = raise_error(TypeError) obj.matches?(lambda { raise NameError }) obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but NameError was raised instead./ end def test_raise_error_error_fail_message_when_no_error obj = raise_error(TypeError) obj.matches?(lambda { "moop" }) obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but none was raised./ end def test_raise_error_error_negative_fail_message obj = raise_error(TypeError) obj.matches?(lambda { raise TypeError }) obj.negative_failure_message.should =~ /Expected #<(.*)> to not raise TypeError./ end def test_raise_error_string_argument_message lambda {raise "message"}.should raise_error("message") end def test_string_argument_message_fails_no_error lambda do lambda { 1 }.should raise_error("message") end.should raise_error end def test_raise_error_string_argument_message_fails_wrong_message lambda do lambda { raise "other message" }.should raise_error("message") end.should raise_error end def test_raise_error_regexp_argument_message lambda {raise "message"}.should raise_error(/essa/) end def test_raise_error_regexp_argument_message_fails_no_error lambda do lambda { 1 }.should raise_error(/essa/) end.should raise_error end def test_raise_error_regexp_argument_message_fails_wrong_message lambda do lambda { raise "other message" }.should raise_error(/abc/) end.should raise_error(/matching/) end # throw def test_throws_symbol lambda { throw :win }.should throw_symbol(:win) end def test_throws_symbol_fails_with_different_symbol lambda { lambda { throw :fail }.should throw_symbol(:win) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_throws_symbol lambda { "not this time!" }.should_not throw_symbol(:win) end def test_negative_throws_symbol_fails_with_different_symbol lambda{ lambda { throw :fail }.should_not throw_symbol(:fail) }.should raise_error(Test::Unit::AssertionFailedError) end def test_throw_fail_message obj = throw_symbol(:fail) obj.matches?(lambda { throw :lame }) obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but :lame was thrown instead./ end def test_throw_fail_message_when_no_symbol obj = throw_symbol(:fail) obj.matches?(lambda { "moop" }) obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but no symbol was thrown./ end def test_throw_negative_fail_message obj = throw_symbol(:fail) obj.matches?(lambda { throw :fail }) obj.negative_failure_message.should =~ /Expected #<(.*)> to not throw :fail./ end endjnunemaker-matchy-0.4.0/test/test_helper.rb0000644000175200017520000000006512046776553020555 0ustar nandajanandajarequire File.dirname(__FILE__) + '/../lib/matchy.rb' jnunemaker-matchy-0.4.0/test/test_operator_expectations.rb0000644000175200017520000000611712046776553023723 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestOperatorExpectations < Test::Unit::TestCase # EQUALS (==) def test_equals 3.should == 3 end def test_equals_fails lambda { 3.should == 5 }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_equals 3.should_not == 4 end def test_negative_equals_fails lambda { 3.should_not == 3 }.should raise_error(Test::Unit::AssertionFailedError) end # LESS THAN (<) def test_less_than 3.should < 5 end def test_less_than_fails lambda { 4.should < 3 }.should raise_error(Test::Unit::AssertionFailedError) end def test_less_than_equals 3.should_not < 2 end def test_negative_less_than_fails lambda { 4.should_not < 5 }.should raise_error(Test::Unit::AssertionFailedError) end # GREATER THAN (>) def test_greater_than 3.should > 2 end def test_greater_than_fails lambda { 4.should > 5 }.should raise_error(Test::Unit::AssertionFailedError) end def test_greater_than_equals 3.should_not > 5 end def test_negative_greater_than_fails lambda { 4.should_not > 3 }.should raise_error(Test::Unit::AssertionFailedError) end # LESS THAN EQUAL (<=) def test_less_than_equal 3.should <= 5 end def test_less_than_equal_equal 3.should <= 3 end def test_less_than_equal_fails lambda { 4.should <= 3 }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_less_than_equal 3.should_not <= 2 end def test_negative_less_than_equal_fails lambda { 4.should_not <= 5 }.should raise_error(Test::Unit::AssertionFailedError) end # GREATER THAN EQUALS (>=) def test_greater_than_equal 3.should >= 2 end def test_greater_than_equal_equals 3.should >= 3 end def test_greater_than_equal_fails lambda { 4.should >= 5 }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_greater_than_equal_equals 3.should_not >= 5 end def test_negative_greater_than_equal_fails lambda { 4.should_not >= 3 }.should raise_error(Test::Unit::AssertionFailedError) end # MATCHES (=~) def test_matches "hey world".should =~ /world/ end def test_matches_fails lambda { "d00d ur 1337".should =~ /world/ }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_matches "1337@age".should_not =~ /434/ end def test_negative_matches_fails lambda { "it's a freak out!".should_not =~ /freak/ }.should raise_error(Test::Unit::AssertionFailedError) end def test_fail_message obj = Matchy::Expectations::OperatorExpectation.new(3, true) def obj.flunk(msg) msg end (obj == 4).should == "Expected 3 to == 4." end def test_negative_fail_message obj = Matchy::Expectations::OperatorExpectation.new(3, false) def obj.flunk(msg) msg end (obj == 3).should == "Expected 3 to not == 3." end end jnunemaker-matchy-0.4.0/test/test_error_expectations.rb0000644000175200017520000000747012046776553023224 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestErrorExpectations < Test::Unit::TestCase def test_raises_error lambda { raise "FAIL" }.should raise_error end def test_raises_error_fail lambda { lambda { "WIN" }.should raise_error }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_raises_error lambda { "WIN" }.should_not raise_error end def test_negative_raises_error_fail lambda { lambda { raise "FAIL" }.should_not raise_error }.should raise_error(Test::Unit::AssertionFailedError) end def test_raises_specific_error lambda { raise TypeError }.should raise_error(TypeError) end def test_raises_specific_error_fail_with_no_error lambda { lambda { "WIN" }.should raise_error(TypeError) }.should raise_error(Test::Unit::AssertionFailedError) end def test_raises_specific_error_fail_with_different_error lambda { lambda { raise StandardError }.should raise_error(TypeError) }.should raise_error(Test::Unit::AssertionFailedError) end def test_throws_symbol lambda { throw :win }.should throw_symbol(:win) end def test_throws_symbol_fails_with_different_symbol lambda { lambda { throw :fail }.should throw_symbol(:win) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_throws_symbol lambda { "not this time!" }.should_not throw_symbol(:win) end def test_negative_throws_symbol_fails_with_different_symbol lambda{ lambda { throw :fail }.should_not throw_symbol(:fail) }.should raise_error(Test::Unit::AssertionFailedError) end def test_error_fail_message obj = raise_error(TypeError) obj.matches?(lambda { raise NameError }) obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but NameError was raised instead./ end def test_error_fail_message_when_no_error obj = raise_error(TypeError) obj.matches?(lambda { "moop" }) obj.failure_message.should =~ /Expected #<(.*)> to raise TypeError, but none was raised./ end def test_error_negative_fail_message obj = raise_error(TypeError) obj.matches?(lambda { raise TypeError }) obj.negative_failure_message.should =~ /Expected #<(.*)> to not raise TypeError./ end def test_throw_fail_message obj = throw_symbol(:fail) obj.matches?(lambda { throw :lame }) obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but :lame was thrown instead./ end def test_throw_fail_message_when_no_symbol obj = throw_symbol(:fail) obj.matches?(lambda { "moop" }) obj.failure_message.should =~ /Expected #<(.*)> to throw :fail, but no symbol was thrown./ end def test_throw_negative_fail_message obj = throw_symbol(:fail) obj.matches?(lambda { throw :fail }) obj.negative_failure_message.should =~ /Expected #<(.*)> to not throw :fail./ end def test_string_argument_message lambda {raise "message"}.should raise_error("message") end def test_string_argument_message_fails_no_error lambda do lambda { 1 }.should raise_error("message") end.should raise_error end def test_string_argument_message_fails_wrong_message lambda do lambda { raise "other message" }.should raise_error("message") end.should raise_error end def test_regexp_argument_message lambda {raise "message"}.should raise_error(/essa/) end def test_regexp_argument_message_fails_no_error lambda do lambda { 1 }.should raise_error(/essa/) end.should raise_error end def test_regexp_argument_message_fails_wrong_message lambda do lambda { raise "other message" }.should raise_error(/abc/) end.should raise_error(/matching/) end end jnunemaker-matchy-0.4.0/test/test_enumerable_expectations.rb0000644000175200017520000000406312046776553024205 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class TestEnumerableExpectations < Test::Unit::TestCase def test_include [1,2,3,4].should include(4) end def test_include_fail lambda { [1,2,3,4].should include(6) }.should raise_error(Test::Unit::AssertionFailedError) end def test_exclude [1,2,3,4].should exclude(9) end def test_exclude_fail lambda { [1,2,3,4].should exclude(4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_multi_include [1,2,3,4].should include(1,2) end def test_multi_include_fail lambda { [1,2,3,4].should include(6,7,8) }.should raise_error(Test::Unit::AssertionFailedError) end def test_multi_exclude [1,2,3,4].should exclude(13,14) end def test_multi_exclude_fail lambda { [1,2,3,4].should exclude(2,3,4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_include [1,2,3,4].should_not include(9) end def test_negative_include_fail lambda { [1,2,3,4].should_not include(4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_exclude [1,2,3,4].should_not exclude(3) end def test_negative_exclude_fail lambda { [1,2,3,4].should_not exclude(6,7) }.should raise_error(Test::Unit::AssertionFailedError) end def test_include_fail_message obj = include(1) obj.matches?([4,5,6]) obj.failure_message.should be("Expected [4, 5, 6] to include [1].") end def test_include_negative_fail_message obj = include(1) obj.matches?([4,5,6]) obj.negative_failure_message.should be("Expected [4, 5, 6] to not include [1].") end def test_exclude_fail_message obj = exclude(4) obj.matches?([4,5,6]) obj.failure_message.should be("Expected [4, 5, 6] to exclude [4].") end def test_exclude_negative_fail_message obj = exclude(4) obj.matches?([4,5,6]) obj.negative_failure_message.should be("Expected [4, 5, 6] to not exclude [4].") end end jnunemaker-matchy-0.4.0/test/test_truth_expectations.rb0000644000175200017520000002046012046776553023233 0ustar nandajanandajarequire File.dirname(__FILE__) + '/test_helper.rb' class Exister def initialize(what) @what = what end def exist? @what end end class TestTruthExpectations < Test::Unit::TestCase def setup @obj = Object.new end def test_equal 3.should equal(3) end def test_negative_equal instance = String.new instance.should_not equal(String.new) end def test_equal_fail lambda { 3.should equal(4) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_equal_fail lambda { 3.should_not equal(3) }.should raise_error(Test::Unit::AssertionFailedError) end def test_eql 3.should eql(3) end def test_eql_array [1,2,3].should eql([1,2,3]) end def test_negative_eql 3.should_not eql(9) end def test_eql_fail lambda { 3.should eql(13) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_eql_fail lambda { 3.should_not eql(3) }.should raise_error(Test::Unit::AssertionFailedError) end def test_exists thing = Exister.new(true) thing.should exist end def test_negative_exists thing = Exister.new(false) thing.should_not exist end def test_exists_fail lambda { thing = Exister.new(false) thing.should exist }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_exists_fail lambda { thing = Exister.new(true) thing.should_not exist }.should raise_error(Test::Unit::AssertionFailedError) end def test_be true.should be(true) end def test_be_array [1,2,3].should be([1,2,3]) end def test_negative_be true.should_not be(false) end def test_be_fail lambda { true.should be(false) }.should raise_error(Test::Unit::AssertionFailedError) end def test_be_close (5.0 - 2.0).should be_close(3.0) end def test_be_close_with_delta (5.0 - 2.0).should be_close(3.0, 0.2) end def test_be_close_fail lambda { (19.0 - 13.0).should be_close(33.04) }.should raise_error(Test::Unit::AssertionFailedError) end def test_be_close_with_delta_fail lambda { (19.0 - 13.0).should be_close(6.0, 0.0) }.should raise_error(Test::Unit::AssertionFailedError) end def test_satisfy 13.should satisfy(lambda {|i| i < 15}) end def test_negative_satisfy 13.should_not satisfy(lambda {|i| i < 10}) end def test_satisfy_fail lambda { 13.should satisfy(lambda {|i| i > 15}) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_satisfy_fail lambda { 13.should_not satisfy(lambda {|i| i < 15}) }.should raise_error(Test::Unit::AssertionFailedError) end def test_equal_fail_message obj = equal(4) obj.matches?(5) obj.failure_message.should be("Expected 5 to return true for equal?, with '4'.") end def test_equal_negative_fail_message obj = equal(5) obj.matches?(5) obj.negative_failure_message.should be("Expected 5 to not return true for equal?, with '5'.") end def test_eql_fail_message obj = eql(4) obj.matches?(5) obj.failure_message.should be("Expected 5 to return true for eql?, with '4'.") end def test_eql_negative_fail_message_for_eql obj = eql(5) obj.matches?(5) obj.negative_failure_message.should be("Expected 5 to not return true for eql?, with '5'.") end def test_exist_fail_message obj = exist obj.matches?(Exister.new(false)) obj.failure_message.should =~ /Expected #<(.*)> to return true for exist?./ end def test_exist_negative_fail_message obj = exist obj.matches?(Exister.new(true)) obj.negative_failure_message.should =~ /Expected #<(.*)> to not return true for exist?./ end def test_be_close_fail_message obj = be_close(3.0) obj.matches?(6.0) obj.failure_message.should be("Expected 6.0 to be close to 3.0 (delta: 0.3).") end def test_be_close_negative_fail_message obj = be_close(5.0) obj.matches?(5.0) obj.negative_failure_message.should be("Expected 5.0 to not be close to 5.0 (delta: 0.3).") end def test_be_fail_message obj = be(4) obj.matches?(5) obj.failure_message.should be("Expected 5 to be 4.") end def test_be_negative_fail_message obj = be(5) obj.matches?(5) obj.negative_failure_message.should be("Expected 5 to not be 5.") end def test_satisfy_fail_message obj = satisfy(lambda {|x| x == 4}) obj.matches?(6) obj.failure_message.should be("Expected 6 to satisfy given block.") end def test_eql_negative_fail_message_for_matches obj = satisfy(lambda {|x| x == 4}) obj.matches?(4) obj.negative_failure_message.should be("Expected 4 to not satisfy given block.") end def test_kind_of 3.should be_kind_of(Fixnum) end def test_kind_of_fail lambda { 3.should be_kind_of(Hash) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_kind_of 3.should_not be_kind_of(Hash) end def test_negative_kind_of_fail lambda { 3.should_not be_kind_of(Fixnum) }.should raise_error(Test::Unit::AssertionFailedError) end def test_respond_to "foo".should respond_to(:length) end def test_respond_to_fail lambda { "foo".should respond_to(:nonexistant_method) }.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_respond_to "foo".should_not respond_to(:nonexistant_method) end def test_negative_respond_to_fail lambda { "foo".should_not respond_to(:length) }.should raise_error(Test::Unit::AssertionFailedError) end # be_something def test_positive_be_something_method_missing_pass def @obj.something? true end @obj.should be_something end def test_positive_be_something_method_missing_fails def @obj.something? false end lambda {@obj.should be_something}.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_be_something_method_missing_pass def @obj.something? false end @obj.should_not be_something end def test_negative_be_something_method_missing_fails def @obj.something? true end lambda {@obj.should_not be_something}.should raise_error(Test::Unit::AssertionFailedError) end def test_be_something_method_missing_fail_message obj = "foo" def obj.something? true end matcher_obj = be_something obj.should matcher_obj matcher_obj.failure_message.should be("Expected \"foo\" to return true for something?, with 'no args'.") end def test_be_something_method_missing_negative_fail_message obj = "foo" def obj.something? false end matcher_obj = be_something obj.should_not matcher_obj matcher_obj.negative_failure_message.should =~ /Expected \"foo\" to not return true for something?/ end # be_something(arg) def test_positive_be_something_with_arg_method_missing_pass def @obj.something?(arg) true end @obj.should be_something(1) end def test_positive_be_something_with_arg_method_missing_fails def @obj.something?(arg) false end lambda {@obj.should be_something(1)}.should raise_error(Test::Unit::AssertionFailedError) end def test_negative_be_something_method_missing_pass def @obj.something?(arg) false end @obj.should_not be_something(1) end def test_negative_be_something_method_missing_fails def @obj.something?(arg) true end lambda {@obj.should_not be_something(1)}.should raise_error(Test::Unit::AssertionFailedError) end def test_be_something_method_missing_fail_message obj = "foo" def obj.something?(arg) true end matcher_obj = be_something(1) obj.should matcher_obj matcher_obj.failure_message.should be("Expected \"foo\" to return true for something?, with '1'.") end def test_be_something_method_missing_negative_fail_message obj = "foo" def obj.something?(arg) false end matcher_obj = be_something(1) obj.should_not matcher_obj matcher_obj.negative_failure_message.should be("Expected \"foo\" to not return true for something?, with '1'.") end end jnunemaker-matchy-0.4.0/test/all.rb0000644000175200017520000000023712046776553017010 0ustar nandajanandajadir = File.dirname(__FILE__) Dir[File.expand_path("#{dir}/*.rb")].uniq.each do |file| if file =~ /\/test_\w+\.rb$/ puts file require file end endjnunemaker-matchy-0.4.0/config/0000755000175200017520000000000012046776553016177 5ustar nandajanandajajnunemaker-matchy-0.4.0/config/requirements.rb0000644000175200017520000000052412046776553021250 0ustar nandajanandajarequire 'fileutils' include FileUtils require 'rubygems' %w[rake hoe newgem rubigen].each do |req_gem| begin require req_gem rescue LoadError puts "This Rakefile requires the '#{req_gem}' RubyGem." puts "Installation: gem install #{req_gem} -y" exit end end $:.unshift(File.join(File.dirname(__FILE__), %w[.. lib])) jnunemaker-matchy-0.4.0/config/hoe.rb0000644000175200017520000000473012046776553017303 0ustar nandajanandajarequire 'matchy/version' AUTHOR = 'Jeremy McAnally' # can also be an array of Authors EMAIL = "jeremy@entp.com" DESCRIPTION = "RSpec-esque matchers for use in Test::Unit" GEM_NAME = 'matchy' # what ppl will type to install your gem RUBYFORGE_PROJECT = 'matchy' # The unix name for your project HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org" DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}" EXTRA_DEPENDENCIES = [ # ['activesupport', '>= 1.3.1'] ] # An array of rubygem dependencies [name, version] @config_file = "~/.rubyforge/user-config.yml" @config = nil RUBYFORGE_USERNAME = "unknown" def rubyforge_username unless @config begin @config = YAML.load(File.read(File.expand_path(@config_file))) rescue puts <<-EOS ERROR: No rubyforge config file found: #{@config_file} Run 'rubyforge setup' to prepare your env for access to Rubyforge - See http://newgem.rubyforge.org/rubyforge.html for more details EOS exit end end RUBYFORGE_USERNAME.replace @config["username"] end REV = nil # UNCOMMENT IF REQUIRED: # REV = YAML.load(`svn info`)['Revision'] VERS = Matchy::VERSION::STRING + (REV ? ".#{REV}" : "") RDOC_OPTS = ['--quiet', '--title', 'matchy documentation', "--opname", "index.html", "--line-numbers", "--main", "README.rdoc", "--inline-source"] class Hoe def extra_deps @extra_deps.reject! { |x| Array(x).first == 'hoe' } @extra_deps end end # Generate all the Rake tasks # Run 'rake -T' to see list of generated tasks (from gem root directory) $hoe = Hoe.new(GEM_NAME, VERS) do |p| p.developer(AUTHOR, EMAIL) p.description = DESCRIPTION p.summary = DESCRIPTION p.url = HOMEPATH p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT p.test_globs = ["test/**/test_*.rb"] p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store'] #An array of file patterns to delete on clean. # == Optional p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n") #p.extra_deps = EXTRA_DEPENDENCIES #p.spec_extras = {} # A hash of extra values to set in the gemspec. end CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n") PATH = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}" $hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc') $hoe.rsync_args = '-av --delete --ignore-errors' $hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""jnunemaker-matchy-0.4.0/tasks/0000755000175200017520000000000012046776553016057 5ustar nandajanandajajnunemaker-matchy-0.4.0/tasks/environment.rake0000644000175200017520000000017312046776553021270 0ustar nandajanandajatask :ruby_env do RUBY_APP = if RUBY_PLATFORM =~ /java/ "jruby" else "ruby" end unless defined? RUBY_APP end jnunemaker-matchy-0.4.0/tasks/deployment.rake0000644000175200017520000000217512046776553021110 0ustar nandajanandajadesc 'Release the website and new gem version' task :deploy => [:check_version, :website, :release] do puts "Remember to create SVN tag:" puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " + "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} " puts "Suggested comment:" puts "Tagging release #{CHANGES}" end desc 'Runs tasks website_generate and install_gem as a local deployment of the gem' task :local_deploy => [:website_generate, :install_gem] task :check_version do unless ENV['VERSION'] puts 'Must pass a VERSION=x.y.z release version' exit end unless ENV['VERSION'] == VERS puts "Please update your version.rb to match the release version, currently #{VERS}" exit end end desc 'Install the package as a gem, without generating documentation(ri/rdoc)' task :install_gem_no_doc => [:clean, :package] do sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri" end namespace :manifest do desc 'Recreate Manifest.txt to include ALL files' task :refresh do `rake check_manifest | patch -p0 > Manifest.txt` end endjnunemaker-matchy-0.4.0/lib/0000755000175200017520000000000012046776553015500 5ustar nandajanandajajnunemaker-matchy-0.4.0/lib/matchy.rb0000644000175200017520000000121612046776553017312 0ustar nandajanandaja$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__))) require 'test/unit' require 'matchy/expectation_builder' require 'matchy/modals' require 'matchy/matcher_builder' require 'matchy/custom_matcher' require 'matchy/version' require 'matchy/built_in/enumerable_expectations' require 'matchy/built_in/error_expectations' require 'matchy/built_in/truth_expectations' require 'matchy/built_in/operator_expectations' require 'matchy/built_in/change_expectations' Test::Unit::TestCase.send(:include, Matchy::Expectations::TestCaseExtensions) include Matchy::CustomMatcher jnunemaker-matchy-0.4.0/lib/matchy/0000755000175200017520000000000012046776553016765 5ustar nandajanandajajnunemaker-matchy-0.4.0/lib/matchy/version.rb0000644000175200017520000000021112046776553020771 0ustar nandajanandajamodule Matchy module VERSION #:nodoc: MAJOR = 0 MINOR = 4 TINY = 0 STRING = [MAJOR, MINOR, TINY].join('.') end end jnunemaker-matchy-0.4.0/lib/matchy/modals.rb0000644000175200017520000000154012046776553020571 0ustar nandajanandajamodule Matchy module Modals # Tests an expectation against the given object. # # ==== Examples # # "hello".should eql("hello") # 13.should equal(13) # lambda { raise "u r doomed" }.should raise_error # def should(expectation = nil) Matchy::ExpectationBuilder.build_expectation(true, expectation, self) end alias :will :should # Tests that an expectation doesn't match the given object. # # ==== Examples # # "hello".should_not eql("hi") # 41.should_not equal(13) # lambda { "savd bai da bell" }.should_not raise_error # def should_not(expectation = nil) Matchy::ExpectationBuilder.build_expectation(false, expectation, self) end alias :will_not :should_not alias :wont :should_not end end Object.send(:include, Matchy::Modals)jnunemaker-matchy-0.4.0/lib/matchy/expectation_builder.rb0000644000175200017520000000041512046776553023343 0ustar nandajanandajamodule Matchy module ExpectationBuilder def self.build_expectation(match, exp, obj) return Matchy::Expectations::OperatorExpectation.new(obj, match) unless exp (exp.matches?(obj) != match) ? exp.fail!(match) : exp.pass!(match) end end endjnunemaker-matchy-0.4.0/lib/matchy/matcher_builder.rb0000644000175200017520000000304412046776553022444 0ustar nandajanandajamodule Matchy module MatcherBuilder class ChainedMessage < Struct.new(:name, :args, :block); end def build_matcher(matcher_name=nil, args=[], &block) match_block = lambda do |actual, matcher| block.call(actual, matcher, args) end body = lambda do |klass| include Test::Unit::Assertions @matcher_name = matcher_name.to_s def self.matcher_name @matcher_name end attr_reader :matcher_name attr_accessor :positive_failure_message, :negative_failure_message, :chained_messages def initialize(match_block, test_case) @match_block, @test_case = match_block, test_case @matcher_name = self.class.matcher_name end def method_missing(id, *args, &block) (self.chained_messages ||= []) << ChainedMessage.new(id, args, block) self end def matches?(given) @positive_failure_message ||= "Matching with '#{matcher_name}' failed, although it should match." @negative_failure_message ||= "Matching with '#{matcher_name}' passed, although it should_not match." @match_block.call(given, self) end def fail!(which) @test_case.flunk(which ? failure_message : negative_failure_message) end def pass!(which) @test_case.assert true end alias_method :failure_message, :positive_failure_message end Class.new(&body).new(match_block, self) end end endjnunemaker-matchy-0.4.0/lib/matchy/custom_matcher.rb0000644000175200017520000000035612046776553022333 0ustar nandajanandajamodule Matchy module CustomMatcher include Matchy::MatcherBuilder def custom_matcher(matcher_name, &block) define_method matcher_name do |*args| build_matcher(matcher_name, args, &block) end end end endjnunemaker-matchy-0.4.0/lib/matchy/built_in/0000755000175200017520000000000012046776553020572 5ustar nandajanandajajnunemaker-matchy-0.4.0/lib/matchy/built_in/change_expectations.rb0000644000175200017520000000270312046776553025134 0ustar nandajanandajamodule Matchy module Expectations module TestCaseExtensions # Checks if the given block alters the value of the block attached to change # # ==== Examples # lambda {var += 1}.should change {var}.by(1) # lambda {var += 2}.should change {var}.by_at_least(1) # lambda {var += 1}.should change {var}.by_at_most(1) # lambda {var += 2}.should change {var}.from(1).to(3) if var = 1 def change(&block) build_matcher(:change) do |receiver, matcher, args| before, done, after = block.call, receiver.call, block.call comparison = after != before if list = matcher.chained_messages comparison = case list[0].name # todo: provide meaningful messages when :by then (after == before + list[0].args[0] || after == before - list[0].args[0]) when :by_at_least then (after >= before + list[0].args[0] || after <= before - list[0].args[0]) when :by_at_most then (after <= before + list[0].args[0] && after >= before - list[0].args[0]) when :from then (before == list[0].args[0]) && (after == list[1].args[0]) end end matcher.positive_failure_message = "given block shouldn't alter the block attached to change" matcher.negative_failure_message = "given block should alter the block attached to change" comparison end end end end endjnunemaker-matchy-0.4.0/lib/matchy/built_in/enumerable_expectations.rb0000644000175200017520000000240112046776553026021 0ustar nandajanandajamodule Matchy module Expectations module TestCaseExtensions # Calls +include?+ on the receiver for any object. You can also provide # multiple arguments to see if all of them are included. # # ==== Examples # # [1,2,3].should include(1) # [7,8,8].should_not include(3) # ['a', 'b', 'c'].should include('a', 'c') # def include(*obj) _clude(:include, obj) end # Expects the receiver to exclude the given object(s). You can provide # multiple arguments to see if all of them are included. # # ==== Examples # # [1,2,3].should exclude(16) # [7,8,8].should_not exclude(7) # ['a', 'b', 'c'].should exclude('e', 'f', 'g') # def exclude(*obj) _clude(:exclude, obj) end private def _clude(sym, obj) build_matcher(sym, obj) do |given, matcher, args| matcher.positive_failure_message = "Expected #{given.inspect} to #{sym} #{args.inspect}." matcher.negative_failure_message = "Expected #{given.inspect} to not #{sym} #{args.inspect}." args.inject(true) {|m,o| m && (given.include?(o) == (sym == :include)) } end end end end endjnunemaker-matchy-0.4.0/lib/matchy/built_in/operator_expectations.rb0000644000175200017520000000221512046776553025540 0ustar nandajanandajamodule Matchy module Expectations # Class to handle operator expectations. # # ==== Examples # # 13.should == 13 # "hello".length.should_not == 2 # class OperatorExpectation #< Base include Test::Unit::Assertions def initialize(receiver, match) @receiver, @match = receiver, match end ['==', '===', '=~', '>', '>=', '<', '<='].each do |op| define_method(op) do |expected| @expected = expected (@receiver.send(op,expected) ? true : false) == @match ? pass! : fail!(op) end end protected def pass! defined?($current_test_case) ? $current_test_case.assert(true) : (assert true) end def fail!(operator) flunk @match ? failure_message(operator) : negative_failure_message(operator) end def failure_message(operator) "Expected #{@receiver.inspect} to #{operator} #{@expected.inspect}." end def negative_failure_message(operator) "Expected #{@receiver.inspect} to not #{operator} #{@expected.inspect}." end end end endjnunemaker-matchy-0.4.0/lib/matchy/built_in/truth_expectations.rb0000644000175200017520000001166112046776553025060 0ustar nandajanandajamodule Matchy module Expectations module TestCaseExtensions # Simply checks if the receiver matches the expected object. # TODO: Fill this out to implement much of the RSpec functionality (and then some) # # ==== Examples # # "hello".should be("hello") # (13 < 20).should be(true) # def be(*obj) build_matcher(:be, obj) do |receiver, matcher, args| @receiver, expected = receiver, args[0] matcher.positive_failure_message = "Expected #{@receiver.inspect} to be #{expected.inspect}." matcher.negative_failure_message = "Expected #{@receiver.inspect} to not be #{expected.inspect}." expected == @receiver end end # Checks if the given object is within a given object and delta. # # ==== Examples # # (20.0 - 2.0).should be_close(18.0) # (13.0 - 4.0).should be_close(9.0, 0.5) # def be_close(obj, delta = 0.3) build_matcher(:be_close, [obj, delta]) do |receiver, matcher, args| @receiver, expected, delta = receiver, args[0], args[1] matcher.positive_failure_message = "Expected #{@receiver.inspect} to be close to #{expected.inspect} (delta: #{delta})." matcher.negative_failure_message = "Expected #{@receiver.inspect} to not be close to #{expected.inspect} (delta: #{delta})." (@receiver - expected).abs < delta end end # Calls +exist?+ on the given object. # # ==== Examples # # # found_user.exist? # found_user.should exist # def exist ask_for(:exist, :with_arg => nil) end # Calls +eql?+ on the given object (i.e., are the objects the same value?) # # ==== Examples # # 1.should_not eql(1.0) # (12 / 6).should eql(6) # def eql(*obj) ask_for(:eql, :with_arg => obj) end # Calls +equal?+ on the given object (i.e., do the two objects have the same +object_id+?) # # ==== Examples # # x = [1,2,3] # y = [1,2,3] # # # Different object_id's... # x.should_not equal(y) # # # The same object_id # x[0].should equal(y[0]) # def equal(*obj) ask_for(:equal, :with_arg => obj) end # A last ditch way to implement your testing logic. You probably shouldn't use this unless you # have to. # # ==== Examples # # (13 - 4).should satisfy(lambda {|i| i < 20}) # "hello".should_not satisfy(lambda {|s| s =~ /hi/}) # def satisfy(*obj) build_matcher(:satisfy, obj) do |receiver, matcher, args| @receiver, expected = receiver, args[0] matcher.positive_failure_message = "Expected #{@receiver.inspect} to satisfy given block." matcher.negative_failure_message = "Expected #{@receiver.inspect} to not satisfy given block." expected.call(@receiver) == true end end # Checks if the given object responds to the given method # # ==== Examples # # "foo".should respond_to(:length) # {}.should respond_to(:has_key?) def respond_to(*meth) ask_for(:respond_to, :with_arg => meth) end # Asks given for success?(). # This is necessary because Rails Integration::Session # overides method_missing without grace. # # ==== Examples # # @response.should be_success def be_success ask_for(:success, :with_arg => nil) end alias_method :old_missing, :method_missing # ==be_*something(*args) # # ===This method_missing acts as a matcher builder. # If a call to be_xyz() reaches this method_missing (say: obj.should be_xyz), # a matcher with the name xyz will be built, whose defining property # is that it returns the value of obj.xyz? for matches?. # ==== Examples # # nil.should be_nil # 17.should be_kind_of(Fixnum) # obj.something? #=> true # obj.should be_something def method_missing(name, *args, &block) if (name.to_s =~ /^be_(.+)/) ask_for($1, :with_arg => args) else old_missing(name, *args, &block) end end private def ask_for(sym, option={}) build_matcher(sym, (option[:with_arg] || [])) do |receiver, matcher, args| expected, meth = args[0], (sym.to_s + "?" ).to_sym matcher.positive_failure_message = "Expected #{receiver.inspect} to return true for #{sym}?, with '#{(expected && expected.inspect) || 'no args'}'." matcher.negative_failure_message = "Expected #{receiver.inspect} to not return true for #{sym}?, with '#{(expected && expected.inspect) || 'no args'}'." expected ? receiver.send(meth, expected) : receiver.send(meth) end end end end endjnunemaker-matchy-0.4.0/lib/matchy/built_in/error_expectations.rb0000644000175200017520000000560212046776553025041 0ustar nandajanandajamodule Matchy module Expectations module TestCaseExtensions # Expects a lambda to raise an error. You can specify the error or leave it blank to encompass # any error. # # ==== Examples # # lambda { raise "FAILURE." }.should raise_error # lambda { puts i_dont_exist }.should raise_error(NameError) # def raise_error(*obj) build_matcher(:raise_error, obj) do |receiver, matcher, args| expected = args[0] || Exception raised = false error = nil begin receiver.call rescue Exception => e raised = true error = e end if expected.respond_to?(:ancestors) && expected.ancestors.include?(Exception) matcher.positive_failure_message = "Expected #{receiver.inspect} to raise #{expected.name}, " + (error ? "but #{error.class.name} was raised instead." : "but none was raised.") matcher.negative_failure_message = "Expected #{receiver.inspect} to not raise #{expected.name}." comparison = (raised && error.class.ancestors.include?(expected)) else message = error ? error.message : "none" matcher.positive_failure_message = "Expected #{receiver.inspect} to raise error with message matching '#{expected}', but '#{message}' was raised." matcher.negative_failure_message = "Expected #{receiver.inspect} to raise error with message not matching '#{expected}', but '#{message}' was raised." comparison = (raised && (expected.kind_of?(Regexp) ? ((error.message =~ expected) ? true : false) : expected == error.message)) end comparison end end # Expects a lambda to throw an error. # # ==== Examples # # lambda { throw :thing }.should throw_symbol(:thing) # lambda { "not this time" }.should_not throw_symbol(:hello) # def throw_symbol(*obj) build_matcher(:throw_symbol, obj) do |receiver, matcher, args| raised, thrown_symbol, expected = false, nil, args[0] begin receiver.call rescue NameError => e raise e unless e.message =~ /uncaught throw/ raised = true thrown_symbol = e.name.to_sym if e.respond_to?(:name) rescue ArgumentError => e raise e unless e.message =~ /uncaught throw/ thrown_symbol = e.message.match(/uncaught throw :(.+)/)[1].to_sym end matcher.positive_failure_message = "Expected #{receiver.inspect} to throw :#{expected}, but " + "#{thrown_symbol ? ':' + thrown_symbol.to_s + ' was thrown instead' : 'no symbol was thrown'}." matcher.negative_failure_message = "Expected #{receiver.inspect} to not throw :#{expected}." expected == thrown_symbol end end end end endjnunemaker-matchy-0.4.0/README.rdoc0000644000175200017520000001123712046776553016544 0ustar nandajanandaja= matchy * http://github.com/jeremymcanally/matchy == DESCRIPTION: Hate writing assertions? Need a little behavior-driven love in your tests? Then matchy is for you. == FEATURES/PROBLEMS: * Get the beauty of RSpec without all the overhead * Create your own matchers with ease == SYNOPSIS: * Get BDD on your objects x = 13 * 4 x.should == 42 y = "hello" y.length.should_not be(4) * Use familiar syntax to specify things # RSpec "my string".should =~ /string/ lambda { raise "FAIL" }.should raise_error # matchy "my string".should =~ /string/ lambda { raise "FAIL" }.should raise_error * Most of familiar RSpec Matchers are built in # raise_error matcher lambda {raise}.should raise_error #pass lambda {raise MyCustomError.new}.should raise_error(MyCustomError) #pass lambda {raise "message"}.should raise_error("message") #pass lambda {raise "message"}.should raise_error(/essa/) #pass # change matcher lambda {@var+=1}.should change {@var} # passes lambda { }.should change {@var} # fails @var = 1 lambda {@var+=1}.should change {@var}.from(1).to(2) # passes # be_something matcher @obj.should be_something # passes if @obj.something? is true * a lot more ... * Create your own custom matchers # maybe in your test helper class Test::Unit::TestCase custom_matcher :be_nil do |receiver, matcher, args| receiver.nil? end # also you can set positive (should) and negative (should not) failure messages custom_matcher :be_nil do |receiver, matcher, args| matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't" matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was" receiver.nil? end end # your actual test class NilTest < Test::Unit::TestCase def test_nil_stuff nil.should be_nil # pass nil.should_not be_nil # fail 'foo'.should_not be_nil # pass 'foo'.should be_nil # fail end end # Matchers can accept arguments class Test::Unit::TestCase custom_matcher :have_error_on do |receiver, matcher, args| attribute = args[0] receiver.valid? receiver.errors.on(attribute).should_not == nil end end class ArgumentTest < Test::Unit::TestCase class Item < ActiveRecord::Base validate_presence_of :title end def test_arguments item = Item.new item.should have_error_on(:title) # pass item.title = 'Foo' item.should_not have_error_on(:title) # pass end end # Even more advanced, you can have messages on matchers class Test::Unit::TestCase custom_matcher :have do |receiver, matcher, args| count = args[0] something = matcher.chained_messages[0].name actual = receiver.send(something).size matcher.positive_failure_message = "Expected #{receiver} to have #{actual} #{something}, but found #{count} " actual == count end end class MoreAdvancedTest < Test::Unit::TestCase class Item def tags %w(foo bar baz) end end def test_item_has_tags item = Item.new item.should have(3).tags # pass item.should have(2).tags # fail end end == REQUIREMENTS: * Test::Unit (you got it) == INSTALL: $ gem sources -a http://gems.github.com $ sudo gem install jnunemaker-matchy == LICENSE: (The MIT License) Copyright (c) 2008 Jeremy McAnally Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.jnunemaker-matchy-0.4.0/Manifest.txt0000644000175200017520000000161312046776553017242 0ustar nandajanandajaHistory.txt License.txt Manifest.txt PostInstall.txt README.rdoc Rakefile config/hoe.rb config/requirements.rb countloc.rb lib/matchy.rb lib/matchy/built_in/change_expectations.rb lib/matchy/built_in/enumerable_expectations.rb lib/matchy/built_in/error_expectations.rb lib/matchy/built_in/operator_expectations.rb lib/matchy/built_in/truth_expectations.rb lib/matchy/custom_matcher.rb lib/matchy/expectation_builder.rb lib/matchy/matcher_builder.rb lib/matchy/modals.rb lib/matchy/version.rb matchy.gemspec setup.rb tasks/deployment.rake tasks/environment.rake test/all.rb test/ruby1.9.compatibility_tests.rb test/test_change_expectation.rb test/test_custom_matcher.rb test/test_enumerable_expectations.rb test/test_error_expectations.rb test/test_expectation_builder.rb test/test_helper.rb test/test_matcher_builder.rb test/test_modals.rb test/test_operator_expectations.rb test/test_truth_expectations.rb jnunemaker-matchy-0.4.0/History.txt0000644000175200017520000000010012046776553017123 0ustar nandajanandaja== 0.0.1 2008-10-03 * 1 major enhancement: * Initial release