acts_as_caesar 0.0.1

data/spec/objects/persistence_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require_relative '../../lib/acts_as_caesar/objects/persistence'
+
+describe ActsAsCaesar::Persistence do
+  context "the class" do
+    subject { ActsAsCaesar::Persistence }
+
+    it "should have a connection" do
+      subject.connection.should be_kind_of Redis
+    end
+    
+    context "when loading a vote value" do
+      let(:keys) do
+        { candidate: mock('candidate', key: 'candidate_1'), voter: mock('voter', key: 'voter_1') }
+      end
+      let(:key_array) { keys.values.map(&:key) }
+      
+      context "and the value is positive" do
+        it "should find vote values when provided with a set of keys" do
+          subject.connection.set(key_array.join("_"), 1)
+          subject.vote_value(keys).should == 1
+        end
+      end
+      
+      context "and the value is negative" do
+        it "should find vote values when provided with a set of keys" do
+          subject.connection.set(key_array.join("_"), -1)
+          subject.vote_value(keys).should == -1
+        end
+      end
+      
+      context "and no value is set" do
+        it "should find vote values when provided with a set of keys" do
+          subject.connection.del(key_array.join("_"))
+          subject.vote_value(keys).should == 0
+        end
+      end
+    end
+    
+    context "when incrementing the total" do
+      let(:candidate) { mock('candidate', key: 'candidate_1') }
+
+      it "should set the total to the same value + 1" do
+        current_total = subject.vote_total(candidate)
+        subject.increment_total_votes_on(candidate)
+        subject.vote_total(candidate).should == current_total + 1
+      end
+    end
+    
+    context "when decrementing the total" do
+      let(:candidate) { mock('candidate', key: 'candidate_1') }
+
+      it "should set the total to the same value - 1" do
+        current_total = subject.vote_total(candidate)
+        subject.decrement_total_votes_on(candidate)
+        subject.vote_total(candidate).should == current_total - 1
+      end
+    end
+    
+    context "when setting a vote value" do
+      let(:keys) do
+        { candidate: mock('candidate', key: 'candidate_1'), voter: mock('voter', key: 'voter_1') }
+      end
+      
+      context "and the value is positive" do
+        it "should set the value to 1" do
+          subject.set_vote_value(1, keys)
+          subject.vote_value(keys).should == 1
+        end
+      end
+      
+      context "and the value is negative" do
+        it "should set the value to -1" do
+          subject.set_vote_value(-1, keys)
+          subject.vote_value(keys).should == -1
+        end
+      end
+      
+      context "and no value is set" do
+        it "should set delete value" do
+          subject.set_vote_value(0, keys)
+          subject.vote_value(keys).should == 0
+        end
+      end
+    end
+  end
+end

data/spec/objects/vote_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require_relative '../../lib/acts_as_caesar/objects/vote'
+
+describe ActsAsCaesar::Vote do
+  let(:voter) { ActsAsCaesar::Voter.new(mock('user')) }
+  let(:candidate) { ActsAsCaesar::Candidate.new(mock('answer')) }
+  
+  subject { ActsAsCaesar::Vote }
+
+  context "when finding a vote" do
+    it "should return no vote when nil" do
+      ActsAsCaesar::Persistence.should_receive(:vote_value).and_return(nil)
+      subject.find(voter: voter, candidate: candidate).should be_kind_of ActsAsCaesar::NoVote
+    end
+
+    it "should return a positive vote when 1" do
+      ActsAsCaesar::Persistence.should_receive(:vote_value).and_return(1)
+      subject.find(voter: voter, candidate: candidate).should be_kind_of ActsAsCaesar::PositiveVote
+    end
+    
+    it "should return a negative vote when -1" do
+      ActsAsCaesar::Persistence.should_receive(:vote_value).and_return(-1)
+      subject.find(voter: voter, candidate: candidate).should be_kind_of ActsAsCaesar::NegativeVote
+    end
+  end
+end
+
+describe ActsAsCaesar::NoVote do
+  let(:candidate) { mock('candidate') }
+  let(:params) { { candidate: candidate, voter: mock('voter') } }
+
+  subject { ActsAsCaesar::NoVote.new(params) }
+
+  context "when updating the vote to 1" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(1, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:increment_total_votes_on).with(candidate).and_return(true)
+    end
+    
+    it "should return a positive vote" do
+      subject.update(1).should be_kind_of ActsAsCaesar::PositiveVote
+    end
+  end
+  
+  context "when updating the vote to 0" do
+    it "should return a non-vote" do
+      subject.update(0).should be_kind_of ActsAsCaesar::NoVote
+    end
+  end
+  
+  context "when updating the vote to -1" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(-1, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:decrement_total_votes_on).with(candidate).and_return(true)
+    end
+
+    it "should return a negative vote" do
+      subject.update(-1).should be_kind_of ActsAsCaesar::NegativeVote
+    end
+  end
+end
+
+describe ActsAsCaesar::PositiveVote do
+  let(:candidate) { mock('candidate') }
+  let(:params) { { candidate: candidate, voter: mock('voter') } }
+
+  subject { ActsAsCaesar::PositiveVote.new(params) }
+
+  context "when updating the vote to 1" do
+    it "should return a positive vote" do
+      subject.update(1).should be_kind_of ActsAsCaesar::PositiveVote
+    end
+  end
+
+  context "when updating the vote to 0" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(0, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:decrement_total_votes_on).with(candidate).and_return(true)
+    end
+    
+    it "should return a non-vote" do
+      subject.update(0).should be_kind_of ActsAsCaesar::NoVote
+    end
+  end
+
+  context "when updating the vote to -1" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(-1, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:decrement_total_votes_on).with(candidate).and_return(true)
+    end
+
+    it "should return a negative vote" do
+      subject.update(-1).should be_kind_of ActsAsCaesar::NegativeVote
+    end
+  end
+end
+
+describe ActsAsCaesar::NegativeVote do
+  let(:candidate) { mock('candidate') }
+  let(:params) { { candidate: candidate, voter: mock('voter') } }
+
+  subject { ActsAsCaesar::NegativeVote.new(params) }
+
+  context "when updating the vote to 1" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(1, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:increment_total_votes_on).with(candidate).and_return(true)
+    end
+    
+    it "should return a positive vote" do
+      subject.update(1).should be_kind_of ActsAsCaesar::PositiveVote
+    end
+  end
+
+  context "when updating the vote to 0" do
+    before do
+      ActsAsCaesar::Persistence.should_receive(:set_vote_value).with(0, params).and_return(true)
+      ActsAsCaesar::Persistence.should_receive(:increment_total_votes_on).with(candidate).and_return(true)
+    end
+
+    it "should return a non-vote" do
+      subject.update(0).should be_kind_of ActsAsCaesar::NoVote
+    end
+  end
+
+  context "when updating the vote to -1" do
+    it "should return a negative vote" do
+      subject.update(-1).should be_kind_of ActsAsCaesar::NegativeVote
+    end
+  end
+end

data/spec/objects/voter_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require_relative '../../lib/acts_as_caesar/objects/voter'
+
+describe ActsAsCaesar::Voter do
+  let(:candidate) { mock('candidate', key: 'candidate_1') }
+  let(:source) { mock('user', key: 'user_1') }
+  let(:voter) { ActsAsCaesar::Voter.new(source) }
+  subject { voter }
+  
+  context "when a voter is created with a nil source" do
+    let(:source) { nil }
+    it "should store a NoVoter object" do
+      voter.send(:source).should be_kind_of ActsAsCaesar::NoVoter
+    end
+  end
+  
+  context "when quering vote status" do
+    context "when a positive vote has been placed for the candidate" do
+      before(:each) do
+        ActsAsCaesar::Vote.should_receive(:find).and_return(ActsAsCaesar::PositiveVote.new(voter: source, candidate: candidate))
+      end
+      
+      it "should return true for has_voted_on?" do
+        voter.has_voted_on?(candidate).should be_true
+      end
+      
+      it "should return 1 for vote_value_for" do
+        voter.vote_value_for(candidate).should == 1
+      end
+    end
+    
+    context "when a negative vote has been placed for the candidate" do
+      before(:each) do
+        ActsAsCaesar::Vote.should_receive(:find).and_return(ActsAsCaesar::NegativeVote.new(voter: source, candidate: candidate))
+      end
+
+      it "should return true for has_voted_on?" do
+        voter.has_voted_on?(candidate).should be_true
+      end
+      
+      it "should return -1 for vote_value_for" do
+        voter.vote_value_for(candidate).should == -1
+      end
+    end
+    
+    context "when no vote has been placed for the candidate" do
+      before(:each) do
+        ActsAsCaesar::Vote.should_receive(:find).and_return(ActsAsCaesar::NoVote.new(voter: source, candidate: candidate))
+      end
+
+      it "should return false for has_voted_on?" do
+        voter.has_voted_on?(candidate).should be_false
+      end
+      
+      it "should return 0 for vote_value_for" do
+        voter.vote_value_for(candidate).should == 0
+      end
+    end
+  end
+  
+  context "when creating a vote" do
+    before(:each) do
+      ActsAsCaesar::Vote.should_receive(:find).and_return(ActsAsCaesar::NoVote.new(voter: source, candidate: candidate))
+    end
+    
+    it "should return a positive vote" do
+      voter.update_vote(candidate, 1).should be_kind_of ActsAsCaesar::PositiveVote
+    end
+  end
+  
+  context "when updating a vote to be negative" do
+    before(:each) do
+      ActsAsCaesar::Vote.should_receive(:find).and_return(ActsAsCaesar::PositiveVote.new(voter: source, candidate: candidate))
+    end
+    
+    it "should return a negative vote" do
+      voter.update_vote(candidate, -1).should be_kind_of ActsAsCaesar::NegativeVote
+    end
+  end
+end

data/spec/rack_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require_relative '../lib/acts_as_caesar/rack'
+require 'json'
+require 'rack/test'
+
+ENV['RACK_ENV'] = 'test'
+
+describe Rack::ActsAsCaesar do
+  include Rack::Test::Methods
+
+  let(:rails_response) { [404, {}, []] }
+  let(:rails_app) do 
+    m = mock('rails_app')
+    m.stub(:call).and_return(rails_response)
+    m
+  end
+  let(:app) { Rack::ActsAsCaesar.new(rails_app) }
+  
+  context "when Rails has already rendered a response" do
+    let(:rails_response) { [200, {}, ["Some response"]] }
+    
+    it "should return the response when calling" do
+      app.call({}).should == rails_response
+    end
+  end
+  
+  context "GET /unknown-path" do
+    before do
+      get '/unknown-path'
+    end
+    
+    it "should return 404" do
+      last_response.should be_not_found
+    end
+  end
+    
+  context "GET /votes/1/1-2-3.json" do
+    before do
+      get '/votes/1/1-2-3.json'
+    end
+    
+    it "should return 200" do
+      last_response.should be_ok
+    end
+    
+    context "the JSON response" do
+      subject { JSON.parse(last_response.body) }
+
+      it { should be_kind_of Array }
+
+      it "should contain 3 votes" do
+        subject.size.should == 3
+      end
+
+      context "each vote" do
+        it "should have a candidate" do
+          subject.each do |vote|
+            ['1', '2', '3'].should include vote['candidate'].to_s
+          end
+        end
+        
+        it "should have a voter" do
+          subject.each do |vote|
+            vote['voter'].should == '1'
+          end
+        end
+      end
+    end
+  end
+  
+  context "POST /votes/voter_1/candidate_1.json" do
+    before do
+      post '/votes/voter_1/candidate_1.json', value: '-1'
+    end
+
+    it "should return a 200" do
+      last_response.should be_ok
+    end
+    
+    it "should return a JSON encoded string of the new vote" do
+      vote = JSON.parse(last_response.body)
+      vote['candidate'].should == 'candidate_1'
+      vote['voter'].should == 'voter_1'
+      vote['value'].should == -1
+    end
+  end
+  
+  context "PUT /votes/voter_1/candidate_1.json" do
+    before do
+      put '/votes/voter_1/candidate_1.json', value: '-1'
+    end
+  
+    it "should return a 405" do
+      last_response.should be_method_not_allowed
+    end
+  end
+end

data/spec/rails/engine_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+require_relative '../../lib/acts_as_caesar/rails/engine'
+
+describe ActsAsCaesar::Rails::Engine do
+  subject { ActsAsCaesar::Rails::Engine }
+  
+  it "should subclass Rails::Engine" do
+    subject.superclass.should == ::Rails::Engine
+  end
+end

data/spec/rails/view_helpers_spec.rb

@@ -0,0 +1,30 @@
+require 'rails_helper'
+require 'action_view'
+
+require_relative '../../lib/acts_as_caesar/rails/view_helpers'
+
+class TestViewHelpers < ActionView::Base
+  include ActsAsCaesar::Rails::ViewHelpers
+end
+
+describe ActsAsCaesar::Rails::ViewHelpers do
+  let(:helper) { TestViewHelpers.new }
+  
+  describe "#acts_as_caesar" do
+    it "should render the candidate key" do
+      candidate = mock('candidate', acts_as_caesar_key: 'my_key')
+      tag = helper.acts_as_caesar(candidate: candidate)
+      tag.should include 'data-candidate="my_key"'
+    end
+
+    it "should allow nil voters, but not render empty values" do
+      tag = helper.acts_as_caesar(candidate: "candidate_1")
+      tag.should_not include 'data-voter=""'
+    end
+
+    it "should accept custom HTML attributes" do
+      tag = helper.acts_as_caesar(candidate: "candidate_1", voter: "user_1", html: { class: 'test' })
+      tag.should include 'class="test"'
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,8 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+require "rspec/rails"
+
+Rails.backtrace_cleaner.remove_silencers!

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end

data/vendor/assets/javascripts/acts_as_caesar.js

@@ -0,0 +1 @@
+//= require_tree .

data/vendor/assets/javascripts/initialization.js.coffee

@@ -0,0 +1,36 @@
+window.ActsAsCaesar = {}
+
+window.ActsAsCaesar.init = (options) ->
+  jQuery(document.body).on('init', options.selector, ->
+    $aac = jQuery(this)
+    # set the base path
+    window.ActsAsCaesar.base_path = $aac.data('base-path')
+    # create buttons
+    $button_upvote = jQuery("<button></button>").addClass('upvote').text('Upvote').attr('value', 1)
+    $button_downvote = jQuery("<button></button>").addClass('downvote').text('Downvote').attr('value', -1)
+    # append buttons, update status and set value
+    $aac.append($button_upvote, $button_downvote).attr('data-acts-as-caesar', 'init')
+    # link the vote up
+    VoteView.watch($aac)
+
+  ).on('click', "#{options.selector.replace(/uninit/, 'init')} button", (event) ->
+    $button = jQuery(this)
+    $aac = $button.parent()
+    # set the value to this value
+    if $aac.attr('data-current-value').toString() == $button.val()
+      $aac.data('view').update(0)
+    else
+      $aac.data('view').update($button.val())
+    # should this be nested within a form, we don't want it to submit
+    event.stopPropagation()
+  )
+  # initialize the elements
+  jQuery(options.selector).trigger('init')
+
+if typeof jQuery == 'undefined'
+  console.log "jQuery must be installed to use acts_as_caesar"
+else if typeof window.ActsAsCaesar != 'undefined'
+  jQuery ->
+    ActsAsCaesar.init {
+      selector: "[data-acts-as-caesar='uninit'][data-voter]"
+    }

data/vendor/assets/javascripts/vote.js.coffee

@@ -0,0 +1,45 @@
+class window.Vote
+  value: 0
+
+  @find = (voter, candidate) ->
+    VotePersistence.read(voter, candidate)
+  
+  @load = (voter, candidate, callback) ->
+    VotePersistence.read(voter, candidate, callback)
+
+  # class method: creates a vote based on the passed value
+  # returns: a Positive/Negative/Pending/NoVote object
+  @from_value = (vote_value, voter, candidate) ->  
+    switch vote_value
+      when 1
+        new PositiveVote(voter, candidate)
+      when -1
+        new NegativeVote(voter, candidate)
+      when null
+        new PendingVote(voter, candidate)
+      else
+        new NoVote(voter, candidate)
+
+  # instance method: initializer to store voter and candidate
+  # returns: null
+  constructor: (@voter, @candidate) ->
+    
+  # instance method: changes this vote to a new value
+  # returns: a Positive/Negative/Pending/NoVote object
+  update: (new_value) ->
+    # ensure it's an integer
+    new_value = parseInt(new_value)
+    # write the value to the cache
+    VotePersistence.write(new_value, @voter, @candidate)
+    # return a new vote
+    Vote.from_value(new_value, @voter, @candidate)
+
+class window.NoVote extends Vote
+  
+class window.PendingVote extends Vote
+
+class window.PositiveVote extends Vote
+  value: 1
+
+class window.NegativeVote extends Vote
+  value: -1

data/vendor/assets/javascripts/vote_cache.js.coffee

@@ -0,0 +1,42 @@
+class window.VoteCache
+  # property: the object/class used to cache the values
+  # returns: see above
+  @storageEngine = window.localStorage
+  
+  # property: tests whether the engine is supported
+  # returns: true or false
+  @enabled = ( (engine) ->
+    try
+      return !!engine.getItem
+    catch e
+      return false
+  )(@storageEngine)
+
+  # class method: writes a value to the cache
+  # returns: a CachedVote or NoCachedVote object
+  @write = (value, voter, candidate) ->
+    if @enabled
+      vote = new CachedVote(value)
+      @storageEngine.setItem(voter + '-' + candidate, vote.value)
+      vote
+    else
+      new NoCachedVote()
+
+  # class method: reads a value from the cache
+  # returns: a CachedVote or NoCachedVote object
+  @read = (voter, candidate) ->
+    unless @enabled
+      return new NoCachedVote()
+
+    value = @storageEngine.getItem(voter + '-' + candidate)
+    if value
+      new CachedVote(value)
+    else
+      new NoCachedVote()
+
+class window.CachedVote
+  constructor: (value) ->
+    @value = parseInt(value)
+
+class window.NoCachedVote
+  value: 0

data/vendor/assets/javascripts/vote_persistence.js.coffee

@@ -0,0 +1,51 @@
+if typeof window.ActsAsCaesar != 'undefined'
+  window.ActsAsCaesar ||= {}
+  window.ActsAsCaesar.base_path ||= ''
+
+
+class window.VotePersistence
+  # class method: generates a url to contact the server with
+  @url = (voter, candidates) ->
+    if candidates instanceof Array
+      candidates = candidates.sort().join('-')
+    [window.ActsAsCaesar.base_path, 'votes', voter, candidates].join('/') + '.json'
+
+  # class method: loads the votes asynchronously via AJAX
+  @fetch = (voter, candidates, callback) ->
+    jQuery.ajax {
+      url: this.url(voter, candidates),
+      type: 'GET'
+      dataType: 'json'
+      success: (votes) ->
+        for vote in votes
+          VotePersistence.cache(vote.value, vote.voter, vote.candidate)
+          if callback
+            callback(Vote.from_value(vote.value, vote.voter, vote.candidatee))
+    }
+
+  # class method: reads a vote either from cache or via AJAX
+  @read = (voter, candidate, callback) ->
+    cached_vote = VoteCache.read(voter, candidate)
+    if cached_vote instanceof NoCachedVote
+      @fetch(voter, candidate, callback)
+      Vote.from_value(null, voter, candidate)
+    else
+      vote = Vote.from_value(cached_vote.value, voter, candidate)
+      callback(vote) if callback
+      vote
+      
+  # class method: caches a new value for a vote
+  @cache = (value, voter, candidate) ->
+    # cache the value
+    VoteCache.write(value, voter, candidate)
+  
+  # class method: updates a value for a vote
+  @write = (value, voter, candidate) ->
+    VotePersistence.cache(value, voter, candidate)
+    # write the value back to the server
+    jQuery.ajax {
+      url: this.url(voter, candidate),
+      type: 'POST'
+      dataType: 'json',
+      data: { value: value }
+    }

data/vendor/assets/javascripts/vote_view.js.coffee

@@ -0,0 +1,23 @@
+class window.VoteView
+  @watch = (element) ->
+    view = new VoteView(element)
+    element.data('view', view)
+  
+  constructor: (element) ->
+    @element = element
+    @voter = @element.data('voter')
+    @candidate = @element.data('candidate')
+    @update_status()
+  
+  set_vote: (vote) ->
+    @vote = vote
+    @element.attr('data-current-value', vote.value)
+  
+  update_status: ->
+    view = @
+    @set_vote(Vote.load(@voter, @candidate, (vote) ->
+      view.set_vote(vote)
+    ))
+  
+  update: (value) ->
+    @set_vote(@vote.update(value))