activity_hub 0.0.1

data/lib/public_activity/roles/deactivatable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Enables per-class disabling of PublicActivity functionality.
+  module Deactivatable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :public_activity_enabled_for_model
+      set_public_activity_class_defaults
+    end
+
+    # Returns true if PublicActivity is enabled
+    # globally and for this class.
+    # @return [Boolean]
+    # @api private
+    # @since 0.5.0
+    # overrides the method from Common
+    def public_activity_enabled?
+      PublicActivity.enabled? && self.class.public_activity_enabled_for_model
+    end
+
+    # Provides global methods to disable or enable PublicActivity on a per-class
+    # basis.
+    module ClassMethods
+      # Switches public_activity off for this class
+      def public_activity_off
+        self.public_activity_enabled_for_model = false
+      end
+
+      # Switches public_activity on for this class
+      def public_activity_on
+        self.public_activity_enabled_for_model = true
+      end
+
+      # @since 1.0.0
+      # @api private
+      def set_public_activity_class_defaults
+        super
+        self.public_activity_enabled_for_model = true
+      end
+    end
+  end
+end

data/lib/public_activity/roles/tracked.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Main module extending classes we want to keep track of.
+  module Tracked
+    extend ActiveSupport::Concern
+    # A shortcut method for setting custom key, owner and parameters of {Activity}
+    # in one line. Accepts a hash with 3 keys:
+    # :key, :owner, :params. You can specify all of them or just the ones you want to overwrite.
+    #
+    # == Options
+    #
+    # [:key]
+    #   See {Common#activity_key}
+    # [:owner]
+    #   See {Common#activity_owner}
+    # [:params]
+    #   See {Common#activity_params}
+    # [:recipient]
+    #   Set the recipient for this activity. Useful for private notifications, which should only be visible to a certain user. See {Common#activity_recipient}.
+    # @example
+    #
+    #   @article = Article.new
+    #   @article.title = "New article"
+    #   @article.activity :key => "my.custom.article.key", :owner => @article.author, :params => {:title => @article.title}
+    #   @article.save
+    #   @article.activities.last.key #=> "my.custom.article.key"
+    #   @article.activities.last.parameters #=> {:title => "New article"}
+    #
+    # @param options [Hash] instance options to set on the tracked model
+    # @return [nil]
+    def activity(options = {})
+      rest = options.clone
+      self.activity_key           = rest.delete(:key) if rest[:key]
+      self.activity_owner         = rest.delete(:owner) if rest[:owner]
+      self.activity_params        = rest.delete(:params) if rest[:params]
+      self.activity_recipient     = rest.delete(:recipient) if rest[:recipient]
+      self.activity_custom_fields = rest if rest.count > 0
+      nil
+    end
+
+    # Module with basic +tracked+ method that enables tracking models.
+    module ClassMethods
+      # Adds required callbacks for creating and updating
+      # tracked models and adds +activities+ relation for listing
+      # associated activities.
+      #
+      # == Parameters:
+      # [:owner]
+      #   Specify the owner of the {Activity} (person responsible for the action).
+      #   It can be a Proc, Symbol or an ActiveRecord object:
+      #   == Examples:
+      #
+      #    tracked :owner => :author
+      #    tracked :owner => proc {|o| o.author}
+      #
+      #   Keep in mind that owner relation is polymorphic, so you can't just
+      #   provide id number of the owner object.
+      # [:recipient]
+      #   Specify the recipient of the {Activity}
+      #   It can be a Proc, Symbol, or an ActiveRecord object
+      #   == Examples:
+      #
+      #    tracked :recipient => :author
+      #    tracked :recipient => proc {|o| o.author}
+      #
+      #   Keep in mind that recipient relation is polymorphic, so you can't just
+      #   provide id number of the owner object.
+      # [:params]
+      #   Accepts a Hash with custom parameters you want to pass to i18n.translate
+      #   method. It is later used in {Renderable#text} method.
+      #   == Example:
+      #    class Article < ActiveRecord::Base
+      #      include PublicActivity::Model
+      #      tracked :params => {
+      #          :title => :title,
+      #          :author_name => "Michael",
+      #          :category_name => proc {|controller, model_instance| model_instance.category.name},
+      #          :summary => proc {|controller, model_instance| truncate(model.text, :length => 30)}
+      #      }
+      #    end
+      #
+      #   Values in the :params hash can either be an *exact* *value*, a *Proc/Lambda* executed before saving the activity or a *Symbol*
+      #   which is a an attribute or a method name executed on the tracked model's instance.
+      #
+      #   Everything specified here has a lower priority than parameters
+      #   specified directly in {#activity} method.
+      #   So treat it as a place where you provide 'default' values or where you
+      #   specify what data should be gathered for every activity.
+      #   For more dynamic settings refer to {Activity} model documentation.
+      # [:skip_defaults]
+      #   Disables recording of activities on create/update/destroy leaving that to programmer's choice. Check {PublicActivity::Common#create_activity}
+      #   for a guide on how to manually record activities.
+      # [:only]
+      #   Accepts a symbol or an array of symbols, of which any combination of the three is accepted:
+      #   * _:create_
+      #   * _:update_
+      #   * _:destroy_
+      #   Selecting one or more of these will make PublicActivity create activities
+      #   automatically for the tracked model on selected actions.
+      #
+      #   Resulting activities will have have keys assigned to, respectively:
+      #   * _article.create_
+      #   * _article.update_
+      #   * _article.destroy_
+      #   Since only three options are valid,
+      #   see _:except_ option for a shorter version
+      # [:except]
+      #   Accepts a symbol or an array of symbols with values like in _:only_, above.
+      #   Values provided will be subtracted from all default actions:
+      #   (create, update, destroy).
+      #
+      #   So, passing _create_ would track and automatically create
+      #   activities on _update_ and _destroy_ actions,
+      #   but not on the _create_ action.
+      # [:on]
+      #   Accepts a Hash with key being the *action* on which to execute *value* (proc)
+      #   Currently supported only for CRUD actions which are enabled in _:only_
+      #   or _:except_ options on this method.
+      #
+      #   Key-value pairs in this option define callbacks that can decide
+      #   whether to create an activity or not. Procs have two attributes for
+      #   use: _model_ and _controller_. If the proc returns true, the activity
+      #   will be created, if not, then activity will not be saved.
+      #
+      #   == Example:
+      #     # app/models/article.rb
+      #     tracked :on => {:update => proc {|model, controller| model.published? }}
+      #
+      #   In the example above, given a model Article with boolean column _published_.
+      #   The activities with key _article.update_ will only be created
+      #   if the published status is set to true on that article.
+      # @param opts [Hash] options
+      # @return [nil] options
+      def tracked(opts = {})
+        options = opts.clone
+
+        include_default_actions(options)
+
+        assign_globals       options
+        assign_hooks         options
+        assign_custom_fields options
+
+        nil
+      end
+
+      def include_default_actions(options)
+        defaults = {
+          create:  Creation,
+          destroy: Destruction,
+          update:  Update
+        }
+
+        if options[:skip_defaults] == true
+          return
+        end
+
+        modules = if options[:except]
+          defaults.except(*options[:except])
+        elsif options[:only]
+          defaults.slice(*options[:only])
+        else
+          defaults
+        end
+
+        modules.each do |key, value|
+          include value
+        end
+      end
+
+      def available_options
+        [:skip_defaults, :only, :except, :on, :owner, :recipient, :params].freeze
+      end
+
+      def assign_globals(options)
+        [:owner, :recipient, :params].each do |key|
+          if options[key]
+            self.send("activity_#{key}_global=".to_sym, options.delete(key))
+          end
+        end
+      end
+
+      def assign_hooks(options)
+        if options[:on].is_a?(Hash)
+          self.activity_hooks = options[:on].select {|_, v| v.is_a? Proc}.symbolize_keys
+        end
+      end
+
+      def assign_custom_fields(options)
+        options.except(*available_options).each do |k, v|
+          self.activity_custom_fields_global[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/testing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# This file provides functionality for testing your code with public_activity
+# activated or deactivated.
+# This file should only be required in test/spec code!
+#
+# To enable PublicActivity testing capabilities do:
+#   require 'public_activity/testing'
+module PublicActivity
+  # Execute the code block with PublicActiviy active
+  #
+  # Example usage:
+  #   PublicActivity.with_tracking do
+  #     # your test code here
+  #   end
+  def self.with_tracking
+    current = PublicActivity.config.enabled
+    PublicActivity.config.enabled(true)
+    yield
+  ensure
+    PublicActivity.config.enabled(current)
+  end
+
+  # Execute the code block with PublicActiviy deactive
+  #
+  # Example usage:
+  #   PublicActivity.without_tracking do
+  #     # your test code here
+  #   end
+  def self.without_tracking
+    current = PublicActivity.enabled?
+    PublicActivity.config.enabled(false)
+    yield
+  ensure
+    PublicActivity.config.enabled(current)
+  end
+end

data/lib/public_activity/utility/store_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  class << self
+    # Setter for remembering controller instance
+    def set_controller(controller)
+      Thread.current[:public_activity_controller] = controller
+    end
+
+    # Getter for accessing the controller instance
+    def get_controller
+      Thread.current[:public_activity_controller]
+    end
+  end
+
+  # Module included in controllers to allow p_a access to controller instance
+  module StoreController
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :store_controller_for_public_activity if     respond_to?(:around_action)
+      around_filter :store_controller_for_public_activity unless respond_to?(:around_action)
+    end
+
+    def store_controller_for_public_activity
+      PublicActivity.set_controller(self)
+      yield
+    ensure
+      PublicActivity.set_controller(nil)
+    end
+  end
+end

data/lib/public_activity/utility/view_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Provides a shortcut from views to the rendering method.
+module PublicActivity
+  # Module extending ActionView::Base and adding `render_activity` helper.
+  module ViewHelpers
+    # View helper for rendering an activity, calls {PublicActivity::Activity#render} internally.
+    def render_activity activities, options = {}
+      if activities.is_a? PublicActivity::Activity
+        activities.render self, options
+      elsif activities.respond_to?(:map)
+        # depend on ORMs to fetch as needed
+        # maybe we can support Postgres streaming with this?
+        activities.map {|activity| activity.render self, options.dup }.join.html_safe
+      end
+    end
+    alias_method :render_activities, :render_activity
+
+    # Helper for setting content_for in activity partial, needed to
+    # flush remains in between partial renders.
+    def single_content_for(name, content = nil, &block)
+      @view_flow.set(name, ActiveSupport::SafeBuffer.new)
+      content_for(name, content, &block)
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_view) do
+  include PublicActivity::ViewHelpers
+end

data/lib/public_activity/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # A constant with gem's version
+  VERSION = '0.0.1'
+end

data/test/migrations/001_create_activities.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Migration responsible for creating a table with activities
+class CreateActivities < (ActiveRecord.version.release() < Gem::Version.new('5.2.0') ? ActiveRecord::Migration : ActiveRecord::Migration[5.2])
+  # Create table
+  def self.up
+    create_table :activities do |t|
+      t.belongs_to :trackable, :polymorphic => true
+      t.belongs_to :owner, :polymorphic => true
+      t.string  :key
+      t.text    :parameters
+      t.belongs_to :recipient, :polymorphic => true
+
+      t.timestamps
+    end
+
+    add_index :activities, [:trackable_id, :trackable_type]
+    add_index :activities, [:owner_id, :owner_type]
+    add_index :activities, [:recipient_id, :recipient_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :activities
+  end
+end

data/test/migrations/002_create_articles.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'migrations_base.rb'
+
+class CreateArticles < MigrationsBase
+  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,12 @@
+# frozen_string_literal: true
+
+require 'migrations_base.rb'
+
+class CreateUsers < MigrationsBase
+  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,11 @@
+# frozen_string_literal: true
+
+require 'migrations_base.rb'
+
+class AddNonstandardToActivities < MigrationsBase
+  def change
+    change_table :activities do |t|
+      t.string :nonstandard
+    end
+  end
+end

data/test/migrations_base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+MigrationsBase = if ActiveRecord.version.release() < Gem::Version.new('5.2.0')
+  ActiveRecord::Migration
+else
+  ActiveRecord::Migration[5.2]
+end

data/test/mongo_mapper.yml

@@ -0,0 +1,4 @@
+test:
+  host: 127.0.0.1
+  port: 27017
+  database: public_activity_test

data/test/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  clients:
+    default:
+      hosts:
+        - 127.0.0.1:27017
+      database: public_activity_test