mathml 0.8.1 → 0.10.1

data/Rakefile

@@ -1,121 +1,65 @@
-require "rake/clean"
-require "rake/testtask"
-require "rake/rdoctask"
-require "rake/gempackagetask"
+load "Rakefile.utirake"
 
-FILES = FileList["**/*"].exclude("pkg", "html", "eim_xml")
-CLOBBER.include("eim_xml")
+VER = "0.10.1"
 
-task :default => :test
+UtiRake.setup do
+	external("https://hg.hinet.mydns.jp", %w[eim_xml])
 
-
-### Document ###
-RDOC_DIR = "./html/"
-RDOC_OPTS = ["-S", "-w", "3", "-c", "UTF-8", "-m", "README"]
-RDOC_OPTS << "-d" if ENV["DOT"]
-RDOC_FILES = FileList["lib/**/*.rb"]
-RDOC_EXTRAS = FileList["README"]
-["", "ja", "en"].each do |l|
-	dir = RDOC_DIR.dup
-	dir << "#{l}/" unless l.empty?
-	Rake::RDocTask.new("rdoc#{":"+l unless l.empty?}") do |rdoc|
-		rdoc.title = "MathML Library"
-		rdoc.options = RDOC_OPTS.dup
-		rdoc.options << "-l" << l unless l.empty?
-		rdoc.rdoc_dir = dir
-		rdoc.rdoc_files.include(RDOC_FILES, RDOC_EXTRAS)
+	rdoc do |t|
+		t.title = "MathML Library"
+		t.main = "README"
+		t.rdoc_files << FileList["lib/**/*.rb", "README"]
 	end
-end
-task "rdoc:all" => ["rdoc", "rdoc:ja", "rdoc:en"]
-task "rerdoc:all" => ["rerdoc", "rerdoc:ja", "rerdoc:en"]
-
-
-### Publish document ###
-task :publish => [:clobber_rdoc, "rdoc:ja", "rdoc:en"] do
-	require "rake/contrib/rubyforgepublisher"
-	cp "index.html", "html/index.html"
-	Rake::RubyForgePublisher.new("mathml", "hiraku").upload
-end
 
-
-### Clone external library ###
-EIMXML_DIR = "./eim_xml"
-file EIMXML_DIR do |t|
-	sh "hg clone https://hg.hinet.mydns.jp/eim_xml #{t.name}"
-end
-task :eim_xml => EIMXML_DIR
-
-
-### Test ###
-task :test => "test:apart"
-namespace :test do
-	def add_libs_for_test(t)
-		t.libs << "test" << "eim_xml/lib" << "../eim_xml/lib"
-	end
-	FileList["test/*_test.rb"].sort{|a,b| File.mtime(a)<=>File.mtime(b)}.reverse.each do |i|
-		Rake::TestTask.new(:apart) do |t|
-			t.test_files = [i]
-			add_libs_for_test(t)
-		end
+	publish("mathml", "hiraku") do
+		cp "index.html", "html/index.html"
 	end
-	task(:apart).comment = "Run tests separately"
 
-	Rake::TestTask.new(:lump) do |t|
-		t.test_files = FileList["test/*_test.rb"]
-		add_libs_for_test(t)
+	gemspec do |s|
+		s.name = "mathml"
+		s.rubyforge_project = "mathml"
+		s.version = VER
+		s.summary = "MathML Library"
+		s.author = "KURODA Hiraku"
+		s.email = "hiraku@hinet.mydns.jp"
+		s.homepage = "http://mathml.rubyforge.org/"
+		s.add_dependency("eimxml")
+		s.post_install_message = "*"*60 << "\n" << <<EOT << "*"*60
+[DEPRECATION]
+"mathml" gem is deprecated.
+Please use "math_ml" gem instead.
+EOT
 	end
-	task(:lump).comment = "Run all tests in a lump"
 
-	Rake::TestTask.new(:symbol) do |t|
-		t.test_files = FileList["symbols/*_test.rb"]
-		add_libs_for_test(t)
+	rcov_spec do |s|
+		s.ruby_opts = %w[-rubygems]
+		s.pattern ||= %w[spec/util.rb spec/**/*_spec.rb]
+		s.pattern = [s.pattern] unless s.pattern.is_a?(Array)
+#		s.pattern << "symbols/**/*_spec.rb"
 	end
-end
-
 
-### Build GEM ###
-GEM_DIR = "./pkg"
-directory GEM_DIR
-def build_gem(unstable=false)
-	spec = Gem::Specification.new do |spec|
-		spec.name = "mathml"
-		spec.rubyforge_project = "mathml"
-		spec.version = ENV["VER"] or raise "Need VER=x.y.z(.?)"
-		spec.summary = "MathML Library"
-		spec.author = "KURODA Hiraku"
-		spec.email = "hiraku@hinet.mydns.jp"
-		spec.homepage = "http://mathml.rubyforge.org/"
-		spec.add_dependency("eimxml")
-		spec.files = FILES
-		spec.test_files = Dir.glob("test/*.rb")
-		spec.has_rdoc = true
-		spec.rdoc_options = RDOC_OPTS.dup
-		spec.extra_rdoc_files = RDOC_EXTRAS
+	spec do |s|
+#		s.spec_opts << "-b"
 	end
-
-	spec.version = spec.version.to_s << Time.now.strftime(".%Y.%m%d.%H%M") if unstable
-	b = Gem::Builder.new(spec)
-	gname = b.build
-	mv gname, "#{GEM_DIR}/"
-end
-
-desc "Build gem package"
-task :gem => GEM_DIR do
-	build_gem
+	alias_task
 end
 
-desc "Build unstable version gem package"
-task "gem:unstable" => GEM_DIR do
-	build_gem(true)
+namespace :spec do
+	RSpec::Core::RakeTask.new(:symbols) do |s|
+		s.pattern = "./symbols/**/*_spec.rb"
+		s.rspec_opts = %w[-c -I lib -I external/lib]
+	end
 end
 
-
-### Build package ###
-package_task = Rake::PackageTask.new("math_ml",ENV["VER"] || :noversion) do |t|
-	t.package_files.include(FILES)
-	t.need_tar_gz = true
+task :package do
+	name = "math_ml-#{VER}"
+	cp "external/eim_xml/lib/eim_xml.rb", "pkg/#{name}/lib/"
+	Dir.chdir "pkg" do
+		rm "#{name}.tar.gz"
+		sh "tar zcf #{name}.tar.gz #{name}/"
+	end
 end
 
-file "#{package_task.package_dir_path}" => EIMXML_DIR do |t|
-	cp "#{EIMXML_DIR}/lib/eim_xml.rb", "#{t.name}/lib/"
-end
+task :default => :spec
+task "spec:no_here" => "spec:apart"
+task :all => [:spec, "spec:symbols"]

data/Rakefile.utirake

@@ -0,0 +1,374 @@
+# Utility for Rake
+#
+# Copyright (C) 2008, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL3.
+
+require "rake/clean"
+require "rake/testtask"
+require "rdoc/task"
+require "rake/contrib/rubyforgepublisher"
+require "rubygems/package_task"
+
+class UtiRake
+	include Rake::DSL
+
+	def self.setup(opt={}, &proc)
+		ur = new
+		ur.setup(opt, &proc)
+	rescue
+		puts $!.class, $!.message, $!.backtrace
+	end
+
+	attr_reader :opt, :spec_proc, :cucumber_proc, :rdoc_proc, :gemspec_proc, :package_proc, :rcov_spec_proc
+
+	def setup(opt={}, &proc)
+		@opt = opt
+		directory "external"
+		CLEAN << "coverage" << "coverage.spec" << "coverage.cuke" << "doc"
+		CLOBBER << "external"
+
+		instance_eval(&proc) if proc
+
+		if need_spec?
+			begin
+				@rspec2_flg = false
+				require "rspec/core/rake_task"
+				@rspec2_flg = true
+			rescue LoadError
+				require "spec/rake/spectask"
+			end
+			define_spec_task
+		end
+
+		if need_cucumber?
+			require "cucumber/rake/task"
+			define_cucumber_task
+		end
+
+		define_rdoc_task
+		define_rcov_task
+		define_package_task
+		define_here_dependency
+		define_alias_task if @alias_task
+	end
+
+	def rspec2?; @rspec2_flg; end
+
+	def spec_task
+		rspec2? ? RSpec::Core::RakeTask : Spec::Rake::SpecTask
+	end
+
+	def need_spec?
+		File.directory?("spec")
+	end
+
+	def need_cucumber?
+		File.directory?("features")
+	end
+
+	def spec(&proc)
+		@spec_proc = proc
+	end
+
+	def cucumber(&proc)
+		@cucumber_proc = proc
+	end
+
+	def rdoc(&proc)
+		@rdoc_proc = proc
+	end
+
+	def gemspec(&proc)
+		@gemspec_proc = proc
+	end
+
+	def rcov_spec(&proc)
+		@rcov_spec_proc = proc
+	end
+
+	def package(&proc)
+		@package_proc = proc
+	end
+
+	def no_here(task)
+		@no_here_task = task
+	end
+
+	def no_here_task
+		@no_here_task || "spec:lump"
+	end
+
+	def alias_task
+		@alias_task = true
+	end
+
+	def hg(cmd)
+		sh "hg #{cmd.to_s}"
+	end
+
+	def external(base_url, *libs)
+		libs = libs.first if libs.first.is_a?(Array)
+		namespace :external do
+			directory "external/lib"
+			libs.each do |lib|
+				libdir = "external/#{lib}"
+				file libdir => "external/lib" do
+					if File.exist?("../#{lib}")
+						Dir.chdir("external") do
+							ln_s "../../#{lib}", "./", :force=>true
+						end
+					end
+					hg "clone #{File.join(base_url, lib)} #{libdir}" unless File.exist?(libdir)
+					Dir["#{libdir}/lib/*"].each do |f|
+						base = File.basename(f)
+						cd "external/lib" do
+							ln_s "../#{lib}/lib/#{base}", "./"
+						end
+					end
+				end
+
+				if File.exist?(libdir)
+					Dir["#{libdir}/lib/*"].each do |f|
+						base = File.basename(f)
+						file "external/lib/#{base}" => "external/lib" do
+							cd "external/lib" do
+								ln_s "../#{lib}/lib/#{base}", "./"
+							end
+						end
+						task :setup => "external/lib/#{base}"
+					end
+				end
+
+				desc "Setup external libraries"
+				task :setup=>libdir
+			end
+
+			task :rake => :setup do
+				libs.each do |lib|
+					Dir.chdir "external/#{lib}" do
+						sh "rake"
+					end
+				end
+			end
+		end
+		@external = true
+	end
+
+	def external?; @external; end
+
+	def define_rdoc_task
+		Rake::RDocTask.new(:rdoc) do |rdoc|
+			rdoc.options << "-S"
+			rdoc.options << "-w" << "3"
+			rdoc.options << "-c" << "UTF-8"
+			rdoc.rdoc_files.include("lib/**/*.rb")
+			rdoc_proc.call(rdoc) if rdoc_proc
+		end
+		task :doc do
+			remove_entry_secure "doc" if File.directory?("doc")
+			sh "rdoc -S -w 3 -c UTF-8 -d -x external"
+		end
+	end
+
+	def define_package_task
+		spec = Gem::Specification.new do |s|
+			s.platform = Gem::Platform::RUBY
+			s.files = FileList["Rakefile*", "lib/**/*", "spec/**/*"]
+			s.version = "0.0.0.noversion"
+			gemspec_proc.call(s) if gemspec_proc
+		end
+
+		gem = Gem::PackageTask.new(spec) do |t|
+			t.need_tar_gz = true
+			package_proc.call(t) if package_proc
+		end
+
+		task "utirake:copy_for_package" do
+			mv "Rakefile.utirake", "Rakefile.utirake_#{$$}"
+			cp "external/utirake/utirake.rb", "Rakefile.utirake"
+		end
+
+		file gem.package_dir_path => "utirake:copy_for_package"
+
+		task :gem do
+			rm "Rakefile.utirake"
+			mv "Rakefile.utirake_#{$$}", "Rakefile.utirake"
+		end
+	end
+
+	def publish(project_name, user_id)
+		task :publish => "rdoc" do
+			yield if block_given?
+			Rake::RubyForgePublisher.new(project_name, user_id).upload
+		end
+	end
+
+	FILE_SORT = lambda{|a, b| File.mtime(a)<=>File.mtime(b)}
+
+	def spec_files
+		@spec_files ||= FileList["./spec/**/*_spec.rb"].sort(&FILE_SORT).reverse
+	end
+
+	def set_spec_opts(spec)
+		spec.verbose = false
+		if rspec2?
+			spec.rspec_opts ||= []
+			spec.rspec_opts << "-c"
+			spec.rspec_opts << "-I" << "." << "-I" << "./lib" << "-I" << "./external/lib"
+		else
+			spec.spec_opts << "-c"
+			spec.libs << "." << "./lib" << "./external/lib"
+		end
+	end
+
+	def define_spec_task
+		task :spec => "spec:apart"
+		namespace :spec do
+			spec_files.each do |f|
+				desc ""
+				spec_task.new(:apart) do |s|
+					if rspec2?
+						s.pattern = f
+					else
+						s.spec_files = FileList[f]
+					end
+					set_spec_opts(s)
+					spec_proc.call(s) if spec_proc
+				end
+			end
+			task(:apart).comment = "Run all specs separately"
+
+			desc "Run all specs in a lump"
+			spec_task.new(:lump) do |s|
+				s.spec_files = spec_files unless rspec2?
+				set_spec_opts(s)
+				spec_proc.call(s) if spec_proc
+			end
+
+			desc "Run all specs to profile"
+			spec_task.new(:profile) do |s|
+				set_spec_opts(s)
+				if rspec2?
+					s.rspec_opts << "-p"
+				else
+					s.spec_opts << "-f" << "profile"
+				end
+			end
+
+			`grep -sRn '#[[:space:]]*here\\([[:space:]]\\|$\\)' --include='*.rb' spec`.split(/\n/).map{|l|
+				next nil unless l=~/\A(.*?):(\d+):/
+				[$1, $2.to_i]
+			}.compact.sort{|a, b| FILE_SORT.call(a[0], b[0])}.reverse.each do |file, line|
+				desc ""
+				spec_task.new(:here) do |s|
+					set_spec_opts(s)
+					if rspec2?
+						s.pattern = file
+						s.rspec_opts << "-l#{line}"
+					else
+						s.spec_files = [file]
+						s.spec_opts << "-l#{line}"
+					end
+					spec_proc.call(s) if spec_proc
+				end
+			end
+			task :no_here => no_here_task
+		end
+	end
+
+	def set_cucumber_opts(task)
+		task.libs << "."
+		cucumber_proc.call(task) if cucumber_proc
+	end
+
+	def define_cucumber_task
+		Cucumber::Rake::Task.new do |t|
+			set_cucumber_opts(t)
+		end
+
+		unless `grep -sRn '^[[:space:]]*@here$' features`.empty?
+			Cucumber::Rake::Task.new("cucumber:here") do |t|
+				t.cucumber_opts = %w[--tags @here]
+				set_cucumber_opts(t)
+			end
+		end
+		task "cucumber:no_here" => :cucumber
+	end
+
+	def define_here_dependency
+		unless Rake::Task.task_defined?("spec:here") || Rake::Task.task_defined?("cucumber:here")
+			task "spec:here" => "spec:no_here" if need_spec? && !Rake::Task.task_defined?("spec:here")
+			task "cucumber:here" => "cucumber:no_here" if need_cucumber? && !Rake::Task.task_defined?("cucumber:here")
+		end
+
+		task("spec:here").comment = "Run spec only marked '# here'"
+		task("cucumber:here").comment = "only tagged '@here'"
+	end
+
+	def rcov_opts(t, aggregation)
+		t.rcov_opts ||= []
+		t.rcov_opts << "-I" << "./spec:./lib:./external/lib"
+		t.rcov_opts << "--exclude" << "gems\/,features\/,external\/"
+		t.rcov_opts << "--aggregate" << "coverage.data" if aggregation
+		t.rcov = true
+	end
+
+	def define_rcov_each_task(aggregation)
+		if need_spec?
+			spec_task.new do |t|
+				t.verbose = false
+				rcov_opts(t, aggregation)
+				if rspec2?
+					t.rcov_opts << "-o" << "coverage.spec" unless aggregation
+				else
+					set_spec_opts(t)
+					t.spec_files = spec_files
+					t.rcov_dir = "coverage.spec" unless aggregation
+				end
+				rcov_spec_proc.call(t) if rcov_spec_proc
+			end
+		else
+			task "spec"
+		end
+
+		if need_cucumber?
+			Cucumber::Rake::Task.new do |t|
+				set_cucumber_opts(t)
+				rcov_opts(t, aggregation)
+				t.rcov_opts << "-o" << "coverage.cuke" unless aggregation
+			end
+		else
+			task "cucumber"
+		end
+	end
+
+	def define_rcov_task
+		namespace :rcov do
+			define_rcov_each_task(false)
+		end
+
+		desc "Run specs and Cucumber using RCov"
+		task "rcov:lump" do
+			rm "coverage.data" if File.exist?("coverage.data")
+			ns = namespace do
+				define_rcov_each_task(true)
+			end
+			ns.tasks.each do |t|
+				t.invoke
+			end
+			rm "coverage.data"
+		end
+
+		task "rcov:all" => %w[rcov:spec rcov:cucumber rcov:lump]
+	end
+
+	def define_alias_task
+		if Rake::Task.task_defined?("spec:apart")
+			task :apart => "spec:apart"
+			task :lump => "spec:lump"
+			task :here => "spec:here"
+			task :profile => "spec:profile"
+		end
+		task :here => "cucumber:here" if Rake::Task.task_defined?("cucumber:here")
+	end
+end