Class: ONIX::SubsetDSL

Inherits:
Subset
  • Object
show all
Defined in:
lib/onix/subset.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Subset

parse, #tag_match, tag_match

Constructor Details

#initialize ⇒ SubsetDSL

Returns a new instance of SubsetDSL.



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# File 'lib/onix/subset.rb', line 261

def initialize
  # initialize plural as Array
  self.class.ancestors_registered_elements.each do |k, e|
    if e.is_array?
      # register a contextual SubsetArray object
      subset_array = SubsetArray.new
      subset_klass = self.class.get_class(e.class_name)
      if subset_klass.respond_to? :registered_scopes
        subset_klass.registered_scopes.each do |n, l|
          unless subset_array.respond_to? n.to_s
            subset_array.define_singleton_method(n.to_s) do
              instance_exec(&l)
            end
          end
        end
      end
      instance_variable_set(e.to_instance, subset_array)
    end
  end
end

Class Method Details

._ancestor_registered_scopes ⇒ Object 



209
210
211
212
213
214
215
216
217
 
# File 'lib/onix/subset.rb', line 209

def self._ancestor_registered_scopes
  els=self.registered_scopes
  sup=self
  while sup.respond_to?(:registered_scopes)
    els.merge!(sup.registered_scopes) if sup.registered_scopes
    sup=sup.superclass
  end
  els
end

._ancestors_registered_elements ⇒ Object 



243
244
245
246
247
248
249
250
251
 
# File 'lib/onix/subset.rb', line 243

def self._ancestors_registered_elements
  els=self.registered_elements
  sup=self
  while sup.respond_to?(:registered_elements)
    els.merge!(sup.registered_elements) if sup.registered_elements
    sup=sup.superclass
  end
  els
end

.ancestor_registered_scopes ⇒ Object 



219
220
221
 
# File 'lib/onix/subset.rb', line 219

def self.ancestor_registered_scopes
  @ancestors_registered_scopes||=_ancestor_registered_scopes
end

.ancestors_registered_elements ⇒ Object 



253
254
255
 
# File 'lib/onix/subset.rb', line 253

def self.ancestors_registered_elements
  @ancestors_registered_elements||=_ancestors_registered_elements
end

.element(name, type, options = {}) ⇒ Object 



227
228
229
230
231
232
233
234
235
236
 
# File 'lib/onix/subset.rb', line 227

def self.element(name, type, options={})
  @elements ||= {}
  @elements[name]=ElementParser.new(name, type, options)
  short_name=self.ref_to_short(name)
  if short_name
    @elements[short_name]=@elements[name].dup
    @elements[short_name].short = true
  end
  attr_accessor @elements[name].to_sym
end

.elements(name, type, options = {}) ⇒ Object

shortcut for element :array=>true



239
240
241
 
# File 'lib/onix/subset.rb', line 239

def self.elements(name, type, options={})
  self.element(name, type, options.merge(:array => true))
end

.get_class(name) ⇒ Object 



290
291
292
 
# File 'lib/onix/subset.rb', line 290

def self.get_class(name)
  ONIX.const_get(name) if ONIX.const_defined? name
end

.ref_to_short(name) ⇒ Object 



286
287
288
 
# File 'lib/onix/subset.rb', line 286

def self.ref_to_short(name)
  RefToShort.names[name]
end

.registered_elements ⇒ Object 



257
258
259
 
# File 'lib/onix/subset.rb', line 257

def self.registered_elements
  @elements||{}
end

.registered_scopes ⇒ Object 



223
224
225
 
# File 'lib/onix/subset.rb', line 223

def self.registered_scopes
  @scopes||{}
end

.scope(name, lambda) ⇒ Object 



204
205
206
207
 
# File 'lib/onix/subset.rb', line 204

def self.scope(name, lambda)
  @scopes ||= {}
  @scopes[name] = lambda
end

.short_to_ref(name) ⇒ Object 



282
283
284
 
# File 'lib/onix/subset.rb', line 282

def self.short_to_ref(name)
  ShortToRef.names[name]
end

Instance Method Details

#parse(n) ⇒ Object 



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
 
# File 'lib/onix/subset.rb', line 294

def parse(n)
  n.elements.each do |t|
    name = t.name
    e=self.class.ancestors_registered_elements[name]
    if e
      case e.type
        when :subset
          val=self.class.get_class(e.class_name).parse(t)
        when :text
          val=t.text
        when :integer
          val=t.text.to_i
        when :float
          val=t.text.to_f
        when :bool
          val=true
        when :ignore
          val=nil
        else
          val=t.text
      end
      if val
        if e.is_array?
          instance_variable_get(e.to_instance).send(:push, val)
        else
          instance_variable_set(e.to_instance, e.parse_lambda(val))
        end
      end
    else
      unsupported(t)
    end
  end
end

#unsupported(tag) ⇒ Object 



328
329
330
331
 
# File 'lib/onix/subset.rb', line 328

def unsupported(tag)
#      raise SubsetUnsupported,tag.name
#      puts "SubsetUnsupported: #{self.class}##{tag.name} (#{self.class.short_to_ref(tag.name)})"
end