Module: Atom::Xml::Parseable::DeclarationMethods

Defined in:

lib/atom/xml/parser.rb

Overview

:nodoc:

Instance Method Summary

• #attribute(*names) ⇒ Object
• #element(*names) ⇒ Object
• #elements(*names) ⇒ Object
• #loadable!(&error_handler) ⇒ Object
• #parse(xml) ⇒ Object

Instance Method Details

#attribute(*names) ⇒ Object

# File 'lib/atom/xml/parser.rb', line 247

def attribute(*names)
  names.each do |name|
    attr_accessor name.to_s.sub(/:/, '_').to_sym
    self.attributes << name.to_s
  end
end

#element(*names) ⇒ Object

# File 'lib/atom/xml/parser.rb', line 217

def element(*names)
  options = {:type => :single}
  options.merge!(names.pop) if names.last.is_a?(Hash) 

  names.each do |name|
    attr_accessor name.to_s.sub(/:/, '_').to_sym
    ns, local_name = name.to_s[/(.*):(.*)/,1], $2 || name
    self.known_namespaces << self.extensions_namespaces[ns] if ns
    self.ordered_element_specs << self.element_specs[local_name.to_s] = ParseSpec.new(name, options)
  end
end

#elements(*names) ⇒ Object

# File 'lib/atom/xml/parser.rb', line 229

def elements(*names)
  options = {:type => :collection}
  options.merge!(names.pop) if names.last.is_a?(Hash)

  names.each do |name|
    name_sym = name.to_s.sub(/:/, '_').to_sym
    attr_writer name_sym
    define_method name_sym do 
      ivar = :"@#{name_sym}"
      self.instance_variable_set ivar, [] unless self.instance_variable_defined? ivar
      self.instance_variable_get ivar
    end
    ns, local_name = name.to_s[/(.*):(.*)/,1], $2 || name
    self.known_namespaces << self.extensions_namespaces[ns] if ns
    self.ordered_element_specs << self.element_specs[local_name.to_s.singularize] = ParseSpec.new(name, options)
  end
end

#loadable!(&error_handler) ⇒ Object

# File 'lib/atom/xml/parser.rb', line 254

def loadable!(&error_handler)
  class_name = self.name
  (class << self; self; end).instance_eval do
    
    define_method "load_#{class_name.demodulize.downcase}" do |*args|
       o = args.first
       opts = args.size > 1 ? args.last : {}
       
       xml = 
        case o
        when String
          XML::Reader.string(o)
        when IO
          XML::Reader.io(o)
        when URI
          # raise ArgumentError, "#{class_name}.load only handles http & https URIs" if o.scheme != 'https' || o.scheme != 'http'
          response = nil
          http_obj = Net::HTTP.new(o.host, o.port)
          http_obj.use_ssl = true if o.scheme == 'https'
          http_obj.start do |http|
            request = Net::HTTP::Get.new(o.request_uri)
            if opts[:user] && opts[:pass]
              request.basic_auth(opts[:user], opts[:pass])
            elsif opts[:hmac_access_id] && opts[:hmac_secret_key]
              if Atom::Configuration.auth_hmac_enabled?
                AuthHMAC.sign!(request, opts[:hmac_access_id], opts[:hmac_secret_key])
              else
                raise ArgumentError, "AuthHMAC credentials provides by auth-hmac gem is not installed"
              end
            end
            response = http.request(request)
          end
          case response
          when Net::HTTPSuccess
            XML::Reader.string(response.body)
          when nil
            raise ArgumentError.new("nil response to #{o}")
          else
            raise Atom::LoadError.new(response)
          end
        else
          raise ArgumentError, "#{class_name}.load needs String, URI or IO, got #{o.class.name}"
        end

        if error_handler
          XML::Error.set_handler(&error_handler)
        else
          XML::Error.set_handler do |reader, message, severity, base, line|
            if severity == XML::Reader::SEVERITY_ERROR
              raise ArgumentError, "#{message} at #{line} in #{o}"
            end
          end
        end
        
        o = self.new(xml)
        xml.close
        o
    end
  end
end

#parse(xml) ⇒ Object

# File 'lib/atom/xml/parser.rb', line 315

def parse(xml)
  new(xml)
end