Class: Atom::Entry

Inherits:

Object

Object
Atom::Entry

show all

Extended by:

Forwardable

Includes:

SimpleExtensions, Xml::Parseable

Defined in:

lib/atom.rb,
lib/atom/pub.rb

Overview

Represents an Entry as defined by the Atom Syndication Format specification.

An Entry represents an individual entry within a Feed.

Parsing

An Entry can be parsed using the Entry.load_entry method. This method accepts a String containing a valid atom entry document, an IO object, or an URI to a valid atom entry document. For example:

# Using a File
entry = Entry.load_entry(File.open("/path/to/myfeedentry.atom"))

# Using a URL
Entry = Entry.load_entry(URI.parse("http://example.org/afeedentry.atom"))

The document must contain a stand alone entry element as described in the Atom Syndication Format.

Encoding

A Entry can be converted to XML using, the to_xml method that returns a valid atom entry document in a String.

Attributes

An entry has the following attributes:

`id`	A unique id for the entry.
`updated`	The Time the entry was updated.
`published`	The Time the entry was published.
`title`	The title of the entry.
`summary`	A short textual summary of the item.
`authors`	An array of Atom::Person objects that are authors of this entry.
`contributors`	An array of Atom::Person objects that are contributors to this entry.
`rights`	A string describing the rights associated with this entry.
`links`	An array of Atom:Link objects. (This is actually an Atom::Links array which is an Array with some sugar).
`source`	Metadata of a feed that was the source of this item, for feed aggregators, etc.
`categories`	Array of Atom::Categories.
`content`	The content of the entry. This will be one of Atom::Content::Text, Atom::Content:Html or Atom::Content::Xhtml.

References

See also www.atomenabled.org/developers/syndication/atom-format-spec.php#element.entry for more detailed definitions of the attributes.

Instance Attribute Summary

Attributes included from SimpleExtensions

#simple_extensions

Instance Method Summary (collapse)

- (Object) destroy!(opts = {})
- (Entry) initialize(o = {}) {|_self| ... } constructor

Initialize an Entry.
- (Object) reload!(opts = {})

Reload the Entry by fetching the self link.
- (Object) save!(opts = {})

Methods included from SimpleExtensions

#[]

Methods included from Xml::Parseable

#==, #accessor_name, #current_node_is?, included, #next_node_is?, #parse, #to_xml

Constructor Details

- (`Entry`) initialize(o = {}) {|_self| ... }

Initialize an Entry.

This will also yield itself, so an Entry can be constructed like this:

entry = Entry.new do |entry|
  entry.title = "My Cool entry"
end

`o`	An XML Reader or a Hash of attributes.

Yields:

(_self)

Yield Parameters:

_self (Atom::Entry) —

the object that the method was called on

# File 'lib/atom.rb', line 577

def initialize(o = {})
  @links = Links.new
  @authors = []
  @contributors = []
  @categories = []
  
  case o
  when XML::Reader
    if current_node_is?(o, 'entry', Atom::NAMESPACE) || next_node_is?(o, 'entry', Atom::NAMESPACE)
      o.read
      parse(o)
    else
      raise ArgumentError, "Entry created with node other than atom:entry: #{o.name}"
    end
  when Hash
    o.each do |k,v|
      send("#{k.to_s}=", v)
    end
  else
    raise ArgumentError, "Got #{o.class} but expected a Hash or XML::Reader"
  end

  yield(self) if block_given?
end

Instance Method Details

- (`Object`) destroy!(opts = {})

# File 'lib/atom/pub.rb', line 214

def destroy!(opts = {})
  if edit = edit_link
    uri = URI.parse(edit.href)
    response = nil
    Net::HTTP.start(uri.host, uri.port) do |http|
      request = Net::HTTP::Delete.new(uri.request_uri, {'Accept' => 'application/atom+xml', 'User-Agent' => "rAtom #{Atom::VERSION::STRING}"})
      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
    else
      raise Atom::Pub::ProtocolError, response
    end
  else
    raise Atom::Pub::NotSupported, "Entry does not have an edit link"
  end
end

- (`Object`) reload!(opts = {})

Reload the Entry by fetching the self link.

# File 'lib/atom.rb', line 603

def reload!(opts = {})
  if links.self
    Entry.load_entry(URI.parse(links.self.href), opts)
  end
end

- (`Object`) save!(opts = {})

# File 'lib/atom/pub.rb', line 185

def save!(opts = {})
  if edit = edit_link
    uri = URI.parse(edit.href)
    response = nil
    Net::HTTP.start(uri.host, uri.port) do |http|
      request = Net::HTTP::Put.new(uri.request_uri, headers)
      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, self.to_xml)
    end
    
    case response
    when Net::HTTPSuccess
    else
      raise Atom::Pub::ProtocolError, response
    end
  else
    raise Atom::Pub::NotSupported, "Entry does not have an edit link"
  end
end