activity_hub 0.0.1

data/lib/public_activity/models/activist.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Provides helper methods for selecting activities from a user.
+  module Activist
+    # Delegates to configured ORM.
+    def self.included(base)
+      base.extend PublicActivity::inherit_orm("Activist")
+    end
+  end
+end

data/lib/public_activity/models/activity.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  class Activity < inherit_orm("Activity")
+  end
+end

data/lib/public_activity/models/adapter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Loads database-specific routines for use by PublicActivity.
+  class Adapter < inherit_orm("Adapter")
+  end
+end

data/lib/public_activity/models/trackable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Provides association for activities bound to this object by *trackable*.
+  module Trackable
+    # Delegates to ORM.
+    def self.included(base)
+      base.extend PublicActivity::inherit_orm("Trackable")
+    end
+  end
+end

data/lib/public_activity/orm/active_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require_relative 'active_record/activity.rb'
+require_relative 'active_record/adapter.rb'
+require_relative 'active_record/activist.rb'
+require_relative 'active_record/trackable.rb'

data/lib/public_activity/orm/active_record/activist.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module ActiveRecord
+      # Module extending classes that serve as owners
+      module Activist
+        # Adds ActiveRecord associations to model to simplify fetching
+        # so you can list activities performed by the owner.
+        # It is completely optional. Any model can be an owner to an activity
+        # even without being an explicit activist.
+        #
+        # == Usage:
+        # In model:
+        #
+        #   class User < ActiveRecord::Base
+        #     include PublicActivity::Model
+        #     activist
+        #   end
+        #
+        # In controller:
+        #   User.first.activities
+        #
+        def activist
+          has_many :activities_as_owner,
+            :class_name => "::PublicActivity::Activity",
+            :as => :owner
+          has_many :activities_as_recipient,
+            :class_name => "::PublicActivity::Activity",
+            :as => :recipient
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/active_record/activity.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PublicActivity
+
+  if not defined? ::PG::ConnectionBad
+    module ::PG
+      class ConnectionBad < Exception; end
+    end
+  end
+  if not defined? Mysql2::Error::ConnectionError
+    module Mysql2
+      module Error
+        class ConnectionError < Exception; end
+      end
+    end
+  end
+  
+  module ORM
+    module ActiveRecord
+      # The ActiveRecord model containing
+      # details about recorded activity.
+      class Activity < ::ActiveRecord::Base
+        include Renderable
+        self.table_name = PublicActivity.config.table_name
+        self.abstract_class = true
+
+        # Define polymorphic association to the parent
+        belongs_to :trackable, :polymorphic => true
+
+        case ::ActiveRecord::VERSION::MAJOR
+        when 3..4
+          # Define ownership to a resource responsible for this activity
+          belongs_to :owner, :polymorphic => true
+          # Define ownership to a resource targeted by this activity
+          belongs_to :recipient, :polymorphic => true
+        when 5..6
+          with_options(:required => false) do
+            # Define ownership to a resource responsible for this activity
+            belongs_to :owner, :polymorphic => true
+            # Define ownership to a resource targeted by this activity
+            belongs_to :recipient, :polymorphic => true
+          end
+        end
+
+        # Serialize parameters Hash
+        begin
+          if table_exists?
+            serialize :parameters, Hash unless [:json, :jsonb, :hstore].include?(columns_hash['parameters'].type)
+          else
+            warn("[WARN] table #{name} doesn't exist. Skipping PublicActivity::Activity#parameters's serialization")
+          end
+        rescue ::ActiveRecord::NoDatabaseError => e
+          warn("[WARN] database doesn't exist. Skipping PublicActivity::Activity#parameters's serialization")
+        rescue ::PG::ConnectionBad => e
+          warn("[WARN] couldn't connect to database. Skipping PublicActivity::Activity#parameters's serialization")
+        rescue Mysql2::Error::ConnectionError
+          warn("[WARN] couldn't connect to database. Skipping PublicActivity::Activity#parameters's serialization")
+        end
+
+        if ::ActiveRecord::VERSION::MAJOR < 4 || defined?(ProtectedAttributes)
+          attr_accessible :key, :owner, :parameters, :recipient, :trackable
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/active_record/adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    # Support for ActiveRecord for PublicActivity. Used by default and supported
+    # officialy.
+    module ActiveRecord
+      # Provides ActiveRecord specific, database-related routines for use by
+      # PublicActivity.
+      class Adapter
+        # Creates the activity on `trackable` with `options`
+        def self.create_activity(trackable, options)
+          trackable.activities.create options
+        end
+
+        # Creates activity on `trackable` with `options`; throws error on validation failure
+        def self.create_activity!(trackable, options)
+          trackable.activities.create! options
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/active_record/trackable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module ActiveRecord
+      # Implements {PublicActivity::Trackable} for ActiveRecord
+      # @see PublicActivity::Trackable
+      module Trackable
+        # Creates an association for activities where self is the *trackable*
+        # object.
+        def self.extended(base)
+          base.has_many :activities, :class_name => "::PublicActivity::Activity", :as => :trackable
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongo_mapper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "mongo_mapper/activity.rb"
+require_relative "mongo_mapper/adapter.rb"
+require_relative "mongo_mapper/activist.rb"
+require_relative "mongo_mapper/trackable.rb"

data/lib/public_activity/orm/mongo_mapper/activist.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module MongoMapper
+      # Module extending classes that serve as owners
+      module Activist
+        # Adds MongoMapper associations to model to simplify fetching
+        # so you can list activities performed by the owner.
+        # It is completely optional. Any model can be an owner to an activity
+        # even without being an explicit activist.
+        #
+        # == Usage:
+        # In model:
+        #
+        #   class User
+        #     include MongoMapper::Document
+        #     include PublicActivity::Model
+        #     activist
+        #   end
+        #
+        # In controller:
+        #   User.first.activities
+        #
+        def activist
+          many :activities_as_owner,
+            :class_name => "::PublicActivity::Activity",
+            :as => :owner
+          many :activities_as_recipient,
+            :class_name => "::PublicActivity::Activity",
+            :as => :recipient
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongo_mapper/activity.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'mongo_mapper'
+require 'active_support/core_ext'
+
+module PublicActivity
+  module ORM
+    module MongoMapper
+      # The MongoMapper document containing
+      # details about recorded activity.
+      class Activity
+        include ::MongoMapper::Document
+        include Renderable
+
+        class SymbolHash < Hash
+          def self.from_mongo(value)
+            value.symbolize_keys unless value.nil?
+          end
+        end
+
+        # Define polymorphic association to the parent
+        belongs_to :trackable,  polymorphic: true
+        # Define ownership to a resource responsible for this activity
+        belongs_to :owner,      polymorphic: true
+        # Define ownership to a resource targeted by this activity
+        belongs_to :recipient,  polymorphic: true
+
+        key :key,         String
+        key :parameters,  SymbolHash
+
+        timestamps!
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongo_mapper/adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module MongoMapper
+      class Adapter
+        # Creates the activity on `trackable` with `options`
+        def self.create_activity(trackable, options)
+          trackable.activities.create options
+        end
+
+        # Creates activity on `trackable` with `options`; throws error on validation failure
+        def self.create_activity!(trackable, options)
+          trackable.activities.create! options
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongo_mapper/trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module MongoMapper
+      module Trackable
+        def self.extended(base)
+          base.many :activities, :class_name => "::PublicActivity::Activity", order: :created_at.asc, :as => :trackable
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongoid.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "mongoid/activity.rb"
+require_relative "mongoid/adapter.rb"
+require_relative "mongoid/activist.rb"
+require_relative "mongoid/trackable.rb"

data/lib/public_activity/orm/mongoid/activist.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module Mongoid
+      # Module extending classes that serve as owners
+      module Activist
+        # Adds ActiveRecord associations to model to simplify fetching
+        # so you can list activities performed by the owner.
+        # It is completely optional. Any model can be an owner to an activity
+        # even without being an explicit activist.
+        #
+        # == Usage:
+        # In model:
+        #
+        #   class User < ActiveRecord::Base
+        #     include PublicActivity::Model
+        #     activist
+        #   end
+        #
+        # In controller:
+        #   User.first.activities
+        #
+        def activist
+          has_many :activities_as_owner,
+            :class_name => "::PublicActivity::Activity",
+            :inverse_of => :owner
+
+          has_many :activities_as_recipient,
+            :class_name => "::PublicActivity::Activity",
+            :inverse_of => :recipient
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongoid/activity.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'mongoid'
+
+module PublicActivity
+  module ORM
+    module Mongoid
+      # The ActiveRecord model containing
+      # details about recorded activity.
+      class Activity
+        include ::Mongoid::Document
+        include ::Mongoid::Timestamps
+        include ::Mongoid::Attributes::Dynamic if ::Mongoid::VERSION.split('.')[0].to_i >= 4
+        include Renderable
+
+        if ::Mongoid::VERSION.split('.')[0].to_i >= 7
+          opts = { polymorphic: true, optional: false }
+        else
+          opts = { polymorphic: true }
+        end
+
+        # Define polymorphic association to the parent
+        belongs_to :trackable,  opts
+        # Define ownership to a resource responsible for this activity
+        belongs_to :owner,      opts
+        # Define ownership to a resource targeted by this activity
+        belongs_to :recipient,  opts
+
+        field :key,         type: String
+        field :parameters,  type: Hash
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongoid/adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module Mongoid
+      class Adapter
+        # Creates the activity on `trackable` with `options`
+        def self.create_activity(trackable, options)
+          trackable.activities.create options
+        end
+
+        # Creates activity on `trackable` with `options`; throws error on validation failure
+        def self.create_activity!(trackable, options)
+          trackable.activities.create! options
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/orm/mongoid/trackable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  module ORM
+    module Mongoid
+      module Trackable
+        def self.extended(base)
+          base.has_many :activities, :class_name => "::PublicActivity::Activity", :as => :trackable
+        end
+      end
+    end
+  end
+end

data/lib/public_activity/renderable.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module PublicActivity
+  # Provides logic for rendering activities. Handles both i18n strings
+  # support and smart partials rendering (different templates per activity key).
+  module Renderable
+    # Virtual attribute returning text description of the activity
+    # using the activity's key to translate using i18n.
+    def text(params = {})
+      # TODO: some helper for key transformation for two supported formats
+      k = key.split('.')
+      k.unshift('activity') if k.first != 'activity'
+      k = k.join('.')
+
+      I18n.t(k, parameters.merge(params) || {})
+    end
+
+    # Renders activity from views.
+    #
+    # @param [ActionView::Base] context
+    # @return [nil] nil
+    #
+    # Renders activity to the given ActionView context with included
+    # AV::Helpers::RenderingHelper (most commonly just ActionView::Base)
+    #
+    # The *preferred* *way* of rendering activities is
+    # to provide a template specifying how the rendering should be happening.
+    # However, one may choose using _I18n_ based approach when developing
+    # an application that supports plenty of languages.
+    #
+    # If partial view exists that matches the *key* attribute
+    # renders that partial with local variables set to contain both
+    # Activity and activity_parameters (hash with indifferent access)
+    #
+    # Otherwise, it outputs the I18n translation to the context
+    # @example Render a list of all activities from a view (erb)
+    #   <ul>
+    #     <% for activity in PublicActivity::Activity.all %>
+    #      <li><%= render_activity(activity) %></li>
+    #     <% end %>
+    #   </ul>
+    #
+    # = Layouts
+    # You can supply a layout that will be used for activity partials
+    # with :layout param.
+    # Keep in mind that layouts for partials are also partials.
+    # @example Supply a layout
+    #   # in views:
+    #   #   All examples look for a layout in app/views/layouts/_activity.erb
+    #    render_activity @activity, :layout => "activity"
+    #    render_activity @activity, :layout => "layouts/activity"
+    #    render_activity @activity, :layout => :activity
+    #
+    #   # app/views/layouts/_activity.erb
+    #   <p><%= a.created_at %></p>
+    #   <%= yield %>
+    #
+    # == Custom Layout Location
+    # You can customize the layout directory by supplying :layout_root
+    # or by using an absolute path.
+    #
+    # @example Declare custom layout location
+    #
+    #   # Both examples look for a layout in "app/views/custom/_layout.erb"
+    #
+    #    render_activity @activity, :layout_root => "custom"
+    #    render_activity @activity, :layout      => "/custom/layout"
+    #
+    # = Creating a template
+    # To use templates for formatting how the activity should render,
+    # create a template based on activity key, for example:
+    #
+    # Given a key _activity.article.create_, create directory tree
+    # _app/views/public_activity/article/_ and create the _create_ partial there
+    #
+    # Note that if a key consists of more than three parts splitted by commas, your
+    # directory structure will have to be deeper, for example:
+    #   activity.article.comments.destroy => app/views/public_activity/articles/comments/_destroy.html.erb
+    #
+    # == Custom Directory
+    # You can override the default `public_directory` template root with the :root parameter
+    #
+    # @example Custom template root
+    #    # look for templates inside of /app/views/custom instead of /app/views/public_directory
+    #    render_activity @activity, :root => "custom"
+    #
+    # == Variables in templates
+    # From within a template there are two variables at your disposal:
+    # * activity (aliased as *a* for a shortcut)
+    # * params   (aliased as *p*) [converted into a HashWithIndifferentAccess]
+    #
+    # @example Template for key: _activity.article.create_ (erb)
+    #   <p>
+    #     Article <strong><%= p[:name] %></strong>
+    #     was written by <em><%= p["author"] %></em>
+    #     <%= distance_of_time_in_words_to_now(a.created_at) %>
+    #   </p>
+    def render(context, params = {})
+      partial_root  = params.delete(:root)         || 'public_activity'
+      partial_path  = nil
+      layout_root   = params.delete(:layout_root)  || 'layouts'
+
+      if params.has_key? :display
+        if params[:display].to_sym == :"i18n"
+          text = self.text(params)
+          return context.render :text => text, :plain => text
+        else
+          partial_path = File.join(partial_root, params[:display].to_s)
+        end
+      end
+
+      context.render(
+        params.merge({
+          :partial => prepare_partial(partial_root, partial_path),
+          :layout  => prepare_layout(layout_root, params.delete(:layout)),
+          :locals  => prepare_locals(params)
+        })
+      )
+    end
+
+    def prepare_partial(root, path)
+      path || self.template_path(self.key, root)
+    end
+
+    def prepare_locals(params)
+      locals = params.delete(:locals) || Hash.new
+
+      controller  = PublicActivity.get_controller
+      prepared_params = prepare_parameters(params)
+      locals.merge(
+        {
+          :a              => self,
+          :activity       => self,
+          :controller     => controller,
+          :current_user   => controller.respond_to?(:current_user) ? controller.current_user : nil,
+          :p              => prepared_params,
+          :params         => prepared_params
+        }
+      )
+    end
+
+    def prepare_layout(root, layout)
+      if layout
+        path = layout.to_s
+        unless path.starts_with?(root) || path.starts_with?("/")
+          return File.join(root, path)
+        end
+      end
+      layout
+    end
+
+    def prepare_parameters(params)
+      @prepared_params ||= self.parameters.with_indifferent_access.merge(params)
+    end
+
+    protected
+
+    # Builds the path to template based on activity key
+    def template_path(key, partial_root)
+      path = key.split(".")
+      path.delete_at(0) if path[0] == "activity"
+      path.unshift partial_root
+      path.join("/")
+    end
+  end
+end