repository-manager 0.1.16 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b215f3835b3f6d5607af3584d728891288809873
-  data.tar.gz: 2db5f3fa34414eca002e0b6479a786ba24321193
+  metadata.gz: 5570145fdab6a68044c23360f2cda512bbff93da
+  data.tar.gz: 63ac568cef21b1e6e1c69f34ec14701a811e393b
 SHA512:
-  metadata.gz: af70a3c06755dbc515c7f84358b5628f60e7795815cfb00303e2f6ba234d6b73aa992a960de19a36606fcaa1c1524d37483ba94048a8a9479f25416df252668e
-  data.tar.gz: 45a648974b60a5cdfb28c36ce9bcbc3b07699d9b75c1accdfbe6e8237cac76cc2392d1575aec0b166e91ad491b915b4873780c037a964ff4b145d7f62cbea39c
+  metadata.gz: 3aa7875fc7c3cbcb7653af770e548eade784c6d10dc35bb6e86a8baffcd5c3764acf9133d3cf86386cb1fc98ae33a5ec7c757c4f88ea7723bbb52930bf05a208
+  data.tar.gz: 82b701bd769e352108cbcf7c25773d1e48ad0b7b068056c6f75f2956429f74cc238124b5182393f8af7228c626aba9f8c65e019f75fa278d81534ca8a8dd54d8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    repository-manager (0.1.15)
+    repository-manager (0.1.17)
       ancestry
       carrierwave (>= 0.5.8)
       rails (> 3.0.0)
@@ -36,7 +36,7 @@ GEM
       tzinfo (~> 0.3.37)
     ancestry (2.0.0)
       activerecord (>= 3.0.0)
-    arel (4.0.1)
+    arel (4.0.2)
     atomic (1.1.14)
     builder (3.1.4)
     carrierwave (0.9.0)

data/README.md

@@ -273,9 +273,9 @@ children = @user1.create_folder('Children', nested)
 
 @user1.share(nested, @user2)
 
-nested.has_nested_sharing? # Returns false (because `nested` is shared but there is no nested sharing)
-parent.has_nested_sharing? # Returns true (because there is a sharing on one of his descendants)
-children.has_nested_sharing? # Returns true (because there is a sharing on one of his ancestors)
+nested.can_be_shared_without_nesting? # Returns true (because `nested` is shared but there exist no nested sharing)
+parent.can_be_shared_without_nesting? # Returns false (because there is a sharing on one of his descendants)
+children.can_be_shared_without_nesting? # Returns false (because there is a sharing on one of his ancestors)
 
 # Here we can't share 'Parent' or 'Children' because it already exist a nested sharing.
 @user1.share(parent, @user2) # Returns false
@@ -382,7 +382,7 @@ sharing.add_members(member, {can_add: true, can_remove: false})
 
 
 # Remove members from the sharing
-sharing.remove_members({user2, group1})
+sharing.remove_members([user2, group1])
 ```
 
 ### Authorisations
@@ -414,7 +414,7 @@ You can get all the authorisations of an `object` in a `repo_item` with this met
       end
 ```
 
-#### Sharing permissions
+#### Sharing authorisations
 
 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.
@@ -456,7 +456,9 @@ the_folder.delete_zip
 ## TODO
 
 - Do the rename file method
-- Write the methods : copy, share_link.
+- Test the copy method
+- Configure path to save files
+- Write the methods : share_link.
 - Snapshot the file if possible
 - Versioning
 - ...

data/app/models/repository_manager/repo_file.rb

@@ -19,6 +19,42 @@ class RepositoryManager::RepoFile < RepositoryManager::RepoItem
     path = file.path
   end
 
+  # Copy itself into the source_folder
+  # options
+  #   :source_folder = the folder in witch you copy this item
+  #   :owner = the owner of the item
+  #   :sender = the sender of the item (if you don't specify sender.. The sender is still the same)
+  def copy!(options = {})
+    new_item = RepositoryManager::RepoFile.new
+    new_item.file = File.open(self.file.current_path)
+
+    if options[:source_folder]
+      options[:source_folder].add!(new_item)
+    elsif options[:owner].repo_item_name_exist_in_root?(new_item.name)
+      raise RepositoryManager::RepositoryManagerException.new("copy failed. The repo_file '#{new_item.name}' already exist in root.")
+    end
+
+    options[:owner] ? new_item.owner = options[:owner] : new_item.owner = self.owner
+    if options[:sender]
+      new_item.sender = options[:sender]
+      #elsif options[:owner]
+      #  new_item.sender = options[:owner]
+    else
+      new_item.sender = self.sender
+    end
+
+    new_item.save!
+    new_item
+  end
+
+  def copy(options = {})
+    begin
+      copy!(options)
+    rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+      false
+    end
+  end
+
   private
 
   def update_asset_attributes

data/app/models/repository_manager/repo_folder.rb

@@ -47,6 +47,48 @@ class RepositoryManager::RepoFolder < RepositoryManager::RepoItem
     end
   end
 
+  # Copy itself into the source_folder
+  # options
+  #   :source_folder = the folder in witch you copy this item
+  #   :owner = the owner of the item
+  #   :sender = the sender of the item (if you don't specify sender.. The sender is still the same)
+  def copy!(options = {})
+    new_item = RepositoryManager::RepoFolder.new
+    new_item.name = self.name
+
+    if options[:source_folder]
+      options[:source_folder].add!(new_item)
+    elsif options[:owner].repo_item_name_exist_in_root?(new_item.name)
+      raise RepositoryManager::RepositoryManagerException.new("copy failed. The repo_folder '#{new_item.name}' already exist in root.")
+    end
+
+    options[:owner] ? new_item.owner = options[:owner] : new_item.owner = self.owner
+    if options[:sender]
+      new_item.sender = options[:sender]
+      #elsif options[:owner]
+      #  new_item.sender = options[:owner]
+    else
+      new_item.sender = self.sender
+    end
+
+    new_item.save!
+
+    # Recursive method who copy all children.
+    children.each do |c|
+      c.copy!(source_folder: new_item, owner: options[:owner], sender: options[:sender])
+    end
+
+    new_item
+  end
+
+  def copy(options = {})
+    begin
+      copy!(options)
+    rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
+      false
+    end
+  end
+
     # Download this folder (zip it first)
   # Return the path to the folder.zip
   # options can have :

data/app/models/repository_manager/repo_item.rb

@@ -27,47 +27,11 @@ class RepositoryManager::RepoItem < ActiveRecord::Base
     scope :folders, where(type: 'RepositoryManager::RepoFolder')
   end
 
-  # Copy itself into the source_folder
+  # Move itself into the target or root
   # options
   #   :source_folder = the folder in witch you copy this item
   #   :owner = the owner of the item
-  #   :sender = the sender of the item (if you specify owner and not sender.. The sender becomes the owner)
-  def copy!(options = {})
-    new_item = RepoItem.new
-    new_item.type = self.type
-    new_item.file = self.file
-    new_item.content_type = self.content_type
-    new_item.file_size = self.file_size
-    new_item.name = self.name
-    options[:owner] ? new_item.owner = options[:owner] : new_item.owner = self.owner
-    if options[:sender]
-      new_item.sender = options[:sender]
-    elsif options[:owner]
-      new_item.sender = options[:owner]
-    else
-      new_item.sender = self.sender
-    end
-
-    if options[:source_folder]
-      options[:source_folder].add!(new_item)
-    end
-
-    new_item.save!
-    new_item
-  end
-
-  def copy(options = {})
-    begin
-      copy!(options)
-    rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
-      false
-    end
-  end
-
-  # Move itself into the source_folder or root
-  # options
-  #   :source_folder => move into this source_folder
-  #   :owner = the owner of the item
+  # If :source_folder = nil, move to the root (of same owner)
   def move!(options = {})
     # If we are in source_folder, we check if it's ok
     if options[:source_folder]
@@ -77,18 +41,19 @@ class RepositoryManager::RepoItem < ActiveRecord::Base
       if options[:source_folder].name_exist_in_children?(self.name)
         raise RepositoryManager::RepositoryManagerException.new("move failed. The repo_item '#{name}' already exist ine the folder '#{options[:source_folder].name}'")
       end
-    else
-      # We are in root, we check if name exist in root
-      if options[:owner]
-        if options[:owner].repo_item_name_exist_in_root?(self.name)
-          raise RepositoryManager::RepositoryManagerException.new("move failed. The repo_item '#{name}' already exist ine the root")
-        elsif self.owner.repo_item_name_exist_in_root?(self.name)
-          raise RepositoryManager::RepositoryManagerException.new("move failed. The repo_item '#{name}' already exist ine the root")
-        end
-      end
+    # We are in root, we check if name exist in root
+    # We stay in the same owner
+    elsif self.owner.repo_item_name_exist_in_root?(self.name)
+      raise RepositoryManager::RepositoryManagerException.new("move failed. The repo_item '#{name}' already exist ine the root")
     end
     # here, all is ok
-    self.owner = options[:owner] if options[:owner]
+    # We change the owner if another one is specify
+    if options[:owner]
+      self.owner = options[:owner]
+    elsif options[:source_folder]
+      self.owner = options[:source_folder].owner
+    end
+    # we update the tree with the new parent
     self.update_attribute :parent, options[:source_folder]
     self.save!
     self
@@ -103,7 +68,7 @@ class RepositoryManager::RepoItem < ActiveRecord::Base
   end
 
   # Returns true if it exist a sharing in the ancestors of descendant_ids of the repo_item (without itself)
-  def has_nested_sharing?
+  def can_be_shared_without_nesting?
     # An array with the ids of all ancestors and descendants
     ancestor_and_descendant_ids = []
     ancestor_and_descendant_ids << self.descendant_ids if self.is_folder? && !self.descendant_ids.empty?
@@ -111,9 +76,9 @@ class RepositoryManager::RepoItem < ActiveRecord::Base
 
     # If it exist a sharing, it returns true
     if RepositoryManager::Sharing.where(repo_item_id: ancestor_and_descendant_ids).count > 0
-      true
-    else
       false
+    else
+      true
     end
   end
 

data/app/models/repository_manager/sharing.rb

@@ -15,9 +15,9 @@ class RepositoryManager::Sharing < ActiveRecord::Base
   #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)
-  }
+  #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)
@@ -36,12 +36,18 @@ class RepositoryManager::Sharing < ActiveRecord::Base
     if members.kind_of?(Array)
       # Add each member to this sharing
       members.each do |i|
+        unless i.respond_to? :share # Check if this object "has_repository"
+          raise RepositoryManager::RepositoryManagerException.new("add members failed. The object passed into members should be a model who 'has_repository'")
+        end
         sharing_member = RepositoryManager::SharingsMember.new(sharing_permissions)
         sharing_member.member = i
         # Add the sharings members in the sharing
         self.sharings_members << sharing_member
       end
     else
+      unless members.respond_to? :share # Check if this object "has_repository"
+        raise RepositoryManager::RepositoryManagerException.new("add members failed. The object passed into members should be a model who 'has_repository'")
+      end
       sharing_member = RepositoryManager::SharingsMember.new(sharing_permissions)
       sharing_member.member = members
       # Add the sharings members in the sharing

data/lib/repository_manager/has_repository.rb

@@ -48,7 +48,7 @@ module RepositoryManager
         # Nested sharing are not accepted
         if !RepositoryManager.accept_nested_sharing
           # Check if no other sharing exist in the path
-          if repo_item.has_nested_sharing?
+          unless repo_item.can_be_shared_without_nesting?
             raise RepositoryManager::NestedSharingException.new("sharing failed. Another sharing already exist on the subtree or an ancestor of '#{repo_item.name}'")
           end
         end
@@ -286,78 +286,71 @@ module RepositoryManager
       end
 
       # Move the repo_item. If you let all options empty, the item is moving into the self.root
-      # options
-      #   :source_folder => move into this source_folder
-      #   :owner => the new owner if we move it to root (source_folder => nil)
-      def move_repo_item!(repo_item, options = {})
+      # target =>  move into this source_folder
+      # 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}'")
+        end
         # If we want to change the owner we have to have the can_delete authorisation
-        if options[:source_folder]
+        if target
           # If want to change the owner, we have to check if we have the authorisation
-          if options[:source_folder].owner != repo_item.owner && !can_delete?(repo_item)
+          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}'")
           end
           # If we don't want to change the owner, we look if we can_update
-          if options[:source_folder].owner == repo_item.owner && !can_update?(repo_item)
+          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}'")
           end
           # We check if we can_create in the source_folder
-          unless can_create?(options[: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}'")
           end
-        elsif options[:owner]
-          # elsif there is no source_folder, but a specify owner, we check if we can delete, if owner change
-          if options[: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}'")
-          end
-          # If we don't want to change the owner, we look if we can_update
-          if options[: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}'")
-          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}'")
           end
         end
-        # We put the owner
-        if options[:source_folder]
-          owner = options[:source_folder].owner
-        elsif options[:owner]
-          owner = options[:owner].owner
-        else
-          owner = self
-        end
         # If it has the permission, we move the repo_item in the source_folder
-        repo_item.move!(source_folder: options[:source_folder], owner: owner)
+        repo_item.move!(source_folder: target)
       end
 
-      def move_repo_item(repo_item, options = {})
+      def move_repo_item(repo_item, target = nil)
         begin
-          move_repo_item!(repo_item, options)
+          move_repo_item!(repo_item, target)
         rescue RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
       end
 
-      # Copy the repo_item in the source_folder or in the root
+      # Copy the repo_item in the source_folder or in own root
+      # target => the folder in witch we want to copy the repo item
       # options
-      #   :source_folder => the folder in witch we want to copy the repo item
-      #   :sender => the new sender (by default => owner)
-      def copy_repo_item!(repo_item, options = {})
+      #   :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}'")
         end
 
-        if options[:source_folder] &&  !can_create?(options[:source_folder])
-          raise RepositoryManager::AuthorisationException.new("copy repo_item failed. You don't have the permission to create in the source_folder '#{source_folder.name}'")
+        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}'")
         end
+
+        # The new owner
+        if target
+          owner = target.owner
+        else
+          owner = self
+        end
+
         # If it has the permission, we move the repo_item in the source_folder
-        repo_item.copy!(source_folder: options[:source_folder], owner: self, sender: options[:sender])
+        repo_item.copy!(source_folder: target, owner: owner, sender: options[:sender])
       end
 
-      def copy_repo_item(repo_item, options = {})
+      def copy_repo_item(repo_item, target = nil, options = {})
         begin
-          copy_repo_item!(repo_item, options)
+          copy_repo_item!(repo_item, target, options)
         rescue RepositoryManager::AuthorisationException, RepositoryManager::RepositoryManagerException, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
           false
         end
@@ -451,7 +444,7 @@ module RepositoryManager
         end
       end
 
-        # You can here remove members in the sharing
+      # You can here remove 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)
@@ -476,13 +469,7 @@ module RepositoryManager
 
       # Returns true of false if the name exist in the root path of this instance
       def repo_item_name_exist_in_root?(name)
-        # add : or file : name
-        #RepoItem.where(name: name).where(owner: self).where(ancestry: nil).first ? true : false
-        #puts RepoItem.where('name = ? OR file = ?', name, name).where(owner: self).where(ancestry: nil).first.inspect
-        #puts self.inspect
-
         RepoItem.where('name = ? OR file = ?', name, name).where(owner: self).where(ancestry: nil).first ? true : false
-
       end
 
       private
@@ -500,6 +487,12 @@ module RepositoryManager
         end
       end
 
+      # reflexion: can_do?(what, options)
+      # options
+      #   hash : authorisations hash
+      #   class: RepoItem => get_authorisations
+      #   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
@@ -612,4 +605,4 @@ module RepositoryManager
   end
 end
 
-ActiveRecord::Base.send :include, RepositoryManager::HasRepository
+ActiveRecord::Base.send :include, RepositoryManager::HasRepository

data/lib/repository_manager/version.rb

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

data/spec/has_repository_spec.rb

@@ -18,7 +18,6 @@ describe 'HasRepository' do
     expect(@user2.sharings.last).to eq(sharing)
   end
 
-
   it 'can share his own repo_item with other users' do
     rep = FactoryGirl.build(:rm_repo_file)
     rep.owner = @user1
@@ -224,9 +223,9 @@ describe 'HasRepository' do
 
     @user1.share(nested, @user2)
 
-    expect(nested.has_nested_sharing?).to eq(false) # Returns false (because `nested` is shared but there is no nested sharing)
-    expect(parent.has_nested_sharing?).to eq(true) # Returns true (because there is a sharing on one of his descendants)
-    expect(parent.has_nested_sharing?).to eq(true) # Returns true (because there is a sharing on one of his ancestors)
+    expect(nested.can_be_shared_without_nesting?).to eq(true) # Returns true (because `nested` is shared but there is no nested sharing)
+    expect(parent.can_be_shared_without_nesting?).to eq(false) # Returns false (because there is a sharing on one of his descendants)
+    expect(parent.can_be_shared_without_nesting?).to eq(false) # Returns false (because there is a sharing on one of his ancestors)
 
     # Here we can't share 'Parent' or 'Children' because it already exist a nested sharing.
     expect(@user1.share(parent, @user2)).to eq(false) # Returns false

data/spec/models/repository_spec.rb

@@ -143,6 +143,24 @@ describe 'RepoItem' do
     @user2.delete_download_path()
   end
 
+  it 'can copy a hard folder (nested folders and files)' do
+    nested = @user2.create_folder!('a')
+    a = @user2.create_folder!('a', source_folder: nested)
+    b = @user2.create_folder!('b', source_folder: a)
+    c = @user2.create_folder!('c', source_folder: b)
+    d = @user2.create_folder!('a', source_folder: c)
+    e = @user2.create_folder!('a', source_folder: d)
+
+    file = FactoryGirl.build(:rm_repo_file)
+    #@user2.create_file!(file, source_folder: a)
+    #@user2.create_file!(file, source_folder: nested)
+    @user2.create_file!(file, source_folder: c)
+    @user2.share!(nested, @user1, repo_item_permissions: {can_read: true})
+    copy = @user1.copy_repo_item!(nested)
+    @user1.download(copy)
+    @user1.delete_download_path()
+  end
+
   it 'can\'t add a repo_item with the same name in a folder' do
     root_folder = @user1.create_folder('Root folder')
     root_folder.add(@user1_folder)
@@ -151,7 +169,7 @@ describe 'RepoItem' do
     test_folder = @user1.create_folder('Test folder', source_folder: root_test_folder)
     @user1.create_folder('Nested test folder', source_folder: test_folder)
 
-    @user1.move_repo_item(test_folder, source_folder: @user1_folder)
+    @user1.move_repo_item(test_folder, @user1_folder)
 
     expect(test_folder.parent_id).to eq(@user1_folder.id)
   end
@@ -244,15 +262,15 @@ describe 'RepoItem' do
     file = @user2.create_file(File.open("#{Rails.root}/../fixture/textfile.txt"))
     folder = @user2.create_folder('folder')
 
-    @user2.move_repo_item!(file, source_folder: folder)
+    @user2.move_repo_item!(file, folder)
 
     expect(folder.children).to eq([file])
   end
 
-  it "can move a folder to folder" do
+  it "can move a folder into a folder" do
     folder = @user2.create_folder('folder')
     folder2 = @user2.create_folder('folder2')
-    @user2.move_repo_item!(folder, source_folder: folder2)
+    @user2.move_repo_item!(folder, folder2)
 
     expect(folder2.children).to eq([folder])
   end
@@ -261,7 +279,35 @@ describe 'RepoItem' do
     file = @user2.create_file(File.open("#{Rails.root}/../fixture/textfile.txt"))
     folder = @user2.create_folder('folder')
 
-    expect(@user2.move_repo_item!(folder, source_folder: file)).to eq(false)
+    expect(@user2.move_repo_item(folder, file)).to eq(false)
+  end
+
+  it "move_repo_item default to the root of the self owner" do
+    file = @user1.create_file(File.open("#{Rails.root}/../fixture/textfile.txt"), source_folder: @user1_folder)
+
+    @user1.delete_repo_item!(@user1_file)
+    #expect(@user1.root_repo_items.count).to eq(1)
+    @user1.move_repo_item!(file)
+    expect(@user1.root_repo_items.count).to eq(2)
+  end
+
+  it "move_repo_item can't move a file into a root if file already exist" do
+    file = @user1.create_file(File.open("#{Rails.root}/../fixture/textfile.txt"), source_folder: @user1_folder)
+    expect(@user1.move_repo_item(file)).to eq(false)
   end
 
+  it "move_repo_item can't move if no permission" do
+    file = @user1.create_file(File.open("#{Rails.root}/../fixture/textfile.txt"), source_folder: @user1_folder)
+    expect(@user2.move_repo_item(file)).to eq(false)
+  end 
+
+  it "can't copy a file withour permission" do
+    expect(@user2.copy_repo_item(@user1_file)).to eq(false)         
+  end
+  
+  it "can copy a file with read permission" do
+    @user1.share(@user1_file, @user2, repo_item_permissions: {can_read:true})
+    @user2.copy_repo_item(@user1_file)
+    expect(@user2.root_repo_items.count).to eq(1)
+  end
 end

data/spec/models/share_spec.rb

@@ -35,6 +35,7 @@ describe 'Sharing' do
     expect(@user2.shared_repo_items.count).to eq(0)
   end
 
+
   it 'can remove a member in a sharing with permission' do
     sharing = @user1.share(@user1_file, @user2, {sharing_permissions:{can_add: false, can_remove: true}})
     @user1.add_members_to(sharing, @user3)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: repository-manager
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.18
 platform: ruby
 authors:
 - Yves Baumann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-12 00:00:00.000000000 Z
+date: 2014-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails