repository-manager 0.1.18 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5570145fdab6a68044c23360f2cda512bbff93da
-  data.tar.gz: 63ac568cef21b1e6e1c69f34ec14701a811e393b
+  metadata.gz: 7f4887b6bdb653d978499c8da9c904af411cdcdf
+  data.tar.gz: 30bcb1450fc36c85e7f45146ddd6d355bcc06032
 SHA512:
-  metadata.gz: 3aa7875fc7c3cbcb7653af770e548eade784c6d10dc35bb6e86a8baffcd5c3764acf9133d3cf86386cb1fc98ae33a5ec7c757c4f88ea7723bbb52930bf05a208
-  data.tar.gz: 82b701bd769e352108cbcf7c25773d1e48ad0b7b068056c6f75f2956429f74cc238124b5182393f8af7228c626aba9f8c65e019f75fa278d81534ca8a8dd54d8
+  metadata.gz: 4a4fad797cc95fd161805a8c226baa52d3a8f209871b3679b27aa68f32629cdc3bfb79d39dfed2797f03453ab604be590a527b45b527cdf6e11f16af6370ece3
+  data.tar.gz: 01f74b128f2f88026bd078479a0a81268608b9c77ef3830797df2a433c3da52a98edb2df2c022ca8432b567853161abb876d40e3a1d1ee6a796583ee32a663f6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    repository-manager (0.1.17)
+    repository-manager (0.1.18)
       ancestry
       carrierwave (>= 0.5.8)
       rails (> 3.0.0)

data/README.md

@@ -6,7 +6,7 @@ Ruby on Rails plugin (gem) for managing repositories (files/folders/permissions/
 
 This gem add functionalities to manage repositories. Each instance (users, groups, etc..) can have it own repository (with files and folders). It can manage them (edit, remove, add, etc) and share them with other objects.
 
-This project is based on the need for a repository manager system for [Collaide](https://github.com/facenord-sud/collaide). A system for easily create/delete files and folders in a repository. For sharing these "repo items" easily with other object with a flexible and complete authorisations management.
+This project is based on the need for a repository manager system for [Collaide](https://github.com/facenord-sud/collaide). A system for easily create/delete files and folders in a repository. For sharing these "repo items" easily with other object with a flexible and complete permissions management.
 
 Instead of creating my core repository manager system heavily 
 dependent on our development, I'm trying to implement a generic and potent repository gem.
@@ -72,7 +72,7 @@ end
 ```
 
 
-See the chapter [Authorisations](#authorisations) for more details about the permissions.
+See the chapter [Permissions](#permissions) for more details about the permissions.
 
 ## Preparing your models
 
@@ -116,7 +116,7 @@ A few methods are written in those two ways :
 - method(arg, options)
 - method!(arg, options) (note the "!")
 
-The two methods do the same, but the one with the "!" returns an Exception error if it is a problem (AuthorisationException or RepositoryManagerException for instance) and the method without "!" return false if it has a problem.
+The two methods do the same, but the one with the "!" returns an Exception error if it is a problem (PermissionException or RepositoryManagerException for instance) and the method without "!" return false if it has a problem.
 
 ### How can I create/delete/move a repo_item (file or folder)
 
@@ -227,7 +227,7 @@ file.sender # Returns user1
 
 ```
 
-WARNING : There is no verification if the user has the authorisation to create a file or folder into this group. You have to check this in your controller ! The fact that user1 is the sender of this folder gives him NO AUTHORISATION on it !
+WARNING : There is no verification if the user has the permission to create a file or folder into this group. You have to check this in your controller ! The fact that user1 is the sender of this folder gives him NO AUTHORISATION on it !
 
 ### How can I share a repo_item (file/folder)
 
@@ -254,7 +254,7 @@ sharing = user1.share(the_new_folder, members, options)
 
 `sharing_permissions` specifies if the member of the sharing can add or remove other members in this sharing.
 
-See the chapter [Authorisations](#authorisations) for more details.
+See the chapter [Permissions](#permissions) for more details.
 
 ### Repository Manager and the nested sharing
 
@@ -338,7 +338,7 @@ For file details, more infos on [the documentation of the carrierwave gem](https
 ### How can I manage a sharing
 
 
-If it has the authorisation, an object can add members to a sharing.
+If it has the permission, an object can add members to a sharing.
 
 ```ruby
 # user1 want to add members to his sharing
@@ -365,14 +365,14 @@ group2.can_remove_from?(sharing) # => false
 # If user2 (the user who was add with the sharing permissions : {can_add: true, can_remove: false}) add a member in the sharing, he can choose if the permission ':can_add' is true or false, but he can't put ':can_remove' to true (because he don't have this permission himself).
 ```
 
-If an object has the authorisation, it can remove members from a sharing, else the method return `false` (or raise an AuthorisationException if you user the `remove_members_from!` method).
+If an object has the permission, it can remove members from a sharing, else the method return `false` (or raise an PermissionException if you user the `remove_members_from!` method).
 
 ```ruby
 # user1 want to remove group2 from the sharing `sharing`
 user1.remove_members_from(sharing, group2) # The second parameter can be an object or an array of object
 ```
 
-You can directly work with the `sharing`. Be careful, there is NO authorisation control !
+You can directly work with the `sharing`. Be careful, there is NO permission control !
 
 ```ruby
 # Add a member to the sharing `sharing`
@@ -385,36 +385,36 @@ sharing.add_members(member, {can_add: true, can_remove: false})
 sharing.remove_members([user2, group1])
 ```
 
-### Authorisations
+### Permissions
 
-#### Repository authorisations
+#### Repository permissions
 
-The owner of a `repo_item` (file or folder) has all the authorisations on it. When he share this `repo_item`, he can choose what authorisation he gives to the share. The authorisations are :
+The owner of a `repo_item` (file or folder) has all the permissions on it. When he share this `repo_item`, he can choose what permission he gives to the share. The permissions are :
 - `can_read?(repo_item)` : The member can read (=download) this file/folder.
 - `can_create?(repo_item)` : Can create in the repo_item (Note: if repo_item is nil (= own root), always true).
 - `can_update?(repo_item)` : Can update a repo_item (ex: rename).
 - `can_delete?(repo_item)` : Can delete a repo_item.
 - `can_share?(repo_item)` : Can share a repo_item.
 
-To check if a user has one of this authorisation, you just have to write : `user1.can_read?(repo_item)`, `user1.can_share?(repo_item)`, etc (it returns `true` or `false`).
+To check if a user has one of this permission, you just have to write : `user1.can_read?(repo_item)`, `user1.can_share?(repo_item)`, etc (it returns `true` or `false`).
 
 NOTICE : An object who can share a repo_item, can't set new permissions that it doesn't have.
 For instance: `user3` has a `sharing` of `repo_item1` in which it `:can_delete => false` and `:can_share => true`. He can share `repo_item1` with `user4`, but he can't put `:can_delete => true` in the `repo_item_permission` of this new share.
 
-You can get all the authorisations of an `object` in a `repo_item` with this method: `object.get_authorisations(repo_item)`
+You can get all the permissions of an `object` in a `repo_item` with this method: `object.get_permissions(repo_item)`
 
 ```ruby
-      # Gets the repo authorisations
-      # Return false if the entity has not the authorisation to share this rep
-      # Return true if the entity can share this rep with all the authorisations
+      # Gets the repo permissions
+      # Return false if the entity has not the permission to share this rep
+      # Return true if the entity can share this rep with all the permissions
       # Return an Array if the entity can share but with restriction
-      # Return true if the repo_item is nil (he as all authorisations on his own rep)
-      def get_authorisations(repo_item = nil)
+      # Return true if the repo_item is nil (he as all permissions on his own rep)
+      def get_permissions(repo_item = nil)
         [...]
       end
 ```
 
-#### Sharing authorisations
+#### Sharing permissions
 
 You can manage the permissions of a member in a sharing. The owner of the sharing has all the permissions. The sharing permissions are:
 - `can_add_to?(sharing)` : The member can add a new instance in this sharing.
@@ -422,7 +422,7 @@ You can manage the permissions of a member in a sharing. The owner of the sharin
 
 To check if the object can add or remove an instance in the sharing, just write : `group1.can_add_to?(sharing)` or `group1.can_remove_from?(sharing)` (it returns `true` or `false`).
 
-Like the repo_item authorisations, you can get the sharing authorisations of an `object` in a `sharing` with : `object.get_sharing_authorisations(sharing)`.
+Like the repo_item permissions, you can get the sharing permissions of an `object` in a `sharing` with : `object.get_sharing_permissions(sharing)`.
 
 ### Download a repository
 
@@ -456,7 +456,6 @@ the_folder.delete_zip
 ## TODO
 
 - Do the rename file method
-- Test the copy method
 - Configure path to save files
 - Write the methods : share_link.
 - Snapshot the file if possible

data/app/models/repository_manager/repo_file.rb

@@ -50,7 +50,7 @@ class RepositoryManager::RepoFile < RepositoryManager::RepoItem
   def copy(options = {})
     begin
       copy!(options)
-    rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+    rescue RepositoryManager::PermissionException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
       false
     end
   end

data/app/models/repository_manager/repo_folder.rb

@@ -1,7 +1,6 @@
 require 'zip'
 
 class RepositoryManager::RepoFolder < RepositoryManager::RepoItem
-  #attr_accessible :name if RepositoryManager.protected_attributes?
 
   validates :name, presence: true
 
@@ -84,7 +83,7 @@ class RepositoryManager::RepoFolder < RepositoryManager::RepoItem
   def copy(options = {})
     begin
       copy!(options)
-    rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+    rescue RepositoryManager::PermissionException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
       false
     end
   end

data/app/models/repository_manager/sharing.rb

@@ -19,8 +19,8 @@ class RepositoryManager::Sharing < ActiveRecord::Base
   #  joins(:sharings_members).where('sharings_members.member_id' => member.id,'sharings_members.member_type' => member.class.base_class.to_s)
   #}
 
-  # Return the authorisations of the sharing for the member
-  def get_authorisations(member)
+  # Return the permissions of the sharing for the member
+  def get_permissions(member)
     # If the member is the owner, he can do what he want !
     if self.owner == member
       return true

data/lib/repository_manager/exceptions.rb

@@ -2,7 +2,7 @@ module RepositoryManager
   class RepositoryManagerException < RuntimeError
   end
 
-  class AuthorisationException < RepositoryManagerException
+  class PermissionException < RepositoryManagerException
   end
 
   class NestedSharingException < RepositoryManagerException

data/lib/repository_manager/has_repository.rb

@@ -53,10 +53,10 @@ module RepositoryManager
           end
         end
 
-        authorisations = get_authorisations(repo_item)
+        permissions = get_permissions(repo_item)
 
-        # Here we look if the instance has the authorisation for making a sharing
-        if can_share?(nil, authorisations)
+        # Here we look if the instance has the permission for making a sharing
+        if can_share?(nil, permissions)
 
           # We put the default options
           repo_item_permissions = RepositoryManager.default_repo_item_permissions
@@ -67,7 +67,7 @@ module RepositoryManager
           sharing_permissions = options[:sharing_permissions] if options[:sharing_permissions]
 
           # Correct the item permission with accepted permissions
-          repo_item_permissions = make_repo_item_permissions(repo_item_permissions, authorisations)
+          repo_item_permissions = make_repo_item_permissions(repo_item_permissions, permissions)
 
           sharing = RepositoryManager::Sharing.new(repo_item_permissions)
           sharing.owner = self
@@ -80,14 +80,14 @@ module RepositoryManager
           sharing
         else
           # No permission => No sharing
-          raise RepositoryManager::AuthorisationException.new("sharing failed. You don't have the permission to share the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("sharing failed. You don't have the permission to share the repo_item '#{repo_item.name}'")
         end
       end
 
       def share(repo_item, members, options = {})
         begin
           share!(repo_item, members, options)
-        rescue RepositoryManager::AuthorisationException, RepositoryManager::NestedSharingException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+        rescue RepositoryManager::PermissionException, RepositoryManager::NestedSharingException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
       end
@@ -99,7 +99,7 @@ module RepositoryManager
       # Returns the object of the folder created if it is ok
       # Returns an Exception if the folder is not created
       #     RepositoryManagerException if the name already exist
-      #     AuthorisationException if the object don't have the permission
+      #     PermissionException if the object don't have the permission
       def create_folder!(name = '', options = {})
         source_folder = options[:source_folder]
         if source_folder
@@ -108,7 +108,7 @@ module RepositoryManager
           end
         end
 
-        # If he want to create a folder in a directory, we have to check if he have the authorisation
+        # If he want to create a folder in a directory, we have to check if he have the permission
         if can_create?(source_folder)
 
           folder = RepoFolder.new
@@ -130,7 +130,7 @@ module RepositoryManager
 
           folder.save!
         else
-          raise RepositoryManager::AuthorisationException.new("create_folder failed. You don't have the permission to create a folder in '#{source_folder.name}'")
+          raise RepositoryManager::PermissionException.new("create_folder failed. You don't have the permission to create a folder in '#{source_folder.name}'")
         end
         folder
       end
@@ -140,7 +140,7 @@ module RepositoryManager
       def create_folder(name = '', options = {})
         begin
           create_folder!(name, options)
-        rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+        rescue RepositoryManager::PermissionException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
       end
@@ -150,14 +150,14 @@ module RepositoryManager
         if can_delete?(repo_item)
           repo_item.destroy
         else
-          raise RepositoryManager::AuthorisationException.new("delete_repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("delete_repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
         end
       end
 
       def delete_repo_item(repo_item)
         begin
           delete_repo_item!(repo_item)
-        rescue RepositoryManager::AuthorisationException
+        rescue RepositoryManager::PermissionException
           false
         end
       end
@@ -171,7 +171,7 @@ module RepositoryManager
       # Returns the object of the file created if it is ok
       # Returns an Exception if the folder is not created
       #     RepositoryManagerException if the file already exist
-      #     AuthorisationException if the object don't have the permission
+      #     PermissionException if the object don't have the permission
       def create_file!(file, options = {})
         source_folder = options[:source_folder]
         if source_folder
@@ -180,7 +180,7 @@ module RepositoryManager
           end
         end
 
-        # If he want to create a file in a directory, we have to check if he have the authorisation
+        # If he want to create a file in a directory, we have to check if he have the permission
         if can_create?(source_folder)
 
           if file.class.name == 'RepositoryManager::RepoFile'
@@ -206,7 +206,7 @@ module RepositoryManager
 
           repo_file.save!
         else
-          raise RepositoryManager::AuthorisationException.new("create_file failed. You don't have the permission to create a file")
+          raise RepositoryManager::PermissionException.new("create_file failed. You don't have the permission to create a file")
         end
         repo_file
       end
@@ -214,17 +214,17 @@ module RepositoryManager
       def create_file(file, options = {})
         begin
           create_file!(file, options)
-        rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+        rescue RepositoryManager::PermissionException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
       end
 
-      # Gets the repo authorisations
-      # Return false if the entity has not the authorisation to share this rep
-      # Return true if the entity can share this rep with all the authorisations
+      # Gets the repo permissions
+      # Return false if the entity has not the permission to share this rep
+      # Return true if the entity can share this rep with all the permissions
       # Return an Array if the entity can share but with restriction
-      # Return true if the repo_item is nil (he as all authorisations on his own rep)
-      def get_authorisations(repo_item = nil)
+      # Return true if the repo_item is nil (he as all permissions on his own rep)
+      def get_permissions(repo_item = nil)
         # If repo_item is nil, he can do what he want
         return true if repo_item == nil
 
@@ -256,14 +256,14 @@ module RepositoryManager
 
           repo_item.download!({object: self, path: path})
         else
-          raise RepositoryManager::AuthorisationException.new("download failed. You don't have the permission to download the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("download failed. You don't have the permission to download the repo_item '#{repo_item.name}'")
         end
       end
 
       def download(repo_item, options = {})
         begin
           download!(repo_item, options)
-        rescue RepositoryManager::AuthorisationException
+        rescue RepositoryManager::PermissionException
           false
         end
       end
@@ -271,7 +271,7 @@ module RepositoryManager
       # Rename the repo_item with the new_name
       def rename_repo_item!(repo_item, new_name)
         unless can_update?(repo_item)
-          raise RepositoryManager::AuthorisationException.new("rename repo_item failed. You don't have the permission to update the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("rename repo_item failed. You don't have the permission to update the repo_item '#{repo_item.name}'")
         end
         repo_item.rename!(new_name)
       end
@@ -280,7 +280,7 @@ module RepositoryManager
       def rename_repo_item(repo_item, new_name)
         begin
           rename_repo_item!(repo_item, new_name)
-        rescue RepositoryManager::AuthorisationException
+        rescue RepositoryManager::PermissionException
           false
         end
       end
@@ -290,26 +290,26 @@ module RepositoryManager
       # if target == nil, move to the root
       def move_repo_item!(repo_item, target = nil)
         if !can_read?(repo_item)
-          raise RepositoryManager::AuthorisationException.new("move repo_item failed. You don't have the permission to read the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("move repo_item failed. You don't have the permission to read the repo_item '#{repo_item.name}'")
         end
-        # If we want to change the owner we have to have the can_delete authorisation
+        # If we want to change the owner we have to have the can_delete permission
         if target
-          # If want to change the owner, we have to check if we have the authorisation
+          # If want to change the owner, we have to check if we have the permission
           if target.owner != repo_item.owner && !can_delete?(repo_item)
-            raise RepositoryManager::AuthorisationException.new("move repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
+            raise RepositoryManager::PermissionException.new("move repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
           end
           # If we don't want to change the owner, we look if we can_update
           if target.owner == repo_item.owner && !can_update?(repo_item)
-            raise RepositoryManager::AuthorisationException.new("move repo_item failed. You don't have the permission to update the '#{repo_item.name}'")
+            raise RepositoryManager::PermissionException.new("move repo_item failed. You don't have the permission to update the '#{repo_item.name}'")
           end
           # We check if we can_create in the source_folder
           unless can_create?(target)
-            raise RepositoryManager::AuthorisationException.new("move repo_item failed. You don't have the permission to create in the source_folder '#{options[:source_folder].name}'")
+            raise RepositoryManager::PermissionException.new("move repo_item failed. You don't have the permission to create in the source_folder '#{options[:source_folder].name}'")
           end
         else
           # Else if there is no source_folder, we check if we can delete the repo_item, if the owner change
           if self != repo_item.owner && !can_delete?(repo_item)
-            raise RepositoryManager::AuthorisationException.new("move repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
+            raise RepositoryManager::PermissionException.new("move repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'")
           end
         end
         # If it has the permission, we move the repo_item in the source_folder
@@ -330,11 +330,11 @@ module RepositoryManager
       #   :sender => the new sender (by default => still the old sender)
       def copy_repo_item!(repo_item, target = nil, options = {})
         unless can_read?(repo_item)
-          raise RepositoryManager::AuthorisationException.new("copy repo_item failed. You don't have the permission to read the repo_item '#{repo_item.name}'")
+          raise RepositoryManager::PermissionException.new("copy repo_item failed. You don't have the permission to read the repo_item '#{repo_item.name}'")
         end
 
         if target &&  !can_create?(target)
-          raise RepositoryManager::AuthorisationException.new("copy repo_item failed. You don't have the permission to create in the source_folder '#{target.name}'")
+          raise RepositoryManager::PermissionException.new("copy repo_item failed. You don't have the permission to create in the source_folder '#{target.name}'")
         end
 
         # The new owner
@@ -351,7 +351,7 @@ module RepositoryManager
       def copy_repo_item(repo_item, target = nil, options = {})
         begin
           copy_repo_item!(repo_item, target, options)
-        rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+        rescue RepositoryManager::PermissionException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
       end
@@ -361,41 +361,41 @@ module RepositoryManager
         FileUtils.rm_rf(self.get_default_download_path())
       end
 
-      #Return the authorisations of the sharing (can_add, can_remove)
-      def get_sharing_authorisations(sharing)
-        sharing.get_authorisations(self)
+      #Return the permissions of the sharing (can_add, can_remove)
+      def get_sharing_permissions(sharing)
+        sharing.get_permissions(self)
       end
 
       # Return true if you can share the repo, else false
-      # You can give the authorisations or the repo_item as params
-      def can_share?(repo_item, authorisations = nil)
-        can_do?('share', repo_item, authorisations)
+      # You can give the permissions or the repo_item as params
+      def can_share?(repo_item, permissions = nil)
+        can_do?('share', repo_item, permissions)
       end
 
       # Return true if you can read the repo, else false
-      def can_read?(repo_item, authorisations = nil)
-        can_do?('read', repo_item, authorisations)
+      def can_read?(repo_item, permissions = nil)
+        can_do?('read', repo_item, permissions)
       end
 
       # Return true if you can download the repo, else false
       # Read = Download for the moment
-      def can_download?(repo_item, authorisations = nil)
-        can_do?('read', repo_item, authorisations)
+      def can_download?(repo_item, permissions = nil)
+        can_do?('read', repo_item, permissions)
       end
 
       # Return true if you can create in the repo, false else
-      def can_create?(repo_item, authorisations = nil)
-        can_do?('create', repo_item, authorisations)
+      def can_create?(repo_item, permissions = nil)
+        can_do?('create', repo_item, permissions)
       end
 
       # Returns true if you can edit the repo, false else
-      def can_update?(repo_item, authorisations = nil)
-        can_do?('update', repo_item, authorisations)
+      def can_update?(repo_item, permissions = nil)
+        can_do?('update', repo_item, permissions)
       end
 
       # Returns true if you can delete the repo, false else
-      def can_delete?(repo_item, authorisations = nil)
-        can_do?('delete', repo_item, authorisations)
+      def can_delete?(repo_item, permissions = nil)
+        can_do?('delete', repo_item, permissions)
       end
 
       ## Returns true if  it exist a sharing in the ancestors of descendant_ids of the repo_item (without itself)
@@ -427,19 +427,19 @@ module RepositoryManager
       # You can here add new members in the sharing
       # Param member could be an object or an array of object
       def add_members_to!(sharing, members, options = RepositoryManager.default_sharing_permissions)
-        authorisations = get_sharing_authorisations(sharing)
+        permissions = get_sharing_permissions(sharing)
         if can_add_to?(sharing)
-          sharing_permissions = make_sharing_permissions(options, authorisations)
+          sharing_permissions = make_sharing_permissions(options, permissions)
           sharing.add_members(members, sharing_permissions)
         else
-          raise RepositoryManager::AuthorisationException.new("add members failed. You don't have the permission to add a member in this sharing")
+          raise RepositoryManager::PermissionException.new("add members failed. You don't have the permission to add a member in this sharing")
         end
       end
 
       def add_members_to(sharing, members, options = RepositoryManager.default_sharing_permissions)
         begin
           add_members_to!(sharing, members, options = RepositoryManager.default_sharing_permissions)
-        rescue RepositoryManager::AuthorisationException
+        rescue RepositoryManager::PermissionException
           false
         end
       end
@@ -450,14 +450,14 @@ module RepositoryManager
         if can_remove_from?(sharing)
           sharing.remove_members(members)
         else
-          raise RepositoryManager::AuthorisationException.new("remove members failed. You don't have the permission to remove a member on this sharing")
+          raise RepositoryManager::PermissionException.new("remove members failed. You don't have the permission to remove a member on this sharing")
         end
       end
 
       def remove_members_from(sharing, members)
         begin
           remove_members_from!(sharing, members)
-        rescue RepositoryManager::AuthorisationException
+        rescue RepositoryManager::PermissionException
           false
         end
       end
@@ -475,53 +475,53 @@ module RepositoryManager
       private
 
       # Return if you can do or not this action in the sharing
-      def can_do_to?(what, sharing, authorisations = nil)
-        if authorisations == nil
-          authorisations = sharing.get_authorisations(self)
+      def can_do_to?(what, sharing, permissions = nil)
+        if permissions == nil
+          permissions = sharing.get_permissions(self)
         end
         case what
           when 'add'
-            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_add] == true)
+            permissions == true || (permissions.kind_of?(Hash) && permissions[:can_add] == true)
           when 'remove'
-            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_remove] == true)
+            permissions == true || (permissions.kind_of?(Hash) && permissions[:can_remove] == true)
         end
       end
 
       # reflexion: can_do?(what, options)
       # options
-      #   hash : authorisations hash
-      #   class: RepoItem => get_authorisations
+      #   hash : permissions hash
+      #   class: RepoItem => get_permissions
       #   class: has_repository => regarder si on peu déplacer dans root (question: non pas possible ?)
 
       # Return if you can do or not this action (what)
-      def can_do?(what, repo_item, authorisations = nil)
-        # If we pass no authorisations we have to get it
-        if authorisations == nil
-          authorisations = get_authorisations(repo_item)
+      def can_do?(what, repo_item, permissions = nil)
+        # If we pass no permissions we have to get it
+        if permissions == nil
+          permissions = get_permissions(repo_item)
         end
 
         case what
           when 'read'
-            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_read] == true)
+            permissions == true || (permissions.kind_of?(Hash) && permissions[:can_read] == true)
           when 'delete'
             if RepositoryManager.accept_nested_sharing
               # TODO implement to look if he can delete all the folder
             else
-              authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_delete] == true)
+              permissions == true || (permissions.kind_of?(Hash) && permissions[:can_delete] == true)
             end
           when 'update'
-            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_update] == true)
+            permissions == true || (permissions.kind_of?(Hash) && permissions[:can_update] == true)
           when 'share'
             if RepositoryManager.accept_nested_sharing
               # TODO implement to look if he can delete all the folder
             else
-              authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_share] == true)
+              permissions == true || (permissions.kind_of?(Hash) && permissions[:can_share] == true)
             end
           when 'create'
             if RepositoryManager.accept_nested_sharing
               # TODO implement to look if he can delete all the folder
             else
-              authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_create] == true)
+              permissions == true || (permissions.kind_of?(Hash) && permissions[:can_create] == true)
             end
           else
             false
@@ -529,41 +529,41 @@ module RepositoryManager
 
       end
 
-      # Correct the repo_item_permissions with the authorisations
-      def make_repo_item_permissions(wanted_permissions, authorisations)
+      # Correct the repo_item_permissions with the permissions
+      def make_repo_item_permissions(wanted_permissions, permissions)
         # If it is an array, we have restriction in the permissions
-        if authorisations.kind_of?(Hash) && wanted_permissions
+        if permissions.kind_of?(Hash) && wanted_permissions
           # Built the sharing with the accepted permissions
           # We remove the permission if we can't sharing it
-          if wanted_permissions[:can_read] == true && authorisations[:can_read] == false
+          if wanted_permissions[:can_read] == true && permissions[:can_read] == false
             wanted_permissions[:can_read] = false
           end
-          if wanted_permissions[:can_create] == true && authorisations[:can_create] == false
+          if wanted_permissions[:can_create] == true && permissions[:can_create] == false
             wanted_permissions[:can_create] = false
           end
-          if wanted_permissions[:can_update] == true && authorisations[:can_update] == false
+          if wanted_permissions[:can_update] == true && permissions[:can_update] == false
             wanted_permissions[:can_update] = false
           end
-          if wanted_permissions[:can_delete] == true && authorisations[:can_delete] == false
+          if wanted_permissions[:can_delete] == true && permissions[:can_delete] == false
             wanted_permissions[:can_delete] = false
           end
-          if wanted_permissions[:can_share] == true && authorisations[:can_share] == false
+          if wanted_permissions[:can_share] == true && permissions[:can_share] == false
             wanted_permissions[:can_share] = false
           end
         end
         return wanted_permissions
       end
 
-      # Correct the sharing_permissions with the authorisations
-      def make_sharing_permissions(wanted_permissions, authorisations)
+      # Correct the sharing_permissions with the permissions
+      def make_sharing_permissions(wanted_permissions, permissions)
         # If it is an array, we have restriction in the permissions
-        if authorisations.kind_of?(Hash) && wanted_permissions
+        if permissions.kind_of?(Hash) && wanted_permissions
           # Built the sharing with the accepted permissions
           # We remove the permission if we can't share it
-          if wanted_permissions[:can_add] == true && authorisations[:can_add] == false
+          if wanted_permissions[:can_add] == true && permissions[:can_add] == false
             wanted_permissions[:can_add] = false
           end
-          if wanted_permissions[:can_remove] == true && authorisations[:can_remove] == false
+          if wanted_permissions[:can_remove] == true && permissions[:can_remove] == false
             wanted_permissions[:can_remove] = false
           end
         end

data/lib/repository_manager/version.rb

@@ -1,3 +1,3 @@
 module RepositoryManager
-  VERSION = '0.1.18'
+  VERSION = '0.1.19'
 end

data/repository-manager.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.email       = ['texicitys@gmail.com']
   s.homepage    = 'https://github.com/Texicitys/repository-manager'
   s.summary     = "Ruby on Rails plugin (gem) for managing repositories (files/folders/permissions/sharings)."
-  s.description = "This project is based on the need for a repository manager system for Collaide. A system for easily create/delete files and folders in a repository. For sharing these repositories easily with other object with a flexible and complete authorisations management.
+  s.description = "This project is based on the need for a repository manager system for Collaide. A system for easily create/delete files and folders in a repository. For sharing these repositories easily with other object with a flexible and complete permissions management.
 Each instance (users, groups, etc..) can have it own repositories (with files and folders). It can manage them easily (edit, remove, add, etc) and sharing them with other instance."
 
   #s.files = Dir["{app,config,db,lib}/**/*", "MIT-LICENSE", "Rakefile", "README.md"]

data/spec/has_repository_spec.rb

@@ -73,7 +73,7 @@ describe 'HasRepository' do
 
     # here user3 can share because he is the owner
     @user3.share(rep, members)
-    # here user2 should can share because he has the authorisation
+    # here user2 should can share because he has the permission
     members = []
     members << @user1
     @user2.share(rep, members)
@@ -95,7 +95,7 @@ describe 'HasRepository' do
 
     # here user3 can share because he is the owner
     @user3.share(rep, members, options)
-    # here user2 should can share because he has the authorisation
+    # here user2 should can share because he has the permission
     members = []
     members << @user1
     @user2.share(rep, members)
@@ -117,8 +117,8 @@ describe 'HasRepository' do
 
     # here user3 can share because he is the owner
     @user3.share(rep, members, options)
-    # here user2 should can share because he has the authorisation
-    # But he has only the authorisation of read (can_read = true), He can't share with more permissions
+    # here user2 should can share because he has the permission
+    # But he has only the permission of read (can_read = true), He can't share with more permissions
     members = []
     members << @user1
     #Here the permissions should be : :can_read => true, and all others false
@@ -146,8 +146,8 @@ describe 'HasRepository' do
 
     # here user3 can share because he is the owner
     @user3.share(rep, members, options)
-    # here user2 should can share because he has the authorisation
-    # But he has only the authorisation of read (can_read = true), He can't share with more permissions
+    # here user2 should can share because he has the permission
+    # But he has only the permission of read (can_read = true), He can't share with more permissions
     members = []
     members << @user1
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: repository-manager
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Yves Baumann
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.0.0
 description: |-
-  This project is based on the need for a repository manager system for Collaide. A system for easily create/delete files and folders in a repository. For sharing these repositories easily with other object with a flexible and complete authorisations management.
+  This project is based on the need for a repository manager system for Collaide. A system for easily create/delete files and folders in a repository. For sharing these repositories easily with other object with a flexible and complete permissions management.
   Each instance (users, groups, etc..) can have it own repositories (with files and folders). It can manage them easily (edit, remove, add, etc) and sharing them with other instance.
 email:
 - texicitys@gmail.com