lotus 0.0.12

data/lib/lotus/author.rb

@@ -0,0 +1,177 @@
+require 'lotus/activity'
+
+module Lotus
+  require 'atom'
+
+  # Holds information about the author of the Feed.
+  class Author
+    require 'date'
+
+    # Holds the id that represents this contact.
+    attr_reader :id
+
+    # Holds the nickname of this contact.
+    attr_reader :nickname
+
+    # Holds a hash representing information about the name of this contact.
+    #
+    # contains one or more of the following:
+    #   :formatted         => The full name of the contact
+    #   :family_name       => The family name. "Last name" in Western contexts.
+    #   :given_name        => The given name. "First name" in Western contexts.
+    #   :middle_name       => The middle name.
+    #   :honorific_prefix  => "Title" in Western contexts. (e.g. "Mr." "Mrs.")
+    #   :honorific_suffix  => "Suffix" in Western contexts. (e.g. "Esq.")
+    attr_reader :extended_name
+
+    # The uri that uniquely identifies the author.
+    attr_reader :uri
+
+    # The email address of the author.
+    attr_reader :email
+
+    # The name of the author
+    attr_reader :name
+
+    # Holds a hash representing the address of the contact.
+    #
+    # contains one or more of the following:
+    #   :formatted      => A formatted representating of the address. May
+    #                     contain newlines.
+    #   :street_address => The full street address. May contain newlines.
+    #   :locality       => The city or locality component.
+    #   :region         => The state or region component.
+    #   :postal_code    => The zipcode or postal code component.
+    #   :country        => The country name component.
+    attr_reader :address
+
+    # Holds a hash representing an organization for this contact.
+    #
+    # contains one or more of the following:
+    #   :name        => The name of the organization (e.g. company, school,
+    #                   etc) This field is required. Will be used for sorting.
+    #   :department  => The department within the organization.
+    #   :title       => The title or role within the organization.
+    #   :type        => The type of organization. Canonical values include
+    #                   "job" or "school"
+    #   :start_date  => A DateTime representing when the contact joined
+    #                   the organization.
+    #   :end_date    => A DateTime representing when the contact left the
+    #                   organization.
+    #   :location    => The physical location of this organization.
+    #   :description => A free-text description of the role this contact
+    #                   played in this organization.
+    attr_reader :organization
+
+    # Holds a hash representing information about an account held by this
+    # contact.
+    #
+    # contains one or more of the following:
+    #   :domain   => The top-most authoriative domain for this account. (e.g.
+    #                "twitter.com") This is the primary field. Is required.
+    #                Used for sorting.
+    #   :username => An alphanumeric username, typically chosen by the user.
+    #   :userid   => A user id, typically assigned, that uniquely refers to
+    #                the user.
+    attr_reader :account
+
+    # Holds the gender of this contact.
+    attr_reader :gender
+
+    # Holds a note for this contact.
+    attr_reader :note
+
+    # Holds the display name for this contact.
+    attr_reader :display_name
+
+    # Holds the preferred username of this contact.
+    attr_reader :preferred_username
+
+    # Holds a DateTime that represents when this contact was last modified.
+    attr_reader :updated
+
+    # Holds a DateTime that represents when this contact was originally
+    # published.
+    attr_reader :published
+
+    # Holds a DateTime representing this contact's birthday.
+    attr_reader :birthday
+
+    # Holds a DateTime representing a contact's anniversary.
+    attr_reader :anniversary
+
+    # Creates a representating of an author.
+    #
+    # options:
+    #   name               => The name of the author. Defaults: "anonymous"
+    #   id                 => The identifier that uniquely identifies the
+    #                         contact.
+    #   nickname           => The nickname of the contact.
+    #   gender             => The gender of the contact.
+    #   note               => A note for this contact.
+    #   display_name       => The display name for this contact.
+    #   preferred_username => The preferred username for this contact.
+    #   updated            => A DateTime representing when this contact was
+    #                         last updated.
+    #   published          => A DateTime representing when this contact was
+    #                         originally created.
+    #   birthday           => A DateTime representing a birthday for this
+    #                         contact.
+    #   anniversary        => A DateTime representing an anniversary for this
+    #                         contact.
+    #   extended_name      => A Hash representing the name of the contact.
+    #   organization       => A Hash representing the organization of which the
+    #                         contact belongs.
+    #   account            => A Hash describing the authorative account for the
+    #                         author.
+    #   address            => A Hash describing the address of the contact.
+    #   uri                => The uri that uniquely identifies this author.
+    #   email              => The email of the author.
+    def initialize(options = {})
+      @uri = options[:uri]
+      @name = options[:name] || "anonymous"
+      @email = options[:email]
+
+      @id = options[:id]
+      @name = options[:name]
+      @gender = options[:gender]
+      @note = options[:note]
+      @nickname = options[:nickname]
+      @display_name = options[:display_name]
+      @preferred_username = options[:preferred_username]
+      @updated = options[:updated]
+      @published = options[:published]
+      @birthday = options[:birthday]
+      @anniversary = options[:anniversary]
+
+      @extended_name = options[:extended_name]
+      @organization = options[:organization]
+      @account = options[:account]
+      @address = options[:address]
+    end
+
+    def to_hash
+      {
+        :uri => self.uri,
+        :email => self.email,
+        :name => self.name,
+
+        :id => self.id,
+        :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,
+
+        :extended_name => self.extended_name,
+        :organization => self.organization,
+        :account => self.account,
+        :address => self.address
+      }
+    end
+  end
+end

data/lib/lotus/category.rb

@@ -0,0 +1,45 @@
+module Lotus
+  # This element conveys information about a category associated with an entry
+  # or feed. There is no defined meaning to the content according to the Atom
+  # specification.
+  class Category
+    # Holds the base URI for relative URIs contained in scheme.
+    attr_reader :base
+
+    # Holds the language of term and label, when it exists. The language
+    # should be specified as RFC 3066 as either 2 or 3 letter codes.
+    # For example: 'en' for English or more specifically 'en-us'
+    attr_reader :lang
+
+    # Holds the optional scheme used for categorization.
+    attr_reader :scheme
+
+    # Holds the string identifying the category to which the entry or
+    # feed belongs.
+    attr_reader :term
+
+    # Holds the string that provides a human-readable label for display in
+    # end-user applications. The content of this field is language sensitive.
+    attr_reader :label
+
+    # Create a Category to apply to a feed or entry.
+    def initialize(options = {})
+      @base = options[:base]
+      @lang = options[:lang]
+      @scheme = options[:scheme]
+      @term = options[:term]
+      @label = options[:label]
+    end
+
+    # Yields a Hash that represents this category.
+    def to_hash
+      {
+        :base => @base,
+        :lang => @lang,
+        :scheme => @scheme,
+        :term => @term,
+        :label => @label
+      }
+    end
+  end
+end

data/lib/lotus/crypto.rb

@@ -0,0 +1,146 @@
+module Lotus
+  module Crypto
+    require 'openssl'
+    require 'rsa'
+    require 'base64'
+
+    KeyPair = Struct.new(:public_key, :private_key)
+
+    # Generate a new RSA keypair with the given bitlength.
+    def self.new_keypair(bits = 2048)
+      keypair = KeyPair.new
+
+      key = RSA::KeyPair.generate(bits)
+
+      public_key = key.public_key
+      m = public_key.modulus
+      e = public_key.exponent
+
+      modulus = ""
+      until m == 0 do
+        modulus << [m % 256].pack("C")
+        m >>= 8
+      end
+      modulus.reverse!
+
+      exponent = ""
+      until e == 0 do
+        exponent << [e % 256].pack("C")
+        e >>= 8
+      end
+      exponent.reverse!
+
+      keypair.public_key = "RSA.#{Base64::urlsafe_encode64(modulus)}.#{Base64::urlsafe_encode64(exponent)}"
+
+      tmp_private_key = key.private_key
+      m = tmp_private_key.modulus
+      e = tmp_private_key.exponent
+
+      modulus = ""
+      until m == 0 do
+        modulus << [m % 256].pack("C")
+        m >>= 8
+      end
+      modulus.reverse!
+
+      exponent = ""
+      until e == 0 do
+        exponent << [e % 256].pack("C")
+        e >>= 8
+      end
+      exponent.reverse!
+
+      keypair.private_key = "RSA.#{Base64::urlsafe_encode64(modulus)}.#{Base64::urlsafe_encode64(exponent)}"
+
+      keypair
+    end
+
+    # Creates an EMSA signature for the given plaintext and key.
+    def self.emsa_sign(text, private_key)
+      private_key = generate_key(private_key) unless private_key.is_a? RSA::Key
+
+      signature = self.emsa_signature(text, private_key)
+
+      self.decrypt(private_key, signature)
+    end
+
+    # Verifies an existing EMSA signature.
+    def self.emsa_verify(text, signature, public_key)
+      # RSA encryption is needed to compare the signatures
+      public_key = generate_key(public_key) unless public_key.is_a? RSA::Key
+
+      # Get signature to check
+      emsa = self.emsa_signature(text, public_key)
+
+      # Get signature in payload
+      emsa_signature = self.encrypt(public_key, signature)
+
+      # RSA gem drops leading 0s since it does math upon an Integer
+      # As a workaround, I check for what I expect the second byte to be (\x01)
+      # This workaround will also handle seeing a \x00 first if the RSA gem is
+      # fixed.
+      if emsa_signature.getbyte(0) == 1
+        emsa_signature = "\x00#{emsa_signature}"
+      end
+
+      # Does the signature match?
+      # Return the result.
+      emsa_signature == emsa
+    end
+
+    # Decrypts the given data with the given private key.
+    def self.decrypt(private_key, data)
+      private_key = generate_key(private_key) unless private_key.is_a? RSA::Key
+      keypair = generate_keypair(nil, private_key)
+      keypair.decrypt(data)
+    end
+
+    # Encrypts the given data with the given public key.
+    def self.encrypt(public_key, data)
+      public_key = generate_key(public_key) unless public_key.is_a? RSA::Key
+      keypair = generate_keypair(public_key, nil)
+      keypair.encrypt(data)
+    end
+
+    private
+
+    # :nodoc:
+    def self.emsa_signature(text, key)
+      modulus_byte_count = key.modulus.size
+
+      plaintext = Digest::SHA2.new(256).digest(text)
+
+      prefix = "\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20"
+      padding_count = modulus_byte_count - prefix.bytes.count - plaintext.bytes.count - 3
+
+      padding = ""
+      padding_count.times do
+        padding = padding + "\xff"
+      end
+
+      "\x00\x01#{padding}\x00#{prefix}#{plaintext}".force_encoding('binary')
+    end
+
+    # :nodoc:
+    def self.generate_key(key_string)
+      return nil unless key_string
+
+      key_string.match /^RSA\.(.*?)\.(.*)$/
+
+      modulus = decode_key($1)
+      exponent = decode_key($2)
+
+      RSA::Key.new(modulus, exponent)
+    end
+
+    def self.generate_keypair(public_key, private_key)
+      RSA::KeyPair.new(private_key, public_key)
+    end
+
+    # :nodoc:
+    def self.decode_key(encoded_key_part)
+      modulus = Base64::urlsafe_decode64(encoded_key_part)
+      modulus.bytes.inject(0) {|num, byte| (num << 8) | byte }
+    end
+  end
+end

data/lib/lotus/feed.rb

@@ -0,0 +1,190 @@
+require 'lotus/activity'
+require 'lotus/author'
+
+module Lotus
+  require 'atom'
+
+  # This class represents a Lotus::Feed object.
+  class Feed
+    require 'open-uri'
+    require 'date'
+
+    # Holds the id that uniquely represents this feed.
+    attr_reader :id
+
+    # Holds the url that represents this feed.
+    attr_reader :url
+
+    # Holds the list of categories for this feed as Lotus::Category.
+    attr_reader :categories
+
+    # Holds human-readable information about the content rights of the entries
+    # in the feed without an explicit rights field of their own. SHOULD NOT be
+    # machine interpreted.
+    attr_reader :rights
+
+    # Holds the title for this feed.
+    attr_reader :title
+
+    # Holds the content-type for the title.
+    attr_reader :title_type
+
+    # Holds the subtitle for this feed.
+    attr_reader :subtitle
+
+    # Holds the content-type for the subtitle.
+    attr_reader :subtitle_type
+
+    # Holds the URL for the icon representing this feed.
+    attr_reader :icon
+
+    # Holds the URL for the logo representing this feed.
+    attr_reader :logo
+
+    # Holds the generator for this content as an Lotus::Generator.
+    attr_reader :generator
+
+    # Holds the list of contributors, if any, that are involved in this feed
+    # as Lotus::Author.
+    attr_reader :contributors
+
+    # Holds the DateTime when this feed was originally created.
+    attr_reader :published
+
+    # Holds the DateTime when this feed was last modified.
+    attr_reader :updated
+
+    # Holds the list of authors as Lotus::Author responsible for this feed.
+    attr_reader :authors
+
+    # Holds the list of entries as Lotus::Activity contained within this feed.
+    attr_reader :entries
+
+    # Holds the list of hubs that are available to manage subscriptions to this
+    # feed.
+    attr_reader :hubs
+
+    # Holds the salmon url that handles notifications for this feed.
+    attr_reader :salmon_url
+
+    # Holds links to other resources as an array of Lotus::Link
+    attr_reader :links
+
+    # Creates a new representation of a feed.
+    #
+    # options:
+    #   id            => The unique identifier for this feed.
+    #   url           => The url that represents this feed.
+    #   title         => The title for this feed. Defaults: "Untitled"
+    #   title_type    => The content type for the title.
+    #   subtitle      => The subtitle for this feed.
+    #   subtitle_type => The content type for the subtitle.
+    #   authors       => The list of Lotus::Author's for this feed.
+    #                    Defaults: []
+    #   contributors  => The list of Lotus::Author's that contributed to this
+    #                    feed. Defaults: []
+    #   entries       => The list of Lotus::Activity's for this feed.
+    #                    Defaults: []
+    #   icon          => The url of the icon that represents this feed. It
+    #                    should have an aspect ratio of 1 horizontal to 1
+    #                    vertical and optimized for presentation at a
+    #                    small size.
+    #   logo          => The url of the logo that represents this feed. It
+    #                    should have an aspect ratio of 2 horizontal to 1
+    #                    vertical.
+    #   categories    => An array of Lotus::Category's that describe how to
+    #                    categorize and describe the content of the feed.
+    #                    Defaults: []
+    #   rights        => A String depicting the rights of entries without
+    #                    explicit rights of their own. SHOULD NOT be machine
+    #                    interpreted.
+    #   updated       => The DateTime representing when this feed was last
+    #                    modified.
+    #   published     => The DateTime representing when this feed was originally
+    #                    published.
+    #   salmon_url    => The url of the salmon endpoint, if one exists, for this
+    #                    feed.
+    #   links         => An array of Lotus::Link that adds relations to other
+    #                    resources.
+    #   generator     => A Lotus::Generator representing the agent
+    #                    responsible for generating this feed.
+    #
+    # Usage:
+    #
+    #   author = Lotus::Author.new(:name => "Kelly")
+    #
+    #   feed = Lotus::Feed.new(:title   => "My Feed",
+    #                            :id      => "1",
+    #                            :url     => "http://example.com/feeds/1",
+    #                            :authors => [author])
+    def initialize(options = {})
+      @id = options[:id]
+      @url = options[:url]
+      @icon = options[:icon]
+      @logo = options[:logo]
+      @rights = options[:rights]
+      @title = options[:title] || "Untitled"
+      @title_type = options[:title_type]
+      @subtitle = options[:subtitle]
+      @subtitle_type = options[:subtitle_type]
+      @authors = options[:authors] || []
+      @categories = options[:categories] || []
+      @contributors = options[:contributors] || []
+      @entries = options[:entries] || []
+      @updated = options[:updated]
+      @published = options[:published]
+      @salmon_url = options[:salmon_url]
+      @hubs = options[:hubs] || []
+      @generator = options[:generator]
+    end
+
+    # Yields a Lotus::Link to this feed.
+    #
+    # options: Can override Lotus::Link properties, such as rel.
+    #
+    # Usage:
+    #
+    #   feed = Lotus::Feed.new(:title => "Foo", :url => "http://example.com")
+    #   feed.to_link(:rel => "alternate", :title => "Foo's Feed")
+    #
+    # Generates a link with:
+    #   <Lotus::Link rel="alternate" title="Foo's Feed" url="http://example.com">
+    def to_link(options = {})
+      options = { :title => self.title,
+                  :href  => self.url }.merge(options)
+
+      Lotus::Link.new(options)
+    end
+
+    # Returns a hash of the properties of the feed.
+    def to_hash
+      {
+        :id => self.id,
+        :url => self.url,
+        :hubs => self.hubs.dup,
+        :icon => self.icon,
+        :logo => self.logo,
+        :rights => self.rights,
+        :title => self.title,
+        :title_type => self.title_type,
+        :subtitle => self.subtitle,
+        :subtitle_type => self.subtitle_type,
+        :authors => self.authors.dup,
+        :categories => self.categories.dup,
+        :contributors => self.contributors.dup,
+        :entries => self.entries.dup,
+        :updated => self.updated,
+        :salmon_url => self.salmon_url,
+        :published => self.published,
+        :generator => self.generator
+      }
+    end
+
+    # Returns a string containing an Atom representation of the feed.
+    def to_atom
+      require 'lotus/atom/feed'
+
+      Lotus::Atom::Feed.from_canonical(self).to_xml
+    end
+  end
+end