voluntary_ranking 0.0.1

data/app/assets/stylesheets/voluntary_ranking/twitter-typeahead.css.sass

@@ -0,0 +1,29 @@
+.tt-dropdown-menu, .gist 
+    text-align: left
+
+.tt-query 
+    box-shadow: 0 1px 1px rgba(0, 0, 0, 0.075) inset
+
+.tt-hint 
+    color: #999
+
+.tt-dropdown-menu 
+    background-color: #fff
+    border: 1px solid rgba(0, 0, 0, 0.2)
+    border-radius: 8px
+    box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2)
+    margin-top: 12px
+    padding: 8px 0
+    width: 422px
+
+.tt-suggestion 
+    font-size: 18px
+    line-height: 24px
+    padding: 3px 20px
+
+.tt-suggestion.tt-cursor 
+    background-color: #0097cf
+    color: #fff
+
+.tt-suggestion p 
+    margin: 0

data/app/controllers/api/v1/argument_topics_controller.rb

@@ -0,0 +1,12 @@
+class Api::V1::ArgumentTopicsController < ActionController::Base
+  include Voluntary::V1::BaseController
+ 
+  respond_to :json
+  
+  def autocomplete
+    render json: (
+      ArgumentTopic.order(:name).where("name LIKE ?", "%#{params[:term]}%").
+      map{|t| { id: t.id, value: t.name }}
+    ), root: false
+  end
+end

data/app/controllers/api/v1/arguments_controller.rb

@@ -0,0 +1,32 @@
+class Api::V1::ArgumentsController < ActionController::Base
+  include Voluntary::V1::BaseController
+ 
+  respond_to :json
+  
+  def index
+    options = {}
+  
+    arguments = Argument
+    arguments = Argument.where(thing_id: params[:thing_id]) if params[:thing_id].present?
+    options[:json] = arguments.paginate(page: params[:page], per_page: 10)
+    
+    options[:meta] = { 
+      pagination: {
+        total_pages: options[:json].total_pages, current_page: options[:json].current_page,
+        previous_page: options[:json].previous_page, next_page: options[:json].next_page
+      }
+    }
+    
+    respond_with do |format|
+      format.json { render options }
+    end
+  end
+  
+  def create
+    raise CanCan::AccessDenied if current_user.blank?
+    
+    respond_to do |format|
+      format.json { render json: Argument.create_with_topic(params[:argument]) }
+    end
+  end
+end

data/app/controllers/api/v1/ranking_items_controller.rb

@@ -0,0 +1,43 @@
+class Api::V1::RankingItemsController < ActionController::Base
+  include Voluntary::V1::BaseController
+  include Concerns::Controller::BaseRankingItemsController
+  
+  respond_to :json
+  
+  def index
+    options = {}
+    
+    if ranking.present?
+      options[:json] = ranking.items.order('position').includes(:thing).paginate(page: params[:page], per_page: 10)
+      
+      options[:meta] = { 
+        pagination: {
+          total_pages: options[:json].total_pages, current_page: options[:json].current_page,
+          previous_page: options[:json].previous_page, next_page: options[:json].next_page
+        }
+      }
+    else
+      options[:json] = []
+      options[:meta] = { pagination: { total_pages: 0, current_page: 0, previous_page: 0, next_page: 0 } }
+    end
+    
+    respond_with do |format|
+      format.json { render options }
+    end
+  end
+  
+  def show
+    ranking = Ranking.where(
+      '(LOWER(adjective) = :adjective OR LOWER(negative_adjective) = :adjective) AND LOWER(topic) = :topic AND LOWER(scope) = :scope',
+      adjective: params[:adjective].downcase, topic: params[:topic].downcase, scope: params[:scope].downcase
+    ).first
+    thing = Thing.where('LOWER(name) = ?', params[:thing_name].downcase).first
+    ranking_item = RankingItem.where(ranking_id: ranking.try(:id), thing_id: thing.try(:id)).first
+    
+    raise ActiveRecord::RecordNotFound if ranking_item.blank?
+    
+    respond_with do |format|
+      format.json { render json: ranking_item }
+    end
+  end
+end

data/app/controllers/api/v1/rankings_controller.rb

@@ -0,0 +1,29 @@
+class Api::V1::RankingsController < ActionController::Base
+  include Voluntary::V1::BaseController
+  
+  respond_to :json
+  
+  def index
+    options = {}
+  
+    rankings = Ranking
+    rankings = Ranking.for_user(params[:user_name]) if params[:user_name].present?
+    rankings = Ranking.for_thing(params[:thing_id]) if params[:thing_id].present?
+    options[:json] = rankings.paginate page: params[:page], per_page: 1, count: { group: 'rankings.id' }
+    
+    options[:meta] = { 
+      pagination: {
+        total_pages: options[:json].total_pages, current_page: options[:json].current_page,
+        previous_page: options[:json].previous_page, next_page: options[:json].next_page
+      }
+    }
+    
+    respond_with do |format|
+      format.json { render options }
+    end
+  end
+  
+  def autocomplete_attribute
+    render json: Ranking.autocomplete_attribute(params[:attribute], params[:term]), root: false
+  end
+end

data/app/controllers/api/v1/things/arguments_controller.rb

@@ -0,0 +1,40 @@
+class Api::V1::Things::ArgumentsController < ActionController::Base
+  include Voluntary::V1::BaseController
+ 
+  respond_to :json
+  
+  def comparison
+    options = {}
+  
+    arguments = Argument.compare_two_things(params[:side], params[:left_thing_name], params[:right_thing_name]).
+                paginate(page: params[:page], per_page: 10)
+    
+    options[:json] = arguments.map do |argument_comparison|
+      hash = { 
+        left: { id: argument_comparison.id, value: argument_comparison.value },
+        right: { id: argument_comparison.right_id, value: argument_comparison.right_value },
+        topic: { id: argument_comparison.topic_id, name: argument_comparison.topic_name }
+      }
+      
+      if params[:side] == 'right'
+        left = hash[:left].clone
+        right = hash[:right].clone
+        hash[:left] = right
+        hash[:right] = left
+      end
+      
+      hash
+    end
+    
+    options[:meta] = { 
+      pagination: {
+        total_pages: arguments.total_pages, current_page: arguments.current_page,
+        previous_page: arguments.previous_page, next_page: arguments.next_page
+      }
+    }
+    
+    respond_with do |format|
+      format.json { render options }
+    end
+  end
+end

data/app/controllers/api/v1/things_controller.rb

@@ -0,0 +1,26 @@
+class Api::V1::ThingsController < ActionController::Base
+  include Voluntary::V1::BaseController
+
+  respond_to :json
+
+  def show
+    @thing = Thing.where('LOWER(name) = ?', params[:id].downcase).first
+    
+    raise ActiveRecord::RecordNotFound if @thing.blank?
+    
+    respond_with do |format|
+      format.json { render json: @thing, root: true }
+    end
+  end
+  
+  def autocomplete
+    render json: (
+      Thing.order(:name).where("name LIKE ?", "%#{params[:term]}%").
+      map{|t| { id: t.id, value: t.name }}
+    ), root: false
+  end
+  
+  def suggest
+    render json: Thing.suggest(params[:term]), root: false
+  end
+end

data/app/controllers/api/v1/user_ranking_items_controller.rb

@@ -0,0 +1,94 @@
+class Api::V1::UserRankingItemsController < ActionController::Base
+  include Voluntary::V1::BaseController
+  include Concerns::Controller::BaseRankingItemsController
+  
+  respond_to :json
+  
+  def index
+    options = {}
+    
+    if ranking.present?
+      options[:json] = if params[:user_id].present? || params[:user_name].present?
+        user.ranking_items
+      else
+        UserRankingItem
+      end
+      
+      if params[:thing_name].present?
+        options[:json] = options[:json].where(
+          thing_id: Thing.where('LOWER(name) = ?', params[:thing_name].downcase).first.id
+        )
+      end
+      
+      options[:json] = options[:json].order('position').where(ranking_id: ranking.id).includes(:thing)
+      options[:json] = options[:json].paginate(page: params[:page], per_page: 10)
+      
+      options[:meta] = { 
+        pagination: {
+          total_pages: options[:json].total_pages, current_page: options[:json].current_page,
+          previous_page: options[:json].previous_page, next_page: options[:json].next_page
+        }
+      }
+    else
+      options[:json] = []
+      options[:meta] = { pagination: { total_pages: 0, current_page: 0, previous_page: 0, next_page: 0 } }
+    end
+    
+    respond_with do |format|
+      format.json { render options }
+    end
+  end
+  
+  def create
+    raise CanCan::AccessDenied if current_user.blank?
+    
+    respond_to do |format|
+      format.json { render json: current_user.add_ranking_item(params[:user_ranking_item]) }
+    end
+  end
+  
+  def update
+    user_ranking_item = current_user.ranking_items.find(params[:id])
+    user_ranking_item.update_stars params[:user_ranking_item][:stars]
+    respond_with user_ranking_item
+  end
+  
+  def move
+    user_ranking_item = UserRankingItem.find(params[:id])
+    
+    raise CanCan::AccessDenied unless can? :update, user_ranking_item
+    
+    user_ranking_item.set_position(params[:position].to_i)
+    respond_with user_ranking_item
+  end
+  
+  def move_to_page
+    user_ranking_item = UserRankingItem.find(params[:id])
+    
+    raise CanCan::AccessDenied unless can? :update, user_ranking_item
+    
+    user_ranking_item.move_to_top_of_page(params[:page])
+    
+    respond_to do |format|
+      format.json { render json: user_ranking_item }
+    end
+  end
+  
+  def destroy
+    current_user.ranking_items.find(params[:id]).destroy!
+    
+    render nothing: true
+  end
+  
+  private
+  
+  def user
+    if @user
+      @user
+    elsif params[:user_id].present?
+      @user = User.find(params[:user_id])
+    elsif params[:user_name].present?
+      @user = User.where('LOWER(name) = ?', params[:user_name].downcase).first
+    end
+  end
+end

data/app/controllers/api/v1/users_controller.rb

@@ -0,0 +1,9 @@
+class Api::V1::UsersController < ActionController::Base
+  include Voluntary::V1::BaseController
+
+  respond_to :json
+ 
+  def show
+    respond_with User.find(params[:id])
+  end
+end

data/app/controllers/product/ranking_controller.rb

@@ -0,0 +1,16 @@
+class Product::RankingController < Voluntary::EmberJs::ApplicationController
+  layout Proc.new { |controller| controller.request.xhr? || request.format.try('json?') ? false : 'voluntary/ember_js' }
+  
+  def index
+  end
+  
+  protected
+  
+  def voluntary_ember_js_stylesheets
+    ['voluntary_ranking/application']
+  end
+  
+  def voluntary_ember_js_javascripts
+    ['voluntary_ranking/application']
+  end
+end

data/app/models/argument.rb

@@ -0,0 +1,48 @@
+class Argument < ActiveRecord::Base
+  belongs_to :topic, class_name: 'ArgumentTopic'
+  belongs_to :thing
+  
+  scope :compare_two_things, ->(side, left_thing_name, right_thing_name) do
+    left_thing_name, right_thing_name = right_thing_name, left_thing_name if side == 'right'
+      
+    left_thing = Thing.where('LOWER(name) = ?', left_thing_name.downcase).first
+    right_thing = Thing.where('LOWER(name) = ?', right_thing_name.downcase).first
+    
+    scope = joins(:topic).select('arguments.id, arguments.value, arguments.topic_id, argument_topics.name AS topic_name, arguments2.id AS right_id, arguments2.value AS right_value').
+    joins("#{side == 'both' ? 'INNER' : 'LEFT'} JOIN arguments arguments2 ON arguments2.thing_id = #{sanitize(right_thing.id)} AND arguments2.topic_id = arguments.topic_id")
+    scope = scope.where('arguments2.id IS NULL') unless side == 'both'
+    scope.where('arguments.thing_id = ?', left_thing.id)
+  end
+  
+  validates :topic_id, presence: true
+  validates :thing_id, presence: true, uniqueness: { scope: :topic_id }
+  validates :value, presence: true
+  
+  attr_accessible :topic_id, :thing_id, :value
+  
+  def self.create_with_topic(attributes)
+    topic = ArgumentTopic.where('LOWER(name) = ?', attributes[:topic_name].to_s.strip.downcase).first
+    
+    unless topic
+      topic = ArgumentTopic.create(name: attributes[:topic_name].to_s.strip)
+    end
+    
+    if topic.valid?
+      thing_id = if attributes[:thing_name].present?
+        Thing.where('LOWER(name) = ?', attributes[:thing_name].downcase).first.id
+      else
+        Thing.where(id: attributes[:thing_id]).first.try(:id)
+      end
+      
+      argument = Argument.create(topic_id: topic.id, thing_id: thing_id, value: attributes[:value])
+      
+      if argument.valid?
+        argument
+      else
+        { errors: argument.errors.to_hash }
+      end
+    else
+      { errors: { topic: topic.errors.to_hash } }
+    end
+  end
+end

data/app/models/argument_topic.rb

@@ -0,0 +1,7 @@
+class ArgumentTopic < ActiveRecord::Base
+  has_many :arguments
+  
+  validates :name, presence: true, uniqueness: { case_sensitive: false }
+  
+  attr_accessible :name, :text
+end

data/app/models/product/ranking.rb

@@ -0,0 +1,2 @@
+class Product::Ranking < ::Product
+end

data/app/models/ranking.rb

@@ -0,0 +1,97 @@
+class Ranking < ActiveRecord::Base
+  attr_accessible :adjective, :topic, :scope, :negative_adjective
+  
+  has_many :items, class_name: 'RankingItem', dependent: :destroy
+  has_many :user_items, class_name: 'UserRankingItem', dependent: :destroy
+  
+  scope :for_user, ->(user_name) do
+    all.select('DISTINCT(rankings.id), rankings.*').joins(:user_items).
+    where('user_ranking_items.user_id = ?', User.where('LOWER(name) = ?', user_name.downcase).first.id)
+  end 
+
+  scope :for_thing, ->(thing_id) do
+    all.select('DISTINCT(rankings.id), rankings.*').joins(:items).where('ranking_items.thing_id = ?', thing_id)
+  end 
+  
+  validates :adjective, presence: true
+  validates :topic, presence: true, uniqueness: { scope: [:adjective, :scope], case_sensitive: false }
+  validates :scope, presence: true
+  validate :one_ranking_per_topic_scope_and_one_of_the_adjectives
+  
+  #pusherable "#{Rails.env}_channel"
+  
+  def self.find_by_params(params)
+    scope = if params[:negative_adjective].present?
+      where(
+        'LOWER(adjective) = ? AND LOWER(negative_adjective) = ?', 
+        params[:adjective].downcase, params[:negative_adjective].downcase
+      )
+    else
+      where(
+        '(LOWER(adjective) = :adjective OR LOWER(negative_adjective) = :adjective)', 
+        adjective: params[:adjective].downcase
+      )
+    end
+     
+    scope.where(
+      'LOWER(topic) = ? AND LOWER(scope) = ?', params[:topic].downcase, params[:scope].downcase
+    ).first
+  end
+  
+  def self.find_or_create_by_params(params)
+    attributes = (params[:user_ranking_item] || params[:ranking_item] || params).clone
+    attributes.symbolize_keys! unless params.is_a?(ActiveSupport::HashWithIndifferentAccess)
+    
+    if attributes[:ranking_id].present? then Ranking.find(attributes[:ranking_id])
+    elsif attributes[:adjective].present?
+      rankings = Ranking
+      ranking  = Ranking.new
+      
+      attributes.each do |param, value| 
+        if ranking.respond_to?(param) && value.present?
+          rankings = rankings.where("LOWER(#{param}) = ?", value.downcase)
+        else
+          attributes.delete(param)
+        end
+      end
+       
+      rankings.first || Ranking.create(attributes)
+    end
+  end
+  
+  def self.autocomplete_attribute(attribute, term)
+    unless ['adjective', 'negative_adjective', 'topic', 'scope'].include? attribute
+      raise ActiveRecord::RecordNotFound
+    end
+    
+    Ranking.select("DISTINCT(#{attribute})").order(attribute).limit(10).
+    where("#{attribute} LIKE ?", "%#{term.strip}%").map(&attribute.to_sym).map{|v| { value: v }}
+  end
+  
+  private
+  
+  def one_ranking_per_topic_scope_and_one_of_the_adjectives
+    if Ranking.where(
+      '(' +
+      'LOWER(adjective) = :adjective OR LOWER(negative_adjective) = :adjective OR ' +
+      'LOWER(adjective) = :negative_adjective OR LOWER(negative_adjective) = :negative_adjective' +
+      ') AND ' + 
+      'LOWER(topic) = :topic AND LOWER(scope) = :scope',
+      adjective: adjective.downcase, negative_adjective: negative_adjective.downcase, 
+      topic: topic.downcase, scope: scope.downcase
+    ).any?
+      errors[:base] << I18n.t(
+        'activerecord.errors.models.ranking.attributes.base.' + 
+        'one_ranking_per_topic_scope_and_one_of_the_adjectives'
+      )
+    end
+  end
+  
+  def special_characters_excluded
+    if adjective.match(/\//) || negative_adjective.match(/\//) || topic.match(/\//) || scope.match(/\//)
+      errors[:name] << I18n.t(
+        'activerecord.errors.models.ranking.attributes.name.unwanted_special_characters_included'
+      )
+    end
+  end
+end