repository-manager 0.0.7 → 0.0.8

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    repository-manager (0.0.6)
+    repository-manager (0.0.7)
       ancestry
       carrierwave
-      enumerize
       rails (> 3.0.0)
       rubyzip
 
@@ -44,14 +43,12 @@ GEM
       activemodel (>= 3.2.0)
       activesupport (>= 3.2.0)
       json (>= 1.7)
-    diff-lcs (1.2.4)
-    enumerize (0.7.0)
-      activesupport (>= 3.2)
+    diff-lcs (1.2.5)
     erubis (2.7.0)
-    factory_girl (4.2.0)
+    factory_girl (4.3.0)
       activesupport (>= 3.0.0)
-    factory_girl_rails (4.2.1)
-      factory_girl (~> 4.2.0)
+    factory_girl_rails (4.3.0)
+      factory_girl (~> 4.3.0)
       railties (>= 3.0.0)
     hike (1.2.3)
     i18n (0.6.5)
@@ -80,10 +77,10 @@ GEM
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)
     rake (10.1.0)
-    rspec-core (2.14.5)
-    rspec-expectations (2.14.3)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.3)
+    rspec-mocks (2.14.4)
     rspec-rails (2.14.0)
       actionpack (>= 3.0)
       activesupport (>= 3.0)
@@ -91,7 +88,7 @@ GEM
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
-    rubyzip (0.9.9)
+    rubyzip (1.1.0)
     sprockets (2.10.0)
       hike (~> 1.2)
       multi_json (~> 1.0)

data/README.md

@@ -1,17 +1,18 @@
 WORK IN PROGRESS, but it already works !
 
-Ruby on Rails plugin (gem) for managing repositories (files/folders/permissions). 
+Ruby on Rails plugin (gem) for managing repositories (files/folders/permissions/sharing). 
 
 # RepositoryManager
 
-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 share these repositories easily with other object with a flexible and complete authorisations management. 
+This gem add fonctionalities 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.
 
-Instead of creating my core repository manager system heavily
+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.
+
+Instead of creating my core repository manager system heavily 
 dependent on our development, I'm trying to implement a generic and potent repository gem.
 
 After looking for a good gem to use I noticed the lack of repository gems
 and flexibility in them. RepositoryManager tries to be the more flexible possible.
-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.
 
 This gem is my informatics project for the Master in [University of Lausanne (CH)](http://www.unil.ch/index.html). 
 
@@ -42,6 +43,32 @@ And don't forget to migrate your database:
 $ rake db:migrate
 ```
 
+## Settings
+
+You can edit the RepositoryManager settings in the initializer (/config/initializer/repository_manager.rb).
+
+```ruby
+RepositoryManager.setup do |config|
+
+  # Default 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_sharing: false }
+
+  # Default permissions that an object has when he is added in a sharing.
+  config.default_sharing_permissions = { can_add: false, can_remove: false }
+end
+```
+
+For instance, if you want that a default sharing is totaly free, just put all default parameters to `true` :
+```ruby
+RepositoryManager.setup do |config|
+  config.default_repo_item_permissions = { can_read: true, can_create: true, can_update: true, can_delete: true, can_share: true }
+  config.default_sharing_permissions = { can_add: true, can_remove: true }
+end
+```
+
+
+See the chapter [Authorisations](#authorisations) for more details about the permissions.
+
 ## Preparing your models
 
 You can choose wich model can have repository. 
@@ -54,7 +81,7 @@ class User < ActiveRecord::Base
 end
 ```
 
-You are not limited to the User model. You can use RepositoryManager in any other model and use it in serveral different models. If you have Groups and Houses in your application and you want to exchange repositories as if they were the same, just add `has_repository` to each one and you will be able to share files/folders groups-groups, groups-users, users-groups and users-users. Of course, you can extend it for as many classes as you need.
+You are not limited to the User model. You can use RepositoryManager in any other model and use it in serveral different models. If you have Groups and Houses in your application and you want to exchange `repo_items` as if they were the same, just add `has_repository` to each one and you will be able to sharing `repo_files`/`repo_folders` groups-groups, groups-users, users-groups and users-users. Of course, you can extend it for as many classes as you need.
 
 Example:
 
@@ -72,9 +99,17 @@ end
 
 ## How to use RepositoryManager
 
-### How can I create/delete a repository (file or folder)
+### Introduction
+
+A `repo_item` is an item in a repository, it can be:
+- A file (`repo_file`, class name : `RepoFile`)
+- A folder (`repo_folder`, class name : `RepoFolder`).
+
+A folder can contains files and folders. Like in a real tree files and folders.
+
+### How can I create/delete a repo_item (file or folder)
 
-You just have to call the `has_repository` methods `create_file`, `create_folder`, or `delete_repository`.
+You just have to call the `has_repository` methods `create_file`, `create_folder`, or `delete_repo_item`.
 
 ```ruby
 # user1 wants to create a folder in his repository
@@ -83,195 +118,197 @@ You just have to call the `has_repository` methods `create_file`, `create_folder
 source_folder = user1.create_folder('Root folder')
 
 # user1 own repository :
-#   'Root folder'
+#   -- 'Root folder'
 
-# sourceFolder is the directory in wich user1 wants to create the folder 'The new folder'
-name = 'The new folder'
-the_folder = user1.create_folder(name, source_folder)
+# source_folder is the directory in wich user1 wants to create the folder 'The new folder'
+the_new_folder = user1.create_folder('The new folder', source_folder)
 
 # user1 own repository :
-#   'Root folder'
-#     'The new folder'
+#   |-- 'Root folder'
+#   |  |-- 'The new folder'
 
-# Now we want to add a file into the_folder 
-# Note : user1 needs the ':can_create => true' permission in the folder : the_folder.
-user1.create_file(params[:file], the_folder)
+# Now we want to add a file into the_new_folder 
+# Note : user1 needs the ':can_create => true' permission in the folder : the_new_folder (else the method returns `false`).
+user1.create_file(params[:file], the_new_folder)
 # OR
-user1.create_file(File.open('somewhere'), the_folder)
+user1.create_file(File.open('somewhere'), the_new_folder)
 
 # user1 own repository :
-#   'Root folder'
-#     'The new folder'
-#        'file'
+#   |-- 'Root folder'
+#   |  |-- 'The new folder'
+#   |  |   |-- 'file'
 
+# user1 want to create a file on the root of his repository
 file2 = user1.create_file(params[:file2])
 
 # user1 own repository :
-#   'Root folder'
-#     'The new folder'
-#        'file'
-#   'file2'
+#   |-- 'Root folder'
+#   |  |-- 'The new folder'
+#   |  |   |-- 'file'
+#   |-- 'file2'
 
-# Delete a repository
-# Note : user1 needs the ':can_delete => true' permission in the folder : the_folder
-user1.delete_repository(the_folder)
+# Delete a repo_item
+# Note : user1 needs the ':can_delete => true' permission in the folder : the_new_folder (else the method returns `false`).
+user1.delete_repo_item(the_new_folder)
 
 # user1 own repository :
-#   'Root folder'
-#   'file2'
+#   |-- 'Root folder'
+#   |-- 'file2'
 
-user1.delete_repository(file2)
+user1.delete_repo_item(file2)
 
 # user1 own repository :
-#   'Root folder'
+#   |-- 'Root folder'
 
 ```
 
-### How can I share a repository (file/folder)
+### How can I share a repo_item (file/folder)
 
-Now, user1 want to share his folder 'The new folder' with a Group object et another User object. You can use the `has_repository` method `share(repository, to, options = nil)`.
+Now, user1 want to share his folder 'The new folder' with a Group object `group1` et another User object `user2`. You can use the `has_repository` method `share(repo_item, member, options = nil)`.
 
 ```ruby
-# user1 wants to share the_folder with group1 and user2
-
-items = []
-# You can add other instance (who has_repository) in this array to share with more than one instance
-item << group1
-items << user2
-
-share = user1.share(the_folder, items)
-
+# user1 wants to share the_new_folder with group1 and user2
 
-# If you want to customize your share options, you can do it like this:
+members = []
+# You can add other instances (who `has_repository`) in this array to share with more than one instance
+member << group1
+members << user2
 
-# Default shares permisions are : {can_add: false, can_remove: false} 
-share_permissions = {can_add: true, can_remove: true}
-# Default reposiroty permissions are: {can_read: true, can_create: false, can_update: false, can_delete: false, can_share: false}
-repo_permissions = {can_read: true, can_create: true, can_update: true, can_delete: true, can_share: true}
+sharing = user1.share(the_new_folder, members)
 
-options = {share_permissions: share_permissions, repo_permissions: repo_permissions}
+# If you want to customize your sharing options, you can do it like this:
+options = {sharing_permissions: {can_add: true, can_remove: true}, repo_item_permissions: {can_read: true, can_create: true, can_update: true, can_delete: true, can_share: true}}
 
-share = user1.share(the_folder, items, options)
+sharing = user1.share(the_new_folder, members, options)
 ```
 
-`share_permissions` specifies if the item who receive the share can add or remove items in this share.
+`repo_item_permissions` specifies what kind of permissions you give on the repo_item in a specific sharing.
 
-`repo_permissions` specifies what kind of permission do you give at this share. If all the params are false, the share is useless, because the items have no more permissions in the repository selectionned. 
+`sharing_permissions` specifies if the member selectionned can add or remove other members in this sharing.
 
-See the chapter Authorisations for more details.
+See the chapter [Authorisations](#authorisations) for more details.
 
-### How can I see my repository
+### How can I see my repo_items
 
-There is two king of repository: 
-- Your own repositories
-- The repositories shared with you.
+You can have two kind of repo_items: 
+- Your own repo_items
+- The repo_items shared with you.
 
 ```ruby
 # user1 want to get his own repository
-user1.repositories.all # => You get the repository that user1 has created
+user1.repo_items.all # => You get the repo_items that user1 has created
 
-# user2 want to get his shared repository
-user2.shared_repositories.all
+# user2 want to get his shared repo_items
+user2.shared_repo_items.all
 ```
 
-A repository can be:
+Recall: a repo_item can be:
 - A file
 - A folder
 
 ```ruby
-# We want to know if the object repository is a file or a folder:
-if repository.type == 'Folder'
-  repository.name #=> Returns the name of the folder ('New folder').
-elsif repository.type == 'AppFile'
-  repository.name #=> Returns the name of the file ('file.png').
+# We want to know if the object repo_item is a file or a folder:
+if repo_item.type == 'RepoFolder'
+  repo_item.name #=> Returns the name of the folder ('New folder').
+elsif repo_item.type == 'RepoFile'
+  repo_item.name #=> Returns the name of the file ('file.png').
   # Here is the file
-  repository.file.url # => '/url/to/file.png'
-  repository.file.current_path # => 'path/to/file.png'
-  repository.file.identifier # => 'file.png'
+  repo_item.file.url # => '/url/to/file.png'
+  repo_item.file.current_path # => 'path/to/file.png'
 end
 ```
 
+For file informations, more infos on [the documentation of the carrierwave gem](https://github.com/carrierwaveuploader/carrierwave). 
 
-### How can I manage a share
 
+### How can I manage a sharing
 
-If it has the authorisation, an object can add items to a share.
+
+If it has the authorisation, an object can add members to a sharing.
 
 ```ruby
-# user1 want to add items to his share (the actions are done only if user1 has the ':can_add' permission)
-user1.can_add_to?(share) # => true
+# user1 want to add members to his sharing
+# NOTE: The action is done only if user1 has the ':can_add' permission.
+user1.can_add_to?(sharing) # => true
+
+# Add members
+members = []
+members << user3
+members << group2
+...
 
+user1.add_members_to(sharing, members)
+
+# You can change the default sharing permissions options :
 options = {can_add: true, can_remove: false}
-# Add items
-items = []
-items << user3
-items << group2
-...
-user1.add_items_to(share, items, options)
+user1.add_members_to(sharing, members, options)
 
-# Here user3 and group2 can add items in this share, but they can't remove an item.
-group2.can_add_to?(share) # => true
-group2.can_remove_from?(share) # => false
 
-# If user2 add an item in the share, 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).
+# Here user3 and group2 can add members in this sharing, but they can't remove a member.
+group2.can_add_to?(sharing) # => true
+group2.can_remove_from?(sharing) # => false
+
+# If user2 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 it has the authorisation, an object can remove items from a share.
+If an object has the authorisation, it can remove members from a sharing, else the method return `false`.
 
 ```ruby
-# user1 want to remove group2 from this share
-user1.remove_items_from(share, group2)
+# 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
 ```
 
-As admin, you can directly work with the share. Be carefull, there is NO authorisation verification !
+You can directly work with the `sharing`. Be carefull, there is NO authorisation control !
 
 ```ruby
-# Add an item to the share
-share.add_items(item, share_permissions)
+# Add a member to the sharing `sharing`
+sharing.add_members(member)
+# Or with options :
+sharing.add_members(member, {can_add: true, can_remove: false})
+
 
-# Delete items from the share
-share.remove_items(items)
+# Remove members from the sharing
+sharing.remove_members({user2, group1})
 ```
 
 ### Authorisations
 
 #### Repository authorisations
 
-The owner of a repository (file or folder) has all the authorisations on it. When he share this repository, he can choose what authorisation he gives to the share. The authorisations are :
-- can_read?(repository) : The item can read (=download) this file/folder.
-- can_create?(repository) : Can create in the repository (if repository is nil (= root), always true).
-- can_update?(repository) : Can update a repository.
-- can_delete?(repository) : Can delete a repository.
-- can_share?(repository) : Can share a repository.
+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 :
+- 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 (= root), always true).
+- can_update?(repo_item) : Can update a repo_item.
+- 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?(repository)`, `user1.can_share?(repository)`, etc (it returns `true` or `false`).
+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`).
 
-NOTICE : An object who can share a repository, can't set new permissions that it doesn't have. 
-For instance, `user3` has a share of `repository1` with `:can_delete => false` and `:can_share => true`. He can share `repository1` with `user4`, but he can't put `:can_delete => true` in this new share.
+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` with `:can_delete => false` and `:can_share => true`. He can share `repo_item1` with `user4`, but he can't put `:can_delete => true` in this new share.
 
-You can get all the authorisations with this method: `user1.get_authorisations(repository)`
+You can get all the authorisations with this method: `user1.get_authorisations(repo_item)`
 
 ```ruby
-# Returns false if the object has no authorisation in this repository
-# Returns true if the object has all the authorisations
-# Returns a Hash if the entity has custums authorisations 
-#   Exemple
-#     {can_read: true, can_create: true, can_update:true, can_delete:false, can_share: true}
-# Returns true if the repository is nil (because an object has all authorisations on his root folder)
-def get_authorisations(repository=nil)
-    [...]
-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
+      # 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)
+        [...]
+      end
 ```
 
-#### Share permissions
+#### Sharing permissions
 
-You can manage the permissions of an instance in a share. The owner of the share has all the permissions. The permissions are:
-- can_add_to?(share) : The item can add a new instance in this share.
-- can_remove_from?(share) : Can remove an instance from this share.
+You can manage the permissions of a member in a sharing. The owner of the sharing has all the permissions. The permissions are:
+- can_add_to?(sharing) : The member can add a new instance in this sharing.
+- can_remove_from?(sharing) : Can remove an instance from this sharing.
 
-To check if the object can add or remove an instance in the share, just write : `group1.can_add_to?(share)` or `group1.can_remove_from?(share)` (it returns `true` or `false`).
+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 repository authorisations, you can get the share authorisations with : `group1.get_share_authorisations(share)`.
+Like the repo_item authorisations, you can get the sharing authorisations with : `group1.get_sharing_authorisations(sharing)`.
 
 ## TODO
 

data/app/models/{app_file.rb → repo_file.rb}

@@ -1,13 +1,13 @@
-class AppFile < Repository
+class RepoFile < RepoItem
   attr_accessible :file, :content_type, :file_size if RepositoryManager.protected_attributes?
 
   validates :file, presence: true
-  mount_uploader :file, RepositoryUploader
+  mount_uploader :file, RepoFileUploader
   before_save :update_asset_attributes
 
   # Return the name of the file with his extension
   def name
-    file.identifier
+    file.url.split('/').last
   end
 
   # Downloading this file

data/app/models/repo_folder.rb

@@ -0,0 +1,60 @@
+require 'zip'
+
+class RepoFolder < RepoItem
+  attr_accessible :name if RepositoryManager.protected_attributes?
+
+  validates :name, presence: true
+
+  # Add a repo_item in the folder.
+  def add(repo_item)
+    # We check if this name already exist
+    if RepoItem.where(name: repo_item.name).where(id: child_ids).first
+      #raise "add failed. The repo_item '#{repo_item.name}' already exist in the folder '#{name}'"
+      false
+    else
+      repo_item.update_attribute :parent, self
+    end
+  end
+
+  # Download this folder (zip it first)
+  # If object = nil, it download all the folder
+  # if object is set, it download only the folder that the object can_read.
+  def download(object = nil)
+    # Get all the children
+    children = RepoItem.find(child_ids)
+
+    # If something is in the array to add, we zip it
+    if children.length > 0
+      # We create the zip here
+      Zip::File.open("#{name}.zip", Zip::File::CREATE) { |zf|
+        add_repo_item_to_zip(children, zf, object)
+      }
+    else
+      # Nothing to download here
+      #raise "download failed. Folder #{name} is empty"
+      false
+    end
+
+  end
+
+  private
+
+  def add_repo_item_to_zip(children, zf, object = nil, prefix = nil)
+    children.each do |child|
+      # If this is a file, we just add this file to the zip
+      if child.type == 'RepoFile'
+        # Add the file in the zip if the object is authorised to read it.
+        zf.add("#{prefix}#{child.name}", child.file.current_path) if object == nil || object.can_read?(child)
+      elsif child.type == 'RepoFolder'
+        # If this folder has children, we do it again with it children
+        if child.has_children?
+          # We go in this new directory and add it repo_items
+          add_repo_item_to_zip(RepoItem.find(child.child_ids), zf, object, "#{prefix}#{child.name}/")
+        else
+          # We just create the folder if it is empty
+          zf.mkdir(child.name) if object == nil || object.can_read?(child)
+        end
+      end
+    end
+  end
+end

data/app/models/{repository.rb → repo_item.rb}

@@ -1,4 +1,4 @@
-class Repository < ActiveRecord::Base
+class RepoItem < ActiveRecord::Base
   attr_accessible :type if RepositoryManager.protected_attributes?
 
 
@@ -6,16 +6,16 @@ class Repository < ActiveRecord::Base
 
   # Associate with the User Classe
   belongs_to :owner, :polymorphic => true
-  has_many :shares, :dependent => :destroy
-  #has_many :items, through: :shares
+  has_many :sharings, :dependent => :destroy
+  #has_many :members, through: :sharings
 
   if Rails::VERSION::MAJOR == 4
-    scope :files, -> { where type: 'AppFile' }
-    scope :folders, -> { where type: 'Folder' }
+    scope :files, -> { where type: 'RepoFile' }
+    scope :folders, -> { where type: 'RepoFolder' }
   else
     # Rails 3 does it this way
-    scope :files, where(type: 'AppFile')
-    scope :folders, where(type: 'Folder')
+    scope :files, where(type: 'RepoFile')
+    scope :folders, where(type: 'RepoFolder')
   end
 
   def copy(target_folder)
@@ -30,10 +30,10 @@ class Repository < ActiveRecord::Base
     #new_file
   end
 
-  # Move the repository into the target_folder
-  # TODO à tester
+  # Move the repo_item into the target_folder
+  # TODO à faire
   def move(target_folder)
-    if target_folder.type == 'Folder'
+    if target_folder.type == 'RepoFolder'
       self.update_attribute :parent, target_folder
     end
   end

data/app/models/sharing.rb

@@ -0,0 +1,58 @@
+class Sharing < ActiveRecord::Base
+  attr_accessible :can_read, :can_create, :can_update, :can_delete, :can_share if RepositoryManager.protected_attributes?
+
+
+  has_many :sharings_members, :dependent => :destroy
+  belongs_to :owner, :polymorphic => true
+  belongs_to :repo_item
+
+  #scope :recipient, lambda { |recipient|
+  #  joins(:receipts).where('receipts.receiver_id' => recipient.id,'receipts.receiver_type' => recipient.class.base_class.to_s)
+  #}
+  scope :members, lambda { |member|
+    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)
+    # If the member is the owner, he can do what he want !
+    if self.owner == member
+      return true
+    elsif i = self.sharings_members.where(member_id: member.id, member_type: member.class.base_class.to_s).first
+      return {can_add: i.can_add, can_remove: i.can_remove}
+    else
+      return false
+    end
+  end
+
+  # Add members to the sharing
+  def add_members(members, sharing_permissions = nil)
+    if members.kind_of?(Array)
+      # Add each member to this sharing
+      members.each do |i|
+        sharing_member = SharingsMember.new(sharing_permissions)
+        sharing_member.member = i
+        # Add the sharings members in the sharing
+        self.sharings_members << sharing_member
+      end
+    else
+      sharing_member = SharingsMember.new(sharing_permissions)
+      sharing_member.member = members
+      # Add the sharings members in the sharing
+      self.sharings_members << sharing_member
+    end
+  end
+
+  # Remove members to the sharing
+  def remove_members(members)
+    if members.kind_of?(Array)
+      # Add each member to this sharing
+      members.each do |member|
+        self.sharings_members.where(:member_id => member.id, :member_type => member.class.base_class.to_s).first.destroy
+      end
+    else
+      self.sharings_members.where(:member_id => members.id, :member_type => members.class.base_class.to_s).first.destroy
+    end
+  end
+
+end

data/app/models/sharings_member.rb

@@ -0,0 +1,6 @@
+class SharingsMember < ActiveRecord::Base
+  attr_accessible :can_add, :can_remove if RepositoryManager.protected_attributes?
+
+  belongs_to :member, polymorphic: true
+  belongs_to :sharing
+end

data/app/uploaders/{repository_uploader.rb → repo_file_uploader.rb}

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'carrierwave/processing/mime_types'
 
-class RepositoryUploader < CarrierWave::Uploader::Base
+class RepoFileUploader < CarrierWave::Uploader::Base
   include CarrierWave::MimeTypes
 
   process :set_content_type