nelumba-mongodb 0.0.1

data/lib/nelumba-mongodb/article.rb

@@ -0,0 +1,30 @@
+module Nelumba
+  class Article
+    require 'redcarpet'
+
+    include Nelumba::EmbeddedObject
+
+    key :markdown
+
+    def initialize(options = {})
+      super(options)
+
+      self.render_markdown unless options[:content]
+    end
+
+    def markdown=(value)
+      super value
+      render_markdown
+    end
+
+    # Generates content field with the markdown field.
+    def render_markdown
+      return if self.markdown.nil?
+
+      render_as = Redcarpet::Render::HTML
+      engine = Redcarpet::Markdown.new(render_as, :autolink            => true,
+                                                  :space_after_headers => true)
+      self.content = engine.render(self.markdown)
+    end
+  end
+end

data/lib/nelumba-mongodb/authorization.rb

@@ -0,0 +1,213 @@
+module Nelumba
+  # This represents how a Person can authenticate to act on our server.
+  # This is attached to an Identity and a Person. Use this to allow an
+  # Person to generate Activities on this server.
+  class Authorization
+    require 'bcrypt'
+    require 'json'
+    require 'nokogiri'
+
+    include MongoMapper::Document
+
+    # Ensure writes happen
+    safe
+
+    # An Authorization involves a Person.
+    key :person_id,     ObjectId
+    belongs_to :person, :class_name => 'Nelumba::Person'
+
+    # Whether or not this authorization requires ssl
+    key :ssl
+
+    # The domain this authorization is registered for
+    key :domain
+
+    # The port authorization is tied to
+    key :port
+
+    # An Authorization involves an Identity.
+    key :identity_id, ObjectId
+    belongs_to :identity, :class_name => 'Nelumba::Identity'
+
+    # You authorize with a username
+    key :username,        String
+
+    # A private key can verify that external information originated with this
+    # account.
+    key :private_key,     String
+
+    # A password can authenticate you if you are manually signing in as a human
+    # being. The password is hashed to prevent information leaking.
+    key :hashed_password, String
+
+    # You must have enough credentials to be able to log into the system:
+    validates_presence_of :username
+    validates_presence_of :identity
+    validates_presence_of :hashed_password
+
+    # Log modification
+    timestamps!
+
+    # Generate a Hash containing this person's LRDD meta info.
+    def self.lrdd(username)
+      username = username.match /(?:acct\:)?([^@]+)(?:@([^@]+))?$/
+      username = username[1] if username
+      if username.nil?
+        return nil
+      end
+
+      # Find the person
+      auth = Authorization.find_by_username(/#{Regexp.escape(username)}/i)
+      return nil unless auth
+
+      domain    = auth.identity.domain
+      port      = auth.identity.port
+      url       = "http#{auth.identity.ssl ? "s" : ""}://#{auth.identity.domain}#{port ? ":#{port}" : ""}"
+      feed_id   = auth.identity.outbox.id
+      person_id = auth.person.id
+
+      {
+        :subject => "acct:#{username}@#{domain}#{port ? ":#{port}" : ""}",
+        :expires => "#{(Time.now.utc.to_date >> 1).xmlschema}Z",
+        :aliases => [
+          "#{url}#{auth.identity.profile_page}",
+          "#{url}/feeds/#{feed_id}"
+        ],
+        :links => [
+          {:rel  => "http://webfinger.net/rel/profile-page",
+           :href => "#{url}/people/#{person_id}"},
+          {:rel  => "http://schemas.google.com/g/2010#updates-from",
+           :href => "#{url}/feeds/#{feed_id}"},
+          {:rel  => "salmon",
+           :href => "#{url}/people/#{person_id}/salmon"},
+          {:rel  => "http://salmon-protocol.org/ns/salmon-replies",
+           :href => "#{url}/people/#{person_id}/salmon"},
+          {:rel  => "http://salmon-protocol.org/ns/salmon-mention",
+           :href => "#{url}/people/#{person_id}/salmon"},
+          {:rel  => "magic-public-key",
+           :href => "data:application/magic-public-key,#{auth.identity.public_key}"}
+
+          # TODO: ostatus subscribe
+          #{:rel      => "http://ostatus.org/schema/1.0/subscribe",
+          # :template => "#{url}/subscriptions?url={uri}&_method=post"}
+        ]
+      }
+    end
+
+    # Generate a String containing the json representation of this person's LRDD.
+    def self.jrd(username)
+      lrdd = self.lrdd(username)
+      return nil if lrdd.nil?
+
+      lrdd.to_json
+    end
+
+    # Generate a String containing the XML representaton of this person's LRDD.
+    def self.xrd(username)
+      lrdd = self.lrdd(username)
+      return nil if lrdd.nil?
+
+      # Build xml
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.XRD("xmlns"     => 'http://docs.oasis-open.org/ns/xri/xrd-1.0',
+                "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance') do
+          xml.Subject lrdd[:subject]
+          xml.Expires lrdd[:expires]
+
+          lrdd[:aliases].each do |alias_name|
+            xml.Alias alias_name
+          end
+
+          lrdd[:links].each do |link|
+            xml.Link link
+          end
+        end
+      end
+
+      # Output
+      builder.to_xml
+    end
+
+    # Create a hash of the password.
+    def self.hash_password(password)
+      BCrypt::Password.create(password, :cost => Nelumba::BCRYPT_ROUNDS)
+    end
+
+    # Determine if the given password matches the account.
+    def authenticated?(password)
+      BCrypt::Password.new(hashed_password) == password
+    end
+
+    # :nodoc: Do not allow the password to be set at any cost.
+    def password=(value)
+    end
+
+    # Cleanup any unexpected keys.
+    def self.sanitize_params(params)
+      # Convert Symbols to Strings
+      params.keys.each do |k|
+        if k.is_a? Symbol
+          params[k.to_s] = params[k]
+          params.delete k
+        end
+      end
+
+      # Delete unknown keys
+      params.keys.each do |k|
+        unless self.keys.keys.map.include?(k)
+          params.delete(k)
+        end
+      end
+
+      # Delete immutable fields
+      params.delete("id")
+      params.delete("_id")
+
+      # Convert to symbols
+      params.keys.each do |k|
+        params[k.intern] = params[k]
+        params.delete k
+      end
+
+      params
+    end
+
+    # Create a new Authorization.
+    def initialize(*args)
+      params = {}
+      params = args.shift if args.length > 0
+
+      params["password"] = params[:password] if params[:password]
+      params.delete :password
+
+      params["hashed_password"] = Authorization.hash_password(params["password"])
+      params.delete "password"
+
+      params = Authorization.sanitize_params(params)
+
+      person = Nelumba::Person.new_local(params[:username],
+                                         params[:domain],
+                                         params[:port],
+                                         params[:ssl])
+      person.save
+      params[:person_id] = person.id
+
+      keypair = Nelumba::Crypto.new_keypair
+      params[:private_key] = keypair.private_key
+
+      identity = Nelumba::Identity.new_local(person,
+                                             params[:username],
+                                             params[:domain],
+                                             params[:port],
+                                             params[:ssl],
+                                             keypair.public_key)
+      identity.save
+      params[:identity_id] = identity.id
+
+      params[:person] = person
+      params[:identity] = identity
+
+      super params, *args
+    end
+  end
+end

data/lib/nelumba-mongodb/avatar.rb

@@ -0,0 +1,130 @@
+module Nelumba
+  class Avatar
+    require 'RMagick'
+
+    include MongoMapper::Document
+
+    # The avatar belongs to a particular Person
+    key :author_id, ObjectId
+    belongs_to :author, :class_name => 'Nelumba::Person'
+
+    # The array of sizes this avatar has stored.
+    key :sizes, Array, :default => []
+
+    # The content type for the image.
+    key :content_type
+
+    # Log modification.
+    timestamps!
+
+    # Create a new Avatar from the given blob
+    def self.from_blob!(author, blob, options = {})
+      avatar = Avatar.new(:author_id => author.id,
+                          :sizes     => options[:sizes])
+
+      image = Magick::ImageList.new
+      image.from_blob(blob)
+
+      # Store the content_type
+      avatar.content_type = image.mime_type
+
+      # Resize the images to fit the given sizes (crop to the aspect ratio)
+      # And store them in the storage backend.
+      options[:sizes] ||= []
+      images = options[:sizes].each do |size|
+        width  = size[0]
+        height = size[1]
+
+        # Resize to maintain aspect ratio
+        resized = image.resize_to_fill(width, height)
+        self.storage_write "avatar_#{avatar.id}_#{width}x#{height}", resized.to_blob
+      end
+
+      # Find old avatar
+      old = Avatar.first(:author_id => author.id)
+      if old
+        old.destroy
+      end
+
+      avatar.save
+      avatar
+    end
+
+    # Create a new Avatar from the given url
+    def self.from_url!(author, url, options = {})
+      # Pull image down
+      response = self.pull_url(url, options[:content_type])
+      return nil unless response.kind_of? Net::HTTPSuccess
+
+      self.from_blob!(author, response.body, options)
+    end
+
+    def url(size = nil)
+      return nil if self.sizes.empty?
+
+      size = self.sizes.first unless size
+      return nil unless self.sizes.include? size
+
+      "/avatars/#{self.id}/#{size[0]}x#{size[1]}"
+    end
+
+    # Retrieve the avatar image as a byte string.
+    def read(size = nil)
+      return nil if self.sizes.empty?
+
+      size = self.sizes.first unless size
+      return nil unless self.sizes.include? size
+
+      Avatar.storage_read "avatar_#{self.id}_#{size[0]}x#{size[1]}"
+    end
+
+    # Yield a base64 string encoded with the content type
+    def read_base64(size = nil)
+      data = self.read(size)
+      return nil unless data
+
+      "data:#{self.content_type};base64,#{Base64.encode64(data)}"
+    end
+
+    private
+
+    # :nodoc:
+    def self.pull_url(url, content_type = nil, limit = 10)
+      uri = URI(url)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request.content_type = content_type if content_type
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      response = http.request(request)
+
+      if response.is_a?(Net::HTTPRedirection) && limit > 0
+        location = response['location']
+        self.pull_url(location, content_type, limit - 1)
+      else
+        response
+      end
+    end
+
+    # :nodoc:
+    def self.storage
+      @@grid ||= Mongo::Grid.new(MongoMapper.database)
+    end
+
+    # TODO: Add ability to read from filesystem
+    # :nodoc:
+    def self.storage_read(id)
+      self.storage.get(id).read
+    end
+
+    # TODO: Add ability to store on filesystem
+    # :nodoc:
+    def self.storage_write(id, data)
+      self.storage.put(data, :_id => id)
+    end
+  end
+end

data/lib/nelumba-mongodb/comment.rb

@@ -0,0 +1,7 @@
+module Nelumba
+  class Comment
+    include Nelumba::EmbeddedObject
+
+    key :in_reply_to, :default => []
+  end
+end

data/lib/nelumba-mongodb/embedded_object.rb

@@ -0,0 +1,43 @@
+module Nelumba
+  module EmbeddedObject
+    def self.included(klass)
+      klass.class_eval do
+        include MongoMapper::EmbeddedDocument
+
+        def initialize(*args, &blk)
+          init(*args, &blk)
+
+          super(*args, &blk)
+        end
+
+        belongs_to :author, :class_name => 'Nelumba::Person'
+        key :author_id, ObjectId
+
+        key :title
+        key :uid
+        key :url
+        key :display_name
+        key :summary
+        key :content
+        key :image
+
+        # Automated Timestamps
+        key :published, Time
+        key :updated,   Time
+        before_save :update_timestamps
+
+        def update_timestamps
+          now = Time.now.utc
+          self[:published] ||= now if !persisted?
+          self[:updated]     = now
+        end
+
+        def self.find_by_id(id)
+          Nelumba::Activity.object_by_id_and_type(id, self)
+        end
+
+        embedded_in :'Nelumba::Activity'
+      end
+    end
+  end
+end

data/lib/nelumba-mongodb/feed.rb

@@ -0,0 +1,268 @@
+module Nelumba
+  class Feed
+    def initialize(*args); super(*args); end
+
+    include MongoMapper::Document
+
+    # Ensure writes happen
+    safe
+
+    # A unique identifier for this Feed.
+    key :uid
+
+    # A URL for this Feed that can be used to retrieve a representation.
+    key :url
+
+    # Feeds generally belong to a person.
+    key :person_id, ObjectId
+    belongs_to :person, :class_name => 'Nelumba::Person'
+
+    remove_method :categories
+    key :categories,   :default => []
+
+    # The type of rights one has to this feed generally for human display.
+    key :rights
+
+    # The title of this feed.
+    key :title
+
+    # The representation of the title. (e.g. "html")
+    key :title_type
+
+    # The subtitle of the feed.
+    key :subtitle
+
+    # The representation of the subtitle. (e.g. "html")
+    key :subtitle_type
+
+    # An array of Persons that contributed to this Feed.
+    key  :contributors_ids, Array, :default => []
+    remove_method :contributors
+    many :contributors,     :class_name => 'Nelumba::Person', :in => :contributors_ids
+
+    # An Array of Persons that create the content in this Feed.
+    key  :authors_ids,  Array, :default => []
+    remove_method :authors
+    many :authors,      :class_name => 'Nelumba::Person', :in => :authors_ids
+
+    # An Array of Activities that are contained in this Feed.
+    key :items_ids,  Array
+    many :items,     :class_name => 'Nelumba::Activity',
+                     :in         => :items_ids,
+                     :order      => :published.desc
+
+    # A Hash containing information about the entity that is generating content
+    # for this Feed when it isn't a person.
+    key :generator
+
+    # Feeds may have an icon to represent them.
+    #key :icon, :class_name => 'Image'
+
+    # Feeds may have an image they use as a logo.
+    #key :logo, :class_name => 'Image'
+
+    # TODO: Normalize the first 100 or so activities. I dunno.
+    key :normalized
+
+    # Automated Timestamps
+    key :published, Time
+    key :updated,   Time
+    before_save :update_timestamps
+
+    def update_timestamps
+      now = Time.now.utc
+      self[:published] ||= now if !persisted?
+      self[:updated]     = now
+    end
+
+    # The external feeds being aggregated.
+    key  :following_ids, Array
+    many :following,     :in => :following_ids, :class_name => 'Nelumba::Feed'
+
+    # Who is aggregating this feed.
+    key  :followers_ids, Array
+    many :followers,     :in => :followers_ids, :class_name => 'Nelumba::Feed'
+
+    # Subscription status.
+    # Since subscriptions are done by the server, we only need to share one
+    # secret/token pair for all users that follow this feed on the server.
+    # This is done at the Feed level since people may want to follow your
+    # "timeline", or your "favorites". Or People who use Nelumba will ignore
+    # the Person aggregate class and go with their own thing.
+    key :subscription_secret
+    key :verification_token
+
+    # Create a new Feed if the given Feed is not found by its id.
+    def self.find_or_create_by_uid!(arg, *args)
+      if arg.is_a? Nelumba::Feed
+        uid = arg.uid
+      else
+        uid = arg[:uid]
+      end
+
+      feed = self.first(:uid => uid)
+      return feed if feed
+
+      begin
+        feed = create!(arg, *args)
+      rescue
+        feed = self.first(:uid => uid) or raise
+      end
+
+      feed
+    end
+
+    # Create a new Feed from a Hash of values or a Nelumba::Feed.
+    def initialize(*args)
+      hash = {}
+      if args.length > 0
+        hash = args.shift
+      end
+
+      if hash.is_a? Nelumba::Feed
+        hash = hash.to_hash
+      end
+
+      if hash[:authors].is_a? Array
+        hash[:authors].map! do |author|
+          if author.is_a? Hash
+            author = Nelumba::Person.find_or_create_by_uid!(author)
+          end
+          author
+        end
+      end
+
+      if hash[:contributors].is_a? Array
+        hash[:contributors].map! do |contributor|
+          if contributor.is_a? Hash
+            contributor = Nelumba::Person.find_or_create_by_uid!(contributor)
+          end
+          contributor
+        end
+      end
+
+      if hash[:items].is_a? Array
+        hash[:items].map! do |item|
+          if item.is_a? Hash
+            item = Nelumba::Activity.find_or_create_by_uid!(item)
+          end
+          item
+        end
+      end
+
+      super hash, *args
+    end
+
+    # Discover a feed by the given feed location or account.
+    def self.discover!(feed_identifier)
+      feed = Feed.first(:url => feed_identifier)
+      return feed if feed
+
+      feed = Nelumba::Discover.feed(feed_identifier)
+      return false unless feed
+
+      existing_feed = Feed.first(:uid => feed.uid)
+      return existing_feed if existing_feed
+
+      self.create!(feed)
+    end
+
+    # Merges the information in the given feed with this one.
+    def merge!(feed)
+      # Merge metadata
+      meta_data = feed.to_hash
+      meta_data.delete :items
+      meta_data.delete :authors
+      meta_data.delete :contributors
+      meta_data.delete :uid
+      self.update_attributes!(meta_data)
+
+      # Merge new/updated authors
+      feed.authors.each do |author|
+      end
+
+      # Merge new/updated contributors
+      feed.contributors.each do |author|
+      end
+
+      # Merge new/updated activities
+      feed.items.each do |activity|
+      end
+    end
+
+    # Retrieve the feed's activities with the most recent first.
+    def ordered
+      Nelumba::Activity.where(:id => self.items_ids).order(:published => :desc)
+    end
+
+    # Follow the given feed. When a new post is placed in this feed, it
+    # will be copied into ours.
+    def follow!(feed)
+      self.following << feed
+      self.save
+
+      # Subscribe to that feed on this server if not already.
+    end
+
+    # Unfollow the given feed. Our feed will no longer receive new posts from
+    # the given feed.
+    def unfollow!(feed)
+      self.following_ids.delete(feed.id)
+      self.save
+    end
+
+    # Denotes that the given feed will contain your posts.
+    def followed_by!(feed)
+      self.followers << feed
+      self.save
+    end
+
+    # Denotes that the given feed will not contain your posts from now on.
+    def unfollowed_by!(feed)
+      self.followers_ids.delete(feed.id)
+      self.save
+    end
+
+    # Add to the feed and tell subscribers.
+    def post!(activity)
+      if activity.is_a?(Hash)
+        # Create a new activity
+        activity = Nelumba::Activity.create!(activity)
+      end
+
+      activity.feed_id = self.id
+      activity.save
+
+      self.items << activity
+      self.save
+
+      publish(activity)
+
+      activity
+    end
+
+    # Remove the activity from the feed.
+    def delete!(activity)
+      self.items_ids.delete(activity.id)
+      self.save
+    end
+
+    # Add a copy to our feed and tell subscribers.
+    def repost!(activity)
+      self.items << activity
+      self.save
+
+      publish(activity)
+    end
+
+    # Publish an activity that is within our feed.
+    def publish(activity)
+      # Push to direct followers
+      self.followers.each do |feed|
+        feed.repost! activity
+      end
+
+      # TODO: PuSH Hubs
+    end
+  end
+end