1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
|
require "forwardable"
require "rss/rss"
module RSS
class NotWellFormedError < Error
attr_reader :line, :element
def initialize(line=nil, element=nil)
message = "This is not well formed XML"
if element or line
message << "\nerror occurred"
message << " in #{element}" if element
message << " at about #{line} line" if line
end
message << "\n#{yield}" if block_given?
super(message)
end
end
class XMLParserNotFound < Error
def initialize
super("available XML parser does not found in " <<
"#{AVAILABLE_PARSER_LIBRARIES.inspect}.")
end
end
class NotValidXMLParser < Error
def initialize(parser)
super("#{parser} is not available XML parser. " <<
"available XML parser is " <<
"#{AVAILABLE_PARSERS.inspect}.")
end
end
class NSError < InvalidRSSError
attr_reader :tag, :prefix, :uri
def initialize(tag, prefix, require_uri)
@tag, @prefix, @uri = tag, prefix, require_uri
super("prefix <#{prefix}> doesn't associate uri " <<
"<#{require_uri}> in tag <#{tag}>")
end
end
class Parser
extend Forwardable
class << self
@@default_parser = nil
def default_parser
@@default_parser || AVAILABLE_PARSERS.first
end
def default_parser=(new_value)
if AVAILABLE_PARSERS.include?(new_value)
@@default_parser = new_value
else
raise NotValidXMLParser.new(new_value)
end
end
def parse(rss, do_validate=true, ignore_unknown_element=true, parser_class=default_parser)
parser = new(rss, parser_class)
parser.do_validate = do_validate
parser.ignore_unknown_element = ignore_unknown_element
parser.parse
end
end
def_delegators(:@parser, :parse, :rss,
:ignore_unknown_element,
:ignore_unknown_element=, :do_validate,
:do_validate=)
def initialize(rss, parser_class=self.class.default_parser)
@parser = parser_class.new(rss)
end
end
class BaseParser
def initialize(rss)
@listener = listener.new
@rss = rss
end
def rss
@listener.rss
end
def ignore_unknown_element
@listener.ignore_unknown_element
end
def ignore_unknown_element=(new_value)
@listener.ignore_unknown_element = new_value
end
def do_validate
@listener.do_validate
end
def do_validate=(new_value)
@listener.do_validate = new_value
end
def parse
if @listener.rss.nil?
_parse
end
@listener.rss
end
end
class BaseListener
extend Utils
class << self
@@setter = {}
def install_setter(uri, tag_name, setter)
@@setter[uri] = {} unless @@setter.has_key?(uri)
@@setter[uri][tag_name] = setter
end
def setter(uri, tag_name)
begin
@@setter[uri][tag_name]
rescue NameError
nil
end
end
def available_tags(uri)
begin
@@setter[uri].keys
rescue NameError
[]
end
end
def install_get_text_element(name, uri, setter)
install_setter(uri, name, setter)
def_get_text_element(name, *get_file_and_line_from_caller(1))
end
private
def def_get_text_element(name, file, line)
unless private_instance_methods(false).include?("start_#{name}")
module_eval(<<-EOT, file, line)
def start_#{name}(name, prefix, attrs, ns)
uri = ns[prefix]
if @do_validate
tags = self.class.available_tags(uri)
unless tags.include?(name)
raise UnknownTagError.new(name, uri)
end
end
start_get_text_element(name, prefix, ns, uri)
end
EOT
end
send("private", "start_#{name}")
end
end
end
module ListenerMixin
attr_reader :rss
attr_accessor :ignore_unknown_element
attr_accessor :do_validate
def initialize
@rss = nil
@ignore_unknown_element = true
@do_validate = true
@ns_stack = [{}]
@tag_stack = [[]]
@text_stack = ['']
@proc_stack = []
@last_element = nil
@version = @encoding = @standalone = nil
end
def xmldecl(version, encoding, standalone)
@version, @encoding, @standalone = version, encoding, standalone
end
def tag_start(name, attributes)
@text_stack.push('')
ns = @ns_stack.last.dup
attrs = {}
attributes.each do |n, v|
if n =~ /\Axmlns:?/
ns[$'] = v # $' is post match
else
attrs[n] = v
end
end
@ns_stack.push(ns)
prefix, local = split_name(name)
@tag_stack.last.push([ns[prefix], local])
@tag_stack.push([])
if respond_to?("start_#{local}", true)
send("start_#{local}", local, prefix, attrs, ns.dup)
else
start_else_element(local, prefix, attrs, ns.dup)
end
end
def tag_end(name)
if DEBUG
p "end tag #{name}"
p @tag_stack
end
text = @text_stack.pop
tags = @tag_stack.pop
pr = @proc_stack.pop
pr.call(text, tags) unless pr.nil?
end
def text(data)
@text_stack.last << data
end
private
def start_RDF(tag_name, prefix, attrs, ns)
check_ns(tag_name, prefix, ns, RDF::URI)
@rss = RDF.new(@version, @encoding, @standalone)
@rss.do_validate = @do_validate
@last_element = @rss
@proc_stack.push Proc.new { |text, tags|
@rss.validate_for_stream(tags) if @do_validate
}
end
def start_else_element(local, prefix, attrs, ns)
class_name = local[0,1].upcase << local[1..-1]
current_class = @last_element.class
begin
# if current_class.const_defined?(class_name)
next_class = current_class.const_get(class_name)
start_have_something_element(local, prefix, attrs, ns, next_class)
rescue NameError
# else
if @ignore_unknown_element
@proc_stack.push(nil)
else
parent = "ROOT ELEMENT???"
begin
parent = current_class::TAG_NAME
rescue NameError
end
raise NotExceptedTagError.new(local, parent)
end
end
end
NAMESPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
def split_name(name)
name =~ NAMESPLIT
[$1 || '', $2]
end
def check_ns(tag_name, prefix, ns, require_uri)
if @do_validate
if ns[prefix] == require_uri
#ns.delete(prefix)
else
raise NSError.new(tag_name, prefix, require_uri)
end
end
end
def start_get_text_element(tag_name, prefix, ns, required_uri)
@proc_stack.push Proc.new {|text, tags|
setter = self.class.setter(required_uri, tag_name)
setter ||= "#{tag_name}="
if @last_element.respond_to?(setter)
@last_element.send(setter, text.to_s)
else
if @do_validate and not @ignore_unknown_element
raise NotExceptedTagError.new(tag_name, @last_element.tag_name)
end
end
}
end
def start_have_something_element(tag_name, prefix, attrs, ns, klass)
check_ns(tag_name, prefix, ns, klass.required_uri)
args = []
klass.get_attributes.each do |a_name, a_uri, required|
if a_uri
for prefix, uri in ns
if uri == a_uri
val = attrs["#{prefix}:#{a_name}"]
break if val
end
end
else
val = attrs[a_name]
end
if @do_validate and required and val.nil?
raise MissingAttributeError.new(tag_name, a_name)
end
args << val
end
previous = @last_element
next_element = klass.send(:new, *args)
next_element.do_validate = @do_validate
setter = ""
setter << "#{klass.required_prefix}_" if klass.required_prefix
setter << "#{tag_name}="
@last_element.send(setter, next_element)
@last_element = next_element
@proc_stack.push Proc.new { |text, tags|
p(@last_element.class) if DEBUG
@last_element.content = text if klass.have_content?
@last_element.validate_for_stream(tags) if @do_validate
@last_element = previous
}
end
end
unless const_defined? :AVAILABLE_PARSER_LIBRARIES
AVAILABLE_PARSER_LIBRARIES = [
["rss/xmlparser", :XMLParserParser],
["rss/xmlscanner", :XMLScanParser],
["rss/rexmlparser", :REXMLParser],
]
end
AVAILABLE_PARSERS = []
AVAILABLE_PARSER_LIBRARIES.each do |lib, parser|
begin
require lib
AVAILABLE_PARSERS.push(const_get(parser))
rescue LoadError
end
end
if AVAILABLE_PARSERS.empty?
raise XMLParserNotFound
end
end
|