RubyGems - eimxml - Versions diffs - 0.0.1 - Mend

eimxml 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

data/README ADDED Viewed

@@ -0,0 +1,58 @@
+= Easy IMplemented XML
+:lang:ja
+Easy IMplemented XML(EimXML)は、RubyスクリプトからXMLを作成するためのライブラリです。
+動作が軽くなるように、単純さを心がけて実装しています。
+:lang:en
+Easy IMplemented XML(EimXML) is library to construct XML on Ruby.
+For light weight performance, this library is implemented simply.
+:lang:
+= URLs
+* Document(Japanese)[http://eimxml.rubyforge.org/ja/]
+* Document(English)[http://eimxml.rubyforge.org/en/]
+* MercurialRepository[https://hg.hinet.mydns.jp/eim_xml/]
+= Sample
+:lang:ja
+例えば、次のようなHTMLを作成する場合は
+:lang:en
+For example, to construct html like bellow
+:lang:
+ <html>
+  <head>
+   <title>TITLE</title>
+  </head>
+  <body>
+   <p>Texts...</p>
+  </body>
+ </html>
+:lang:ja
+スクリプトは以下のように記述します。
+:lang:en
+write script like bellow.
+:lang:
+ #!/usr/bin/ruby
+ # require "rubygems"
+ require "eim_xml/xhtml"
+ include EimXML::XHTML
+ html = HTML.new do |html|
+	 html << Head.new do |head|
+		 head << Title.new do |title|
+			 title << "TITLE"
+		 end
+	 end
+	 html << Body.new do |body|
+		 body << P.new do |par|
+			 par << "Text..."
+		 end
+	 end
+ end
+ html.write($stdout, false)

data/Rakefile ADDED Viewed

@@ -0,0 +1,94 @@
+require "rake/clean"
+require "rake/testtask"
+require "rake/rdoctask"
+require "rake/gempackagetask"
+FILES = FileList["**/*"].exclude("pkg", "html")
+task :default => :test
+### 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 = "Easy IMplemented XML"
+		rdoc.options = RDOC_OPTS.dup
+		rdoc.options << "-l" << l unless l.empty?
+		rdoc.rdoc_dir = dir
+		rdoc.rdoc_files.include(RDOC_FILES, RDOC_EXTRAS)
+	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("eimxml", "hiraku").upload
+end
+### Test ###
+task :test => "test:apart"
+namespace :test do
+	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
+		end
+	end
+	task(:apart).comment = "Run tests separately"
+	Rake::TestTask.new(:lump) do |t|
+		t.test_files = FileList["test/*_test.rb"]
+	end
+	task(:lump).comment = "Run all tests in a lump"
+end
+### Build GEM ###
+GEM_DIR = "./pkg"
+directory GEM_DIR
+def build_gem(unstable=false)
+	spec = Gem::Specification.new do |spec|
+		spec.name = "eimxml"
+		spec.rubyforge_project = "eimxml"
+		spec.version = "0.0.1"
+		spec.summary = "Easy IMplemented XML"
+		spec.author = "KURODA Hiraku"
+		spec.email = "hiraku@hinet.mydns.jp"
+		spec.homepage = "http://eimxml.rubyforge.org/"
+		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
+	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
+end
+desc "Build unstable version gem package"
+task "gem:unstable" do
+	build_gem(true)
+end
+### Build package ###
+package_task = Rake::PackageTask.new("eim_xml",ENV["VER"] || :noversion) do |t|
+	t.package_files.include(FILES)
+	t.need_tar_gz = true
+end

data/lib/eim_xml/assertions.rb ADDED Viewed

@@ -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/parser.rb ADDED Viewed

@@ -0,0 +1,99 @@
+# 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, *space_holders)
+			@scanner = StringScanner.new(src)
+			@space_holders = []
+			@space_holder_res = []
+			space_holders.each do |i|
+				if i.is_a?(Regexp)
+					@space_holder_res << i
+				else
+					@space_holders << i.to_sym
+				end
+			end
+		end
+		def parse(hold_space = false)
+			@scanner.scan(/\s+/) unless hold_space
+			if @scanner.scan(RE::EMPTY_ELEMENT)
+				parse_empty_element(hold_space)
+			elsif @scanner.scan(RE::START_TAG)
+				parse_start_tag(hold_space)
+			elsif @scanner.scan(RE::STRING)
+				parse_string(hold_space)
+			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 space_holder?(ename)
+			return true if @space_holders.include?(ename)
+			s = ename.to_s
+			@space_holder_res.each do |re|
+				return true if re=~s
+			end
+			false
+		end
+		def parse_empty_element(hold_space)
+			e = parse_tag
+			hold_space = space_holder?(e.name) unless hold_space
+			e.hold_space if hold_space
+			e
+		end
+		protected :parse_empty_element
+		def parse_start_tag(hold_space)
+			e = parse_tag
+			hold_space = space_holder?(e.name) unless hold_space
+			e.hold_space if hold_space
+			@scanner.scan(/\s*/) unless hold_space
+			until @scanner.scan(RE::END_TAG)
+				c = parse(hold_space)
+				raise ParseError.new("Syntax error.") unless c
+				e << c
+				@scanner.scan(/\s*/) unless hold_space
+			end
+			raise ParseError.new("End tag mismatched.") unless @scanner[1].to_sym==e.name
+			e
+		end
+		protected :parse_start_tag
+		def parse_string(hold_space)
+			s = @scanner[0]
+			s.strip! unless hold_space
+			PCString.new(s)
+		end
+		protected :parse_string
+	end
+end

data/lib/eim_xml.rb ADDED Viewed

@@ -0,0 +1,235 @@
+# Easy IMplementation of XML
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+#
+module EimXML
+	XML_DECLARATION = %[<?xml version="1.0"?>]
+	class PCString
+		attr_reader :encoded_string
+		alias to_s encoded_string
+		def self.encode(s)
+			s.gsub(/&\#?\w+;|[&\"\'<>]/) do |m|
+				case m
+				when /&\#?\w+;/
+					m
+				when "&"
+					"&amp;"
+				when '"'
+					"&quot;"
+				when "'"
+					"&apos;"
+				when "<"
+					"&lt;"
+				when ">"
+					"&gt;"
+				end
+			end
+		end
+		def initialize(s, encoded=false)
+			@encoded_string = encoded ? s : PCString.encode(s)
+		end
+		def ==(other)
+			@encoded_string==other.encoded_string
+		end
+	end
+	class SymbolKeyHash < Hash
+		def initialize(src=nil)
+			case src
+			when self.class
+				super(src)
+			when Hash
+				src.each_key do |k|
+					store(k, src[k])
+				end
+			end
+		end
+		def update(src)
+			src = self.class.new(src) unless src.is_a?(self.class)
+			super(src)
+		end
+		alias :merge! :update
+		def merge(src)
+			super(self.class.new(src))
+		end
+		def store(k, v)
+			super(k.to_sym, v)
+		end
+		alias :[]= :store
+	end
+	class Element
+		attr_reader :name, :attributes, :contents
+		NEST = " "
+		def initialize(name, attributes=nil)
+			@name = name.to_sym
+			@attributes = SymbolKeyHash.new
+			@contents = Array.new
+			@hold_space = false
+			@attributes.update(attributes) if attributes
+			yield(self) if block_given?
+		end
+		def name=(new_name)
+			@name = new_name.to_sym
+		end
+		protected :name=
+		def hold_space
+			@hold_space = true
+			self
+		end
+		def unhold_space
+			@hold_space = false
+			self
+		end
+		def hold_space?
+			@hold_space
+		end
+		def add(v)
+			case v
+			when nil
+			when Element, PCString
+				@contents << v
+			when Array
+				v.each{|i| self.add(i)}
+			else
+				@contents << v.to_s
+			end
+			self
+		end
+		alias << add
+		def write(dst=String.new, level=0, is_head=true)
+			nest = NEST*level
+			head = is_head ? nest : ""
+			lf = @hold_space ? "" : "\n"
+			attributes = ""
+			@attributes.each do |k, v|
+				v = k.to_s unless v
+				attributes << " #{k}='#{PCString===v ? v : PCString.encode(v)}'"
+			end
+			case @contents.size
+			when 0
+				dst << "#{head}<#{@name}#{attributes} />"
+			when 1
+				dst << "#{head}<#{@name}#{attributes}>"
+				write_content_to(dst, @contents[0], level, false)
+				dst << "</#{@name}>"
+			else
+				dst << "#{head}<#{@name}#{attributes}>#{lf}"
+				@contents.each {|i| write_content_to(dst, i, level+1, !@hold_space) << lf}
+				dst << "#{@hold_space ? "" : nest}</#{@name}>"
+			end
+		end
+		def to_s(*args)
+			args.unshift("")
+			write(*args)
+		end
+		alias :inspect :to_s
+		def write_content_to(dst, c, level, is_head)
+			return c.write(dst, level, is_head) if c.is_a?(Element)
+			dst << (is_head ? NEST*level : "") + (c.is_a?(PCString) ? c.to_s : PCString.encode(c))
+		end
+		private :write_content_to
+		def ==(xml)
+			return false unless xml.is_a?(Element)
+			(@name==xml.name && @attributes==xml.attributes && @contents==xml.contents && @hold_space==xml.hold_space?)
+		end
+		def add_attribute(key, value)
+			@attributes[key.to_sym] = value
+		end
+		alias []= add_attribute
+		def [](key)
+			if key.is_a?(Fixnum)
+				@contents[key]
+			else
+				@attributes[key.to_sym]
+			end
+		end
+		def del_attribute(key)
+			@attributes.delete(key.to_sym)
+		end
+		def match?(name, attrs=nil)
+			case name
+			when Module
+				return is_a?(name)
+			when Element
+				return match?(name.name, name.attributes)
+			when Array
+				return match?(name[0], name[1])
+			end
+			if name.is_a?(Regexp)
+				return false unless name=~@name.to_s
+			else
+				return false unless @name==name
+			end
+			(attrs||[]).all? do |k, v|
+				if k.is_a?(Regexp)
+					@attributes.any? do |sk, sv|
+						next false unless k===sk.to_s
+						v===sv
+					end
+				else
+					v===@attributes[k]
+				end
+			end
+		end
+		alias :=~ :match?
+		def has?(name, attrs=nil, find_deep=true)
+			return true if match?(name, attrs)
+			@contents.any? do |i|
+				if i.is_a?(Element)
+					if find_deep
+						i=~[name, attrs] || i.has?(name, attrs, find_deep)
+					else
+						i=~[name, attrs]
+					end
+				else
+					name.is_a?(Module) && i.is_a?(name)
+				end
+			end
+		end
+		def find(name, attrs=nil)
+			r = []
+			r << self if match?(name, attrs)
+			@contents.each do |i|
+				if i.is_a?(Element)
+					r.concat(i.find(name, attrs))
+				else
+					r << i if name.is_a?(Module) && i.is_a?(name)
+				end
+			end
+			r
+		end
+	end
+end

data/test/assertions_test.rb ADDED Viewed

@@ -0,0 +1,29 @@
+# Test for eim_xml/assertions.rb
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+require "test/unit"
+require "eim_xml/assertions"
+class TC_EimXML_Assertions < Test::Unit::TestCase
+	include EimXML
+	include EimXML::Assertions
+	def test_assert_has
+		e = Element.new(:tag) do |e|
+			e <<= Element.new(:sub)
+		end
+		assert_nothing_raised do
+			assert_has(:sub, e)
+		end
+		a = assert_raises(Test::Unit::AssertionFailedError) do
+			assert_has(:no, e)
+		end
+		assert(!a.backtrace.any?{ |i|
+				i=~/eim_xml\/assertions\.rb/
+			})
+	end
+end

data/test/eim_xml_test.rb ADDED Viewed

@@ -0,0 +1,428 @@
+# Test for eim_xml.rb
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+require "test/unit"
+require "eim_xml"
+class TC_PCString < Test::Unit::TestCase
+	include EimXML
+	def test_encode
+		assert_equal("&lt;&gt;&quot;&apos;&amp;", PCString.encode("<>\"'&"))
+		assert_equal("&test;", PCString.encode("&test;"))
+		assert_equal("&\#0ax;", PCString.encode("&#0ax;"))
+		assert_equal("&amp;test", PCString.encode("&test"))
+		assert_equal("&amp;\#0ax", PCString.encode("&#0ax"))
+	end
+	def test_new
+		assert_equal("&amp;", PCString.new("&").encoded_string)
+		assert_equal("&", PCString.new("&", true).encoded_string)
+	end
+	def test_equal
+		p1 = PCString.new("str")
+		p2 = PCString.new("str")
+		assert_equal(p1, p2)
+	end
+end
+class TC_Element < Test::Unit::TestCase
+	include EimXML
+	class Dummy < Element
+		def chgname(name)
+			self.name = name
+		end
+	end
+	def test_name
+		e = Element.new("el")
+		assert_equal(:el, e.name)
+		assert_raises(NoMethodError){e.name="changed"}
+		d = Dummy.new("el1")
+		assert_equal(:el1, d.name)
+		d.chgname(:el2)
+		assert_equal(:el2, d.name)
+		d.chgname("el3")
+		assert_equal(:el3, d.name)
+	end
+	def test_attributes
+		e = Element.new("el", {"a1"=>"v1", "a2"=>"v2", "a3"=>nil})
+		assert_equal(:el, e.name)
+		assert_equal({:a1=>"v1", :a2=>"v2", :a3=>nil}, e.attributes)
+	end
+	def test_bracket
+		e = Element.new(:el, :attr=>"value")
+		e << "test"
+		assert_equal("value", e[:attr])
+		assert_equal("test", e[0])
+	end
+	def test_add_attribute
+		e = Element.new("el")
+		e.add_attribute("key_str", "value1")
+		e.add_attribute(:key_sym, "value2")
+		assert_equal({:key_str=>"value1", :key_sym=>"value2"}, e.attributes)
+		e.add_attribute(:nil, nil)
+		assert_equal({:key_str=>"value1", :key_sym=>"value2", :nil=>nil}, e.attributes)
+	end
+	def test_del_attribute
+		e = Element.new("el", {:a1=>"v1", :a2=>"v2"})
+		e.del_attribute("a1")
+		assert_equal({:a2=>"v2"}, e.attributes)
+		e.del_attribute(:a2)
+		assert_equal({}, e.attributes)
+	end
+	def test_contents
+		sub = Element.new("sub")
+		e = Element.new("el") << "String1" << "String2" << sub
+		assert_equal(["String1", "String2", sub], e.contents)
+	end
+	def test_add
+		e = Element.new("el").add(Element.new("sub"))
+		assert_instance_of(Element, e, "add Element")
+		assert_equal(:el, e.name)
+		e = Element.new("el")
+		e.add(Element.new("sub1"))
+		e.add([Element.new("sub2").add("text"), "string"])
+		assert_equal([Element.new("sub1"), Element.new("sub2").add("text"), "string"], e.contents, "add Array")
+		e = Element.new("el")
+		e.add(nil)
+		assert_equal(0, e.contents.size, "add nil")
+		e = Element.new("el").add(:symbol)
+		assert_equal(["symbol"], e.contents, "add anything(which has to_s)")
+		e = Element.new("super") << Element.new("sub")
+		assert_equal(:super, e.name)
+		assert_equal([Element.new("sub")], e.contents)
+	end
+	def test_write
+		e = Element.new("el")
+		s = String.new
+		assert_equal(s.object_id, e.write(s).object_id)
+		assert_equal("<el />", s)
+		e = Element.new("super")
+		e << Element.new("sub")
+		assert_equal("<super><sub /></super>", e.write)
+		e << Element.new("sub2")
+		assert_equal("<super>\n <sub />\n <sub2 />\n</super>", e.write)
+		assert_equal(" <super>\n  <sub />\n  <sub2 />\n </super>", e.write("", 1))
+		assert_equal("<super>\n  <sub />\n  <sub2 />\n </super>", e.write("", 1, false))
+		s = Element.new("supersuper")
+		s << e
+		assert_equal("<supersuper><super>\n <sub />\n <sub2 />\n</super></supersuper>", s.write)
+		e = Element.new("el") << "str"
+		s = Element.new("sub")
+		s << "inside"
+		e << s
+		assert_equal("<el>\n str\n <sub>inside</sub>\n</el>", e.write)
+		e = Element.new("el")
+		e.attributes["a1"] = "v1"
+		e.attributes["a2"] = "'\"<>&"
+		s = e.write
+		assert_match(/\A<el ([^>]*) \/>\z/, s)
+		assert_match(/a1='v1'/, s)
+		assert_match(/a2='&apos;&quot;&lt;&gt;&amp;'/, s)
+		e = Element.new("el", {"a1"=>nil})
+		assert_equal("<el a1='a1' />", e.write)
+	end
+	def test_spcial_string
+		e = Element.new("el") << "&\"'<>"
+		e << PCString.new("&\"'<>", true)
+		e.attributes["key"] = PCString.new("&\"'<>", true)
+		assert_equal(%[<el key='&\"'<>'>\n &amp;&quot;&apos;&lt;&gt;\n &\"'<>\n</el>], e.to_s)
+	end
+	def test_dup
+		e = Element.new("el")
+		e.attributes["key"] = "value"
+		e << "String"
+		e << "Freeze".freeze
+		s = Element.new("sub")
+		s.attributes["subkey"] = "subvalue"
+		e << s
+		f = e.dup
+		assert_equal(e.attributes.object_id, f.attributes.object_id)
+		assert_equal(e.contents.object_id, f.contents.object_id)
+		assert_equal(e.to_s, f.to_s)
+		e = Element.new("el")
+		e.hold_space
+		f = e.dup
+		assert(f.hold_space?)
+	end
+	def test_clone
+		e = Element.new("el")
+		e.attributes["key"] = "value"
+		e << "String"
+		e << "Freeze".freeze
+		s = Element.new("sub")
+		s.attributes["subkey"] = "subvalue"
+		e << s
+		f = e.clone
+		assert_equal(e.attributes.object_id, f.attributes.object_id)
+		assert_equal(e.contents.object_id, f.contents.object_id)
+		assert_equal(e.to_s, f.to_s)
+		e = Element.new("el")
+		e.hold_space
+		f = e.clone
+		assert(f.hold_space?)
+	end
+	def test_hold_space
+		e = Element.new("el") << "Line1" << "Line2"
+		s = Element.new("sub") << "Sub1" << "Sub2"
+		e << s
+		e.hold_space
+		assert_equal("<el>Line1Line2<sub>\n  Sub1\n  Sub2\n </sub></el>", e.to_s)
+		e.unhold_space
+		assert_equal("<el>\n Line1\n Line2\n <sub>\n  Sub1\n  Sub2\n </sub>\n</el>", e.to_s)
+		e = Element.new("e")
+		assert_equal(e.object_id, e.hold_space.object_id)
+		assert_equal(e.object_id, e.unhold_space.object_id)
+	end
+	def test_equal
+		e1 = Element.new("el")
+		e1.attributes["key"] = "value"
+		s = Element.new("sub")
+		s << "String"
+		e1 << s
+		e2 = e1.dup
+		assert_equal(e1, e2)
+		e3 = Element.new("e")
+		e3.attributes["key"] = "value"
+		s = Element.new("sub")
+		s << "String"
+		e3 << s
+		assert_not_equal(e1, e3)
+		e3 = Element.new("e")
+		e3.attributes["k"] = "value"
+		s = Element.new("sub")
+		s << "String"
+		e3 << s
+		assert_not_equal(e1, e3)
+		e3 = Element.new("e")
+		e3.attributes["key"] = "v"
+		s = Element.new("sub")
+		s << "String"
+		e3 << s
+		assert_not_equal(e1, e3)
+		e3 = Element.new("e")
+		e3.attributes["key"] = "value"
+		s = Element.new("sub")
+		s << "S"
+		e3 << s
+		assert_not_equal(e1, e3)
+		e3 = Element.new("e")
+		e3.attributes["key"] = "value"
+		s = Element.new("s")
+		s << "String"
+		e3 << s
+		assert_not_equal(e1, e3)
+		assert_not_equal(e1, "string")
+	end
+	def test_new_with_block
+		b = nil
+		e = Element.new("base") do |b|
+			b["attr"]="value"
+			b << Element.new("sub")
+		end
+		assert_same(e, b)
+		e2 = Element.new("base", "attr"=>"value")
+		e2 << Element.new("sub")
+		assert_equal(e, e2)
+		e = Element.new("base") do |e|
+			e <<= Element.new("sub1") do |e|
+				e <<= Element.new("sub12")
+			end
+			e <<= Element.new("sub2")
+		end
+		base = Element.new("base")
+		sub1 = Element.new("sub1")
+		sub1 << Element.new("sub12")
+		sub2 = Element.new("sub2")
+		base << sub1  << sub2
+		assert_equal(base, e)
+	end
+	def test_symbol_string_compatible
+		sym = Element.new(:tag, :attr=>"value")
+		str = Element.new("tag", "attr"=>"value")
+		assert_equal(sym.to_s, str.to_s)
+		assert_equal(sym, str)
+	end
+	def test_match
+		e = Element.new(:tag, :attr=>"value")
+		assert(e.match?(:tag))
+		assert(e.match?(:tag, :attr=>"value"))
+		assert(! e.match?(:t))
+		assert(! e.match?(:tag, :attr2=>"value"))
+		assert(! e.match?(:tag, :attr=>"value2"))
+		assert(e.match?(Element.new(:tag)))
+		assert(e.match?(Element.new(:tag, :attr=>"value")))
+		assert(! e.match?(Element.new(:t)))
+		assert(! e.match?(Element.new(:tag, :attr2=>"value")))
+		assert(! e.match?(Element.new(:tag, :attr=>"value2")))
+		assert(e.match?(/ag/))
+		assert(e.match?(/ag/, /tt/=>/al/))
+		assert(! e.match?(/elem/))
+		assert(! e.match?(/tag/, /attr2/=>/val/))
+		assert(! e.match?(/tag/, /attr/=>/v2/))
+		assert(e.match?(:tag, :attr=>/val/))
+		assert(e.match?(/t/, /at/=>"value"))
+		e = Element.new(:tag, :attr1=>"value", :attr2=>"test")
+		assert(e.match?(:tag, /attr/=>"value"))
+		assert(e.match?(:tag, /attr/=>/t/))
+		assert(e.match?(Element))
+		assert(!e.match?(Dummy))
+		assert(!e.match?(String))
+	end
+	def test_match_by_array
+		e = Element.new(:tag, :attr=>"value", :a2=>"v2")
+		assert(e.match?([:tag]))
+		assert(e.match?([:tag, {:attr=>"value"}]))
+		assert(e.match?([:tag, {:attr=>"value", :a2=>"v2"}]))
+		assert(e.match?([/tag/, {/a/=>/v/}]))
+	end
+	def test_match_operator
+		e = Element.new(:tag, :attr=>"value", :a2=>"v2")
+		assert_match(:tag, e)
+		assert_match(Element.new(:tag), e)
+		assert_match([:tag], e)
+		assert_match([:tag, {:attr=>"value"}], e)
+		assert_match(Element.new(:tag, :a2=>"v2"), e)
+		assert_match([/t/, {/a/=>/v/}], e)
+		assert(e !~ :t)
+		assert(e !~ Element.new(:t))
+		assert(e !~ [:t])
+		assert(e !~ [:tag, {:a=>"v"}])
+		assert(e !~ Element.new(:tag, :a=>"v"))
+	end
+	def test_has
+		e = Element.new(:base) do |b|
+			b <<= Element.new(:sub) do |s|
+				s <<= Element.new(:deep) do |d|
+					d << "text"
+				end
+			end
+			b <<= Element.new(:sub, :attr=>"value")
+		end
+		assert(e.has?(:base))
+		assert(e.has?(:sub))
+		assert(e.has?(:sub, :attr=>"value"))
+		assert(!e.has?(:sub, :attr=>"value", :attr2=>""))
+		assert(e.has?(:deep))
+		assert(! e.has?(:deep, {}, false))
+		assert(e.has?(String))
+	end
+	def test_find
+		s1 = Element.new(:sub)
+		d = Element.new(:deep)
+		d << "3rd"
+		s1 << "2nd" << d
+		s2 = Element.new(:sub, :attr=>"value")
+		e = Element.new(:base)
+		e << "1st" << s1 << s2
+		assert_equal([d], e.find(:deep))
+		assert_equal([s1, s2], e.find(:sub))
+		assert_equal([e, s1, d, s2], e.find(//))
+		assert_equal(["1st", "2nd", "3rd"], e.find(String))
+	end
+end
+class TC_SymbolKeyHash < Test::Unit::TestCase
+	SKH = EimXML::SymbolKeyHash
+	def test_new
+		s = SKH.new({"key1"=>"value1", :key2=>"value2"})
+		assert_equal({:key1=>"value1", :key2=>"value2"}, s)
+	end
+	def test_update
+		h = {"key"=>"value"}
+		s = SKH.new
+		s.update(h)
+		assert_equal({:key=>"value"}, s)
+		s2 = SKH.new
+		s2.update(s)
+		assert_equal(s, s2)
+	end
+	def test_merge
+		s = SKH.new
+		s2 = s.merge({"key"=>"value"})
+		assert_equal({}, s)
+		assert_equal({:key=>"value"}, s2)
+	end
+	def test_merge!
+		s = SKH.new
+		s2 = s.merge!({"key"=>"value"})
+		h = {:key=>"value"}
+		assert_equal(h, s)
+		assert_equal(h, s2)
+	end
+	def test_store
+		s = SKH.new
+		s.store(:sym1, "value1")
+		s.store("str1", "value2")
+		s[:sym2] = "value3"
+		s["str2"] = "value4"
+		assert_equal({:sym1=>"value1", :str1=>"value2", :sym2=>"value3", :str2=>"value4"}, s)
+	end
+end

data/test/parser_test.rb ADDED Viewed

@@ -0,0 +1,102 @@
+# Test for eim_xml/parser.rb
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+require "test/unit"
+require "eim_xml/parser"
+class TC_Parser < Test::Unit::TestCase
+	include EimXML
+	def parse(src)
+		Parser.new(src).parse
+	end
+	def test_parse
+		s = " <e /> "
+		assert_equal(Parser.new(s).parse, parse(s))
+	end
+	def test_parse_empty_element
+		assert_equal(Element.new("e"), parse("<e />"))
+		assert_equal(Element.new("e"), parse("<e/>"))
+		assert_equal(Element.new("e", "key"=>"value"), parse(%[<e key="value"/>]))
+		assert_equal(Element.new("e", "key"=>"value"), parse(%[<e key='value'/>]))
+		assert_equal(Element.new("e", "key"=>"value"), parse(%[<e key="value" />]))
+		assert_equal(Element.new("e", "key"=>"value"), parse(%[<e key='value' />]))
+		assert_equal(Element.new("e", "key"=>"value", "key2"=>"value2"), parse(%[<e key="value" key2="value2"/>]))
+		assert_equal(Element.new("e", "key"=>"value", "key2"=>"value2"), parse(%[<e key="value" key2="value2" />]))
+		s = " <e1 /> <e2 /> "
+		p = Parser.new(s)
+		assert_equal(Element.new("e1"), p.parse)
+		assert_equal(Element.new("e2"), p.parse)
+	end
+	def test_parse_nonempty_element
+		assert_equal(Element.new("super") << Element.new("sub"), parse("<super><sub /></super>"))
+		e = assert_raises(ParseError){parse("<el></e>")}
+		assert_equal("End tag mismatched.", e.message)
+		e = assert_raises(ParseError){parse("<el><></el>")}
+		assert_equal("Syntax error.", e.message)
+	end
+	def test_parse_string
+		e = parse("string&amp;")
+		assert_instance_of(PCString, e)
+		assert_equal("string&amp;", e.to_s)
+		e = parse(" string &amp; ")
+		assert_instance_of(PCString, e)
+		assert_equal("string &amp;", e.to_s)
+		e = Element.new("e")
+		e << PCString.new("string")
+		assert_equal(e, parse("<e> string </e>"))
+		assert_equal(e, parse("<e>string</e>"))
+	end
+	def test_hold_space
+		s = "<e> string with space\n</e>"
+		e = Element.new("e")
+		e << PCString.new("string with space", true)
+		assert_equal(e, parse(s))
+		e = Element.new("e").hold_space
+		e << PCString.new(" string with space\n", true)
+		assert_not_equal(e, Parser.new(s).parse)
+		assert_equal(e, Parser.new(s).parse(true))
+		assert_equal(e, Parser.new(s, "dummy", "e").parse)
+		assert_equal(e, Parser.new(s, /dummy/, /e/).parse)
+		assert_equal(e, Parser.new(s, :dummy, :e).parse)
+		assert_equal(e, Parser.new(s, :dummy, /^(.*:)?e$/).parse)
+		s = "<ns:e> string with space\n</ns:e>"
+		e = Element.new("ns:e")
+		e << PCString.new("string with space")
+		assert_equal(e, Parser.new(s).parse)
+		e = Element.new("ns:e").hold_space
+		e << PCString.new(" string with space\n")
+		assert_equal(e, Parser.new(s, /^(.*:)?e$/).parse)
+		s = "<a> string without space <b> string with space <a> string with space 2 </a> </b>  </a>"
+		oa = Element.new("a") << PCString.new("string without space")
+		b = Element.new("b").hold_space
+		b << PCString.new(" string with space ")
+		ia = Element.new("a").hold_space
+		ia << PCString.new(" string with space 2 ")
+		b << ia
+		b << PCString.new(" ")
+		oa << b
+		assert_equal(oa, Parser.new(s, "b").parse)
+		s = "<a><b/></a>"
+		a = Element.new("a").hold_space
+		b = Element.new("b").hold_space
+		a << b
+		assert_equal(a, Parser.new(s, "a").parse)
+	end
+end

data/test/xhtml_test.rb ADDED Viewed

@@ -0,0 +1,138 @@
+# Test for eim_xml/xhtml.rb
+#
+# Copyright (C) 2007, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+require "eim_xml/xhtml"
+require "test/unit"
+class TC_XHTML < Test::Unit::TestCase
+	include EimXML::XHTML
+	Element = EimXML::Element
+	def test_html
+		h = HTML.new(:attr=>"value")
+		assert_equal(Element.new(:html, :attr=>"value"), h)
+		h = HTML.new do |e|
+			e <<= Element.new(:sub)
+		end
+		h2 = HTML.new
+		h2 << Element.new(:sub)
+		assert_equal(h, h2)
+	end
+	def test_html_with_declarations
+		decs = EimXML::XML_DECLARATION + "\n" + DocType::XHTML_MATHML + "\n"
+		h = HTML.new
+		assert_equal(decs + "<html />", h.to_s)
+		h = HTML.new
+		assert_equal("<html />", h.to_s(false))
+		h = HTML.new do |h|
+			h << Body.new do |b|
+				b << "test"
+			end
+		end
+		assert_equal(decs+h.to_s(false), h.to_s)
+		s1 = ""
+		s2 = ""
+		assert_equal(decs+h.write(s1, false), h.write(s2))
+	end
+	def test_head
+		assert_equal(:head, Head.new.name)
+	end
+	def test_title
+		assert_equal(:title, Title.new.name)
+	end
+	def test_body
+		assert_equal(:body, Body.new.name)
+	end
+	def test_pre
+		assert_equal(:pre, Pre.new.name)
+	end
+	def test_form
+		assert_equal(:form, Form.new.name)
+	end
+	def test_hn
+		assert_equal(:h1, Hn.new(1).name)
+		assert_equal(:h6, Hn.new(6).name)
+		assert_raises(ArgumentError){Hn.new(7)}
+		assert_raises(ArgumentError){Hn.new(0)}
+	end
+	def test_p
+		assert_equal(:p, P.new.name)
+	end
+	def test_a
+		assert_equal(:a, A.new.name)
+	end
+	def test_em
+		assert_equal(:em, Em.new.name)
+	end
+	def test_strong
+		assert_equal(:strong, Strong.new.name)
+	end
+	def test_div
+		assert_equal(:div, Div.new.name)
+	end
+	def test_ul
+		assert_equal(:ul, Ul.new.name)
+	end
+	def test_ol
+		assert_equal(:ol, Ol.new.name)
+	end
+	def test_li
+		assert_equal(:li, Li.new.name)
+	end
+	def test_text_area
+		assert_equal(Element.new(:textarea, :name=>"item"), TextArea.new("item"))
+		assert_equal(Element.new(:textarea, :name=>"item"), TextArea.new(:item))
+		assert_equal(Element.new(:textarea, :name=>"item", :class=>"cv"), TextArea.new("item", :class=>"cv"))
+	end
+	def test_input
+		assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"), Input.new(:test, :item, "v"))
+		assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"), Input.new("test", "item", "v"))
+		assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v", :class=>"c"), Input.new(:test, :item, "v", :class=>"c"))
+		assert_equal(Element.new(:input, :type=>"submit", :value=>"v"), Input.new(:submit, nil, "v"))
+		assert_equal(Element.new(:input, :type=>"submit", :name=>"item"), Input.new(:submit, "item", nil))
+	end
+	def test_hidden
+		assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v"), Hidden.new("item", "v"))
+		assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v"), Hidden.new(:item, "v"))
+		assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v", :class=>"c"), Hidden.new(:item, "v", :class=>"c"))
+	end
+	def test_submit
+		assert_equal(Element.new(:input, :type=>"submit"), Submit.new)
+		assert_equal(Element.new(:input, :type=>"submit", :value=>"OK"), Submit.new("OK"))
+		assert_equal(Element.new(:input, :type=>"submit", :value=>"OK", :class=>"c"), Submit.new("OK", :class=>"c"))
+	end
+	def test_text
+		assert_equal(Element.new(:input, :type=>"text", :name=>"item"), Text.new(:item))
+		assert_equal(Element.new(:input, :type=>"text", :name=>"item"), Text.new("item"))
+		assert_equal(Element.new(:input, :type=>"text", :name=>"item", :value=>"txt"), Text.new(:item, "txt"))
+		assert_equal(Element.new(:input, :type=>"text", :name=>"item", :value=>"txt", :class=>"c"), Text.new(:item, "txt", :class=>"c"))
+	end
+end

metadata ADDED Viewed

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+rubygems_version: 0.9.4
+specification_version: 1
+name: eimxml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+date: 2007-10-23 00:00:00 +09:00
+summary: Easy IMplemented XML
+require_paths:
+- lib
+email: hiraku@hinet.mydns.jp
+homepage: http://eimxml.rubyforge.org/
+rubyforge_project: eimxml
+description:
+autorequire:
+default_executable:
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 0.0.0
+  version:
+platform: ruby
+signing_key:
+cert_chain:
+post_install_message:
+authors:
+- KURODA Hiraku
+files:
+- lib
+- test
+- Rakefile
+- README
+- lib/eim_xml.rb
+- lib/eim_xml
+- lib/eim_xml/parser.rb
+- lib/eim_xml/assertions.rb
+- test/assertions_test.rb
+- test/eim_xml_test.rb
+- test/parser_test.rb
+test_files:
+- test/assertions_test.rb
+- test/xhtml_test.rb
+- test/eim_xml_test.rb
+- test/parser_test.rb
+rdoc_options:
+- -S
+- -w
+- "3"
+- -c
+- UTF-8
+- -m
+- README
+extra_rdoc_files:
+- README
+executables: []
+extensions: []
+requirements: []
+dependencies: []