ostatus 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ostatus.gemspec
+gemspec

data/README.md

@@ -0,0 +1,9 @@
+OStatus
+=======
+
+This gem implements the OStatus protocol data streams and the technologies that are related to it such as ActivityStreams, PortableContacts, and Salmon.
+
+What it does
+------------
+
+Right now, it simply parses Atom and gives the ability to parse the XML for each of the objects in the OStatus world.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rspec/core/rake_task'
+
+# rake spec
+RSpec::Core::RakeTask.new(:spec) do |spec|
+	spec.pattern = 'spec/*_spec.rb'
+end
+
+# rake doc
+RSpec::Core::RakeTask.new(:doc) do |spec|
+	spec.pattern = 'spec/*_spec.rb'
+	spec.rspec_opts = ['--format documentation']
+end
+
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/ostatus.rb

@@ -0,0 +1,4 @@
+require 'nokogiri'
+
+module OStatus
+end

data/lib/ostatus/activity.rb

@@ -0,0 +1,63 @@
+module OStatus
+
+  # This class represents an Activity object for an OStatus entry.
+  class Activity
+
+    # This will create an instance of an Activity class populated
+    # with the given data as a Hash or parsable XML given by a 
+    # Nokogiri::XML::Element that serves as the root node of
+    # anything containing the activity tags.
+    def initialize(activity_root)
+      if activity_root.class == Hash
+        @activity_data = activity_root
+        @activity = nil
+      else
+        @activity = activity_root
+        @activity_data = nil
+      end
+    end
+
+    def pick_first_node(a)
+      if a.empty?
+        nil
+      else
+        a[0].content
+      end
+    end
+    private :pick_first_node
+
+    # Returns the object field or nil if it does not exist.
+    def object
+      return @activity_data[:object] unless @activity_data == nil
+      pick_first_node(@activity.xpath('./activity:object'))
+    end
+
+    # Returns the target field or nil if it does not exist.
+    def target
+      return @activity_data[:target] unless @activity_data == nil
+      pick_first_node(@activity.xpath('./activity:target'))
+    end
+
+    # Returns the verb field or nil if it does not exist.
+    def verb
+      return @activity_data[:verb] unless @activity_data == nil
+      pick_first_node(@activity.xpath('./activity:verb'))
+    end
+
+    # Returns the object-type field or nil if it does not exist.
+    def object_type
+      return @activity_data[:object_type] unless @activity_data == nil
+      pick_first_node(@activity.xpath('./activity:object-type'))
+    end
+
+    # Returns a hash of all relevant fields.
+    def info
+      {
+        :object => self.object,
+        :target => self.target,
+        :verb => self.verb,
+        :object_type => self.object_type
+      }
+    end
+  end
+end

data/lib/ostatus/author.rb

@@ -0,0 +1,62 @@
+require_relative 'activity'
+require_relative 'portable_contacts'
+
+module OStatus
+
+  # Holds information about the author of the Feed.
+  class Author
+
+    # Instantiates an Author object either from a given <author></author> root
+    # passed as an instance of a Nokogiri::XML::Element or a Hash containing
+    # the properties.
+    def initialize(author_node)
+      if author_node.class == Hash
+        @author_data = author_node
+        @author = nil
+      else
+        @author = author_node
+        @author_data = nil
+      end
+    end
+
+    # Gives an instance of an OStatus::Activity that parses the fields
+    # having an activity prefix.
+    def activity
+      OStatus::Activity.new(@author)
+    end
+
+    def pick_first_node(a)
+      if a.empty?
+        nil
+      else
+        a[0].content
+      end
+    end
+    private :pick_first_node
+
+    # Returns the name of the author, if it exists.
+    def name
+      return @author_data[:name] unless @author_data == nil
+      pick_first_node(@author.css('name'))
+    end
+
+    # Returns the email of the author, if it exists.
+    def email
+      return @author_data[:email] unless @author_data == nil
+      pick_first_node(@author.css('email'))
+    end
+
+    # Returns the uri of the author, if it exists.
+    def uri
+      return @author_data[:uri] unless @author_data == nil
+      pick_first_node(@author.css('uri'))
+    end
+
+    # Returns an instance of a PortableContacts that further describe the
+    # author's contact information, if it exists.
+    def portable_contacts
+      return @author_data[:portable_contacts] unless @author_data == nil
+      PortableContacts.new(@author)
+    end
+  end
+end

data/lib/ostatus/entry.rb

@@ -0,0 +1,107 @@
+require_relative 'activity'
+
+module OStatus
+
+  # Holds information about an individual entry in the Feed.
+  class Entry
+
+    # Instantiates an Entry object from either a given <entry></entry> root
+    # passed as an instance of a Nokogiri::XML::Element or a Hash
+    # containing the properties.
+    def initialize(entry_node)
+      if entry_node.class == Hash
+        @entry_data = entry_node
+        @entry = nil
+      else
+        @entry = entry_node
+        @entry_data = nil
+      end
+    end
+
+    # Gives an instance of an OStatus::Activity that parses the fields
+    # having an activity prefix.
+    def activity
+      Activity.new(@entry)
+    end
+
+    def pick_first_node(a)
+      if a.empty?
+        nil
+      else
+        a[0].content
+      end
+    end
+    private :pick_first_node
+
+    # Returns the title of the entry.
+    def title
+      return @entry_data[:title] unless @entry_data == nil
+      pick_first_node(@entry.css('title'))
+    end
+
+    # Returns the content of the entry.
+    def content
+      return @entry_data[:content] unless @entry_data == nil
+      pick_first_node(@entry.css('content'))
+    end
+
+    # Returns the content-type of the entry.
+    def content_type
+      return @entry_data[:content_type] unless @entry_data == nil
+      content = @entry.css('content')
+      content.empty? ? "" : content[0]['type']
+    end
+
+    # Returns the DateTime that this entry was published.
+    def published
+      return @entry_data[:published] unless @entry_data == nil
+      DateTime.parse(pick_first_node(@entry.css('published')))
+    end
+
+    # Returns the DateTime that this entry was updated.
+    def updated
+      return @entry_data[:updated] unless @entry_data == nil
+      DateTime.parse(pick_first_node(@entry.css('updated')))
+    end
+
+    # Returns the id of the entry.
+    def id
+      return @entry_data[:id] unless @entry_data == nil
+      pick_first_node(@entry.css('id'))
+    end
+
+    def link
+      return @entry_data[:link] unless @entry_data == nil
+
+      result = {}
+
+      @entry.css('link').each do |node|
+        if node[:rel] != nil
+          rel = node[:rel].intern
+          if result[rel] == nil
+            result[rel] = []
+          end
+
+          result[rel] << node
+        end
+      end
+
+      result
+    end
+
+    # Returns a Hash of all fields.
+    def info
+      return @entry_data unless @entry_data == nil
+      {
+        :activity => self.activity.info,
+        :id => pick_first_node(@entry.css('id')),
+        :title => self.title,
+        :content => self.content,
+        :content_type => self.content_type,
+        :link => self.link,
+        :published => self.published,
+        :updated => self.updated
+      }
+    end
+  end
+end

data/lib/ostatus/feed.rb

@@ -0,0 +1,156 @@
+require 'nokogiri'
+require 'open-uri'
+require 'tinyatom'
+
+require_relative 'entry'
+
+module OStatus
+
+  # This class represents an OStatus Feed object.
+  class Feed
+    def initialize(url, access_token, author, entries, id, title, links)
+      @url = url
+      @access_token = access_token
+      @author = author
+      @entries = entries
+      @id = id
+      @title = title
+      @links = links
+
+      if id == nil
+        @xml = Nokogiri::XML::Document.parse(self.atom)
+      end
+    end
+
+    # Creates a new Feed instance given by the atom feed located at 'url'
+    # and optionally using the OAuth::AccessToken given.
+    def Feed.from_url(url, access_token = nil)
+      Feed.new(url, access_token, nil, nil, nil, nil, nil)
+    end
+
+    # Creates a new Feed instance that contains the information given by
+    # the various instances of author and entries.
+    def Feed.from_data(id, title, url, author, entries, links)
+      Feed.new(url, nil, author, entries, id, title, links)
+    end
+
+    # Returns an array of  Nokogiri::XML::Element instances for all link tags
+    # that have a rel equal to that given by attribute. This can be used 
+    # generally as a Hash where the keys are intern strings that give an 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)
+      return @links[attribute] unless @links == nil
+
+      # get all links with rel attribute being equal to attribute
+      @xml.xpath('/xmlns:feed/xmlns:link').select do |link|
+        link[:rel] == attribute.to_s
+      end
+    end
+
+    # Returns an array of URLs for each hub link tag.
+    def hubs
+      link(:hub).map do |link|
+        link[:href]
+      end
+    end
+
+    # Returns the salmon URL from the link tag.
+    def salmon
+      link(:salmon).first[:href]
+    end
+
+    # This method will return a String containing the actual content of
+    # the atom feed. It will make a network request (through OAuth if
+    # an access token was given) to retrieve the document if necessary.
+    def atom
+      if @id == nil and @access_token == nil
+        # simply open the url
+        open(@url).read
+      elsif @id == nil and @url != nil
+        # open the url through OAuth
+        @access_token.get(@url).body
+      else
+        # build the atom file from internal information
+        feed = TinyAtom::Feed.new(
+          self.id,
+          self.title,
+          @url,
+
+          :author_name => self.author.name,
+          :author_email => self.author.email,
+          :author_uri => self.author.uri,
+
+          :hubs => self.hubs
+        )
+
+        @entries.each do |entry|
+          feed.add_entry(
+            entry.id,
+            entry.title,
+            entry.updated,
+
+            '',
+
+            :content => entry.content,
+
+            :author_name => self.author.name,
+            :author_email => self.author.email,
+            :author_uri => self.author.uri
+          )
+        end
+
+        feed.make(:indent => 2)
+      end
+    end
+
+    def pick_first_node(a)
+      if a.empty?
+        nil
+      else
+        a[0].content
+      end
+    end
+    private :pick_first_node
+
+    def id
+      return @id if @xml == nil
+
+      pick_first_node(@xml.xpath('/xmlns:feed/xmlns:id'))
+    end
+
+    def title
+      return @title if @xml == nil
+
+      pick_first_node(@xml.xpath('/xmlns:feed/xmlns:title'))
+    end
+
+    def url
+      return @url
+    end
+
+    # Returns an OStatus::Author that will parse the author information
+    # within the Feed.
+    def author
+      return @author if @xml == nil
+
+      author_xml = @xml.at_css('author')
+      OStatus::Author.new(author_xml)
+    end
+
+    # This method gives you an array of OStatus::Entry instances for 
+    # each entry listed in the feed.
+    def entries
+      return @entries if @xml == nil
+
+      entries_xml = @xml.css('entry')
+
+      entries_xml.map do |entry|
+        OStatus::Entry.new(entry)
+      end
+    end
+  end
+end

data/lib/ostatus/portable_contacts.rb

@@ -0,0 +1,124 @@
+module OStatus
+
+  # Holds information about the extended contact information
+  # in the Feed given in the Portable Contacts specification.
+  class PortableContacts
+    
+    # Instantiates a OStatus::PortableContacts object from either
+    # a given root that contains all <poco:*> tags as a
+    # Nokogiri::XML::Element or a Hash containing the properties.
+    def initialize(author_node)
+      if author_node.class == Hash
+        @poco_data = author_node
+        @poco = nil
+      else
+        @poco = author_node
+        @poco_data = nil
+      end
+    end
+
+    def pick_first_node(a)
+      if a.empty?
+        nil
+      else
+        a[0].content
+      end
+    end
+    private :pick_first_node
+
+    # Returns the id of the contact, if it exists.
+    def id
+      return @poco_data[:id] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:id'))
+    end
+
+    # Returns the display_name of the contact, if it exists.
+    def display_name
+      return @poco_data[:display_name] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:displayName'))
+    end
+
+    # Returns the name of the contact, if it exists.
+    def name
+      return @poco_data[:name] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:name'))
+    end
+
+    # Returns the nickname of the contact, if it exists.
+    def nickname
+      return @poco_data[:nickname] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:nickname'))
+    end
+
+    # Returns the published of the contact, if it exists.
+    def published
+      return @poco_data[:published] unless @poco_data == nil
+      pub = pick_first_node(@poco.xpath('./poco:published'))
+      if pub != nil
+        DateTime.parse(pub)
+      end
+    end
+
+    # Returns the updated of the contact, if it exists.
+    def updated
+      return @poco_data[:updated] unless @poco_data == nil
+      upd = pick_first_node(@poco.xpath('./poco:updated'))
+      if upd != nil
+        DateTime.parse(upd)
+      end
+    end
+
+    # Returns the birthday of the contact, if it exists.
+    def birthday
+      return @poco_data[:birthday] unless @poco_data == nil
+      bday = pick_first_node(@poco.xpath('./poco:birthday'))
+      if bday != nil
+        Date.parse(bday)
+      end
+    end
+
+    # Returns the anniversary of the contact, if it exists.
+    def anniversary
+      return @poco_data[:anniversary] unless @poco_data == nil
+      anni = pick_first_node(@poco.xpath('./poco:anniversary'))
+      if anni != nil
+        Date.parse(anni)
+      end
+    end
+
+    # Returns the gender of the contact, if it exists.
+    def gender
+      return @poco_data[:gender] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:gender'))
+    end
+
+    # Returns the note of the contact, if it exists.
+    def note
+      return @poco_data[:note] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:note'))
+    end
+
+    # Returns the preferred username of the contact, if it exists.
+    def preferred_username
+      return @poco_data[:preferred_username] unless @poco_data == nil
+      pick_first_node(@poco.xpath('./poco:preferredUsername'))
+    end
+
+    # Returns a boolean that indicates that a bi-directional connection
+    # has been established between the user and the contact, if it is
+    # able to assert this.
+    def connected
+      return @poco_data[:connected] unless @poco_data == nil
+      str = pick_first_node(@poco.xpath('./poco:connected'))
+      return nil if str == nil
+
+      if str == "true"
+        true
+      elsif str == "false"
+        false
+      else
+        nil
+      end
+    end
+  end
+end