nelumba 0.0.13

data/lib/nelumba.rb

@@ -0,0 +1,47 @@
+# Base Activity Objects
+require 'nelumba/object'
+require 'nelumba/activity'
+require 'nelumba/collection'
+
+# Activity Objects
+require 'nelumba/article'
+require 'nelumba/audio'
+require 'nelumba/badge'
+require 'nelumba/binary'
+require 'nelumba/bookmark'
+require 'nelumba/comment'
+require 'nelumba/device'
+require 'nelumba/event'
+require 'nelumba/file'
+require 'nelumba/group'
+require 'nelumba/image'
+require 'nelumba/note'
+require 'nelumba/place'
+require 'nelumba/question'
+require 'nelumba/review'
+require 'nelumba/service'
+require 'nelumba/video'
+
+# Data Structures
+require 'nelumba/feed'
+require 'nelumba/person'
+require 'nelumba/identity'
+require 'nelumba/notification'
+require 'nelumba/link'
+
+# Crypto
+require 'nelumba/crypto'
+
+# Pub-Sub
+require 'nelumba/subscription'
+require 'nelumba/publisher'
+
+# Discovery
+require 'nelumba/discover'
+
+# This module contains elements that allow federated interaction. It also
+# contains methods to construct these objects from external sources.
+module Nelumba
+  # This module isolates Atom generation.
+  module Atom; end
+end

data/lib/nelumba/activity.rb

@@ -0,0 +1,250 @@
+module Nelumba
+  # This class represents an Activity object that represents an action taken
+  # by a Person.
+  class Activity
+    require 'time-lord/units'
+    require 'time-lord/scale'
+    require 'time-lord/period'
+
+    include Nelumba::Object
+
+    STANDARD_TYPES = [:article, :audio, :bookmark, :comment, :file, :folder,
+                      :group, :list, :note, :person, :image,
+                      :place, :playlist, :product, :review, :service, :status,
+                      :video]
+
+    # Holds a hash containing the information about interactions where keys
+    # are verbs.
+    #
+    # For instance, it could have a :share key, with a hash containing the
+    # number of times it has been shared.
+    attr_reader :interactions
+
+    # The object of this activity.
+    attr_reader :object
+
+    # The type of object for this activity.
+    #
+    # The field can be a String for uncommon types. Several are standard:
+    #   :article, :audio, :bookmark, :comment, :file, :folder, :group,
+    #   :list, :note, :person, :image, :place, :playlist,
+    #   :product, :review, :service, :video
+    attr_reader :type
+
+    # The action being invoked in this activity.
+    #
+    # The field can be a String for uncommon verbs. Several are standard:
+    #   :favorite, :follow, :like, :"make-friend", :join, :play,
+    #   :post, :save, :share, :tag, :update
+    attr_reader :verb
+
+    # The target of the action.
+    attr_reader :target
+
+    # Holds an Nelumba::Person.
+    attr_reader :actor
+
+    # Holds the source of this entry as an Nelumba::Feed.
+    attr_reader :source
+
+    # Holds an array of related Nelumba::Activity's that this entry is a response
+    # to.
+    attr_reader :in_reply_to
+
+    # Holds an array of related Nelumba::Activity's that are replies to this one.
+    attr_reader :replies
+
+    # Holds an array of Nelumba::Person's that have favorited this activity.
+    attr_reader :likes
+
+    # Holds an array of Nelumba::Person's that have shared this activity.
+    attr_reader :shares
+
+    # Holds an array of Nelumba::Person's that are mentioned in this activity.
+    attr_reader :mentions
+
+    # Create a new entry with the given action and object.
+    #
+    # options:
+    #   :object      => The object of this activity.
+    #   :type        => The type of object for this activity.
+    #   :target      => The target of this activity.
+    #   :verb        => The action of the activity.
+    #
+    #   :actor        => An Nelumba::Person responsible for generating this entry.
+    #   :source       => An Nelumba::Feed where this Entry originated. This
+    #                    should be used when an Entry is copied into this feed
+    #                    from another.
+    #   :published    => The DateTime depicting when the entry was originally
+    #                    published.
+    #   :updated      => The DateTime depicting when the entry was modified.
+    #   :url          => The canonical url of the entry.
+    #   :uid          => The unique id that identifies this entry.
+    #   :in_reply_to  => An Nelumba::Entry for which this entry is a response.
+    #                    Or an array of Nelumba::Entry's that this entry is a
+    #                    response to. Use this when this Entry is a reply
+    #                    to an existing Entry.
+    def initialize(options = {}, &blk)
+      super(options, &blk)
+
+      @object      = options[:object]
+
+      @type        = options[:type]
+      if STANDARD_TYPES.map(&:to_s).include? @type
+        @type = @type.intern
+      end
+
+      @target      = options[:target]
+      @verb        = options[:verb]
+
+      @actor        = options[:actor]
+      @source       = options[:source]
+      @published    = options[:published]
+      @updated      = options[:updated]
+      @url          = options[:url]
+      @uid          = options[:uid]
+
+      unless options[:in_reply_to].nil? or options[:in_reply_to].is_a?(Array)
+        options[:in_reply_to] = [options[:in_reply_to]]
+      end
+
+      @in_reply_to  = options[:in_reply_to]  || []
+      @replies      = options[:replies]      || []
+
+      @mentions     = options[:mentions]     || []
+      @likes        = options[:likes]        || []
+      @shares       = options[:shares]       || []
+
+      @interactions = options[:interactions] || {}
+    end
+
+    # Returns the number of times the given verb has been used with this
+    # Activity.
+    def interaction_count(verb)
+      hash = self.interactions
+      if hash && hash.has_key?(verb)
+        hash[verb][:count] || 0
+      else
+        0
+      end
+    end
+
+    def published_ago_in_words
+      TimeLord::Period.new(self.published.to_time, Time.now).to_words
+    end
+
+    def updated_ago_in_words
+      TimeLord::Period.new(self.updated.to_time, Time.now).to_words
+    end
+
+    # Returns a hash of all relevant fields.
+    def to_hash(scheme = 'https', domain = 'example.org', port = nil)
+      {
+        :source => self.source,
+
+        :in_reply_to => self.in_reply_to.dup,
+        :replies => self.replies.dup,
+
+        :mentions => self.mentions.dup,
+        :likes => self.likes.dup,
+        :shares => self.shares.dup,
+
+        :object => self.object,
+        :target => self.target,
+        :actor => self.actor,
+        :verb => self.verb,
+        :type => self.type,
+      }.merge(super(scheme, domain, port))
+    end
+
+    # Returns a string containing the Atom representation of this Activity.
+    def to_atom
+      require 'nelumba/atom/entry'
+
+      Nelumba::Atom::Entry.from_canonical(self).to_xml
+    end
+
+    # Returns a hash of all relevant fields with JSON activity streams
+    # conventions.
+    def to_json_hash(scheme = 'https', domain = 'example.org', port = nil)
+      {
+        :objectType => "activity",
+        :object => @object,
+        :actor => @actor,
+        :target => @target,
+        :type => @type,
+        :verb => @verb,
+        :source => self.source,
+        :in_reply_to => self.in_reply_to.dup,
+        :replies => self.replies.dup,
+        :mentions => self.mentions.dup,
+        :likes => self.likes.dup,
+        :shares => self.shares.dup,
+      }.merge(super(scheme, domain, port))
+    end
+
+    # Generates a sentence describing this activity in the current or given
+    # locale.
+    #
+    # Usage:
+    #   # The default locale
+    #   Nelumba::Activity.new(:verb => :post,
+    #                       :object => Nelumba::Note(:content => "hello"),
+    #                       :actor => Nelumba::Person.new(:name => "wilkie"))
+    #                  .sentence
+    #   # => "wilkie posted a note"
+    #
+    #   Nelumba::Activity.new(:verb => :follow,
+    #                       :object => Nelumba::Person.new(:name => "carol"),
+    #                       :actor => Nelumba::Person.new(:name => "wilkie"))
+    #                  .sentence
+    #   # => "wilkie followed carol"
+    #
+    #   # In Spanish
+    #   Nelumba::Activity.new(:verb => :post,
+    #                       :object => Nelumba::Note(:content => "hello"),
+    #                       :actor => Nelumba::Person.new(:name => "wilkie"))
+    #                  .sentence(:locale => :es)
+    #   # => "wilkie puso una nota"
+    def sentence(options = {})
+      object_owner = nil
+
+      if self.verb == :favorite || self.verb == :share
+        if self.object.author
+          object_owner = self.object.author.name
+        elsif self.object.actor.is_a? Nelumba::Person
+          object_owner = self.object.actor.name
+        end
+      end
+
+      object = self.type
+
+      if self.verb == :favorite || self.verb == :share
+        if self.object
+          object = self.object.type
+        end
+      end
+
+      actor = nil
+
+      if self.actor
+        actor = self.actor.preferred_display_name
+      end
+
+      person = nil
+
+      if self.object.is_a?(Nelumba::Person)
+        person = self.object.name
+      end
+
+      Nelumba::I18n.sentence({
+        :actor => actor,
+        :object => object,
+        :object_owner => object_owner,
+        :person => person,
+        :verb => self.verb,
+        :target => self.target ? self.target.preferred_display_name : nil
+      }.merge(options))
+    end
+  end
+end

data/lib/nelumba/application.rb

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

data/lib/nelumba/article.rb

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

data/lib/nelumba/atom/account.rb

@@ -0,0 +1,50 @@
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an PortableContacts Account object.
+    class Account
+      include ::Atom::Xml::Parseable
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/spec/1.0'
+
+      namespace POCO_NAMESPACE
+
+      element :domain
+      element :username
+      element :userid
+
+      def initialize(o = {})
+        case o
+        when XML::Reader
+          o.read
+          parse(o)
+        when Hash
+          o.each do |k, v|
+            if k.to_s.include? '_'
+              k = k.to_s.gsub(/_(.)/){"#{$1.upcase}"}.intern
+            end
+            self.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
+
+      def to_hash
+        {
+          :domain => self.domain,
+          :username => self.username,
+          :userid => self.userid
+        }
+      end
+
+      def to_canonical
+        to_hash
+      end
+    end
+  end
+end

data/lib/nelumba/atom/address.rb

@@ -0,0 +1,56 @@
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an OStatus PortableContacts Address object.
+    class Address
+      include ::Atom::Xml::Parseable
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/spec/1.0'
+
+      namespace POCO_NAMESPACE
+
+      element :formatted
+      element :streetAddress
+      element :locality
+      element :region
+      element :postalCode
+      element :country
+
+      def initialize(o = {})
+        case o
+        when XML::Reader
+          o.read
+          parse(o, :test=>true)
+        when Hash
+          o.each do |k, v|
+            if k.to_s.include? '_'
+              k = k.to_s.gsub(/_(.)/){"#{$1.upcase}"}.intern
+            end
+            self.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
+
+      def to_hash
+        {
+          :formatted => self.formatted,
+          :street_address => self.streetAddress,
+          :locality => self.locality,
+          :region => self.region,
+          :postal_code => self.postalCode,
+          :country => self.country
+        }
+      end
+
+      def to_canonical
+        to_hash
+      end
+    end
+  end
+end

data/lib/nelumba/atom/author.rb

@@ -0,0 +1,176 @@
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # Holds information about the author of the Feed.
+    class Author < ::Atom::Person
+      require 'date'
+
+      include ::Atom::SimpleExtensions
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/spec/1.0'
+
+      # The XML namespace that identifies the conforming specification.
+      ACTIVITY_NAMESPACE = 'http://activitystrea.ms/spec/1.0/'
+
+      add_extension_namespace :activity, ACTIVITY_NAMESPACE
+      element 'activity:object-type'
+
+      namespace ::Atom::NAMESPACE
+      element :email
+      element :uri
+
+      elements :links, :class => ::Atom::Link
+
+      add_extension_namespace :poco, POCO_NAMESPACE
+      element 'poco:id'
+      element 'poco:organization', :class => Nelumba::Atom::Organization
+      element 'poco:address',      :class => Nelumba::Atom::Address
+      element 'poco:account',      :class => Nelumba::Atom::Account
+      element 'poco:displayName'
+      element 'poco:nickname'
+      element 'poco:updated',     :class => DateTime, :content_only => true
+      element 'poco:published',   :class => DateTime, :content_only => true
+      element 'poco:birthday',    :class => Date,     :content_only => true
+      element 'poco:anniversary', :class => Date,     :content_only => true
+      element 'poco:gender'
+      element 'poco:note'
+      element 'poco:preferredUsername'
+
+      element 'pronoun'
+
+      # unfortunately ratom doesn't handle elements with the same local name well.
+      # this is a workaround for that.
+      attr_writer :name, :poco_name
+
+      def name
+        @name or self[::Atom::NAMESPACE, 'name'].first
+      end
+
+      def poco_name
+        return @poco_name if @poco_name
+        name = self[POCO_NAMESPACE, 'name'].first
+        if name
+          name = "<name>#{name}</name>"
+          reader = XML::Reader.string(name)
+          reader.read
+          reader.read
+          Nelumba::Atom::Name.new(reader)
+        else
+          nil
+        end
+      end
+
+      def to_xml(*args)
+        x = super(true)
+
+        if self.name
+          node = XML::Node.new('name')
+          node << self.name
+          x << node
+        end
+
+        if self.poco_name
+          x << self.poco_name.to_xml(true, root_name = 'poco:name')
+        end
+
+        x
+      end
+
+      def initialize *args
+        self.activity_object_type = "http://activitystrea.ms/schema/1.0/person"
+        super(*args)
+      end
+
+      # Gives an instance of an Nelumba::Activity that parses the fields
+      # having an activity prefix.
+      def activity
+        Nelumba::Activity.new(self)
+      end
+
+      def self.from_canonical(obj)
+        hash = obj.to_hash
+        hash.keys.each do |k|
+          to_k = k
+          if k == :display_name
+            to_k = :displayName
+          elsif k == :preferred_username
+            to_k = :preferredUsername
+          end
+
+          if k == :extended_name
+            if hash[:extended_name]
+              hash[:"poco_name"] = Nelumba::Atom::Name.new(hash[:extended_name])
+            end
+            hash.delete :extended_name
+          elsif k == :organization
+            if hash[:organization]
+              hash[:"poco_organization"] = Nelumba::Atom::Organization.new(hash[:organization])
+            end
+            hash.delete :organization
+          elsif k == :address
+            if hash[:address]
+              hash[:"poco_address"] = Nelumba::Atom::Address.new(hash[:address])
+            end
+            hash.delete :address
+          elsif k == :account
+            if hash[:account]
+              hash[:"poco_account"] = Nelumba::Atom::Account.new(hash[:account])
+            end
+            hash.delete :account
+          elsif k == :uid
+            if hash[:uid]
+              hash[:"poco_id"] = hash[:uid]
+            end
+            hash.delete :uid
+          elsif k == :pronoun
+          elsif (k != :uri) && (k != :name) && (k != :email)
+            hash[:"poco_#{to_k}"] = hash[k]
+            hash.delete k
+          end
+        end
+
+        # Remove any blank entries
+        hash.keys.each do |key|
+          if hash[key].nil? || hash[key] == ""
+            hash.delete key
+          end
+        end
+
+        self.new(hash)
+      end
+
+      def to_canonical
+        organization = self.poco_organization
+        organization = organization.to_canonical if organization
+
+        address = self.poco_address
+        address = address.to_canonical if address
+
+        account = self.poco_account
+        account = account.to_canonical if account
+
+        ext_name = self.poco_name
+        ext_name = ext_name.to_canonical if ext_name
+        Nelumba::Person.new(:uid => self.poco_id,
+                          :extended_name => ext_name,
+                          :organization => organization,
+                          :address => address,
+                          :account => account,
+                          :gender => self.poco_gender,
+                          :note => self.poco_note,
+                          :nickname => self.poco_nickname,
+                          :display_name => self.poco_displayName,
+                          :preferred_username => self.poco_preferredUsername,
+                          :updated => self.poco_updated,
+                          :published => self.poco_published,
+                          :birthday => self.poco_birthday,
+                          :anniversary => self.poco_anniversary,
+                          :uri => self.uri,
+                          :email => self.email,
+                          :name => self.name)
+      end
+    end
+  end
+end