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

eimxml 0.0.1 → 0.0.2

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