lotus 0.0.12

data/lib/lotus/atom/name.rb

@@ -0,0 +1,57 @@
+module Lotus
+  require 'atom'
+
+  module Atom
+    # This class represents an PortableContacts Name object.
+    class Name
+      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 :familyName
+      element :givenName
+      element :middleName
+      element :honorificPrefix
+      element :honorificSuffix
+
+      def initialize(o = {})
+        case o
+        when XML::Reader
+          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,
+          :family_name => self.familyName,
+          :given_name => self.givenName,
+          :middle_name => self.middleName,
+          :honorific_prefix => self.honorificPrefix,
+          :honorific_suffix => self.honorificSuffix
+        }
+      end
+
+      def to_canonical
+        to_hash
+      end
+    end
+  end
+end
+
+

data/lib/lotus/atom/organization.rb

@@ -0,0 +1,62 @@
+module Lotus
+  require 'atom'
+
+  module Atom
+    # This class represents an PortableContacts Organization object.
+    class Organization
+      include ::Atom::Xml::Parseable
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/spec/1.0'
+
+      namespace POCO_NAMESPACE
+
+      element :name
+      element :department
+      element :title
+      element :type
+      element :startDate, :class => Date, :content_only => true
+      element :endDate,   :class => Date, :content_only => true
+      element :location
+      element :description
+
+      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
+        {
+          :name => self.name,
+          :department => self.department,
+          :title => self.title,
+          :type => self.type,
+          :start_date => self.startDate,
+          :end_date => self.endDate,
+          :location => self.location,
+          :description => self.description
+        }
+      end
+
+      def to_canonical
+        to_hash
+      end
+    end
+  end
+end
+
+

data/lib/lotus/atom/portable_contacts.rb

@@ -0,0 +1,117 @@
+module Lotus
+  module Atom
+    # Holds information about the extended contact information
+    # in the Feed given in the Portable Contacts specification.
+    class PortableContacts
+      # Instantiates a Lotus::PortableContacts object from either
+      # a given root that contains all <poco:*> tags as an ratom Person
+      #  or a Hash containing the properties.
+      def initialize(parent)
+        if parent.is_a? Hash
+          @options = parent
+        else
+          @parent = parent
+        end
+      end
+
+      def id;                   get_prop(:id); end
+      def id= value;            set_prop(:id, value); end
+
+      def name;                 get_prop(:name); end
+      def name= value;          set_prop(:name, value); end
+
+      def nickname;             get_prop(:nickname); end
+      def nickname= value;      set_prop(:nickname, value); end
+
+      def gender;               get_prop(:gender); end
+      def gender= value;        set_prop(:gender, value); end
+
+      def note;                 get_prop(:note); end
+      def note= value;          set_prop(:note, value); end
+
+      def display_name;         get_prop(:display_name, 'displayName'); end
+      def display_name= value;  set_prop(:display_name, value, 'displayName'); end
+
+      def preferred_username
+        get_prop(:preferred_username, 'preferredUsername')
+      end
+
+      def preferred_username= value
+        set_prop(:preferred_username, value, 'preferredUsername')
+      end
+
+      def updated;   get_datetime(:updated); end
+      def published; get_datetime(:published); end
+
+      def birthday;    get_date(:birthday); end
+      def anniversary; get_date(:anniversary); 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 @options[:connected] unless @options.nil?
+        str = @parent.poco_connected
+
+        if str == "true"
+          true
+        elsif str == "false"
+          false
+        else
+          nil
+        end
+      end
+
+      private
+
+      def get_prop name, xmlName = name
+        @options ? @options[name] : @parent.send("poco_#{xmlName}")
+      end
+
+      def set_prop name, value, xmlName = name
+        if @options
+          @options[name] = value
+        else
+          @parent.send("poco_#{xmlName}=", value)
+        end
+      end
+
+      def get_datetime x
+        if @options
+          dt = @options[x]
+          DateTime.parse(dt) if dt
+        else
+          @parent.send("poco_#{x}")
+        end
+      end
+
+      def get_date x
+        if @options
+          d = @options[x]
+          Date.parse(d) if d
+        else
+          @parent.send("poco_#{x}")
+        end
+      end
+
+      def to_canonical
+        Lotus::PortableContacts.new(:id => self.id,
+                                    :name => self.name,
+                                    :gender => self.gender,
+                                    :note => self.note,
+                                    :nickname => self.nickname,
+                                    :display_name => self.display_name,
+                                    :preferred_username => self.preferred_username,
+                                    :updated => self.updated,
+                                    :published => self.published,
+                                    :birthday => self.birthday,
+                                    :anniversary => self.anniversary,
+
+                                    :name => self.name,
+                                    :organization => self.organization,
+                                    :account => self.account,
+                                    :address => self.address)
+      end
+    end
+  end
+end

data/lib/lotus/atom/source.rb

@@ -0,0 +1,168 @@
+require 'lotus/author'
+require 'lotus/category'
+require 'lotus/generator'
+
+require 'lotus/atom/generator'
+require 'lotus/atom/category'
+require 'lotus/atom/author'
+require 'lotus/atom/link'
+
+module Lotus
+  require 'atom'
+
+  module Atom
+    # This class represents an OStatus Feed object.
+    class Source < ::Atom::Source
+      require 'open-uri'
+
+      include ::Atom::SimpleExtensions
+
+      # The XML namespace that identifies the conforming specification.
+      ACTIVITY_NAMESPACE = 'http://activitystrea.ms/spec/1.0/'
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/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 => Lotus::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 => Lotus::Atom::Author
+      elements :contributors, :class => Lotus::Atom::Author
+      elements :categories, :class => Lotus::Atom::Category
+
+      # Creates an Atom generator for the given Lotus::Feed.
+      def self.from_canonical(obj)
+        hash = obj.to_hash
+        hash.delete :entries
+
+        # Ensure that the generator is encoded.
+        if hash[:generator]
+          hash[:generator] = Lotus::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|
+          Lotus::Atom::Author.from_canonical(a)
+        }
+
+        hash[:contributors].map! {|a|
+          Lotus::Atom::Author.from_canonical(a)
+        }
+
+        hash[:categories].map! {|c|
+          Lotus::Atom::Category.from_canonical(c)
+        }
+
+        # 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
+
+        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)
+
+        Lotus::Feed.new(:title         => self.title,
+                        :title_type    => self.title ? self.title.type : nil,
+                        :subtitle      => self.subtitle,
+                        :subtitle_type => self.subtitle ? self.subtitle.type : nil,
+                        :id            => self.id,
+                        :url           => url,
+                        :categories    => categories,
+                        :icon          => self.icon,
+                        :logo          => self.logo,
+                        :rights        => self.rights,
+                        :published     => self.published,
+                        :updated       => self.updated,
+                        :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

data/lib/lotus/atom/thread.rb

@@ -0,0 +1,60 @@
+module Lotus
+  module Atom
+    # This will parse the Thread Atom extension
+    class Thread
+      require 'xml/libxml'
+      require 'atom/xml/parser.rb'
+
+      include ::Atom::Xml::Parseable
+      attribute :ref, :type, :source
+      uri_attribute :href
+
+      def initialize(o)
+        case o
+        when XML::Reader
+          if current_node_is?(o, 'in-reply-to')
+            parse(o, :once => true)
+          else
+            raise ArgumentError, "Thread created with node other than thr:in-reply-to: #{o.name}"
+          end
+        when Hash
+          [:href, :ref, :type, :source].each do |attr|
+            self.send("#{attr}=", o[attr])
+          end
+        else
+          raise ArgumentError, "Don't know how to handle #{o}"
+        end
+      end
+
+      def length=(v)
+        @length = v.to_i
+      end
+
+      def to_s
+        self.href
+      end
+
+      def ==(o)
+        o.respond_to?(:href) && o.href == self.href
+      end
+
+      def self.from_canonical(obj)
+        self.new(obj.to_hash)
+      end
+
+      def to_canonical
+        Lotus::Activity.new(:url => self.href,
+                            :id  => self.ref)
+      end
+
+      def info
+        {
+          :ref    => self.ref,
+          :type   => self.type,
+          :source => self.source,
+          :href   => self.href
+        }
+      end
+    end
+  end
+end