cancancan 1.15.0 → 1.16.0

data/lib/cancan/model_adapters/active_record_4_adapter.rb

@@ -6,62 +6,75 @@ module CanCan
         model_class <= ActiveRecord::Base
       end
 
-      private
-
-      # As of rails 4, `includes()` no longer causes active record to
-      # look inside the where clause to decide to outer join tables
-      # you're using in the where. Instead, `references()` is required
-      # in addition to `includes()` to force the outer join.
-      def build_relation(*where_conditions)
-        relation = @model_class.where(*where_conditions)
-        relation = relation.includes(joins).references(joins) if joins.present?
-        relation
-      end
-
-      def self.override_condition_matching?(subject, name, value)
+      # TODO: this should be private
+      def self.override_condition_matching?(subject, name, _value)
         # ActiveRecord introduced enums in version 4.1.
         (ActiveRecord::VERSION::MAJOR > 4 || ActiveRecord::VERSION::MINOR >= 1) &&
           subject.class.defined_enums.include?(name.to_s)
       end
 
+      # TODO: this should be private
       def self.matches_condition?(subject, name, value)
         # Get the mapping from enum strings to values.
         enum = subject.class.send(name.to_s.pluralize)
         # Get the value of the attribute as an integer.
         attribute = enum[subject.send(name)]
         # Check to see if the value matches the condition.
-        value.is_a?(Enumerable) ? 
-          (value.include? attribute) :
+        if value.is_a?(Enumerable)
+          value.include? attribute
+        else
           attribute == value
+        end
+      end
+
+      private
+
+      # As of rails 4, `includes()` no longer causes active record to
+      # look inside the where clause to decide to outer join tables
+      # you're using in the where. Instead, `references()` is required
+      # in addition to `includes()` to force the outer join.
+      def build_relation(*where_conditions)
+        relation = @model_class.where(*where_conditions)
+        relation = relation.includes(joins).references(joins) if joins.present?
+        relation
       end
 
       # Rails 4.2 deprecates `sanitize_sql_hash_for_conditions`
       def sanitize_sql(conditions)
-        if ActiveRecord::VERSION::MAJOR > 4 && Hash === conditions
-          table = @model_class.send(:arel_table)
-          table_metadata = ActiveRecord::TableMetadata.new(@model_class, table)
-          predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
+        if ActiveRecord::VERSION::MAJOR > 4 && conditions.is_a?(Hash)
+          sanitize_sql_activerecord5(conditions)
+        elsif ActiveRecord::VERSION::MINOR >= 2 && conditions.is_a?(Hash)
+          sanitize_sql_activerecord4(conditions)
+
+        else
+          @model_class.send(:sanitize_sql, conditions)
+        end
+      end
 
-          conditions = predicate_builder.resolve_column_aliases(conditions)
-          conditions = @model_class.send(:expand_hash_conditions_for_aggregates, conditions)
+      def sanitize_sql_activerecord4(conditions)
+        table = Arel::Table.new(@model_class.send(:table_name))
 
-          conditions.stringify_keys!
+        conditions = ActiveRecord::PredicateBuilder.resolve_column_aliases @model_class, conditions
+        conditions = @model_class.send(:expand_hash_conditions_for_aggregates, conditions)
 
-          predicate_builder.build_from_hash(conditions).map { |b|
-            @model_class.send(:connection).visitor.compile b
-          }.join(' AND ')
-        elsif ActiveRecord::VERSION::MINOR >= 2 && Hash === conditions
-          table = Arel::Table.new(@model_class.send(:table_name))
+        ActiveRecord::PredicateBuilder.build_from_hash(@model_class, conditions, table).map do |b|
+          @model_class.send(:connection).visitor.compile b
+        end.join(' AND ')
+      end
 
-          conditions = ActiveRecord::PredicateBuilder.resolve_column_aliases @model_class, conditions
-          conditions = @model_class.send(:expand_hash_conditions_for_aggregates, conditions)
+      def sanitize_sql_activerecord5(conditions)
+        table = @model_class.send(:arel_table)
+        table_metadata = ActiveRecord::TableMetadata.new(@model_class, table)
+        predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
 
-          ActiveRecord::PredicateBuilder.build_from_hash(@model_class, conditions, table).map { |b|
-            @model_class.send(:connection).visitor.compile b
-          }.join(' AND ')
-        else
-          @model_class.send(:sanitize_sql, conditions)
-        end
+        conditions = predicate_builder.resolve_column_aliases(conditions)
+        conditions = @model_class.send(:expand_hash_conditions_for_aggregates, conditions)
+
+        conditions.stringify_keys!
+
+        predicate_builder.build_from_hash(conditions).map do |b|
+          @model_class.send(:connection).visitor.compile b
+        end.join(' AND ')
       end
     end
   end

data/lib/cancan/model_adapters/active_record_adapter.rb

@@ -28,13 +28,13 @@ module CanCan
       end
 
       def tableized_conditions(conditions, model_class = @model_class)
-        return conditions unless conditions.kind_of? Hash
-        conditions.inject({}) do |result_hash, (name, value)|
-          if value.kind_of? Hash
+        return conditions unless conditions.is_a? Hash
+        conditions.each_with_object({}) do |(name, value), result_hash|
+          if value.is_a? Hash
             value = value.dup
             association_class = model_class.reflect_on_association(name).klass.name.constantize
-            nested = value.inject({}) do |nested,(k,v)|
-              if v.kind_of? Hash
+            nested_resulted = value.each_with_object({}) do |(k, v), nested|
+              if v.is_a? Hash
                 value.delete(k)
                 nested[k] = v
               else
@@ -42,7 +42,7 @@ module CanCan
               end
               nested
             end
-            result_hash.merge!(tableized_conditions(nested,association_class))
+            result_hash.merge!(tableized_conditions(nested_resulted, association_class))
           else
             result_hash[name] = value
           end
@@ -67,28 +67,29 @@ module CanCan
           if mergeable_conditions?
             build_relation(conditions)
           else
-            build_relation(*(@rules.map(&:conditions)))
+            build_relation(*@rules.map(&:conditions))
           end
         else
-          @model_class.all(:conditions => conditions, :joins => joins)
+          @model_class.all(conditions: conditions, joins: joins)
         end
       end
 
       private
 
       def mergeable_conditions?
-        @rules.find {|rule| rule.unmergeable? }.blank?
+        @rules.find(&:unmergeable?).blank?
       end
 
       def override_scope
         conditions = @rules.map(&:conditions).compact
-        if defined?(ActiveRecord::Relation) && conditions.any? { |c| c.kind_of?(ActiveRecord::Relation) }
-          if conditions.size == 1
-            conditions.first
-          else
-            rule = @rules.detect { |rule| rule.conditions.kind_of?(ActiveRecord::Relation) }
-            raise Error, "Unable to merge an Active Record scope with other conditions. Instead use a hash or SQL for #{rule.actions.first} #{rule.subjects.first} ability."
-          end
+        return unless defined?(ActiveRecord::Relation) && conditions.any? { |c| c.is_a?(ActiveRecord::Relation) }
+        if conditions.size == 1
+          conditions.first
+        else
+          rule_found = @rules.detect { |rule| rule.conditions.is_a?(ActiveRecord::Relation) }
+          raise Error,
+                'Unable to merge an Active Record scope with other conditions. '\
+                "Instead use a hash or SQL for #{rule_found.actions.first} #{rule_found.subjects.first} ability."
         end
       end
 
@@ -135,7 +136,7 @@ module CanCan
       def clean_joins(joins_hash)
         joins = []
         joins_hash.each do |name, nested|
-          joins << (nested.empty? ? name : {name => clean_joins(nested)})
+          joins << (nested.empty? ? name : { name => clean_joins(nested) })
         end
         joins
       end

data/lib/cancan/model_adapters/mongoid_adapter.rb

@@ -6,8 +6,8 @@ module CanCan
       end
 
       def self.override_conditions_hash_matching?(subject, conditions)
-        conditions.any? do |k,v|
-          key_is_not_symbol = lambda { !k.kind_of?(Symbol) }
+        conditions.any? do |k, _v|
+          key_is_not_symbol = -> { !k.is_a?(Symbol) }
           subject_value_is_array = lambda do
             subject.respond_to?(k) && subject.send(k).is_a?(Array)
           end
@@ -19,50 +19,55 @@ module CanCan
       def self.matches_conditions_hash?(subject, conditions)
         # To avoid hitting the db, retrieve the raw Mongo selector from
         # the Mongoid Criteria and use Mongoid::Matchers#matches?
-        subject.matches?( subject.class.where(conditions).selector )
+        subject.matches?(subject.class.where(conditions).selector)
       end
 
       def database_records
-        if @rules.size == 0
-          @model_class.where(:_id => {'$exists' => false, '$type' => 7}) # return no records in Mongoid
+        if @rules.empty?
+          @model_class.where(_id: { '$exists' => false, '$type' => 7 }) # return no records in Mongoid
         elsif @rules.size == 1 && @rules[0].conditions.is_a?(Mongoid::Criteria)
           @rules[0].conditions
         else
           # we only need to process can rules if
           # there are no rules with empty conditions
-          rules = @rules.reject { |rule| rule.conditions.empty? && rule.base_behavior }
-          process_can_rules = @rules.count == rules.count
+          database_records_from_multiple_rules
+        end
+      end
 
-          rules.inject(@model_class.all) do |records, rule|
-            if process_can_rules && rule.base_behavior
-              records.or simplify_relations(@model_class, rule.conditions)
-            elsif !rule.base_behavior
-              records.excludes simplify_relations(@model_class, rule.conditions)
-            else
-              records
-            end
+      def database_records_from_multiple_rules
+        rules = @rules.reject { |rule| rule.conditions.empty? && rule.base_behavior }
+        process_can_rules = @rules.count == rules.count
+
+        rules.inject(@model_class.all) do |records, rule|
+          if process_can_rules && rule.base_behavior
+            records.or simplify_relations(@model_class, rule.conditions)
+          elsif !rule.base_behavior
+            records.excludes simplify_relations(@model_class, rule.conditions)
+          else
+            records
           end
         end
       end
 
       private
+
       # Look for criteria on relations and replace with simple id queries
       # eg.
       # {user: {:tags.all => []}} becomes {"user_id" => {"$in" => [__, ..]}}
       # {user: {:session => {:tags.all => []}}} becomes {"user_id" => {"session_id" => {"$in" => [__, ..]} }}
-      def simplify_relations model_class, conditions
+      def simplify_relations(model_class, conditions)
         model_relations = model_class.relations.with_indifferent_access
         Hash[
-          conditions.map {|k,v|
-            if relation = model_relations[k]
+          conditions.map do |k, v|
+            if (relation = model_relations[k])
               relation_class_name = relation[:class_name].blank? ? k.to_s.classify : relation[:class_name]
               v = simplify_relations(relation_class_name.constantize, v)
               relation_ids = relation_class_name.constantize.where(v).only(:id).map(&:id)
               k = "#{k}_id"
-              v = { "$in" => relation_ids }
+              v = { '$in' => relation_ids }
             end
-            [k,v]
-          }
+            [k, v]
+          end
         ]
       end
     end

data/lib/cancan/model_adapters/sequel_adapter.rb

@@ -9,8 +9,8 @@ module CanCan
         model_class[id]
       end
 
-      def self.override_condition_matching?(subject, name, value)
-        value.kind_of?(Hash)
+      def self.override_condition_matching?(_subject, _name, value)
+        value.is_a?(Hash)
       end
 
       def self.matches_condition?(subject, name, value)
@@ -19,8 +19,8 @@ module CanCan
           false
         else
           value.each do |k, v|
-            if v.kind_of?(Hash)
-              return false unless self.matches_condition?(obj, k, v)
+            if v.is_a?(Hash)
+              return false unless matches_condition?(obj, k, v)
             elsif obj.send(k) != v
               return false
             end
@@ -29,12 +29,12 @@ module CanCan
       end
 
       def database_records
-        if @rules.size == 0
+        if @rules.empty?
           @model_class.where('1=0')
         else
           # only need to process can rules if there are no can rule with empty conditions
           rules = @rules.reject { |rule| rule.base_behavior && rule.conditions.empty? }
-          rules.reject! { |rule| rule.base_behavior } if rules.count < @rules.count
+          rules.reject!(&:base_behavior) if rules.count < @rules.count
 
           can_condition_added = false
           rules.reverse.inject(@model_class.dataset) do |records, rule|
@@ -56,13 +56,13 @@ module CanCan
       private
 
       def normalize_conditions(conditions, model_class = @model_class)
-        return conditions unless conditions.kind_of? Hash
-        conditions.inject({}) do |result_hash, (name, value)|
-          if value.kind_of? Hash
+        return conditions unless conditions.is_a? Hash
+        conditions.each_with_object({}) do |(name, value), result_hash|
+          if value.is_a? Hash
             value = value.dup
             association_class = model_class.association_reflection(name).associated_class
-            nested = value.inject({}) do |nested, (k, v)|
-              if v.kind_of?(Hash)
+            nested_resulted = value.each_with_object({}) do |(k, v), nested|
+              if v.is_a?(Hash)
                 value.delete(k)
                 nested_class = association_class.association_reflection(k).associated_class
                 nested[k] = nested_class.where(normalize_conditions(v, association_class))
@@ -71,7 +71,7 @@ module CanCan
               end
               nested
             end
-            result_hash[name] = association_class.where(nested)
+            result_hash[name] = association_class.where(nested_resulted)
           else
             result_hash[name] = value
           end

data/lib/cancan/model_additions.rb

@@ -1,5 +1,4 @@
 module CanCan
-
   # This module adds the accessible_by class method to a model. It is included in the model adapters.
   module ModelAdditions
     module ClassMethods

data/lib/cancan/rule.rb

@@ -11,7 +11,9 @@ module CanCan
     # and subject respectively (such as :read, @project). The third argument is a hash
     # of conditions and the last one is the block passed to the "can" call.
     def initialize(base_behavior, action, subject, conditions, block)
-      raise Error, "You are not able to supply a block with a hash of conditions in #{action} #{subject} ability. Use either one." if conditions.kind_of?(Hash) && !block.nil?
+      both_block_and_hash_error = 'You are not able to supply a block with a hash of conditions in '\
+                                  "#{action} #{subject} ability. Use either one."
+      raise Error, both_block_and_hash_error if conditions.is_a?(Hash) && block
       @match_all = action.nil? && subject.nil?
       @base_behavior = base_behavior
       @actions = [action].flatten
@@ -32,9 +34,9 @@ module CanCan
         call_block_with_all(action, subject, extra_args)
       elsif @block && !subject_class?(subject)
         @block.call(subject, *extra_args)
-      elsif @conditions.kind_of?(Hash) && subject.class == Hash
+      elsif @conditions.is_a?(Hash) && subject.class == Hash
         nested_subject_matches_conditions?(subject)
-      elsif @conditions.kind_of?(Hash) && !subject_class?(subject)
+      elsif @conditions.is_a?(Hash) && !subject_class?(subject)
         matches_conditions_hash?(subject)
       else
         # Don't stop at "cannot" definitions when there are conditions.
@@ -43,11 +45,11 @@ module CanCan
     end
 
     def only_block?
-      conditions_empty? && !@block.nil?
+      conditions_empty? && @block
     end
 
     def only_raw_sql?
-      @block.nil? && !conditions_empty? && !@conditions.kind_of?(Hash)
+      @block.nil? && !conditions_empty? && !@conditions.is_a?(Hash)
     end
 
     def conditions_empty?
@@ -56,29 +58,33 @@ module CanCan
 
     def unmergeable?
       @conditions.respond_to?(:keys) && @conditions.present? &&
-        (!@conditions.keys.first.kind_of? Symbol)
+        (!@conditions.keys.first.is_a? Symbol)
     end
 
     def associations_hash(conditions = @conditions)
       hash = {}
-      conditions.map do |name, value|
-        hash[name] = associations_hash(value) if value.kind_of? Hash
-      end if conditions.kind_of? Hash
+      if conditions.is_a? Hash
+        conditions.map do |name, value|
+          hash[name] = associations_hash(value) if value.is_a? Hash
+        end
+      end
       hash
     end
 
     def attributes_from_conditions
       attributes = {}
-      @conditions.each do |key, value|
-        attributes[key] = value unless [Array, Range, Hash].include? value.class
-      end if @conditions.kind_of? Hash
+      if @conditions.is_a? Hash
+        @conditions.each do |key, value|
+          attributes[key] = value unless [Array, Range, Hash].include? value.class
+        end
+      end
       attributes
     end
 
     private
 
     def subject_class?(subject)
-      klass = (subject.kind_of?(Hash) ? subject.values.first : subject).class
+      klass = (subject.is_a?(Hash) ? subject.values.first : subject).class
       klass == Class || klass == Module
     end
 
@@ -92,9 +98,9 @@ module CanCan
 
     def matches_subject_class?(subject)
       @subjects.any? do |sub|
-        sub.kind_of?(Module) && (subject.kind_of?(sub) ||
+        sub.is_a?(Module) && (subject.is_a?(sub) ||
                                  subject.class.to_s == sub.to_s ||
-                                 (subject.kind_of?(Module) && subject.ancestors.include?(sub)))
+                                 (subject.is_a?(Module) && subject.ancestors.include?(sub)))
       end
     end
 
@@ -147,10 +153,10 @@ module CanCan
     end
 
     def hash_condition_match?(attribute, value)
-      if attribute.kind_of?(Array) || (defined?(ActiveRecord) && attribute.kind_of?(ActiveRecord::Relation))
+      if attribute.is_a?(Array) || (defined?(ActiveRecord) && attribute.is_a?(ActiveRecord::Relation))
         attribute.any? { |element| matches_conditions_hash?(element, value) }
       else
-        !attribute.nil? && matches_conditions_hash?(attribute, value)
+        attribute && matches_conditions_hash?(attribute, value)
       end
     end
   end

data/lib/cancan/version.rb

@@ -1,3 +1,3 @@
 module CanCan
-  VERSION = "1.15.0"
+  VERSION = '1.16.0'.freeze
 end