live-activity 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe8df6a8d020963d1afb51c4f68a711008cf404a
+  data.tar.gz: 6c9215b22a933a080d89f809e6278acda4d47da5
+SHA512:
+  metadata.gz: 85250962c209b1a30435eb3feedc56b449db92f559b514aec2d000038ed31e95475a5520ef924f59f5351592d42910b8b872d0cf70223cf469e25e799d719403
+  data.tar.gz: b3a405bce7b9146729f35be6c59c78a7c66c6b5b8fe9719517aafb45b4eb3b6b19646e7c82e3295f089f6c167474da9aa8096efa992920ecbe36551edfc32dbc

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm:
+  - 1.9.2

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development, :test do
+  gem 'sqlite3', '~> 1.3.7'
+end
+
+# Specify your gem's dependencies in live_activity.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Andreas Saebjoernsen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# LiveActivity
+
+LiveActivity is a simple Ruby activity stream gem for use with the ActiveRecord ODM framework.
+
+This gem is inspired by Streama by Christopher Pappas.
+
+[![Build Status](https://secure.travis-ci.org/digitalplaywright/live-activity.png)](http://travis-ci.org/digitalplaywright/live-activity) [![Dependency Status](https://gemnasium.com/digitalplaywright/live-activity.png)](https://gemnasium.com/digitalplaywright/live-activity) [![Code Climate](https://codeclimate.com/github/digitalplaywright/live-activity.png)](https://codeclimate.com/github/digitalplaywright/live-activity)
+
+
+## Install
+
+    gem install live_activity
+
+## Usage
+
+### Create migration for activities and migrate the database (in your Rails project):
+
+```ruby
+rails g public_activity:migration
+rake db:migrate
+```
+
+A join table must also be created for all receivers. E.g if users are receivers:
+
+``` ruby
+create_table :activities_users, :id => false do |t|
+  t.references :activity, :user
+end
+
+add_index :activities_users, [:activity_id, :user_id ]
+```
+
+### Define Activities
+
+Create an Activity model and define the activities and the fields you would like to cache within the activity.
+
+An activity consists of an actor, a verb, an act_object, and a target.
+
+``` ruby
+class Activity < ActiveRecord::Base
+  include LiveActivity::Activity
+
+  has_and_belongs_to_many :users
+
+  activity :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+  end
+end
+```
+
+The activity verb is implied from the activity name, in the above example the verb is :new_enquiry
+
+The act_object may be the entity performing the activity, or the entity on which the activity was performed.
+e.g John(actor) shared a video(act_object)
+
+The target is the act_object that the verb is enacted on.
+e.g. Geraldine(actor) posted a photo(act_object) to her album(target)
+
+This is based on the Activity Streams 1.0 specification (http://activitystrea.ms)
+
+### Setup Actors
+
+Include the Actor module in a class and override the default followers method.
+
+``` ruby
+class User < ActiveRecord::Base
+  include LiveActivity::Actor
+
+  has_and_belongs_to_many :activities
+
+end
+```
+
+
+
+### Publishing Activity
+
+In your controller or background worker:
+
+``` ruby
+current_user.publish_activity(:new_enquiry, :act_object => @enquiry, :target => @listing)
+```
+  
+This will publish the activity to the mongoid act_objects returned by the #followers method in the Actor.
+
+To send your activity to different receievers, pass in an additional :receivers parameter.
+
+``` ruby
+current_user.publish_activity(:new_enquiry, :act_object => @enquiry, :target => @listing, :receivers => :friends) # calls friends method
+```
+
+``` ruby
+current_user.publish_activity(:new_enquiry, :act_object => @enquiry, :target => @listing, :receivers => current_user.find(:all, :conditions => {:group_id => mygroup}))
+```
+
+## Retrieving Activity
+
+To retrieve all activity for an actor
+
+``` ruby
+current_user.activity_stream
+```
+  
+To retrieve and filter to a particular activity type
+
+``` ruby
+current_user.activity_stream(:verb => 'new_enquiry')
+```
+
+#### Options
+
+Additional options can be required:
+
+``` ruby
+class Activity < ActiveRecord::Base
+  include LiveActivity::Activity
+
+  has_and_belongs_to_many :users
+
+  activity :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :country
+    option       :city
+  end
+end
+```
+
+The option fields are stored using the ActiveRecord 'store' feature.
+
+
+#### Bond type
+
+A verb can have one bond type. This bond type can be used to classify and quickly retrieve
+activity feed items that belong to a particular aggregate feed, like e.g the global feed.
+
+``` ruby
+class Activity < ActiveRecord::Base
+  include LiveActivity::Activity
+
+  has_and_belongs_to_many :users
+
+  activity :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    bond_type    :global
+  end
+end
+```

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'yard'
+require 'yard/rake/yardoc_task'
+require 'rake/testtask'
+
+task :default => :test
+
+desc 'Generate documentation for the live_stream plugin.'
+YARD::Rake::YardocTask.new do |doc|
+  doc.files = ['lib/**/*.rb']
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb', 'test/unit/*_test.rb']
+end
+

data/lib/generators/live_stream/activity/activity_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/live_stream'
+require 'rails/generators/active_record'
+
+module LiveActivity
+  module Generators
+    # Activity generator that creates activity model file from template
+    class ActivityGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'activity'
+      # Create model in project's folder
+      def generate_files
+        copy_file 'activity.rb', "app/models/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/live_stream/activity/templates/activity.rb

@@ -0,0 +1,5 @@
+# Activity model for customisation & custom methods
+class Activity < ActiveRecord::Base
+  include LiveActivity::Activity
+
+end

data/lib/generators/live_stream/migration/migration_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/live_stream'
+require 'rails/generators/active_record'
+
+module LiveStream
+  module Generators
+    # Migration generator that creates migration file from template
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'create_activities'
+      # Create migration in project's folder
+      def generate_files
+        migration_template 'migration.rb', "db/migrate/#{name}"
+      end
+    end
+  end
+end

data/lib/generators/live_stream/migration/templates/migration.rb

@@ -0,0 +1,33 @@
+# Migration responsible for creating a table with activities
+class CreateActivities < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :activities do |t|
+      t.belongs_to :actor,      :polymorphic => true
+      t.belongs_to :act_object, :polymorphic => true
+      t.belongs_to :act_target, :polymorphic => true
+
+      t.string  :verb
+      t.string  :description
+      t.string  :options
+      t.string  :bond_type
+
+      t.timestamps
+    end
+
+    create_table :activities_users, :id => false do |t|
+      t.references :activity, :user
+    end
+
+    add_index :activities_users, [:activity_id, :user_id ]
+
+    add_index :activities, [:verb]
+    add_index :activities, [:actor_id, :actor_type]
+    add_index :activities, [:act_object_id, :act_object_type]
+    add_index :activities, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :activities
+  end
+end

data/lib/generators/live_stream.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/named_base'
+
+module LiveActivity
+  # A generator module with Activity table schema.
+  module Generators
+    # A base module 
+    module Base
+      # Get path for migration template
+      def source_root
+        @_live_activity_source_root ||= File.expand_path(File.join('../live_activity', generator_name, 'templates'), __FILE__)
+      end
+    end
+  end
+end

data/lib/live_activity/activity.rb

@@ -0,0 +1,183 @@
+module LiveActivity
+  module Activity
+    extend ActiveSupport::Concern
+
+    included do
+
+      store :options
+
+      belongs_to :actor,      :polymorphic => true
+      belongs_to :act_object, :polymorphic => true
+      belongs_to :act_target, :polymorphic => true
+
+      validates_presence_of :actor_id, :actor_type, :verb
+    end
+
+    module ClassMethods
+
+      # Defines a new Activity2 type and registers a definition
+      #
+      # @param [ String ] name The name of the activity
+      #
+      # @example Define a new activity
+      #   activity(:enquiry) do
+      #     actor :user, :cache => [:full_name]
+      #     act_object :enquiry, :cache => [:subject]
+      #     act_target :listing, :cache => [:title]
+      #   end
+      #
+      # @return [Definition] Returns the registered definition
+      def activity(name, &block)
+        definition = LiveActivity::DefinitionDSL.new(name)
+        definition.instance_eval(&block)
+        LiveActivity::Definition.register(definition)
+      end
+
+      # Publishes an activity using an activity name and data
+      #
+      # @param [ String ] verb The verb of the activity
+      # @param [ Hash ] data The data to initialize the activity with.
+      #
+      # @return [LiveActivity::Activity2] An Activity instance with data
+      def publish(verb, data)
+        new.publish({:verb => verb}.merge(data))
+      end
+
+    end
+
+
+
+    # Publishes the activity to the receivers
+    #
+    # @param [ Hash ] options The options to publish with.
+    #
+    def publish(data = {})
+      assign_properties(data)
+
+      self
+    end
+
+
+    def refresh_data
+      save(:validate => false)
+    end
+
+    protected
+
+    def assign_properties(data = {})
+
+      self.verb      = data.delete(:verb)
+
+      cur_receivers  = data.delete(:receivers)
+
+
+
+      [:actor, :act_object, :act_target].each do |type|
+
+        cur_object = data[type]
+
+        unless cur_object
+          if definition.send(type.to_sym)
+            raise verb.to_json
+            #raise LiveActivity::InvalidData.new(type)
+          else
+            next
+
+          end
+        end
+
+        class_sym = cur_object.class.name.to_sym
+
+        raise LiveActivity::InvalidData.new(class_sym) unless definition.send(type) == class_sym
+
+        case type
+          when :actor
+            self.actor = cur_object
+          when :act_object
+            self.act_object = cur_object
+          when :act_target
+            self.act_target = cur_object
+          else
+            raise "unknown type"
+        end
+
+        data.delete(type)
+
+      end
+
+      [:grouped_actor].each do |group|
+
+
+        grp_object = data[group]
+
+        if grp_object == nil
+          if definition.send(group.to_sym)
+            raise verb.to_json
+            #raise LiveActivity::InvalidData.new(group)
+          else
+            next
+
+          end
+        end
+
+        grp_object.each do |cur_obj|
+          raise LiveActivity::InvalidData.new(class_sym) unless definition.send(group) == cur_obj.class.name.to_sym
+
+          self.grouped_actors << cur_obj
+
+        end
+
+        data.delete(group)
+
+      end
+
+      cur_bond_type = definition.send(:bond_type)
+
+      if cur_bond_type
+        write_attribute( :bond_type, cur_bond_type.to_s )
+      end
+
+      def_options = definition.send(:options)
+      def_options.each do |cur_option|
+        cur_object = data[cur_option]
+
+        if cur_object
+
+          if cur_option == :description
+            self.description = cur_object
+          else
+            options[cur_option] = cur_object
+          end
+          data.delete(cur_option)
+
+        else
+          #all options defined must be used
+          raise Streama::InvalidData.new(cur_object[0])
+        end
+      end
+
+      if data.size > 0
+        raise "unexpected arguments: " + data.to_json
+      end
+
+
+
+      self.save
+
+
+      if cur_receivers
+        cur_receivers.each do |sp|
+          send(sp.class.to_s.tableize) << sp
+        end
+      end
+
+
+    end
+
+    def definition
+      @definition ||= LiveActivity::Definition.find(verb)
+    end
+
+
+  end
+end

data/lib/live_activity/actor.rb

@@ -0,0 +1,53 @@
+module LiveActivity
+  
+  module Actor
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :activity_klass
+
+      has_many :created_activities,     :class_name => "Activity", :as => :actor
+      has_many :act_object_activities,  :class_name => "Activity", :as => :act_object
+      has_many :act_target_activities,  :class_name => "Activity", :as => :act_target
+
+
+    end
+
+    module ClassMethods
+
+      def activity_class(klass)
+        self.activity_klass = klass.to_s
+      end
+
+    end
+
+
+    # Publishes the activity to the receivers
+    #
+    # @param [ Hash ] options The options to publish with.
+    #
+    # @example publish an activity with a act_object and act_target
+    #   current_user.publish_activity(:enquiry, :act_object => @enquiry, :act_target => @listing)
+    #
+    def publish_activity(name, options={})
+      options[:receivers] = self.send(options[:receivers]) if options[:receivers].is_a?(Symbol)
+      activity = activity_class.publish(name, {:actor => self}.merge(options))
+    end
+
+    def activity_class
+      @activity_klass ||= activity_klass ? activity_klass.classify.constantize : ::Activity
+    end
+
+    def activity_stream(options = {})
+
+      if options.empty?
+        activities
+      else
+        activities.where(options)
+      end
+
+    end
+
+  end
+  
+end

data/lib/live_activity/definition.rb

@@ -0,0 +1,48 @@
+module LiveActivity
+
+  class Definition
+
+    attr_reader :name, :actor, :act_object, :act_target, :grouped_actor, :bond_type, :options,  :receivers
+
+    # @param dsl [LiveActivity::DefinitionDSL] A DSL act_object
+    def initialize(definition)
+      @name             = definition[:name]
+      @actor            = definition[:actor]         || nil
+      @act_object       = definition[:act_object]    || nil
+      @act_target       = definition[:act_target]    || nil
+      @grouped_actor    = definition[:grouped_actor] || nil
+      @bond_type        = definition[:bond_type]     || nil
+      @options          = definition[:options]       || []
+    end
+
+    #
+    # Registers a new definition
+    #
+    # @param definition [Definition] The definition to register
+    # @return [Definition] Returns the registered definition
+    def self.register(definition)
+      return false unless definition.is_a? DefinitionDSL
+      definition = new(definition)
+      self.registered << definition
+      return definition || false
+    end
+
+    # List of registered definitions
+    # @return [Array<LiveActivity::Definition>]
+    def self.registered
+      @definitions ||= []
+    end
+
+    def self.find(name)
+      unless definition = registered.find{|definition| definition.name == name.to_sym}
+        raise LiveActivity::InvalidActivity, "Could not find a definition for `#{name}`"
+      else
+        definition
+      end
+    end
+
+
+
+  end
+  
+end

data/lib/live_activity/definition_dsl.rb

@@ -0,0 +1,48 @@
+require 'active_support'
+
+module LiveActivity
+
+  class DefinitionDSL
+
+    attr_reader :attributes
+
+    def initialize(name)
+      @attributes = {
+          :name             => name.to_sym,
+          :actor            => nil,
+          :act_object       => nil,
+          :act_target       => nil,
+          :grouped_actor    => nil,
+          :reverses         => nil,
+          :bond_type        => nil,
+          :options          => nil
+      }
+    end
+
+    def add_option(option)
+      @attributes[:options] ||= []
+
+      @attributes[:options] << option
+    end
+
+    def option(text)
+      add_option( text )
+    end
+
+    delegate :[], :to => :@attributes
+
+    def self.data_methods(*args)
+      args.each do |method|
+        define_method method do |*args|
+
+          @attributes[method] = args[0]
+
+        end
+      end
+    end
+
+    data_methods :actor, :act_object, :act_target, :grouped_actor, :bond_type
+
+  end
+  
+end

data/lib/live_activity/errors.rb

@@ -0,0 +1,44 @@
+module LiveActivity
+  
+  class LiveActivityError < StandardError
+  end
+  
+  class InvalidActivity < LiveActivityError
+  end
+  
+  # This error is raised when an act_object isn't defined
+  # as an actor, act_object or act_target
+  #
+  # Example:
+  #
+  # <tt>InvalidField.new('field_name')</tt>
+  class InvalidData < LiveActivityError
+    attr_reader :message
+
+    def initialize message
+      @message = "Invalid Data: #{message}"
+    end
+
+  end
+  
+  # This error is raised when trying to store a field that doesn't exist
+  #
+  # Example:
+  #
+  # <tt>InvalidField.new('field_name')</tt>
+  class InvalidField < LiveActivityError
+    attr_reader :message
+
+    def initialize message
+      @message = "Invalid Field: #{message}"
+    end
+
+  end
+  
+  class ActivityNotSaved < LiveActivityError
+  end
+  
+  class NoFollowersDefined < LiveActivityError
+  end
+  
+end

data/lib/live_activity/version.rb

@@ -0,0 +1,3 @@
+module LiveActivity
+  VERSION = "0.3.2"
+end

data/lib/live_activity.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+require 'active_support'
+require 'active_support/core_ext/module/delegation.rb'
+require "live_activity/version"
+require "live_activity/actor"
+require "live_activity/activity"
+require "live_activity/definition"
+require "live_activity/definition_dsl"
+require "live_activity/errors"

data/live-activity.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "live_activity/version"
+
+Gem::Specification.new do |s|
+  s.name        = "live-activity"
+  s.version     = LiveActivity::VERSION
+  s.authors     = ["Andreas Saebjoernsen"]
+  s.email       = ["andreas.saebjoernsen@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Activity Streams for rails}
+  s.description = %q{LiveActivity is a simple activity stream gem for use with the Mongoid ODM framework}
+
+  s.rubyforge_project = "live-activity"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'activerecord', '>= 3'
+  s.add_dependency 'activesupport', '>= 3'
+  s.add_dependency 'actionpack', '>= 3'
+end

data/test/migrations/001_create_activities.rb

@@ -0,0 +1,33 @@
+# Migration responsible for creating a table with activities
+class CreateActivities < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :activities do |t|
+      t.belongs_to :actor,      :polymorphic => true
+      t.belongs_to :act_object, :polymorphic => true
+      t.belongs_to :act_target, :polymorphic => true
+
+      t.string  :verb
+      t.string  :description
+      t.string  :options
+      t.string  :bond_type
+
+      t.timestamps
+    end
+
+    create_table :activities_users, :id => false do |t|
+      t.references :activity, :user
+    end
+
+    add_index :activities_users, [:activity_id, :user_id ]
+
+    add_index :activities, [:verb]
+    add_index :activities, [:actor_id, :actor_type]
+    add_index :activities, [:act_object_id, :act_object_type]
+    add_index :activities, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :activities
+  end
+end

data/test/migrations/002_create_articles.rb

@@ -0,0 +1,11 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+    puts "creating"
+    create_table :articles do |t|
+      t.string :name
+      t.boolean :published
+      t.belongs_to :user
+      t.timestamps
+    end
+  end
+end

data/test/migrations/003_create_users.rb

@@ -0,0 +1,8 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/test/migrations/004_add_nonstandard_to_activities.rb

@@ -0,0 +1,7 @@
+class AddNonstandardToActivities < ActiveRecord::Migration
+  def change
+    change_table :activities do |t|
+      t.string :nonstandard
+    end
+  end
+end

data/test/migrations/005_create_volumes.rb

@@ -0,0 +1,9 @@
+class CreateVolumes < ActiveRecord::Migration
+  def self.up
+    puts "creating"
+    create_table :volumes do |t|
+      t.belongs_to :user
+      t.timestamps
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,77 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require 'active_support/testing/setup_and_teardown'
+require 'live_activity'
+require 'minitest/autorun'
+
+#LiveStream.config # touch config to load ORM, needed in some separate tests
+
+require 'active_record'
+require 'active_record/connection_adapters/sqlite3_adapter'
+
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  #fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end
+
+class Activity < ActiveRecord::Base
+  include LiveActivity::Activity
+
+  has_and_belongs_to_many :users
+
+  activity :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    #option       :description
+  end
+
+  activity :test_description do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :description
+  end
+
+  activity :test_option do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :country
+  end
+
+  activity :test_bond_type do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    bond_type    :global
+  end
+
+end
+
+class User < ActiveRecord::Base
+  include LiveActivity::Actor
+
+  has_and_belongs_to_many :activities
+
+end
+
+class Article < ActiveRecord::Base
+
+end
+
+class Volume < ActiveRecord::Base
+
+end
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Migrator.migrate(File.expand_path('../migrations', __FILE__))

data/test/unit/activity_test.rb

@@ -0,0 +1,85 @@
+class ActivityTest < ActiveSupport::TestCase
+
+  def test_truth
+    assert true
+  end
+
+  def test_register_definition
+
+    @definition = Activity.activity(:test_activity) do
+      actor :user, :cache => [:full_name]
+      act_object :listing, :cache => [:title, :full_address]
+      act_target :listing, :cache => [:title]
+    end
+
+    assert @definition.is_a?(LiveActivity::Definition)
+
+  end
+
+  def test_push_activity_to_receivers
+    _user    = User.create()
+    _user_2  = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _activity = Activity.publish(:new_enquiry, :actor => _user, :act_object => _article, :act_target => _volume,
+                                 :receivers => [_user_2])
+    assert _activity.users.size == 1
+
+  end
+
+  def test_publish_new_activity
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _activity = Activity.publish(:new_enquiry, :actor => _user, :act_object => _article, :act_target => _volume)
+
+    assert _activity.persisted?
+    #_activity.should be_an_instance_of Activity
+
+  end
+
+  def test_description
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _description = "this is a test"
+    _activity = Activity.publish(:test_description, :actor => _user, :act_object => _article, :act_target => _volume,
+                                 :description => _description )
+
+    assert _activity.description  == _description
+
+  end
+
+  def test_options
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _country = "denmark"
+    _activity = Activity.publish(:test_option, :actor => _user, :act_object => _article, :act_target => _volume,
+                                 :country => _country )
+
+    assert _activity.options[:country]  == _country
+
+  end
+
+  def test_bond_type
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _activity = Activity.publish(:test_bond_type, :actor => _user, :act_object => _article, :act_target => _volume)
+
+    assert _activity.bond_type  == 'global'
+
+  end
+
+
+
+
+
+
+end

data/test/unit/actor_test.rb

@@ -0,0 +1,58 @@
+class ActorTest < ActiveSupport::TestCase
+
+
+  def test_publish_activity
+
+    _user = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    activity = _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume)
+
+    assert activity.persisted?
+
+  end
+
+  def test_pushes_to_a_defined_stream
+    _user    = User.create()
+    _user_2  = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _activity = _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume,
+                                       :receivers => [_user_2])
+    assert _activity.users.size == 1
+
+  end
+
+  def test_retrieves_the_stream_for_an_actor
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume, :receivers => [_user])
+    _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume, :receivers => [_user])
+
+    assert _user.activity_stream.size == 2
+
+  end
+
+
+  def test_retrieves_the_stream_for_a_particular_activity_type
+    _user = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume, :receivers => [_user])
+    _user.publish_activity(:new_enquiry, :act_object => _article, :act_target => _volume, :receivers => [_user])
+    _user.publish_activity(:test_bond_type, :act_object => _article, :act_target => _volume, :receivers => [_user])
+
+    assert _user.activity_stream(:verb      => 'new_enquiry').size == 2
+    assert _user.activity_stream(:bond_type => 'global').size == 1
+
+  end
+
+
+
+
+end

data/test/unit/definition_dsl_test.rb

@@ -0,0 +1,29 @@
+class DefinitionDslTest < ActiveSupport::TestCase
+
+  def definition_dsl
+    LiveActivity::DefinitionDSL.new(:new_enquiry)
+  end
+
+  def test_initializes_with_name
+    assert definition_dsl.attributes[:name] == :new_enquiry
+  end
+
+  def test_adds_an_actor_to_the_definition
+    dsl = definition_dsl
+    dsl.actor(:User)
+    assert dsl.attributes[:actor] == :User
+  end
+
+  def test_adds_an_act_object_to_the_definition
+    dsl = definition_dsl
+    dsl.act_object(:Article)
+    assert dsl.attributes[:act_object] == :Article
+  end
+
+  def test_adds_a_act_target_to_the_definition
+    dsl = definition_dsl
+    dsl.act_target(:Volume)
+    assert dsl.attributes[:act_target] == :Volume
+  end
+
+end

data/test/unit/definition_test.rb

@@ -0,0 +1,51 @@
+class DefinitionTest < ActiveSupport::TestCase
+
+  def definition_dsl
+    dsl = LiveActivity::DefinitionDSL.new(:new_enquiry)
+    dsl.actor(:User)
+    dsl.act_object(:Article)
+    dsl.act_target(:Volume)
+    dsl
+  end
+
+  def test_initialization
+    _definition_dsl = definition_dsl
+    _definition     = LiveActivity::Definition.new(_definition_dsl)
+
+    assert _definition.actor      == :User
+    assert _definition.act_object == :Article
+    assert _definition.act_target == :Volume
+
+  end
+
+  def test_register_definition_and_return_new_definition
+
+    assert LiveActivity::Definition.register(definition_dsl).is_a?(LiveActivity::Definition)
+
+  end
+
+  def test_register_invalid_definition
+
+    assert LiveActivity::Definition.register(false)  == false
+
+  end
+
+  def test_return_registered_definitions
+
+    LiveActivity::Definition.register(definition_dsl)
+    assert LiveActivity::Definition.registered.size > 0
+
+  end
+
+  def test_return_definition_by_name
+    assert LiveActivity::Definition.find(:new_enquiry).name == :new_enquiry
+
+  end
+
+  def test_raise_exception_if_invalid_activity
+
+    assert_raises(LiveActivity::InvalidActivity){ LiveActivity::Definition.find(:unknown_activity) }
+
+  end
+
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: live-activity
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+platform: ruby
+authors:
+- Andreas Saebjoernsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+description: LiveActivity is a simple activity stream gem for use with the Mongoid
+  ODM framework
+email:
+- andreas.saebjoernsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/live_stream.rb
+- lib/generators/live_stream/activity/activity_generator.rb
+- lib/generators/live_stream/activity/templates/activity.rb
+- lib/generators/live_stream/migration/migration_generator.rb
+- lib/generators/live_stream/migration/templates/migration.rb
+- lib/live_activity.rb
+- lib/live_activity/activity.rb
+- lib/live_activity/actor.rb
+- lib/live_activity/definition.rb
+- lib/live_activity/definition_dsl.rb
+- lib/live_activity/errors.rb
+- lib/live_activity/version.rb
+- live-activity.gemspec
+- test/migrations/001_create_activities.rb
+- test/migrations/002_create_articles.rb
+- test/migrations/003_create_users.rb
+- test/migrations/004_add_nonstandard_to_activities.rb
+- test/migrations/005_create_volumes.rb
+- test/test_helper.rb
+- test/unit/activity_test.rb
+- test/unit/actor_test.rb
+- test/unit/definition_dsl_test.rb
+- test/unit/definition_test.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: live-activity
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Activity Streams for rails
+test_files:
+- test/migrations/001_create_activities.rb
+- test/migrations/002_create_articles.rb
+- test/migrations/003_create_users.rb
+- test/migrations/004_add_nonstandard_to_activities.rb
+- test/migrations/005_create_volumes.rb
+- test/test_helper.rb
+- test/unit/activity_test.rb
+- test/unit/actor_test.rb
+- test/unit/definition_dsl_test.rb
+- test/unit/definition_test.rb
+has_rdoc: