eim_xml 0.0.3

data/Rakefile

@@ -0,0 +1,23 @@
+load "Rakefile.utirake"
+UtiRake.setup do
+	rdoc do |t|
+		t.title = "Easy IMplemented XML"
+		t.main = "README"
+		t.rdoc_files.include(FileList["lib/**/*.rb", "README"])
+	end
+
+	gemspec do |s|
+		s.name = "eim_xml"
+		s.summary = "Easy IMplemented XML"
+		s.author = "KURODA Hiraku"
+		s.email = "hiraku@hinet.mydns.jp"
+		s.homepage = "http://eimxml.rubyforge.org/"
+		s.rubyforge_project = "eimxml"
+	end
+
+	publish("eimxml", "hiraku")
+
+	alias_task
+end
+
+task :default => :spec

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/eim_xml/assertions.rb

@@ -0,0 +1,16 @@
+require "eim_xml"
+
+module EimXML::Assertions
+	def assert_has(expect, element, message="")
+		message << "\n" unless message.size==0
+		message << "<#{element}> doesn't have\n<#{expect.inspect}>"
+		assert_block(message) do
+			element.has?(expect)
+		end
+	rescue Test::Unit::AssertionFailedError=>e
+		bt = e.backtrace.find_all do |b|
+			b !~ /#{Regexp.escape(__FILE__)}/
+		end
+		raise Test::Unit::AssertionFailedError, e.message, bt
+	end
+end

data/lib/eim_xml/dsl.rb

@@ -0,0 +1,105 @@
+# Easy IMplementation of XML
+#
+# Copyright (C) 2006,2008, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+#
+
+require "eim_xml"
+
+module EimXML
+	class BaseDSL
+		def add(v)
+			@_container << v
+		end
+		alias << add
+
+		def import_variables(src)
+			src.instance_variables.each do |v|
+				instance_variable_set(v, src.instance_variable_get(v)) unless v=~/\A@_[^_]/
+			end
+			self
+		end
+
+		def _build(klass, *arg, &proc)
+			e = klass.new(*arg)
+			@_container << e if @_container
+			if proc
+				oc = @_container
+				@_container = e
+				begin
+					instance_eval(&proc)
+				ensure
+					@_container = oc
+				end
+			end
+			e
+		end
+		private :_build
+
+		def _push(container)
+			oc = @_container
+			@_container = container
+			begin
+				yield if block_given?
+				container
+			ensure
+				@_container = oc
+			end
+		end
+		private :_push
+
+		def self.register(*args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				eval("def #{name}(*a, &p);_build(#{klass}, *a, &p);end", binding)
+				eval("def self.#{name}(*a, &p);new.#{name}(*a, &p);end", binding)
+			end
+		end
+	end
+
+	class DSL < BaseDSL
+	end
+
+	class OpenDSL
+		def _build(klass, *arg, &proc)
+			e = klass.new(*arg)
+			oc = @_container
+			oc << e if oc.is_a?(Element)
+			@_container = e
+			begin
+				proc.call(self) if proc
+				e
+			ensure
+				@_container = oc
+			end
+		end
+		private :_build
+
+		def self.register_base(dsl, binding, *args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				eval("def #{name}(*a, &p);_build(#{klass}, *a, &p);end", binding)
+				eval("def self.#{name}(*a, &p);self.new.#{name}(*a, &p);end", binding)
+			end
+		end
+
+		def self.register(*args)
+			register_base(self, binding, *args)
+		end
+
+		def initialize
+			@_container = nil
+			yield(self) if block_given?
+		end
+
+		def add(v)
+			@_container.add(v)
+		end
+		alias :<< :add
+
+		def container; @_container; end
+	end
+
+	DSL.register Element, Comment
+	OpenDSL.register Element, Comment
+end

data/lib/eim_xml/formatter.rb

@@ -0,0 +1,112 @@
+require "eim_xml"
+
+module EimXML
+	class Formatter
+		attr_reader :out
+
+		def self.write(element, opt={})
+			opt = {:out=>""}.merge(opt)
+			new(opt).write(element)
+			opt[:out]
+		end
+
+		def initialize(opt)
+			@out = opt[:out]
+			@preservers = opt[:preservers]
+			@preserve_space = false
+			@indent_string = "  "
+			@indent_depth = 0
+		end
+
+		def write(src)
+			case src
+			when Comment
+				write_comment(src)
+			when Element
+				write_element(src)
+			when PCString
+				write_pcstring(src)
+			else
+				write_string(src)
+			end
+		end
+
+		def indent(&proc)
+			@indent_depth += 1
+			proc.call
+		ensure
+			@indent_depth -= 1
+		end
+
+		def preserve_space_element?(elm)
+			@preservers && @preservers.any? do |e|
+				case e
+				when Symbol
+					e==elm.name
+				when Class
+					e===elm
+				end
+			end
+		end
+
+		def write_indent
+			out << @indent_string*@indent_depth unless @preserve_space
+		end
+
+		def write_newline
+			out << "\n" unless @preserve_space
+		end
+
+		def write_comment(c)
+			write_indent
+			c.write_to(out)
+			write_newline
+		end
+
+		def write_contents_of(elm)
+			flag = @preserve_space
+			@preserve_space = true if preserve_space_element?(elm)
+			write_newline
+			indent do
+				elm.contents.each do |c|
+					write(c)
+				end
+			end
+			write_indent
+		ensure
+			@preserve_space = flag
+		end
+
+		def write_element(elm)
+			write_indent
+			out << "<"
+			elm.name_and_attributes(out)
+			case elm.contents.size
+			when 0
+				out << " />"
+				write_newline
+			else
+				out << ">"
+				write_contents_of(elm)
+				out << "</#{elm.name}>"
+				write_newline
+			end
+		end
+
+		def write_pcstring(pcs)
+			pcs.encoded_string.each_line do |l|
+				write_indent
+				out << l
+			end
+			write_newline
+		end
+
+		def write_string(str)
+			PCString.encode(str).each_line do |l|
+				write_indent
+				out << l
+			end
+			write_newline
+		end
+	end
+end

data/lib/eim_xml/matcher.rb

@@ -0,0 +1,25 @@
+require "eim_xml"
+module EimXML::Matchers
+	class HaveContent
+		def initialize(expected)
+			@expected = expected
+		end
+
+		def matches?(target)
+			@target = target
+			@target.has?(@expected)
+		end
+
+		def failure_message
+			"expected #{@target.inspect} must have #{@expected}, but not."
+		end
+
+		def negative_failure_message
+			"expected #{@target.inspect} must not have #{@expected}, but has."
+		end
+	end
+
+	def have(expected)
+		HaveContent.new(expected)
+	end
+end

data/lib/eim_xml/parser.rb

@@ -0,0 +1,87 @@
+# XML parser for EimXML
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+#
+
+require "eim_xml"
+require "strscan"
+
+module EimXML
+	class ParseError < StandardError
+	end
+
+	class Parser
+		attr_reader :scanner
+		module RE
+			EMPTY_ELEMENT = /<([^>]*?)\/>/
+			START_TAG = /<([^>]*?([^\/>]\s*))>/
+			END_TAG = /<\/(\S+?)\s*>/
+			ATTRIBUTE = /\s+([^=\s]+)\s*=\s*('(.*?)'|"(.*?)")/m
+			STRING = /[^<]+/
+		end
+
+		def initialize(src)
+			@scanner = StringScanner.new(src)
+			@scanner.scan(/\s*<\?.*?\?>\s*/)
+		end
+
+		def parse
+			if @scanner.scan(RE::EMPTY_ELEMENT)
+				parse_empty_element
+			elsif @scanner.scan(RE::START_TAG)
+				parse_start_tag
+			elsif @scanner.scan(RE::STRING)
+				parse_string
+			else
+				nil
+			end
+		end
+
+		def parse_tag
+			s = StringScanner.new(@scanner[1])
+			e = Element.new(s.scan(/\S+/))
+			e[s[1]] = s[3] ? s[3] : s[4] while s.scan(RE::ATTRIBUTE)
+			e
+		end
+		protected :parse_tag
+
+		def parse_empty_element
+			parse_tag
+		end
+		protected :parse_empty_element
+
+		def parse_start_tag
+			e = parse_tag
+
+			until @scanner.scan(RE::END_TAG)
+				c = parse
+				raise ParseError.new("Syntax error.") unless c
+				e << c
+			end
+			raise ParseError.new("End tag mismatched.") unless @scanner[1].to_sym==e.name
+			e
+		end
+		protected :parse_start_tag
+
+		def parse_string
+			s = @scanner[0]
+			s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
+				case $1
+				when "amp"
+					"&"
+				when "quot"
+					'"'
+				when "apos"
+					"'"
+				when "lt"
+					"<"
+				when "gt"
+					">"
+				end
+			end
+			PCString.new(s)
+		end
+		protected :parse_string
+	end
+end

data/lib/eim_xml/xhtml/dsl.rb

@@ -0,0 +1,18 @@
+require "eim_xml/dsl"
+require "eim_xml/xhtml"
+
+module EimXML::XHTML
+	class DSL < EimXML::BaseDSL
+	end
+
+	class OpenDSL < EimXML::OpenDSL
+	end
+
+	constants.each do |c|
+		v = const_get(c)
+		if v.is_a?(Class) && /_$/ !~ v.name
+			DSL.register v
+			OpenDSL.register v
+		end
+	end
+end