merit 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0822239c7421032c0da3487684baadd738b4805
-  data.tar.gz: 44eb5162425fc37edb09615e7f95f112d6b8cf04
+  metadata.gz: 62f239d505d3f998184052a8cc62602609fcc06d
+  data.tar.gz: c1d5bdba54829b26022f9b68322025574e0078df
 SHA512:
-  metadata.gz: 5379050b40dd4b93083443c349cf0726ee7fa436708cb2d8a4456f86b1a2b6de5c0b2dae51205613bca4b39fb5ea6bd9afded0d45d07fbfa962654284b31c08c
-  data.tar.gz: 346cf4cd10a20c4bfb07b1579cf16291ec77b6906b1f22999444bc7950b797d3fc372dfc4a63e8e393c56117b211e33ca571d8bacd1a8c7c3de5209c4130f8d9
+  metadata.gz: e58ae9a432d4d9a74cf5fed778acee101d39d17cef09a3d8e8fcdd994589d5ce1d091fda10f103d45e3e2a0bfe22b83ae42e536040717badf6586baea0c2cefe
+  data.tar.gz: b1d067b943eb541adf433b6e775d8bd9ba01d606897ccec084f57aff26c055ffa9c248f3c444356fc1f3b576fd9e17e0e9372b1d046a16f74e794a3eeb77270a

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 2.1.0
+
+- [#148] Mongoid support
+- Docs, tests, internals polishing.
+
 ## 2.0.0
 
 - [#146] Fixes loading paths

data/Gemfile

@@ -22,12 +22,12 @@ case ENV['ORM']
 when 'active_record'
   gem 'activerecord'
 when 'mongoid'
-  gem 'mongoid', '3.0.10'
+  gem 'mongoid', '3.1.0'
 end
 
 group :development, :test do
   gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
-  gem 'sqlite3', :platforms => [:ruby, :mswin, :mingw]
+  gem 'sqlite3', '1.3.8', :platforms => [:ruby, :mswin, :mingw]
 end
 
 platforms :rbx do
@@ -36,3 +36,5 @@ platforms :rbx do
   gem 'rubysl-test-unit'
   gem 'rubinius-developer_tools'
 end
+
+gem 'coveralls', require: false

data/README.md

@@ -4,6 +4,8 @@ Merit adds reputation behavior to Rails apps in the form of Badges, Points,
 and Rankings.
 
 [![Build Status](https://travis-ci.org/tute/merit.png?branch=master)](http://travis-ci.org/tute/merit)
+[![Coverage
+Status](https://coveralls.io/repos/tute/merit/badge.png?branch=master)](https://coveralls.io/r/tute/merit?branch=master)
 [![Code Climate](https://codeclimate.com/github/tute/merit.png)](https://codeclimate.com/github/tute/merit)
 
 
@@ -36,7 +38,8 @@ and Rankings.
 2. Run `rails g merit:install`
 3. Run `rails g merit MODEL_NAME` (e.g. `user`)
 4. Run `rake db:migrate`
-5. Define badges in `config/initializers/merit.rb`
+5. Define badges in `config/initializers/merit.rb`. You can also define ORM:
+   `:active_record` (default) or `:mongoid`.
 6. Configure reputation rules for your application in `app/models/merit/*`
 
 
@@ -77,13 +80,15 @@ Badge rules / conditions are defined in `app/models/merit/badge_rules.rb`
 * `'controller#action'` a string similar to Rails routes
 * `:badge` corresponds to the `:name` of the badge
 * `:level` corresponds to the `:level` of the badge
-* `:to` the object's field to give the badge to
-  * If you are putting badges on the related user then this field is probably
-    `:user`.
-  * Needs a variable named `@model` in the associated controller action, like
-    `@post` for `posts_controller.rb` or `@comment` for `comments_controller.rb`.
-    Implementation note: Merit finds the object with following snippet:
-    `instance_variable_get(:"@#{controller_name.singularize}")`.
+* `:to` the object's field to give the badge to. It needs a variable named
+  `@model` in the associated controller action, like `@post` for
+  `posts_controller.rb` or `@comment` for `comments_controller.rb`.
+  * Can be a method name, which called over the target object should retrieve
+    the object to badge. If it's `:user` for example, merit will internally
+    call `@model.user` to find who to badge.
+  * Can be `:itself`, in which case it badges the target object itself
+    (`@model`).
+  * Is `:action_user` by default, which means `current_user`.
 * `:model_name` define the controller's name if it's different from
   the model's (e.g. `RegistrationsController` for the `User` model).
 * `:multiple` whether or not the badge may be granted multiple times. `false` by default.
@@ -266,17 +271,31 @@ To do so, add your observer (to `app/models` or `app/observers`, for example):
 # reputation_change_observer.rb
 class ReputationChangeObserver
   def update(changed_data)
-    # `changed_data[:description]` holds information on what changed
-    # badges granted or removed, points changed.
-
-    # `changed_data[:merit_object]` reputation related object created by merit.
-    # It responds to `sash_id` and `sash`. From there you can get to your
-    # application object that had it's reputation changed, for example:
-    # sash_id = changed_data[:merit_object].sash_id
-    # User.where(sash_id: sash_id).first
-
-    # You may use this to fill a timeline with notifications for users, send
-    # emails, etc.
+    # description will be something like:
+    #   granted 5 points
+    #   granted just-registered badge
+    #   removed autobiographer badge
+    description = changed_data[:description]
+
+    # If user is your meritable model, you can grab it like:
+    if changed_data[:merit_object]
+      sash_id = changed_data[:merit_object].sash_id
+      user = User.where(sash_id: sash_id).first
+    end
+
+    # To know where and when it happened:
+    merit_action = Merit::Action.find changed_data[:merit_action_id]
+    controller = merit_action.target_model
+    action = merit_action.action_method
+    when = merit_action.created_at
+
+    # From here on, you can create a new Notification assuming that's an
+    # ActiveRecord Model in your app, send an email, etc. For example:
+    Notification.create(
+      user: user,
+      what: description,
+      where: "#{controller}##{action}",
+      when: when)
   end
 end
 ```
@@ -285,6 +304,10 @@ end
 config.add_observer 'ReputationChangeObserver'
 ```
 
+TODO: Improve API sending in `changed_data` concrete data instead of merit
+objects.
+
+
 # Uninstalling Merit
 
 1. Run `rails d merit:install`

data/app/models/merit/badge.rb

@@ -6,7 +6,7 @@ module Merit
     extend Ambry::Model
     extend Ambry::ActiveModel
 
-    field :id, :name, :level, :image, :description, :custom_fields
+    field :id, :name, :level, :description, :custom_fields
 
     validates_presence_of :id, :name
     validates_uniqueness_of :id
@@ -26,6 +26,14 @@ module Merit
       end
     end
 
+    def _mongoid_sash_in(sashes)
+      {:sash_id.in => sashes}
+    end
+
+    def _active_record_sash_in(sashes)
+      {sash_id: sashes}
+    end
+
     class << self
       def find_by_name_and_level(name, level)
         badges = Badge.by_name(name)
@@ -48,10 +56,11 @@ module Merit
 
       # Defines Badge#meritable_models method, to get related
       # entries with certain badge. For instance, Badge.find(3).users
+      # orm-specified
       def _define_related_entries_method(meritable_class_name)
         define_method(:"#{meritable_class_name.underscore.pluralize}") do
           sashes = BadgesSash.where(badge_id: id).pluck(:sash_id)
-          meritable_class_name.constantize.where(sash_id: sashes)
+          meritable_class_name.constantize.where(send "_#{Merit.orm}_sash_in", sashes)
         end
       end
     end

data/lib/merit/controller_extensions.rb

@@ -48,10 +48,19 @@ module Merit
       target_id = target_object.try(:id)
       # If target_id is nil
       # then use params[:id].
-      if target_id.nil? && params[:id].to_s =~ /^[0-9]+$/
+      if target_id.nil? && send("check_#{Merit.orm}_id", params[:id])
         target_id = params[:id]
       end
       target_id
     end
+
+    # This check avoids trying to set a slug as integer FK
+    def check_active_record_id(id)
+      id.to_s =~ /^[0-9]+$/
+    end
+
+    def check_mongoid_id(id)
+      id.to_s =~ /^[0-9a-fA-F]{24}$/
+    end
   end
 end

data/lib/merit/model_additions.rb

@@ -7,7 +7,8 @@ module Merit
       # That's why MeritableModel belongs_to Sash. Can't use
       # dependent: destroy as it may raise FK constraint exceptions. See:
       # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/1079-belongs_to-dependent-destroy-should-destroy-self-before-assocation
-      belongs_to :sash, class_name: 'Merit::Sash'
+      belongs_to :sash, class_name: 'Merit::Sash', inverse_of: nil
+      attr_accessible :sash if show_attr_accessible?
 
       send :"_merit_#{Merit.orm}_specific_config"
       _merit_delegate_methods_to_sash
@@ -48,7 +49,7 @@ module Merit
     # http://blog.hasmanythrough.com/2012/1/20/modularized-association-methods-in-rails-3-2
     def _merit_sash_initializer
       define_method(:_sash) do
-        sash || update_attribute(:sash_id, Sash.create.id)
+        sash || update_attributes(sash: Sash.create)
         sash
       end
     end

data/lib/merit/models/active_record/merit/sash.rb

@@ -12,14 +12,18 @@ module Merit
 
     after_create :create_scores
 
-    def add_badge(badge_id)
-      bs = BadgesSash.new(badge_id: badge_id)
-      badges_sashes << bs
-      bs
-    end
-
-    def rm_badge(badge_id)
-      badges_sashes.find_by_badge_id(badge_id).try(:destroy)
+    # Retrieve all points from a category or none if category doesn't exist
+    # By default retrieve all Points
+    # @param category [String] The category
+    # @return [ActiveRecord::Relation] containing the points
+    def score_points(options = {})
+      scope = Merit::Score::Point
+                .includes(:score)
+                .where('merit_scores.sash_id = ?', id)
+      if (category = options[:category])
+        scope = scope.where('merit_scores.category = ?', category)
+      end
+      scope
     end
   end
 end

data/lib/merit/models/active_record/merit/score.rb

@@ -16,6 +16,7 @@ module Merit
       has_many :activity_logs,
                class_name: 'Merit::ActivityLog',
                as: :related_change
+      delegate :sash_id, to: :score
     end
   end
 end

data/lib/merit/models/base/sash.rb

@@ -9,6 +9,16 @@ module Merit
         badges_sashes.map(&:badge_id)
       end
 
+      def add_badge(badge_id)
+        bs = Merit::BadgesSash.new(badge_id: badge_id)
+        badges_sashes << bs
+        bs
+      end
+
+      def rm_badge(badge_id)
+        badges_sashes.where(badge_id: badge_id).first.try(:destroy)
+      end
+
       # Retrieve the number of points from a category
       # By default all points are summed up
       # @param category [String] The category
@@ -21,20 +31,6 @@ module Merit
         end
       end
 
-      # Retrieve all points from a category or none if category doesn't exist
-      # By default retrieve all Points
-      # @param category [String] The category
-      # @return [ActiveRecord::Relation] containing the points
-      def score_points(options = {})
-        scope = Merit::Score::Point
-                  .includes(:score)
-                  .where('merit_scores.sash_id = ?', id)
-        if (category = options[:category])
-          scope = scope.where('merit_scores.category = ?', category)
-        end
-        scope
-      end
-
       def add_points(num_points, options = {})
         point = Merit::Score::Point.new
         point.num_points = num_points

data/lib/merit/models/mongoid/merit/badges_sash.rb

@@ -8,6 +8,7 @@ module Merit
 
     attr_accessible :badge_id if show_attr_accessible?
 
+    belongs_to :sash, class_name: 'Merit::Sash'
     has_many :activity_logs, class_name: 'Merit::ActivityLog', as: :related_change
 
     def self.last_granted(options = {})

data/lib/merit/models/mongoid/merit/sash.rb

@@ -15,14 +15,16 @@ module Merit
 
     after_create :create_scores
 
-    def add_badge(badge_id)
-      bs = Merit::BadgesSash.new(badge_id: badge_id)
-      badges_sashes.push(bs)
-    end
-
-    def rm_badge(badge_id)
-      bs = badges_sashes.where(badge_id: badge_id).first
-      badges_sashes.delete(bs)
+    # Retrieve all points from a category or none if category doesn't exist
+    # By default retrieve all Points
+    # @param category [String] The category
+    # @return [ActiveRecord::Relation] containing the points
+    def score_points(options = {})
+      scope = scores
+      if (category = options[:category])
+        scope = scope.where(category: category)
+      end
+      Merit::Score::Point.where(:score_id.in => scope.map(&:_id))
     end
   end
 end

data/lib/merit/models/mongoid/merit/score.rb

@@ -5,7 +5,7 @@ module Merit
 
     field :category, type: String, default: 'default'
 
-    belongs_to :sash
+    belongs_to :sash, class_name: 'Merit::Sash'
     has_many :score_points, class_name: 'Merit::Score::Point', dependent: :destroy
 
     # Meant to display a leaderboard. Accepts options :table_name (users by
@@ -36,6 +36,10 @@ module Merit
 
       belongs_to :score, class_name: 'Merit::Score'
       has_many :activity_logs, class_name: 'Merit::ActivityLog', as: :related_change
+
+      def sash_id
+        score.sash_id
+      end
     end
   end
 end

data/lib/merit/reputation_change_observer.rb

@@ -1,9 +1,11 @@
 module Merit
   class ReputationChangeObserver
     def update(changed_data)
+      # TODO: sometimes we recieved true in changed_data[:merit_object]
+      # it should be nil or merit object with activity_logs relation
       ActivityLog.create(
         description:    changed_data[:description],
-        related_change: changed_data[:merit_object],
+        related_change: (changed_data[:merit_object] if changed_data[:merit_object].respond_to?(:activity_logs)),
         action_id:      changed_data[:merit_action_id]
       )
     end

data/lib/merit.rb

@@ -72,10 +72,10 @@ module Merit
 
   class Engine < Rails::Engine
     config.app_generators.orm Merit.orm
-    config.eager_load_paths << File.expand_path("../merit/models/#{Merit.orm}", __FILE__)
 
     initializer 'merit.controller' do |app|
       extend_orm_with_has_merit
+      require_models
       ActiveSupport.on_load(:action_controller) do
         begin
           # Load app rules on boot up
@@ -89,6 +89,15 @@ module Merit
       end
     end
 
+    def require_models
+      require 'merit/models/base/sash'
+      require 'merit/models/base/badges_sash'
+      require "merit/models/#{Merit.orm}/merit/activity_log"
+      require "merit/models/#{Merit.orm}/merit/badges_sash"
+      require "merit/models/#{Merit.orm}/merit/sash"
+      require "merit/models/#{Merit.orm}/merit/score"
+    end
+
     def extend_orm_with_has_merit
       if Object.const_defined?('ActiveRecord')
         ActiveRecord::Base.send :include, Merit

data/merit.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/tute/merit"
   s.files       = `git ls-files`.split("\n").reject{|f| f =~ /^\./ }
   s.license     = 'MIT'
-  s.version     = '2.0.0'
+  s.version     = '2.1.0'
   s.authors     = ["Tute Costa"]
   s.email       = 'tutecosta@gmail.com'
 
@@ -13,6 +13,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'ambry',  '~> 0.3.0'
   s.add_development_dependency 'rails', '>= 3.2.0'
+  s.add_development_dependency 'jquery-rails', '~> 2.1'
   s.add_development_dependency 'capybara'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'rubocop'

data/test/dummy/app/models/comment.rb

@@ -1,6 +1,9 @@
 case Merit.orm
 when :active_record
   class Comment < ActiveRecord::Base
+    def friend
+      User.find_by_name('friend')
+    end
   end
 when :mongoid
   class Comment
@@ -9,7 +12,11 @@ when :mongoid
 
     field :name, :type => String
     field :comment, :type => String
-    field :votes, :type => Integer
+    field :votes, :type => Integer, :default => 0
+
+    def friend
+      User.find_by(name: 'friend')
+    end
   end
 end
 
@@ -25,8 +32,4 @@ class Comment
   validates :name, :comment, :user_id, :presence => true
 
   delegate :comments, :to => :user, :prefix => true
-
-  def friend
-    User.find_by_name('friend')
-  end
 end

data/test/dummy/app/views/layouts/application.html.erb

@@ -4,6 +4,8 @@
   <meta charset="utf-8" />
   <title>Merit Dummy app</title>
   <%= stylesheet_link_tag :all %>
+  <script src="//ajax.googleapis.com/ajax/libs/jquery/2.1.0/jquery.min.js"></script>
+  <script src="/rails.js"></script>
   <%= csrf_meta_tag %>
 </head>
 <body>

data/test/dummy/config/environments/test.rb

@@ -30,5 +30,5 @@ Dummy::Application.configure do
   # Print deprecation notices to the stderr
   config.active_support.deprecation = :stderr
 
-  config.eager_load = false
+  config.eager_load = ENV['RAILS_VERSION'] == '4.0' || ENV['RAILS_VERSION'] == '4.0-protected-attributes'
 end

data/test/dummy/config/mongoid.yml

@@ -1,13 +1,13 @@
 development:
   sessions:
     default:
-      database: mongoid_dev
+      database: merit_dev
       hosts:
         - localhost:27017
 
 test:
   sessions:
     default:
-      database: mongoid_test
+      database: merit_test
       hosts:
         - localhost:27017

data/test/dummy/config/routes.rb

@@ -10,7 +10,7 @@ Dummy::Application.routes.draw do
   resources :registrations, :only => :update, :as => :registrations_user
   resources :comments
 
-  get '/comments/:id/vote/:value' => 'comments#vote', :id => /\d+/, :value => /\d+/
+  get '/comments/:id/vote/:value' => 'comments#vote', :value => /\d+/
 
   root :to => 'users#index'
 end

data/test/dummy/public/rails.js

@@ -0,0 +1,404 @@
+(function($, undefined) {
+
+/**
+ * Unobtrusive scripting adapter for jQuery
+ * https://github.com/rails/jquery-ujs
+ *
+ * Requires jQuery 1.7.0 or later.
+ *
+ * Released under the MIT license
+ *
+ */
+
+  // Cut down on the number of issues from people inadvertently including jquery_ujs twice
+  // by detecting and raising an error when it happens.
+  if ( $.rails !== undefined ) {
+    $.error('jquery-ujs has already been loaded!');
+  }
+
+  // Shorthand to make it a little easier to call public rails functions from within rails.js
+  var rails;
+  var $document = $(document);
+
+  $.rails = rails = {
+    // Link elements bound by jquery-ujs
+    linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote], a[data-disable-with]',
+
+    // Button elements bound by jquery-ujs
+    buttonClickSelector: 'button[data-remote], button[data-confirm]',
+
+    // Select elements bound by jquery-ujs
+    inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
+
+    // Form elements bound by jquery-ujs
+    formSubmitSelector: 'form',
+
+    // Form input elements bound by jquery-ujs
+    formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type])',
+
+    // Form input elements disabled during form submission
+    disableSelector: 'input[data-disable-with], button[data-disable-with], textarea[data-disable-with]',
+
+    // Form input elements re-enabled after form submission
+    enableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled',
+
+    // Form required input elements
+    requiredInputSelector: 'input[name][required]:not([disabled]),textarea[name][required]:not([disabled])',
+
+    // Form file input elements
+    fileInputSelector: 'input[type=file]',
+
+    // Link onClick disable selector with possible reenable after remote submission
+    linkDisableSelector: 'a[data-disable-with]',
+
+    // Make sure that every Ajax request sends the CSRF token
+    CSRFProtection: function(xhr) {
+      var token = $('meta[name="csrf-token"]').attr('content');
+      if (token) xhr.setRequestHeader('X-CSRF-Token', token);
+    },
+
+    // making sure that all forms have actual up-to-date token(cached forms contain old one)
+    refreshCSRFTokens: function(){
+      var csrfToken = $('meta[name=csrf-token]').attr('content');
+      var csrfParam = $('meta[name=csrf-param]').attr('content');
+      $('form input[name="' + csrfParam + '"]').val(csrfToken);
+    },
+
+    // Triggers an event on an element and returns false if the event result is false
+    fire: function(obj, name, data) {
+      var event = $.Event(name);
+      obj.trigger(event, data);
+      return event.result !== false;
+    },
+
+    // Default confirm dialog, may be overridden with custom confirm dialog in $.rails.confirm
+    confirm: function(message) {
+      return confirm(message);
+    },
+
+    // Default ajax function, may be overridden with custom function in $.rails.ajax
+    ajax: function(options) {
+      return $.ajax(options);
+    },
+
+    // Default way to get an element's href. May be overridden at $.rails.href.
+    href: function(element) {
+      return element.attr('href');
+    },
+
+    // Submits "remote" forms and links with ajax
+    handleRemote: function(element) {
+      var method, url, data, elCrossDomain, crossDomain, withCredentials, dataType, options;
+
+      if (rails.fire(element, 'ajax:before')) {
+        elCrossDomain = element.data('cross-domain');
+        crossDomain = elCrossDomain === undefined ? null : elCrossDomain;
+        withCredentials = element.data('with-credentials') || null;
+        dataType = element.data('type') || ($.ajaxSettings && $.ajaxSettings.dataType);
+
+        if (element.is('form')) {
+          method = element.attr('method');
+          url = element.attr('action');
+          data = element.serializeArray();
+          // memoized value from clicked submit button
+          var button = element.data('ujs:submit-button');
+          if (button) {
+            data.push(button);
+            element.data('ujs:submit-button', null);
+          }
+        } else if (element.is(rails.inputChangeSelector)) {
+          method = element.data('method');
+          url = element.data('url');
+          data = element.serialize();
+          if (element.data('params')) data = data + "&" + element.data('params');
+        } else if (element.is(rails.buttonClickSelector)) {
+          method = element.data('method') || 'get';
+          url = element.data('url');
+          data = element.serialize();
+          if (element.data('params')) data = data + "&" + element.data('params');
+        } else {
+          method = element.data('method');
+          url = rails.href(element);
+          data = element.data('params') || null;
+        }
+
+        options = {
+          type: method || 'GET', data: data, dataType: dataType,
+          // stopping the "ajax:beforeSend" event will cancel the ajax request
+          beforeSend: function(xhr, settings) {
+            if (settings.dataType === undefined) {
+              xhr.setRequestHeader('accept', '*/*;q=0.5, ' + settings.accepts.script);
+            }
+            if (rails.fire(element, 'ajax:beforeSend', [xhr, settings])) {
+              element.trigger('ajax:send', xhr);
+            } else {
+              return false;
+            }
+          },
+          success: function(data, status, xhr) {
+            element.trigger('ajax:success', [data, status, xhr]);
+          },
+          complete: function(xhr, status) {
+            element.trigger('ajax:complete', [xhr, status]);
+          },
+          error: function(xhr, status, error) {
+            element.trigger('ajax:error', [xhr, status, error]);
+          },
+          crossDomain: crossDomain
+        };
+
+        // There is no withCredentials for IE6-8 when
+        // "Enable native XMLHTTP support" is disabled
+        if (withCredentials) {
+          options.xhrFields = {
+            withCredentials: withCredentials
+          };
+        }
+
+        // Only pass url to `ajax` options if not blank
+        if (url) { options.url = url; }
+
+        return rails.ajax(options);
+      } else {
+        return false;
+      }
+    },
+
+    // Handles "data-method" on links such as:
+    // <a href="/users/5" data-method="delete" rel="nofollow" data-confirm="Are you sure?">Delete</a>
+    handleMethod: function(link) {
+      var href = rails.href(link),
+        method = link.data('method'),
+        target = link.attr('target'),
+        csrfToken = $('meta[name=csrf-token]').attr('content'),
+        csrfParam = $('meta[name=csrf-param]').attr('content'),
+        form = $('<form method="post" action="' + href + '"></form>'),
+        metadataInput = '<input name="_method" value="' + method + '" type="hidden" />';
+
+      if (csrfParam !== undefined && csrfToken !== undefined) {
+        metadataInput += '<input name="' + csrfParam + '" value="' + csrfToken + '" type="hidden" />';
+      }
+
+      if (target) { form.attr('target', target); }
+
+      form.hide().append(metadataInput).appendTo('body');
+      form.submit();
+    },
+
+    /* Disables form elements:
+      - Caches element value in 'ujs:enable-with' data store
+      - Replaces element text with value of 'data-disable-with' attribute
+      - Sets disabled property to true
+    */
+    disableFormElements: function(form) {
+      form.find(rails.disableSelector).each(function() {
+        var element = $(this), method = element.is('button') ? 'html' : 'val';
+        element.data('ujs:enable-with', element[method]());
+        element[method](element.data('disable-with'));
+        element.prop('disabled', true);
+      });
+    },
+
+    /* Re-enables disabled form elements:
+      - Replaces element text with cached value from 'ujs:enable-with' data store (created in `disableFormElements`)
+      - Sets disabled property to false
+    */
+    enableFormElements: function(form) {
+      form.find(rails.enableSelector).each(function() {
+        var element = $(this), method = element.is('button') ? 'html' : 'val';
+        if (element.data('ujs:enable-with')) element[method](element.data('ujs:enable-with'));
+        element.prop('disabled', false);
+      });
+    },
+
+   /* For 'data-confirm' attribute:
+      - Fires `confirm` event
+      - Shows the confirmation dialog
+      - Fires the `confirm:complete` event
+
+      Returns `true` if no function stops the chain and user chose yes; `false` otherwise.
+      Attaching a handler to the element's `confirm` event that returns a `falsy` value cancels the confirmation dialog.
+      Attaching a handler to the element's `confirm:complete` event that returns a `falsy` value makes this function
+      return false. The `confirm:complete` event is fired whether or not the user answered true or false to the dialog.
+   */
+    allowAction: function(element) {
+      var message = element.data('confirm'),
+          answer = false, callback;
+      if (!message) { return true; }
+
+      if (rails.fire(element, 'confirm')) {
+        answer = rails.confirm(message);
+        callback = rails.fire(element, 'confirm:complete', [answer]);
+      }
+      return answer && callback;
+    },
+
+    // Helper function which checks for blank inputs in a form that match the specified CSS selector
+    blankInputs: function(form, specifiedSelector, nonBlank) {
+      var inputs = $(), input, valueToCheck,
+          selector = specifiedSelector || 'input,textarea',
+          allInputs = form.find(selector);
+
+      allInputs.each(function() {
+        input = $(this);
+        valueToCheck = input.is('input[type=checkbox],input[type=radio]') ? input.is(':checked') : input.val();
+        // If nonBlank and valueToCheck are both truthy, or nonBlank and valueToCheck are both falsey
+        if (!valueToCheck === !nonBlank) {
+
+          // Don't count unchecked required radio if other radio with same name is checked
+          if (input.is('input[type=radio]') && allInputs.filter('input[type=radio]:checked[name="' + input.attr('name') + '"]').length) {
+            return true; // Skip to next input
+          }
+
+          inputs = inputs.add(input);
+        }
+      });
+      return inputs.length ? inputs : false;
+    },
+
+    // Helper function which checks for non-blank inputs in a form that match the specified CSS selector
+    nonBlankInputs: function(form, specifiedSelector) {
+      return rails.blankInputs(form, specifiedSelector, true); // true specifies nonBlank
+    },
+
+    // Helper function, needed to provide consistent behavior in IE
+    stopEverything: function(e) {
+      $(e.target).trigger('ujs:everythingStopped');
+      e.stopImmediatePropagation();
+      return false;
+    },
+
+    //  replace element's html with the 'data-disable-with' after storing original html
+    //  and prevent clicking on it
+    disableElement: function(element) {
+      element.data('ujs:enable-with', element.html()); // store enabled state
+      element.html(element.data('disable-with')); // set to disabled state
+      element.bind('click.railsDisable', function(e) { // prevent further clicking
+        return rails.stopEverything(e);
+      });
+    },
+
+    // restore element to its original state which was disabled by 'disableElement' above
+    enableElement: function(element) {
+      if (element.data('ujs:enable-with') !== undefined) {
+        element.html(element.data('ujs:enable-with')); // set to old enabled state
+        element.removeData('ujs:enable-with'); // clean up cache
+      }
+      element.unbind('click.railsDisable'); // enable element
+    }
+
+  };
+
+  if (rails.fire($document, 'rails:attachBindings')) {
+
+    $.ajaxPrefilter(function(options, originalOptions, xhr){ if ( !options.crossDomain ) { rails.CSRFProtection(xhr); }});
+
+    $document.delegate(rails.linkDisableSelector, 'ajax:complete', function() {
+        rails.enableElement($(this));
+    });
+
+    $document.delegate(rails.linkClickSelector, 'click.rails', function(e) {
+      var link = $(this), method = link.data('method'), data = link.data('params'), metaClick = e.metaKey || e.ctrlKey;
+      if (!rails.allowAction(link)) return rails.stopEverything(e);
+
+      if (!metaClick && link.is(rails.linkDisableSelector)) rails.disableElement(link);
+
+      if (link.data('remote') !== undefined) {
+        if (metaClick && (!method || method === 'GET') && !data) { return true; }
+
+        var handleRemote = rails.handleRemote(link);
+        // response from rails.handleRemote() will either be false or a deferred object promise.
+        if (handleRemote === false) {
+          rails.enableElement(link);
+        } else {
+          handleRemote.error( function() { rails.enableElement(link); } );
+        }
+        return false;
+
+      } else if (link.data('method')) {
+        rails.handleMethod(link);
+        return false;
+      }
+    });
+
+    $document.delegate(rails.buttonClickSelector, 'click.rails', function(e) {
+      var button = $(this);
+      if (!rails.allowAction(button)) return rails.stopEverything(e);
+
+      rails.handleRemote(button);
+      return false;
+    });
+
+    $document.delegate(rails.inputChangeSelector, 'change.rails', function(e) {
+      var link = $(this);
+      if (!rails.allowAction(link)) return rails.stopEverything(e);
+
+      rails.handleRemote(link);
+      return false;
+    });
+
+    $document.delegate(rails.formSubmitSelector, 'submit.rails', function(e) {
+      var form = $(this),
+        remote = form.data('remote') !== undefined,
+        blankRequiredInputs,
+        nonBlankFileInputs;
+
+      if (!rails.allowAction(form)) return rails.stopEverything(e);
+
+      // skip other logic when required values are missing or file upload is present
+      if (form.attr('novalidate') == undefined) {
+        blankRequiredInputs = rails.blankInputs(form, rails.requiredInputSelector);
+        if (blankRequiredInputs && rails.fire(form, 'ajax:aborted:required', [blankRequiredInputs])) {
+          return rails.stopEverything(e);
+        }
+      }
+
+      if (remote) {
+        nonBlankFileInputs = rails.nonBlankInputs(form, rails.fileInputSelector);
+        if (nonBlankFileInputs) {
+          // slight timeout so that the submit button gets properly serialized
+          // (make it easy for event handler to serialize form without disabled values)
+          setTimeout(function(){ rails.disableFormElements(form); }, 13);
+          var aborted = rails.fire(form, 'ajax:aborted:file', [nonBlankFileInputs]);
+
+          // re-enable form elements if event bindings return false (canceling normal form submission)
+          if (!aborted) { setTimeout(function(){ rails.enableFormElements(form); }, 13); }
+
+          return aborted;
+        }
+
+        rails.handleRemote(form);
+        return false;
+
+      } else {
+        // slight timeout so that the submit button gets properly serialized
+        setTimeout(function(){ rails.disableFormElements(form); }, 13);
+      }
+    });
+
+    $document.delegate(rails.formInputClickSelector, 'click.rails', function(event) {
+      var button = $(this);
+
+      if (!rails.allowAction(button)) return rails.stopEverything(event);
+
+      // register the pressed submit button
+      var name = button.attr('name'),
+        data = name ? {name:name, value:button.val()} : null;
+
+      button.closest('form').data('ujs:submit-button', data);
+    });
+
+    $document.delegate(rails.formSubmitSelector, 'ajax:send.rails', function(event) {
+      if (this == event.target) rails.disableFormElements($(this));
+    });
+
+    $document.delegate(rails.formSubmitSelector, 'ajax:complete.rails', function(event) {
+      if (this == event.target) rails.enableFormElements($(this));
+    });
+
+    $(function(){
+      rails.refreshCSRFTokens();
+    });
+  }
+
+})( jQuery );

data/test/integration/navigation_test.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 
 class NavigationTest < ActiveSupport::IntegrationCase
+
   def tear_down
     DummyObserver.unstub(:update)
   end
@@ -91,8 +92,17 @@ class NavigationTest < ActiveSupport::IntegrationCase
     assert_equal 0, user.points
     assert_equal 2, Merit::Score::Point.count
 
-    # Make tenth comment, assert 10-commenter badge granted
+    # Tenth comment with errors doesn't change reputation
+    badges = user.reload.badges
+    points = user.points
     visit '/comments/new'
+    assert_no_difference('Merit::ActivityLog.count') do
+      click_button('Create Comment')
+    end
+    assert_equal badges, user.reload.badges
+    assert_equal points, user.points
+
+    # Tenth comment without errors, assert 10-commenter badge granted
     fill_in 'Name', with: 'Hi!'
     fill_in 'Comment', with: 'Hi bro!'
     fill_in 'User', with: user.id

data/test/orm/active_record.rb

@@ -0,0 +1,2 @@
+# Place orm-dependent test preparation here
+ActiveRecord::Migrator.migrate File.expand_path("../../dummy/db/migrate/", __FILE__)

data/test/orm/mongoid.rb

@@ -0,0 +1,6 @@
+# Place orm-dependent test preparation here
+class ActiveSupport::TestCase
+  setup do
+    Mongoid.purge!
+  end
+end

data/test/orm_models/active_record.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+  has_merit
+end
+
+class Fruit < ActiveRecord::Base
+end
+
+class Soldier < ActiveRecord::Base
+  has_merit
+end
+class Player < ActiveRecord::Base
+  has_merit
+end

data/test/orm_models/mongoid.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class User
+  include Mongoid::Document
+  has_merit
+end
+
+class Fruit
+  include Mongoid::Document
+end
+
+class Soldier
+  include Mongoid::Document
+  has_merit
+end
+
+class Player
+  include Mongoid::Document
+  has_merit
+end

data/test/test_helper.rb

@@ -2,6 +2,9 @@
 ENV['RAILS_ENV'] = 'test'
 RUBYOPT="-w $RUBYOPT"
 
+require 'coveralls'
+Coveralls.wear!('rails')
+
 if ENV["COVERAGE"]
   require 'simplecov'
   SimpleCov.adapters.define 'rubygem' do
@@ -26,12 +29,17 @@ require 'capybara/rails'
 Capybara.default_driver   = :rack_test
 Capybara.default_selector = :css
 
-ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
+Merit.orm = :active_record if Merit.orm.nil?
+
+def active_record_orm?
+  Merit.orm == :active_record
+end
+
+def mongoid_orm?
+  Merit.orm == :mongoid
+end
 
-require "merit/models/#{Merit.orm}/merit/activity_log"
-require "merit/models/#{Merit.orm}/merit/badges_sash"
-require "merit/models/#{Merit.orm}/merit/sash"
-require "merit/models/#{Merit.orm}/merit/score"
+require "orm/#{Merit.orm}"
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/test/unit/merit_unit_test.rb

@@ -2,24 +2,14 @@ require 'test_helper'
 
 # TODO: Split different objects tests in it's own files
 class MeritUnitTest < ActiveSupport::TestCase
-  test 'extends only meritable ActiveRecord models' do
-    class User < ActiveRecord::Base
-      has_merit
-    end
-    class Fruit < ActiveRecord::Base
-    end
+  require "orm_models/#{Merit.orm}"
 
+  test 'extends only meritable models' do
     assert User.method_defined?(:points), 'has_merit adds methods'
     assert !Fruit.method_defined?(:points), 'other models aren\'t extended'
   end
 
   test 'Badges get "related_models" methods' do
-    class Soldier < ActiveRecord::Base
-      has_merit
-    end
-    class Player < ActiveRecord::Base
-      has_merit
-    end
     assert Merit::Badge.method_defined?(:soldiers), 'Badge#soldiers should be defined'
     assert Merit::Badge.method_defined?(:players), 'Badge#players should be defined'
   end
@@ -34,7 +24,7 @@ class MeritUnitTest < ActiveSupport::TestCase
     assert_raises Merit::RankAttributeNotDefined do
       WeirdRankRules.new.check_rank_rules
     end
-  end
+  end if active_record_orm?
 
   test 'Badge#custom_fields_hash saves correctly' do
     Merit::Badge.create(id: 99,

data/test/unit/score_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+describe Merit::Score do
+  it 'Point#sash_id delegates to Score' do
+    score = mock()
+    score.stubs(:sash_id).returns(33)
+
+    point = Merit::Score::Point.new
+    point.stubs(:score).returns(score)
+
+    point.sash_id.must_be :==, score.sash_id
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: merit
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Tute Costa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-22 00:00:00.000000000 Z
+date: 2014-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ambry
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -235,10 +249,15 @@ files:
 - test/dummy/public/javascripts/effects.js
 - test/dummy/public/javascripts/prototype.js
 - test/dummy/public/javascripts/rails.js
+- test/dummy/public/rails.js
 - test/dummy/public/stylesheets/.gitkeep
 - test/dummy/public/stylesheets/scaffold.css
 - test/dummy/script/rails
 - test/integration/navigation_test.rb
+- test/orm/active_record.rb
+- test/orm/mongoid.rb
+- test/orm_models/active_record.rb
+- test/orm_models/mongoid.rb
 - test/support/integration_case.rb
 - test/test_helper.rb
 - test/unit/base_target_finder_test.rb
@@ -247,6 +266,7 @@ files:
 - test/unit/rules_matcher_test.rb
 - test/unit/sash_finder_test.rb
 - test/unit/sash_test.rb
+- test/unit/score_test.rb
 - test/unit/target_finder_test.rb
 homepage: http://github.com/tute/merit
 licenses: