RubyGems - eimxml - Versions diffs - 0.0.1 → 0.0.2 - Mend

eimxml 0.0.1 → 0.0.2

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/Rakefile CHANGED Viewed

@@ -1,9 +1,9 @@
 require "rake/clean"
-require "rake/testtask"
 require "rake/rdoctask"
 require "rake/gempackagetask"
+require "spec/rake/spectask"
-FILES = FileList["**/*"].exclude("pkg", "html")
+FILES = FileList["**/*"].exclude(/^pkg/, /\.html$/)
 task :default => :test
@@ -36,17 +36,25 @@ task :publish => [:clobber_rdoc, "rdoc:ja", "rdoc:en"] do
 end
 ### Test ###
-task :test => "test:apart"
+task :test => "test:lump"
 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
+	def set_spec_options(spec)
+		spec.ruby_opts << "-rtest/unit"
+		spec.spec_opts << "-c"
+		spec.libs << "lib"
+	end
+	TEST_FILES = FileList["test/**/*_test.rb"]
+	TEST_FILES.sort{|a,b| File.mtime(a)<=>File.mtime(b)}.reverse.each do |i|
+		Spec::Rake::SpecTask.new(:apart) do |s|
+			s.spec_files = [i]
+			set_spec_options(s)
 		end
 	end
 	task(:apart).comment = "Run tests separately"
-	Rake::TestTask.new(:lump) do |t|
-		t.test_files = FileList["test/*_test.rb"]
+	Spec::Rake::SpecTask.new(:lump) do |s|
+		s.spec_files = TEST_FILES
+		set_spec_options(s)
 	end
 	task(:lump).comment = "Run all tests in a lump"
 end
@@ -58,7 +66,7 @@ def build_gem(unstable=false)
 	spec = Gem::Specification.new do |spec|
 		spec.name = "eimxml"
 		spec.rubyforge_project = "eimxml"
-		spec.version = "0.0.1"
+		spec.version = ENV["VER"] or raise "Need VER=x.y.z(.?)"
 		spec.summary = "Easy IMplemented XML"
 		spec.author = "KURODA Hiraku"
 		spec.email = "hiraku@hinet.mydns.jp"

data/lib/eim_xml/matcher.rb ADDED Viewed

@@ -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 CHANGED Viewed

@@ -91,7 +91,23 @@ module EimXML
 		def parse_string(hold_space)
 			s = @scanner[0]
-			s.strip! unless hold_space
+			s = s.strip unless hold_space
+			s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
+				case $1
+				when "amp"
+					"&"
+				when "quot"
+					'"'
+				when "apos"
+					"'"
+				when "lt"
+					"<"
+				when "gt"
+					">"
+				else
+					raise "must not happen"
+				end
+			end
 			PCString.new(s)
 		end
 		protected :parse_string

data/lib/eim_xml/xhtml.rb ADDED Viewed

@@ -0,0 +1,125 @@
+require "eim_xml"
+module EimXML::XHTML
+	module DocType
+		XHTML_MATHML = %[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN" "http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd">]
+	end
+	class DSL < EimXML::BaseDSL
+	end
+	class OpenDSL < EimXML::OpenDSL
+	end
+	class Base_ < EimXML::Element
+	end
+	class HTML < Base_
+		attr_accessor :prefix
+		module NameSpace
+			XHTML = "http://www.w3.org/1999/xhtml"
+		end
+		def initialize(attributes=nil)
+			super(:html, attributes)
+		end
+		def to_xml(s="")
+			s << @prefix << "\n" if @prefix
+			super(s)
+		end
+	end
+	class Simple_ < Base_
+		def initialize(attributes=nil)
+			super(self.class.name[/.*::(.*)/, 1].downcase.to_sym, attributes)
+		end
+	end
+	class HEAD < Simple_; end
+	class META < Simple_; end
+	class LINK < Simple_; end
+	class STYLE < Simple_; end
+	class SCRIPT < Simple_; end
+	class TITLE < Simple_; end
+	class BODY < Simple_; end
+	class PRE < Simple_
+		def initialize(attributes=nil)
+			super
+			hold_space
+		end
+	end
+	class FORM < Simple_; end
+	class H1 < Simple_; end
+	class H2 < Simple_; end
+	class H3 < Simple_; end
+	class H4 < Simple_; end
+	class H5 < Simple_; end
+	class H6 < Simple_; end
+	class P < Simple_; end
+	class A < Simple_; end
+	class EM < Simple_; end
+	class STRONG < Simple_; end
+	class DIV < Simple_; end
+	class UL < Simple_; end
+	class OL < Simple_; end
+	class LI < Simple_; end
+	class DL < Simple_; end
+	class DT < Simple_; end
+	class DD < Simple_; end
+	class TABLE < Simple_; end
+	class CAPTION < Simple_; end
+	class TR < Simple_; end
+	class TH < Simple_; end
+	class TD < Simple_; end
+	module Hn
+		def self.new(level, attr=nil, &proc)
+			raise ArgumentError unless 1<=level && level<=6
+			klass = EimXML::XHTML.const_get("H#{level}")
+			klass.new(attr, &proc)
+		end
+	end
+	class TEXTAREA < Base_
+		def initialize(name, opt={})
+			super(:textarea, {:name=>name}.merge(opt))
+		end
+	end
+	class INPUT < Base_
+		def initialize(type, name, value, opt={})
+			attr = {:type=>type}
+			attr[:name]=name if name
+			attr[:value]=value if value
+			super(:input, attr.merge(opt))
+		end
+	end
+	class HIDDEN < INPUT
+		def initialize(name, value, opt={})
+			super(:hidden, name, value, opt)
+		end
+	end
+	class SUBMIT < INPUT
+		def initialize(opt={})
+			opt = opt.dup
+			super(:submit, opt.delete(:name), opt.delete(:value), opt)
+		end
+	end
+	class TEXT < INPUT
+		def initialize(name, value=nil, opt={})
+			super(:text, name, value, opt)
+		end
+	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

data/lib/eim_xml.rb CHANGED Viewed

@@ -7,15 +7,97 @@
 module EimXML
 	XML_DECLARATION = %[<?xml version="1.0"?>]
+	class BaseDSL
+		def initialize
+			@container = nil
+			yield(self) if block_given?
+		end
+		def add(v)
+			@container.add(v)
+		end
+		alias << add
+		def self.register(*args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				l = __LINE__+1
+				src = "def #{name}(*arg, &proc)\n" <<
+					"e = #{klass}.new(*arg)\n" <<
+					"@container << e if @container\n" <<
+					"if proc\n" <<
+					"oc = @container\n" <<
+					"@container = e\n" <<
+					"begin\n" <<
+					"instance_eval(&proc)\n" <<
+					"ensure\n" <<
+					"@container = oc\n" <<
+					"end\n" <<
+					"end\n" <<
+					"e\n" <<
+					"end"
+				eval(src, binding, __FILE__, l)
+				l = __LINE__+1
+				src = "def self.#{name}(*arg, &proc)\n" <<
+					"new.#{name}(*arg, &proc)\n" <<
+					"end"
+				eval(src, binding, __FILE__, l)
+			end
+		end
+	end
+	class DSL < BaseDSL
+	end
+	class OpenDSL
+		def self.register_base(dsl, binding, *args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				src = "def #{name}(*arg)\n" <<
+					"e=#{klass}.new(*arg)\n" <<
+					"oc=@container\n" <<
+					"oc << e if oc.is_a?(Element)\n" <<
+					"@container = e\n" <<
+					"begin\n" <<
+					"yield(self) if block_given?\n" <<
+					"e\n" <<
+					"ensure\n" <<
+					"@container = oc\n" <<
+					"end\n" <<
+					"end\n"
+				eval(src, binding, __FILE__, __LINE__-12)
+				src = "def self.#{name}(*arg, &proc)\n" <<
+					"self.new.#{name}(*arg, &proc)\n" <<
+					"end"
+				eval(src, binding, __FILE__, __LINE__-3)
+			end
+		end
+		def self.register(*args)
+			register_base(self, binding, *args)
+		end
+		attr_reader :container
+		def initialize
+			@container = nil
+			yield(self) if block_given?
+		end
+		def add(v)
+			@container.add(v)
+		end
+		alias :<< :add
+	end
 	class PCString
 		attr_reader :encoded_string
 		alias to_s encoded_string
 		def self.encode(s)
-			s.gsub(/&\#?\w+;|[&\"\'<>]/) do |m|
+			s.gsub(/[&\"\'<>]/) do |m|
 				case m
-				when /&\#?\w+;/
-					m
 				when "&"
 					"&amp;"
 				when '"'
@@ -35,7 +117,11 @@ module EimXML
 		end
 		def ==(other)
-			@encoded_string==other.encoded_string
+			other.is_a?(PCString) ? @encoded_string==other.encoded_string : false
+		end
+		def to_xml(dst=String.new)
+			dst << encoded_string
 		end
 	end
@@ -106,26 +192,26 @@ module EimXML
 		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
+				@contents << v
 			end
 			self
 		end
 		alias << add
-		def write(dst=String.new, level=0, is_head=true)
-			nest = NEST*level
+		def to_xml_with_indent(dst=String.new, nest_level=0, is_head=true)
+			nest_level = -1 if @hold_space
+			hold_space = @hold_space || (nest_level<0)
+			nest = nest_level<0 ? "" : NEST*nest_level
 			head = is_head ? nest : ""
-			lf = @hold_space ? "" : "\n"
+			lf = hold_space ? "" : "\n"
 			attributes = ""
 			@attributes.each do |k, v|
 				v = k.to_s unless v
-				attributes << " #{k}='#{PCString===v ? v : PCString.encode(v)}'"
+				attributes << " #{k}='#{PCString===v ? v : PCString.encode(v.to_s)}'"
 			end
 			case @contents.size
@@ -133,25 +219,36 @@ module EimXML
 				dst << "#{head}<#{@name}#{attributes} />"
 			when 1
 				dst << "#{head}<#{@name}#{attributes}>"
-				write_content_to(dst, @contents[0], level, false)
+				content_to_xml(dst, @contents[0], nest_level, false)
 				dst << "</#{@name}>"
 			else
 				dst << "#{head}<#{@name}#{attributes}>#{lf}"
-				@contents.each {|i| write_content_to(dst, i, level+1, !@hold_space) << lf}
+				@contents.each {|i| content_to_xml(dst, i, nest_level<0 ? -1 : nest_level+1, !hold_space) << lf}
 				dst << "#{@hold_space ? "" : nest}</#{@name}>"
 			end
 		end
-		def to_s(*args)
-			args.unshift("")
-			write(*args)
+		def to_xml(dst=String.new)
+			to_xml_with_indent(dst)
+		end
+		def to_s
+			to_xml
 		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))
+		def content_to_xml(dst, c, nest_level, is_head)
+			case
+			when c.respond_to?(:to_xml_with_indent)
+				c.to_xml_with_indent(dst, nest_level, is_head)
+			when c.respond_to?(:to_xml)
+				dst << (is_head && nest_level>=0 ? NEST*nest_level : "")
+				c.to_xml(dst)
+			else
+				dst << (is_head && nest_level>=0 ? NEST*nest_level : "") << PCString.encode(c.to_s)
+			end
 		end
-		private :write_content_to
+		private :content_to_xml
 		def ==(xml)
 			return false unless xml.is_a?(Element)
@@ -198,7 +295,12 @@ module EimXML
 						v===sv
 					end
 				else
-					v===@attributes[k]
+					ak = @attributes[k]
+					if (ak.is_a?(String) or ak.is_a?(Symbol)) and (v.is_a?(String) or v.is_a?(Symbol))
+						ak.to_s == v.to_s
+					else
+						v===@attributes[k]
+					end
 				end
 			end
 		end
@@ -218,6 +320,7 @@ module EimXML
 				end
 			end
 		end
+		alias has_element? has?
 		def find(name, attrs=nil)
 			r = []
@@ -232,4 +335,7 @@ module EimXML
 			r
 		end
 	end
+	DSL.register Element
+	OpenDSL.register Element
 end

data/test/assertions_test.rb CHANGED Viewed

@@ -6,7 +6,7 @@
 require "test/unit"
 require "eim_xml/assertions"
-class TC_EimXML_Assertions < Test::Unit::TestCase
+class EimXMLAssertionsTest < Test::Unit::TestCase
 	include EimXML
 	include EimXML::Assertions

data/test/eim_xml_test.rb CHANGED Viewed

@@ -5,16 +5,15 @@
 require "test/unit"
 require "eim_xml"
+require "spec"
-class TC_PCString < Test::Unit::TestCase
+class PCStringTest < 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"))
+		assert_equal("&amp;test;", PCString.encode("&test;"))
+		assert_equal("&amp;amp;", PCString.encode("&amp;"))
 	end
 	def test_new
@@ -26,10 +25,16 @@ class TC_PCString < Test::Unit::TestCase
 		p1 = PCString.new("str")
 		p2 = PCString.new("str")
 		assert_equal(p1, p2)
+		assert_not_equal(p1, "str")
+	end
+	def test_to_xml
+		assert_equal("&amp;amp;", PCString.new("&amp;").to_xml)
 	end
 end
-class TC_Element < Test::Unit::TestCase
+class ElementTest < Test::Unit::TestCase
 	include EimXML
 	class Dummy < Element
@@ -102,47 +107,59 @@ class TC_Element < Test::Unit::TestCase
 		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)")
+		assert_equal([:symbol], e.contents, "add anything(which has to_s)")
+		assert_equal("<el>symbol</el>", e.to_xml)
 		e = Element.new("super") << Element.new("sub")
 		assert_equal(:super, e.name)
 		assert_equal([Element.new("sub")], e.contents)
 	end
-	def test_write
+	def test_to_xml_with_indent
 		e = Element.new("el")
 		s = String.new
-		assert_equal(s.object_id, e.write(s).object_id)
+		assert_equal(s.object_id, e.to_xml_with_indent(s).object_id)
 		assert_equal("<el />", s)
 		e = Element.new("super")
 		e << Element.new("sub")
-		assert_equal("<super><sub /></super>", e.write)
+		assert_equal("<super><sub /></super>", e.to_xml_with_indent)
 		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))
+		assert_equal("<super>\n <sub />\n <sub2 />\n</super>", e.to_xml_with_indent)
+		assert_equal(" <super>\n  <sub />\n  <sub2 />\n </super>", e.to_xml_with_indent("", 1))
+		assert_equal("<super>\n  <sub />\n  <sub2 />\n </super>", e.to_xml_with_indent("", 1, false))
 		s = Element.new("supersuper")
 		s << e
-		assert_equal("<supersuper><super>\n <sub />\n <sub2 />\n</super></supersuper>", s.write)
+		assert_equal("<supersuper><super>\n <sub />\n <sub2 />\n</super></supersuper>", s.to_xml_with_indent)
 		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)
+		assert_equal("<el>\n str\n <sub>inside</sub>\n</el>", e.to_xml_with_indent)
 		e = Element.new("el")
 		e.attributes["a1"] = "v1"
 		e.attributes["a2"] = "'\"<>&"
-		s = e.write
+		s = e.to_xml_with_indent
 		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)
+		assert_equal("<el a1='a1' />", e.to_xml_with_indent)
+	end
+	def test_to_xml
+		el = Element.new("el")
+		ex = "<el />"
+		assert_equal(ex, el.to_xml)
+		s = ""
+		r = el.to_xml(s)
+		assert_equal(ex, r)
+		assert_equal(s.object_id, r.object_id)
 	end
 	def test_spcial_string
@@ -197,12 +214,14 @@ class TC_Element < Test::Unit::TestCase
 	def test_hold_space
 		e = Element.new("el") << "Line1" << "Line2"
 		s = Element.new("sub") << "Sub1" << "Sub2"
+		ss = Element.new("subsub") << "ss1" << "ss2"
+		s << ss
 		e << s
 		e.hold_space
-		assert_equal("<el>Line1Line2<sub>\n  Sub1\n  Sub2\n </sub></el>", e.to_s)
+		assert_equal("<el>Line1Line2<sub>Sub1Sub2<subsub>ss1ss2</subsub></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)
+		assert_equal("<el>\n Line1\n Line2\n <sub>\n  Sub1\n  Sub2\n  <subsub>\n   ss1\n   ss2\n  </subsub>\n </sub>\n</el>", e.to_s)
 		e = Element.new("e")
 		assert_equal(e.object_id, e.hold_space.object_id)
@@ -257,12 +276,13 @@ class TC_Element < Test::Unit::TestCase
 	end
 	def test_new_with_block
-		b = nil
+		base = nil
 		e = Element.new("base") do |b|
 			b["attr"]="value"
 			b << Element.new("sub")
+			base = b
 		end
-		assert_same(e, b)
+		assert_same(e, base)
 		e2 = Element.new("base", "attr"=>"value")
 		e2 << Element.new("sub")
 		assert_equal(e, e2)
@@ -319,6 +339,11 @@ class TC_Element < Test::Unit::TestCase
 		assert(e.match?(Element))
 		assert(!e.match?(Dummy))
 		assert(!e.match?(String))
+		e1 = Element.new(:tag, :attr=>:value)
+		e2 = Element.new(:tag, :attr=>"value")
+		assert(e1.match?(e2))
+		assert(e2.match?(e1))
 	end
 	def test_match_by_array
@@ -345,7 +370,7 @@ class TC_Element < Test::Unit::TestCase
 		assert(e !~ Element.new(:tag, :a=>"v"))
 	end
-	def test_has
+	def test_has?
 		e = Element.new(:base) do |b|
 			b <<= Element.new(:sub) do |s|
 				s <<= Element.new(:deep) do |d|
@@ -363,6 +388,42 @@ class TC_Element < Test::Unit::TestCase
 		assert(! e.has?(:deep, {}, false))
 		assert(e.has?(String))
+		e = DSL.element(:base) do
+			element(:sub, :sym=>:v1, "string"=>"v2")
+		end
+		assert(e.has?(Element.new(:sub, :sym=>"v1")))
+		assert(e.has?(Element.new(:sub, "sym"=>"v1")))
+		assert(e.has?(Element.new(:sub, "string"=>:v2)))
+		assert(e.has?(Element.new(:sub, :string=>:v2)))
+	end
+	def test_has_element?
+		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_element?(:base))
+		assert(e.has_element?(:sub))
+		assert(e.has_element?(:sub, :attr=>"value"))
+		assert(!e.has_element?(:sub, :attr=>"value", :attr2=>""))
+		assert(e.has_element?(:deep))
+		assert(! e.has_element?(:deep, {}, false))
+		assert(e.has_element?(String))
+		e = DSL.element(:base) do
+			element(:sub, :sym=>:v1, "string"=>"v2")
+		end
+		assert(e.has_element?(Element.new(:sub, :sym=>"v1")))
+		assert(e.has_element?(Element.new(:sub, "sym"=>"v1")))
+		assert(e.has_element?(Element.new(:sub, "string"=>:v2)))
+		assert(e.has_element?(Element.new(:sub, :string=>:v2)))
 	end
 	def test_find
@@ -382,7 +443,7 @@ class TC_Element < Test::Unit::TestCase
 	end
 end
-class TC_SymbolKeyHash < Test::Unit::TestCase
+class SymbolKeyHashTest < Test::Unit::TestCase
 	SKH = EimXML::SymbolKeyHash
 	def test_new
@@ -426,3 +487,162 @@ class TC_SymbolKeyHash < Test::Unit::TestCase
 		assert_equal({:sym1=>"value1", :str1=>"value2", :sym2=>"value3", :str2=>"value4"}, s)
 	end
 end
+describe EimXML::DSL do
+	it "scope is in instance of EimXML::DSL" do
+		outer = inner = nil
+		e3 = e2 = nil
+		block_executed = false
+		e = EimXML::DSL.element(:out, :k1=>"v1") do
+			outer = self
+			e2 = element(:in, :k2=>"v2") do
+				block_executed = true
+				inner = self
+				e3 = element(:deep)
+			end
+		end
+		block_executed.should == true
+		outer.should be_kind_of(EimXML::DSL)
+		inner.should be_kind_of(EimXML::DSL)
+		outer.object_id.should == inner.object_id
+		e.name.should == :out
+		e[:k1].should == "v1"
+		e[0].name.should == :in
+		e[0][:k2].should == "v2"
+		e[0][0].name.should == :deep
+		e2.object_id.should == e[0].object_id
+		e3.object_id.should == e[0][0].object_id
+	end
+end
+describe "Subclass of EimXML::BaseDSL" do
+	class DSL1 < EimXML::BaseDSL
+		register([EimXML::Element, "call"])
+		register(Hash)
+		register(String, Array, Object)
+	end
+	it "register" do
+		lambda{EimXML::DSL.call(:dummy)}.should raise_error(NoMethodError)
+		lambda{EimXML::BaseDSL.call(:dummy)}.should raise_error(NoMethodError)
+		lambda{DSL1.element(:dummy)}.should raise_error(NoMethodError)
+		DSL1.call(:dummy).should be_kind_of(EimXML::Element)
+		DSL1.hash.should be_kind_of(Hash)
+		DSL1.string.should be_kind_of(String)
+		DSL1.array.should be_kind_of(Array)
+		DSL1.object.should be_kind_of(Object)
+	end
+end
+describe EimXML::OpenDSL do
+	it "scope of block is one of outside" do
+		@scope_checker_variable = 1
+		block_executed = false
+		d = EimXML::OpenDSL.new do |d|
+			block_executed = true
+			d.should be_kind_of(EimXML::OpenDSL)
+			d.container.should be_nil
+			d.element(:base, :key1=>"v1") do
+				@scope_checker_variable.should == 1
+				self.should_not be_kind_of(EimXML::Element)
+				d.container.should be_kind_of(EimXML::Element)
+				d.container.should == EimXML::Element.new(:base, :key1=>"v1")
+				d.element(:sub, :key2=>"v2") do
+					d.container.should be_kind_of(EimXML::Element)
+					d.container.should == EimXML::Element.new(:sub, :key2=>"v2")
+				end
+				d.element(:sub2).should == EimXML::Element.new(:sub2)
+			end
+		end
+		block_executed.should be_true
+	end
+	it "DSL methods return element" do
+		d = EimXML::OpenDSL.new
+		d.container.should be_nil
+		r = d.element(:base, :key1=>"v1") do
+			d.element(:sub, :key2=>"v2")
+		end
+		r.should == EimXML::DSL.element(:base, :key1=>"v1") do
+			element(:sub, :key2=>"v2")
+		end
+	end
+	it "DSL method's block given instance of OpenDSL" do
+		e = EimXML::OpenDSL.new.element(:base) do |d|
+			d.should be_kind_of(EimXML::OpenDSL)
+			d.container.name.should == :base
+			d.element(:sub) do |d2|
+				d2.object_id.should == d.object_id
+			end
+		end
+		e.should == EimXML::DSL.element(:base) do
+			element(:sub)
+		end
+	end
+	it "ensure reset container when error raised" do
+		EimXML::OpenDSL.new do |d|
+			begin
+				d.element(:base) do
+					begin
+						d.element(:sub) do
+							raise "OK"
+						end
+					rescue RuntimeError => e
+						raise unless e.message=="OK"
+						d.container.name.should == :base
+						raise
+					end
+				end
+			rescue RuntimeError => e
+				raise unless e.message=="OK"
+				d.container.should == nil
+			end
+		end
+	end
+	it "respond to add" do
+		r = EimXML::OpenDSL.new.element(:base) do |d|
+			d.add "text"
+			d.element(:sub) do
+				s = EimXML::Element.new(:sub)
+				s.add("sub text")
+				d.add("sub text").should == s
+			end
+		end
+		r.should == EimXML::DSL.element(:base) do
+			add "text"
+			element(:sub) do
+				add "sub text"
+			end
+		end
+	end
+	it "respond to <<" do
+		r = EimXML::OpenDSL.new.element(:base) do |d|
+			b = EimXML::Element.new(:base)
+			b << "text" << "next"
+			(d << "text" << "next").should == b
+		end
+		r.should == EimXML::DSL.element(:base) do
+			add "text"
+			add "next"
+		end
+	end
+	it "can call directly element method" do
+		r = EimXML::OpenDSL.element(:base) do |d|
+			d.element(:sub)
+			d.element(:sub2)
+		end
+		r.should == EimXML::DSL.element(:base) do
+			element(:sub)
+			element(:sub2)
+		end
+	end
+end

data/test/parser_test.rb CHANGED Viewed

@@ -6,7 +6,7 @@
 require "test/unit"
 require "eim_xml/parser"
-class TC_Parser < Test::Unit::TestCase
+class ParserTest < Test::Unit::TestCase
 	include EimXML
 	def parse(src)

data/test/xhtml_test.rb CHANGED Viewed

@@ -4,12 +4,23 @@
 # You can redistribute it and/or modify it under GPL2.
 require "eim_xml/xhtml"
+require "eim_xml/assertions"
 require "test/unit"
+require "stringio"
-class TC_XHTML < Test::Unit::TestCase
+class XHTMLTest < Test::Unit::TestCase
 	include EimXML::XHTML
+	include EimXML::Assertions
 	Element = EimXML::Element
+	def test_base_
+		assert_raise(NoMethodError){DSL.base_}
+	end
+	def setup
+		@od = OpenDSL.new
+	end
 	def test_html
 		h = HTML.new(:attr=>"value")
 		assert_equal(Element.new(:html, :attr=>"value"), h)
@@ -20,119 +31,310 @@ class TC_XHTML < Test::Unit::TestCase
 		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)
+		assert_raise(NoMethodError){EimXML::DSL.html}
+		assert_match(HTML.new(:key=>"v"), DSL.html(:key=>"v"))
+		@od.html(:key=>"v").should == HTML.new(:key=>"v")
 		h = HTML.new
-		assert_equal("<html />", h.to_s(false))
+		h.to_xml.should == "<html />"
+		h.prefix='<?xml version="1.0"?>'
+		h.to_xml.should == %[<?xml version="1.0"?>\n<html />]
+	end
-		h = HTML.new do |h|
-			h << Body.new do |b|
-				b << "test"
-			end
-		end
+	def test_head
+		assert_equal(:head, HEAD.new.name)
+		assert_kind_of(HEAD, DSL.head)
+		@od.head.should be_kind_of(HEAD)
+	end
-		assert_equal(decs+h.to_s(false), h.to_s)
+	def test_meta
+		assert_equal(:meta, META.new.name)
+		assert_kind_of(META, DSL.meta)
+		@od.meta.should be_kind_of(META)
+	end
-		s1 = ""
-		s2 = ""
-		assert_equal(decs+h.write(s1, false), h.write(s2))
+	def test_link
+		assert_equal(:link, LINK.new.name)
+		assert_kind_of(LINK, DSL.link)
+		@od.link.should be_kind_of(LINK)
 	end
-	def test_head
-		assert_equal(:head, Head.new.name)
+	def test_style
+		assert_equal(:style, STYLE.new.name)
+		assert_kind_of(STYLE, DSL.style)
+		@od.style.should be_kind_of(STYLE)
+	end
+	def test_script
+		assert_equal(:script, SCRIPT.new.name)
+		assert_kind_of(SCRIPT, DSL.script)
+		@od.script.should be_kind_of(SCRIPT)
 	end
 	def test_title
-		assert_equal(:title, Title.new.name)
+		assert_equal(:title, TITLE.new.name)
+		assert_kind_of(TITLE, DSL.title)
+		@od.title.should be_kind_of(TITLE)
 	end
 	def test_body
-		assert_equal(:body, Body.new.name)
+		assert_equal(:body, BODY.new.name)
+		assert_kind_of(BODY, DSL.body)
+		@od.body.should be_kind_of(BODY)
 	end
 	def test_pre
-		assert_equal(:pre, Pre.new.name)
-	end
-	def test_form
-		assert_equal(:form, Form.new.name)
+		assert_equal(:pre, PRE.new.name)
+		assert_kind_of(PRE, DSL.pre)
+		@od.pre.should be_kind_of(PRE)
+		PRE.new.hold_space?.should be_true
 	end
 	def test_hn
-		assert_equal(:h1, Hn.new(1).name)
-		assert_equal(:h6, Hn.new(6).name)
+		h1 = Hn.new(1)
+		h6 = Hn.new(6)
+		assert_equal(:h1, h1.name)
+		assert_kind_of(H1, h1)
+		assert_equal(:h6, h6.name)
+		assert_kind_of(H6, h6)
 		assert_raises(ArgumentError){Hn.new(7)}
 		assert_raises(ArgumentError){Hn.new(0)}
+		h = Hn.new(1, :key=>:value) do |hn|
+			hn << "test"
+		end
+		assert_equal(:value, h[:key])
+		assert_equal("test", h[0])
+		[
+			[H1, DSL.h1, @od.h1],
+			[H2, DSL.h2, @od.h2],
+			[H3, DSL.h3, @od.h3],
+			[H4, DSL.h4, @od.h4],
+			[H5, DSL.h5, @od.h5],
+			[H6, DSL.h6, @od.h6]
+		].each do |klass, dsl, od|
+			dsl.should be_kind_of(klass)
+			od.should be_kind_of(klass)
+		end
 	end
 	def test_p
 		assert_equal(:p, P.new.name)
+		assert_kind_of(P, DSL.p)
+		@od.p.should be_kind_of(P)
 	end
 	def test_a
 		assert_equal(:a, A.new.name)
+		assert_kind_of(A, DSL.a)
+		@od.a.should be_kind_of(A)
 	end
 	def test_em
-		assert_equal(:em, Em.new.name)
+		assert_equal(:em, EM.new.name)
+		assert_kind_of(EM, DSL.em)
+		@od.em.should be_kind_of(EM)
 	end
 	def test_strong
-		assert_equal(:strong, Strong.new.name)
+		assert_equal(:strong, STRONG.new.name)
+		assert_kind_of(STRONG, DSL.strong)
+		@od.strong.should be_kind_of(STRONG)
 	end
 	def test_div
-		assert_equal(:div, Div.new.name)
+		assert_equal(:div, DIV.new.name)
+		assert_kind_of(DIV, DSL.div)
+		@od.div.should be_kind_of(DIV)
 	end
 	def test_ul
-		assert_equal(:ul, Ul.new.name)
+		assert_equal(:ul, UL.new.name)
+		assert_kind_of(UL, DSL.ul)
+		@od.ul.should be_kind_of(UL)
 	end
 	def test_ol
-		assert_equal(:ol, Ol.new.name)
+		assert_equal(:ol, OL.new.name)
+		assert_kind_of(OL, DSL.ol)
+		@od.ol.should be_kind_of(OL)
 	end
 	def test_li
-		assert_equal(:li, Li.new.name)
+		assert_equal(:li, LI.new.name)
+		assert_kind_of(LI, DSL.li)
+		@od.li.should be_kind_of(LI)
+	end
+	def test_dl
+		DL.new.name.should == :dl
+		DSL.dl.should be_kind_of(DL)
+		@od.dl.should be_kind_of(DL)
+	end
+	def test_dt
+		DT.new.name.should == :dt
+		DSL.dt.should be_kind_of(DT)
+		@od.dt.should be_kind_of(DT)
+	end
+	def test_dd
+		DD.new.name.should == :dd
+		DSL.dd.should be_kind_of(DD)
+		@od.dd.should be_kind_of(DD)
+	end
+	def test_table
+		assert_equal(:table, TABLE.new.name)
+		assert_kind_of(TABLE, DSL.table)
+		@od.table.should be_kind_of(TABLE)
+	end
+	def test_caption
+		assert_equal(:caption, CAPTION.new.name)
+		assert_kind_of(CAPTION, DSL.caption)
+		@od.caption.should be_kind_of(CAPTION)
+	end
+	def test_tr
+		assert_equal(:tr, TR.new.name)
+		assert_kind_of(TR, DSL.tr)
+		@od.tr.should be_kind_of(TR)
+	end
+	def test_th
+		assert_equal(:th, TH.new.name)
+		assert_kind_of(TH, DSL.th)
+		@od.th.should be_kind_of(TH)
+	end
+	def test_td
+		assert_equal(:td, TD.new.name)
+		assert_kind_of(TD, DSL.td)
+		@od.td.should be_kind_of(TD)
+	end
+	def test_form
+		assert_equal(:form, FORM.new.name)
+		assert_kind_of(FORM, DSL.form)
+		@od.form.should be_kind_of(FORM)
 	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"))
+		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"))
+		t = DSL.textarea("t")
+		assert_kind_of(TEXTAREA, t)
+		assert_equal("t", t[:name])
+		t = @od.textarea("t")
+		t.should be_kind_of(TEXTAREA)
+		t[:name].should == "t"
 	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=>: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))
+		i = DSL.input(:dummy, :n, :v)
+		assert_kind_of(INPUT, i)
+		assert_match(INPUT.new(:dummy, :n, :v), i)
-		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))
+		i = @od.input(:dummy, :n, :v)
+		i.should be_kind_of(INPUT)
+		i.should == INPUT.new(:dummy, :n, :v)
 	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"))
+		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"))
+		h = DSL.hidden(:n, :v)
+		assert_kind_of(HIDDEN, h)
+		assert_match(HIDDEN.new(:n, :v), h)
+		h = @od.hidden(:n, :v)
+		h.should be_kind_of(HIDDEN)
+		h.should == HIDDEN.new(:n, :v)
 	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"))
+		assert_equal(Element.new(:input, :type=>:submit), SUBMIT.new)
+		assert_equal(Element.new(:input, :type=>:submit, :value=>"OK"), SUBMIT.new(:value=>"OK"))
+		assert_equal(Element.new(:input, :type=>:submit, :value=>"OK", :class=>"c"), SUBMIT.new(:value=>"OK", :class=>"c"))
+		opt = {:value=>"v", :name=>"n"}
+		opt2 = opt.dup
+		SUBMIT.new(opt2)
+		assert_equal(opt, opt2)
+		s = DSL.submit
+		assert_kind_of(SUBMIT, s)
+		assert_match(SUBMIT.new, s)
+		assert(!s[:name])
+		assert(!s[:value])
+		s = DSL.submit(:name=>:s, :value=>:v)
+		assert_equal(:s, s[:name])
+		assert_equal(:v, s[:value])
+		s = @od.submit
+		s.should be_kind_of(SUBMIT)
+		s.should == SUBMIT.new
+		s[:name].should be_nil
+		s[:value].should be_nil
+		s = @od.submit(:name=>:s, :value=>:v)
+		s.should == SUBMIT.new(:name=>:s, :value=>:v)
 	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"))
+		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"))
+		t = DSL.text(:n, :v)
+		assert_kind_of(TEXT, t)
+		assert_match(TEXT.new(:n, :v), t)
+		t = @od.text(:n, :v)
+		t.should be_kind_of(TEXT)
+		t.should == TEXT.new(:n, :v)
+	end
+end
+describe EimXML::XHTML::OpenDSL do
+	it "replace EimXML::XHTML::DSL" do
+		e = EimXML::XHTML::OpenDSL.html do |d|
+			d.head do
+				d.title.add "Title"
+			end
+			d.body do
+				d.h1.add "Sample"
+				d.p do
+					d.add "text"
+					d.add "next"
+				end
+			end
+		end
+		e.should == EimXML::XHTML::DSL.html do
+			head do
+				title.add "Title"
+			end
+			body do
+				h1.add "Sample"
+				p do
+					add "text"
+					add "next"
+				end
+			end
+		end
 	end
 end

metadata CHANGED Viewed

@@ -1,50 +1,44 @@
 --- !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:
+  version: 0.0.2
 platform: ruby
-signing_key:
-cert_chain:
-post_install_message:
 authors:
 - KURODA Hiraku
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2008-04-14 00:00:00 -04:00
+default_executable:
+dependencies: []
+description:
+email: hiraku@hinet.mydns.jp
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
 files:
 - lib
-- test
-- Rakefile
-- README
 - lib/eim_xml.rb
 - lib/eim_xml
 - lib/eim_xml/parser.rb
+- lib/eim_xml/matcher.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
+- lib/eim_xml/xhtml.rb
+- README
+- Rakefile
+- test
 - test/xhtml_test.rb
 - test/eim_xml_test.rb
+- test/assertions_test.rb
 - test/parser_test.rb
+has_rdoc: true
+homepage: http://eimxml.rubyforge.org/
+post_install_message:
 rdoc_options:
 - -S
 - -w
@@ -53,13 +47,29 @@ rdoc_options:
 - UTF-8
 - -m
 - README
-extra_rdoc_files:
-- README
-executables: []
-extensions: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
 requirements: []
-dependencies: []
+rubyforge_project: eimxml
+rubygems_version: 1.1.1
+signing_key:
+specification_version: 2
+summary: Easy IMplemented XML
+test_files:
+- test/xhtml_test.rb
+- test/eim_xml_test.rb
+- test/assertions_test.rb
+- test/parser_test.rb