monarchy 1.1.5 → 2.0.0.pre.beta.1

data/lib/monarchy/acts_as_resource.rb

@@ -13,10 +13,7 @@ module Monarchy
         after_update :assign_parent
         after_create :ensure_hierarchy, :assign_parent
 
-        has_many :members, through: :hierarchy, class_name: "::#{Monarchy.member_class}"
-        has_many :users, through: :members, class_name: "::#{Monarchy.user_class}"
-        has_one :hierarchy, as: :resource, dependent: :destroy, class_name: 'Monarchy::Hierarchy'
-
+        include_relationships
         include_scopes
 
         include Monarchy::ActsAsResource::InstanceMethods
@@ -24,7 +21,16 @@ module Monarchy
     end
 
     module SupportMethods
-      attr_accessor :parentize, :acting_as_resource, :automatic_hierarchy
+      attr_accessor :automatic_hierarchy
+      attr_reader :acting_as_resource, :parentize_name
+
+      def default_role_name
+        Monarchy.configuration.inherited_default_role
+      end
+
+      def default_role
+        @default_role ||= Monarchy.role_class.find_by(name: default_role_name)
+      end
 
       private
 
@@ -35,18 +41,26 @@ module Monarchy
       end
 
       def parent_as(name)
-        self.parentize = name
+        @parentize_name = name
       end
 
       def include_scopes
-        scope :in, (lambda do |resource|
-          joins(:hierarchy).where(monarchy_hierarchies: { parent_id: resource.hierarchy.self_and_descendants })
+        scope :in, (lambda do |resource, descendants = true|
+          Monarchy::Validators.resource(resource)
+          hierarchies = Monarchy.hierarchy_class.in(resource.hierarchy, descendants)
+          joins(:hierarchy).where(monarchy_hierarchies: { id: hierarchies })
         end)
 
         scope :accessible_for, (lambda do |user|
-          joins(:hierarchy).where(monarchy_hierarchies: { id: Monarchy::Hierarchy.accessible_for(user) })
+          joins(:hierarchy).where(monarchy_hierarchies: { id: Monarchy.hierarchy_class.accessible_for(user) })
         end)
       end
+
+      def include_relationships
+        has_many :members, through: :hierarchy, class_name: "::#{Monarchy.member_class}"
+        has_many :users, through: :members, class_name: "::#{Monarchy.user_class}"
+        has_one :hierarchy, as: :resource, dependent: :destroy, class_name: "::#{Monarchy.hierarchy_class}"
+      end
     end
 
     module InstanceMethods
@@ -55,11 +69,9 @@ module Monarchy
       end
 
       def parent=(resource)
-        if hierarchy
-          hierarchy.update(parent: resource.try(:ensure_hierarchy))
-        else
-          @parent = resource
-        end
+        Monarchy::Validators.resource(resource, true)
+        hierarchy&.update(parent: resource.try(:ensure_hierarchy))
+        @parent = resource
       end
 
       def children
@@ -67,12 +79,12 @@ module Monarchy
       end
 
       def children=(array)
-        hierarchy.update(children: hierarchies_for(array)) if hierarchy
+        hierarchy&.update(children: hierarchies_for(array))
         @children = array
       end
 
       def ensure_hierarchy(force = false)
-        self.hierarchy ||= Monarchy::Hierarchy.create(
+        self.hierarchy ||= Monarchy.hierarchy_class.create(
           resource: self,
           parent: parent.try(:hierarchy),
           children: hierarchies_for(children)
@@ -82,12 +94,12 @@ module Monarchy
       private
 
       def assign_parent(force = false)
-        parentize = self.class.parentize
+        parentize = self.class.parentize_name
+        return unless parentize
 
-        if parentize
-          was_changed = changes["#{parentize}_id"] || changes["#{parentize}_type"]
-          self.parent = send(parentize) if was_changed || force
-        end
+        was_changed = changes["#{parentize}_id"] || changes["#{parentize}_type"]
+        Monarchy::Validators.resource(send(parentize), true, false)
+        self.parent = send(parentize) if was_changed || force
       end
 
       def children_resources
@@ -97,7 +109,8 @@ module Monarchy
       end
 
       def hierarchies_for(array)
-        Array(array).map(&:hierarchy)
+        array&.compact!
+        Array(array).map { |resource| Monarchy::Validators.resource(resource).hierarchy }
       end
     end
   end

data/lib/monarchy/acts_as_user.rb

@@ -6,10 +6,10 @@ module Monarchy
     module ClassMethods
       def acts_as_user
         has_many :members, class_name: "::#{Monarchy.member_class}", dependent: :destroy
-        has_many :hierarchies, through: :members, class_name: 'Monarchy::Hierarchy'
+        has_many :hierarchies, through: :members, class_name: "::#{Monarchy.hierarchy_class}"
 
         scope :accessible_for, (lambda do |user|
-          where(id: Monarchy::Hierarchy.accessible_for(user)
+          where(id: Monarchy.hierarchy_class.accessible_for(user)
                                        .joins(members: [:user]).select(:user_id)).union(where(id: user.id))
         end)
 
@@ -18,24 +18,26 @@ module Monarchy
     end
 
     module InstanceMethods
-      def roles_for(resource, inheritence = true)
-        return Monarchy.role_class.none unless resource.hierarchy
-        accessible_roles_for(resource, inheritence)
+      def roles_for(resource, inheritance = true)
+        Monarchy::Validators.resource(resource, false, false)
+        accessible_roles_for(resource, inheritance)
       end
 
       def member_for(resource)
+        Monarchy::Validators.resource(resource)
         resource.hierarchy.members.where(monarchy_members: { user_id: id }).first
       end
 
-      def grant(role_name, resource)
+      def grant(*role_names, resource)
         ActiveRecord::Base.transaction do
-          grant_or_create_member(role_name, resource)
+          grant_or_create_member(role_names, resource)
         end
       end
 
-      def revoke_access(resource, hierarchy_ids = nil)
-        hierarchy_ids ||= resource.hierarchy.self_and_descendant_ids
-        members_for(hierarchy_ids).delete_all
+      def revoke_access(resource, hierarchies = nil)
+        Monarchy::Validators.resource(resource)
+        hierarchies ||= resource.hierarchy.self_and_descendants
+        members_for(hierarchies).delete_all
       end
 
       def revoke_role(role_name, resource)
@@ -43,14 +45,15 @@ module Monarchy
       end
 
       def revoke_role!(role_name, resource)
-        revoking_role(role_name, resource, true)
+        revoking_role(role_name, resource, Monarchy.configuration.revoke_strategy)
       end
 
       private
 
       def accessible_roles_for(resource, inheritnce)
+        return Monarchy.role_class.none unless resource.hierarchy
         accessible_roles = if inheritnce
-                             resource_and_inheritence_roles(resource)
+                             resource_and_inheritance_roles(resource)
                            else
                              resource_roles(resource).order('level desc')
                            end
@@ -58,7 +61,7 @@ module Monarchy
         accessible_roles.present? ? accessible_roles : descendant_role(resource)
       end
 
-      def resource_and_inheritence_roles(resource)
+      def resource_and_inheritance_roles(resource)
         hierarchy_ids = resource.hierarchy.ancestors.select(:id)
         Monarchy.role_class.where(id:
                       Monarchy.role_class.joins(:members).where('monarchy_members.user_id': id)
@@ -71,52 +74,61 @@ module Monarchy
       def resource_roles(resource)
         Monarchy.role_class.joins(:members)
                 .where('monarchy_members.hierarchy_id': resource.hierarchy.id, 'monarchy_members.user_id': id)
-                .distinct
       end
 
       def descendant_role(resource)
-        descendant_ids = resource.hierarchy.descendant_ids
-        children_access = members_for(descendant_ids).present?
-        children_access ? Monarchy.role_class.where(id: default_role) : Monarchy.role_class.none
+        descendants = resource.hierarchy.descendants
+        children_access = members_for(descendants).present?
+        children_access ? Monarchy.role_class.where(id: inherited_default_role) : Monarchy.role_class.none
       end
 
-      def revoking_role(role_name, resource, force = false)
-        member_roles = member_for(resource).try(:members_roles)
+      def revoking_role(role_name, resource, strategy = nil)
+        Monarchy::Validators.resource(resource)
+        role = Monarchy::Validators.role_name(role_name)
+
+        member = member_for(resource)
+        member_roles = member.try(:members_roles)
         return 0 if member_roles.nil?
 
-        return revoke_access(resource) if last_role?(member_roles, role_name) && force
-        member_roles.joins(:role).where(monarchy_roles: { name: role_name }).delete_all
+        revoking_last_role(role, resource, strategy) if Monarchy::Validators.last_role?(member, role)
+        member_roles.where(role: role).delete_all
       end
 
-      def grant_or_create_member(role_name, resource)
-        role = Monarchy.role_class.find_by(name: role_name)
-        raise 'Role does not exist' unless role
+      def revoking_last_role(role, resource, strategy)
+        case strategy
+        when :revoke_access
+          return revoke_access(resource)
+        when :revoke_member
+          return member_for(resource).delete
+        else
+          default_role = Monarchy::Validators.default_role?(resource, role)
+          raise Monarchy::Exceptions::RoleNotRevokable if default_role
+
+          grant(resource.class.default_role_name, resource)
+        end
+      end
 
+      def grant_or_create_member(role_names, resource)
+        Monarchy::Validators.resource(resource)
+        roles = Monarchy::Validators.role_names(role_names)
         member = member_for(resource)
+
         if member
-          Monarchy::MembersRole.create(member: member, role: role)
+          member_roles = roles.map { |role| { member: member, role: role } }
+          Monarchy::MembersRole.create(member_roles)
         else
-          member = Monarchy.member_class.create(user: self, hierarchy: resource.hierarchy, roles: [role])
+          member = Monarchy.member_class.create(user: self, hierarchy: resource.hierarchy, roles: roles)
         end
 
         member
       end
 
-      def members_for(hierarchy_ids)
-        Monarchy.member_class.where(hierarchy_id: hierarchy_ids, user_id: id)
-      end
-
-      def default_role
-        @default_role ||= Monarchy.role_class.find_by(name: Monarchy.configuration.default_role.name)
-      end
-
-      def last_role?(member_roles, role_name = nil)
-        role_name ||= default_role.name
-        member_roles.count == 1 && member_roles.first.role.name == role_name.to_s
+      def members_for(hierarchies)
+        Monarchy.member_class.where(hierarchy: hierarchies, user_id: id)
       end
 
-      def default_role?(role_name)
-        default_role.name.to_s == role_name.to_s
+      def inherited_default_role
+        @inherited_default_role ||= Monarchy.role_class.find_by(name: Monarchy.configuration.inherited_default_role)
       end
     end
   end

data/lib/monarchy/exceptions.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+module Monarchy
+  module Exceptions
+    class Error < StandardError; end
+
+    class ClassNotDefined < Error
+      def initialize(class_name)
+        @class_name = class_name
+      end
+
+      def message
+        "#{@class_name} class has to be initialized or exist!"
+      end
+    end
+
+    class ConfigNotDefined < Error
+      def initialize(property)
+        @property = property
+      end
+
+      def message
+        "Monarchy requires a #{@property} to be configured!"
+      end
+    end
+
+    class RoleNotExist < Error
+      def initialize(role_name)
+        @role_name = role_name
+      end
+
+      def message
+        "Role '#{@role_name}' does not exist"
+      end
+    end
+
+    class ModelNotResource < Error
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def message
+        "Model '#{@resource.class}' is not acting as resource!"
+      end
+    end
+
+    class ModelNotHierarchy < Error
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def message
+        "Model '#{@resource.class}' is not a hierarchy!"
+      end
+    end
+
+    class ModelNotMember < Error
+      def initialize(member)
+        @member = member
+      end
+
+      def message
+        "Model '#{@member.class}' is not acting as member!"
+      end
+    end
+
+    class ModelNotRole < Error
+      def initialize(role)
+        @role = role
+      end
+
+      def message
+        "Model '#{@role.class}' is not acting as role!"
+      end
+    end
+
+    class ModelNotUser < Error
+      def initialize(user)
+        @user = user
+      end
+
+      def message
+        "Model '#{@user.class}' is not acting as user!"
+      end
+    end
+
+    class RoleNotRevokable < Error
+      def message
+        "Can not revoke default role when no more roles exists! \
+          (Use 'revoke_role!' if you know what you are doing )"
+      end
+    end
+
+    class ResourceIsNil < Error
+      def message
+        'Resource can NOT be nil!'
+      end
+    end
+
+    class HierarchyIsNil < Error
+      def message
+        'Hierarchy can NOT be nil!'
+      end
+    end
+
+    class UserIsNil < Error
+      def message
+        'User can NOT be nil!'
+      end
+    end
+
+    class MemberIsNil < Error
+      def message
+        'Member can NOT be nil!'
+      end
+    end
+
+    class RoleIsNil < Error
+      def message
+        'Role can NOT be nil!'
+      end
+    end
+
+    class ResourceNotPersist < Error
+      def message
+        'Resource has to persisted!'
+      end
+    end
+
+    class HierarchyNotPersist < Error
+      def message
+        'Resource has to persisted!'
+      end
+    end
+  end
+end

data/lib/monarchy/tasks.rb

@@ -31,7 +31,7 @@ module Monarchy
         end
       end
 
-      Monarchy::Hierarchy.rebuild!
+      Monarchy.hierarchy_class.rebuild!
       p 'Monarchy reparentize ended!'
     end
   end

data/lib/monarchy/validators.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module Monarchy
+  module Validators
+    class << self
+      def last_role?(member, role)
+        member(member)
+        role(role)
+        (member.roles - [role]).empty?
+      end
+
+      def default_role?(resource, role)
+        resource(resource)
+        role(role)
+
+        role == resource.class.default_role
+      end
+
+      def role_name(role_name)
+        role = Monarchy.role_class.find_by(name: role_name)
+        role || raise(Monarchy::Exceptions::RoleNotExist, role_name)
+      end
+
+      def role_names(*role_names)
+        role_names.flatten!
+        roles = Monarchy.role_class.where(name: role_names)
+        wrong_names = role_names.map(&:to_s) - roles.map(&:name)
+        wrong_names.each { |name| raise(Monarchy::Exceptions::RoleNotExist, name) }
+        roles
+      end
+
+      def resource(resource, allow_nil = false, persistance = true)
+        raise Monarchy::Exceptions::ResourceIsNil if !resource && !allow_nil
+
+        model = check_model_class(resource, 'ModelNotResource') do
+          resource.class.try(:acting_as_resource)
+        end
+
+        persistance && resource && !resource.persisted? ? raise(Monarchy::Exceptions::ResourceNotPersist) : model
+      end
+
+      def hierarchy(hierarchy, allow_nil = false, persistance = true)
+        raise Monarchy::Exceptions::HierarchyIsNil if !hierarchy && !allow_nil
+
+        model = check_model_class(hierarchy, 'ModelNotHierarchy') do
+          hierarchy.is_a?(Monarchy.hierarchy_class)
+        end
+
+        persistance && hierarchy && !hierarchy.persisted? ? raise(Monarchy::Exceptions::HierarchyNotPersist) : model
+      end
+
+      def user(user, allow_nil = false)
+        raise Monarchy::Exceptions::UserIsNil if !user && !allow_nil
+        model_is_class(user, Monarchy.user_class, 'ModelNotUser')
+      end
+
+      def member(member, allow_nil = false)
+        raise Monarchy::Exceptions::MemberIsNil if !member && !allow_nil
+        model_is_class(member, Monarchy.member_class, 'ModelNotMember')
+      end
+
+      def role(role, allow_nil = false)
+        raise Monarchy::Exceptions::RoleIsNil if !role && !allow_nil
+        model_is_class(role, Monarchy.role_class, 'ModelNotRole')
+      end
+
+      private
+
+      def check_model_class(model, exception_class)
+        if yield
+          model
+        elsif model
+          raise "Monarchy::Exceptions::#{exception_class}".constantize, model
+        end
+      end
+
+      def model_is_class(model, klass, exception_class)
+        check_model_class(model, exception_class) do
+          model.is_a?(klass)
+        end
+      end
+    end
+  end
+end

data/lib/monarchy/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Monarchy
-  VERSION = '1.1.5'
+  VERSION = '2.0.0-beta.1'
 end

data/lib/monarchy.rb

@@ -3,12 +3,14 @@ require 'closure_tree'
 require 'configurations'
 require 'active_record_union'
 
+require 'monarchy/exceptions'
+require 'monarchy/validators'
 require 'monarchy/tasks'
 require 'monarchy/engine'
 
-require 'monarchy/acts_as_user'
 require 'monarchy/acts_as_role'
 require 'monarchy/acts_as_member'
+require 'monarchy/acts_as_user'
 require 'monarchy/acts_as_resource'
 require 'monarchy/acts_as_hierarchy'
 
@@ -24,23 +26,34 @@ module Monarchy
   configuration_defaults do |config|
     config.member_class_name = 'Monarchy::Member'
     config.role_class_name = 'Monarchy::Role'
-    config.member_force_revoke = false
+    config.hierarchy_class_name = 'Monarchy::Hierarchy'
+    config.members_access_revoke = false
+    config.revoke_strategy = :revoke_member
   end
 
-  not_configured do |prop|
-    raise NoMethodError, "Monarchy requires a #{prop} to be configured"
+  not_configured do |property|
+    raise Monarchy::Exceptions::ConfigNotDefined, property
   end
 
   def self.member_class
-    Monarchy.configuration.member_class_name.safe_constantize
+    Monarchy.configuration.member_class_name.safe_constantize || class_not_defined('Member')
   end
 
   def self.role_class
-    Monarchy.configuration.role_class_name.safe_constantize
+    Monarchy.configuration.role_class_name.safe_constantize || class_not_defined('Role')
   end
 
   def self.user_class
-    klass = Monarchy.configuration.user_class_name.safe_constantize
-    klass ? klass : raise(ArgumentError, 'User class has to be initialized or exist!')
+    Monarchy.configuration.user_class_name.safe_constantize || class_not_defined('User')
+  end
+
+  def self.hierarchy_class
+    Monarchy.configuration.hierarchy_class_name.safe_constantize || class_not_defined('Hierarchy')
+  end
+
+  private
+
+  def class_not_defined(class_name)
+    raise Monarchy::Exceptions::ClassNotDefined, class_name
   end
 end

data/monarchy.gemspec

@@ -25,13 +25,13 @@ Gem::Specification.new do |s|
   s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency 'rails', '~> 4.2', '>= 4.2.4'
-  s.add_dependency 'closure_tree', '6.1.0'
-  s.add_dependency 'configurations', '2.2.0'
+  s.add_runtime_dependency 'rails', '~> 4.2', '>= 4.2.7.1'
+  s.add_dependency 'closure_tree', '6.2.0'
+  s.add_dependency 'configurations', '2.2.1'
   s.add_dependency 'active_record_union', '1.2.0'
   s.add_dependency 'tqdm', '0.3.0'
 
   s.add_development_dependency 'bundler', '~> 1.12'
-  s.add_development_dependency 'rake', '~> 11.1'
+  s.add_development_dependency 'rake', '~> 11.3'
   s.add_development_dependency 'rspec', '3.5.0'
 end