recognition 0.3.8 → 0.4.0

data/README.md

@@ -1,17 +1,18 @@
 # Recognition
+[![Build Status](https://travis-ci.org/rayasocialmedia/recognition.png?branch=master)](https://travis-ci.org/rayasocialmedia/recognition)
 
 A fully-fledged reward system for Rails 3.1+.
 
 ## Features
 
-*  Reward users with points for any model method or ActiveRecord CRUD operation.
+*  Reward users with points for any model method, ActiveRecord crud or even controller methods.
 *  Create vouchers that users can redeem for points.
 
 ## Links
 
 *  [Installation](#Installation)
-*  [Usage](#Usage)
-*  [Examples](#Examples)
+*  [Usage](#usage)
+*  [Examples](#example)
 *  [Wiki](https://github.com/rayasocialmedia/recognition/wiki)
 *  [Code Documentation](http://rubydoc.info/gems/recognition/frames)
 *  [Changelog](https://raw.github.com/rayasocialmedia/recognition/master/CHANGELOG.txt)

data/lib/recognition.rb

@@ -1,9 +1,12 @@
-require "recognition/engine"
 require "recognition/version"
-require "recognition/railtie"
+require "recognition/logger"
+require "recognition/rails/engine"
+require "recognition/rails/railtie"
 require "redis"
 
 module Recognition
+  extend Recognition::Logger
+  
   mattr_accessor :redis
   # Redis Db connection parameters
   @@redis = 'localhost:6378'

data/lib/recognition/controllers/recognizer.rb

@@ -0,0 +1,13 @@
+module Recognition
+  module Controllers
+    module Recognizer
+      def recognize_actions
+        action = params[:action].to_sym
+        self.class.recognitions[action][:proc_params] = params
+        if self.class.recognitions.keys.include? action
+          Recognition::Database.update_points self, action, self.class.recognitions[action]
+        end
+      end
+    end
+  end
+end

data/lib/recognition/database.rb

@@ -1,98 +1,54 @@
-require "recognition/transaction"
+require 'recognition/parser'
 
 module Recognition
   # Handle all Transactions and logging to Redis
   module Database
     def self.log id, amount, bucket, code = nil
       hash = Time.now.to_f.to_s
+      Recognition.log :transaction, "hash:'#{hash}' user:'#{id}' amount:'#{amount}' bucket:'#{bucket}'"
       Recognition.backend.multi do
         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
         unless code.nil?
-          Recognition.backend.zadd "recognition:voucher:#{ code }:transactions", hash, { hash: hash, id: id, bucket: bucket, datetime: DateTime.now.to_s }.to_json
+          Recognition.backend.zadd "recognition:#{ code[:type] }:#{ code[:code] }:transactions", hash, { hash: hash, id: id, bucket: bucket, datetime: DateTime.now.to_s }.to_json
         end
       end
     end
     
     def self.get key
-      Recognition.backend.get key
+      Recognition.backend.get "recognition:#{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.get_user_transactions id, page = 0, per = 20
-      start = page * per 
-      stop = (1 + page) * per 
-      keypart = "user:#{ id }"
-      self.get_transactions keypart, start, stop
-    end
-    
-    def self.get_voucher_transactions code, page = 0, per = 20
-      start = page * per
-      stop = (1 + page) * per 
-      keypart = "voucher:#{ code }"
-      self.get_transactions keypart, start, stop
+    def self.get_counter hash, key
+      Recognition.backend.hget("recognition:#{hash}", key).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)
+      Recognition.log 'foo', condition.to_s
+      condition[:bucket] ||= "#{ object.class.to_s.camelize }:#{ action }"
+      user = Recognition::Parser.parse_recognizable(object, condition[:recognizable], condition[:proc_params])
       if condition[:amount].nil? && condition[:gain].nil? && condition[:loss].nil?
+        Recognition.log 'validation', "Unable to determine points: no 'amount', 'gain' or 'loss' specified"
         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
+        total = Recognition::Parser.parse_amount(condition[:amount], object, condition[:proc_params]) + Recognition::Parser.parse_amount(condition[:gain], object, condition[:proc_params]) - Recognition::Parser.parse_amount(condition[:loss], object, condition[:proc_params])
+        ground_total = user.recognition_counter(condition[:bucket]) + total
         if condition[:maximum].nil? || ground_total <= condition[:maximum]
-          Database.log(user.id, total.to_i, bucket)
+          log(user.id, total.to_i, condition[:bucket])
+        else
+          Recognition.log 'validation', "Unable to add points: bucket maximum reached for bucket '#{condition[:bucket]}'"
         end
       end
     end
     
-    def self.redeem_voucher id, code, amount
-      bucket = "Voucher:redeem##{ code }"
-      Database.log(id, amount.to_i, bucket, code)
-    end
-    
-    def self.get_user_voucher id, code
-      bucket = "Voucher:redeem##{ code }"
-      Database.get_user_counter id, bucket
-    end
-    
-    def self.parse_voucher_part part, object
-      case part.class.to_s
-      when 'String'
-        value = part
-      when 'Integer'
-        value = part.to_s
-      when 'Fixnum'
-        value = part.to_s
-      when 'Symbol'
-        value = object.send(part).to_s
-      when 'Proc'
-        value = part.call(object).to_s
-      when 'NilClass'
-        # Do not complain about nil amounts
-      else
-        raise ArgumentError, "type mismatch for voucher part: expecting 'Integer', 'Fixnum', 'Symbol' or 'Proc' but got '#{ amount.class.to_s }' instead."
-      end
-      value || ''
+    def self.redeem id, bucket, type, code, value
+      certificate = { type: type, code: code }
+      Recognition.log type, "redeeming #{type}:#{code} for user: #{id}"
+      log id, value, bucket, certificate
     end
     
-    private
-    
     def self.get_transactions keypart, start, stop
       transactions = []
       range = Recognition.backend.zrange "recognition:#{ keypart }:transactions", start, stop
@@ -101,41 +57,5 @@ module Recognition
       end
       transactions
     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'
-        value = amount
-      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/extensions/action_controller.rb

@@ -0,0 +1,21 @@
+module Recognition
+  module Extensions
+    # Extending ActionController
+    module ActionController
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_attribute :recognitions
+      end
+  
+      module ClassMethods
+        def recognize recognizable, condition
+          require "recognition/controllers/recognizer"
+          include Recognition::Controllers::Recognizer
+          self.recognitions ||= {}
+          self.recognitions[condition[:for]] = { recognizable: recognizable, amount: condition[:amount], gain: condition[:gain], loss: condition[:loss], maximum: condition[:maximum] }
+          after_filter :recognize_actions
+        end
+      end
+    end
+  end
+end

data/lib/recognition/extensions/active_record.rb

@@ -0,0 +1,72 @@
+module Recognition
+  module Extensions
+    module ActiveRecord
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_attribute :recognitions
+        base.class_attribute :recognizable
+      end
+
+      module ClassMethods
+        # to be called from user model
+        def acts_as_recognizable options = {}
+          require "recognition/models/recognizable"
+          include Recognition::Models::Recognizable
+          self.recognizable = true
+          self.recognitions ||= {}
+          self.recognitions[:initial] = {
+            amount: options[:initial]
+          }
+          after_save :add_initial_points
+        end
+  
+        # to be called from other models
+        def recognize recognizable, condition
+          require "recognition/models/recognizer"
+          include Recognition::Models::Recognizer
+          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)
+                Recognition::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
+
+        # to be called from user-model
+        def acts_as_voucher options = {}
+          require "recognition/models/voucher"
+          include Recognition::Models::Voucher
+          self.recognitions = options
+          cattr_accessor :voucher_validators
+          def self.validates_voucher_redmeption validators
+            self.voucher_validators ||= []
+            self.voucher_validators << validators
+            self.voucher_validators.flatten!
+          end
+          before_create :regenerate_code
+        end
+      end
+    end
+  end
+end

data/lib/recognition/logger.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+module Recognition
+  module Logger
+    def log key, message
+      logger.info("[recognition] [#{key}] #{message}") if logging?
+    end
+
+    def logger #:nodoc:
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logging? #:nodoc:
+      # TODO: Add an option to toggle logging
+      false
+    end
+  end
+end

data/lib/recognition/{activerecord/voucher.rb → models/gift.rb}

@@ -1,9 +1,9 @@
 module Recognition
-  module ActiveRecord
-    module Voucher
+  module Models
+    module Gift
       def regenerate_code
-        prefix = Recognition::Database.parse_voucher_part(self.class.recognitions[:prefix], self)
-        suffix = Recognition::Database.parse_voucher_part(self.class.recognitions[:suffix], self)
+        prefix = Recognition::Database.parse_code_part(self.class.recognitions[:prefix], self)
+        suffix = Recognition::Database.parse_code_part(self.class.recognitions[:suffix], self)
         l = (self.class.recognitions[:code_length] - (prefix.length + suffix.length)) || 10
         dict = [('a'..'z'),('A'..'Z'),(0..9)].map{|i| i.to_a}.flatten
         code = (1..l).map{ dict[rand(dict.length)] }.prepend(prefix).append(suffix).join
@@ -21,14 +21,14 @@ module Recognition
         if defined? self.amount
           if self.redeemable? recognizable
             # Call custom validators
-            if defined? self.class.voucher_validators
-              self.class.voucher_validators.each do |validator|
+            if defined? self.class.gift_validators
+              self.class.gift_validators.each do |validator|
                 # quit if any validator returned false
                 return if send(validator) == false
               end
             end
             # If all went well:
-            Database.redeem_voucher recognizable.id, self.code, self.amount
+            Database.redeem_gift recognizable.id, self.code, self.amount
           end
         end
       end
@@ -36,14 +36,14 @@ module Recognition
       def redeemable? recognizable
         # default: not redeemable
         pass = false
-        # only check if the voucher did not expire
+        # only check if the gift did not expire
         unless expired?
-          # has the voucher ever been redeemed?
-          if Database.get_voucher_transactions(self.code).any?
-            # has the voucher ever been redeemed by this user?
-            if Database.get_user_voucher(recognizable.id, code) != 0
+          # has the gift ever been redeemed?
+          if Database.get_gift_transactions(self.code).any?
+            # has the gift ever been redeemed by this user?
+            if Database.get_user_gift(recognizable.id, code) != 0
               pass = false
-              # is the voucher reusable?
+              # is the gift reusable?
             elsif defined?(self.reusable?) && self.reusable?
               pass = true
             end
@@ -57,6 +57,9 @@ module Recognition
       def expired?
         defined?(self.expires_at) && self.expires_at.present? && self.expires_at < DateTime.now
       end
+      
+      private
+      
     end
   end
 end

data/lib/recognition/models/recognizable.rb

@@ -0,0 +1,31 @@
+module Recognition
+  module Models
+    module Recognizable
+      # Determine user current balance of points
+      def points
+        recognition_counter 'points'
+      end
+
+      def recognition_counter bucket
+        Recognition::Database.get_counter "user:#{ self.id }:counters", bucket
+      end
+
+      def add_initial_points
+        amount = self.class.recognitions[:initial][:amount]
+        update_points amount, :initial
+      end
+
+      def update_points amount, bucket
+        require 'recognition/database'
+        Recognition::Database.log(self.id, amount.to_i, bucket)
+      end
+  
+      def transactions page = 0, per = 20
+        start = page * per 
+        stop = (1 + page) * per 
+        keypart = "user:#{ self.id }"
+        Recognition::Database.get_transactions keypart, start, stop
+      end
+    end
+  end
+end

data/lib/recognition/{activerecord/model.rb → models/recognizer.rb}

@@ -1,6 +1,6 @@
 module Recognition
-  module ActiveRecord
-    module Model
+  module Models
+    module Recognizer
       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?

data/lib/recognition/models/voucher.rb

@@ -0,0 +1,82 @@
+module Recognition
+  module Models
+    module Voucher
+      def regenerate_code
+        prefix = Recognition::Parser.parse_code_part(self.class.recognitions[:prefix], self)
+        suffix = Recognition::Parser.parse_code_part(self.class.recognitions[:suffix], self)
+        l = (self.class.recognitions[:code_length] - (prefix.length + suffix.length)) || 10
+        dict = [('a'..'z'),('A'..'Z'),(0..9)].map{|i| i.to_a}.flatten
+        code = (1..l).map{ dict[rand(dict.length)] }.prepend(prefix).append(suffix).join
+        # Prevent code collision at all costs
+        if self.class.to_s.constantize.find_all_by_code(code).any?
+          regenerate_code
+        else
+          self.code = code
+          self
+        end
+      end
+    
+      def redeem recognizable
+        # Make sure we have an amount beforehand
+        if defined? self.amount
+          if self.redeemable? recognizable
+            # Call custom validators
+            if defined? self.class.voucher_validators
+              self.class.voucher_validators.each do |validator|
+                # quit if any validator returned false
+                if send(validator) == false
+                  Recognition.log :voucher, "validation error for voucher:#{self.id}"
+                  return
+                end
+              end
+            end
+            # If all went well:
+            Recognition::Database.redeem recognizable.id, bucket, 'voucher', self.code, amount.to_i
+          end
+        end
+      end
+    
+      def redeemable? recognizable
+        # default: not redeemable
+        pass = false
+        # only check if the voucher did not expire
+        unless expired?
+          # has the voucher ever been redeemed?
+          if transactions.any?
+            # has the voucher ever been redeemed by this user?
+            if get_user_voucher(recognizable.id) != 0
+              pass = false
+              # is the voucher reusable?
+            elsif defined?(self.reusable?) && self.reusable?
+              pass = true
+            end
+          else
+            pass = true
+          end
+        end
+        pass
+      end
+      
+      def expired?
+        defined?(self.expires_at) && self.expires_at.present? && self.expires_at < DateTime.now
+      end
+      
+      private
+      
+      def bucket
+        "voucher:#{ self.code }"
+      end
+      
+      def get_user_voucher id
+        Recognition::Database.get_counter "user:#{id}", bucket
+      end
+      
+      def transactions page = 0, per = 20
+        start = page * per
+        stop = (1 + page) * per 
+        Recognition::Database.get_transactions bucket, start, stop
+      end
+    
+    end
+  end
+end

data/lib/recognition/parser.rb

@@ -0,0 +1,62 @@
+module Recognition
+  module Parser
+    def self.parse_recognizable object, recognizable, proc_params = nil
+      if recognizable.nil?
+        user = object
+      else
+        case recognizable.class.to_s
+        when 'Symbol'
+          user = object.send(recognizable)
+        when 'String'
+          user = object.send(recognizable.to_sym)
+        when 'Proc'
+          params = proc_params || object
+          user = recognizable.call(params)
+        else
+          user = recognizable
+        end
+      end
+      user
+    end
+    
+    def self.parse_amount amount, object, proc_params = nil
+      case amount.class.to_s
+      when 'Integer'
+        value = amount
+      when 'Fixnum'
+        value = amount
+      when 'Symbol'
+        value = object.send(amount)
+      when 'Proc'
+        params = proc_params || object
+        value = amount.call(params)
+      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
+    
+    def self.parse_code_part part, object
+      case part.class.to_s
+      when 'String'
+        value = part
+      when 'Integer'
+        value = part.to_s
+      when 'Fixnum'
+        value = part.to_s
+      when 'Symbol'
+        value = object.send(part).to_s
+      when 'Proc'
+        value = part.call(object).to_s
+      when 'NilClass'
+        # Do not complain about nil amounts
+      else
+        raise ArgumentError, "type mismatch for voucher part: expecting 'Integer', 'Fixnum', 'Symbol' or 'Proc' but got '#{ amount.class.to_s }' instead."
+      end
+      value || ''
+    end
+    
+  end
+end

data/lib/recognition/rails/engine.rb

@@ -0,0 +1,12 @@
+module Recognition
+  module Rails
+    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
+end

data/lib/recognition/rails/railtie.rb

@@ -0,0 +1,16 @@
+require "recognition/extensions/active_record"
+require "recognition/extensions/action_controller"
+require "rails"
+
+module Recognition
+  class Railtie < ::Rails::Railtie
+    initializer 'recognition.initialize' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.send :include, Recognition::Extensions::ActiveRecord
+      end
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.send(:include, Recognition::Extensions::ActionController)
+      end
+    end
+  end
+end

data/lib/recognition/version.rb

@@ -1,4 +1,4 @@
 module Recognition
   # Current Version
-  VERSION = "0.3.8"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recognition
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-23 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -150,17 +150,19 @@ files:
 - lib/generators/recognition/templates/recognition.rb
 - lib/generators/recognition/templates/recognition.yml
 - lib/generators/recognition/voucher_generator.rb
-- lib/recognition/action_controller_extension.rb
-- lib/recognition/active_record_extension.rb
-- lib/recognition/activerecord/model.rb
-- lib/recognition/activerecord/recognizable.rb
-- lib/recognition/activerecord/voucher.rb
 - lib/recognition/backend.rb
-- lib/recognition/condition.rb
+- lib/recognition/controllers/recognizer.rb
 - lib/recognition/database.rb
-- lib/recognition/engine.rb
-- lib/recognition/railtie.rb
-- lib/recognition/transaction.rb
+- lib/recognition/extensions/action_controller.rb
+- lib/recognition/extensions/active_record.rb
+- lib/recognition/logger.rb
+- lib/recognition/models/gift.rb
+- lib/recognition/models/recognizable.rb
+- lib/recognition/models/recognizer.rb
+- lib/recognition/models/voucher.rb
+- lib/recognition/parser.rb
+- lib/recognition/rails/engine.rb
+- lib/recognition/rails/railtie.rb
 - lib/recognition/version.rb
 - lib/recognition.rb
 - lib/tasks/recognition_tasks.rake
@@ -181,7 +183,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1363284435597105623
+      hash: -4080240542959513995
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -190,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1363284435597105623
+      hash: -4080240542959513995
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23

data/lib/recognition/action_controller_extension.rb

@@ -1,31 +0,0 @@
-require "recognition/database"
-
-module Recognition
-  # Extending ActiveRecord
-  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

@@ -1,72 +0,0 @@
-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
-      # to be called from user model
-      def acts_as_recognizable options = {}
-        require "recognition/activerecord/recognizable"
-        include Recognition::ActiveRecord::Recognizable
-        self.recognizable = true
-        self.recognitions ||= {}
-        self.recognitions[:initial] = {
-          amount: options[:initial]
-        }
-        after_save :add_initial_points
-      end
-  
-      # to be called from other models
-      def recognize recognizable, condition
-        require "recognition/activerecord/model"
-        include Recognition::ActiveRecord::Model
-        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
-
-      # to be called from user-model
-      def acts_as_voucher options = {}
-        require "recognition/activerecord/voucher"
-        include Recognition::ActiveRecord::Voucher
-        self.recognitions = options
-        cattr_accessor :voucher_validators
-        def self.validates_voucher_redmeption validators
-          self.voucher_validators ||= []
-          self.voucher_validators << validators
-          self.voucher_validators.flatten!
-        end
-        before_create :regenerate_code
-      end
-    end
-  end
-end

data/lib/recognition/activerecord/recognizable.rb

@@ -1,26 +0,0 @@
-module Recognition
-  module ActiveRecord
-    module Recognizable
-      # Determine user current balance of points
-      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
-  
-      def transactions page = 0, per = 20
-        Database.get_user_transactions self.id, page, per
-      end
-    end
-  end
-end

data/lib/recognition/condition.rb

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

data/lib/recognition/engine.rb

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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