mongoid_ability 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6fb77bedd14bcfb7ebb1273b4ef828ff32bad598
-  data.tar.gz: 64be0c5963ed532e20fe346c11ac7b2e8c8e1597
+  metadata.gz: 9e8efe06a6a08b5f7d80532153f9324597c3a932
+  data.tar.gz: e77cc428a3509f03cca38a40b9a25155d3cd3539
 SHA512:
-  metadata.gz: 9d6c8e052c01530819e06b298bfb9e8cb49bb225c853c157a3789e07f4f722a06f4a24f9a129bf21194cf48a913637033c2b22efb499a3a73193ba5e0e06f758
-  data.tar.gz: 85c46d10706e25f424138cc5645d6030aa97446e8a3b430ecd6ef751c13102671c098d9605f74f624f4c4cb5bd46a6f4cf4a6f05ca1d0ef4ca6e45b5b4c96c56
+  metadata.gz: ddef2f4d29749491c06f0dd21601fa509208808c2542b87eade4eb73fb91644b0500aabd9eccf30e6b8bb150cad60101b88d34d0ed1b6a3f994cc55706f623c2
+  data.tar.gz: d774fe84fded69148b77b5edddfcc21fed50371159dfc8454b58f916f0d1e2c5a5eddc9f87a4859235c52d15ece619966f1af1bbfbca1197e6cc91d11b6d7e11

data/lib/mongoid_ability.rb

@@ -11,6 +11,7 @@ require "mongoid_ability/resolve_default_locks"
 require "mongoid_ability/resolve_inherited_locks"
 require "mongoid_ability/resolve_owner_locks"
 
+require "mongoid_ability/values_for_accessible_query"
 require "mongoid_ability/accessible_query_builder"
 
 # ---------------------------------------------------------------------

data/lib/mongoid_ability/accessible_query_builder.rb

@@ -6,80 +6,42 @@ module MongoidAbility
 
     # =====================================================================
 
-    # TODO: cleanup
     def call
-      closed_classes = [] # [cls]
-      open_ids = [] # [cls, id]
-      closed_ids = [] # [id]
-
-      base_class_and_descendants.each do |cls|
-        closed_classes << cls.to_s if ability.cannot?(action, cls, options)
-
-        id_locks(cls).each do |lock|
-          if ability.can?(action, cls.new(_id: lock.subject_id), options)
-            open_ids << [cls.to_s, lock.subject_id]
-          else
-            closed_ids << lock.subject_id
-          end
-        end
-      end
-
-      closed_classes_condition = { :_type.nin => closed_classes }
-      open_ids_condition = { :_type.in => open_ids.map(&:first), :_id.in => open_ids.map(&:last) }
-      closed_ids_condition = { :_id.nin => closed_ids }
-      or_conditions = [ closed_classes_condition, open_ids_condition ].reject(&:blank?)
-
-      base_criteria.where( :$and => [ { :$or => or_conditions }, closed_ids_condition ])
+      or_conditions = [closed_types_condition, open_ids_condition].reject(&:blank?)
+      base_class.criteria.where(:$and => [{ :$or => or_conditions }, closed_ids_condition])
     end
 
     private # =============================================================
 
-    def base_criteria
-      @base_criteria ||= base_class.criteria
-    end
-
-    # ---------------------------------------------------------------------
-
-    def base_class_superclass
-      @base_class_superclass ||= (base_class.ancestors_with_default_locks.last || base_class)
+    def closed_types_condition
+      { :_type.nin => values.closed_types }
     end
 
-    def default_lock(_cls, action)
-      base_class_superclass.default_locks.detect { |l| l.action.to_s == action.to_s }
+    def open_ids_condition
+      {
+        :_type.in => values.open_types_and_ids.map(&:type),
+        :_id.in => values.open_types_and_ids.map(&:id)
+      }
     end
 
-    def base_class_and_descendants
-      @base_class_and_descendants ||= [base_class].concat(base_class.descendants)
+    def closed_ids_condition
+      { :_id.nin => values.closed_ids }
     end
 
     # ---------------------------------------------------------------------
 
-    def owner
-      @owner ||= ability.owner
-    end
-
-    def inherited_from_relation
-      return unless owner.respond_to?(owner.class.inherit_from_relation_name)
-      owner.inherit_from_relation
+    def values
+      @values ||= MongoidAbility::ValuesForAccessibleQuery.call(base_class, ability, action, options)
     end
 
     # ---------------------------------------------------------------------
 
-    def id_locks(cls)
-      (Array(owner_id_locks_for_subject_type(cls)) + Array(inherited_from_relation_ids_locks_for_subject_type(cls))).flatten
-    end
-
-    def owner_id_locks_for_subject_type(cls)
-      @owner_id_locks_for_subject_type ||= {}
-      @owner_id_locks_for_subject_type[cls] ||= owner.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s)
+    def base_class_superclass
+      @base_class_superclass ||= (base_class.ancestors_with_default_locks.last || base_class)
     end
 
-    def inherited_from_relation_ids_locks_for_subject_type(cls)
-      return [] unless inherited_from_relation
-      @inherited_from_relation_ids_locks_for_subject_type ||= {}
-      @inherited_from_relation_ids_locks_for_subject_type[cls] ||= inherited_from_relation.collect do |o|
-        o.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s)
-      end.flatten
+    def default_lock(_cls, action)
+      base_class_superclass.default_locks.detect { |l| l.action.to_s == action.to_s }
     end
   end
 end

data/lib/mongoid_ability/lock.rb

@@ -18,7 +18,12 @@ module MongoidAbility
         scope :for_action, -> (action) { where(action: action.to_sym) }
 
         scope :for_subject_type, -> (subject_type) { where(subject_type: subject_type.to_s) }
-        scope :for_subject_id, -> (subject_id) { where(subject_id: subject_id.presence) }
+
+        scope :for_subject_id, -> (subject_id) {
+          return where(subject_id: nil) unless subject_id.present?
+          where(subject_id: BSON::ObjectId.from_string(subject_id))
+        }
+
         scope :for_subject, -> (subject) {
           return where(subject_id: nil) unless subject.present?
           where(subject_type: subject.class.model_name, subject_id: subject.id)

data/lib/mongoid_ability/values_for_accessible_query.rb

@@ -0,0 +1,70 @@
+module MongoidAbility
+  class ValuesForAccessibleQuery < Struct.new(:base_class, :ability, :action, :options)
+    def self.call(*args)
+      new(*args).call
+    end
+
+    # =====================================================================
+
+    def call
+      closed_types = [] # [cls]
+      open_types_and_ids = [] # OpenStruct.new(type: …, id: …)
+      closed_ids = [] # [id]
+
+      base_class_and_descendants.each do |cls|
+        closed_types << cls.to_s if ability.cannot?(action, cls, options)
+        id_locks(cls).each do |lock|
+          if ability.can?(action, cls.new(_id: lock.subject_id), options)
+            open_types_and_ids << OpenStruct.new(type: cls.to_s, id: lock.subject_id)
+          else
+            closed_ids << lock.subject_id
+          end
+        end
+      end
+
+      OpenStruct.new(
+        closed_types: closed_types,
+        open_types_and_ids: open_types_and_ids,
+        closed_ids: closed_ids
+      )
+    end
+
+    private # =============================================================
+
+    def base_class_and_descendants
+      @base_class_and_descendants ||= [base_class].concat(base_class.descendants)
+    end
+
+    # ---------------------------------------------------------------------
+
+    def id_locks(cls)
+      (Array(owner_id_locks_for_subject_type(cls)) + Array(inherited_from_relation_ids_locks_for_subject_type(cls))).flatten
+    end
+
+    def owner_id_locks_for_subject_type(cls)
+      @owner_id_locks_for_subject_type ||= {}
+      @owner_id_locks_for_subject_type[cls] ||= owner.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s)
+    end
+
+    def inherited_from_relation_ids_locks_for_subject_type(cls)
+      return [] unless inherited_from_relation
+      @inherited_from_relation_ids_locks_for_subject_type ||= {}
+      @inherited_from_relation_ids_locks_for_subject_type[cls] ||= inherited_from_relation.collect do |o|
+        o.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s)
+      end.flatten
+    end
+
+    # ---------------------------------------------------------------------
+
+    def owner
+      @owner ||= ability.owner
+    end
+
+    # ---------------------------------------------------------------------
+
+    def inherited_from_relation
+      return unless owner.respond_to?(owner.class.inherit_from_relation_name)
+      owner.inherit_from_relation
+    end
+  end
+end

data/lib/mongoid_ability/version.rb

@@ -1,3 +1,3 @@
 module MongoidAbility
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_ability
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Tomáš Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancancan
@@ -162,6 +162,7 @@ files:
 - lib/mongoid_ability/resolve_locks.rb
 - lib/mongoid_ability/resolve_owner_locks.rb
 - lib/mongoid_ability/subject.rb
+- lib/mongoid_ability/values_for_accessible_query.rb
 - lib/mongoid_ability/version.rb
 - mongoid_ability.gemspec
 - test/mongoid_ability/ability_role_test.rb