simple_activity 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d868ca86145e7defedd43fbda7cf7a9ef9119c4
+  data.tar.gz: fe60f2894728a517af4f2348e815ee366a93d60e
+SHA512:
+  metadata.gz: 83459aca9b69474c188714a199c442839f58194d44a7bdbbad47f389114cd6f739471317629c143159af1586a0a91fe73b3f078fd12a62002adccb716caa61d5
+  data.tar.gz: e1f9846693efb02da8aca434c95050fd09db96937fe3a1e02892fd426d62099e5fdd0e27703da7bea71328897d2fcb49a7d7201ead59125762cfaffa9fb65394

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Billy Chan
+
+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,142 @@
+# SimpleActivity
+
+SimpleActivity is a gem to record, display and reuse users activities for
+Rails app, in a fast, flexible and extendable way.
+
+## Features
+* **Fast** - SimpleActivity is built with speed in mind. Normally activities involve
+several models and hard to eager load. SimpleActivity allows you define cache
+rules beforehand so there is no JOIN on displaying activities. 
+
+* **Flexible** - Raw data is here, you are free to do anything you like, display them
+in any fashion.
+
+* **Extendable** - Actually activity records are useful not only for displaying as timeline. There could be lots of other functionality based on activity such as assining reputation
+to models, assign points to users, send notifications, granting badges etc. It would be
+redudant if every feature build its own logic to record activity which is basically the same.
+
+    To solve this problem, this gem provides a hook for other libs or your app code to work
+on the raw data once activity created, either within the request or at
+backend(recommended). This will remove code repetition and increase app performance.
+
+## How it works
+* Record key data of user activities(create, update, destroy and custom) in
+controler level, automaticly or manually.
+* Read and process cache rules to allow showing activities with minimal db load.
+* Provide helper to load partials with defined names
+* Provide barebone model to allow your customization if needed.
+* Provide hook to further working on the activity created.
+
+## Installation
+
+* Add the gem to Gemfile and `bundle`
+
+```bash
+    gem 'simple_activity'
+```
+
+* Install the custom files and migration  
+
+```bash
+    $ rails generate simple_activity:install
+    $ rake db:migrate
+```
+
+## Usage
+
+### Record Activities
+By default you don't need to do anything to get activities recorded.
+
+Activity record will be created automaticly at basic RESTful actions :create, :update
+and :destroy, with filtering out some controllers such as "registration", "session",
+"admin" etc. You can also customize them. See more at Configurations.
+
+### Display Activities: Define Rules
+
+The rules file `rules.yml` resides in `app/models/activity/rules.yml`. One purpose of
+rule.yml is to helper displaying - customizing displaying logic and define things to cache.
+
+Here is an example of rules.yml
+```yml
+Comment:
+  _cache:
+    actor:
+      - nick_name
+    target:
+      - commentable_title
+      - excerpt
+Article:
+  ...
+```
+
+### Display Activities: By partial
+
+A helper `render_activity(activity)` is shipped. This helper will render partial
+at default place according to the activity. 
+
+At first you need to write partials at right place. By default the helper will
+look up `app/views/activities` folder. The partial name need to be a combination
+of model name and action key with underscore before. e.g. `_comment_create.html.erb`,
+`_article_destroy.html.slim`
+
+You can call any attributes defined in cache rules within the partial, by concating
+actor/target and the method name. e.g. `activity.actore_name`, `activity.target_title`, 
+`activity.target_commentable_title`
+
+`actor_id` and `target_id` is available natively. No need cache rules.
+
+Also `actor` and `target` object is available if you really need them. But it's not
+recommended to use them to reduce db load. `activity.actor.name` is less preferred to
+`activity.actore_name` which is a cached value.
+
+As said above, to define a link, you don't need the instance itself. Instead, id will work
+as well. So, instead of `link_to activity.actor`, it's recommended to use
+`link_to user_path(activity.actor_id)`
+
+## Configurations
+
+#### To customize the actions to record
+
+The default actions to record activiies are `:create`, `:update` and `:destroy`.
+Customize them as per your need.
+```ruby
+config.filtered_controllers = /(user|admin|session|registration)/i
+```
+
+#### To filter out more controllers
+
+You don't need activity to be recorded in every controller. Below is the
+default settings. You can customize them as you like.
+```ruby
+config.filtered_controllers = /(user|admin|session|registration)/i
+```
+
+## Extend
+
+Reuse activity in third party libs.
+
+Docs and demo coming soon.
+
+## Compatability
+
+SimpleActivity is built to work under both Rails 3 and Rails 4. The demo is on Rails 4.
+The current tests are based on Rails 3, and Rails 4 ones will come later.
+
+The current ORM is ActiveRecord. Other ORMS should be able to added in the future without
+too much sweat(or coffee?)
+
+## Contributing
+
+This gem is still at its early stage. Very likely there are bugs and unconsidered 
+situations. Thansk for your patience and trust to use it. Your bug reporting and
+pull requests will be appreciated.
+
+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
+
+## License
+
+MIT. See MIT-LICENSE

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SimpleActivity'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/generators/simple_activity/install_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators/base'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module SimpleActivity
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Description: Create yml template for rules. Generate migration file for activities table. Create custom activity model(default to Activity)"
+
+      self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+      def self.next_migration_number(path)
+        ActiveRecord::Generators::Base.next_migration_number(path)
+      end
+
+      def create_migration_file
+        migration_template "create_activity.rb", "db/migrate/create_activity.rb"
+      end
+
+      def copy_rules
+        copy_file "rules.yml", "app/models/activity/rules.yml"
+      end
+
+      def copy_activity_model
+        copy_file "activity.rb", "app/models/activity.rb"
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,2 @@
+class Activity < SimpleActivity::Activity
+end

data/lib/generators/simple_activity/templates/create_activity.rb

@@ -0,0 +1,15 @@
+class CreateActivity < ActiveRecord::Migration
+  def change
+    create_table :simple_activity_activities do |t|
+      t.string  :actor_type
+      t.integer :actor_id
+      t.string  :target_type
+      t.integer :target_id
+      t.string  :action_key
+      t.boolean :display
+      t.text    :cache
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/simple_activity/templates/rules.yml

@@ -0,0 +1,35 @@
+# Sample Activity settings
+#
+# How to write rules
+#   * Model class name at first level
+#   * '_cache` at second level. It's for defining things to cache
+#   * The third level allows only keys as `actor` or `target`.
+#     - actor is the user who initiate this action. For example, the
+#       man who wrote an article, the man who liked a comment.
+#     - target is the resource itself. It represents the only instance variable
+#       you processed in controller. e.g. the article wrote, the comment
+#       be liked, or the like itself if "Like" is the model
+#     - Any other things are based on actor or target.
+#   * The fourth level represents the method available in actor's or taget's
+#     model. The value will be stored for caching.
+#     - Item(s) here must be in array(with dash and one space before it)
+#     - The model must respond to such methods.
+
+# Comment:
+#   _cache: 
+#     actor:
+#       - name
+#     target:
+#       - body
+#   create:
+#     # future possibility to extend
+#     # points:
+#       # - user: 10
+#       #  condition: within_1_day_of_article
+#       # - commentable_user: 2
+# Article:
+#   _cache:
+#     actor:
+#       - name
+#     target:
+#       - title

data/lib/generators/simple_activity/templates/simple_activity.rb

@@ -0,0 +1,8 @@
+# SimpleActivity Intializers
+SimpleActivity.setup do |config|
+  # Setup controllers not to record activities
+  # config.filtered_controllers = /(user|admin|session|registration)/i
+
+  # Setup actions to record activities
+  # config.allowed_actions = [:create, :update, :destroy]
+end

data/lib/simple_activity/controller_methods.rb

@@ -0,0 +1,69 @@
+module SimpleActivity
+
+  # Public: To be used on controller. The module is supposed to be
+  # included in ActionController::Base
+
+  module ControllerMethods
+
+    # extend ActiveSupport::Concern
+
+    # included do
+    #   after_filter :record_activity, only: [:create, :update, :destroy]
+    # end
+    #
+    def self.included(base)
+      base.after_filter :record_activity, only: SimpleActivity.allowed_actions
+    end
+
+    # The main method to log activity.
+    #
+    # By default it is used as an after_filter
+    #
+    # If after_filter disabled, it can be called without arguments
+    #
+    #   # ArticlesController
+    #   def create
+    #     @article = Article.create(params[:article])
+    #     if @article.save
+    #       record_activity
+    #     end
+    #   end
+    #
+    # target argument is needed if the instance is not the convention
+    # (the sigularize of controller name)
+    #
+    #   # ArticlesController
+    #   def create
+    #     @article_in_other_name = Article.create(params[:article])
+    #     if @article_in_other_name.save
+    #       record_activity(@article_in_other_name)
+    #     end
+    #   end
+    #
+    #
+    # @param target [Object] the target instance variable. If nil, the processor
+    #        will build it according to mathcing instance variable in controller
+    #        automatically
+    private
+    def record_activity(target=nil)
+      unless controller_name.match SimpleActivity.filtered_controllers
+        process_activity(target)
+      end
+    end
+
+    def process_activity(target)
+      activity = ::SimpleActivity::ActivityProcessor.new(self, target)
+      activity.save
+    end
+
+  end
+end
+
+# ActiveSupport.on_load(:action_controller) do
+#   ActionController::Base.send :include, SimpleActivity::ControllerMethods
+# end
+# ActionController::Base.send :include, SimpleActivity::ControllerMethods
+# ActionController::Base.class_eval do
+#   include SimpleActivity::ControllerMethods
+# end
+# end

data/lib/simple_activity/helpers.rb

@@ -0,0 +1,12 @@
+module SimpleActivity
+  module Helpers
+    def render_activity(activity, mode="actor")
+      target = activity.target_type.underscore 
+      action_key = activity.action_key
+      template = "activities/#{mode}/#{target}_#{action_key}"
+      if lookup_context.template_exists? template, [], true
+        render partial: template, locals: {activity: activity}
+      end
+    end
+  end
+end

data/lib/simple_activity/hooks.rb

@@ -0,0 +1,20 @@
+module SimpleActivity
+  class Hooks
+    def self.init
+      ActiveSupport.on_load(:action_controller) do
+        require 'simple_activity/controller_methods'
+        ActionController::Base.send :include, SimpleActivity::ControllerMethods
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        require 'simple_activity/models/extenders'
+        ActiveRecord::Base.send :include, SimpleActivity::ModelExtenders
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        require 'simple_activity/helpers'
+        ActionView::Base.send :include, SimpleActivity::Helpers
+      end
+    end
+  end
+end

data/lib/simple_activity/models/activity.rb

@@ -0,0 +1,79 @@
+module SimpleActivity
+  class Activity < ActiveRecord::Base
+    self.table_name = "simple_activity_activities"
+
+    # cache can cache rule when necessary, for third party lib speeding
+    # us processing.
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :actor_type, :actor_id, :target_type, :target_id, :action_key, :display, :cache
+    end
+
+    serialize :cache
+
+    # Show activities belongs to an actor
+    def self.actor_activities(obj)
+      type = obj.class.to_s
+      id   = obj.id
+      self.where(actor_type: type, actor_id: id)
+    end
+
+    # Show activities belongs to a target
+    def self.target_activities(obj)
+      type = obj.class.to_s
+      id   = obj.id
+      self.where(target_type: type, target_id: id)
+    end
+
+    def cache
+      read_attribute(:cache) || []
+    end
+
+    # Delegate the methods start with "actor_" or "target_" to
+    # cached result
+    def method_missing(method_name, *arguments, &block)
+      if method_name.to_s =~ /(actor|target)_(?!type|id).*/
+        self.cache.try(:[], method_name.to_s)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.match /(actor|target)_.*/ || super
+    end
+
+    # TODO: Untested
+    def update_cache(cache_rule)
+      cache_rule.each do |type, type_methods|
+        type_methods.each do |method|
+          value = self.send(type).send(method)
+          self.cache["#{type}_#{method}"] = value
+        end
+      end
+      save
+    end
+
+    def actor
+      actor_type.capitalize.constantize.find(actor_id)
+    end
+
+    def target
+      target_type.capitalize.constantize.find(target_id)
+    end
+
+    def can_display?
+      display
+    end
+
+    private
+
+    def self.cache_methods
+      Rule.get_rules_set self.class.to_s
+    end
+
+    def past_form(action)
+      action.last == 'e' ?
+        "#{action}d" : "#{action}ed"
+    end
+  end
+end

data/lib/simple_activity/models/extenders.rb

@@ -0,0 +1,29 @@
+require 'active_support/concern'
+
+module SimpleActivity
+  module ModelExtenders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def acts_as_activity_actor
+        include ::SimpleActivity::ActorMethods
+      end
+
+      def acts_as_activity_target
+        include ::SimpleActivity::TargetMethods
+      end
+    end
+  end
+
+  module ActorMethods
+    def activities
+      ::Activity.actor_activities(self)
+    end
+  end
+
+  module TargetMethods
+    def activities
+      ::Activity.target_activities(self)
+    end
+  end
+end

data/lib/simple_activity/railtie.rb

@@ -0,0 +1,7 @@
+module SimpleActivity
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'simple_activity' do |_app|
+      SimpleActivity::Hooks.init
+    end
+  end
+end

data/lib/simple_activity/rule.rb

@@ -0,0 +1,31 @@
+module SimpleActivity
+  class Rule
+
+    # Get a set of rules for specific target, action, and type.
+    # The type is normally "cache". It can also be other things once
+    # needed in external libs.
+    #
+    # @param target [String] model class name as string. e.g. "Article"
+    #
+    # @param type [String] the rule type, default as "cache". or
+    #   other types defined by third parties
+    #
+    # @return set of rule when matched. Returns nil when unmatching
+    def self.get_rules_set(target, type='_cache')
+      all_rules.try(:[], target).try(:[], type)
+    end
+
+    private
+
+    def self.all_rules
+      @@_all_rules ||= load_rules
+    end
+
+    # @return rules or blank array
+    def self.load_rules
+      File.open("#{Rails.root}/app/models/activity/rules.yml") do |rules|
+        YAML.load rules || []
+      end
+    end
+  end
+end

data/lib/simple_activity/services/activity_processor.rb

@@ -0,0 +1,118 @@
+module SimpleActivity
+  class ActivityProcessor
+
+    # This class is for internal usage. No need to initialize this manually,
+    # instead use controller methods provided.
+    #
+    # When being used as automatical way in controller, e.g. as 
+    # after_filter, supply the controller
+    #
+    #   ActivityProcessor.new(self)
+    #
+    # If cache options needs to be attached, ensure the second argument
+    #
+    #   ActivityProcessor.new(self, nil, foo: 'bar')
+    #
+    # When being used manually, normally the target would be provided
+    #
+    #   ActivityProcessor.new(self, @article, foo: 'bar')
+    #
+    # @param controller [Object] The controller object, often self in controller
+    #
+    # @param target [Object] The target instance. If nil, it will be found based on
+    #        controller. 
+    #
+    #        When supplied manually, target should be free of error, aka,
+    #        after controller actiton(create, update etc) success
+    #
+    # @param reference [Hash] When required, the second arg "target" should be
+    #        there, either object or nil
+    #
+    # @return warning
+    #         If the target object has any error, the fact is it has not
+    #         passed validation yet. Return a warning in logger.
+    #
+    #         If there is any other errors say absence of current_user, warning
+    #         will also be returned from create_activity
+    #
+    # @return Valid activity object from create_activity if everything okay
+    #
+    def initialize(controller, target=nil)
+      @controller   = controller
+      @target       = target ? target : get_target
+      @target_type  = @target.class.to_s
+      @actor        = get_actor
+      @actor_type   = @actor.class.to_s
+      @action_key   = @controller.action_name
+      @cache        = get_cache
+    end
+
+    # Return nil at this level, but not at #initialize. The reason is not to
+    # throw error on `nil.create_activity`, for validation error of
+    # target is common case. SimpleActivity should let it pass.
+    def save
+      if validate_attrs
+        Activity.create(activity_attrs).tap do |activity|
+          Callbacks.run_callbacks(activity)
+        end
+      else
+        warning
+      end
+    end
+
+    def warning
+      Rails.logger.warn "SimpleActivity: failed to create activity"
+      nil
+    end
+
+    private
+
+    # Do it here but not model level because target having error is very
+    # common. Catch it so that such info could be logged.
+    def validate_attrs
+      @target.present? && !@target.errors.any? && @actor.present? && @action_key.present?
+    end
+
+    def activity_attrs
+      { actor_type:      @actor_type,
+        actor_id:        @actor.id,
+        target_type:     @target_type,
+        target_id:       @target.id,
+        action_key:      @action_key,
+        display:         true,
+        cache:           @cache
+      }
+    end
+
+    def get_target
+      @controller.instance_variable_get "@#{@controller.controller_name.singularize}" 
+    end
+
+    def get_actor
+      @controller.current_user
+    end
+
+    def get_cache
+      return nil unless cache_methods
+      set_cache
+    end
+
+    def set_cache
+      cache = {}
+      %w{actor target}.each do |type|
+        if cache_methods[type]
+          cache_methods[type].each do |method|
+            value = instance_variable_get("@#{type}").send method
+            cache["#{type}_#{method}"] = value
+          end
+        end
+      end
+      cache
+    end
+
+    def cache_methods
+      @cache_methods ||= Rule.get_rules_set(@target_type)
+    end
+
+  end
+end

data/lib/simple_activity/services/callbacks.rb

@@ -0,0 +1,45 @@
+module SimpleActivity
+  # The callback would be the module or class name.
+  # It must be responsed to `process` method with argument of
+  # activity.
+  #
+  #
+  # Add option if need to process the callback in the backend.
+  # The callback constant need to be responsible to add its own
+  # backend worker which respond to `delay` as per backend_jobs
+  # and sidekiq.
+  #
+  # @param const - the third party lib name in constant or string
+  #
+  #     SimpleActivity::Callbacks.add_callback('Foo')
+  #     SimpleActivity::Callbacks.add_callback(Foo)
+  #
+  # @option backend: true 
+  #         if true, will process the callback in backend by its own works
+  class Callbacks
+    @@callbacks = []
+
+    def self.add_callback(name, options={})
+      name = name.to_string unless name.kind_of?(String)
+      @@callbacks << {name: name}.merge!(options)
+    end
+
+    def self.run_callbacks(activity)
+      @@callbacks.each do |callback|
+        const = Object.const_get callback[:name]
+        if callback[:backend]
+          const.delay.process(activity)
+        else
+          const.process(activity)
+        end
+      end
+    end
+
+    def self.delete_callback(name)
+      @@callbacks.delete_if do |callback|
+        callback[:name] == name
+      end
+    end
+
+  end
+end

data/lib/simple_activity/version.rb

@@ -0,0 +1,3 @@
+module SimpleActivity
+  VERSION = "0.1.1"
+end

data/lib/simple_activity.rb

@@ -0,0 +1,21 @@
+module SimpleActivity
+  mattr_accessor :filtered_controllers
+  @@filtered_controllers = /(user|admin|session|registration)/i
+
+  mattr_accessor :allowed_actions
+  @@allowed_actions = [:create, :update, :destroy]
+
+  def self.setup
+    yield self
+  end
+end
+
+require 'active_support/dependencies'
+require 'simple_activity/version'
+require 'simple_activity/rule'
+require 'simple_activity/models/activity'
+require 'simple_activity/models/extenders'
+require 'simple_activity/services/activity_processor'
+require 'simple_activity/services/callbacks'
+require 'simple_activity/hooks'
+require 'simple_activity/railtie'

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: simple_activity
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Billy Chan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-highlight
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: SimpleActivity is a gem to record, display and reuse users activities
+  for Rails app, in a fast, flexible and extendable way.
+email: billychanpublic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/simple_activity/install_generator.rb
+- lib/generators/simple_activity/templates/rules.yml
+- lib/generators/simple_activity/templates/create_activity.rb
+- lib/generators/simple_activity/templates/activity.rb
+- lib/generators/simple_activity/templates/simple_activity.rb
+- lib/simple_activity/railtie.rb
+- lib/simple_activity/controller_methods.rb
+- lib/simple_activity/version.rb
+- lib/simple_activity/hooks.rb
+- lib/simple_activity/services/activity_processor.rb
+- lib/simple_activity/services/callbacks.rb
+- lib/simple_activity/rule.rb
+- lib/simple_activity/helpers.rb
+- lib/simple_activity/models/activity.rb
+- lib/simple_activity/models/extenders.rb
+- lib/simple_activity.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/billychan/simple_activity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Record, display and reuse users activities for Rails app
+test_files: []
+has_rdoc: