nelumba-mongodb 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - rbx
+services:
+  - mongodb
+script: "bundle exec rake test"

data/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nelumba-mongodb.gemspec
+gemspec
+
+gem "redfinger", :git => "git://github.com/hotsh/redfinger.git"
+gem 'nelumba', :git => 'git://github.com/hotsh/nelumba.git'
+
+group :test do
+  gem "rake"              # rakefile
+  gem "minitest", "4.7.0" # test framework (specified here for prior rubies)
+  gem "ansi"              # minitest colors
+  gem "turn"              # minitest output
+  gem "mocha"             # stubs
+  gem "debugger"          # debugging
+
+  gem "awesome_print"
+  gem "rack-test"
+end
+
+platforms :rbx do
+  gem "json"
+  gem "racc"
+  gem "rubysl"
+end

data/LICENSE

@@ -0,0 +1,127 @@
+nelumba-mongodb
+
+To the extent possible under law, the author(s) have dedicated all 
+copyright and related and neighboring rights to this software to the 
+public domain worldwide. This software is distributed without any warranty.
+
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

data/README.md

@@ -0,0 +1,29 @@
+# Nelumba::Mongodb
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nelumba-mongodb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nelumba-mongodb
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,60 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+namespace :test do
+  desc "Run all tests (rake test will do this be default)"
+  task :all do
+    Rake::TestTask.new("all") do |t|
+      t.pattern = "spec/**/*_spec.rb"
+    end
+    task("all").execute
+  end
+
+  Dir.foreach("spec") do |dirname|
+    if File.directory?(File.join("spec", dirname))
+      desc "Run #{dirname} tests"
+      task dirname do
+        test_task = Rake::TestTask.new("#{dirname}tests") do |t|
+          t.test_files = Dir.glob(File.join("spec", dirname, "**", "*_spec.rb"))
+        end
+        task("#{dirname}tests").execute
+      end
+    end
+  end
+
+  desc "Run single model"
+  task :model, :file do |task, args|
+    test_task = Rake::TestTask.new("unittests") do |t|
+      if args.file
+        file = "spec/#{args.file}_spec.rb"
+        t.pattern = file
+        puts "Testing #{file}"
+      else
+        t.pattern = "spec/*_spec.rb"
+      end
+    end
+    task("unittests").execute
+  end
+
+  desc "Run single file"
+  task :file, :file do |task, args|
+    test_task = Rake::TestTask.new("unittests") do |t|
+      if args.file
+        file = args.file
+        unless file.start_with? "spec/"
+          file = "spec/#{args.file}"
+        end
+        t.pattern = file
+        puts "Testing #{file}"
+      else
+        t.pattern = "spec/**/*_spec.rb"
+      end
+    end
+    task("unittests").execute
+  end
+end

data/lib/nelumba-mongodb.rb

@@ -0,0 +1,35 @@
+require 'nelumba'
+require 'mongo_mapper'
+
+MongoMapper.setup({
+  'default' => {
+    'database' => ENV['MONGOHQ_DATABASE'] ||
+                  ENV['MONGODB_DATABASE'] ||
+                  'nelumba-mongodb',
+    'uri'      => ENV['MONGOHQ_URL'] ||
+                  ENV['MONGODB_URI'] ||
+                  ENV['MONGOLAB_URI']
+  }
+}, 'default')
+
+require "nelumba-mongodb/embedded_object"
+require "nelumba-mongodb/object"
+
+require "nelumba-mongodb/identity"
+require "nelumba-mongodb/activity"
+require "nelumba-mongodb/feed"
+require "nelumba-mongodb/person"
+require "nelumba-mongodb/authorization"
+require "nelumba-mongodb/avatar"
+
+require "nelumba-mongodb/note"
+require "nelumba-mongodb/article"
+require "nelumba-mongodb/comment"
+require "nelumba-mongodb/image"
+
+module Nelumba
+  BCRYPT_ROUNDS = 13
+
+  def create_person
+  end
+end

data/lib/nelumba-mongodb/activity.rb

@@ -0,0 +1,316 @@
+module Nelumba
+  class Activity
+    include Nelumba::Object
+
+    # All Activities originate from one particular Feed.
+    key :feed_id, ObjectId
+    belongs_to :feed, :class_name => 'Nelumba::Feed'
+
+    # Determines what type of object this Activity represents. Standard types
+    # include:
+    #   :article, :audio, :bookmark, :comment, :file, :folder, :group,
+    #   :list, :note, :person, :photo, :"photo-album", :place, :playlist,
+    #   :product, :review, :service, :status, :video
+    key :type
+
+    # Determines the action this Activity represents. Standard types include:
+    #   :favorite, :follow, :like, :"make-friend", :join, :play,
+    #   :post, :save, :share, :tag, :update
+    key :verb
+
+    # Determines what is acting.
+    key :actor_id, ObjectId
+    key :actor_type, String
+
+    # Determines what the action is acting upon.
+    key :target_id, ObjectId
+    key :target_type, String
+
+    # Can attach an external object to this Activity.
+    key :external_object_id, ObjectId
+    key :external_object_type, String
+
+    # Optionally, an object can be embedded inside an Activity.
+    one :embedded_object, :class_name => "Nelumba::Comment", :polymorphic => true
+
+    # The title of the Activity.
+    key :title
+
+    # Contains the source of this Activity if it is a repost or otherwise copied
+    # from another Feed.
+    key :source, :class_name => 'Nelumba::Feed'
+
+    # Contains the Activity this Activity is a response of.
+    key :in_reply_to_ids, Array
+    remove_method :in_reply_to
+    many :in_reply_to, :in => :in_reply_to_ids, :class_name => 'Nelumba::Activity'
+
+    # Contains the Activities that are replies to this one
+    key :replies_ids, Array
+    remove_method :replies
+    many :replies, :in => :replies_ids, :class_name => 'Nelumba::Activity'
+
+    # Contains the Persons this Activity mentions.
+    key :mentions_ids, Array
+    remove_method :mentions
+    many :mentions, :in => :mentions_ids, :class_name => 'Nelumba::Person'
+
+    # Contains the Persons that have shared this activity
+    key :shares_ids, Array
+    remove_method :shares
+    many :shares, :in => :shares_ids, :class_name => 'Nelumba::Person'
+
+    # Contains the Persons that have liked this activity
+    key :likes_ids, Array
+    remove_method :likes
+    many :likes, :in => :likes_ids, :class_name => 'Nelumba::Person'
+
+    # Hash containing various interaction metadata
+    key :interactions
+
+    # Ensure that url and uid for the activity are set
+    before_create :ensure_uid_and_url
+
+    # Scrape content for mentions
+    before_create :scrape_mentions
+
+    private
+
+    # Ensure uid and url are established. If they don't exist, just use urls
+    # that point to us for the sake of uniqueness.
+    def ensure_uid_and_url
+      unless self.uid && self.url
+        self.uid = "/activities/#{self.id}"
+        self.url = "/activities/#{self.id}"
+      end
+    end
+
+    # Scrape content for username mentions.
+    def scrape_mentions
+      return if self.object.nil?
+      return unless !self.object.is_a?(Nelumba::Person) &&
+                    self.object.respond_to?(:mentions)
+      authors = self.object.mentions do |username, domain|
+        i = Identity.first(:username => /^#{Regexp.escape(username)}$/i)
+        i.person if i
+      end
+      authors ||= []
+      self.mentions_ids = authors.compact.map(&:id)
+    end
+
+    public
+
+    def mentions?(author)
+      if author.is_a? Nelumba::Identity
+        author = author.person
+      end
+
+      self.mentions_ids.include? author.id
+    end
+
+    def self.article_by_id(id)
+      self.object_by_id_and_type(id, Nelumba::Article)
+    end
+
+    def self.note_by_id(id)
+      self.object_by_id_and_type(id, Nelumba::Note)
+    end
+
+    def self.object_by_id(id)
+      oid = id
+      if id.is_a? String
+        oid = BSON::ObjectId.from_string(id)
+      end
+
+      activity = Nelumba::Activity.first("embedded_object._id" => oid)
+      activity.object if activity
+    end
+
+    def self.object_by_id_and_type(id, type)
+      obj = self.object_by_id(id)
+      return obj if obj.is_a? type
+      nil
+    end
+
+    # Intern, for consistency, standard object types.
+    def type=(type)
+      if STANDARD_TYPES.map(&:to_s).include? type
+        type = type.intern
+      end
+
+      super type
+    end
+
+    # Set the actor.
+    def actor=(obj)
+      if obj.nil?
+        self.actor_id = nil
+        self.actor_type = nil
+        return
+      end
+
+      @actor = obj
+
+      self.actor_id   = obj.id
+      self.actor_type = obj.class.to_s
+      self.actor_type = self.actor_type[9..-1] if self.actor_type.start_with? "Nelumba::"
+    end
+
+    # Get the actor.
+    def actor
+      return @actor if @actor
+
+      return nil if self.actor_type && !Nelumba.const_defined?(self.actor_type)
+      klass = Nelumba.const_get(self.actor_type) if self.actor_type
+      @actor = klass.first(:id => self.actor_id) if klass && self.actor_id
+    end
+
+    # Set the object.
+    def object=(obj)
+      if obj.nil?
+        self.external_object_id = nil
+        self.external_object_type = nil
+      elsif obj.class.respond_to?(:embeddable?) && obj.class.embeddable?
+        self.embedded_object = obj
+        self.external_object_id = nil
+        self.external_object_type = nil
+      else
+        self.embedded_object = nil
+        self.external_object_id   = obj.id
+        self.external_object_type = obj.class.to_s
+        if self.external_object_type.start_with? "Nelumba::"
+          self.external_object_type = self.external_object_type[7..-1]
+        end
+      end
+      @object = obj
+    end
+
+    # Get the object.
+    def object
+      return @object if @object
+
+      return @object = self.embedded_object if self.embedded_object
+      return @object = self unless self.external_object_type
+
+      return nil if self.external_object_type && !Nelumba.const_defined?(self.external_object_type)
+      klass = Nelumba.const_get(self.external_object_type) if self.external_object_type
+      @object = klass.find_by_id(self.external_object_id) if klass && self.external_object_id
+    end
+
+    # Create a new Activity if the given Activity is not found by its id.
+    def self.find_or_create_by_uid!(arg, *args)
+      if arg.is_a? Nelumba::Activity
+        uid = arg.uid
+      else
+        uid = arg[:uid]
+
+        if arg[:author]
+          arg[:author] = Person.find_or_create_by_uid!(arg[:author])
+        end
+      end
+
+      activity = self.first(:uid => uid)
+      return activity if activity
+
+      begin
+        if arg.is_a? Nelumba::Activity
+          arg.save
+        else
+          activity = create!(arg, *args)
+        end
+      rescue
+        activity = self.first(:uid => uid) or raise
+      end
+
+      activity
+    end
+
+    # Create a new Activity from a Hash of values or a Nelumba::Activity.
+    def self.create!(*args)
+      hash = {}
+      if args.length > 0
+        hash = args.shift
+      end
+
+      if hash.is_a? Nelumba::Activity
+        hash = hash.to_hash
+
+        hash.delete :author
+        hash.delete :in_reply_to
+      end
+
+      super hash, *args
+    end
+
+    # Create a new Activity from a Hash of values or a Nelumba::Activity.
+    def self.create(*args)
+      self.create! *args
+    end
+
+    # Discover a feed by the given activity location.
+    def self.discover!(activity_identifier)
+      activity = Nelumba::Activity.first(:url => activity_identifier)
+      return activity if activity
+
+      activity = Nelumba::Discover.activity(activity_identifier)
+      return false unless activity
+
+      existing = Activity.first(:uid => activity.uid)
+      return existing if existing
+
+      self.create!(activity)
+    end
+
+    def self.find_from_notification(notification)
+      Nelumba::Activity.first(:uid => notification.activity.uid)
+    end
+
+    def self.create_from_notification!(notification)
+      # We need to verify the payload
+      identity = Nelumba::Identity.discover!(notification.account)
+      if notification.verified? identity.return_or_discover_public_key
+        # Then add it to our feed in the appropriate place
+        identity.discover_person!
+        internal_activity = Nelumba::Activity.find_from_notification(notification)
+
+        # If it already exists, update it
+        if internal_activity
+          internal_activity.update_from_notification(notification, true)
+        else
+          internal_activity = Nelumba::Activity.create!(notification.activity)
+          internal_author = Nelumba::Person.find_or_create_by_uid!(
+                              notification.activity.actor.uid)
+
+          internal_activity.actor = internal_author
+          internal_activity.save
+          internal_activity
+        end
+      else
+        nil
+      end
+    end
+
+    def update_from_notification(notification, force = false)
+      # Do not allow another actor to change an existing activity
+      if self.actor && self.actor.url != notification.activity.actor.url
+        return nil
+      end
+
+      # We need to verify the payload
+      identity = Nelumba::Identity.discover!(notification.account)
+      if force or notification.verified?(identity.return_or_discover_public_key)
+        # Then add it to our feed in the appropriate place
+        identity.discover_person!
+
+        attributes = notification.activity.to_hash
+        attributes.delete :uid
+
+        self.update_attributes!(attributes)
+
+        self
+      else
+        nil
+      end
+    end
+  end
+end