RubyGems - eimxml - Versions diffs - 0.0.1 - Mend

eimxml 0.0.1

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: []