RubyGems - eim_xml - Versions diffs - 0.0.4 → 1.0.0 - Mend

eim_xml 0.0.4 → 1.0.0

Files changed (20) hide show

checksums.yaml +7 -0
data/LICENSE +339 -0
data/lib/eim_xml/assertions.rb +14 -14
data/lib/eim_xml/dsl.rb +104 -96
data/lib/eim_xml/formatter/element_wrapper.rb +8 -6
data/lib/eim_xml/formatter.rb +105 -106
data/lib/eim_xml/matcher.rb +23 -20
data/lib/eim_xml/parser.rb +68 -70
data/lib/eim_xml/xhtml/dsl.rb +16 -14
data/lib/eim_xml/xhtml.rb +156 -152
data/lib/eim_xml.rb +202 -202
metadata +31 -61
data/Rakefile +0 -26
data/Rakefile.utirake +0 -374
data/spec/assertions_test.rb +0 -30
data/spec/dsl_spec.rb +0 -217
data/spec/eim_xml_spec.rb +0 -441
data/spec/formatter_spec.rb +0 -260
data/spec/parser_spec.rb +0 -102
data/spec/xhtml_spec.rb +0 -524

data/spec/parser_spec.rb DELETED Viewed

@@ -1,102 +0,0 @@
-require "eim_xml/parser"
-module Module.new::M
-	include EimXML
-	describe Parser do
-		def parse(src)
-			Parser.new(src).parse
-		end
-		it "'parser' method for test" do
-			s = " <e /> "
-			parse(s).should == Parser.new(s).parse
-		end
-		it "#parse with empty element" do
-			parse("<e />").should == Element.new("e")
-			parse("<e/>").should == Element.new("e")
-			parse(%[<e key="value"/>]).should == Element.new("e", :key=>"value")
-			parse(%[<e key='value'/>]).should == Element.new("e", :key=>"value")
-			parse(%[<e key="value" />]).should == Element.new("e", :key=>"value")
-			parse(%[<e key='value' />]).should == Element.new("e", :key=>"value")
-			parse(%[<e key="value" key2="value2"/>]).should == Element.new("e", :key=>"value", :key2=>"value2")
-			parse(%[<e key="value" key2="value2" />]).should == Element.new("e", :key=>"value", :key2=>"value2")
-			s = " <e1 /> <e2 /> "
-			p = Parser.new(s)
-			p.parse.should == PCString.new(" ")
-			p.parse.should == Element.new("e1")
-			p.parse.should == PCString.new(" ")
-			p.parse.should == Element.new("e2")
-		end
-		it "#parse with nonempty element" do
-			parse("<super><sub /></super>").should == Element.new("super") << Element.new("sub")
-			parse("<out><in></in></out>").should == Element.new("out") << Element.new("in")
-			lambda{parse("<el></e>")}.should raise_error(ParseError, "End tag mismatched.")
-			lambda{parse("<el><></el>")}.should raise_error(ParseError, "Syntax error.")
-		end
-		it "#parse with string" do
-			e = parse("string&amp;")
-			e.should be_kind_of(PCString)
-			e.to_s.should == "string&amp;"
-			e = parse(" string &amp; ")
-			e.should be_kind_of(PCString)
-			e.to_s.should == " string &amp; "
-			e = Element.new("e")
-			e << PCString.new(" string ")
-			parse("<e> string </e>").should == e
-			e = Element.new("e")
-			e << PCString.new("string")
-			parse("<e>string</e>").should == e
-		end
-		it "#parse escaped characters" do
-			e = parse("&amp;&quot;&apos;&lt;&gt;")
-			e.to_s.should == "&amp;&quot;&apos;&lt;&gt;"
-			e.src.should == "&\"'<>"
-		end
-		it "#parse with holding space" do
-			s = "<e> string with space\n</e>"
-			e = Element.new("e")
-			e << PCString.new(" string with space\n")
-			parse(s).should == e
-			parse(s).to_s.should == s
-			s = "<ns:e> string with space\n</ns:e>"
-			e = Element.new("ns:e")
-			e << PCString.new(" string with space\n")
-			parse(s).should == e
-			parse(s).to_s.should == s
-			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")
-			b << PCString.new(" string with space ")
-			ia = Element.new("a")
-			ia << PCString.new(" string with space 2 ")
-			b << ia
-			b << PCString.new(" ")
-			oa << b
-			oa << PCString.new("  ")
-			parse(s).should == oa
-			parse(s).to_s.should == s
-			s = "<a><b/></a>"
-			a = Element.new("a")
-			b = Element.new("b")
-			a << b
-			parse(s).should == a
-			parse(s).to_s.should == "<a><b /></a>"
-		end
-	end
-end

data/spec/xhtml_spec.rb DELETED Viewed

@@ -1,524 +0,0 @@
-require "stringio"
-require "eim_xml/xhtml/dsl"
-module Module.new::M
-	include EimXML
-	include EimXML::XHTML
-	XDSL = XHTML::DSL
-	describe XHTML do
-		it "DSL.base_ should raise NoMethodError" do
-			lambda{XDSL.base_}.should raise_error(NoMethodError)
-		end
-		it "HTML" do
-			h = HTML.new(:attr=>"value")
-			h.should == Element.new(:html, :attr=>"value")
-			h = HTML.new do |e|
-				e <<= Element.new(:sub)
-			end
-			h2 = HTML.new
-			h2 << Element.new(:sub)
-			h2.should == h
-			lambda{EimXML::DSL.html}.should raise_error(NoMethodError)
-			XDSL.html(:key=>"v").should == HTML.new(:key=>"v")
-			OpenDSL.html(:key=>"v").should == HTML.new(:key=>"v")
-			h = HTML.new
-			h.write_to.should == "<html />"
-			h.prefix='<?xml version="1.0"?>'
-			h.write_to.should == %[<?xml version="1.0"?>\n<html />]
-		end
-		it "HEAD" do
-			HEAD.new.name.should == :head
-			XDSL.head.should be_kind_of(HEAD)
-			OpenDSL.head.should be_kind_of(HEAD)
-		end
-		it "META" do
-			META.new.name.should == :meta
-			XDSL.meta.should be_kind_of(META)
-			OpenDSL.meta.should be_kind_of(META)
-		end
-		it "LINK" do
-			LINK.new.name.should == :link
-			XDSL.link.should be_kind_of(LINK)
-			OpenDSL.link.should be_kind_of(LINK)
-		end
-		it "STYLE" do
-			STYLE.new.name.should == :style
-			XDSL.style.should be_kind_of(STYLE)
-			OpenDSL.style.should be_kind_of(STYLE)
-		end
-		it "IMG" do
-			IMG.new.name.should == :img
-			XDSL.img.should be_kind_of(IMG)
-			OpenDSL.img.should be_kind_of(IMG)
-		end
-		it "SCRIPT" do
-			SCRIPT.new.name.should == :script
-			XDSL.script.should be_kind_of(SCRIPT)
-			OpenDSL.script.should be_kind_of(SCRIPT)
-		end
-		it "TITLE" do
-			TITLE.new.name.should == :title
-			XDSL.title.should be_kind_of(TITLE)
-			OpenDSL.title.should be_kind_of(TITLE)
-		end
-		it "BODY" do
-			BODY.new.name.should == :body
-			XDSL.body.should be_kind_of(BODY)
-			OpenDSL.body.should be_kind_of(BODY)
-		end
-		it "PRE" do
-			PRE.new.name.should == :pre
-			XDSL.pre.should be_kind_of(PRE)
-			OpenDSL.pre.should be_kind_of(PRE)
-		end
-		it "Hn" do
-			h1 = Hn.new(1)
-			h6 = Hn.new(6)
-			h1.name.should == :h1
-			h1.should be_kind_of(H1)
-			h6.name.should == :h6
-			h6.should be_kind_of(H6)
-			lambda{Hn.new(7)}.should raise_error(ArgumentError)
-			lambda{Hn.new(0)}.should raise_error(ArgumentError)
-			h = Hn.new(1, :key=>:value) do |hn|
-				hn << "test"
-			end
-			h[:key].should == :value
-			h[0].should == "test"
-			[
-				[H1, XDSL.h1, OpenDSL.h1],
-				[H2, XDSL.h2, OpenDSL.h2],
-				[H3, XDSL.h3, OpenDSL.h3],
-				[H4, XDSL.h4, OpenDSL.h4],
-				[H5, XDSL.h5, OpenDSL.h5],
-				[H6, XDSL.h6, OpenDSL.h6]
-			].each do |klass, dsl, od|
-				dsl.should be_kind_of(klass)
-				od.should be_kind_of(klass)
-			end
-		end
-		it "P" do
-			P.new.name.should == :p
-			XDSL.p.should be_kind_of(P)
-			OpenDSL.p.should be_kind_of(P)
-		end
-		it "A" do
-			A.new.name.should == :a
-			XDSL.a.should be_kind_of(A)
-			OpenDSL.a.should be_kind_of(A)
-		end
-		it "EM" do
-			EM.new.name.should == :em
-			XDSL.em.should be_kind_of(EM)
-			OpenDSL.em.should be_kind_of(EM)
-		end
-		it "STRONG" do
-			STRONG.new.name.should == :strong
-			XDSL.strong.should be_kind_of(STRONG)
-			OpenDSL.strong.should be_kind_of(STRONG)
-		end
-		it "DIV" do
-			DIV.new.name.should == :div
-			XDSL.div.should be_kind_of(DIV)
-			OpenDSL.div.should be_kind_of(DIV)
-		end
-		it "SPAN" do
-			SPAN.new.name.should == :span
-			XDSL.span.should be_kind_of(SPAN)
-			OpenDSL.span.should be_kind_of(SPAN)
-		end
-		it "UL" do
-			UL.new.name.should == :ul
-			XDSL.ul.should be_kind_of(UL)
-			OpenDSL.ul.should be_kind_of(UL)
-		end
-		it "OL" do
-			OL.new.name.should == :ol
-			XDSL.ol.should be_kind_of(OL)
-			OpenDSL.ol.should be_kind_of(OL)
-		end
-		it "LI" do
-			LI.new.name.should == :li
-			XDSL.li.should be_kind_of(LI)
-			OpenDSL.li.should be_kind_of(LI)
-		end
-		it "DL" do
-			DL.new.name.should == :dl
-			XDSL.dl.should be_kind_of(DL)
-			OpenDSL.dl.should be_kind_of(DL)
-		end
-		it "DT" do
-			DT.new.name.should == :dt
-			XDSL.dt.should be_kind_of(DT)
-			OpenDSL.dt.should be_kind_of(DT)
-		end
-		it "DD" do
-			DD.new.name.should == :dd
-			XDSL.dd.should be_kind_of(DD)
-			OpenDSL.dd.should be_kind_of(DD)
-		end
-		it "TABLE" do
-			TABLE.new.name.should == :table
-			XDSL.table.should be_kind_of(TABLE)
-			OpenDSL.table.should be_kind_of(TABLE)
-		end
-		it "CAPTION" do
-			CAPTION.new.name.should == :caption
-			XDSL.caption.should be_kind_of(CAPTION)
-			OpenDSL.caption.should be_kind_of(CAPTION)
-		end
-		it "TR" do
-			TR.new.name.should == :tr
-			XDSL.tr.should be_kind_of(TR)
-			OpenDSL.tr.should be_kind_of(TR)
-		end
-		it "TH" do
-			TH.new.name.should == :th
-			XDSL.th.should be_kind_of(TH)
-			OpenDSL.th.should be_kind_of(TH)
-		end
-		it "TD" do
-			TD.new.name.should == :td
-			XDSL.td.should be_kind_of(TD)
-			OpenDSL.td.should be_kind_of(TD)
-		end
-		it "FORM" do
-			FORM.new.name.should == :form
-			XDSL.form.should be_kind_of(FORM)
-			OpenDSL.form.should be_kind_of(FORM)
-			FORM.new.should_not include(HIDDEN)
-		end
-		it "FORM.new should be able to receive CGI::Session object and set random token" do
-			s = mock("session")
-			h = {}
-			s.should_receive(:[]).any_number_of_times{|k| h[k]}
-			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
-			f = FORM.new(:session=>s)
-			h["token"].size.should == 40
-			h["token"].should =~ /\A[0-9a-f]{40}\z/
-			f.should include(HIDDEN.new(:name=>"token", :value=>h["token"]))
-			s = mock("session")
-			h = {}
-			s.should_receive(:[]).any_number_of_times{|k| h[k]}
-			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
-			f = FORM.new(:session=>s, :session_name=>"random_key")
-			h["token"].should be_nil
-			h["random_key"].size.should == 40
-			h["random_key"].should =~ /\A[0-9a-f]{40}\z/
-			f.should include(HIDDEN.new(:name=>"random_key", :value=>h["random_key"]))
-			s = mock("session")
-			h = {}
-			s.should_receive(:[]).any_number_of_times{|k| h[k]}
-			s.should_receive(:[]=).any_number_of_times{|k, v| h[k]=v}
-			FORM.new(:session=>s)
-			token = s["token"]
-			FORM.new(:session=>s).should include(HIDDEN.new(:name=>"token", :value=>token))
-			s["token"].should == token
-		end
-		it "TEXTAREA" do
-			TEXTAREA.new(:name=>"item").should == Element.new(:textarea, :name=>"item")
-			TEXTAREA.new(:name=>:item).should == Element.new(:textarea, :name=>:item)
-			TEXTAREA.new(:name=>"item", :class=>"cv").should == Element.new(:textarea, :name=>"item", :class=>"cv")
-			t = XDSL.textarea(:name=>"t")
-			t.should be_kind_of(TEXTAREA)
-			t[:name].should == "t"
-			t = OpenDSL.textarea(:name=>"t")
-			t.should be_kind_of(TEXTAREA)
-			t[:name].should == "t"
-		end
-		it "BUTTON" do
-			BUTTON.new.should == Element.new(:button)
-		end
-		it "INPUT" do
-			INPUT.new(:type=>:test, :name=>:item, :value=>"v").should == Element.new(:input, :type=>:test, :name=>:item, :value=>"v")
-			INPUT.new(:type=>"test", :name=>"item", :value=>"v").should == Element.new(:input, :type=>"test", :name=>"item", :value=>"v")
-			INPUT.new(:type=>:test, :name=>:item, :value=>"v", :class=>"c").should == Element.new(:input, :type=>:test, :name=>:item, :value=>"v", :class=>"c")
-			INPUT.new(:type=>:submit, :value=>"v").should == Element.new(:input, :type=>:submit, :value=>"v")
-			INPUT.new(:type=>:submit, :name=>"item").should == Element.new(:input, :type=>:submit, :name=>"item")
-			i = XDSL.input(:type=>:dummy, :name=>:n, :value=>:v)
-			i.should be_kind_of(INPUT)
-			i.should =~ INPUT.new(:type=>:dummy, :name=>:n, :value=>:v)
-			i = OpenDSL.input(:type=>:dummy, :name=>:n, :value=>:v)
-			i.should be_kind_of(INPUT)
-			i.should == INPUT.new(:type=>:dummy, :name=>:n, :value=>:v)
-		end
-		it "HIDDEN" do
-			HIDDEN.new(:name=>"item", :value=>"v").should == Element.new(:input, :type=>:hidden, :name=>"item", :value=>"v")
-			HIDDEN.new(:name=>:item, :value=>"v").should == Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v")
-			HIDDEN.new(:name=>:item, :value=>"v", :class=>"c").should == Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v", :class=>"c")
-			h = XDSL.hidden(:name=>:n, :value=>:v)
-			h.should be_kind_of(HIDDEN)
-			h.should =~ HIDDEN.new(:name=>:n, :value=>:v)
-			h = OpenDSL.hidden(:name=>:n, :value=>:v)
-			h.should be_kind_of(HIDDEN)
-			h.should == HIDDEN.new(:name=>:n, :value=>:v)
-		end
-		it "SUBMIT" do
-			SUBMIT.new.should == Element.new(:button, :type=>:submit)
-			SUBMIT.new(:value=>"OK").should == Element.new(:button, :type=>:submit, :value=>"OK")
-			SUBMIT.new(:value=>"OK", :class=>"c").should == Element.new(:button, :type=>:submit, :value=>"OK", :class=>"c")
-			opt = {:value=>"v", :name=>"n"}
-			opt2 = opt.dup
-			SUBMIT.new(opt2)
-			opt2.should == opt
-			s = XDSL.submit
-			s.should be_kind_of(SUBMIT)
-			s.should =~ SUBMIT.new
-			(!s[:name]).should be_true
-			(!s[:value]).should be_true
-			s = XDSL.submit(:name=>:s, :value=>:v)
-			s[:name].should == :s
-			s[:value].should == :v
-			s = OpenDSL.submit
-			s.should be_kind_of(SUBMIT)
-			s.should == SUBMIT.new
-			s[:name].should be_nil
-			s[:value].should be_nil
-			s = OpenDSL.submit(:name=>:s, :value=>:v)
-			s.should == SUBMIT.new(:name=>:s, :value=>:v)
-		end
-		it "TEXT" do
-			TEXT.new(:name=>:item).should == Element.new(:input, :type=>:text, :name=>:item)
-			TEXT.new(:name=>"item").should == Element.new(:input, :type=>:text, :name=>"item")
-			TEXT.new(:name=>:item, :value=>"txt").should == Element.new(:input, :type=>:text, :name=>:item, :value=>"txt")
-			TEXT.new(:name=>:item, :value=>"txt", :class=>"c").should == Element.new(:input, :type=>:text, :name=>:item, :value=>"txt", :class=>"c")
-			t = XDSL.text(:name=>:n, :value=>:v)
-			t.should be_kind_of(TEXT)
-			t.should =~ TEXT.new(:name=>:n, :value=>:v)
-			t = OpenDSL.text(:name=>:n, :value=>:v)
-			t.should be_kind_of(TEXT)
-			t.should == TEXT.new(:name=>:n, :value=>:v)
-		end
-		it "PASSWORD" do
-			PASSWORD.new(:name=>:item).should == Element.new(:input, :type=>:password, :name=>:item)
-			PASSWORD.new(:name=>"item").should == Element.new(:input, :type=>:password, :name=>"item")
-			PASSWORD.new(:name=>:item, :value=>"txt").should == Element.new(:input, :type=>:password, :name=>:item, :value=>"txt")
-			PASSWORD.new(:name=>:item, :value=>"txt", :class=>"c").should == Element.new(:input, :type=>:password, :name=>:item, :value=>"txt", :class=>"c")
-			t = XDSL.password(:name=>:n, :value=>:v)
-			t.should be_kind_of(PASSWORD)
-			t.should =~ PASSWORD.new(:name=>:n, :value=>:v)
-			t = OpenDSL.password(:name=>:n, :value=>:v)
-			t.should be_kind_of(PASSWORD)
-			t.should == PASSWORD.new(:name=>:n, :value=>:v)
-		end
-		it "FILE" do
-			FILE.new(:name=>:foo).should == Element.new(:input, :type=>:file, :name=>:foo)
-			XDSL.file(:name=>:foo).should =~ FILE.new(:name=>:foo)
-			OpenDSL.file(:name=>:foo).should == FILE.new(:name=>:foo)
-		end
-		it "SELECT" do
-			SELECT.new(:name=>:foo).should == Element.new(:select, :name=>:foo)
-			XDSL.select(:name=>:foo).should == SELECT.new(:name=>:foo)
-			OpenDSL.select(:name=>:foo).should == SELECT.new(:name=>:foo)
-		end
-		it "OPTION" do
-			OPTION.new(:value=>:bar, :selected=>true){|e| e << "TEXT"}.should == Element.new(:option, :value=>:bar, :selected=>true){|e| e.add("TEXT")}
-			XDSL.option(:value=>:bar).should == OPTION.new(:value=>:bar)
-			OpenDSL.option(:value=>:bar).should == OPTION.new(:value=>:bar)
-		end
-		it "BR" do
-			BR.new.name.should == :br
-			XDSL.br.should be_kind_of(BR)
-			OpenDSL.br.should be_kind_of(BR)
-		end
-		it "HR" do
-			HR.new.name.should == :hr
-			XDSL.hr.should be_kind_of(HR)
-			OpenDSL.hr.should be_kind_of(HR)
-		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
-	describe EimXML::XHTML::Formatter do
-		describe "#write" do
-			it "should set :preservers=>PRESERVE_SPACES to default option" do
-				e = EimXML::XHTML::HTML.new
-				EimXML::Formatter.should_receive(:write).with(e, :preservers=>EimXML::XHTML::PRESERVE_SPACES, :opt=>:dummy)
-				EimXML::XHTML::Formatter.write(e, :opt=>:dummy)
-			end
-			it "should return string" do
-				h = EimXML::XHTML::DSL.html do
-					head do
-						style.add("style\ntext")
-						script.add("script\ntext")
-					end
-					body do
-						div.add("text\nin\ndiv")
-						pre.add("pre\nt")
-						h1.add("1\nt")
-						h2.add("2\nt")
-						h3.add("3\nt")
-						h4.add("4\nt")
-						h5.add("5\nt")
-						h6.add("6\nt")
-						p.add("p\nt")
-						a.add("a\nt")
-						em.add("e\nt")
-						strong.add("s\nt")
-						span.add("sp\nt")
-						li.add("li\nt")
-						dt.add("dt\nt")
-						dd.add("dd\nt")
-						caption.add("c\nt")
-						th.add("th\nt")
-						td.add("td\nt")
-						button.add("button\nt")
-					end
-				end
-				s = <<EOT
-<html>
-  <head>
-    <style>style
-text</style>
-    <script>script
-text</script>
-  </head>
-  <body>
-    <div>
-      text
-      in
-      div
-    </div>
-    <pre>pre
-t</pre>
-    <h1>1
-t</h1>
-    <h2>2
-t</h2>
-    <h3>3
-t</h3>
-    <h4>4
-t</h4>
-    <h5>5
-t</h5>
-    <h6>6
-t</h6>
-    <p>p
-t</p>
-    <a>a
-t</a>
-    <em>e
-t</em>
-    <strong>s
-t</strong>
-    <span>sp
-t</span>
-    <li>li
-t</li>
-    <dt>dt
-t</dt>
-    <dd>dd
-t</dd>
-    <caption>c
-t</caption>
-    <th>th
-t</th>
-    <td>td
-t</td>
-    <button>button
-t</button>
-  </body>
-</html>
-EOT
-				EimXML::XHTML::Formatter.write(h).should == s
-			end
-		end
-	end
-end