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 +17 -9
- data/lib/eim_xml/matcher.rb +25 -0
- data/lib/eim_xml/parser.rb +17 -1
- data/lib/eim_xml/xhtml.rb +125 -0
- data/lib/eim_xml.rb +127 -21
- data/test/assertions_test.rb +1 -1
- data/test/eim_xml_test.rb +243 -23
- data/test/parser_test.rb +1 -1
- data/test/xhtml_test.rb +253 -51
- metadata +50 -40
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(
|
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:
|
39
|
+
task :test => "test:lump"
|
40
40
|
namespace :test do
|
41
|
-
|
42
|
-
|
43
|
-
|
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::
|
49
|
-
|
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 = "
|
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
|
data/lib/eim_xml/parser.rb
CHANGED
@@ -91,7 +91,23 @@ module EimXML
|
|
91
91
|
|
92
92
|
def parse_string(hold_space)
|
93
93
|
s = @scanner[0]
|
94
|
-
s.strip
|
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(
|
99
|
+
s.gsub(/[&\"\'<>]/) do |m|
|
16
100
|
case m
|
17
|
-
when /&\#?\w+;/
|
18
|
-
m
|
19
101
|
when "&"
|
20
102
|
"&"
|
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
|
198
|
+
@contents << v
|
115
199
|
end
|
116
200
|
self
|
117
201
|
end
|
118
202
|
alias << add
|
119
203
|
|
120
|
-
def
|
121
|
-
|
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 =
|
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
|
-
|
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|
|
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
|
-
|
145
|
-
|
146
|
-
|
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
|
151
|
-
|
152
|
-
|
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 :
|
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
|
-
|
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
|
data/test/assertions_test.rb
CHANGED
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
|
10
|
+
class PCStringTest < Test::Unit::TestCase
|
10
11
|
include EimXML
|
11
12
|
|
12
13
|
def test_encode
|
13
14
|
assert_equal("<>"'&", PCString.encode("<>\"'&"))
|
14
|
-
assert_equal("&test;", PCString.encode("&test;"))
|
15
|
-
assert_equal("
|
16
|
-
assert_equal("&test", PCString.encode("&test"))
|
17
|
-
assert_equal("&\#0ax", PCString.encode("�ax"))
|
15
|
+
assert_equal("&test;", PCString.encode("&test;"))
|
16
|
+
assert_equal("&amp;", PCString.encode("&"))
|
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;", PCString.new("&").to_xml)
|
29
34
|
end
|
30
35
|
end
|
31
36
|
|
32
|
-
class
|
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([
|
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
|
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.
|
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.
|
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.
|
123
|
-
assert_equal(" <super>\n <sub />\n <sub2 />\n </super>", e.
|
124
|
-
assert_equal("<super>\n <sub />\n <sub2 />\n </super>", e.
|
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.
|
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.
|
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.
|
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=''"<>&'/, s)
|
143
149
|
|
144
150
|
e = Element.new("el", {"a1"=>nil})
|
145
|
-
assert_equal("<el a1='a1' />", e.
|
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
|
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
|
-
|
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,
|
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
|
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
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
|
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
|
-
|
26
|
-
|
27
|
-
|
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
|
-
|
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
|
-
|
34
|
-
|
35
|
-
|
36
|
-
|
37
|
-
|
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
|
-
|
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
|
-
|
42
|
-
|
43
|
-
|
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
|
47
|
-
assert_equal(:
|
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,
|
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,
|
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,
|
60
|
-
|
61
|
-
|
62
|
-
|
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
|
-
|
68
|
-
|
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,
|
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,
|
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,
|
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,
|
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,
|
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,
|
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"),
|
107
|
-
assert_equal(Element.new(:textarea, :name
|
108
|
-
assert_equal(Element.new(:textarea, :name=>"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
|
113
|
-
assert_equal(Element.new(:input, :type=>"test", :name=>"item", :value=>"v"),
|
114
|
-
assert_equal(Element.new(:input, :type
|
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
|
-
|
117
|
-
|
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
|
122
|
-
assert_equal(Element.new(:input, :type
|
123
|
-
assert_equal(Element.new(:input, :type
|
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
|
128
|
-
assert_equal(Element.new(:input, :type
|
129
|
-
assert_equal(Element.new(:input, :type
|
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
|
134
|
-
assert_equal(Element.new(:input, :type
|
135
|
-
assert_equal(Element.new(:input, :type
|
136
|
-
assert_equal(Element.new(:input, :type
|
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.
|
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
|
-
-
|
41
|
-
-
|
42
|
-
-
|
43
|
-
|
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
|
-
|
57
|
-
-
|
58
|
-
|
59
|
-
|
60
|
-
|
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
|
-
|
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
|