recognition 0.2.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Raya Social Media
+
+MIT License
+
+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,100 @@
+# Recognition
+
+A fully-fledged reward system for Rails 3.1+.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'recognition'
+
+And then execute:
+
+    $ bundle
+
+Then, you need to run the generator:
+
+    $ rails generate recogintion:install
+
+## Usage
+
+Assuming you have two models User and Post and you want to give users points for the following:
+
+5 points for registration
+7 points for adding new posts, can be earned multiple times with no limit
+2 point for deleting posts, can be earned twice
+2 points for visiting their profile, earned once
+
+app/models/user.rb:
+
+    class User < ActiveRecord::Base
+      attr_accessible :name
+      has_many :posts
+      acts_as_recognizable initial: 5
+    end
+
+app/models/post.rb:
+
+    class Post < ActiveRecord::Base
+      attr_accessible :title, :user_id
+      belongs_to :user
+      recognize :user, for: :create, gain: 7
+      recognize :user, for: :destroy, loss: 2, maximum: 4
+    end
+
+app/controllers/profiles_controller.rb:
+
+    class ProfilesController < ApplicationController
+      recognize :current_user, for: :index, amount: 6, maximum: 12
+      def index
+        @user = User.find(params[:id])
+        respond_to do |format|
+          format.html
+        end
+      end
+    end
+
+Note:
+=====
+Due to the way Ruby method aliasing work, if you need to recognize users for 
+non-ActiveRecord actions (anything that's not :create, :update and :destroy),
+make sure you add the `recognize` line *after* the method you want to 
+recognize the user for.
+
+Example:
+-------
+The following won't work:
+
+    class Post < ActiveRecord::Base
+      attr_accessible :title, :user_id
+      recognize :user, for: :foo, gain: 2
+      def foo
+        # do something useful
+      end
+    end
+
+This one will:
+
+    class Post < ActiveRecord::Base
+      attr_accessible :title, :user_id
+      def foo
+        # do something useful
+      end
+      recognize :user, for: :foo, gain: 2
+    end
+
+  
+
+## Contributing
+
+Please see CONTRIBUTING.md for details.
+
+## Credits
+recognition was originally written by Omar Abdel-Wahab.
+
+![RSM](http://rayasocialmedia.com/images/logo.png)
+
+recognition is maintained and funded by Raya Social Media.
+
+## License
+recognition is Copyright © 2013 Raya Social Media. It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/Rakefile

@@ -0,0 +1,32 @@
+#!/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    = 'Recognition'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+Bundler::GemHelper.install_tasks
+

data/lib/generators/recognition/install_generator.rb

@@ -0,0 +1,12 @@
+module Recognition
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_files
+        template "recognition.rb", "config/initializers/recognition.rb"
+        template "recognition.yml", "config/recognition.yml"
+      end
+    end
+  end
+end

data/lib/generators/recognition/templates/recognition.rb

@@ -0,0 +1,6 @@
+rails_root = Rails.root || File.dirname(__FILE__) + '/../..'
+rails_env = Rails.env || 'development'
+
+Recognition.setup do |config|
+  config.redis = YAML.load_file("#{ rails_root.to_s }/config/recognition.yml")[Rails.env.to_s]
+end

data/lib/generators/recognition/templates/recognition.yml

@@ -0,0 +1,4 @@
+development: localhost:6379
+test: localhost:6379:1
+testing: localhost:6379
+production: localhost:6379

data/lib/recognition.rb

@@ -0,0 +1,32 @@
+require "recognition/engine"
+require "recognition/version"
+require "recognition/railtie"
+require "redis"
+
+module Recognition
+  mattr_accessor :redis
+  @@redis = 'localhost:6378'
+
+  mattr_accessor :backend
+  @@backend = nil
+  
+  def self.setup
+    yield self
+  end
+  
+  def self.backend
+    if self.redis['redis://']
+      @@backend = Redis.connect(:url => self.redis, :thread_safe => true)
+    else
+      self.redis, namespace = self.redis.split('/', 2)
+      host, port, db = self.redis.split(':')
+
+      @@backend = Redis.new(
+        :host => host,
+        :port => port,
+        :db => db,
+        :thread_safe => true
+      )
+    end
+  end
+end

data/lib/recognition/action_controller_extension.rb

@@ -0,0 +1,30 @@
+require "recognition/database"
+
+module Recognition
+  module ActionControllerExtension
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_attribute :recognitions
+    end
+  
+    module ClassMethods
+      def recognize recognizable, condition
+        include InstanceMethods
+        self.recognitions ||= {}
+        self.recognitions[condition[:for]] = { recognizable: recognizable, amount: condition[:amount], maximum: condition[:maximum] || 0 }
+        after_filter :recognize_actions
+      end
+      
+    end
+    
+    module InstanceMethods
+      def recognize_actions
+        action = params[:action].to_sym
+        if self.class.recognitions.keys.include? action
+          # update_points current_user.id, action, self.class.recognitions[action][:amount]
+          Database.update_points self, action, self.class.recognitions[action]
+        end
+      end
+    end
+  end
+end

data/lib/recognition/active_record_extension.rb

@@ -0,0 +1,92 @@
+require "recognition/database"
+
+module Recognition
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_attribute :recognitions
+      base.class_attribute :recognizable
+    end
+
+    module ClassMethods #:nodoc:
+      # to be called from user-model
+      def acts_as_recognizable options = {}
+        include RecognizableInstanceMethods
+        self.recognizable = true
+        self.recognitions ||= {}
+        self.recognitions[:initial] = {
+          amount: options[:initial]
+        }
+        after_save :add_initial_points
+      end
+  
+      def recognize recognizable, condition
+        include ObjectInstanceMethods
+        self.recognitions ||= {}
+        self.recognitions[condition[:for]] = {
+          recognizable: recognizable,
+          bucket: condition[:group],
+          gain: condition[:gain],
+          loss: condition[:loss],
+          maximum: condition[:maximum]
+        }
+        # Due to the lack of ActiveRecord before_filter,
+        # we will have to alias the original method in order to intercept
+        if [:create, :update, :destroy].include? condition[:for]
+          include ActiveModel::Dirty
+        else
+          method = condition[:for]
+          define_method "#{method}_with_recognition" do |*args|
+            if self.send("#{method}_without_recognition", *args)
+              Database.update_points self, condition[:for], self.class.recognitions[condition[:for]]
+            end
+          end
+          alias_method_chain method, 'recognition'
+        end
+        # For actions that can be intercepted using ActiveRecord callbacks
+        before_destroy :recognize_destroying
+        after_save :recognize_updating 
+        # We use after_save for creation to make sure all associations
+        # have been persisted
+        after_save :recognize_creating
+      end
+    end
+
+    module RecognizableInstanceMethods #:nodoc:
+      def points
+        Database.get_user_points self.id
+      end
+  
+      def recognition_counter bucket
+        Database.get_user_counter self.id, bucket
+      end
+  
+      def add_initial_points
+        Database.update_points self, :initial, self.class.recognitions[:initial]
+      end
+
+      def update_points amount, bucket
+        Database.log(self.id, amount.to_i, bucket)
+      end
+    end
+    
+    module ObjectInstanceMethods #:nodoc:
+      def recognize_creating
+        if self.id_changed? # Unless we are creating
+          Database.update_points self, :create, self.class.recognitions[:create] unless self.class.recognitions[:create].nil?
+        end
+      end
+  
+      def recognize_updating
+        unless self.id_changed? # Unless we are creating
+          Database.update_points self, :update, self.class.recognitions[:update] unless self.class.recognitions[:update].nil?
+        end
+      end
+  
+      def recognize_destroying
+        Database.update_points self, :destroy, self.class.recognitions[:destroy] unless self.class.recognitions[:destroy].nil?
+      end
+  
+    end
+  end
+end

data/lib/recognition/backend.rb

@@ -0,0 +1,10 @@
+module Recognition
+  class Backend
+    attr_reader :store
+    
+    def initialize(store)
+      @store = store
+    end
+    
+  end
+end

data/lib/recognition/condition.rb

@@ -0,0 +1,12 @@
+module Recognition
+  module Condition
+    def parse opts
+      {
+        opts[:for] => {
+          recognizable: nil,
+          amount: options[:initial]
+        }
+      }
+    end
+  end
+end

data/lib/recognition/database.rb

@@ -0,0 +1,97 @@
+require "recognition/transaction"
+
+module Recognition
+  module Database
+    def self.log id, amount, bucket
+      hash = Time.now.to_f.to_s
+      Recognition.backend.multi do
+        # Recognition.backend.incrby "recognition:user:#{ id }:points", amount
+        Recognition.backend.hincrby "recognition:user:#{ id }:counters", 'points', amount
+        Recognition.backend.hincrby "recognition:user:#{ id }:counters", bucket, amount
+        Recognition.backend.zadd "recognition:user:#{ id }:transactions", hash, { hash: hash, amount: amount, bucket: bucket, datetime: DateTime.now.to_s }.to_json
+        Recognition.backend.zadd 'recognition:transactions', hash, { hash: hash, id: id, amount: amount, bucket: bucket, datetime: DateTime.now.to_s }.to_json
+      end
+    end
+    
+    def self.record transaction
+      unless transaction.class.to_s == Recognition::Transaction
+        raise ArgumentError, 'parameter should be of type Recognition::Transaction'
+      end
+      hash = Time.now.to_f.to_s
+      Recognition.backend.multi do
+        # Recognition.backend.incrby "recognition:user:#{ id }:points", amount
+        Recognition.backend.hincrby "recognition:user:#{ id }:counters", 'points', transactions.amount
+        Recognition.backend.hincrby "recognition:user:#{ id }:counters", transactions.bucket, transactions.amount
+        Recognition.backend.zadd "recognition:user:#{ id }:transactions", hash, { amount: transactions.amount, bucket: transactions.bucket, datetime: DateTime.now.to_s }.to_json
+        Recognition.backend.zadd 'recognition:transactions', hash, { id: id, amount: transactions.amount, bucket: transactions.bucket, datetime: DateTime.now.to_s }.to_json
+      end
+    end
+    
+    def self.get key
+      Recognition.backend.get key
+    end
+    
+    def self.get_user_points id
+      get_user_counter id, 'points'
+    end
+    
+    def self.get_user_counter id, counter
+      counter = Recognition.backend.hget("recognition:user:#{ id }:counters", counter)
+      counter.to_i
+    end
+    
+    
+    def self.update_points object, action, condition
+      if condition[:bucket].nil?
+        bucket = "#{ object.class.to_s.camelize }:#{ action }"
+      else
+        bucket = condition[:bucket]
+      end
+      user = parse_user(object, condition)
+      if condition[:amount].nil? && condition[:gain].nil? && condition[:loss].nil?
+        false
+      else
+        total = parse_amount(condition[:amount], object) + parse_amount(condition[:gain], object) - parse_amount(condition[:loss], object)
+        ground_total = user.recognition_counter(bucket) + total
+        if condition[:maximum].nil? || ground_total <= condition[:maximum]
+          Database.log(user.id, total.to_i, bucket)
+        end
+      end
+    end
+    
+    def self.parse_user object, condition
+      if condition[:recognizable].nil?
+        user = object
+      else
+        case condition[:recognizable].class.to_s
+        when 'Symbol'
+          user = object.send(condition[:recognizable])
+        when 'String'
+          user = object.send(condition[:recognizable].to_sym)
+        when 'Proc'
+          user = object.call(condition[:proc_params])
+        else
+          user = condition[:recognizable]
+        end
+      end
+      user
+    end
+    
+    def self.parse_amount amount, object
+      case amount.class.to_s
+      when 'Integer'
+      when 'Fixnum'
+        value = amount
+      when 'Symbol'
+        value = object.send(amount)
+      when 'Proc'
+        value = amount.call(object)
+      when 'NilClass'
+        # Do not complain about nil amounts
+      else
+        raise ArgumentError, "type mismatch for amount: expecting 'Integer', 'Fixnum', 'Symbol' or 'Proc' but got '#{ amount.class.to_s }' instead."
+      end
+      value || 0
+    end
+  end
+end

data/lib/recognition/engine.rb

@@ -0,0 +1,10 @@
+module Recognition
+  class Engine < ::Rails::Engine
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/recognition/railtie.rb

@@ -0,0 +1,21 @@
+require "recognition/active_record_extension"
+require "recognition/action_controller_extension"
+require "rails"
+
+module Recognition
+  class Railtie < Rails::Railtie
+    initializer 'recognition.initialize' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.send :include, ActiveRecordExtension
+      end
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.send(:include, ActionControllerExtension)
+      end
+    end
+    # 
+    # initializer 'recognition.database' do
+    #   #TODO: use a Rails initializer
+    #   $REDIS = Redis.new #(host: 'localhost', port: redis_config[:port])
+    # end
+  end
+end

data/lib/recognition/transaction.rb

@@ -0,0 +1,11 @@
+module Recognition
+  class Transaction
+    attr_accessor :id, :gain, :loss, :bucket
+    
+    def create *args
+      args.each do |key, val|
+        self.new
+      end
+    end
+  end
+end

data/lib/recognition/version.rb

@@ -0,0 +1,3 @@
+module Recognition
+  VERSION = "0.2.0"
+end

data/lib/tasks/recognition_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :recognition do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: recognition
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Omar Abdel-Wahab
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Recognize users by giving them points and rewards for their actions
+email:
+- owahab@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/recognition/install_generator.rb
+- lib/generators/recognition/templates/recognition.rb
+- lib/generators/recognition/templates/recognition.yml
+- lib/recognition/action_controller_extension.rb
+- lib/recognition/active_record_extension.rb
+- lib/recognition/backend.rb
+- lib/recognition/condition.rb
+- lib/recognition/database.rb
+- lib/recognition/engine.rb
+- lib/recognition/railtie.rb
+- lib/recognition/transaction.rb
+- lib/recognition/version.rb
+- lib/recognition.rb
+- lib/tasks/recognition_tasks.rake
+- LICENSE.txt
+- Rakefile
+- README.md
+homepage: http://github.com/owahab/recognition
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -334073944928313035
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -334073944928313035
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Recognize users by giving them points and rewards for their actions
+test_files: []