class WriterXML
Attributes
Public Class Methods
# File lib/writerxml.rb, line 4 def initialize(para) end
Public Instance Methods
Metodo para obtener los atributos del objecto
# File lib/writerxml.rb, line 122 def [](key) @attributes = Array.new if @attributes.nil? attributes_downcase =@attributes.map(&:downcase) key.downcase! if attributes_downcase.include? key return get(key) else raise 'El atributo no ha sido encontrado en el objecto '+ key end end
Metodo para escribir atributos en el objecto
# File lib/writerxml.rb, line 136 def []= (key, value) key.downcase! attributes_downcase =@attributes.map(&:downcase) if attributes_downcase.include? key set(key, value) else raise 'El atributo '+ key + ' no ha sido encontrado' end end
Metodo que lee el hash o el arreglo y asigna cada uno de los valores a sus respetivas variables @param [Hash] [Array]
# File lib/writerxml.rb, line 39 def from_hash(para) hash_objects = from_hash_to_array_objects(para) set_atr_object_from_hash(para,hash_objects) end
Metodo que obtiene el objecto o el atributos de la clase @return [Object] regresa un objecto dependiendo del atributos o nodos
# File lib/writerxml.rb, line 95 def get(key) case key when Symbol return instance_variable_get("@#{key}") when String return instance_variable_get("@#{key}") end end
Metodo que inicializa la clase
# File lib/writerxml.rb, line 11 def init(para=nil) #JSON.parse(s,:symbolize_names => true) @attributes = Array.new if @attributes.nil? @sequence = Array.new if @sequence.nil? set_objects_to_acessor set_attributes_to_reader if para.kind_of? Hash from_hash(para) end end
Metodo que revise la existencia del atributos dentro de la clase @param [Sysbol, String] @return [Boolean]
# File lib/writerxml.rb, line 151 def instance_attribute_defined?(key) case key when Symbol return instance_variable_defined?("@#{key}") when String return instance_variable_defined?("@#{key}") end end
Asignara una instancia basandose en el symbolo que se indica en el parametro @param [Symbol, String] , [Object]
# File lib/writerxml.rb, line 109 def set(key, value) case key when Symbol return instance_variable_set("@#{key}", value) when String return instance_variable_set("@#{key}", value) end end
Metodo para colocar los atributos como attr_reader
# File lib/writerxml.rb, line 62 def set_attributes_to_reader if !@attributes.empty? @attributes.each { |ele| self.class.__send__(:attr_reader, ele.downcase) } end end
Metodo para colocar los objecto como attr_acessor
# File lib/writerxml.rb, line 48 def set_objects_to_acessor if !@sequence.empty? @sequence.each { |ele| self.class.__send__(:attr_accessor, ele.downcase) } end end
Metodo que leera cada uno de los atributos y hara un hash de toda la clase @return [Hash] crear un hash leyendo las variables
# File lib/writerxml.rb, line 76 def to_hash hash = {} if !@attributes.nil? return hash end @attributes.each { |attr| downcaseAttr = attr.downcase if instance_attribute_defined?(downcaseAttr) hash[attr.to_sym] = get(downcaseAttr) end } return hash; end
Metodo que actualiza los parametros despues de hacer el new
# File lib/writerxml.rb, line 27 def update(para) if para.kind_of? Hash from_hash(para) end end
Escribira en el objecto del parametro y revisara si el objecto es raiz o es un nodo de una sequencia, si es la raiz agregara un prefijo si esta especificado en las variables de instancia @param [Nokogiri::XML::Builder ]
# File lib/writerxml.rb, line 167 def writeXML(xml) if @targetNamespace.nil? xml.send(self.class.to_s){ write_attributes_elements(xml) } else prefix = "#{@targetNamespace[:prefix]}" namespace = "#{@targetNamespace[:namespace]}" xml.send(self.class.to_s){ ins = xml.parent.add_namespace_definition(prefix, namespace) xml.parent.namespace = ins write_attributes_elements(xml) } end end
Private Instance Methods
Este metodo coloca todos los atributos y ademas tambien coloca los namespace en un hash, es usando para poder usar el metodo de writerXML @return [Hash]
# File lib/writerxml.rb, line 190 def attribites_to_hash hash = {} if !@attributes.nil? @attributes.each { |attr| downcaseAttr = attr.downcase if instance_attribute_defined?(downcaseAttr) hash[attr.to_sym] = get(downcaseAttr) end } end if !@schemaLocation.nil? hash["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance" hash["xsi:schemaLocation"] = "#{@schemaLocation}" end return hash; end
Revisa la secuencia, si la secuencia no esta en vacio reguesa un hash con el nombre de las clases, en cambio si esta vacio, asigna variables de objecto a la clase raiz @param [Hash] [Array] @return [Hash] regresa el nombre de clases con key de la clase en minusculas
# File lib/writerxml.rb, line 266 def from_hash_to_array_objects(para) hash_objects = {} if !@sequence.empty? @sequence.each { |o| hash_objects[o.downcase.to_sym] = o } else if para.kind_of?(Array) @objects= Array.new array_hashing = para array_hashing.each { | l | l.each { |k, v| object = Object.const_get(k.to_s).new(v) @objects << object } } end end return hash_objects end
Revisa que el los valores del hash no haya valores que son arreglos sino busca sus objectos, si estan en la secuencia los crea a partir de alli, sino esta en la secuencia los asigna a un objeto llamado objectos. @param [Array] es el arreglo que se encontro en el from_hash
@param [Array] es el Symbol que se encontro en el from_hash
y estan en minusculas @param [Hash] son las clases disponibles en la sequence
# File lib/writerxml.rb, line 334 def kind_of_value_inside_array(array, key_downcase, hash_objects) sequence_downcase =@sequence.map(&:downcase) objects= Array.new if sequence_downcase.include? key_downcase.to_s array.each { |e| object = Object.const_get(hash_objects[key_downcase.to_sym]).new(e) objects << object } set( key_downcase, objects) end end
Metodo para buscar los objecto de la secuencia y instanciarlos en un arreglo donde seran utilizado para el metodo writeXML @return [Array]
# File lib/writerxml.rb, line 233 def sequence_to_array_objects @sequence = Array.new if @sequence.nil? array = [] if !@sequence.empty? @sequence.each { |element| downcaseElement = element.downcase if instance_attribute_defined?(downcaseElement) object = get(downcaseElement) if object.kind_of?(Array) array.concat object else array << object end end } else if !@objects.nil? @objects.each { |o| array << o } end end return array; end
Metodo que mapea todo el hash a un asignacion en la clase, se basa los atributos y sequence inicializada en la para de arriba @param [Hash] es hash es para mapear todos los atributos con sus asignaciones @param [Array] es un arreglo con el nombre de los objectos, es como se llaman los objectos ya que se inicializara y se asignaran
# File lib/writerxml.rb, line 293 def set_atr_object_from_hash(para, hash_objects) attributes_downcase =@attributes.map(&:downcase) elements_downcase =@sequence.map(&:downcase) if para.kind_of? Hash para.each { |key, value| keyDowncase = key.downcase if(attributes_downcase.include?( keyDowncase.to_s)) set( keyDowncase, value) elsif (elements_downcase.include?(keyDowncase.to_s)) if(value.kind_of?(Hash)) object = Object.const_get(hash_objects[keyDowncase.to_sym]).new(value) set( keyDowncase, object) elsif (value.kind_of?(Array)) kind_of_value_inside_array(value, keyDowncase, hash_objects) end end } elsif para.kind_of? Array array_objects = Array.new para.each { |l| l.each { |k, v| object = Object.const_get(k.to_s).new(v) array_objects << object } } if !@sequence.empty? set( @sequence[0].downcase.to_sym , array_objects) else @objects = array_objects end end end
Metodo que sirve para escribir los atributos y los nodos en el Nokogiri::XML::Builder @param [Nokogiri::XML::Builder ] parametro que se escribira
# File lib/writerxml.rb, line 212 def write_attributes_elements(xml) attributes = attribites_to_hash if !attributes.nil? attributes.each { |key, value| xml.parent.set_attribute(key,value) } end array_elements = sequence_to_array_objects if !array_elements.empty? array_elements.each { |object| object.writeXML(xml) } end end