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.
data/Rakefile CHANGED
@@ -1,9 +1,9 @@
1
1
  require "rake/clean"
2
- require "rake/testtask"
3
2
  require "rake/rdoctask"
4
3
  require "rake/gempackagetask"
4
+ require "spec/rake/spectask"
5
5
 
6
- FILES = FileList["**/*"].exclude("pkg", "html")
6
+ FILES = FileList["**/*"].exclude(/^pkg/, /\.html$/)
7
7
 
8
8
  task :default => :test
9
9
 
@@ -36,17 +36,25 @@ task :publish => [:clobber_rdoc, "rdoc:ja", "rdoc:en"] do
36
36
  end
37
37
 
38
38
  ### Test ###
39
- task :test => "test:apart"
39
+ task :test => "test:lump"
40
40
  namespace :test do
41
- FileList["test/*_test.rb"].sort{|a,b| File.mtime(a)<=>File.mtime(b)}.reverse.each do |i|
42
- Rake::TestTask.new(:apart) do |t|
43
- t.test_files = i
41
+ def set_spec_options(spec)
42
+ spec.ruby_opts << "-rtest/unit"
43
+ spec.spec_opts << "-c"
44
+ spec.libs << "lib"
45
+ end
46
+ TEST_FILES = FileList["test/**/*_test.rb"]
47
+ TEST_FILES.sort{|a,b| File.mtime(a)<=>File.mtime(b)}.reverse.each do |i|
48
+ Spec::Rake::SpecTask.new(:apart) do |s|
49
+ s.spec_files = [i]
50
+ set_spec_options(s)
44
51
  end
45
52
  end
46
53
  task(:apart).comment = "Run tests separately"
47
54
 
48
- Rake::TestTask.new(:lump) do |t|
49
- t.test_files = FileList["test/*_test.rb"]
55
+ Spec::Rake::SpecTask.new(:lump) do |s|
56
+ s.spec_files = TEST_FILES
57
+ set_spec_options(s)
50
58
  end
51
59
  task(:lump).comment = "Run all tests in a lump"
52
60
  end
@@ -58,7 +66,7 @@ def build_gem(unstable=false)
58
66
  spec = Gem::Specification.new do |spec|
59
67
  spec.name = "eimxml"
60
68
  spec.rubyforge_project = "eimxml"
61
- spec.version = "0.0.1"
69
+ spec.version = ENV["VER"] or raise "Need VER=x.y.z(.?)"
62
70
  spec.summary = "Easy IMplemented XML"
63
71
  spec.author = "KURODA Hiraku"
64
72
  spec.email = "hiraku@hinet.mydns.jp"
@@ -0,0 +1,25 @@
1
+ require "eim_xml"
2
+ module EimXML::Matchers
3
+ class HaveContent
4
+ def initialize(expected)
5
+ @expected = expected
6
+ end
7
+
8
+ def matches?(target)
9
+ @target = target
10
+ @target.has?(@expected)
11
+ end
12
+
13
+ def failure_message
14
+ "expected #{@target.inspect} must have #{@expected}, but not."
15
+ end
16
+
17
+ def negative_failure_message
18
+ "expected #{@target.inspect} must not have #{@expected}, but has."
19
+ end
20
+ end
21
+
22
+ def have(expected)
23
+ HaveContent.new(expected)
24
+ end
25
+ end
@@ -91,7 +91,23 @@ module EimXML
91
91
 
92
92
  def parse_string(hold_space)
93
93
  s = @scanner[0]
94
- s.strip! unless hold_space
94
+ s = s.strip unless hold_space
95
+ s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
96
+ case $1
97
+ when "amp"
98
+ "&"
99
+ when "quot"
100
+ '"'
101
+ when "apos"
102
+ "'"
103
+ when "lt"
104
+ "<"
105
+ when "gt"
106
+ ">"
107
+ else
108
+ raise "must not happen"
109
+ end
110
+ end
95
111
  PCString.new(s)
96
112
  end
97
113
  protected :parse_string
@@ -0,0 +1,125 @@
1
+ require "eim_xml"
2
+
3
+ module EimXML::XHTML
4
+ module DocType
5
+ 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">]
6
+ end
7
+
8
+ class DSL < EimXML::BaseDSL
9
+ end
10
+
11
+ class OpenDSL < EimXML::OpenDSL
12
+ end
13
+
14
+ class Base_ < EimXML::Element
15
+ end
16
+
17
+ class HTML < Base_
18
+ attr_accessor :prefix
19
+ module NameSpace
20
+ XHTML = "http://www.w3.org/1999/xhtml"
21
+ end
22
+
23
+ def initialize(attributes=nil)
24
+ super(:html, attributes)
25
+ end
26
+
27
+ def to_xml(s="")
28
+ s << @prefix << "\n" if @prefix
29
+ super(s)
30
+ end
31
+ end
32
+
33
+ class Simple_ < Base_
34
+ def initialize(attributes=nil)
35
+ super(self.class.name[/.*::(.*)/, 1].downcase.to_sym, attributes)
36
+ end
37
+ end
38
+
39
+ class HEAD < Simple_; end
40
+ class META < Simple_; end
41
+ class LINK < Simple_; end
42
+ class STYLE < Simple_; end
43
+ class SCRIPT < Simple_; end
44
+ class TITLE < Simple_; end
45
+ class BODY < Simple_; end
46
+ class PRE < Simple_
47
+ def initialize(attributes=nil)
48
+ super
49
+ hold_space
50
+ end
51
+ end
52
+ class FORM < Simple_; end
53
+ class H1 < Simple_; end
54
+ class H2 < Simple_; end
55
+ class H3 < Simple_; end
56
+ class H4 < Simple_; end
57
+ class H5 < Simple_; end
58
+ class H6 < Simple_; end
59
+ class P < Simple_; end
60
+ class A < Simple_; end
61
+ class EM < Simple_; end
62
+ class STRONG < Simple_; end
63
+ class DIV < Simple_; end
64
+ class UL < Simple_; end
65
+ class OL < Simple_; end
66
+ class LI < Simple_; end
67
+ class DL < Simple_; end
68
+ class DT < Simple_; end
69
+ class DD < Simple_; end
70
+ class TABLE < Simple_; end
71
+ class CAPTION < Simple_; end
72
+ class TR < Simple_; end
73
+ class TH < Simple_; end
74
+ class TD < Simple_; end
75
+
76
+ module Hn
77
+ def self.new(level, attr=nil, &proc)
78
+ raise ArgumentError unless 1<=level && level<=6
79
+ klass = EimXML::XHTML.const_get("H#{level}")
80
+ klass.new(attr, &proc)
81
+ end
82
+ end
83
+
84
+ class TEXTAREA < Base_
85
+ def initialize(name, opt={})
86
+ super(:textarea, {:name=>name}.merge(opt))
87
+ end
88
+ end
89
+
90
+ class INPUT < Base_
91
+ def initialize(type, name, value, opt={})
92
+ attr = {:type=>type}
93
+ attr[:name]=name if name
94
+ attr[:value]=value if value
95
+ super(:input, attr.merge(opt))
96
+ end
97
+ end
98
+
99
+ class HIDDEN < INPUT
100
+ def initialize(name, value, opt={})
101
+ super(:hidden, name, value, opt)
102
+ end
103
+ end
104
+
105
+ class SUBMIT < INPUT
106
+ def initialize(opt={})
107
+ opt = opt.dup
108
+ super(:submit, opt.delete(:name), opt.delete(:value), opt)
109
+ end
110
+ end
111
+
112
+ class TEXT < INPUT
113
+ def initialize(name, value=nil, opt={})
114
+ super(:text, name, value, opt)
115
+ end
116
+ end
117
+
118
+ constants.each do |c|
119
+ v = const_get(c)
120
+ if v.is_a?(Class) && /_$/ !~ v.name
121
+ DSL.register v
122
+ OpenDSL.register v
123
+ end
124
+ end
125
+ end
data/lib/eim_xml.rb CHANGED
@@ -7,15 +7,97 @@
7
7
  module EimXML
8
8
  XML_DECLARATION = %[<?xml version="1.0"?>]
9
9
 
10
+ class BaseDSL
11
+ def initialize
12
+ @container = nil
13
+ yield(self) if block_given?
14
+ end
15
+
16
+ def add(v)
17
+ @container.add(v)
18
+ end
19
+ alias << add
20
+
21
+ def self.register(*args)
22
+ args.each do |klass, name|
23
+ name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
24
+ l = __LINE__+1
25
+ src = "def #{name}(*arg, &proc)\n" <<
26
+ "e = #{klass}.new(*arg)\n" <<
27
+ "@container << e if @container\n" <<
28
+ "if proc\n" <<
29
+ "oc = @container\n" <<
30
+ "@container = e\n" <<
31
+ "begin\n" <<
32
+ "instance_eval(&proc)\n" <<
33
+ "ensure\n" <<
34
+ "@container = oc\n" <<
35
+ "end\n" <<
36
+ "end\n" <<
37
+ "e\n" <<
38
+ "end"
39
+ eval(src, binding, __FILE__, l)
40
+
41
+ l = __LINE__+1
42
+ src = "def self.#{name}(*arg, &proc)\n" <<
43
+ "new.#{name}(*arg, &proc)\n" <<
44
+ "end"
45
+ eval(src, binding, __FILE__, l)
46
+ end
47
+ end
48
+ end
49
+
50
+ class DSL < BaseDSL
51
+ end
52
+
53
+ class OpenDSL
54
+ def self.register_base(dsl, binding, *args)
55
+ args.each do |klass, name|
56
+ name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
57
+ src = "def #{name}(*arg)\n" <<
58
+ "e=#{klass}.new(*arg)\n" <<
59
+ "oc=@container\n" <<
60
+ "oc << e if oc.is_a?(Element)\n" <<
61
+ "@container = e\n" <<
62
+ "begin\n" <<
63
+ "yield(self) if block_given?\n" <<
64
+ "e\n" <<
65
+ "ensure\n" <<
66
+ "@container = oc\n" <<
67
+ "end\n" <<
68
+ "end\n"
69
+ eval(src, binding, __FILE__, __LINE__-12)
70
+
71
+ src = "def self.#{name}(*arg, &proc)\n" <<
72
+ "self.new.#{name}(*arg, &proc)\n" <<
73
+ "end"
74
+ eval(src, binding, __FILE__, __LINE__-3)
75
+ end
76
+ end
77
+
78
+ def self.register(*args)
79
+ register_base(self, binding, *args)
80
+ end
81
+
82
+ attr_reader :container
83
+ def initialize
84
+ @container = nil
85
+ yield(self) if block_given?
86
+ end
87
+
88
+ def add(v)
89
+ @container.add(v)
90
+ end
91
+ alias :<< :add
92
+ end
93
+
10
94
  class PCString
11
95
  attr_reader :encoded_string
12
96
  alias to_s encoded_string
13
97
 
14
98
  def self.encode(s)
15
- s.gsub(/&\#?\w+;|[&\"\'<>]/) do |m|
99
+ s.gsub(/[&\"\'<>]/) do |m|
16
100
  case m
17
- when /&\#?\w+;/
18
- m
19
101
  when "&"
20
102
  "&amp;"
21
103
  when '"'
@@ -35,7 +117,11 @@ module EimXML
35
117
  end
36
118
 
37
119
  def ==(other)
38
- @encoded_string==other.encoded_string
120
+ other.is_a?(PCString) ? @encoded_string==other.encoded_string : false
121
+ end
122
+
123
+ def to_xml(dst=String.new)
124
+ dst << encoded_string
39
125
  end
40
126
  end
41
127
 
@@ -106,26 +192,26 @@ module EimXML
106
192
  def add(v)
107
193
  case v
108
194
  when nil
109
- when Element, PCString
110
- @contents << v
111
195
  when Array
112
196
  v.each{|i| self.add(i)}
113
197
  else
114
- @contents << v.to_s
198
+ @contents << v
115
199
  end
116
200
  self
117
201
  end
118
202
  alias << add
119
203
 
120
- def write(dst=String.new, level=0, is_head=true)
121
- nest = NEST*level
204
+ def to_xml_with_indent(dst=String.new, nest_level=0, is_head=true)
205
+ nest_level = -1 if @hold_space
206
+ hold_space = @hold_space || (nest_level<0)
207
+ nest = nest_level<0 ? "" : NEST*nest_level
122
208
  head = is_head ? nest : ""
123
- lf = @hold_space ? "" : "\n"
209
+ lf = hold_space ? "" : "\n"
124
210
 
125
211
  attributes = ""
126
212
  @attributes.each do |k, v|
127
213
  v = k.to_s unless v
128
- attributes << " #{k}='#{PCString===v ? v : PCString.encode(v)}'"
214
+ attributes << " #{k}='#{PCString===v ? v : PCString.encode(v.to_s)}'"
129
215
  end
130
216
 
131
217
  case @contents.size
@@ -133,25 +219,36 @@ module EimXML
133
219
  dst << "#{head}<#{@name}#{attributes} />"
134
220
  when 1
135
221
  dst << "#{head}<#{@name}#{attributes}>"
136
- write_content_to(dst, @contents[0], level, false)
222
+ content_to_xml(dst, @contents[0], nest_level, false)
137
223
  dst << "</#{@name}>"
138
224
  else
139
225
  dst << "#{head}<#{@name}#{attributes}>#{lf}"
140
- @contents.each {|i| write_content_to(dst, i, level+1, !@hold_space) << lf}
226
+ @contents.each {|i| content_to_xml(dst, i, nest_level<0 ? -1 : nest_level+1, !hold_space) << lf}
141
227
  dst << "#{@hold_space ? "" : nest}</#{@name}>"
142
228
  end
143
229
  end
144
- def to_s(*args)
145
- args.unshift("")
146
- write(*args)
230
+
231
+ def to_xml(dst=String.new)
232
+ to_xml_with_indent(dst)
233
+ end
234
+
235
+ def to_s
236
+ to_xml
147
237
  end
148
238
  alias :inspect :to_s
149
239
 
150
- def write_content_to(dst, c, level, is_head)
151
- return c.write(dst, level, is_head) if c.is_a?(Element)
152
- dst << (is_head ? NEST*level : "") + (c.is_a?(PCString) ? c.to_s : PCString.encode(c))
240
+ def content_to_xml(dst, c, nest_level, is_head)
241
+ case
242
+ when c.respond_to?(:to_xml_with_indent)
243
+ c.to_xml_with_indent(dst, nest_level, is_head)
244
+ when c.respond_to?(:to_xml)
245
+ dst << (is_head && nest_level>=0 ? NEST*nest_level : "")
246
+ c.to_xml(dst)
247
+ else
248
+ dst << (is_head && nest_level>=0 ? NEST*nest_level : "") << PCString.encode(c.to_s)
249
+ end
153
250
  end
154
- private :write_content_to
251
+ private :content_to_xml
155
252
 
156
253
  def ==(xml)
157
254
  return false unless xml.is_a?(Element)
@@ -198,7 +295,12 @@ module EimXML
198
295
  v===sv
199
296
  end
200
297
  else
201
- v===@attributes[k]
298
+ ak = @attributes[k]
299
+ if (ak.is_a?(String) or ak.is_a?(Symbol)) and (v.is_a?(String) or v.is_a?(Symbol))
300
+ ak.to_s == v.to_s
301
+ else
302
+ v===@attributes[k]
303
+ end
202
304
  end
203
305
  end
204
306
  end
@@ -218,6 +320,7 @@ module EimXML
218
320
  end
219
321
  end
220
322
  end
323
+ alias has_element? has?
221
324
 
222
325
  def find(name, attrs=nil)
223
326
  r = []
@@ -232,4 +335,7 @@ module EimXML
232
335
  r
233
336
  end
234
337
  end
338
+
339
+ DSL.register Element
340
+ OpenDSL.register Element
235
341
  end
@@ -6,7 +6,7 @@
6
6
  require "test/unit"
7
7
  require "eim_xml/assertions"
8
8
 
9
- class TC_EimXML_Assertions < Test::Unit::TestCase
9
+ class EimXMLAssertionsTest < Test::Unit::TestCase
10
10
  include EimXML
11
11
  include EimXML::Assertions
12
12
 
data/test/eim_xml_test.rb CHANGED
@@ -5,16 +5,15 @@
5
5
 
6
6
  require "test/unit"
7
7
  require "eim_xml"
8
+ require "spec"
8
9
 
9
- class TC_PCString < Test::Unit::TestCase
10
+ class PCStringTest < Test::Unit::TestCase
10
11
  include EimXML
11
12
 
12
13
  def test_encode
13
14
  assert_equal("&lt;&gt;&quot;&apos;&amp;", PCString.encode("<>\"'&"))
14
- assert_equal("&test;", PCString.encode("&test;"))
15
- assert_equal("&\#0ax;", PCString.encode("&#0ax;"))
16
- assert_equal("&amp;test", PCString.encode("&test"))
17
- assert_equal("&amp;\#0ax", PCString.encode("&#0ax"))
15
+ assert_equal("&amp;test;", PCString.encode("&test;"))
16
+ assert_equal("&amp;amp;", PCString.encode("&amp;"))
18
17
  end
19
18
 
20
19
  def test_new
@@ -26,10 +25,16 @@ class TC_PCString < Test::Unit::TestCase
26
25
  p1 = PCString.new("str")
27
26
  p2 = PCString.new("str")
28
27
  assert_equal(p1, p2)
28
+
29
+ assert_not_equal(p1, "str")
30
+ end
31
+
32
+ def test_to_xml
33
+ assert_equal("&amp;amp;", PCString.new("&amp;").to_xml)
29
34
  end
30
35
  end
31
36
 
32
- class TC_Element < Test::Unit::TestCase
37
+ class ElementTest < Test::Unit::TestCase
33
38
  include EimXML
34
39
 
35
40
  class Dummy < Element
@@ -102,47 +107,59 @@ class TC_Element < Test::Unit::TestCase
102
107
  assert_equal(0, e.contents.size, "add nil")
103
108
 
104
109
  e = Element.new("el").add(:symbol)
105
- assert_equal(["symbol"], e.contents, "add anything(which has to_s)")
110
+ assert_equal([:symbol], e.contents, "add anything(which has to_s)")
111
+ assert_equal("<el>symbol</el>", e.to_xml)
106
112
 
107
113
  e = Element.new("super") << Element.new("sub")
108
114
  assert_equal(:super, e.name)
109
115
  assert_equal([Element.new("sub")], e.contents)
110
116
  end
111
117
 
112
- def test_write
118
+ def test_to_xml_with_indent
113
119
  e = Element.new("el")
114
120
  s = String.new
115
- assert_equal(s.object_id, e.write(s).object_id)
121
+ assert_equal(s.object_id, e.to_xml_with_indent(s).object_id)
116
122
  assert_equal("<el />", s)
117
123
 
118
124
  e = Element.new("super")
119
125
  e << Element.new("sub")
120
- assert_equal("<super><sub /></super>", e.write)
126
+ assert_equal("<super><sub /></super>", e.to_xml_with_indent)
121
127
  e << Element.new("sub2")
122
- assert_equal("<super>\n <sub />\n <sub2 />\n</super>", e.write)
123
- assert_equal(" <super>\n <sub />\n <sub2 />\n </super>", e.write("", 1))
124
- assert_equal("<super>\n <sub />\n <sub2 />\n </super>", e.write("", 1, false))
128
+ assert_equal("<super>\n <sub />\n <sub2 />\n</super>", e.to_xml_with_indent)
129
+ assert_equal(" <super>\n <sub />\n <sub2 />\n </super>", e.to_xml_with_indent("", 1))
130
+ assert_equal("<super>\n <sub />\n <sub2 />\n </super>", e.to_xml_with_indent("", 1, false))
125
131
 
126
132
  s = Element.new("supersuper")
127
133
  s << e
128
- assert_equal("<supersuper><super>\n <sub />\n <sub2 />\n</super></supersuper>", s.write)
134
+ assert_equal("<supersuper><super>\n <sub />\n <sub2 />\n</super></supersuper>", s.to_xml_with_indent)
129
135
 
130
136
  e = Element.new("el") << "str"
131
137
  s = Element.new("sub")
132
138
  s << "inside"
133
139
  e << s
134
- assert_equal("<el>\n str\n <sub>inside</sub>\n</el>", e.write)
140
+ assert_equal("<el>\n str\n <sub>inside</sub>\n</el>", e.to_xml_with_indent)
135
141
 
136
142
  e = Element.new("el")
137
143
  e.attributes["a1"] = "v1"
138
144
  e.attributes["a2"] = "'\"<>&"
139
- s = e.write
145
+ s = e.to_xml_with_indent
140
146
  assert_match(/\A<el ([^>]*) \/>\z/, s)
141
147
  assert_match(/a1='v1'/, s)
142
148
  assert_match(/a2='&apos;&quot;&lt;&gt;&amp;'/, s)
143
149
 
144
150
  e = Element.new("el", {"a1"=>nil})
145
- assert_equal("<el a1='a1' />", e.write)
151
+ assert_equal("<el a1='a1' />", e.to_xml_with_indent)
152
+ end
153
+
154
+ def test_to_xml
155
+ el = Element.new("el")
156
+ ex = "<el />"
157
+ assert_equal(ex, el.to_xml)
158
+
159
+ s = ""
160
+ r = el.to_xml(s)
161
+ assert_equal(ex, r)
162
+ assert_equal(s.object_id, r.object_id)
146
163
  end
147
164
 
148
165
  def test_spcial_string
@@ -197,12 +214,14 @@ class TC_Element < Test::Unit::TestCase
197
214
  def test_hold_space
198
215
  e = Element.new("el") << "Line1" << "Line2"
199
216
  s = Element.new("sub") << "Sub1" << "Sub2"
217
+ ss = Element.new("subsub") << "ss1" << "ss2"
218
+ s << ss
200
219
  e << s
201
220
  e.hold_space
202
- assert_equal("<el>Line1Line2<sub>\n Sub1\n Sub2\n </sub></el>", e.to_s)
221
+ assert_equal("<el>Line1Line2<sub>Sub1Sub2<subsub>ss1ss2</subsub></sub></el>", e.to_s)
203
222
 
204
223
  e.unhold_space
205
- assert_equal("<el>\n Line1\n Line2\n <sub>\n Sub1\n Sub2\n </sub>\n</el>", e.to_s)
224
+ 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)
206
225
 
207
226
  e = Element.new("e")
208
227
  assert_equal(e.object_id, e.hold_space.object_id)
@@ -257,12 +276,13 @@ class TC_Element < Test::Unit::TestCase
257
276
  end
258
277
 
259
278
  def test_new_with_block
260
- b = nil
279
+ base = nil
261
280
  e = Element.new("base") do |b|
262
281
  b["attr"]="value"
263
282
  b << Element.new("sub")
283
+ base = b
264
284
  end
265
- assert_same(e, b)
285
+ assert_same(e, base)
266
286
  e2 = Element.new("base", "attr"=>"value")
267
287
  e2 << Element.new("sub")
268
288
  assert_equal(e, e2)
@@ -319,6 +339,11 @@ class TC_Element < Test::Unit::TestCase
319
339
  assert(e.match?(Element))
320
340
  assert(!e.match?(Dummy))
321
341
  assert(!e.match?(String))
342
+
343
+ e1 = Element.new(:tag, :attr=>:value)
344
+ e2 = Element.new(:tag, :attr=>"value")
345
+ assert(e1.match?(e2))
346
+ assert(e2.match?(e1))
322
347
  end
323
348
 
324
349
  def test_match_by_array
@@ -345,7 +370,7 @@ class TC_Element < Test::Unit::TestCase
345
370
  assert(e !~ Element.new(:tag, :a=>"v"))
346
371
  end
347
372
 
348
- def test_has
373
+ def test_has?
349
374
  e = Element.new(:base) do |b|
350
375
  b <<= Element.new(:sub) do |s|
351
376
  s <<= Element.new(:deep) do |d|
@@ -363,6 +388,42 @@ class TC_Element < Test::Unit::TestCase
363
388
  assert(! e.has?(:deep, {}, false))
364
389
 
365
390
  assert(e.has?(String))
391
+
392
+ e = DSL.element(:base) do
393
+ element(:sub, :sym=>:v1, "string"=>"v2")
394
+ end
395
+ assert(e.has?(Element.new(:sub, :sym=>"v1")))
396
+ assert(e.has?(Element.new(:sub, "sym"=>"v1")))
397
+ assert(e.has?(Element.new(:sub, "string"=>:v2)))
398
+ assert(e.has?(Element.new(:sub, :string=>:v2)))
399
+ end
400
+
401
+ def test_has_element?
402
+ e = Element.new(:base) do |b|
403
+ b <<= Element.new(:sub) do |s|
404
+ s <<= Element.new(:deep) do |d|
405
+ d << "text"
406
+ end
407
+ end
408
+ b <<= Element.new(:sub, :attr=>"value")
409
+ end
410
+
411
+ assert(e.has_element?(:base))
412
+ assert(e.has_element?(:sub))
413
+ assert(e.has_element?(:sub, :attr=>"value"))
414
+ assert(!e.has_element?(:sub, :attr=>"value", :attr2=>""))
415
+ assert(e.has_element?(:deep))
416
+ assert(! e.has_element?(:deep, {}, false))
417
+
418
+ assert(e.has_element?(String))
419
+
420
+ e = DSL.element(:base) do
421
+ element(:sub, :sym=>:v1, "string"=>"v2")
422
+ end
423
+ assert(e.has_element?(Element.new(:sub, :sym=>"v1")))
424
+ assert(e.has_element?(Element.new(:sub, "sym"=>"v1")))
425
+ assert(e.has_element?(Element.new(:sub, "string"=>:v2)))
426
+ assert(e.has_element?(Element.new(:sub, :string=>:v2)))
366
427
  end
367
428
 
368
429
  def test_find
@@ -382,7 +443,7 @@ class TC_Element < Test::Unit::TestCase
382
443
  end
383
444
  end
384
445
 
385
- class TC_SymbolKeyHash < Test::Unit::TestCase
446
+ class SymbolKeyHashTest < Test::Unit::TestCase
386
447
  SKH = EimXML::SymbolKeyHash
387
448
 
388
449
  def test_new
@@ -426,3 +487,162 @@ class TC_SymbolKeyHash < Test::Unit::TestCase
426
487
  assert_equal({:sym1=>"value1", :str1=>"value2", :sym2=>"value3", :str2=>"value4"}, s)
427
488
  end
428
489
  end
490
+
491
+ describe EimXML::DSL do
492
+ it "scope is in instance of EimXML::DSL" do
493
+ outer = inner = nil
494
+ e3 = e2 = nil
495
+ block_executed = false
496
+ e = EimXML::DSL.element(:out, :k1=>"v1") do
497
+ outer = self
498
+ e2 = element(:in, :k2=>"v2") do
499
+ block_executed = true
500
+ inner = self
501
+ e3 = element(:deep)
502
+ end
503
+ end
504
+
505
+ block_executed.should == true
506
+ outer.should be_kind_of(EimXML::DSL)
507
+ inner.should be_kind_of(EimXML::DSL)
508
+ outer.object_id.should == inner.object_id
509
+
510
+ e.name.should == :out
511
+ e[:k1].should == "v1"
512
+ e[0].name.should == :in
513
+ e[0][:k2].should == "v2"
514
+ e[0][0].name.should == :deep
515
+ e2.object_id.should == e[0].object_id
516
+ e3.object_id.should == e[0][0].object_id
517
+ end
518
+ end
519
+
520
+ describe "Subclass of EimXML::BaseDSL" do
521
+ class DSL1 < EimXML::BaseDSL
522
+ register([EimXML::Element, "call"])
523
+ register(Hash)
524
+ register(String, Array, Object)
525
+ end
526
+
527
+ it "register" do
528
+ lambda{EimXML::DSL.call(:dummy)}.should raise_error(NoMethodError)
529
+ lambda{EimXML::BaseDSL.call(:dummy)}.should raise_error(NoMethodError)
530
+ lambda{DSL1.element(:dummy)}.should raise_error(NoMethodError)
531
+ DSL1.call(:dummy).should be_kind_of(EimXML::Element)
532
+ DSL1.hash.should be_kind_of(Hash)
533
+ DSL1.string.should be_kind_of(String)
534
+ DSL1.array.should be_kind_of(Array)
535
+ DSL1.object.should be_kind_of(Object)
536
+ end
537
+ end
538
+
539
+ describe EimXML::OpenDSL do
540
+ it "scope of block is one of outside" do
541
+ @scope_checker_variable = 1
542
+ block_executed = false
543
+ d = EimXML::OpenDSL.new do |d|
544
+ block_executed = true
545
+ d.should be_kind_of(EimXML::OpenDSL)
546
+ d.container.should be_nil
547
+ d.element(:base, :key1=>"v1") do
548
+ @scope_checker_variable.should == 1
549
+ self.should_not be_kind_of(EimXML::Element)
550
+ d.container.should be_kind_of(EimXML::Element)
551
+ d.container.should == EimXML::Element.new(:base, :key1=>"v1")
552
+ d.element(:sub, :key2=>"v2") do
553
+ d.container.should be_kind_of(EimXML::Element)
554
+ d.container.should == EimXML::Element.new(:sub, :key2=>"v2")
555
+ end
556
+ d.element(:sub2).should == EimXML::Element.new(:sub2)
557
+ end
558
+ end
559
+ block_executed.should be_true
560
+ end
561
+
562
+ it "DSL methods return element" do
563
+ d = EimXML::OpenDSL.new
564
+ d.container.should be_nil
565
+ r = d.element(:base, :key1=>"v1") do
566
+ d.element(:sub, :key2=>"v2")
567
+ end
568
+ r.should == EimXML::DSL.element(:base, :key1=>"v1") do
569
+ element(:sub, :key2=>"v2")
570
+ end
571
+ end
572
+
573
+ it "DSL method's block given instance of OpenDSL" do
574
+ e = EimXML::OpenDSL.new.element(:base) do |d|
575
+ d.should be_kind_of(EimXML::OpenDSL)
576
+ d.container.name.should == :base
577
+ d.element(:sub) do |d2|
578
+ d2.object_id.should == d.object_id
579
+ end
580
+ end
581
+
582
+ e.should == EimXML::DSL.element(:base) do
583
+ element(:sub)
584
+ end
585
+ end
586
+
587
+ it "ensure reset container when error raised" do
588
+ EimXML::OpenDSL.new do |d|
589
+ begin
590
+ d.element(:base) do
591
+ begin
592
+ d.element(:sub) do
593
+ raise "OK"
594
+ end
595
+ rescue RuntimeError => e
596
+ raise unless e.message=="OK"
597
+ d.container.name.should == :base
598
+ raise
599
+ end
600
+ end
601
+ rescue RuntimeError => e
602
+ raise unless e.message=="OK"
603
+ d.container.should == nil
604
+ end
605
+ end
606
+ end
607
+
608
+ it "respond to add" do
609
+ r = EimXML::OpenDSL.new.element(:base) do |d|
610
+ d.add "text"
611
+ d.element(:sub) do
612
+ s = EimXML::Element.new(:sub)
613
+ s.add("sub text")
614
+ d.add("sub text").should == s
615
+ end
616
+ end
617
+
618
+ r.should == EimXML::DSL.element(:base) do
619
+ add "text"
620
+ element(:sub) do
621
+ add "sub text"
622
+ end
623
+ end
624
+ end
625
+
626
+ it "respond to <<" do
627
+ r = EimXML::OpenDSL.new.element(:base) do |d|
628
+ b = EimXML::Element.new(:base)
629
+ b << "text" << "next"
630
+ (d << "text" << "next").should == b
631
+ end
632
+ r.should == EimXML::DSL.element(:base) do
633
+ add "text"
634
+ add "next"
635
+ end
636
+ end
637
+
638
+ it "can call directly element method" do
639
+ r = EimXML::OpenDSL.element(:base) do |d|
640
+ d.element(:sub)
641
+ d.element(:sub2)
642
+ end
643
+ r.should == EimXML::DSL.element(:base) do
644
+ element(:sub)
645
+ element(:sub2)
646
+ end
647
+ end
648
+ end
data/test/parser_test.rb CHANGED
@@ -6,7 +6,7 @@
6
6
  require "test/unit"
7
7
  require "eim_xml/parser"
8
8
 
9
- class TC_Parser < Test::Unit::TestCase
9
+ class ParserTest < Test::Unit::TestCase
10
10
  include EimXML
11
11
 
12
12
  def parse(src)
data/test/xhtml_test.rb CHANGED
@@ -4,12 +4,23 @@
4
4
  # You can redistribute it and/or modify it under GPL2.
5
5
 
6
6
  require "eim_xml/xhtml"
7
+ require "eim_xml/assertions"
7
8
  require "test/unit"
9
+ require "stringio"
8
10
 
9
- class TC_XHTML < Test::Unit::TestCase
11
+ class XHTMLTest < Test::Unit::TestCase
10
12
  include EimXML::XHTML
13
+ include EimXML::Assertions
11
14
  Element = EimXML::Element
12
15
 
16
+ def test_base_
17
+ assert_raise(NoMethodError){DSL.base_}
18
+ end
19
+
20
+ def setup
21
+ @od = OpenDSL.new
22
+ end
23
+
13
24
  def test_html
14
25
  h = HTML.new(:attr=>"value")
15
26
  assert_equal(Element.new(:html, :attr=>"value"), h)
@@ -20,119 +31,310 @@ class TC_XHTML < Test::Unit::TestCase
20
31
  h2 = HTML.new
21
32
  h2 << Element.new(:sub)
22
33
  assert_equal(h, h2)
23
- end
24
34
 
25
- def test_html_with_declarations
26
- decs = EimXML::XML_DECLARATION + "\n" + DocType::XHTML_MATHML + "\n"
27
- h = HTML.new
28
- assert_equal(decs + "<html />", h.to_s)
35
+ assert_raise(NoMethodError){EimXML::DSL.html}
36
+ assert_match(HTML.new(:key=>"v"), DSL.html(:key=>"v"))
37
+ @od.html(:key=>"v").should == HTML.new(:key=>"v")
29
38
 
30
39
  h = HTML.new
31
- assert_equal("<html />", h.to_s(false))
40
+ h.to_xml.should == "<html />"
41
+ h.prefix='<?xml version="1.0"?>'
42
+ h.to_xml.should == %[<?xml version="1.0"?>\n<html />]
43
+ end
32
44
 
33
- h = HTML.new do |h|
34
- h << Body.new do |b|
35
- b << "test"
36
- end
37
- end
45
+ def test_head
46
+ assert_equal(:head, HEAD.new.name)
47
+ assert_kind_of(HEAD, DSL.head)
48
+ @od.head.should be_kind_of(HEAD)
49
+ end
38
50
 
39
- assert_equal(decs+h.to_s(false), h.to_s)
51
+ def test_meta
52
+ assert_equal(:meta, META.new.name)
53
+ assert_kind_of(META, DSL.meta)
54
+ @od.meta.should be_kind_of(META)
55
+ end
40
56
 
41
- s1 = ""
42
- s2 = ""
43
- assert_equal(decs+h.write(s1, false), h.write(s2))
57
+ def test_link
58
+ assert_equal(:link, LINK.new.name)
59
+ assert_kind_of(LINK, DSL.link)
60
+ @od.link.should be_kind_of(LINK)
44
61
  end
45
62
 
46
- def test_head
47
- assert_equal(:head, Head.new.name)
63
+ def test_style
64
+ assert_equal(:style, STYLE.new.name)
65
+ assert_kind_of(STYLE, DSL.style)
66
+ @od.style.should be_kind_of(STYLE)
67
+ end
68
+
69
+ def test_script
70
+ assert_equal(:script, SCRIPT.new.name)
71
+ assert_kind_of(SCRIPT, DSL.script)
72
+ @od.script.should be_kind_of(SCRIPT)
48
73
  end
49
74
 
50
75
  def test_title
51
- assert_equal(:title, Title.new.name)
76
+ assert_equal(:title, TITLE.new.name)
77
+ assert_kind_of(TITLE, DSL.title)
78
+ @od.title.should be_kind_of(TITLE)
52
79
  end
53
80
 
54
81
  def test_body
55
- assert_equal(:body, Body.new.name)
82
+ assert_equal(:body, BODY.new.name)
83
+ assert_kind_of(BODY, DSL.body)
84
+ @od.body.should be_kind_of(BODY)
56
85
  end
57
86
 
58
87
  def test_pre
59
- assert_equal(:pre, Pre.new.name)
60
- end
61
-
62
- def test_form
63
- assert_equal(:form, Form.new.name)
88
+ assert_equal(:pre, PRE.new.name)
89
+ assert_kind_of(PRE, DSL.pre)
90
+ @od.pre.should be_kind_of(PRE)
91
+ PRE.new.hold_space?.should be_true
64
92
  end
65
93
 
66
94
  def test_hn
67
- assert_equal(:h1, Hn.new(1).name)
68
- assert_equal(:h6, Hn.new(6).name)
95
+ h1 = Hn.new(1)
96
+ h6 = Hn.new(6)
97
+ assert_equal(:h1, h1.name)
98
+ assert_kind_of(H1, h1)
99
+ assert_equal(:h6, h6.name)
100
+ assert_kind_of(H6, h6)
69
101
  assert_raises(ArgumentError){Hn.new(7)}
70
102
  assert_raises(ArgumentError){Hn.new(0)}
103
+
104
+ h = Hn.new(1, :key=>:value) do |hn|
105
+ hn << "test"
106
+ end
107
+ assert_equal(:value, h[:key])
108
+ assert_equal("test", h[0])
109
+
110
+ [
111
+ [H1, DSL.h1, @od.h1],
112
+ [H2, DSL.h2, @od.h2],
113
+ [H3, DSL.h3, @od.h3],
114
+ [H4, DSL.h4, @od.h4],
115
+ [H5, DSL.h5, @od.h5],
116
+ [H6, DSL.h6, @od.h6]
117
+ ].each do |klass, dsl, od|
118
+ dsl.should be_kind_of(klass)
119
+ od.should be_kind_of(klass)
120
+ end
71
121
  end
72
122
 
73
123
  def test_p
74
124
  assert_equal(:p, P.new.name)
125
+ assert_kind_of(P, DSL.p)
126
+ @od.p.should be_kind_of(P)
75
127
  end
76
128
 
77
129
  def test_a
78
130
  assert_equal(:a, A.new.name)
131
+ assert_kind_of(A, DSL.a)
132
+ @od.a.should be_kind_of(A)
79
133
  end
80
134
 
81
135
  def test_em
82
- assert_equal(:em, Em.new.name)
136
+ assert_equal(:em, EM.new.name)
137
+ assert_kind_of(EM, DSL.em)
138
+ @od.em.should be_kind_of(EM)
83
139
  end
84
140
 
85
141
  def test_strong
86
- assert_equal(:strong, Strong.new.name)
142
+ assert_equal(:strong, STRONG.new.name)
143
+ assert_kind_of(STRONG, DSL.strong)
144
+ @od.strong.should be_kind_of(STRONG)
87
145
  end
88
146
 
89
147
  def test_div
90
- assert_equal(:div, Div.new.name)
148
+ assert_equal(:div, DIV.new.name)
149
+ assert_kind_of(DIV, DSL.div)
150
+ @od.div.should be_kind_of(DIV)
91
151
  end
92
152
 
93
153
  def test_ul
94
- assert_equal(:ul, Ul.new.name)
154
+ assert_equal(:ul, UL.new.name)
155
+ assert_kind_of(UL, DSL.ul)
156
+ @od.ul.should be_kind_of(UL)
95
157
  end
96
158
 
97
159
  def test_ol
98
- assert_equal(:ol, Ol.new.name)
160
+ assert_equal(:ol, OL.new.name)
161
+ assert_kind_of(OL, DSL.ol)
162
+ @od.ol.should be_kind_of(OL)
99
163
  end
100
164
 
101
165
  def test_li
102
- assert_equal(:li, Li.new.name)
166
+ assert_equal(:li, LI.new.name)
167
+ assert_kind_of(LI, DSL.li)
168
+ @od.li.should be_kind_of(LI)
169
+ end
170
+
171
+ def test_dl
172
+ DL.new.name.should == :dl
173
+ DSL.dl.should be_kind_of(DL)
174
+ @od.dl.should be_kind_of(DL)
175
+ end
176
+
177
+ def test_dt
178
+ DT.new.name.should == :dt
179
+ DSL.dt.should be_kind_of(DT)
180
+ @od.dt.should be_kind_of(DT)
181
+ end
182
+
183
+ def test_dd
184
+ DD.new.name.should == :dd
185
+ DSL.dd.should be_kind_of(DD)
186
+ @od.dd.should be_kind_of(DD)
187
+ end
188
+
189
+ def test_table
190
+ assert_equal(:table, TABLE.new.name)
191
+ assert_kind_of(TABLE, DSL.table)
192
+ @od.table.should be_kind_of(TABLE)
193
+ end
194
+
195
+ def test_caption
196
+ assert_equal(:caption, CAPTION.new.name)
197
+ assert_kind_of(CAPTION, DSL.caption)
198
+ @od.caption.should be_kind_of(CAPTION)
199
+ end
200
+
201
+ def test_tr
202
+ assert_equal(:tr, TR.new.name)
203
+ assert_kind_of(TR, DSL.tr)
204
+ @od.tr.should be_kind_of(TR)
205
+ end
206
+
207
+ def test_th
208
+ assert_equal(:th, TH.new.name)
209
+ assert_kind_of(TH, DSL.th)
210
+ @od.th.should be_kind_of(TH)
211
+ end
212
+
213
+ def test_td
214
+ assert_equal(:td, TD.new.name)
215
+ assert_kind_of(TD, DSL.td)
216
+ @od.td.should be_kind_of(TD)
217
+ end
218
+
219
+ def test_form
220
+ assert_equal(:form, FORM.new.name)
221
+ assert_kind_of(FORM, DSL.form)
222
+ @od.form.should be_kind_of(FORM)
103
223
  end
104
224
 
105
225
  def test_text_area
106
- assert_equal(Element.new(:textarea, :name=>"item"), TextArea.new("item"))
107
- assert_equal(Element.new(:textarea, :name=>"item"), TextArea.new(:item))
108
- assert_equal(Element.new(:textarea, :name=>"item", :class=>"cv"), TextArea.new("item", :class=>"cv"))
226
+ assert_equal(Element.new(:textarea, :name=>"item"), TEXTAREA.new("item"))
227
+ assert_equal(Element.new(:textarea, :name=>:item), TEXTAREA.new(:item))
228
+ assert_equal(Element.new(:textarea, :name=>"item", :class=>"cv"), TEXTAREA.new("item", :class=>"cv"))
229
+
230
+ t = DSL.textarea("t")
231
+ assert_kind_of(TEXTAREA, t)
232
+ assert_equal("t", t[:name])
233
+
234
+ t = @od.textarea("t")
235
+ t.should be_kind_of(TEXTAREA)
236
+ t[:name].should == "t"
109
237
  end
110
238
 
111
239
  def test_input
112
- assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"), Input.new(:test, :item, "v"))
113
- assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"), Input.new("test", "item", "v"))
114
- assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v", :class=>"c"), Input.new(:test, :item, "v", :class=>"c"))
240
+ assert_equal(Element.new(:input, :type=>:test, :name=>:item, :value=>"v"), INPUT.new(:test, :item, "v"))
241
+ assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"), INPUT.new("test", "item", "v"))
242
+ assert_equal(Element.new(:input, :type=>:test, :name=>:item, :value=>"v", :class=>"c"), INPUT.new(:test, :item, "v", :class=>"c"))
243
+
244
+ assert_equal(Element.new(:input, :type=>:submit, :value=>"v"), INPUT.new(:submit, nil, "v"))
245
+ assert_equal(Element.new(:input, :type=>:submit, :name=>"item"), INPUT.new(:submit, "item", nil))
246
+
247
+ i = DSL.input(:dummy, :n, :v)
248
+ assert_kind_of(INPUT, i)
249
+ assert_match(INPUT.new(:dummy, :n, :v), i)
115
250
 
116
- assert_equal(Element.new(:input, :type=>"submit", :value=>"v"), Input.new(:submit, nil, "v"))
117
- assert_equal(Element.new(:input, :type=>"submit", :name=>"item"), Input.new(:submit, "item", nil))
251
+ i = @od.input(:dummy, :n, :v)
252
+ i.should be_kind_of(INPUT)
253
+ i.should == INPUT.new(:dummy, :n, :v)
118
254
  end
119
255
 
120
256
  def test_hidden
121
- assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v"), Hidden.new("item", "v"))
122
- assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v"), Hidden.new(:item, "v"))
123
- assert_equal(Element.new(:input, :type=>"hidden", :name=>"item", :value=>"v", :class=>"c"), Hidden.new(:item, "v", :class=>"c"))
257
+ assert_equal(Element.new(:input, :type=>:hidden, :name=>"item", :value=>"v"), HIDDEN.new("item", "v"))
258
+ assert_equal(Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v"), HIDDEN.new(:item, "v"))
259
+ assert_equal(Element.new(:input, :type=>:hidden, :name=>:item, :value=>"v", :class=>"c"), HIDDEN.new(:item, "v", :class=>"c"))
260
+
261
+ h = DSL.hidden(:n, :v)
262
+ assert_kind_of(HIDDEN, h)
263
+ assert_match(HIDDEN.new(:n, :v), h)
264
+
265
+ h = @od.hidden(:n, :v)
266
+ h.should be_kind_of(HIDDEN)
267
+ h.should == HIDDEN.new(:n, :v)
124
268
  end
125
269
 
126
270
  def test_submit
127
- assert_equal(Element.new(:input, :type=>"submit"), Submit.new)
128
- assert_equal(Element.new(:input, :type=>"submit", :value=>"OK"), Submit.new("OK"))
129
- assert_equal(Element.new(:input, :type=>"submit", :value=>"OK", :class=>"c"), Submit.new("OK", :class=>"c"))
271
+ assert_equal(Element.new(:input, :type=>:submit), SUBMIT.new)
272
+ assert_equal(Element.new(:input, :type=>:submit, :value=>"OK"), SUBMIT.new(:value=>"OK"))
273
+ assert_equal(Element.new(:input, :type=>:submit, :value=>"OK", :class=>"c"), SUBMIT.new(:value=>"OK", :class=>"c"))
274
+ opt = {:value=>"v", :name=>"n"}
275
+ opt2 = opt.dup
276
+ SUBMIT.new(opt2)
277
+ assert_equal(opt, opt2)
278
+
279
+ s = DSL.submit
280
+ assert_kind_of(SUBMIT, s)
281
+ assert_match(SUBMIT.new, s)
282
+ assert(!s[:name])
283
+ assert(!s[:value])
284
+ s = DSL.submit(:name=>:s, :value=>:v)
285
+ assert_equal(:s, s[:name])
286
+ assert_equal(:v, s[:value])
287
+
288
+ s = @od.submit
289
+ s.should be_kind_of(SUBMIT)
290
+ s.should == SUBMIT.new
291
+ s[:name].should be_nil
292
+ s[:value].should be_nil
293
+ s = @od.submit(:name=>:s, :value=>:v)
294
+ s.should == SUBMIT.new(:name=>:s, :value=>:v)
130
295
  end
131
296
 
132
297
  def test_text
133
- assert_equal(Element.new(:input, :type=>"text", :name=>"item"), Text.new(:item))
134
- assert_equal(Element.new(:input, :type=>"text", :name=>"item"), Text.new("item"))
135
- assert_equal(Element.new(:input, :type=>"text", :name=>"item", :value=>"txt"), Text.new(:item, "txt"))
136
- assert_equal(Element.new(:input, :type=>"text", :name=>"item", :value=>"txt", :class=>"c"), Text.new(:item, "txt", :class=>"c"))
298
+ assert_equal(Element.new(:input, :type=>:text, :name=>:item), TEXT.new(:item))
299
+ assert_equal(Element.new(:input, :type=>:text, :name=>"item"), TEXT.new("item"))
300
+ assert_equal(Element.new(:input, :type=>:text, :name=>:item, :value=>"txt"), TEXT.new(:item, "txt"))
301
+ assert_equal(Element.new(:input, :type=>:text, :name=>:item, :value=>"txt", :class=>"c"), TEXT.new(:item, "txt", :class=>"c"))
302
+
303
+ t = DSL.text(:n, :v)
304
+ assert_kind_of(TEXT, t)
305
+ assert_match(TEXT.new(:n, :v), t)
306
+
307
+ t = @od.text(:n, :v)
308
+ t.should be_kind_of(TEXT)
309
+ t.should == TEXT.new(:n, :v)
310
+ end
311
+ end
312
+
313
+ describe EimXML::XHTML::OpenDSL do
314
+ it "replace EimXML::XHTML::DSL" do
315
+ e = EimXML::XHTML::OpenDSL.html do |d|
316
+ d.head do
317
+ d.title.add "Title"
318
+ end
319
+ d.body do
320
+ d.h1.add "Sample"
321
+ d.p do
322
+ d.add "text"
323
+ d.add "next"
324
+ end
325
+ end
326
+ end
327
+ e.should == EimXML::XHTML::DSL.html do
328
+ head do
329
+ title.add "Title"
330
+ end
331
+ body do
332
+ h1.add "Sample"
333
+ p do
334
+ add "text"
335
+ add "next"
336
+ end
337
+ end
338
+ end
137
339
  end
138
340
  end
metadata CHANGED
@@ -1,50 +1,44 @@
1
1
  --- !ruby/object:Gem::Specification
2
- rubygems_version: 0.9.4
3
- specification_version: 1
4
2
  name: eimxml
5
3
  version: !ruby/object:Gem::Version
6
- version: 0.0.1
7
- date: 2007-10-23 00:00:00 +09:00
8
- summary: Easy IMplemented XML
9
- require_paths:
10
- - lib
11
- email: hiraku@hinet.mydns.jp
12
- homepage: http://eimxml.rubyforge.org/
13
- rubyforge_project: eimxml
14
- description:
15
- autorequire:
16
- default_executable:
17
- bindir: bin
18
- has_rdoc: true
19
- required_ruby_version: !ruby/object:Gem::Version::Requirement
20
- requirements:
21
- - - ">"
22
- - !ruby/object:Gem::Version
23
- version: 0.0.0
24
- version:
4
+ version: 0.0.2
25
5
  platform: ruby
26
- signing_key:
27
- cert_chain:
28
- post_install_message:
29
6
  authors:
30
7
  - KURODA Hiraku
8
+ autorequire:
9
+ bindir: bin
10
+ cert_chain: []
11
+
12
+ date: 2008-04-14 00:00:00 -04:00
13
+ default_executable:
14
+ dependencies: []
15
+
16
+ description:
17
+ email: hiraku@hinet.mydns.jp
18
+ executables: []
19
+
20
+ extensions: []
21
+
22
+ extra_rdoc_files:
23
+ - README
31
24
  files:
32
25
  - lib
33
- - test
34
- - Rakefile
35
- - README
36
26
  - lib/eim_xml.rb
37
27
  - lib/eim_xml
38
28
  - lib/eim_xml/parser.rb
29
+ - lib/eim_xml/matcher.rb
39
30
  - lib/eim_xml/assertions.rb
40
- - test/assertions_test.rb
41
- - test/eim_xml_test.rb
42
- - test/parser_test.rb
43
- test_files:
44
- - test/assertions_test.rb
31
+ - lib/eim_xml/xhtml.rb
32
+ - README
33
+ - Rakefile
34
+ - test
45
35
  - test/xhtml_test.rb
46
36
  - test/eim_xml_test.rb
37
+ - test/assertions_test.rb
47
38
  - test/parser_test.rb
39
+ has_rdoc: true
40
+ homepage: http://eimxml.rubyforge.org/
41
+ post_install_message:
48
42
  rdoc_options:
49
43
  - -S
50
44
  - -w
@@ -53,13 +47,29 @@ rdoc_options:
53
47
  - UTF-8
54
48
  - -m
55
49
  - README
56
- extra_rdoc_files:
57
- - README
58
- executables: []
59
-
60
- extensions: []
61
-
50
+ require_paths:
51
+ - lib
52
+ required_ruby_version: !ruby/object:Gem::Requirement
53
+ requirements:
54
+ - - ">="
55
+ - !ruby/object:Gem::Version
56
+ version: "0"
57
+ version:
58
+ required_rubygems_version: !ruby/object:Gem::Requirement
59
+ requirements:
60
+ - - ">="
61
+ - !ruby/object:Gem::Version
62
+ version: "0"
63
+ version:
62
64
  requirements: []
63
65
 
64
- dependencies: []
65
-
66
+ rubyforge_project: eimxml
67
+ rubygems_version: 1.1.1
68
+ signing_key:
69
+ specification_version: 2
70
+ summary: Easy IMplemented XML
71
+ test_files:
72
+ - test/xhtml_test.rb
73
+ - test/eim_xml_test.rb
74
+ - test/assertions_test.rb
75
+ - test/parser_test.rb