Class: DDEX::Element

Inherits:

Object

Object
DDEX::Element

Includes:: ROXML

Defined in:: lib/ddex/element.rb

Direct Known Subclasses

Constant Summary collapse

XML_PARSER = Set parser for ROXML

"nokogiri".freeze

Class Method Summary collapse

.ns ⇒ Object

Instance Method Summary collapse

#==(other) ⇒ Object
#eql?(other) ⇒ Boolean
#hash ⇒ Object
#initialize(attributes = nil) ⇒ Element constructor

Create an new instance.
#to_hash ⇒ Object

Create a Hash representation of this instance and its descendants.
#to_xml(options = {}) ⇒ Object

Creates an XML representation of this instance and its descendants.

Constructor Details

#initialize(attributes = nil) ⇒ `Element`

Create an new instance

Arguments

attributes (Hash): Values to set on the instance’s attributes, a nested Hash will result in instantiation of child objects.

Errors

ArgumentError: If attributes is not a Hash or is not nil

Raises:

(ArgumentError)

# File 'lib/ddex/element.rb', line 34

def initialize(attributes = nil)
  attributes ||= {}
  raise ArgumentError, "attributes must be a Hash" unless Hash === attributes

  attributes.each do |name, value|
    name   = name.to_s
    method = "#{name}="
    next unless attr = roxml_attributes[name] and respond_to?(method)

    if !attr.sought_type.instance_of?(Symbol) && attr.array? # If it's not a ROXML directive && ...
      value = Array(value)
    end

    if !value.is_a?(DDEX::Element) && attr.sought_type.is_a?(Class) && attr.sought_type.ancestors.include?(DDEX::Element)
      value = if attr.array? && value.is_a?(Array)
        value.map { |v| v.is_a?(DDEX::Element) ? v : attr.sought_type.new(v) }
      elsif !value.is_a?(Hash)
        attr.sought_type.new(name => value)
      else
        attr.sought_type.new(value)
      end
    end

    public_send(method, value)
  end
end

Class Method Details

.ns ⇒ `Object`



13
14
15

# File 'lib/ddex/element.rb', line 13

def ns
  @namespace
end

Instance Method Details

#==(other) ⇒ `Object`



101
102
103

# File 'lib/ddex/element.rb', line 101

def ==(other)
  eql?(other)
end

#eql?(other) ⇒ `Boolean`

Returns:

(Boolean)



97
98
99

# File 'lib/ddex/element.rb', line 97

def eql?(other)
  instance_of?(other.class) && roxml_attributes.values.all? { |attr| other.respond_to?(attr.accessor) && other.send(attr.accessor) == send(attr.accessor) }
end

#hash ⇒ `Object`



105
106
107

# File 'lib/ddex/element.rb', line 105

def hash
  to_hash.hash
end

#to_hash ⇒ `Object`

Create a Hash representation of this instance and its descendants

# File 'lib/ddex/element.rb', line 81

def to_hash
  hash = {}
  roxml_attributes.values.each do |attr|
    value = send(attr.accessor)
    value = if value.is_a?(Array)
      value.map { |v| v.respond_to?(:to_hash) ? v.to_hash : v }
    else
      value.respond_to?(:to_hash) ? value.to_hash : value
    end

    hash[attr.attr_name.to_sym] = value if value.present?
  end

  hash
end

#to_xml(options = {}) ⇒ `Object`

Creates an XML representation of this instance and its descendants. Use DDEX.write instead, it’s more flexable.

# File 'lib/ddex/element.rb', line 65

def to_xml(options = {})
  doc = super
  ns  = self.class.ns

  if ns and ns.size == 2 # prefix and name
    doc.add_namespace_definition(*ns)
    doc.name = "#{ns.first}:#{doc.name}"
  end

  doc
end