nelumba 0.0.13

data/lib/nelumba/atom/category.rb

@@ -0,0 +1,41 @@
+require 'nelumba/category'
+
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an Nelumba 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
+        Nelumba::Category.new(:base   => self.xml_base,
+                            :lang   => self.xml_lang,
+                            :scheme => self.scheme,
+                            :lable  => self.label,
+                            :term   => self.term)
+      end
+    end
+  end
+end
+
+

data/lib/nelumba/atom/comment.rb

@@ -0,0 +1,96 @@
+module Nelumba
+  require 'atom'
+  require 'nelumba/atom/thread'
+
+  module Atom
+    # This class represents an ActivityStreams Comment object.
+    class Comment
+      include ::Atom::Xml::Parseable
+
+      # The XML namespace that identifies the conforming specification.
+      ACTIVITY_NAMESPACE = 'http://activitystrea.ms/spec/1.0/'
+
+      # The XML namespace that identifies the conforming specification of 'thr'
+      # elements.
+      THREAD_NAMESPACE = "http://purl.org/syndication/thread/1.0"
+
+      # The XML schema that identifies the conforming schema for objects.
+      SCHEMA_ROOT = 'http://activitystrea.ms/schema/1.0/'
+
+      add_extension_namespace :activity, ACTIVITY_NAMESPACE
+      element 'activity:object-type'
+
+      element :author, :class => Nelumba::Atom::Author
+      element :content, :class => ::Atom::Content
+      element :displayName
+      element :id
+      element :title
+      element :url
+      element :summary
+      element :updated, :published, :class => DateTime, :content_only => true
+
+      add_extension_namespace :thr, THREAD_NAMESPACE
+      elements 'thr:in-reply-to', :class => Nelumba::Atom::Thread
+
+      def initialize(o = {})
+        o[:activity_object_type] = SCHEMA_ROOT + "comment"
+
+        case o
+        when XML::Reader
+          o.read
+          parse(o)
+        when Hash
+          o.each do |k, v|
+            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
+        {
+        }
+      end
+
+      def self.from_canonical(obj)
+        entry_hash = obj.to_hash
+
+        entry_hash.delete :text
+        entry_hash.delete :html
+
+        entry_hash[:id] = entry_hash[:uid]
+        entry_hash.delete :uid
+
+        entry_hash[:displayName] = entry_hash[:display_name]
+        entry_hash.delete :display_name
+
+        entry_hash[:thr_in_reply_to] = entry_hash[:in_reply_to].map do |t|
+          Nelumba::Atom::Thread.new(:href => t.url,
+                                  :ref  => t.uid)
+        end
+        entry_hash.delete :in_reply_to
+
+        if entry_hash[:author]
+          entry_hash[:author] = Nelumba::Atom::Author.from_canonical(entry_hash[:author])
+        end
+
+        node = XML::Node.new("content")
+        node['type'] = "html"
+        node << entry_hash[:content]
+
+        xml = XML::Reader.string(node.to_s)
+        xml.read
+        entry_hash[:content] = ::Atom::Content.parse(xml)
+
+        self.new entry_hash
+      end
+
+      def to_canonical
+        to_hash
+      end
+    end
+  end
+end

data/lib/nelumba/atom/entry.rb

@@ -0,0 +1,216 @@
+module Nelumba
+  module Atom
+    require 'atom'
+
+    class Entry < ::Atom::Entry
+      require 'nelumba/activity'
+      require 'nelumba/person'
+      require 'nelumba/link'
+
+      require 'nelumba/atom/person'
+      require 'nelumba/atom/author'
+      require 'nelumba/atom/thread'
+      require 'nelumba/atom/link'
+      require 'nelumba/atom/comment'
+      require 'nelumba/atom/source'
+
+      require 'libxml'
+
+      # The XML namespace that identifies the conforming specification of 'thr'
+      # elements.
+      THREAD_NAMESPACE = "http://purl.org/syndication/thread/1.0"
+
+      # The XML namespace that identifies the conforming specification.
+      ACTIVITY_NAMESPACE = 'http://activitystrea.ms/spec/1.0/'
+
+      # The XML schema that identifies the conforming schema for objects.
+      SCHEMA_ROOT = 'http://activitystrea.ms/schema/1.0/'
+
+      include ::Atom::SimpleExtensions
+
+      add_extension_namespace :activity, ACTIVITY_NAMESPACE
+      element 'activity:object-type'
+      element 'activity:object'
+      element 'activity:verb'
+      element 'activity:target'
+
+      add_extension_namespace :thr, THREAD_NAMESPACE
+      elements 'thr:in-reply-to', :class => Nelumba::Atom::Thread
+
+      # This is for backwards compatibility with some implementations of Activity
+      # Streams. It should not be generated for Atom representation of Activity
+      # Streams (although it is used in JSON)
+      element 'activity:actor', :class => Nelumba::Atom::Author
+
+      element :source, :class => Nelumba::Atom::Source
+
+      namespace ::Atom::NAMESPACE
+      element :title, :id, :summary
+      element :updated, :published, :class => DateTime, :content_only => true
+      elements :links, :class => Nelumba::Atom::Link
+
+      elements :replies, :class => Nelumba::Atom::Entry
+
+      elements :shares, :class => Nelumba::Atom::Person
+      elements :likes, :class => Nelumba::Atom::Person
+      elements :mentions, :class => Nelumba::Atom::Person
+
+      elements :categories, :class => ::Atom::Category
+      element :content, :class => ::Atom::Content
+      elements :authors, :class => Nelumba::Atom::Author
+
+      # ActivityStreams
+      element :displayName
+
+      def url
+        if links.alternate
+          links.alternate.href
+        elsif links.self
+          links.self.href
+        else
+          links.map.each do |l|
+            l.href
+          end.compact.first
+        end
+      end
+
+      def link
+        link_list = links.group_by { |l| l.rel.intern if l.rel }
+      end
+
+      def link= options
+        links.clear << ::Atom::Link.new(options)
+      end
+
+      def self.from_canonical(obj)
+        entry_hash = obj.to_hash
+
+        # Ensure that the content type is encoded.
+        object = obj.object
+
+        title = object.title
+
+        content = object.text
+        content = object.html if object.html
+
+        content_type = nil
+        content_type = "html" if object.html
+
+        if object.is_a? Nelumba::Note
+        elsif object.is_a? Nelumba::Comment
+          content = nil
+          content_type = nil
+          title = nil
+          object = Nelumba::Atom::Comment.from_canonical(object.to_hash)
+          entry_hash[:activity_object] = object
+        else
+          content = nil
+          content_type = nil
+          title = nil
+          entry_hash[:activity_object] = object if object.is_a? Nelumba::Person
+        end
+
+        if content
+          node = XML::Node.new("content")
+          node['type'] = content_type if content_type
+          node << content
+
+          xml = XML::Reader.string(node.to_s)
+          xml.read
+          entry_hash[:content] = ::Atom::Content.parse(xml)
+          entry_hash.delete :content_type
+        end
+
+        entry_hash[:title] = title if title
+
+        if entry_hash[:source]
+          entry_hash[:source] = Nelumba::Atom::Source.from_canonical(entry_hash[:source])
+        end
+
+        if entry_hash[:actor]
+          entry_hash[:authors] = [Nelumba::Atom::Author.from_canonical(entry_hash[:actor])]
+        end
+        entry_hash.delete :actor
+
+        # Encode in-reply-to fields
+        entry_hash[:thr_in_reply_to] = entry_hash[:in_reply_to].map do |t|
+          Nelumba::Atom::Thread.new(:href => t.url,
+                                  :ref  => t.uid)
+        end
+        entry_hash.delete :in_reply_to
+
+        entry_hash[:links] ||= []
+
+        if entry_hash[:url]
+          entry_hash[:links] << ::Atom::Link.new(:rel => "self", :href => entry_hash[:url])
+        end
+        entry_hash.delete :url
+
+        object_type = entry_hash[:type]
+        if object_type
+          entry_hash[:activity_object_type] = SCHEMA_ROOT + object_type.to_s
+        end
+        if entry_hash[:verb]
+          entry_hash[:activity_verb] = SCHEMA_ROOT + entry_hash[:verb].to_s
+        end
+        entry_hash[:activity_target] = entry_hash[:target] if entry_hash[:target]
+
+        entry_hash[:id] = entry_hash[:uid]
+        entry_hash.delete :uid
+
+        entry_hash.delete :object
+        entry_hash.delete :verb
+        entry_hash.delete :target
+        entry_hash.delete :type
+
+        entry_hash[:displayName] = entry_hash[:display_name]
+        entry_hash.delete :display_name
+
+        # Remove empty entries
+        entry_hash.keys.each do |key|
+          if entry_hash[key].nil? || entry_hash[key] == ""
+            entry_hash.delete key
+          end
+        end
+
+        self.new(entry_hash)
+      end
+
+      def to_canonical
+        # Reform the activity type
+        # TODO: Add new Base schema verbs
+        object_type = self.activity_object_type
+        if object_type && object_type.start_with?(SCHEMA_ROOT)
+          object_type.gsub!(/^#{Regexp.escape(SCHEMA_ROOT)}/, "")
+        end
+
+        object_type = "note" if object_type == "status"
+
+        if self.activity_object
+          object = self.activity_object.to_canonical
+        else
+          case object_type
+          when "note"
+            object = Nelumba::Note.new(:html  => self.content.to_s,
+                                     :title => self.title)
+          end
+        end
+
+        source = self.source
+        source = source.to_canonical if source
+        Nelumba::Activity.new(:actor        => self.authors ? self.authors.first.to_canonical : nil,
+                            :uid          => self.id,
+                            :url          => self.url,
+                            :source       => source,
+                            :display_name => self.displayName,
+                            :in_reply_to  => self.thr_in_reply_to.map(&:to_canonical),
+                            :object       => object,
+                            :type         => object_type,
+                            :verb         => self.activity_verb,
+                            :target       => self.activity_target,
+                            :published    => self.published,
+                            :updated      => self.updated)
+      end
+    end
+  end
+end

data/lib/nelumba/atom/feed.rb

@@ -0,0 +1,198 @@
+require 'nelumba/activity'
+require 'nelumba/person'
+require 'nelumba/category'
+require 'nelumba/generator'
+
+require 'nelumba/atom/entry'
+require 'nelumba/atom/generator'
+require 'nelumba/atom/category'
+require 'nelumba/atom/person'
+require 'nelumba/atom/author'
+require 'nelumba/atom/link'
+
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an OStatus Feed object.
+    class Feed < ::Atom::Feed
+      require 'open-uri'
+
+      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/'
+
+      namespace ::Atom::NAMESPACE
+
+      add_extension_namespace :poco, POCO_NAMESPACE
+      add_extension_namespace :activity, ACTIVITY_NAMESPACE
+      element :id, :rights, :icon, :logo
+      element :generator, :class => Nelumba::Atom::Generator
+      element :title, :class => ::Atom::Content
+      element :subtitle, :class => ::Atom::Content
+      element :published, :class => Time, :content_only => true
+      element :updated, :class => Time, :content_only => true
+      elements :links, :class => ::Atom::Link
+      elements :authors, :class => Nelumba::Atom::Author
+      elements :contributors, :class => Nelumba::Atom::Person
+      elements :categories, :class => Nelumba::Atom::Category
+      elements :entries, :class => Nelumba::Atom::Entry
+
+      # Activity Streams
+      element :totalItems
+      element :displayName
+      element :content
+      element :summary
+
+      # Creates an Atom generator for the given Nelumba::Feed.
+      def self.from_canonical(obj)
+        hash = obj.to_hash
+        hash[:items].map! {|e|
+          Nelumba::Atom::Entry.from_canonical(e)
+        }
+
+        hash.delete :text
+        hash.delete :html
+
+        # Ensure that the generator is encoded.
+        if hash[:generator]
+          hash[:generator] = Nelumba::Atom::Generator.from_canonical(hash[:generator])
+        end
+
+        hash[:links] ||= []
+
+        if hash[:salmon_url]
+          hash[:links] << ::Atom::Link.new(:rel => "salmon", :href => hash[:salmon_url])
+        end
+        hash.delete :salmon_url
+
+        if hash[:url]
+          hash[:links] << ::Atom::Link.new(:rel => "self", :href => hash[:url])
+        end
+        hash.delete :url
+
+        hash[:hubs].each {|h|
+          hash[:links] << ::Atom::Link.new(:rel => "hub", :href => h)
+        }
+        hash.delete :hubs
+
+        hash[:authors].map! {|a|
+          Nelumba::Atom::Author.from_canonical(a)
+        }
+
+        hash[:contributors].map! {|a|
+          Nelumba::Atom::Person.from_canonical(a)
+        }
+
+        hash[:categories].map! {|c|
+          Nelumba::Atom::Category.from_canonical(c)
+        }
+
+        hash.delete :author
+
+        hash[:displayName] = hash[:display_name]
+        hash.delete :display_name
+
+        hash[:entries] = hash[:items]
+        hash.delete :items
+
+        hash[:totalItems] = hash[:total_items]
+        hash.delete :total_items
+
+        # title/subtitle content type
+        node = XML::Node.new("title")
+        node['type'] = hash[:title_type] if hash[:title_type]
+        node << hash[:title]
+
+        xml = XML::Reader.string(node.to_s)
+        xml.read
+        hash[:title] = ::Atom::Content.parse(xml)
+        hash.delete :title_type
+
+        hash[:id] = hash[:uid]
+        hash.delete :uid
+
+        if hash[:subtitle]
+          node = XML::Node.new("subtitle")
+          node['type'] = hash[:subtitle_type] if hash[:subtitle_type]
+          node << hash[:subtitle]
+
+          xml = XML::Reader.string(node.to_s)
+          xml.read
+          hash[:subtitle] = ::Atom::Content.parse(xml)
+        else
+          hash.delete :subtitle
+        end
+        hash.delete :subtitle_type
+
+        self.new(hash)
+      end
+
+      def to_canonical
+        generator = nil
+        generator = self.generator.to_canonical if self.generator
+
+        salmon_url = nil
+        if self.link('salmon').any?
+          salmon_url = self.link('salmon').first.href
+        end
+
+        url = self.url
+
+        categories = self.categories.map(&:to_canonical)
+
+        Nelumba::Feed.new(:title         => self.title.to_s,
+                        :title_type    => self.title ? self.title.type : nil,
+                        :subtitle      => self.subtitle.to_s,
+                        :subtitle_type => self.subtitle ? self.subtitle.type : nil,
+                        :uid           => self.id,
+                        :url           => url,
+                        :categories    => categories,
+                        :icon          => self.icon,
+                        :logo          => self.logo,
+                        :rights        => self.rights,
+                        :published     => self.published,
+                        :updated       => self.updated,
+                        :items         => self.entries.map(&:to_canonical),
+                        :authors       => self.authors.map(&:to_canonical),
+                        :contributors  => self.contributors.map(&:to_canonical),
+                        :hubs          => self.hubs,
+                        :salmon_url    => salmon_url,
+                        :generator     => generator)
+      end
+
+      # Returns an array of ::Atom::Link instances for all link tags
+      # that have a rel equal to that given by attribute.
+      #
+      # For example:
+      #   link(:hub).first.href -- Gets the first link tag with rel="hub" and
+      #                            returns the contents of the href attribute.
+      #
+      def link(attribute)
+        links.find_all { |l| l.rel == attribute.to_s }
+      end
+
+      # Returns an array of URLs for each hub link tag.
+      def hubs
+        link('hub').map { |link| link.href }
+      end
+
+      # Returns a string of the url for this feed.
+      def url
+        if links.alternate
+          links.alternate.href
+        elsif links.self
+          links.self.href
+        else
+          links.map.each do |l|
+            l.href
+          end.compact.first
+        end
+      end
+    end
+  end
+end