lotus 0.0.12

data/lib/lotus/activity.rb

@@ -0,0 +1,134 @@
+module Lotus
+  # This class represents an Activity object for an Lotus::Entry.
+  class Activity
+    # 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, :photo, :"photo-album", :place, :playlist,
+    #   :product, :review, :service, :status, :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 a String containing the title of the entry.
+    attr_reader :title
+
+    # Holds an Lotus::Author.
+    attr_reader :actor
+
+    # Holds the content.
+    attr_reader :content
+
+    # Holds the MIME type of the content.
+    attr_reader :content_type
+
+    # Holds the id that uniquely identifies this entry.
+    attr_reader :id
+
+    # Holds the url that represents the entry.
+    attr_reader :url
+
+    # Holds the source of this entry as an Lotus::Feed.
+    attr_reader :source
+
+    # Holds the DateTime of when the entry was published originally.
+    attr_reader :published
+
+    # Holds the DateTime of when the entry was last modified.
+    attr_reader :updated
+
+    # Holds an array of related Lotus::Entry's that this entry is a response
+    # to.
+    attr_reader :in_reply_to
+
+    # Create a new entry with the given content.
+    #
+    # 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.
+    #
+    #   :title        => The title of the entry. Defaults: "Untitled"
+    #   :actor        => An Lotus::Author responsible for generating this entry.
+    #   :content      => The content of the entry. Defaults: ""
+    #   :content_type => The MIME type of the content.
+    #   :source       => An Lotus::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.
+    #   :id           => The unique id that identifies this entry.
+    #   :activity     => The activity this entry represents. Either a single string
+    #                    denoting what type of object this entry represents, or an
+    #                    entire Lotus::Activity when a more detailed description is
+    #                    appropriate.
+    #   :in_reply_to  => An Lotus::Entry for which this entry is a response.
+    #                    Or an array of Lotus::Entry's that this entry is a
+    #                    response to. Use this when this Entry is a reply
+    #                    to an existing Entry.
+    def initialize(options = {})
+      @object      = options[:object]
+      @type        = options[:type]
+      @target      = options[:target]
+      @verb        = options[:verb]
+
+      @title        = options[:title] || "Untitled"
+      @actor        = options[:actor]
+      @content      = options[:content] || ""
+      @content_type = options[:content_type]
+      @source       = options[:source]
+      @published    = options[:published]
+      @updated      = options[:updated]
+      @url          = options[:url]
+      @id           = options[:id]
+
+      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] || []
+    end
+
+    # Returns a hash of all relevant fields.
+    def to_hash
+      {
+        :source => self.source,
+        :title => self.title,
+        :content => self.content,
+        :content_type => self.content_type,
+        :published => self.published,
+        :updated => self.updated,
+        :url => self.url,
+        :id => self.id,
+        :in_reply_to => self.in_reply_to.dup,
+
+        :object => self.object,
+        :target => self.target,
+        :actor => self.actor,
+        :verb => self.verb,
+        :type => self.type
+      }
+    end
+
+    # Returns a string containing the Atom representation of this Activity.
+    def to_atom
+      require 'lotus/atom/entry'
+
+      Lotus::Atom::Entry.from_canonical(self).to_xml
+    end
+  end
+end

data/lib/lotus/atom/account.rb

@@ -0,0 +1,50 @@
+module Lotus
+  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/lotus/atom/address.rb

@@ -0,0 +1,56 @@
+module Lotus
+  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/lotus/atom/author.rb

@@ -0,0 +1,167 @@
+require 'lotus/activity'
+require 'lotus/atom/name'
+require 'lotus/atom/address'
+require 'lotus/atom/account'
+require 'lotus/atom/organization'
+
+module Lotus
+  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 => Lotus::Atom::Organization
+      element 'poco:address',      :class => Lotus::Atom::Address
+      element 'poco:account',      :class => Lotus::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'
+
+      # 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
+          Lotus::Atom::Name.new(reader)
+        else
+          nil
+        end
+      end
+
+      def to_xml(*args)
+        x = super(*args)
+
+        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 Lotus::Activity that parses the fields
+      # having an activity prefix.
+      def activity
+        Lotus::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"] = Lotus::Atom::Name.new(hash[:extended_name])
+            end
+            hash.delete :extended_name
+          elsif k == :organization
+            if hash[:organization]
+              hash[:"poco_organization"] = Lotus::Atom::Organization.new(hash[:organization])
+            end
+            hash.delete :organization
+          elsif k == :address
+            if hash[:address]
+              hash[:"poco_address"] = Lotus::Atom::Address.new(hash[:address])
+            end
+            hash.delete :address
+          elsif k == :account
+            if hash[:account]
+              hash[:"poco_account"] = Lotus::Atom::Account.new(hash[:account])
+            end
+            hash.delete :account
+          elsif (k != :uri) && (k != :name) && (k != :email)
+            hash[:"poco_#{to_k}"] = hash[k]
+            hash.delete k
+          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
+        Lotus::Author.new(:id => 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

data/lib/lotus/atom/category.rb

@@ -0,0 +1,41 @@
+require 'lotus/category'
+
+module Lotus
+  require 'atom'
+
+  module Atom
+    # This class represents an Lotus Category object.
+    class Category < ::Atom::Category
+      require 'open-uri'
+
+      attribute :'xml:base'
+      attribute :'xml:lang'
+      attribute :scheme
+      attribute :term
+      attribute :label
+
+      def self.from_canonical(obj)
+        hash = obj.to_hash
+        if hash[:base]
+          hash[:xml_base] = hash[:base]
+        end
+        if hash[:lang]
+          hash[:xml_lang] = hash[:lang]
+        end
+        hash.delete :base
+        hash.delete :lang
+        self.new(hash)
+      end
+
+      def to_canonical
+        Lotus::Category.new(:base   => self.xml_base,
+                            :lang   => self.xml_lang,
+                            :scheme => self.scheme,
+                            :lable  => self.label,
+                            :term   => self.term)
+      end
+    end
+  end
+end
+
+