nelumba 0.0.13

data/lib/nelumba/event.rb

@@ -0,0 +1,57 @@
+module Nelumba
+  class Event
+    include Nelumba::Object
+
+    attr_reader :attending
+    attr_reader :maybe_attending
+    attr_reader :not_attending
+
+    attr_reader :start_time
+    attr_reader :end_time
+
+    attr_reader :location
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super options
+
+      @attending       = options[:attending]       || []
+      @maybe_attending = options[:maybe_attending] || []
+      @not_attending   = options[:not_attending]   || []
+      @start_time      = options[:start_time]
+      @end_time        = options[:end_time]
+      @location        = options[:location]
+    end
+
+    def to_hash
+      {
+        :attending       => @attending.dup,
+        :maybe_attending => @maybe_attending.dup,
+        :not_attending   => @not_attending.dup,
+
+        :start_time      => @start_time,
+        :end_time        => @end_time,
+
+        :location        => @location
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType     => "event",
+
+        :attending      => @attending.dup,
+        :maybeAttending => @maybe_attending.dup,
+        :notAttending   => @not_attending.dup,
+
+        :startTime      => (@start_time && @start_time.to_date.rfc3339 + 'Z'),
+        :endTime        => (@end_time   && @end_time.to_date.rfc3339   + 'Z'),
+
+        :location       => @location
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/feed.rb

@@ -0,0 +1,173 @@
+module Nelumba
+  # This class represents a Nelumba::Feed object.
+  class Feed < Nelumba::Collection
+    require 'open-uri'
+    require 'date'
+
+    # Holds the list of categories for this feed as Nelumba::Category.
+    attr_reader :categories
+
+    # Holds human-readable information about the content rights of the entries
+    # in the feed without an explicit rights field of their own. SHOULD NOT be
+    # machine interpreted.
+    attr_reader :rights
+
+    # Holds the title for this feed.
+    attr_reader :title
+
+    # Holds the content-type for the title.
+    attr_reader :title_type
+
+    # Holds the subtitle for this feed.
+    attr_reader :subtitle
+
+    # Holds the content-type for the subtitle.
+    attr_reader :subtitle_type
+
+    # Holds the URL for the icon representing this feed.
+    attr_reader :icon
+
+    # Holds the URL for the logo representing this feed.
+    attr_reader :logo
+
+    # Holds the generator for this content as an Nelumba::Generator.
+    attr_reader :generator
+
+    # Holds the list of contributors, if any, that are involved in this feed
+    # as Nelumba::Person.
+    attr_reader :contributors
+
+    # Holds the list of authors as Nelumba::Person responsible for this feed.
+    attr_reader :authors
+
+    # Holds the list of hubs that are available to manage subscriptions to this
+    # feed.
+    attr_reader :hubs
+
+    # Holds the salmon url that handles notifications for this feed.
+    attr_reader :salmon_url
+
+    # Holds links to other resources as an array of Nelumba::Link
+    attr_reader :links
+
+    # Creates a new representation of a feed.
+    #
+    # options:
+    #   uid           => The unique identifier for this feed.
+    #   url           => The url that represents this feed.
+    #   title         => The title for this feed. Defaults: "Untitled"
+    #   title_type    => The content type for the title.
+    #   subtitle      => The subtitle for this feed.
+    #   subtitle_type => The content type for the subtitle.
+    #   authors       => The list of Nelumba::Person's for this feed.
+    #                    Defaults: []
+    #   contributors  => The list of Nelumba::Person's that contributed to this
+    #                    feed. Defaults: []
+    #   items         => The list of Nelumba::Activity's for this feed.
+    #                    Defaults: []
+    #   icon          => The url of the icon that represents this feed. It
+    #                    should have an aspect ratio of 1 horizontal to 1
+    #                    vertical and optimized for presentation at a
+    #                    small size.
+    #   logo          => The url of the logo that represents this feed. It
+    #                    should have an aspect ratio of 2 horizontal to 1
+    #                    vertical.
+    #   categories    => An array of Nelumba::Category's that describe how to
+    #                    categorize and describe the content of the feed.
+    #                    Defaults: []
+    #   rights        => A String depicting the rights of items without
+    #                    explicit rights of their own. SHOULD NOT be machine
+    #                    interpreted.
+    #   updated       => The DateTime representing when this feed was last
+    #                    modified.
+    #   published     => The DateTime representing when this feed was originally
+    #                    published.
+    #   salmon_url    => The url of the salmon endpoint, if one exists, for this
+    #                    feed.
+    #   links         => An array of Nelumba::Link that adds relations to other
+    #                    resources.
+    #   generator     => A Nelumba::Generator representing the agent
+    #                    responsible for generating this feed.
+    #
+    # Usage:
+    #
+    #   author = Nelumba::Person.new(:name => "Kelly")
+    #
+    #   feed = Nelumba::Feed.new(:title     => "My Feed",
+    #                            :uid     => "1",
+    #                            :url     => "http://example.com/feeds/1",
+    #                            :authors => [author])
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {})
+      super options
+
+      @icon = options[:icon]
+      @logo = options[:logo]
+      @rights = options[:rights]
+      @title = options[:title] || "Untitled"
+      @title_type = options[:title_type]
+      @subtitle = options[:subtitle]
+      @subtitle_type = options[:subtitle_type]
+      @authors = options[:authors] || []
+      @categories = options[:categories] || []
+      @contributors = options[:contributors] || []
+      @salmon_url = options[:salmon_url]
+      @hubs = options[:hubs] || []
+      @generator = options[:generator]
+    end
+
+    # Yields a Nelumba::Link to this feed.
+    #
+    # options: Can override Nelumba::Link properties, such as rel.
+    #
+    # Usage:
+    #
+    #   feed = Nelumba::Feed.new(:title => "Foo", :url => "http://example.com")
+    #   feed.to_link(:rel => "alternate", :title => "Foo's Feed")
+    #
+    # Generates a link with:
+    #   <Nelumba::Link rel="alternate" title="Foo's Feed" url="http://example.com">
+    def to_link(options = {})
+      options = { :title => self.title,
+                  :href  => self.url }.merge(options)
+
+      Nelumba::Link.new(options)
+    end
+
+    # Returns a hash of the properties of the feed.
+    def to_hash
+      {
+        :hubs => (self.hubs || []).dup,
+        :icon => self.icon,
+        :logo => self.logo,
+        :rights => self.rights,
+        :title => self.title,
+        :title_type => self.title_type,
+        :subtitle => self.subtitle,
+        :subtitle_type => self.subtitle_type,
+        :authors => (self.authors || []).dup,
+        :categories => (self.categories || []).dup,
+        :contributors => (self.contributors || []).dup,
+        :updated => self.updated,
+        :salmon_url => self.salmon_url,
+        :published => self.published,
+        :generator => self.generator
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+      }.merge(super)
+    end
+
+    # Returns a string containing an Atom representation of the feed.
+    def to_atom
+      require 'nelumba/atom/feed'
+
+      Nelumba::Atom::Feed.from_canonical(self).to_xml
+    end
+  end
+end

data/lib/nelumba/file.rb

@@ -0,0 +1,43 @@
+module Nelumba
+  class File
+    include Nelumba::Object
+
+    attr_reader :file_url
+    attr_reader :mime_type
+
+    attr_reader :length
+    attr_reader :md5
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super options
+
+      @md5         = options[:md5]
+      @file_url    = options[:file_url]
+      @mime_type   = options[:mime_type]
+      @length      = options[:length]
+    end
+
+    def to_hash
+      {
+        :md5       => @md5,
+        :file_url  => @file_url,
+        :mime_type => @mime_type,
+        :length    => @length
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType  => "file",
+        :md5         => @md5,
+        :fileUrl     => @file_url,
+        :mimeType    => @mime_type,
+        :length      => @length
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/generator.rb

@@ -0,0 +1,53 @@
+module Nelumba
+  # The generator element identifies the agent used to generate the feed.
+  class Generator
+    # Holds the base URI for relative URIs contained in uri.
+    attr_reader :base
+
+    # Holds the language of the name, when it exists. The language
+    # should be specified as RFC 3066 as either 2 or 3 letter codes.
+    # For example: 'en' for English or more specifically 'en-us'
+    attr_reader :lang
+
+    # Holds the optional uri that SHOULD produce a representation that is
+    # relevant to the agent.
+    attr_reader :uri
+
+    # Holds the optional string identifying the version of the generating
+    # agent.
+    attr_reader :version
+
+    # Holds the string that provides a human-readable name that identifies
+    # the generating agent. The content of this field is language sensitive.
+    attr_reader :name
+
+    # Creates a representation of a generator.
+    #
+    # options:
+    #   :base    => Optional base URI for use with a relative URI in uri.
+    #   :lang    => Optional string identifying the language of the name field.
+    #   :uri     => Optional string identifying the URL that SHOULD produce
+    #               a representation that is relevant to the agent.
+    #   :version => Optional string indicating the version of the generating
+    #               agent.
+    #   :name    => Optional name of the agent.
+    def initialize(options = {})
+      @base    = options[:base]
+      @lang    = options[:lang]
+      @uri     = options[:uri]
+      @version = options[:version]
+      @name    = options[:name]
+    end
+
+    # Yields a hash that represents the generator.
+    def to_hash
+      {
+        :base    => self.base,
+        :lang    => self.lang,
+        :version => self.version,
+        :uri     => self.uri,
+        :name    => self.name
+      }
+    end
+  end
+end

data/lib/nelumba/group.rb

@@ -0,0 +1,11 @@
+module Nelumba
+  class Group
+    include Nelumba::Object
+
+    def to_json_hash
+      {
+        :objectType => "group"
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/identity.rb

@@ -0,0 +1,63 @@
+module Nelumba
+  # Holds information about an Identity. This is more specific to identifying
+  # an Person than that structure. It is generally hosted in one place and
+  # not replicated. It holds identifying information that allow you to
+  # ensure verification of communication with the author.
+  class Identity
+    # Holds the public key for this identity.
+    attr_reader :public_key
+
+    # Holds the salmon endpoint used for direct notifications for this
+    # identity.
+    attr_reader :salmon_endpoint
+
+    # Holds the dialback endpoint used for capability transfer and
+    # authentication for this identity.
+    attr_reader :dialback_endpoint
+
+    # Holds the activity streams inbox endpoint for this identity.
+    attr_reader :activity_inbox_endpoint
+
+    # Holds the activity streams outbox endpoint for this identity.
+    attr_reader :activity_outbox_endpoint
+
+    # Holds the url to this identity's profile.
+    attr_reader :profile_page
+
+    # Create an instance of an Identity.
+    #
+    # options:
+    #   :public_key               => The identity's public key.
+    #   :salmon_endpoint          => The salmon endpoint for this identity.
+    #   :dialback_endpoint        => The dialback endpoint for this identity.
+    #   :activity_inbox_endpoint  => The activity streams inbox for this
+    #                                identity.
+    #   :activity_outbox_endpoint => The activity streams outbox for this
+    #                                identity.
+    #   :profile_page             => The url for this identity's profile page.
+    def initialize(options = {})
+      init(options)
+    end
+
+    def init(options = {})
+      @public_key               = options[:public_key]
+      @salmon_endpoint          = options[:salmon_endpoint]
+      @dialback_endpoint        = options[:dialback_endpoint]
+      @activity_inbox_endpoint  = options[:activity_inbox_endpoint]
+      @activity_outbox_endpoint = options[:activity_outbox_endpoint]
+      @profile_page             = options[:profile_page]
+    end
+
+    # Returns a hash of the properties of the identity.
+    def to_hash
+      {
+        :public_key               => self.public_key,
+        :salmon_endpoint          => self.salmon_endpoint,
+        :dialback_endpoint        => self.dialback_endpoint,
+        :activity_inbox_endpoint  => self.activity_inbox_endpoint,
+        :activity_outbox_endpoint => self.activity_outbox_endpoint,
+        :profile_page             => self.profile_page
+      }
+    end
+  end
+end

data/lib/nelumba/image.rb

@@ -0,0 +1,30 @@
+module Nelumba
+  class Image
+    include Nelumba::Object
+
+    attr_reader :full_image
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super(options, &blk)
+
+      @full_image = options[:full_image]
+    end
+
+    def to_hash
+      {
+        :full_image => @full_image
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType => "image",
+        :fullImage  => @full_image
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/link.rb

@@ -0,0 +1,56 @@
+module Nelumba
+  require 'atom'
+
+  class Link
+    # The URL for the related resource.
+    attr_reader :href
+
+    # A string indicating the relationship type with the current
+    # document.
+    #
+    # Standard:
+    #   "alternate" = Signifies that the URL in href identifies an alternative
+    #                 version of the resource described by the containing
+    #                 element.
+    #   "related"   = Signifies that the URL in href identifies a resource that
+    #                 is related to the contained resource. For example, the
+    #                 feed for a site that discusses the performance of the
+    #                 search engine at "http://search.example.com" might
+    #                 contain, as a link of Feed, a related link to that
+    #                 "http://search.example.com".
+    #   "self"      = Signifies that href contains a URL to the containing
+    #                 resource.
+    #   "enclosure" = Signifies that the URL in href identifies a related
+    #                 resource that is potentially large in size and
+    #                 require special handling. SHOULD use the length field.
+    #   "via"       = Signifies that the URL in href identifies a resource that
+    #                 is the source of the information provided in the
+    #                 containing element.
+    attr_reader :rel
+
+    # Advises to the content MIME type of the linked resource.
+    attr_reader :type
+
+    # Advises to the language of the linked resource. When used with
+    # rel="alternate" it depicts a translated version of the entry.
+    # Use with a RFC3066 language tag.
+    attr_reader :hreflang
+
+    # Conveys human-readable information about the linked resource.
+    attr_reader :title
+
+    # Advises the length of the linked content in number of bytes. It is simply
+    # a hint about the length based upon prior information. It may change, and
+    # cannot override the actual content length.
+    attr_reader :length
+
+    def initialize(options = {})
+      @href     = options[:href]
+      @rel      = options[:rel]
+      @type     = options[:type]
+      @hreflang = options[:hreflang]
+      @title    = options[:title]
+      @length   = options[:length]
+    end
+  end
+end