nelumba 0.0.13

data/lib/nelumba/note.rb

@@ -0,0 +1,34 @@
+module Nelumba
+  class Note
+    include Nelumba::Object
+
+    # Create a new note.
+    #
+    # options:
+    #   :title        => The title of the note. Defaults: "Untitled"
+    #   :text         => The content of the note. Defaults: ""
+    #   :html         => The content of the note as html.
+    #   :author       => An Person that wrote the note.
+    #   :url          => Permanent location for an html representation of the
+    #                    note.
+    #   :published    => When the note was originally published.
+    #   :updated      => When the note was last updated.
+    #   :uid          => The unique id that identifies this note.
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    # Returns a hash of all relevant fields.
+    def to_hash
+      super.to_hash
+    end
+
+    # Returns a hash of all relevant fields with JSON activity streams
+    # conventions.
+    def to_json_hash
+      {
+        :objectType => "note",
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/notification.rb

@@ -0,0 +1,229 @@
+module Nelumba
+  # This represents a notification that can be sent to a server when you wish
+  # to send information to a server that has not yet subscribed to you. Since
+  # this implies a lack of trust, a notification adds a layer so that the
+  # recipiant can verify the message contents.
+  class Notification
+    require 'xml'
+    require 'digest/sha2'
+
+    # The Activity that is represented by this notification.
+    attr_reader :activity
+
+    # The identity of the sender that can be used to discover the Identity
+    attr_reader :account
+
+    # Create an instance for a particular Nelumba::Activity.
+    def initialize activity, signature = nil, plaintext = nil
+      @activity = activity
+      @signature = signature
+      @plaintext = plaintext
+
+      account = activity.actor.uri
+
+      # XXX: Negotiate various weird uri schemes to find identity account
+      @account = account
+    end
+
+    # Creates an activity for following a particular Person.
+    def self.from_follow(user_author, followed_author)
+      activity = Nelumba::Activity.new(
+        :verb => :follow,
+        :object => followed_author,
+        :actor    => user_author,
+        :title    => "Now following #{followed_author.name}",
+        :content  => "Now following #{followed_author.name}",
+        :content_type => "html"
+      )
+
+      self.new(activity)
+    end
+
+    # Creates an activity for unfollowing a particular Person.
+    def self.from_unfollow(user_author, followed_author)
+      activity = Nelumba::Activity.new(
+        :verb => "http://ostatus.org/schema/1.0/unfollow",
+        :object => followed_author,
+        :actor    => user_author,
+        :title => "Stopped following #{followed_author.name}",
+        :content => "Stopped following #{followed_author.name}",
+        :content_type => "html"
+      )
+
+      self.new(activity)
+    end
+
+    # Creates an activity for a profile update.
+    def self.from_profile_update(user_author)
+      activity = Nelumba::Activity.new(
+        :verb => "http://ostatus.org/schema/1.0/update-profile",
+        :actor    => user_author,
+        :title => "#{user_author.name} changed their profile information.",
+        :content => "#{user_author.name} changed their profile information.",
+        :content_type => "html"
+      )
+
+      self.new(activity)
+    end
+
+    # Will pull a Nelumba::Activity from the given payload and MIME type.
+    def self.from_data(content, content_type)
+      case content_type
+      when 'xml',
+           'magic-envelope+xml',
+           'application/xml',
+           'application/text+xml',
+           'application/magic-envelope+xml'
+        self.from_xml content
+      when 'json',
+           'magic-envelope+json',
+           'application/json',
+           'application/text+json',
+           'application/magic-envelope+json'
+        self.from_json content
+      end
+    end
+
+    # Will pull a Nelumba::Activity from a magic envelope described by the JSON.
+    def self.from_json(source)
+    end
+
+    # Will pull a Nelumba::Activity from a magic envelope described by the XML.
+    def self.from_xml(source)
+      if source.is_a?(String)
+        if source.length == 0
+          return nil
+        end
+
+        source = XML::Document.string(source,
+                                      :options => XML::Parser::Options::NOENT)
+      else
+        return nil
+      end
+
+      # Retrieve the envelope
+      envelope = source.find('/me:env',
+                             'me:http://salmon-protocol.org/ns/magic-env').first
+
+      return nil unless envelope
+
+      data = envelope.find('me:data',
+                           'me:http://salmon-protocol.org/ns/magic-env').first
+      return nil unless data
+
+      data_type = data.attributes["type"]
+      if data_type.nil?
+        data_type = 'application/atom+xml'
+        armored_data_type = ''
+      else
+        armored_data_type = Base64::urlsafe_encode64(data_type)
+      end
+
+      encoding = envelope.find('me:encoding',
+                               'me:http://salmon-protocol.org/ns/magic-env').first
+
+      algorithm = envelope.find(
+                          'me:alg',
+                          'me:http://salmon-protocol.org/ns/magic-env').first
+
+      signature = source.find('me:sig',
+                           'me:http://salmon-protocol.org/ns/magic-env').first
+
+      # Parse fields
+
+      # Well, if we cannot verify, we don't accept
+      return nil unless signature
+
+      # XXX: Handle key_id attribute
+      signature = signature.content
+      signature = Base64::urlsafe_decode64(signature)
+
+      if encoding.nil?
+        # When the encoding is omitted, use base64url
+        # Cite: Magic Envelope Draft Spec Section 3.3
+        armored_encoding = ''
+        encoding = 'base64url'
+      else
+        armored_encoding = Base64::urlsafe_encode64(encoding.content)
+        encoding = encoding.content.downcase
+      end
+
+      if algorithm.nil?
+        # When algorithm is omitted, use 'RSA-SHA256'
+        # Cite: Magic Envelope Draft Spec Section 3.3
+        armored_algorithm = ''
+        algorithm = 'rsa-sha256'
+      else
+        armored_algorithm = Base64::urlsafe_encode64(algorithm.content)
+        algorithm = algorithm.content.downcase
+      end
+
+      # Retrieve and decode data payload
+
+      data = data.content
+      armored_data = data
+
+      case encoding
+      when 'base64url'
+        data = Base64::urlsafe_decode64(data)
+      else
+        # Unsupported data encoding
+        return nil
+      end
+
+      # Signature plaintext
+      plaintext = "#{armored_data}.#{armored_data_type}.#{armored_encoding}.#{armored_algorithm}"
+
+      # Interpret data payload
+      payload = XML::Reader.string(data)
+      self.new Nelumba::Atom::Entry.new(payload).to_canonical, signature, plaintext
+    end
+
+    # Generate the xml for this notice and sign with the given private key.
+    def to_xml private_key
+      # Generate magic envelope
+      magic_envelope = XML::Document.new
+
+      magic_envelope.root = XML::Node.new 'env'
+
+      me_ns = XML::Namespace.new(magic_envelope.root,
+                   'me', 'http://salmon-protocol.org/ns/magic-env')
+
+      magic_envelope.root.namespaces.namespace = me_ns
+
+      # Armored Data <me:data>
+      data = @activity.to_atom
+      @plaintext = data
+      data_armored = Base64::urlsafe_encode64(data)
+      elem = XML::Node.new 'data', data_armored, me_ns
+      elem.attributes['type'] = 'application/atom+xml'
+      data_type_armored = 'YXBwbGljYXRpb24vYXRvbSt4bWw='
+      magic_envelope.root << elem
+
+      # Encoding <me:encoding>
+      magic_envelope.root << XML::Node.new('encoding', 'base64url', me_ns)
+      encoding_armored = 'YmFzZTY0dXJs'
+
+      # Signing Algorithm <me:alg>
+      magic_envelope.root << XML::Node.new('alg', 'RSA-SHA256', me_ns)
+      algorithm_armored = 'UlNBLVNIQTI1Ng=='
+
+      # Signature <me:sig>
+      plaintext =
+        "#{data_armored}.#{data_type_armored}.#{encoding_armored}.#{algorithm_armored}"
+
+      # Assign @signature to the signature generated from the plaintext
+      @signature = Nelumba::Crypto.emsa_sign(plaintext, private_key)
+
+      signature_armored = Base64::urlsafe_encode64(@signature)
+      magic_envelope.root << XML::Node.new('sig', signature_armored, me_ns)
+
+      magic_envelope.to_s :indent => true, :encoding => XML::Encoding::UTF_8
+    end
+
+    # Check the origin of this notification.
+    def verified? key
+      Nelumba::Crypto.emsa_verify(@plaintext, @signature, key)
+    end
+  end
+end

data/lib/nelumba/object.rb

@@ -0,0 +1,251 @@
+module Nelumba
+  module Object
+    require 'json'
+    require 'cgi'
+
+    # Determines what constitutes a username inside an update text
+    USERNAME_REGULAR_EXPRESSION = /(^|[ \t\n\r\f"'\(\[{]+)@([^ \t\n\r\f&?=@%\/\#]*[^ \t\n\r\f&?=@%\/\#.!:;,"'\]}\)])(?:@([^ \t\n\r\f&?=@%\/\#]*[^ \t\n\r\f&?=@%\/\#.!:;,"'\]}\)]))?/
+
+    attr_reader :title
+    attr_reader :author
+    attr_reader :display_name
+    attr_reader :uid
+    attr_reader :url
+
+    # Natural-language description of this object
+    attr_reader :summary
+
+    # The image representation of this object
+    attr_reader :image
+
+    # Natural-language text content
+    attr_reader :content
+
+    attr_reader :published
+    attr_reader :updated
+
+    # Holds the content as plain text.
+    attr_reader :text
+
+    # Holds the content as html.
+    attr_reader :html
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      @author        = options[:author]
+      @content       = options[:content]
+      @display_name  = options[:display_name]
+      @uid           = options[:uid]
+      @url           = options[:url]
+      @summary       = options[:summary]
+      @published     = options[:published] || Time.now
+      @updated       = options[:updated] || Time.now
+      @title         = options[:title] || "Untitled"
+
+      options[:published] = @published
+      options[:updated]   = @updated
+      options[:title]     = @title
+
+      # Alternative representations of 'content'
+      @text          = options[:text] || @content || ""
+      @content       = @content || options[:text]
+      options[:text] = @text
+
+      @html          = options[:html] || to_html(&blk)
+      @content       = @content || @html
+      options[:html] = @html
+    end
+
+    # TODO: Convert html to safe text
+    def to_text()
+      return @text if @text
+
+      return "" if @html.nil?
+
+      ""
+    end
+
+    # Produces an HTML string representing the Object's content.
+    #
+    # Requires a block that is given two arguments: the username and the domain
+    # that should return a Nelumba::Person that matches when a @username tag
+    # is found.
+    def to_html(&blk)
+      return @html if @html
+
+      return "" if @text.nil?
+
+      out = CGI.escapeHTML(@text)
+
+      # Replace any absolute addresses with a link
+      # Note: Do this first! Otherwise it will add anchors inside anchors!
+      out.gsub!(/(http[s]?:\/\/\S+[a-zA-Z0-9\/}])/, "<a href='\\1'>\\1</a>")
+
+      # we let almost anything be in a username, except those that mess with urls.
+      # but you can't end in a .:;, or !
+      # also ignore container chars [] () "" '' {}
+      # XXX: the _correct_ solution will be to use an email validator
+      out.gsub!(USERNAME_REGULAR_EXPRESSION) do |match|
+        if blk
+          author = blk.call($2, $3)
+        end
+
+        if author
+          "#{$1}<a href='#{author.uri}'>@#{$2}</a>"
+        else
+          "#{$1}@#{$2}"
+        end
+      end
+
+      out.gsub!( /(^|\s+)#(\p{Word}+)/ ) do |match|
+        "#{$1}<a href='/search?search=%23#{$2}'>##{$2}</a>"
+      end
+
+      out.gsub!(/\n/, "<br/>")
+
+      out
+    end
+
+    # Returns a list of Nelumba::Person's for those replied by the object.
+    #
+    # Requires a block that is given two arguments: the username and the domain
+    # that should return a Nelumba::Person that matches when a @username tag
+    # is found.
+    #
+    # Usage:
+    #
+    # note = Nelumba::Note.new(:text => "Hello @foo")
+    # note.reply_to do |username, domain|
+    #   i = identities.select {|e| e.username == username && e.domain == domain }.first
+    #   i.author if i
+    # end
+    #
+    # With a persistence backend:
+    # note.reply_to do |username, domain|
+    #   i = Identity.first(:username => /^#{Regexp.escape(username)}$/i
+    #   i.author if i
+    # end
+    def reply_to(&blk)
+      out = CGI.escapeHTML(@text)
+
+      # we let almost anything be in a username, except those that mess with urls.
+      # but you can't end in a .:;, or !
+      # also ignore container chars [] () "" '' {}
+      # XXX: the _correct_ solution will be to use an email validator
+      ret = []
+      out.match(/^#{USERNAME_REGULAR_EXPRESSION}/) do |beginning, username, domain|
+        ret << blk.call(username, domain) if blk
+      end
+
+      ret
+    end
+
+    def to_hash(scheme = 'https', domain = 'example.org', port = nil)
+      url_start = "#{scheme}://#{domain}#{port.nil? ? "" : ":#{port}"}"
+
+      uid = self.uid
+      url = self.url
+
+      if uid && uid.start_with?("/")
+        uid = "#{url_start}#{uid}"
+      end
+
+      if url && url.start_with?("/")
+        url = "#{url_start}#{url}"
+      end
+
+      {
+        :author       => self.author,
+        :summary      => self.summary,
+        :content      => self.content,
+        :display_name => self.display_name,
+        :uid          => uid,
+        :url          => url,
+        :published    => self.published,
+        :updated      => self.updated,
+        :title        => self.title,
+        :text         => self.text,
+        :html         => self.html,
+      }
+    end
+
+    def to_json_hash(scheme = 'https', domain = 'example.org', port = nil)
+      url_start = "#{scheme}://#{domain}#{port.nil? ? "" : ":#{port}"}"
+
+      uid = self.uid
+      url = self.url
+
+      if uid && uid.start_with?("/")
+        uid = "#{url_start}#{uid}"
+      end
+
+      if url && url.start_with?("/")
+        url = "#{url_start}#{url}"
+      end
+
+      {
+        :author      => self.author,
+        :content     => self.content,
+        :summary     => self.summary,
+        :displayName => self.display_name,
+        :id          => uid,
+        :url         => url,
+        :title       => self.title,
+        :published   => (self.published ? self.published.to_date.rfc3339 + 'Z' : nil),
+        :updated     => (self.updated ? self.updated.to_date.rfc3339 + 'Z' : nil),
+      }
+    end
+
+    # Returns a list of Nelumba::Person's for those mentioned within the object.
+    #
+    # Requires a block that is given two arguments: the username and the domain
+    # that should return a Nelumba::Person that matches when a @username tag
+    # is found.
+    #
+    # Usage:
+    #
+    # note = Nelumba::Note.new(:text => "Hello @foo")
+    # note.mentions do |username, domain|
+    #   i = identities.select {|e| e.username == username && e.domain == domain }.first
+    #   i.author if i
+    # end
+    #
+    # With a persistence backend:
+    # note.mentions do |username, domain|
+    #   i = Identity.first(:username => /^#{Regexp.escape(username)}$/i)
+    #   i.author if i
+    # end
+    def mentions(&blk)
+      if self.respond_to? :text
+        out = self.text || ""
+      else
+        out = self.content || ""
+      end
+
+      out = CGI.escapeHTML(out)
+
+      # we let almost anything be in a username, except those that mess with urls.
+      # but you can't end in a .:;, or !
+      # also ignore container chars [] () "" '' {}
+      # XXX: the _correct_ solution will be to use an email validator
+      ret = []
+      out.scan(USERNAME_REGULAR_EXPRESSION) do |beginning, username, domain|
+        ret << blk.call(username, domain) if blk
+      end
+
+      ret
+    end
+
+    # Returns a string containing the JSON representation of this Object.
+    def to_json(*args)
+      to_json_hash.delete_if{|k,v| v.nil?}.to_json(*args)
+    end
+
+    def to_as1(*args)
+      to_json_hash.delete_if{|k,v| v.nil?}.to_json(*args)
+    end
+  end
+end