honor 1.0.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/*.log
+spec/config/database.yml
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## v1.0.1
+
+* Initial Release
+* Points
+* Scorecards

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in honor.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jeremy Ward
+
+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,155 @@
+# Honor
+
+Honor adds support for common gamification features such as points, leaderboards, and achievements.
+
+## Overview
+
+Honor allows you to easily integrate points, rankings, and leaderboards into your Rails application.
+
+## Installation
+
+To use Honor, first add it to you Gemfile:
+
+```ruby
+ gem 'honor'
+```
+
+And then intall it with bundler by executing:
+
+```shell
+bundle install
+```
+
+Install and run the migrations:
+
+```shell
+rails g honor:install
+rails db:migrate
+```
+
+## Usage
+
+Honor is meant to be used with a **single model** (eg. User, Employee, Person, Company, etc). At this time, using Honor with multiple models is NOT supported.
+
+```ruby
+class User < ActiveRecord::Base
+  include Honor
+end
+```
+
+Honor adds two new relationships to the receiving model.
+
+1. `has_many :points`
+2. `has_one :scorecard`
+
+### Points
+
+Points are generally awarded for various User interactions throughout an application. Honor gives you the ability to provide a message as well as a classification to each point block awarded.
+
+```ruby
+class User < ActiveRecord::Base
+  include Honor
+end
+
+@user = User.new
+
+# add points to a user
+@user.add_points(25)
+
+# add points to a user with a bit more description
+@user.add_points(25, "Awarded for some awesome action", "Social")
+
+# subtract points to a user
+@user.subtract_points(25)
+
+# subtract points to a user with a bit more description
+@user.subtract_points(25, "Awarded for some awesome action", "Social")
+
+# Quick Accessors for commone point totals
+@user.points_total
+@user.points_today
+@user.points_this_week
+@user.points_this_month
+@user.points_this_year
+
+# If you're fastidious about keeping business logic categories semantic (same case, same spelling, etc), then you can easily total points for a given point category by passing a string representing the category into any of the accessors above:
+@user.points_total("Social") # => returns total for points with a category matcing "Social"
+
+```
+
+There's bond to be situations where you don't have or don't want to instantiate a new "honorable" object (User in the above example), but have access to the User's id....Honorable has you covered. In these cases, Honorable provides class methods similar to the above:
+
+```ruby
+# example user id, could come from an array or whatever
+user_id = 1
+
+# add points to a user
+Honor::Point.give_to(user_id, 25)
+
+# add points to a user with a bit more description
+Honor::Point.give_to(user_id, 25, "Awarded for some awesome action", "Social")
+
+# subtract points to a user
+Honor::Point.take_from(user_id, 25)
+
+# subtract points to a user with a bit more description
+Honor::Point.take_from(user_id, 25, "Awarded for some awesome action", "Social")
+
+
+# Quick Accessors for commone point totals (does NOT accept a category at this time)
+Honor::Point.points_total
+Honor::Point.points_today
+Honor::Point.points_this_week
+Honor::Point.points_this_month
+Honor::Point.points_this_year
+
+```
+
+### Scorecards
+
+Every "honorable" object (User in the above examples) has one scorecard that is continually updated whenever a point record is saved. Scorecards keep a running tally of points for:
+
+1. daily
+2. weekly
+3. monthly
+4. yearly
+5. lifetime
+
+From these subsets you can quickly and easily make Ranked Leaderboards that complies with the Standard Competition Ranking system. That is, it takes tied positions into account and adjusts ranks accordingly.
+
+```ruby
+user_ids = current_user.friend_ids_and_me # => an array of user_ids (eg. [1, 5, 2, 23])
+@daily_leaderboard    = Honor::Scorecard.leaderboard(user_ids, rank_by: 'daily', sort_direction: 'desc')
+@weekly_leaderboard   = Honor::Scorecard.leaderboard(user_ids, rank_by: 'weekly', sort_direction: 'desc')
+@monthly_leaderboard  = Honor::Scorecard.leaderboard(user_ids, rank_by: 'monthly', sort_direction: 'desc')
+@yearly_leaderboard   = Honor::Scorecard.leaderboard(user_ids, rank_by: 'yearly', sort_direction: 'desc')
+```
+
+Honor provides the Scorecards class with some utility methods useful for setting cron jobs to automate cleaning-up the scorecards.
+
+```ruby
+Honor::Scorecard.reset_daily_scores
+Honor::Scorecard.reset_weekly_scores
+Honor::Scorecard.reset_monthly_scores
+Honor::Scorecard.reset_yearly_scores
+```
+
+## Testing
+
+Honor uses RSpec for its test coverage. Inside the gem directory, you can run the specs with:
+
+```shell
+rake
+```
+
+## TODO
+
+- Add Badges / Achievement functionality
+
+## Contributing
+
+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

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/honor.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'honor/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "honor"
+  gem.version       = Honor::VERSION
+  gem.authors       = ["Jeremy Ward"]
+  gem.email         = ["jrmy.ward@gmail.com"]
+  gem.description   = %q{Adds support for common gamification features such as points, leaderboards, and achievements.}
+  gem.summary       = %q{General gamification-centric reputation system for Rails Applications.}
+  gem.homepage      = "https://github.com/jrmyward/honor"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'rails', '~> 3.0'
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency 'ammeter'
+  gem.add_development_dependency "supermodel"
+  gem.add_development_dependency "database_cleaner"
+  gem.add_development_dependency "timecop"
+end

data/lib/generators/install_generator.rb

@@ -0,0 +1,40 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/migration'
+
+module Honor
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for Points and Scorecard"
+
+    def self.orm
+      Rails::Generators.options[:rails][:orm]
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        migration_number += 1
+        migration_number.to_s
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'create_points.rb', 'db/migrate/create_honor_points.rb'
+        migration_template 'create_scorecards.rb', 'db/migrate/create_honor_scorecards.rb'
+      end
+    end
+  end
+end

data/lib/generators/templates/active_record/create_points.rb

@@ -0,0 +1,13 @@
+class CreateHonorPointsMigration < ActiveRecord::Migration
+  def change
+    create_table :points do |t|
+      t.integer :user_id
+      t.integer :value
+      t.string :category
+      t.text :message
+
+      t.timestamps
+    end
+    add_index :points, :user_id
+  end
+end

data/lib/generators/templates/active_record/create_scorecards.rb

@@ -0,0 +1,15 @@
+class CreateHonorScorecardsMigration < ActiveRecord::Migration
+  def change
+    create_table :scorecards do |t|
+      t.integer :user_id
+      t.integer :daily
+      t.integer :weekly
+      t.integer :monthly
+      t.integer :yearly
+      t.integer :lifetime
+
+      t.timestamps
+    end
+    add_index :scorecards, :user_id
+  end
+end

data/lib/honor.rb

@@ -0,0 +1,25 @@
+require "active_record"
+require "active_record/version"
+require "honor/version"
+require "honor/model_additions"
+require "honor/point"
+require "honor/scorecard"
+
+module Honor
+
+  def self.included(receiver)
+    receiver.class_eval %Q{
+      has_many :points, :class_name => "Honor::Point", :foreign_key => "user_id", :dependent => :destroy
+      has_one :scorecard, :class_name => "Honor::Scorecard", :foreign_key => "user_id", :dependent => :destroy
+    }
+
+    Honor::Point.class_eval %Q{
+      belongs_to :#{receiver.to_s.underscore}, :class_name => "#{receiver.to_s}", :foreign_key => "user_id"
+    }
+
+    Honor::Scorecard.class_eval %Q{
+      belongs_to :#{receiver.to_s.underscore}, :class_name => "#{receiver.to_s}", :foreign_key => "user_id"
+    }
+  end
+
+end

data/lib/honor/model_additions.rb

@@ -0,0 +1,51 @@
+module Honor
+  extend ActiveSupport::Concern
+
+  def add_points(number_of_points, message = "Manually granted through 'add_points'", category = 'default' )
+    points.create!({value: number_of_points, message: message, category: category})
+  end
+
+  def subtract_points(number_of_points, message = "Manually granted through 'add_points'", category = 'default' )
+    add_points -number_of_points, message, category
+  end
+
+  def points_total(category = nil)
+    if category.nil?
+      points.sum(:value)
+    else
+      points.where("points.category = ?", category).sum(:value)
+    end
+  end
+
+  def points_today(category = nil)
+    if category.nil?
+      points.where(:created_at => Time.zone.now.beginning_of_day..Time.zone.now.end_of_day).sum(:value)
+    else
+      points.where(:created_at => Time.zone.now.beginning_of_day..Time.zone.now.end_of_day).where("points.category = ?", category).sum(:value)
+    end
+  end
+
+  def points_this_week(category = nil)
+    if category.nil?
+      points.where(:created_at => Time.zone.now.beginning_of_week..Time.zone.now.end_of_week).sum(:value)
+    else
+      points.where(:created_at => Time.zone.now.beginning_of_week..Time.zone.now.end_of_week).where("points.category = ?", category).sum(:value)
+    end
+  end
+
+  def points_this_month(category = nil)
+    if category.nil?
+      points.where(:created_at => Time.zone.now.beginning_of_month..Time.zone.now.end_of_month).sum(:value)
+    else
+      points.where(:created_at => Time.zone.now.beginning_of_month..Time.zone.now.end_of_month).where("points.category = ?", category).sum(:value)
+    end
+  end
+
+  def points_this_year(category = nil)
+    if category.nil?
+      points.where(:created_at => Time.zone.now.beginning_of_year..Time.zone.now.end_of_year).sum(:value)
+    else
+      points.where(:created_at => Time.zone.now.beginning_of_year..Time.zone.now.end_of_year).where("points.category = ?", category).sum(:value)
+    end
+  end
+end

data/lib/honor/point.rb

@@ -0,0 +1,51 @@
+module Honor
+  class Point < ActiveRecord::Base
+    attr_accessible :category, :message, :user_id, :value
+
+    after_save :update_scorecard
+
+    class << self
+      def give_to(user_id, number_of_points, message = "Manually granted through 'add_points'", category = 'default')
+        create!({user_id: user_id, value: number_of_points, message: message, category: category})
+      end
+
+      def take_from(user_id, number_of_points, message = "Manually granted through 'add_points'", category = 'default')
+        give_to user_id, -number_of_points, message, category
+      end
+
+      def user_points_total(user_id)
+        where(:user_id => user_id).sum(:value)
+      end
+
+      def user_points_today(user_id)
+        where(:user_id => user_id).where(:created_at => Time.zone.now.beginning_of_day..Time.zone.now.end_of_day).sum(:value)
+      end
+
+      def user_points_this_week(user_id)
+        where(:user_id => user_id).where(:created_at => Time.zone.now.beginning_of_week..Time.zone.now.end_of_week).sum(:value)
+      end
+
+      def user_points_this_month(user_id)
+        where(:user_id => user_id).where(:created_at => Time.zone.now.beginning_of_month..Time.zone.now.end_of_month).sum(:value)
+      end
+
+      def user_points_this_year(user_id)
+        where(:user_id => user_id).where(:created_at => Time.zone.now.beginning_of_year..Time.zone.now.end_of_year).sum(:value)
+      end
+
+    end
+
+    private
+
+    def update_scorecard
+      scorecard = Honor::Scorecard.find_or_initialize_by_user_id(user_id)
+      scorecard.daily     = Honor::Point.user_points_today(user_id)
+      scorecard.weekly    = Honor::Point.user_points_this_week(user_id)
+      scorecard.monthly   = Honor::Point.user_points_this_month(user_id)
+      scorecard.yearly    = Honor::Point.user_points_this_year(user_id)
+      scorecard.lifetime  = Honor::Point.user_points_total(user_id)
+      scorecard.save!
+    end
+
+  end
+end

data/lib/honor/scorecard.rb

@@ -0,0 +1,51 @@
+module Honor
+
+  class Scorecard < ActiveRecord::Base
+    attr_accessible :daily, :lifetime, :monthly, :user_id, :weekly, :yearly, :position
+    attr_accessor :position
+
+    class << self
+      def leaderboard(scorecard_user_ids, opt={})
+        opt.reverse_merge!  :rank_by => 'daily',
+                            :sort_direction => 'desc'
+        scorecards = team_scorecards(scorecard_user_ids, rank_by: opt[:rank_by], sort_direction: opt[:sort_direction])
+        rankings = []
+        scorecards.each_with_index do |scorecard, i|
+          if i == 0
+            scorecard.position = 1
+          elsif scorecard[opt[:rank_by]] == scorecards[i-1][opt[:rank_by]]
+            scorecard.position = rankings[i-1]
+          else
+            scorecard.position = i + 1
+          end
+          rankings[i] = scorecard.position
+        end
+        return scorecards
+      end
+
+      def reset_daily_scores
+        where("updated_at < ?", Time.zone.now.beginning_of_day).update_all(:daily => 0)
+      end
+
+      def reset_weekly_scores
+        where("updated_at < ?", Time.zone.now.beginning_of_week).update_all(:weekly => 0)
+      end
+
+      def reset_monthly_scores
+        where("updated_at < ?", Time.zone.now.beginning_of_month).update_all(:monthly => 0)
+      end
+
+      def reset_yearly_scores
+        where("updated_at < ?", Time.zone.now.beginning_of_year).update_all(:yearly => 0)
+      end
+
+      def team_scorecards(scorecard_user_ids, opt={})
+        opt.reverse_merge!  :rank_by => 'daily',
+                            :sort_direction => 'desc'
+        includes(:user).where('user_id IN (?)', scorecard_user_ids).order("#{opt[:rank_by]} #{opt[:sort_direction]}")
+      end
+    end
+
+  end
+
+end

data/lib/honor/version.rb

@@ -0,0 +1,3 @@
+module Honor
+  VERSION = "1.0.0"
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'honor'

data/spec/config/database.yml.sample

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: honor.sqlite3
+
+mysql:
+  adapter: mysql2
+  hostname: localhost
+  username: root
+  password:
+  database: honor
+  charset: utf8
+  
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: honor
+  encoding: utf8

data/spec/config/models.rb

@@ -0,0 +1,7 @@
+class Employee < ActiveRecord::Base
+  include Honor
+end
+
+class User < ActiveRecord::Base
+  include Honor
+end

data/spec/config/schema.rb

@@ -0,0 +1,34 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table "employees", :force => true do |t|
+    t.string   "first_name"
+    t.string   "last_name"
+  end
+
+  create_table "points", :force => true do |t|
+    t.integer  "user_id"
+    t.integer  "value"
+    t.string   "category"
+    t.text     "message"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+  add_index "points", ["user_id"], :name => "index_points_on_user_id"
+
+  create_table "scorecards", :force => true do |t|
+    t.integer  "user_id"
+    t.integer  "daily"
+    t.integer  "weekly"
+    t.integer  "monthly"
+    t.integer  "yearly"
+    t.integer  "lifetime"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+  add_index "scorecards", ["user_id"], :name => "index_scorecards_on_user_id"
+
+  create_table "users", :force => true do |t|
+    t.string   "first_name"
+    t.string   "last_name"
+  end
+
+end

data/spec/generators/install_generator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+# Generators are not automatically loaded by Rails
+require 'generators/install_generator'
+
+describe Honor::InstallGenerator do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+    Rails::Generators.options[:rails][:orm] = :active_record
+  end
+  describe 'no arguments' do
+    before { run_generator  }
+
+    describe 'db/migrate/create_honor_points.rb' do
+      subject { file('db/migrate/create_honor_points.rb') }
+      it { should be_a_migration }
+    end
+
+    describe 'db/migrate/create_honor_scorecards.rb' do
+      subject { file('db/migrate/create_honor_scorecards.rb') }
+      it { should be_a_migration }
+    end
+  end
+end

data/spec/honor/model_additions_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Honor do
+  let(:user) { User.create!({ first_name: 'James', last_name: 'Bond' }) }
+
+  before(:each) do
+    Time.zone = "Central Time (US & Canada)"
+  end
+
+  it "should create an instance attribute for points" do
+    user.should respond_to(:points)
+  end
+
+  it "should create an instance attribute for scorecard" do
+    user.should respond_to(:scorecard)
+  end
+
+  describe "Method" do
+    describe "add_points()" do
+      it "should add points through the current user"  do
+        expect {
+          user.add_points(25, 'Manual Add', 'Test')
+        }.to change(Honor::Point, :count).by(1)
+      end
+    end
+    describe "subtract_points()" do
+      it "should subtract points through the current user"  do
+        expect {
+          user.subtract_points(25, 'Manual Add', 'Test')
+        }.to change(Honor::Point, :count).by(1)
+      end
+      it "should set the value to a negative number" do
+        p = user.subtract_points(25, 'Manual Add', 'Test')
+        p.value.should == -25
+      end
+    end
+  end
+
+  describe "Scopes" do
+    before(:each) do
+      seed_points(user.id)
+      Timecop.freeze(2012, 11, 5, 16, 00)
+    end
+
+    after(:each) do
+      Timecop.return
+    end
+
+    context "User" do
+      describe "points_total" do
+        it "should return a sum of all of the user's points" do
+          user.points_total.should == 150
+        end
+        it "should return a sum of user points for a given category" do
+          user.points_total('Test 2').should == 75
+        end
+      end
+
+      describe "points_today" do
+        it "should return a sum of all of the user's points" do
+          user.points_today.should == 50
+        end
+        it "should return a sum of user points for a given category" do
+          user.points_today('Test 2').should == 25
+        end
+      end
+
+      describe "points_this_week" do
+        it "should return a sum of all of the user's points" do
+          user.points_this_week.should == 50
+        end
+        it "should return a sum of user points for a given category" do
+          user.points_this_week('Test 2').should == 25
+        end
+      end
+
+      describe "points_this_month" do
+        it "should return a sum of all of the user's points" do
+          user.points_this_month.should == 150
+        end
+        it "should return a sum of user points for a given category" do
+          user.points_this_month('Test 2').should == 75
+        end
+      end
+
+      describe "points_this_year" do
+        it "should return a sum of all of the user's points" do
+          user.points_this_year.should == 150
+        end
+        it "should return a sum of user points for a given category" do
+          user.points_this_year('Test 2').should == 75
+        end
+      end
+    end
+  end
+
+end
+
+def seed_points(user_id)
+  Timecop.freeze(2012, 1, 15, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: -25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: -25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 5, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 12, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 19, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 12, 4, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+end

data/spec/honor/point_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Honor::Point do
+  let(:user) { User.create!({ first_name: 'James', last_name: 'Bond' }) }
+
+  before(:each) do
+    Time.zone = "Central Time (US & Canada)"
+  end
+
+  it "should respond to the reciever" do
+    Honor::Point.new.should respond_to(:user)
+  end
+
+  describe "Method" do
+    describe "#give_to()" do
+      it "should add points to a given user" do
+        expect {
+          Honor::Point.give_to(user.id, 25, 'Manual give to', 'Test')
+        }.to change(Honor::Point, :count).by(1)
+      end
+    end
+    describe "#take_from()" do
+      it "should add points to a given user"do
+        expect {
+          Honor::Point.take_from(user.id, 25, 'Manual take away', 'Test')
+        }.to change(Honor::Point, :count).by(1)
+      end
+      it "should set the value to a negative number" do
+        p = Honor::Point.take_from(user.id, 25, 'Manual take away', 'Test')
+        p.value.should == -25
+      end
+    end
+  end
+
+  describe "Scorecard" do
+    before(:each) do
+      seed_points(user.id)
+      Timecop.freeze(2012, 12, 4, 16, 00)
+    end
+
+    after(:each) do
+      Timecop.return
+    end
+
+    it "should update after Points are saved" do
+      sc = Honor::Scorecard.find_by_user_id(user.id)
+      sc.should_not be_nil
+      sc.daily.should == 50
+      sc.weekly.should == 50
+      sc.monthly.should == 50
+      sc.yearly.should == 150
+      sc.lifetime.should == 150
+    end
+  end
+
+  describe "Scopes" do
+    before(:each) do
+      seed_points(user.id)
+      Timecop.freeze(2012, 11, 5, 16, 00)
+    end
+
+    after(:each) do
+      Timecop.return
+    end
+
+    context "Self" do
+      describe "user_points_total" do
+        it "should return a sum of all of the user's points" do
+          Honor::Point.user_points_total(user.id).should == 150
+        end
+      end
+
+      describe "user_points_today" do
+        it "should return a sum of all of the user's points" do
+          Honor::Point.user_points_today(user.id).should == 50
+        end
+      end
+
+      describe "user_points_this_week" do
+        it "should return a sum of all of the user's points" do
+          Honor::Point.user_points_this_week(user.id).should == 50
+        end
+      end
+
+      describe "user_points_this_month" do
+        it "should return a sum of all of the user's points" do
+          Honor::Point.user_points_this_month(user.id).should == 150
+        end
+      end
+
+      describe "user_points_this_year" do
+        it "should return a sum of all of the user's points" do
+          Honor::Point.user_points_this_year(user.id).should == 150
+        end
+      end
+    end
+
+  end
+end
+
+def seed_points(user_id)
+  Timecop.freeze(2012, 1, 15, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: -25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: -25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 5, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 12, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 11, 19, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+  Timecop.freeze(2012, 12, 4, 12, 05)
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test', message: ''})
+  Honor::Point.create!({user_id: user_id, value: 25, category: 'Test 2', message: ''})
+end

data/spec/honor/scorecard_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Honor::Scorecard do
+  let(:valid_user) { FactoryGirl.attributes_for(:user) }
+  let (:valid_friend) { FactoryGirl.attributes_for(:user, username: 'goldfinger', email: Faker::Internet.email) }
+
+  before(:each) do
+    Time.zone = "Central Time (US & Canada)"
+    Timecop.freeze(2011, 12, 4, 16, 00)
+    @user_1 = User.create!({ first_name: 'Bruce', last_name: 'Wayne' })
+    @user_2 = User.create!({ first_name: 'Clark', last_name: 'Kent' })
+    Honor::Scorecard.create!({user_id: @user_1.id, daily: 25, weekly: 100, monthly: 350, yearly: 1250, lifetime: 1375})
+    Honor::Scorecard.create!({user_id: @user_2.id, daily: 50, weekly: 100, monthly: 350, yearly: 1250, lifetime: 1375})
+    Timecop.return
+  end
+
+  it "should respond to the reciever" do
+    Honor::Scorecard.new.should respond_to(:user)
+  end
+
+  describe "Ranking" do
+    it "should produce rankings with correctly calculated tied positions" do
+      user_ids = [@user_2.id, @user_1.id]
+      daily_rankings = Honor::Scorecard.leaderboard(user_ids, rank_by: 'daily', sort_direction: 'desc')
+      daily_rankings[0].position.should == 1
+      daily_rankings[1].position.should == 2
+      weekly_rankings = Honor::Scorecard.leaderboard(user_ids, rank_by: 'weekly', sort_direction: 'desc')
+      weekly_rankings[0].position.should == 1
+      weekly_rankings[1].position.should == 1
+    end
+  end
+
+  describe "Methods" do
+    describe "#reset_daily_scores" do
+      it "should set the daily attribute to 0 if no updates have been made today" do
+        Honor::Scorecard.reset_daily_scores
+        sc = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc.daily.should == 0
+        sc.weekly.should == 100
+        sc.monthly.should == 350
+        sc.yearly.should == 1250
+      end
+
+      it "should NOT change the daily attribute if an update was made today" do
+        sc_before = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_before.update_attribute(:daily, 30)
+        Honor::Scorecard.reset_daily_scores
+        sc_after = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_after.daily.should == 30
+        sc_after.weekly.should == 100
+        sc_after.monthly.should == 350
+        sc_after.yearly.should == 1250
+      end
+    end
+    describe "#reset_weekly_scores" do
+      it "should set the weekly attribute to 0 if no updates have been made this week" do
+        Honor::Scorecard.reset_weekly_scores
+        sc = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc.daily.should == 25
+        sc.weekly.should == 0
+        sc.monthly.should == 350
+        sc.yearly.should == 1250
+      end
+
+      it "should NOT change the weekly attribute if an update was made this week" do
+        sc_before = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_before.update_attribute(:weekly, 125)
+        Honor::Scorecard.reset_weekly_scores
+        sc_after = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_after.daily.should == 25
+        sc_after.weekly.should == 125
+        sc_after.monthly.should == 350
+        sc_after.yearly.should == 1250
+      end
+    end
+    describe "#reset_monthly_scores" do
+      it "should set the monthly attribute to 0 if no updates have been made this month" do
+        Honor::Scorecard.reset_monthly_scores
+        sc = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc.daily.should == 25
+        sc.weekly.should == 100
+        sc.monthly.should == 0
+        sc.yearly.should == 1250
+      end
+
+      it "should NOT change the monthly attribute if an update was made this month" do
+        sc_before = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_before.update_attribute(:monthly, 400)
+        Honor::Scorecard.reset_monthly_scores
+        sc_after = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_after.daily.should == 25
+        sc_after.weekly.should == 100
+        sc_after.monthly.should == 400
+        sc_after.yearly.should == 1250
+      end
+    end
+    describe "#reset_yearly_scores" do
+      it "should set the yearly attribute to 0 if no updates have been made this year" do
+        Honor::Scorecard.reset_yearly_scores
+        sc = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc.daily.should == 25
+        sc.weekly.should == 100
+        sc.monthly.should == 350
+        sc.yearly.should == 0
+      end
+
+      it "should NOT change the yearly attribute if an update was made this year" do
+        sc_before = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_before.update_attribute(:yearly, 1300)
+        Honor::Scorecard.reset_yearly_scores
+        sc_after = Honor::Scorecard.find_by_user_id(@user_1.id)
+        sc_after.daily.should == 25
+        sc_after.weekly.should == 100
+        sc_after.monthly.should == 350
+        sc_after.yearly.should == 1300
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'honor'
+require 'ammeter/init'
+require 'timecop'
+require 'database_cleaner'
+
+# set adapter to use, default is sqlite3
+# to use an alternative adapter run => rake spec DB='postgresql'
+db_name = ENV['DB'] || 'sqlite3'
+database_yml = File.expand_path('../config/database.yml', __FILE__)
+
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)
+
+  ActiveRecord::Base.configurations = active_record_configuration
+  config = ActiveRecord::Base.configurations[db_name]
+
+  begin
+    ActiveRecord::Base.establish_connection(db_name)
+    ActiveRecord::Base.connection
+  rescue
+    case db_name
+    when /mysql/
+      ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+      ActiveRecord::Base.connection.create_database(config['database'],  {:charset => 'utf8', :collation => 'utf8_unicode_ci'})
+    when 'postgresql'
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+      ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+    end
+
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  ActiveRecord::Base.default_timezone = :utc
+
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+
+    load(File.expand_path('../config/schema.rb', __FILE__))
+    load(File.expand_path('../config/models.rb', __FILE__))
+  end
+
+else
+  raise "Please create #{database_yml} first to configure your database. Take a look at: spec/config/#{database_yml}.sample"
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: honor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Ward
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-03 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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: ammeter
+  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: supermodel
+  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: timecop
+  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: Adds support for common gamification features such as points, leaderboards,
+  and achievements.
+email:
+- jrmy.ward@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- honor.gemspec
+- honor.sqlite3
+- lib/generators/install_generator.rb
+- lib/generators/templates/active_record/create_points.rb
+- lib/generators/templates/active_record/create_scorecards.rb
+- lib/honor.rb
+- lib/honor/model_additions.rb
+- lib/honor/point.rb
+- lib/honor/scorecard.rb
+- lib/honor/version.rb
+- rails/init.rb
+- spec/config/database.yml.sample
+- spec/config/models.rb
+- spec/config/schema.rb
+- spec/generators/install_generator_spec.rb
+- spec/honor/model_additions_spec.rb
+- spec/honor/point_spec.rb
+- spec/honor/scorecard_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jrmyward/honor
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: General gamification-centric reputation system for Rails Applications.
+test_files:
+- spec/config/database.yml.sample
+- spec/config/models.rb
+- spec/config/schema.rb
+- spec/generators/install_generator_spec.rb
+- spec/honor/model_additions_spec.rb
+- spec/honor/point_spec.rb
+- spec/honor/scorecard_spec.rb
+- spec/spec_helper.rb
+has_rdoc: