nelumba 0.0.13

data/lib/nelumba/atom/generator.rb

@@ -0,0 +1,40 @@
+require 'nelumba/generator'
+
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an OStatus Generator object.
+    class Generator < ::Atom::Generator
+      require 'open-uri'
+
+      attribute :'xml:base'
+      attribute :'xml:lang'
+      attribute :version
+      attribute :uri
+
+      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::Generator.new(:base    => self.xml_base,
+                             :lang    => self.xml_lang,
+                             :version => self.version,
+                             :name    => self.name,
+                             :uri     => self.uri)
+      end
+    end
+  end
+end
+
+

data/lib/nelumba/atom/link.rb

@@ -0,0 +1,79 @@
+module Nelumba
+  require 'atom'
+
+  module Atom
+
+    # This represents an Atom parser/generator for <link> tags.
+    class Link < ::Atom::Link
+      include ::Atom::Xml::Parseable
+
+      attribute :rel, :type, :length, :hreflang, :title, :text
+
+      uri_attribute :href
+
+      # Create a link.
+      #
+      # +o+:: An XML::Reader containing a link element or a Hash of attributes.
+      #
+      def initialize(o)
+        case o
+        when XML::Reader
+          if current_node_is?(o, 'link')
+            self.text = o.read_string
+            parse(o, :once => true)
+          else
+            raise ArgumentError, "Link created with node other than atom:link: #{o.name}"
+          end
+        when Hash
+          [:href, :rel, :type, :length, :hreflang, :title].each do |attr|
+            self.send("#{attr}=", o[attr])
+          end
+        else
+          raise ArgumentError, "Don't know how to handle #{o}"
+        end
+      end
+
+      remove_method :length=
+        def length=(v)
+          @length = v.to_i
+        end
+
+      # Returns the href of the link, or the content of the link if no href is
+      # provided.
+      def href
+        @href || self.text
+      end
+
+      # Reports the href of the link.
+      def to_s
+        self.href
+      end
+
+      # Two links are equal when their href is exactly the same regardless of
+      # case.
+      def ==(o)
+        o.respond_to?(:href) && o.href == self.href
+      end
+
+      # This will fetch the URL referenced by the link.
+      #
+      # If the URL contains a valid feed, a Feed will be returned, otherwise,
+      # the body of the response will be returned.
+      #
+      # TODO: Handle redirects.
+      #
+      def fetch(options = {})
+        begin
+          ::Atom::Feed.load_feed(URI.parse(self.href), options)
+        rescue ArgumentError
+          Net::HTTP.get_response(URI.parse(self.href)).body
+        end
+      end
+
+      # :nodoc:
+      def inspect
+        "<Nelumba::Link href:'#{href}' type:'#{type}'>"
+      end
+    end
+  end
+end

data/lib/nelumba/atom/name.rb

@@ -0,0 +1,57 @@
+module Nelumba
+  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/nelumba/atom/organization.rb

@@ -0,0 +1,62 @@
+module Nelumba
+  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/nelumba/atom/person.rb

@@ -0,0 +1,179 @@
+require 'nelumba/activity'
+require 'nelumba/atom/name'
+require 'nelumba/atom/address'
+require 'nelumba/atom/account'
+require 'nelumba/atom/organization'
+
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # Holds information about the author of the Feed.
+    class Person < ::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'
+
+      # 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 != :uri) && (k != :name) && (k != :email) && (k != :pronoun)
+            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

data/lib/nelumba/atom/portable_contacts.rb

@@ -0,0 +1,117 @@
+module Nelumba
+  module Atom
+    # Holds information about the extended contact information
+    # in the Feed given in the Portable Contacts specification.
+    class PortableContacts
+      # Instantiates a Nelumba::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
+        Nelumba::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