scorecard 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06e11f730ab8af962e70b4942175fa861d736ef4
-  data.tar.gz: bc09ee07cb46b2ebc3de67fae7fab333166735c3
+  metadata.gz: 1232899ca7b26af8e4a8d8af2baaae024343a688
+  data.tar.gz: c3c252f4debd3424989324fa5a0b239a13f90185
 SHA512:
-  metadata.gz: 21dd7bb81cca83651312ac334966664ec05daaf345cc576300e2ecbbc0e6a9521534ebb70cd1e71df3a324c12298ef20ed6de30e03b9b16deaa2b3f09261175b
-  data.tar.gz: e23a940cdcd60c314ee23d555279bb912cb437244020d3b70357b2b06033a5cacb3f8f95d9e89a17cf48e33c2f6c4ce84799bd42d338ab32a004787e7ea7af08
+  metadata.gz: 2dee14b5121ee947bf95bd12d17ed95a08b36cbb5e6aa469871d7582129c0b48b3b3517f3332790adf72a75df7e1a134008a5f20f63b4c65f87ce9260a8eaa2e
+  data.tar.gz: 88d9897dd851e560050b03bfeb8b88258264ff0c580dcba90b7f7b1efda7eda10109e50b11aab721de74e39523c202fff8b1fd8718e031bf4cf36a2c17a27950

data/README.md

@@ -8,7 +8,7 @@ For anyone who comes across this, please note this is not yet feature complete,
 
 Add this line to your application's Gemfile:
 
-    gem 'scorecard', '0.0.2'
+    gem 'scorecard', '0.0.3'
 
 Don't forget to bundle:
 
@@ -23,36 +23,68 @@ Then, add the migrations to your app and update your database accordingly:
 In an initializer, define the events that points are tied to - with a unique context and the number of points:
 
 ```ruby
-Scorecard::PointRule.new :new_post, 50
+Scorecard.configure do |config|
+  config.rules.add_rule :new_post, 50
+end
 ```
 
 You can also provide a block with logic for whether to award the points, the maximum number of points allowed to be awarded for this rule, and the timeframe for that limit:
 
 ```ruby
-Scorecard::PointRule.new :new_post, 50, limit: 100, timeframe: :day,
+Scorecard.configure do |config|
+  config.rules.add_rule :new_post, 50, limit: 100, timeframe: :day,
   if: lambda { |payload| payload[:user].posts.count <= 1 }
+end
 ```
 
 The payload object contains the context plus every option you send through to `score` call (see below).
 
+For levels, you can set the central piece of logic that calculates the user's current level in the initializer as well:
+
+```ruby
+Scorecard.configure do |config|
+  config.levels = lambda { |user|
+    if user.created_at > 2.years.ago
+      3
+    elsif user.created_at > 1.year.ago
+      2
+    else
+      1
+    end
+  }
+end
+```
+
 ## Scoring
 
 And then, when you want to fire those events, use code much like the following:
 
 ```ruby
-Scorecard::Points.score :new_post, gameable: post
+Scorecard::Scorer.points :new_post, gameable: post
 ```
 
 This presumes that the user the points are for is a method on the gameable object. If that's not the case, you can pass in a custom user:
 
 ```ruby
-Scorecard::Points.score :new_post, gameable: post, user: user
+Scorecard::Scorer.points :new_post, gameable: post, user: user
 ```
 
 If you're using Sidekiq, you can push the scoring behaviour into a background worker using `score_async` instead. Make sure `scorecard` is listed below `sidekiq` in your `Gemfile`.
 
 ```ruby
-Scorecard::Points.score_async :new_post, gameable: post
+Scorecard::Scorer.points_async :new_post, gameable: post
+```
+
+Whenever you want to recalculate a user's level, run the following:
+
+```ruby
+Scorecard::Scorer.level user
+```
+
+To remove points related to a given gameable object, you can use the Scorecard::Cleaner class:
+
+```ruby
+Scorecard::Cleaner.points post
 ```
 
 ## Results
@@ -60,7 +92,13 @@ Scorecard::Points.score_async :new_post, gameable: post
 To get the current points count for a given user:
 
 ```ruby
-Scorecard::Points.for user
+Scorecard::Card.new(user).points
+```
+
+And the current level:
+
+```ruby
+Scorecard::Card.new(user).level
 ```
 
 ## Contributing

data/app/models/scorecard/level.rb

@@ -0,0 +1,17 @@
+class Scorecard::Level < ActiveRecord::Base
+  self.table_name = 'scorecard_levels'
+
+  belongs_to :user, polymorphic: true
+
+  if Rails.version.to_s < '4.0.0'
+    attr_accessible :amount, :user
+  end
+
+  validates :amount,  presence: true
+  validates :user,    presence: true
+  validates :user_id, uniqueness: {scope: :user_type}
+
+  def self.for_user(user)
+    where(user_id: user.id, user_type: user.class.name).first
+  end
+end

data/app/models/scorecard/point.rb

@@ -4,6 +4,10 @@ class Scorecard::Point < ActiveRecord::Base
   belongs_to :user,     polymorphic: true
   belongs_to :gameable, polymorphic: true
 
+  if Rails.version.to_s < '4.0.0'
+    attr_accessible :context, :identifier, :amount, :gameable, :user
+  end
+
   validates :context,    presence: true
   validates :identifier, presence: true, uniqueness: {
     scope: [:context, :user_type, :user_id]
@@ -19,6 +23,10 @@ class Scorecard::Point < ActiveRecord::Base
     where user_id: user.id, user_type: user.class.name
   end
 
+  def self.for_gameable(gameable)
+    where gameable_id: gameable.id, gameable_type: gameable.class.name
+  end
+
   def self.for_user_in_timeframe(context, user, timeframe)
     for_context(context).for_user(user).where(created_at: timeframe)
   end

data/db/migrate/2_create_levels.rb

@@ -0,0 +1,12 @@
+class CreateLevels < ActiveRecord::Migration
+  def change
+    create_table :scorecard_levels do |table|
+      table.integer :amount,        null: false
+      table.string  :user_type,     null: false
+      table.integer :user_id,       null: false
+      table.timestamps
+    end
+
+    add_index :scorecard_levels, [:user_type, :user_id], unique: true
+  end
+end

data/lib/scorecard/card.rb

@@ -0,0 +1,18 @@
+class Scorecard::Card
+  attr_reader :user
+
+  def initialize(user)
+    @user = user
+  end
+
+  def level
+    @level ||= begin
+      record = Scorecard::Level.for_user(user)
+      record.nil? ? Scorecard.levels.call(user) : record.amount
+    end
+  end
+
+  def points
+    @points ||= Scorecard::Point.for_user(user).sum(:amount)
+  end
+end

data/lib/scorecard/cleaner.rb

@@ -0,0 +1,13 @@
+class Scorecard::Cleaner
+  def self.points(gameable)
+    Scorecard::Point.for_gameable(gameable).each do |point|
+      point.destroy
+      ActiveSupport::Notifications.instrument 'scorecard', user: point.user
+    end
+  end
+
+  def self.points_async(gameable)
+    Scorecard::ClearWorker.perform_in 10.seconds, gameable.class.name,
+      gameable.id
+  end
+end

data/lib/scorecard/clear_worker.rb

@@ -0,0 +1,7 @@
+class Scorecard::ClearWorker
+  include Sidekiq::Worker
+
+  def perform(class_name, id)
+    Scorecard::Cleaner.points class_name.constantize.find(id)
+  end
+end

data/lib/scorecard/rules.rb

@@ -5,11 +5,11 @@ class Scorecard::Rules
     @point_rules = []
   end
 
-  def add_rule_for_points(context, amount, options = {})
+  def add_rule(context, amount, options = {})
     point_rules << Scorecard::PointRule.new(context, amount, options)
   end
 
-  def find_rule_for_points(context)
+  def find_rule(context)
     point_rules.detect { |rule| rule.context == context }
   end
 

data/lib/scorecard/{worker.rb → score_worker.rb}

@@ -1,4 +1,4 @@
-class Scorecard::Worker
+class Scorecard::ScoreWorker
   include Sidekiq::Worker
 
   def perform(context, options)
@@ -9,6 +9,6 @@ class Scorecard::Worker
       options[prefix] = klass.find options.delete("#{prefix}_id")
     end
 
-    Scorecard::Points.score context.to_sym, options.symbolize_keys
+    Scorecard::Scorer.points context.to_sym, options.symbolize_keys
   end
 end

data/lib/scorecard/scorer.rb

@@ -0,0 +1,27 @@
+class Scorecard::Scorer
+  def self.level(user)
+    level = Scorecard::Level.for_user(user) || Scorecard::Level.new(user: user)
+    level.amount = Scorecard.levels.call user
+    return unless level.amount_changed?
+
+    level.save
+    ActiveSupport::Notifications.instrument 'level.scorecard', user: user
+  end
+
+  def self.points(context, options)
+    ActiveSupport::Notifications.instrument 'points.scorecard',
+      options.merge(context: context)
+  end
+
+  def self.points_async(context, options)
+    [:gameable, :user].each do |prefix|
+      next unless options[prefix]
+
+      options["#{prefix}_id"]   = options[prefix].id
+      options["#{prefix}_type"] = options[prefix].class.name
+      options.delete prefix
+    end
+
+    Scorecard::ScoreWorker.perform_async context, options.stringify_keys
+  end
+end

data/lib/scorecard/subscriber.rb

@@ -14,7 +14,7 @@ class Scorecard::Subscriber
   end
 
   def points(event)
-    rule = Scorecard.rules.find_rule_for_points event.payload[:context]
+    rule = Scorecard.rules.find_rule event.payload[:context]
 
     event.payload[:amount]     ||= rule.amount
     event.payload[:identifier] ||= event.payload[:gameable].id
@@ -22,8 +22,11 @@ class Scorecard::Subscriber
 
     return unless rule && rule.allowed?(event.payload)
 
-    Scorecard::Point.create(
+    point = Scorecard::Point.create(
       event.payload.slice(:context, :amount, :identifier, :user, :gameable)
     )
+    ActiveSupport::Notifications.instrument(
+      'scorecard', user: event.payload[:user]
+    ) if point.persisted?
   end
 end

data/lib/scorecard.rb

@@ -1,4 +1,6 @@
 module Scorecard
+  mattr_accessor :levels
+
   def self.configure
     yield self
   end
@@ -8,9 +10,15 @@ module Scorecard
   end
 end
 
+require 'scorecard/card'
+require 'scorecard/cleaner'
 require 'scorecard/engine'
-require 'scorecard/points'
 require 'scorecard/point_rule'
 require 'scorecard/rules'
+require 'scorecard/scorer'
 require 'scorecard/subscriber'
-require 'scorecard/worker' if defined?(Sidekiq)
+
+if defined?(Sidekiq)
+  require 'scorecard/clear_worker'
+  require 'scorecard/score_worker'
+end

data/scorecard.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = 'scorecard'
-  spec.version       = '0.0.2'
+  spec.version       = '0.0.3'
   spec.authors       = ['Pat Allan']
   spec.email         = ['pat@freelancing-gods.com']
   spec.summary       = 'Rails Engine for common scorecard patterns'

data/spec/acceptance/clearing_points_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Clearing Points' do
+  let(:post) { Post.create! user: user }
+  let(:user) { User.create! }
+
+  before :each do
+    Scorecard.configure do |config|
+      config.rules.add_rule :new_post, 50
+    end
+
+    post
+  end
+
+  it 'removes points for a given gameable object' do
+    expect(Scorecard::Card.new(user).points).to eq(50)
+
+    Scorecard::Cleaner.points(post)
+
+    expect(Scorecard::Card.new(user).points).to eq(0)
+  end
+
+  it 'clears points via Sidekiq' do
+    expect(Scorecard::Card.new(user).points).to eq(50)
+
+    Scorecard::Cleaner.points_async(post)
+
+    expect(Scorecard::Card.new(user).points).to eq(0)
+  end
+
+  it "fires a generic notification" do
+    fired = false
+
+    subscriber = ActiveSupport::Notifications.subscribe 'scorecard' do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      fired = (event.payload[:user] == user)
+    end
+
+    Scorecard::Cleaner.points_async(post)
+
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    expect(fired).to be_true
+  end
+end
+

data/spec/acceptance/levels_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'Levels' do
+  let(:user) { User.create! email: 'pat-new' }
+
+  before :each do
+    Scorecard.configure do |config|
+      config.levels = lambda { |user|
+        user.email[/old/] ? 2 : 1
+      }
+    end
+  end
+
+  it "saves the score for the user" do
+    Scorecard::Scorer.level user
+
+    level = Scorecard::Level.where(user_id: user.id, user_type: 'User').first
+    expect(level.amount).to eq(1)
+  end
+
+  it "fires a level notification when the level is first set" do
+    fired = false
+
+    subscriber = ActiveSupport::Notifications.subscribe 'level.scorecard' do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      fired = (event.payload[:user] == user)
+    end
+
+    Scorecard::Scorer.level user
+
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    expect(fired).to be_true
+  end
+
+  it "fires a level notification when the level is changed" do
+    Scorecard::Scorer.level user
+    user.update_attributes(email: 'pat-old')
+
+    fired = false
+
+    subscriber = ActiveSupport::Notifications.subscribe 'level.scorecard' do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      fired = (event.payload[:user] == user)
+    end
+
+    Scorecard::Scorer.level user
+
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    expect(fired).to be_true
+  end
+
+  it "does not fire a notification when the level remains the same" do
+    Scorecard::Scorer.level user
+
+    fired = false
+
+    subscriber = ActiveSupport::Notifications.subscribe 'level.scorecard' do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      fired = (event.payload[:user] == user)
+    end
+
+    Scorecard::Scorer.level user
+
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    expect(fired).to be_false
+  end
+
+  it "retrieves stored level for a user" do
+    Scorecard::Scorer.level user
+
+    expect(Scorecard::Card.new(user).level).to eq(1)
+  end
+end

data/spec/acceptance/read_points_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Reading points' do
+  it "returns the total points for a user" do
+    Scorecard.configure do |config|
+      config.rules.add_rule :new_user, 20
+      config.rules.add_rule :new_post, 30
+    end
+
+    user = User.create!
+    post = Post.create! user: user
+    Scorecard::Scorer.points :new_user, gameable: user, user: user
+
+    expect(Scorecard::Card.new(user).points).to eq(50)
+  end
+end

data/spec/acceptance/{points_spec.rb → score_points_spec.rb}

@@ -1,19 +1,15 @@
 require 'spec_helper'
 
-describe 'Scorecard' do
-  before :each do
-    Scorecard.rules.clear
-  end
-
+describe 'Scoring points' do
   it "stores points for configured behaviour" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_post, 50
+      config.rules.add_rule :new_post, 50
     end
 
     user = User.create!
     post = Post.create! user: user
 
-    Scorecard::Point.where(
+    points = Scorecard::Point.where(
       context:       'new_post',
       amount:        50,
       identifier:    post.id.to_s,
@@ -21,12 +17,13 @@ describe 'Scorecard' do
       user_type:     'User',
       gameable_id:   post.id,
       gameable_type: 'Post'
-    ).should_not be_empty
+    )
+    expect(points).to_not be_empty
   end
 
   it "only stores points when provided logic passes" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_post, 50,
+      config.rules.add_rule :new_post, 50,
         if: lambda { |payload| Post.count <= 1 }
     end
 
@@ -34,22 +31,23 @@ describe 'Scorecard' do
     post = Post.create! user: user
     post = Post.create! user: user
 
-    Scorecard::Point.where(
+    count = Scorecard::Point.where(
       context: 'new_post',
       amount:  50
-    ).count.should == 1
+    ).count
+    expect(count).to eq(1)
   end
 
   it "does not double-up on points for the same event" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_post, 50
+      config.rules.add_rule :new_post, 50
     end
 
     user = User.create!
     post = Post.create! user: user
-    Scorecard::Points.score :new_post, gameable: post
+    Scorecard::Scorer.points :new_post, gameable: post
 
-    Scorecard::Point.where(
+    count = Scorecard::Point.where(
       context:       'new_post',
       amount:        50,
       identifier:    post.id.to_s,
@@ -57,12 +55,13 @@ describe 'Scorecard' do
       user_type:     'User',
       gameable_id:   post.id,
       gameable_type: 'Post'
-    ).count.should == 1
+    ).count
+    expect(count).to eq(1)
   end
 
   it "respects limit options" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_post, 50, limit: 100
+      config.rules.add_rule :new_post, 50, limit: 100
     end
 
     user = User.create!
@@ -70,36 +69,32 @@ describe 'Scorecard' do
     post = Post.create! user: user
     post = Post.create! user: user
 
-    Scorecard::Point.where(
-      context: 'new_post',
-      amount:  50
-    ).count.should == 2
+    count = Scorecard::Point.where(context: 'new_post', amount: 50).count
+    expect(count).to eq(2)
   end
 
   it "respects timeframe options" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_post, 50, timeframe: :day
+      config.rules.add_rule :new_post, 50, timeframe: :day
     end
 
     user = User.create!
     post = Post.create! user: user
     post = Post.create! user: user
 
-    Scorecard::Point.where(
-      context: 'new_post',
-      amount:  50
-    ).count.should == 1
+    count = Scorecard::Point.where(context: 'new_post', amount: 50).count
+    expect(count).to eq(1)
   end
 
   it "allows for processing via Sidekiq" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_user, 20
+      config.rules.add_rule :new_user, 20
     end
 
     user = User.create!
-    Scorecard::Points.score_async :new_user, gameable: user, user: user
+    Scorecard::Scorer.points_async :new_user, gameable: user, user: user
 
-    Scorecard::Point.where(
+    points = Scorecard::Point.where(
       context:       'new_user',
       amount:        20,
       identifier:    user.id.to_s,
@@ -107,19 +102,27 @@ describe 'Scorecard' do
       user_type:     'User',
       gameable_id:   user.id,
       gameable_type: 'User'
-    ).should_not be_empty
+    )
+    expect(points).to_not be_empty
   end
 
-  it "returns the total points for a user" do
+  it "fires a generic notification" do
     Scorecard.configure do |config|
-      config.rules.add_rule_for_points :new_user, 20
-      config.rules.add_rule_for_points :new_post, 30
+      config.rules.add_rule :new_post, 50
+    end
+
+    fired = false
+    user  = User.create!
+
+    subscriber = ActiveSupport::Notifications.subscribe 'scorecard' do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      fired = (event.payload[:user] == user)
     end
 
-    user = User.create!
     post = Post.create! user: user
-    Scorecard::Points.score :new_user, gameable: user, user: user
 
-    Scorecard::Points.for(user).should == 50
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+
+    expect(fired).to be_true
   end
 end

data/spec/internal/app/models/post.rb

@@ -2,6 +2,6 @@ class Post < ActiveRecord::Base
   belongs_to :user
 
   after_create lambda { |post|
-    Scorecard::Points.score :new_post, gameable: post
+    Scorecard::Scorer.points :new_post, gameable: post
   }
 end

data/spec/spec_helper.rb

@@ -15,4 +15,7 @@ Dir["./spec/support/**/*.rb"].each { |file| require file }
 
 RSpec.configure do |config|
   config.use_transactional_fixtures = true
+  config.before :each do
+    Scorecard.rules.clear
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorecard
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pat Allan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-24 00:00:00.000000000 Z
+date: 2013-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -93,18 +93,26 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/models/scorecard/level.rb
 - app/models/scorecard/point.rb
 - config.ru
 - db/migrate/1_create_points.rb
+- db/migrate/2_create_levels.rb
 - lib/scorecard.rb
+- lib/scorecard/card.rb
+- lib/scorecard/cleaner.rb
+- lib/scorecard/clear_worker.rb
 - lib/scorecard/engine.rb
 - lib/scorecard/point_rule.rb
-- lib/scorecard/points.rb
 - lib/scorecard/rules.rb
+- lib/scorecard/score_worker.rb
+- lib/scorecard/scorer.rb
 - lib/scorecard/subscriber.rb
-- lib/scorecard/worker.rb
 - scorecard.gemspec
-- spec/acceptance/points_spec.rb
+- spec/acceptance/clearing_points_spec.rb
+- spec/acceptance/levels_spec.rb
+- spec/acceptance/read_points_spec.rb
+- spec/acceptance/score_points_spec.rb
 - spec/internal/app/models/post.rb
 - spec/internal/app/models/user.rb
 - spec/internal/config/database.yml
@@ -138,7 +146,10 @@ signing_key:
 specification_version: 4
 summary: Rails Engine for common scorecard patterns
 test_files:
-- spec/acceptance/points_spec.rb
+- spec/acceptance/clearing_points_spec.rb
+- spec/acceptance/levels_spec.rb
+- spec/acceptance/read_points_spec.rb
+- spec/acceptance/score_points_spec.rb
 - spec/internal/app/models/post.rb
 - spec/internal/app/models/user.rb
 - spec/internal/config/database.yml

data/lib/scorecard/points.rb

@@ -1,22 +0,0 @@
-class Scorecard::Points
-  def self.score(context, options)
-    ActiveSupport::Notifications.instrument 'points.scorecard',
-      options.merge(context: context)
-  end
-
-  def self.score_async(context, options)
-    [:gameable, :user].each do |prefix|
-      next unless options[prefix]
-
-      options["#{prefix}_id"]   = options[prefix].id
-      options["#{prefix}_type"] = options[prefix].class.name
-      options.delete prefix
-    end
-
-    Scorecard::Worker.perform_async context, options.stringify_keys
-  end
-
-  def self.for(user)
-    Scorecard::Point.for_user(user).sum(:amount)
-  end
-end