math_ml 0.9

data/Rakefile

@@ -0,0 +1,49 @@
+load "Rakefile.utirake"
+
+VER = "0.9"
+
+UtiRake.setup do
+	external("https://hg.hinet.mydns.jp", %w[eim_xml])
+
+	rdoc do |t|
+		t.title = "MathML Library"
+		t.main = "README"
+		t.rdoc_files << FileList["lib/**/*.rb", "README"]
+	end
+
+	publish("mathml", "hiraku") do
+		cp "index.html", "html/index.html"
+	end
+
+	gemspec do |s|
+		s.name = "math_ml"
+		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("eim_xml")
+	end
+
+	rcov_spec do |s|
+		s.spec_files << FileList["symbols/**/*_spec.rb"]
+	end
+
+	spec do |s|
+#		s.spec_opts << "-b"
+	end
+	alias_task
+end
+
+namespace :spec do
+	Spec::Rake::SpecTask.new(:symbols) do |s|
+		s.spec_files = FileList["./symbols/**/*_spec.rb"]
+		s.spec_opts << "-c"
+		s.libs << "lib" << "external/lib"
+	end
+end
+
+task :default => :spec
+task "spec:no_here" => "spec:apart"
+task :all => [:spec, "spec:symbols"]

data/Rakefile.utirake

@@ -0,0 +1,334 @@
+# 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 "rake/rdoctask"
+require "rake/gempackagetask"
+require "rake/contrib/rubyforgepublisher"
+require "rubygems/package_task"
+
+class UtiRake
+	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"
+		CLOBBER << "external" << "coverage" << "coverage.spec" << "coverage.cuke" << "doc"
+
+		instance_eval(&proc) if proc
+
+		if need_spec?
+			require "spec/rake/spectask"
+			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 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 = ENV["VER"] || "0.0.0.noversion"
+			gemspec_proc.call(s) if gemspec_proc
+		end
+
+		gem = Gem::PackageTask.new(spec) do |t|
+			t.need_tar_gz = true
+			t.need_zip = true
+			package_proc.call(t) if package_proc
+		end
+
+		task "utirake:gem" do
+			mv "Rakefile.utirake", "Rakefile.utirake_#{$$}"
+			symlink "external/utirake/utirake.rb", "Rakefile.utirake"
+		end
+
+		file "#{gem.package_dir}/#{gem.gem_spec.file_name}" => "utirake:gem"
+
+		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.spec_opts << "-c"
+		spec.libs << "." << "./lib" << "./external/lib"
+	end
+
+	def define_spec_task
+		task :spec => "spec:apart"
+		namespace :spec do
+			spec_files.each do |f|
+				desc ""
+				Spec::Rake::SpecTask.new(:apart) do |s|
+					s.spec_files = FileList[f]
+					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::Rake::SpecTask.new(:lump) do |s|
+				s.spec_files = spec_files
+				set_spec_opts(s)
+				spec_proc.call(s) if spec_proc
+			end
+
+			desc "Run all specs to profile"
+			Spec::Rake::SpecTask.new(:profile) do |s|
+				set_spec_opts(s)
+				s.spec_opts << "-f" << "profile"
+			end
+
+			`grep -sRn '#[[:space:]]*here[[:space:]]*$' 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::Rake::SpecTask.new(:here) do |s|
+					s.spec_files = [file]
+					set_spec_opts(s)
+					s.spec_opts << "-l#{line}"
+					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 << "--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::Rake::SpecTask.new do |t|
+				t.spec_files = spec_files
+				rcov_opts(t, aggregation)
+				set_spec_opts(t)
+				rcov_spec_proc.call(t) if rcov_spec_proc
+				t.rcov_dir = "coverage.spec" unless aggregation
+			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

data/lib/math_ml/element.rb

@@ -0,0 +1,227 @@
+module MathML
+	class Element < XMLElement
+		attr_reader :display_style
+
+		def as_display_style
+			@display_style = true
+			self
+		end
+	end
+
+	module Variant
+		NORMAL = "normal"
+		BOLD = "bold"
+		BOLD_ITALIC = "bold-italic"
+		def variant=(v)
+			self["mathvariant"] = v
+		end
+	end
+
+	module Align
+		CENTER = "center"
+		LEFT = "left"
+		RIGHT = "right"
+	end
+
+	module Line
+		SOLID = "solid"
+		NONE = "none"
+	end
+
+	class Math < XMLElement
+		def initialize(display_style)
+			super("math", "xmlns"=>"http://www.w3.org/1998/Math/MathML")
+			self[:display] = display_style ? "block" : "inline"
+		end
+	end
+
+	class Row < Element
+		def initialize
+			super("mrow")
+		end
+	end
+
+	class None < Element
+		def initialize
+			super("none")
+		end
+	end
+
+	class Space < Element
+		def initialize(width)
+			super("mspace", "width"=>width)
+		end
+	end
+
+	class Fenced < Element
+		attr_reader :open, :close
+
+		def initialize
+			super("mfenced")
+		end
+
+		def open=(o)
+			o = "" if o.to_s=="." || !o
+			o = "{" if o.to_s=="\\{"
+			self[:open] = MathML.pcstring(o, true)
+		end
+
+		def close=(c)
+			c = "" if c.to_s=="." || !c
+			c = "}" if c.to_s=="\\}"
+			self[:close] = MathML.pcstring(c, true)
+		end
+	end
+
+	class Frac < Element
+		def initialize(numerator, denominator)
+			super("mfrac")
+			self << numerator
+			self << denominator
+		end
+	end
+
+	class SubSup < Element
+		attr_reader :sub, :sup, :body
+
+		def initialize(display_style, body)
+			super("mrow")
+			as_display_style if display_style
+			@body = body
+		end
+
+		def update_name
+			if @sub || @sup
+				name = "m"
+				name << (@sub ? (@display_style ? "under" : "sub") : "")
+				name << (@sup ? (@display_style ? "over" : "sup") : "")
+			else
+				name = "mrow"
+			end
+			self.name = name
+		end
+		private :update_name
+
+		def update_contents
+			contents.clear
+			contents << @body
+			contents << @sub if @sub
+			contents << @sup if @sup
+		end
+		private :update_contents
+
+		def update
+			update_name
+			update_contents
+		end
+		private :update
+
+		def sub=(sub)
+			@sub = sub
+			update
+		end
+
+		def sup=(sup)
+			@sup = sup
+			update
+		end
+	end
+
+	class Over < Element
+		def initialize(base, over)
+			super("mover")
+			self << base << over
+		end
+	end
+
+	class Under < Element
+		def initialize(base, under)
+			super("munder")
+			self << base << under
+		end
+	end
+
+	class Number < Element
+		def initialize
+			super("mn")
+		end
+	end
+
+	class Identifier < Element
+		def initialize
+			super("mi")
+		end
+	end
+
+	class Operator < Element
+		def initialize
+			super("mo")
+		end
+	end
+
+	class Text < Element
+		def initialize
+			super("mtext")
+		end
+	end
+
+	class Sqrt < Element
+		def initialize
+			super("msqrt")
+		end
+	end
+
+	class Root < Element
+		def initialize(index, base)
+			super("mroot")
+			self << base
+			self << index
+		end
+	end
+
+	class Table < Element
+		def initialize
+			super("mtable")
+		end
+
+		def set_align_attribute(name, a, default)
+			if a.is_a?(Array) && a.size>0
+				value = ""
+				a.each do |i|
+					value << " "+i
+				end
+				if value =~ /^( #{default})*$/
+					@attributes.delete(name)
+				else
+					@attributes[name] = value.strip
+				end
+			else
+				@attributes.delete(name)
+			end
+		end
+
+		def aligns=(a)
+			set_align_attribute("columnalign", a, Align::CENTER)
+		end
+
+		def vlines=(a)
+			set_align_attribute("columnlines", a, Line::NONE)
+		end
+
+		def hlines=(a)
+			set_align_attribute("rowlines", a, Line::NONE)
+		end
+	end
+
+	class Tr < Element
+		def initialize
+			super("mtr")
+		end
+	end
+
+	class Td < Element
+		def initialize
+			super("mtd")
+		end
+	end
+end