repository-manager 0.0.7 → 0.0.8

data/db/migrate/20131018214212_create_repository_manager.rb

@@ -1,19 +1,10 @@
 class CreateRepositoryManager < ActiveRecord::Migration
 
   def change
-    #create_table :permissions do |t|
-    #  t.boolean :can_create, :default => false
-    #  t.boolean :can_read, :default => false
-    #  t.boolean :can_update, :default => false
-    #  t.boolean :can_delete, :default => false
-    #  t.boolean :can_share, :default => false
-    #end
 
-    create_table :shares do |t|
-      #t.integer :permission_id
-      #t.integer :user_id
+    create_table :sharings do |t|
       t.references :owner, polymorphic: true
-      t.integer :repository_id
+      t.references :repo_item
       t.boolean :can_create, :default => false
       t.boolean :can_read, :default => false
       t.boolean :can_update, :default => false
@@ -21,19 +12,20 @@ class CreateRepositoryManager < ActiveRecord::Migration
       t.boolean :can_share, :default => false
     end
 
-    create_table :shares_items do |t|
-      t.integer :share_id
-      #t.integer :item_type
-      #t.integer :item_id
-      t.references :item, polymorphic: true
+    create_table :sharings_members do |t|
+      t.references :sharing
+      t.references :member, polymorphic: true
       t.boolean :can_add, :default => false
       t.boolean :can_remove, :default => false
     end
 
-    create_table :repositories do |t|
+    create_table :repo_items do |t|
       t.references :owner, polymorphic: true
       t.string :ancestry
       t.string :name
+      t.float :file_size
+      t.string :content_type
+      t.string :file
       t.string :type
     end
   end

data/lib/generators/repository_manager/install_generator.rb

@@ -23,9 +23,7 @@ module RepositoryManager #:nodoc:
     #end
 
     def copy_migrations
-      migrations = [["20131018214212_create_repository_manager.rb","create_repository_manager.rb"],
-                    ["20131025085844_add_file_to_repositories.rb","add_file_to_repositories.rb"],
-                    ["20131025085845_add_file_to_files", "add_file_to_files.rb"]
+      migrations = [["20131018214212_create_repository_manager.rb","create_repository_manager.rb"]
                     ]
       migrations.each do |migration|
         migration_template "../../../../db/migrate/" + migration[0], "db/migrate/" + migration[1]

data/lib/generators/repository_manager/templates/initializer.rb

@@ -1,13 +1,8 @@
 RepositoryManager.setup do |config|
 
-  # Default repository permissions that an object has on the repository after a share.
-  config.default_repo_permissions = { can_read: true, can_create: false, can_update:false, can_delete:false, can_share: false }
+  # Default repo_item permissions that an object has on the repo_item after a sharing.
+  config.default_repo_item_permissions = { can_read: true, can_create: false, can_update:false, can_delete:false, can_share: false }
 
-  # Default share permissions thant an object has when he is added in a share.
-  config.default_share_permissions = { can_add: false, can_remove: false }
-end
-
-#Rails.application.configure do
-#  # Uncomment this to turn on verbose mode
-#  # config.my_gem.verbose = true
-#end
+  # Default sharing permissions that an object has when he is added in a sharing.
+  config.default_sharing_permissions = { can_add: false, can_remove: false }
+end

data/lib/repository-manager.rb

@@ -2,11 +2,11 @@ require 'repository_manager/has_repository'
 
 module RepositoryManager
 
-  mattr_accessor :default_repo_permissions
-  @@default_repo_permissions = { can_read: true, can_create: false, can_update:false, can_delete:false, can_share: false }
+  mattr_accessor :default_repo_item_permissions
+  @@default_repo_item_permissions = { can_read: true, can_create: false, can_update:false, can_delete:false, can_share: false }
 
-  mattr_accessor :default_share_permissions
-  @@default_share_permissions = { can_add: false, can_remove: false }
+  mattr_accessor :default_sharing_permissions
+  @@default_sharing_permissions = { can_add: false, can_remove: false }
 
   class << self
     def setup

data/lib/repository_manager/engine.rb

@@ -1,6 +1,5 @@
 require 'ancestry'
 require 'carrierwave'
-require 'enumerize'
 
 module RepositoryManager
   class Engine < ::Rails::Engine

data/lib/repository_manager/has_repository.rb

@@ -2,25 +2,22 @@ module RepositoryManager
   module HasRepository
     extend ActiveSupport::Concern
 
-    included do
-    end
-
     module ClassMethods
       def has_repository(options = {})
 
-        has_many :shares, through: :shares_items, dependent: :destroy
-        has_many :shares_items, as: :item, dependent: :destroy
-        has_many :shares_owners, as: :owner, class_name: 'Share'
+        has_many :sharings, through: :sharings_members
+        has_many :sharings_members, as: :member, dependent: :destroy
+        has_many :sharings_owners, as: :owner, class_name: 'Sharing'
 
-        # The own repositories
-        has_many :repositories, as: :owner #, dependent: :destroy
-        # The share repositories
-        has_many :shared_repositories, through: :shares, source: :repository, class_name: 'Repository'
+        # The own repo_items
+        has_many :repo_items, as: :owner #, dependent: :destroy
+        # The sharing repo_items
+        has_many :shared_repo_items, through: :sharings, source: :repo_item, class_name: 'RepoItem'
 
-        #scope :all_repositories, -> { self.repositories.shared_repositories }
+        #scope :all_repo_items, -> { self.repo_items.shared_repo_items }
 
-        #All repositories (own and shares)
-        #has_many :all_repositories
+        #All repo_items (own and sharings)
+        #has_many :all_repo_items
 
         include RepositoryManager::HasRepository::LocalInstanceMethods
       end
@@ -28,44 +25,45 @@ module RepositoryManager
 
     module LocalInstanceMethods
 
-      # Share the repository with the items, with the options
-      # options[:repo_permissions] contains :
-      #   <tt>:can_read</tt> - Item can download the repository
-      #   <tt>:can_create</tt> - Item can create a new repository on it
-      #   <tt>:can_edit</tt> - Item can edit the repository
-      #   <tt>:can_delete</tt> - Item can delete the repository
-      #   <tt>:can_share</tt> - Item can share the repository
-      # options[:share_permissions] contains :
-      #   <tt>:can_add</tt> - Specify if the item can add objects to the share
-      #   <tt>:can_remove</tt> - Specify if the item can remove object to the share
-      def share(repository, items, options = nil)
-        authorisations = get_authorisations(repository)
-
-        # Here we look if the instance has the authorisation for making a share
+      # Sharing the repo_item with the members, with the options
+      # options[:repo_item_permissions] contains :
+      #   <tt>:can_read</tt> - Member can download the repo_item
+      #   <tt>:can_create</tt> - Member can create a new repo_item on it
+      #   <tt>:can_edit</tt> - Member can edit the repo_item
+      #   <tt>:can_delete</tt> - Member can delete the repo_item
+      #   <tt>:can_share</tt> - Member can share the repo_item
+      # options[:sharing_permissions] contains :
+      #   <tt>:can_add</tt> - Specify if the member can add objects to the sharing
+      #   <tt>:can_remove</tt> - Specify if the member can remove object to the sharing
+      def share(repo_item, members, options = nil)
+        authorisations = get_authorisations(repo_item)
+
+        # Here we look if the instance has the authorisation for making a sharing
         if can_share?(nil, authorisations)
 
           # We put the default options
-          repo_permissions = RepositoryManager.default_repo_permissions
-          share_permissions = RepositoryManager.default_share_permissions
+          repo_item_permissions = RepositoryManager.default_repo_item_permissions
+          sharing_permissions = RepositoryManager.default_sharing_permissions
 
           # If there is options, we have to take it
           if options
-            repo_permissions = options[:repo_permissions] if options[:repo_permissions]
-            share_permissions = options[:share_permissions] if options[:share_permissions]
+            repo_item_permissions = options[:repo_item_permissions] if options[:repo_item_permissions]
+            sharing_permissions = options[:sharing_permissions] if options[:sharing_permissions]
           end
 
-          repo_permissions = make_repo_permissions(repo_permissions, authorisations)
+          repo_item_permissions = make_repo_item_permissions(repo_item_permissions, authorisations)
 
-          share = Share.new(repo_permissions)
-          share.owner = self
+          sharing = Sharing.new(repo_item_permissions)
+          sharing.owner = self
 
-          share.add_items(items, share_permissions)
+          sharing.add_members(members, sharing_permissions)
 
-          repository.shares << share
-          repository.save
-          share
+          repo_item.sharings << sharing
+          repo_item.save
+          sharing
         else
-          # No permission => No share
+          # No permission => No sharing
+          #raise "sharing failed. You don't have the permission to share the repo_item '#{repo_item.name}'"
           false
         end
       end
@@ -77,57 +75,64 @@ module RepositoryManager
         # If he want to create a folder in a directory, we have to check if he have the authorisation
         if can_create?(source_folder)
 
-          folder = Folder.new(name: name)
+          folder = RepoFolder.new(name: name)
           folder.owner = self
           folder.save
 
-          # If we want to create a folder in a folder, we have to check if we have the authorisation
-          if source_folder
-            source_folder.add_repository(folder)
+          # We have to look if it is ok to add the folder here
+          if source_folder == nil || source_folder.add(folder)
+            folder
+          else
+            # The add didn't works, we delete the folder
+            folder.destroy
+            #raise "create_folder failed. The folder '#{name}' already exist in folder '#{source_folder.name}'"
+            false
           end
-
-          return folder
         else
+          #raise "create_folder failed. You don't have the permission to create a folder in '#{source_folder.name}'"
           return false
         end
       end
 
-      # Delete the repository
-      def delete_repository(repository)
-        if can_delete?(repository)
-          repository.destroy
+      # Delete the repo_item
+      def delete_repo_item(repo_item)
+        if can_delete?(repo_item)
+          repo_item.destroy
         else
+          #raise "delete_repo_item failed. You don't have the permission to delete the repo_item '#{repo_item.name}'"
           return false
         end
       end
 
       # Create the file (file) in the directory (source_folder)
-      # Param file can be a File, or a instance of AppFile
+      # Param file can be a File, or a instance of RepoFile
       # Return the object of the file created if it is ok
       # Return false if the file is not created (no authorisation)
       def create_file(file, source_folder = nil)
         # If he want to create a file in a directory, we have to check if he have the authorisation
         if can_create?(source_folder)
           if file.class.name == 'File'
-            app_file = AppFile.new
-            app_file.file = file
-            app_file.owner = self
-            app_file.save
-          elsif file.class.name == 'AppFile'
-            app_file = file
-            app_file.owner = self
-            app_file.save
-          else
-            return false
+            repo_file = RepoFile.new
+            repo_file.file = file
+            repo_file.owner = self
+            repo_file.save
+          elsif file.class.name == 'RepoFile'
+            repo_file = file
+            repo_file.owner = self
+            repo_file.save
           end
 
-          # Add the file into the source_folder
-          if source_folder
-            source_folder.add_repository(file)
+          # We have to look if it is ok to add the file here
+          if source_folder == nil || source_folder.add(file)
+            return repo_file
+          else
+            # The add didn't works, we delete the file
+            file.destroy
+            #raise "create_file failed. The file '#{name}' already exist in folder '#{source_folder.name}'"
+            return false
           end
-
-          return app_file
         else
+          #raise "create_file failed. You don't have the permission to create a file in the folder '#{source_folder.name}'"
           return false
         end
       end
@@ -136,25 +141,25 @@ module RepositoryManager
       # 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
       # Return an Array if the entity can share but with restriction
-      # Return true if the repository is nil (he as all authorisations on his own rep)
-      def get_authorisations(repository = nil)
-        # If repository is nil, he can do what he want
-        return true if repository == nil
+      # Return true if the repo_item is nil (he as all authorisations on his own rep)
+      def get_authorisations(repo_item = nil)
+        # If repo_item is nil, he can do what he want
+        return true if repo_item == nil
 
-        # If the item is the owner, he can do what he want !
-        if repository.owner == self
+        # If the member is the owner, he can do what he want !
+        if repo_item.owner == self
           # You can do what ever you want :)
           return true
-          # Find if a share of this rep exist for the self instance
-        elsif s = self.shares.where(repository_id: repository.id).first
-          # Ok, give an array with the permission of the actual share
+          # Find if a sharing of this rep exist for the self instance
+        elsif s = self.sharings.where(repo_item_id: repo_item.id).first
+          # Ok, give an array with the permission of the actual sharing
           # (we can't share with more permission then we have)
           return {can_share: s.can_share, can_read: s.can_read, can_create: s.can_create, can_update: s.can_update, can_delete: s.can_delete}
         else
-          # We look at the ancestor if there is a share
-          ancestor_ids = repository.ancestor_ids
-          # Check the nearest share if it exist
-          if s = self.shares.where(repository_id: ancestor_ids).last
+          # We look at the ancestor if there is a sharing
+          ancestor_ids = repo_item.ancestor_ids
+          # Check the nearest sharing if it exist
+          if s = self.sharings.where(repo_item_id: ancestor_ids).last
             return {can_share: s.can_share, can_read: s.can_read, can_create: s.can_create, can_update: s.can_update, can_delete: s.can_delete}
           end
         end
@@ -162,93 +167,96 @@ module RepositoryManager
         return false
       end
 
-      # Download a repository if the object can_read it
+      # Download a repo_item if the object can_read it
       # If it is a file, he download the file
-      # If it is a folder, we check witch repository is in it, and witch he can_read
+      # If it is a folder, we check witch repo_item is in it, and witch he can_read
       # We zip all the content that the object has access.
-      def download(repository)
-        if can_download?(repository)
-          repository.download(self)
+      def download(repo_item)
+        if can_download?(repo_item)
+          repo_item.download(self)
         else
+          #raise "download failed. You don't have the permission to download the repo_item '#{repo_item.name}'"
           false
         end
       end
 
-      #Return the authorisations of the share (can_add, can_remove)
-      def get_share_authorisations(share)
-        share.get_authorisations(self)
+      #Return the authorisations of the sharing (can_add, can_remove)
+      def get_sharing_authorisations(sharing)
+        sharing.get_authorisations(self)
       end
 
       # Return true if you can share the repo, else false
-      # You can give the authorisations or the repository as params
-      def can_share?(repository, authorisations = nil)
-        can_do?('share', repository, authorisations)
+      # You can give the authorisations or the repo_item as params
+      def can_share?(repo_item, authorisations = nil)
+        can_do?('share', repo_item, authorisations)
       end
 
       # Return true if you can read the repo, else false
-      def can_read?(repository, authorisations = nil)
-        can_do?('read', repository, authorisations)
+      def can_read?(repo_item, authorisations = nil)
+        can_do?('read', repo_item, authorisations)
       end
 
       # Return true if you can download the repo, else false
       # Read = Download for the moment
-      def can_download?(repository, authorisations = nil)
-        can_do?('read', repository, authorisations)
+      def can_download?(repo_item, authorisations = nil)
+        can_do?('read', repo_item, authorisations)
       end
 
       # Return true if you can create in the repo, false else
-      def can_create?(repository, authorisations = nil)
-        can_do?('create', repository, authorisations)
+      def can_create?(repo_item, authorisations = nil)
+        can_do?('create', repo_item, authorisations)
       end
 
       # Return true if you can edit the repo, false else
-      def can_update?(repository, authorisations = nil)
-        can_do?('update', repository, authorisations)
+      def can_update?(repo_item, authorisations = nil)
+        can_do?('update', repo_item, authorisations)
       end
 
       # Return true if you can delete the repo, false else
-      def can_delete?(repository, authorisations = nil)
-        can_do?('delete', repository, authorisations)
+      def can_delete?(repo_item, authorisations = nil)
+        can_do?('delete', repo_item, authorisations)
       end
 
-      # Return true if you can add an item in this share, false else
-      def can_add_to?(share)
-        can_do_to?('add', share)
+      # Return true if you can add a member in this sharing, false else
+      def can_add_to?(sharing)
+        can_do_to?('add', sharing)
       end
 
-      # Return true if you can remove an item in this share, false else
-      def can_remove_from?(share)
-        can_do_to?('remove', share)
+      # Return true if you can remove a member in this sharing, false else
+      def can_remove_from?(sharing)
+        can_do_to?('remove', sharing)
       end
 
-      # You can here add new items in the share
-      # Param item could be an object or an array of object
-      def add_items_to(share, items, options = nil)
-        authorisations = get_share_authorisations(share)
-        if can_add_to?(share)
-          share_permissions = make_share_permissions(options, authorisations)
-          share.add_items(items, share_permissions)
+      # 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 = nil)
+        authorisations = get_sharing_authorisations(sharing)
+        if can_add_to?(sharing)
+          sharing_permissions = make_sharing_permissions(options, authorisations)
+          sharing.add_members(members, sharing_permissions)
         else
+          #raise "add members failed. You don't have the permission to add a member in this sharing"
           return false
         end
       end
 
-      # You can here add new items in the share
-      # Param item could be an object or an array of object
-      def remove_items_from(share, items)
-        if can_remove_from?(share)
-          share.remove_items(items)
+      # You can here add new members in the sharing
+      # Param member could be an object or an array of object
+      def remove_members_from(sharing, members)
+        if can_remove_from?(sharing)
+          sharing.remove_members(members)
         else
+          #raise "remove members failed. You don't have the permission to remove a member on this sharing"
           return false
         end
       end
 
       private
 
-      # Return if you can do or not this action in the share
-      def can_do_to?(what, share, authorisations = nil)
+      # Return if you can do or not this action in the sharing
+      def can_do_to?(what, sharing, authorisations = nil)
         if authorisations == nil
-          authorisations = share.get_authorisations(self)
+          authorisations = sharing.get_authorisations(self)
         end
         case what
           when 'add'
@@ -259,10 +267,10 @@ module RepositoryManager
       end
 
       # Return if you can do or not this action (what)
-      def can_do?(what, repository, authorisations = nil)
+      def can_do?(what, repo_item, authorisations = nil)
         #If we pass no authorisations we have to get it
         if authorisations === nil
-          authorisations = get_authorisations(repository)
+          authorisations = get_authorisations(repo_item)
         end
 
         case what
@@ -282,12 +290,12 @@ module RepositoryManager
 
       end
 
-      # Correct the repo_permissions with the authorisations
-      def make_repo_permissions(wanted_permissions, authorisations)
+      # Correct the repo_item_permissions with the authorisations
+      def make_repo_item_permissions(wanted_permissions, authorisations)
         # If it is an array, we have restriction in the permissions
         if authorisations.kind_of?(Hash) && wanted_permissions
-          # Built the share with the accepted permissions
-          # We remove the permission if we can't share it
+          # 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
             wanted_permissions[:can_read] = false
           end
@@ -300,15 +308,18 @@ module RepositoryManager
           if wanted_permissions[:can_delete] == true && authorisations[:can_delete] == false
             wanted_permissions[:can_delete] = false
           end
+          if wanted_permissions[:can_share] == true && authorisations[:can_share] == false
+            wanted_permissions[:can_share] = false
+          end
         end
         return wanted_permissions
       end
 
-      # Correct the share_permissions with the authorisations
-      def make_share_permissions(wanted_permissions, authorisations)
+      # Correct the sharing_permissions with the authorisations
+      def make_sharing_permissions(wanted_permissions, authorisations)
         # If it is an array, we have restriction in the permissions
         if authorisations.kind_of?(Hash) && wanted_permissions
-          # Built the share with the accepted 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
             wanted_permissions[:can_add] = false

data/lib/repository_manager/version.rb

@@ -1,3 +1,3 @@
 module RepositoryManager
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/repository-manager.gemspec

@@ -10,9 +10,9 @@ Gem::Specification.new do |s|
   s.authors     = ['Yves Baumann']
   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/shares)."
-  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 share these repositories easily with other object with a flexible and complete authorisations 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 share them with other instance."
+  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.
+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"]
   s.files         = `git ls-files`.split("\n")
@@ -27,6 +27,5 @@ Each instance (users, groups, etc..) can have it own repositories (with files an
   s.add_development_dependency 'rspec-rails', '~> 2.0'
   s.add_runtime_dependency 'ancestry'
   s.add_runtime_dependency 'carrierwave'
-  s.add_runtime_dependency 'enumerize'
-  s.add_runtime_dependency 'rubyzip'
+  s.add_runtime_dependency 'rubyzip'#, '< 1.0.0'#, :require => 'zip/zip'
 end

data/spec/dummy/config/locales/en.yml

@@ -1,11 +1,4 @@
-en:
-  enumerize:
-    repository:
-      type:
-        file: "File"
-        directory: "Directory"
-
-        # Files in the config/locales directory are used for internationalization
+# Files in the config/locales directory are used for internationalization
 # and are automatically loaded by Rails. If you want to use locales other
 # than English, add the necessary files in this directory.
 #

data/spec/dummy/db/migrate/20131016193722_create_users.rb

@@ -1,11 +1,11 @@
-class CreateUsers < ActiveRecord::Migration
-  def change
-    create_table :users do |t|
-      t.string :nickname
-      t.string :password
-      t.string :email
-
-      t.timestamps
-    end
-  end
-end
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.string :nickname
+      t.string :password
+      t.string :email
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/migrate/20131016193834_create_groups.rb

@@ -1,10 +1,10 @@
-class CreateGroups < ActiveRecord::Migration
-  def change
-    create_table :groups do |t|
-      t.string :name
-      t.text :description
-
-      t.timestamps
-    end
-  end
-end
+class CreateGroups < ActiveRecord::Migration
+  def change
+    create_table :groups do |t|
+      t.string :name
+      t.text :description
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/migrate/20131016194207_create_groups_users.rb

@@ -1,5 +1,5 @@
-class CreateGroupsUsers < ActiveRecord::Migration
-  def change
-    create_join_table :groups, :users
-  end
-end
+class CreateGroupsUsers < ActiveRecord::Migration
+  def change
+    create_join_table :groups, :users
+  end
+end