gitdocs 0.5.0.pre6 → 0.5.0.pre7

data/test/unit/repository_path_test.rb

@@ -0,0 +1,368 @@
+# -*- encoding : utf-8 -*-
+require File.expand_path('../test_helper', __FILE__)
+
+describe Gitdocs::Repository::Path do
+  let(:path) { Gitdocs::Repository::Path.new(repository, relative_path) }
+  let(:repository) { stub(root: local_repo_path) }
+  let(:local_repo_path) { 'tmp/unit/local' }
+
+  let(:relative_path) { 'directory/file' }
+
+  before do
+    FileUtils.rm_rf('tmp/unit')
+  end
+
+  describe '#write' do
+    subject { path.write('foobar', :message) }
+    before { repository.expects(:write_commit_message).with(:message) }
+
+    describe 'directory missing' do
+      before { subject }
+      it { local_file_content.must_equal "foobar\n" }
+    end
+
+    describe 'directory exists' do
+      before do
+        mkdir('directory')
+        subject
+      end
+      it { local_file_content.must_equal "foobar\n" }
+    end
+
+    describe 'file exists' do
+      before do
+        write('directory/file', 'deadbeef')
+        subject
+      end
+      it { local_file_content.must_equal "foobar\n" }
+    end
+  end
+
+  describe '#touch' do
+    subject { path.touch }
+
+    describe 'when directory does not exist' do
+      before { subject }
+      it { local_file_content.must_equal '' }
+    end
+
+    describe 'when directory already exists' do
+      before do
+        mkdir('directory')
+        subject
+      end
+      it { local_file_content.must_equal '' }
+    end
+
+    describe 'when file already exists' do
+      before do
+        write('directory/file', 'test')
+        subject
+      end
+      it { local_file_content.must_equal 'test' }
+    end
+  end
+
+  describe '#mkdir' do
+    subject { path.mkdir }
+
+    describe 'directory does not exist' do
+      before { subject }
+      it { File.directory?(File.join(local_repo_path, 'directory', 'file')) }
+    end
+
+    describe 'directory does exist' do
+      before do
+        mkdir('directory/file')
+        subject
+      end
+      it { File.directory?(File.join(local_repo_path, 'directory', 'file')) }
+    end
+
+    describe 'already exists as a file' do
+      before { write('directory/file', 'foobar') }
+      it { assert_raises(Errno::EEXIST) { subject } }
+    end
+  end
+
+  describe '#remove' do
+    subject { path.remove }
+
+    describe 'missing' do
+      it { subject.must_be_nil }
+    end
+
+    describe 'directory' do
+      before { mkdir('directory/file') }
+      it { subject.must_be_nil }
+    end
+
+    describe 'file' do
+      before do
+        write('directory/file', 'foobar')
+        subject
+      end
+      it { local_file_exist?.must_equal false }
+    end
+  end
+
+  describe '#text?' do
+    subject { path.text? }
+
+    describe 'missing' do
+      it { subject.must_equal false }
+    end
+
+    describe 'directory' do
+      before { mkdir('directory/file') }
+      it { subject.must_equal false }
+    end
+
+    describe 'not a text file' do
+      let(:relative_path) { 'directory/file.png' }
+      it { subject.must_equal false }
+    end
+
+    describe 'empty file' do
+      before { write('directory/file', '') }
+      it { subject.must_equal true }
+    end
+
+    describe 'text file' do
+      before { write('directory/file', 'foobar') }
+      it { subject.must_equal true }
+    end
+  end
+
+  describe '#meta' do
+    subject { path.meta }
+    before do
+      repository.stubs(:last_commit_for).with(relative_path).returns(commit)
+    end
+
+    describe 'when missing' do
+      let(:commit)        { nil }
+      it { assert_raises(RuntimeError) { subject } }
+    end
+
+    describe 'on a 'do
+      let(:commit) { stub(author: { name: :name, time: :time }) }
+      before do
+        write('directory0/file0', '')
+        write('directory/file1', 'foo')
+        write('directory/file2', 'bar')
+      end
+
+      describe 'file size 0' do
+        let(:relative_path) { 'directory0/file0' }
+        it { subject[:author].must_equal :name }
+        it { subject[:size].must_equal(-1) }
+        it { subject[:modified].must_equal :time }
+      end
+
+      describe 'file non-zero size' do
+        let(:relative_path) { 'directory/file1' }
+        it { subject[:author].must_equal :name }
+        it { subject[:size].must_equal(3) }
+        it { subject[:modified].must_equal :time }
+      end
+
+      describe 'directory size 0' do
+        let(:relative_path) { 'directory0' }
+        it { subject[:author].must_equal :name }
+        it { subject[:size].must_equal(-1) }
+        it { subject[:modified].must_equal :time }
+      end
+
+      describe 'directory non-zero size' do
+        let(:relative_path) { 'directory' }
+        it { subject[:author].must_equal :name }
+        it { subject[:size].must_equal(6) }
+        it { subject[:modified].must_equal :time }
+      end
+    end
+  end
+
+  describe '#exist?' do
+    subject { path.exist? }
+
+    describe 'missing' do
+      it { subject.must_equal false }
+    end
+
+    describe 'directory' do
+      before { mkdir('directory/file') }
+      it { subject.must_equal true }
+    end
+
+    describe 'file' do
+      before { write('directory/file', 'foobar') }
+      it { subject.must_equal true }
+    end
+  end
+
+  describe '#directory?' do
+    subject { path.directory? }
+
+    describe 'missing' do
+      it { subject.must_equal false }
+    end
+
+    describe 'directory' do
+      before { mkdir('directory/file') }
+      it { subject.must_equal true }
+    end
+
+    describe 'file' do
+      before { write('directory/file', 'foobar') }
+      it { subject.must_equal false }
+    end
+  end
+
+  describe '#absolute_path' do
+    subject { path.absolute_path(ref) }
+
+    describe 'no revision' do
+      let(:ref) { nil }
+      it { subject.must_equal absolute_local_path }
+    end
+
+    describe 'with revision' do
+      let(:ref) { :ref }
+      before { repository.stubs(:blob_at).with(relative_path, :ref).returns(blob) }
+
+      describe 'no blob' do
+        let(:blob) { nil }
+        it { File.read(subject).must_equal "\n" }
+      end
+
+      describe 'has blob' do
+        let(:blob) { stub(text: 'beef') }
+        it { File.read(subject).must_equal "beef\n" }
+      end
+    end
+  end
+
+  describe '#readme_path' do
+    subject { path.readme_path }
+
+    describe 'no directory' do
+      it { subject.must_be_nil }
+    end
+
+    describe 'no README' do
+      before { mkdir('directory/file') }
+      it { subject.must_be_nil }
+    end
+
+    describe 'with README.md' do
+      before { write('directory/file/README.md', 'foobar') }
+      it { subject.must_equal absolute_local_path('README.md') }
+    end
+  end
+
+  describe '#file_listing' do
+    subject { path.file_listing }
+
+    describe 'missing' do
+      it { subject.must_be_nil }
+    end
+
+    describe 'file' do
+      before { write('directory/file', 'foobar') }
+      it { subject.must_be_nil }
+    end
+
+    describe 'directory' do
+      before do
+        write('directory/file/.hidden', 'beef')
+        mkdir('directory/file/dir1')
+        write('directory/file/file1', 'foo')
+        write('directory/file/file2', 'bar')
+
+        # Paths which should not be included
+        write('directory/file/.git', 'test')
+        write('directory/file/.gitignore', 'test')
+        write('directory/file/.gitmessage~', 'test')
+      end
+
+      it { subject.size.must_equal 4 }
+      it { subject.map(&:name).must_equal %w(dir1 file1 file2 .hidden) }
+      it { subject.map(&:is_directory).must_equal [true, false, false, false] }
+    end
+  end
+
+  describe '#content' do
+    subject { path.content }
+
+    describe 'missing' do
+      it { subject.must_be_nil }
+    end
+
+    describe 'directory' do
+      before { mkdir('directory/file') }
+      it { subject.must_be_nil }
+    end
+
+    describe 'file' do
+      before { write('directory/file', 'foobar') }
+      it { subject.must_equal 'foobar' }
+    end
+  end
+
+  describe '#revisions' do
+    subject { path.revisions }
+
+    before do
+      repository.stubs(:commits_for).returns([
+        stub(oid: '1234567890', message: "short1\nlong", author: { name: :name1, time: :time1 }),
+        stub(oid: '0987654321', message: "short2\nlong", author: { name: :name2, time: :time2 })
+      ])
+    end
+    it { subject.size.must_equal(2) }
+    it { subject[0].must_equal(commit: '1234567', subject: 'short1', author: :name1, date: :time1) }
+    it { subject[1].must_equal(commit: '0987654', subject: 'short2', author: :name2, date: :time2) }
+  end
+
+  describe '#revert' do
+    subject { path.revert('ref') }
+    before { repository.expects(:blob_at).with(relative_path, 'ref').returns(blob) }
+
+    describe 'blob missing' do
+      let(:blob) { nil }
+      it { subject.must_equal(nil) }
+    end
+
+    describe 'blob present' do
+      let(:blob) { stub(text: 'deadbeef') }
+      before { path.expects(:write).with('deadbeef', "Reverting '#{relative_path}' to ref") }
+      it { subject }
+    end
+  end
+
+  #############################################################################
+
+  private
+
+  def write(filename, content)
+    mkdir(File.dirname(filename))
+    File.write(File.join(local_repo_path, filename), content)
+  end
+
+  def mkdir(*path)
+    FileUtils.mkdir_p(File.join(local_repo_path, *path))
+  end
+
+  def local_file_exist?
+    File.exist?(File.join(local_repo_path, relative_path))
+  end
+
+  def local_file_content
+    return nil unless local_file_exist?
+    File.read(File.join(local_repo_path, relative_path))
+  end
+
+  def absolute_local_path(*path_elements)
+    File.join(File.absolute_path(local_repo_path), relative_path, *path_elements)
+  end
+end

data/test/{repository_test.rb → unit/repository_test.rb}

@@ -48,11 +48,13 @@ describe Gitdocs::Repository do
     end
 
     describe 'with a share that is a repository' do
-      let(:path_or_share) { stub(
-        path:        local_repo_path,
-        remote_name: 'remote',
-        branch_name: 'branch'
-      ) }
+      let(:path_or_share) do
+        stub(
+          path:        local_repo_path,
+          remote_name: 'remote',
+          branch_name: 'branch'
+        )
+      end
       it { subject.must_be_kind_of Gitdocs::Repository }
       it { subject.valid?.must_equal true }
       it { subject.invalid_reason.must_be_nil }
@@ -80,59 +82,6 @@ describe Gitdocs::Repository do
     end
   end
 
-  describe '.search' do
-    subject { Gitdocs::Repository.search('term', repositories) }
-
-    let(:repositories) { Array.new(4, stub(root: 'root')) }
-    before do
-      repositories[0].expects(:search).with('term').returns(:result1)
-      repositories[1].expects(:search).with('term').returns(:result2)
-      repositories[2].expects(:search).with('term').returns(:result3)
-      repositories[3].expects(:search).with('term').returns([])
-    end
-
-    it do
-      subject.must_equal({
-        Gitdocs::Repository::RepoDescriptor.new('root', 1) => :result3,
-        Gitdocs::Repository::RepoDescriptor.new('root', 2) => :result2,
-        Gitdocs::Repository::RepoDescriptor.new('root', 3) => :result1
-      })
-    end
-  end
-
-  describe '#search' do
-    subject { repository.search(term) }
-
-    describe 'empty term' do
-      let(:term) { '' }
-      it { subject.must_equal [] }
-    end
-
-    describe 'nothing found' do
-      let(:term) { 'foo' }
-      before do
-        write_and_commit('file1', 'bar', 'commit', author1)
-        write_and_commit('file2', 'beef', 'commit', author1)
-      end
-      it { subject.must_equal [] }
-    end
-
-    describe 'term found' do
-      let(:term) { 'foo' }
-      before do
-        write_and_commit('file1', 'foo', 'commit', author1)
-        write_and_commit('file2', 'beef', 'commit', author1)
-        write_and_commit('file3', 'foobar', 'commit', author1)
-      end
-      it do
-        subject.must_equal([
-          Gitdocs::Repository::SearchResult.new('file1', 'foo'),
-          Gitdocs::Repository::SearchResult.new('file3', 'foobar')
-        ])
-      end
-    end
-  end
-
   describe '#root' do
     subject { repository.root }
 
@@ -185,158 +134,394 @@ describe Gitdocs::Repository do
     end
   end
 
-  describe '#pull' do
-    subject { repository.pull }
+  describe '#dirty?' do
+    subject { repository.dirty? }
 
-    let(:path_or_share) { stub(
-      path:        local_repo_path,
-      remote_name: 'origin',
-      branch_name: 'master'
-    ) }
+    let(:path_or_share) do
+      stub(
+        path:        local_repo_path,
+        remote_name: 'origin',
+        branch_name: 'master'
+      )
+    end
 
     describe 'when invalid' do
       let(:path_or_share) { 'tmp/unit/missing' }
-      it { subject.must_be_nil }
+      it { subject.must_equal false }
     end
 
-    describe 'when there is no remote' do
-      it { subject.must_equal :no_remote }
+    describe 'when no existing commits' do
+      describe 'and no new files' do
+        it { subject.must_equal false }
+      end
+
+      describe 'and new files' do
+        before { write('file1', 'foobar') }
+        it { subject.must_equal true }
+      end
+
+      describe 'and new empty directory' do
+        before { mkdir('directory') }
+        it { subject.must_equal true }
+      end
     end
 
-    describe 'with a valid remote with no initial commits' do
-      before { create_local_repo_with_remote }
+    describe 'when commits exist' do
+      before { write_and_commit('file1', 'foobar', 'initial commit', author1) }
 
-      describe 'when there is an error fetching' do
-        before do
-          Grit::Repo.any_instance.stubs(:remote_fetch)
-            .raises(Grit::Git::CommandFailed.new('', 1, 'fetch error output'))
-        end
-        it { subject.must_equal 'fetch error output' }
+      describe 'and no changes' do
+        it { subject.must_equal false }
       end
 
-      describe 'when there are no local commits' do
-        it { subject.must_equal :ok }
+      describe 'add empty directory' do
+        before { mkdir('directory') }
+        it { subject.must_equal false }
       end
 
-      describe 'when there is a local commit' do
-        before { write_and_commit('file1', 'beef', 'conflict commit', author1) }
-        it { subject.must_equal :ok }
-        it { subject ; commit_count(local_repo).must_equal 1 }
+      describe 'add file' do
+        before { write('file2', 'foobar') }
+        it { subject.must_equal true }
       end
 
-      describe 'then new remote commits are fetched' do
-        before do
-          bare_commit(
-            remote_repo,
-            'file2', 'deadbeef',
-            'second commit',
-            'author@example.com', 'A U Thor'
-          )
-        end
+      describe 'modify existing file' do
+        before { write('file1', 'deadbeef') }
+        it { subject.must_equal true }
+      end
 
-        describe 'when there is an error merging' do
-          before do
-            Grit::Git.any_instance.stubs(:merge)
-              .raises(Grit::Git::CommandFailed.new('', 1, 'merge error output'))
-          end
-          it { subject.must_equal 'merge error output' }
-        end
+      describe 'delete file' do
+        before { rm_rf('file1') }
+        it { subject.must_equal true }
+      end
+    end
+  end
 
-        describe ' and merged' do
-          it { subject.must_equal :ok }
-          it { subject ; local_file_exist?('file2').must_equal true }
-          it { subject ; commit_count(local_repo).must_equal 1 }
-        end
+  describe '#need_sync' do
+    subject { repository.need_sync? }
+
+    let(:path_or_share) do
+      stub(
+        path:        local_repo_path,
+        remote_name: 'origin',
+        branch_name: 'master'
+      )
+    end
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_equal false }
+    end
+
+    describe 'when no remotes' do
+      it { subject.must_equal false }
+    end
+
+    describe 'when no remote commits' do
+      before { create_local_repo_with_remote }
+
+      describe 'no local commits' do
+        it { subject.must_equal false }
+      end
+
+      describe 'local commits' do
+        before { write_and_commit('file1', 'beef', 'conflict commit', author1) }
+        it { subject.must_equal true }
       end
     end
 
-    describe 'with a valid remote with commits' do
+    describe 'when remote commits' do
       before { create_local_repo_with_remote_with_commit }
 
-      describe 'when there is nothing to pull' do
-        it { subject.must_equal :ok }
+      describe 'no local commits' do
+        it { subject.must_equal false }
+      end
+
+      describe 'new local commit' do
+        before { write_and_commit('file2', 'beef', 'conflict commit', author1) }
+        it { subject.must_equal true }
       end
 
-      describe 'when there is a conflict' do
+      describe 'new remote commit' do
         before do
           bare_commit(
             remote_repo,
-            'file1', 'dead',
+            'file3', 'dead',
             'second commit',
             'author@example.com', 'A U Thor'
           )
-          write_and_commit('file1', 'beef', 'conflict commit', author1)
+          repository.fetch
         end
 
-        it { subject.must_equal ['file1'] }
-        it { subject ; commit_count(local_repo).must_equal 2 }
-        it { subject ; local_file_count.must_equal 3 }
-        it { subject ; local_file_content('file1 (f6ea049 original)').must_equal 'foobar' }
-        it { subject ; local_file_content('file1 (18ed963)').must_equal 'beef' }
-        it { subject ; local_file_content('file1 (7bfce5c)').must_equal 'dead' }
+        it { subject.must_equal true }
       end
 
-      describe 'when there is a conflict, with additional files' do
+      describe 'new local and remote commit' do
         before do
           bare_commit(
             remote_repo,
-            'file1', 'dead',
-            'second commit',
-            'author@example.com', 'A U Thor'
-          )
-          bare_commit(
-            remote_repo,
-            'file2', 'foo',
+            'file3', 'dead',
             'second commit',
             'author@example.com', 'A U Thor'
           )
-          write_and_commit('file1', 'beef', 'conflict commit', author1)
+          repository.fetch
+          write_and_commit('file4', 'beef', 'conflict commit', author1)
         end
 
-        it { subject.must_equal ['file1'] }
-        it { subject ; commit_count(local_repo).must_equal 2 }
-        it { subject ; local_file_count.must_equal 3 }
-        it { subject ; local_file_content('file1 (f6ea049 original)').must_equal 'foobar' }
-        it { subject ; local_file_content('file1 (18ed963)').must_equal 'beef' }
-        it { subject ; local_file_content('file2').must_equal 'foo' }
+        it { subject.must_equal true }
       end
+    end
+  end
 
-      describe 'when there is a non-conflicted local commit' do
-        before { write_and_commit('file1', 'beef', 'conflict commit', author1) }
-        it { subject.must_equal :ok }
-        it { subject ; commit_count(local_repo).must_equal 2 }
+  describe '#grep' do
+    subject { repository.grep('foo') { |file, context| @grep_result << "#{file} #{context}" } }
+
+    before { @grep_result = [] }
+
+    describe 'timeout' do
+      before do
+        Grit::Repo.any_instance.stubs(:remote_fetch)
+          .raises(Grit::Git::GitTimeout.new)
+      end
+      it { subject ; @grep_result.must_equal([]) }
+      it { subject.must_equal '' }
+    end
+
+    describe 'command failure' do
+      before do
+        Grit::Repo.any_instance.stubs(:remote_fetch)
+          .raises(Grit::Git::CommandFailed.new('', 1, 'grep error output'))
+      end
+      it { subject ; @grep_result.must_equal([]) }
+      it { subject.must_equal '' }
+    end
+
+    describe 'success' do
+      before do
+        write_and_commit('file1', 'foo', 'commit', author1)
+        write_and_commit('file2', 'beef', 'commit', author1)
+        write_and_commit('file3', 'foobar', 'commit', author1)
+        write_and_commit('file4', "foo\ndead\nbeef\nfoobar", 'commit', author1)
+      end
+      it { subject ; @grep_result.must_equal(['file1 foo', 'file3 foobar', 'file4 foo', 'file4 foobar']) }
+      it { subject.must_equal("file1:foo\nfile3:foobar\nfile4:foo\nfile4:foobar\n") }
+    end
+  end
+
+  describe '#fetch' do
+    subject { repository.fetch }
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when no remote' do
+      it { subject.must_equal :no_remote }
+    end
+
+    describe 'with remote' do
+      before { create_local_repo_with_remote }
+
+      describe 'and times out' do
+        before do
+          Grit::Repo.any_instance.stubs(:remote_fetch)
+            .raises(Grit::Git::GitTimeout.new)
+        end
+        it { subject.must_equal "Fetch timed out for #{File.absolute_path(local_repo_path)}" }
+      end
+
+      describe 'and command fails' do
+        before do
+          Grit::Repo.any_instance.stubs(:remote_fetch)
+            .raises(Grit::Git::CommandFailed.new('', 1, 'fetch error output'))
+        end
+        it { subject.must_equal 'fetch error output' }
       end
 
-      describe 'when new remote commits are pulled and merged' do
+      describe 'and success' do
         before do
           bare_commit(
             remote_repo,
-            'file2', 'deadbeef',
-            'second commit',
-            'author@example.com', 'A U Thor'
+            'file1', 'deadbeef',
+            'commit', 'author@example.com', 'A U Thor'
           )
         end
         it { subject.must_equal :ok }
-        it { subject ; local_file_exist?('file2').must_equal true }
-        it { subject ; commit_count(local_repo).must_equal 2 }
+
+        describe 'side effects' do
+          before { subject }
+          it { local_repo_remote_branch.tip.oid.wont_be_nil }
+        end
+      end
+    end
+  end
+
+  describe '#merge' do
+    subject { repository.merge }
+
+    let(:path_or_share) do
+      stub(
+        path:        local_repo_path,
+        remote_name: 'origin',
+        branch_name: 'master'
+      )
+    end
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when no remote' do
+      it { subject.must_equal :no_remote }
+    end
+
+    describe 'has remote but nothing to merge' do
+      before { create_local_repo_with_remote }
+      it { subject.must_equal :ok }
+    end
+
+    describe 'has remote and times out' do
+      before do
+        create_local_repo_with_remote
+        bare_commit(
+          remote_repo,
+          'file1', 'deadbeef',
+          'commit', 'author@example.com', 'A U Thor'
+        )
+        repository.fetch
+
+        Grit::Git.any_instance.stubs(:merge)
+          .raises(Grit::Git::GitTimeout.new)
+      end
+      it { subject.must_equal "Merge timed out for #{File.absolute_path(local_repo_path)}" }
+    end
+
+    describe 'and fails, but does not conflict' do
+      before do
+        create_local_repo_with_remote
+        bare_commit(
+          remote_repo,
+          'file1', 'deadbeef',
+          'commit', 'author@example.com', 'A U Thor'
+        )
+        repository.fetch
+
+        Grit::Git.any_instance.stubs(:merge)
+          .raises(Grit::Git::CommandFailed.new('', 1, 'merge error output'))
+      end
+      it { subject.must_equal 'merge error output' }
+    end
+
+    describe 'and there is a conflict' do
+      before do
+        create_local_repo_with_remote_with_commit
+        bare_commit(
+          remote_repo,
+          'file1', 'dead',
+          'second commit',
+          'author@example.com', 'A U Thor'
+        )
+        write_and_commit('file1', 'beef', 'conflict commit', author1)
+        repository.fetch
+      end
+
+      it { subject.must_equal ['file1'] }
+
+      describe 'side effects' do
+        before { subject }
+        it { commit_count(local_repo).must_equal 2 }
+        it { local_file_count.must_equal 3 }
+        it { local_file_content('file1 (f6ea049 original)').must_equal 'foobar' }
+        it { local_file_content('file1 (18ed963)').must_equal 'beef' }
+        it { local_file_content('file1 (7bfce5c)').must_equal 'dead' }
+      end
+    end
+
+    describe 'and there is a conflict, with additional files' do
+      before do
+        create_local_repo_with_remote_with_commit
+        bare_commit(
+          remote_repo,
+          'file1', 'dead',
+          'second commit',
+          'author@example.com', 'A U Thor'
+        )
+        bare_commit(
+          remote_repo,
+          'file2', 'foo',
+          'second commit',
+          'author@example.com', 'A U Thor'
+        )
+        write_and_commit('file1', 'beef', 'conflict commit', author1)
+        repository.fetch
+      end
+
+      it { subject.must_equal ['file1'] }
+
+      describe 'side effects' do
+        before { subject }
+        it { commit_count(local_repo).must_equal 2 }
+        it { local_file_count.must_equal 3 }
+        it { local_file_content('file1 (f6ea049 original)').must_equal 'foobar' }
+        it { local_file_content('file1 (18ed963)').must_equal 'beef' }
+        it { local_file_content('file2').must_equal 'foo' }
+      end
+    end
+
+    describe 'and there are non-conflicted local commits' do
+      before do
+        create_local_repo_with_remote_with_commit
+        write_and_commit('file1', 'beef', 'conflict commit', author1)
+        repository.fetch
+      end
+      it { subject.must_equal :ok }
+
+      describe 'side effects' do
+        before { subject }
+        it { local_file_count.must_equal 1 }
+        it { commit_count(local_repo).must_equal 2 }
+      end
+    end
+
+    describe 'when new remote commits are merged' do
+      before do
+        create_local_repo_with_remote_with_commit
+        bare_commit(
+          remote_repo,
+          'file2', 'deadbeef',
+          'second commit',
+          'author@example.com', 'A U Thor'
+        )
+        repository.fetch
+      end
+      it { subject.must_equal :ok }
+
+      describe 'side effects' do
+        before { subject }
+        it { local_file_exist?('file2').must_equal true }
+        it { commit_count(local_repo).must_equal 2 }
       end
     end
   end
 
   describe '#commit' do
-    subject { repository.commit('message') }
+    subject { repository.commit }
 
-    let(:path_or_share) { stub(
-      path:        local_repo_path,
-      remote_name: 'origin',
-      branch_name: 'master'
-    ) }
+    let(:path_or_share) do
+      stub(
+        path:        local_repo_path,
+        remote_name: 'origin',
+        branch_name: 'master'
+      )
+    end
 
     describe 'when invalid' do
       let(:path_or_share) { 'tmp/unit/missing' }
       it { subject.must_be_nil }
     end
 
+    # TODO: should test the paths which use the message file
+
     describe 'no previous commits' do
       describe 'nothing to commit' do
         it { subject.must_equal false }
@@ -348,10 +533,14 @@ describe Gitdocs::Repository do
           mkdir('directory')
         end
         it { subject.must_equal true }
-        it { subject ; local_file_exist?('directory/.gitignore').must_equal true }
-        it { subject ; commit_count(local_repo).must_equal 1 }
-        it { subject ; head_commit(local_repo).message.must_equal "message\n" }
-        it { subject ; local_repo_clean?.must_equal true }
+
+        describe 'side effects' do
+          before { subject }
+          it { local_file_exist?('directory/.gitignore').must_equal true }
+          it { commit_count(local_repo).must_equal 1 }
+          it { head_commit(local_repo).message.must_equal "Auto-commit from gitdocs\n" }
+          it { local_repo_clean?.must_equal true }
+        end
       end
     end
 
@@ -368,15 +557,19 @@ describe Gitdocs::Repository do
       describe 'changes to commit' do
         before do
           write('file1', 'foobar')
-          FileUtils.rm_rf(File.join(local_repo_path, 'file2'))
+          rm_rf('file2')
           write('file3', 'foobar')
           mkdir('directory')
         end
         it { subject.must_equal true }
-        it { subject ; local_file_exist?('directory/.gitignore').must_equal true }
-        it { subject ; commit_count(local_repo).must_equal 3 }
-        it { subject ; head_commit(local_repo).message.must_equal "message\n" }
-        it { subject ; local_repo_clean?.must_equal true }
+
+        describe 'side effects' do
+          before { subject }
+          it { local_file_exist?('directory/.gitignore').must_equal true }
+          it { commit_count(local_repo).must_equal 3 }
+          it { head_commit(local_repo).message.must_equal "Auto-commit from gitdocs\n" }
+          it { local_repo_clean?.must_equal true }
+        end
       end
     end
   end
@@ -384,11 +577,13 @@ describe Gitdocs::Repository do
   describe '#push' do
     subject { repository.push }
 
-    let(:path_or_share) { stub(
-      path:        local_repo_path,
-      remote_name: 'origin',
-      branch_name: 'master'
-    ) }
+    let(:path_or_share) do
+      stub(
+        path:        local_repo_path,
+        remote_name: 'origin',
+        branch_name: 'master'
+      )
+    end
 
     describe 'when invalid' do
       let(:path_or_share) { 'tmp/unit/missing' }
@@ -404,7 +599,11 @@ describe Gitdocs::Repository do
 
       describe 'and no local commits' do
         it { subject.must_equal :nothing }
-        it { subject ; commit_count(remote_repo).must_equal 0 }
+
+        describe 'side effects' do
+          before { subject }
+          it { commit_count(remote_repo).must_equal 0 }
+        end
       end
 
       describe 'and a local commit' do
@@ -421,7 +620,11 @@ describe Gitdocs::Repository do
 
         describe 'and the push succeeds' do
           it { subject.must_equal :ok }
-          it { subject ; commit_count(remote_repo).must_equal 1 }
+
+          describe 'side effects' do
+            before { subject }
+            it { commit_count(remote_repo).must_equal 1 }
+          end
         end
       end
     end
@@ -431,7 +634,11 @@ describe Gitdocs::Repository do
 
       describe 'and no local commits' do
         it { subject.must_equal :nothing }
-        it { subject ; commit_count(remote_repo).must_equal 1 }
+
+        describe 'side effects' do
+          before { subject }
+          it { commit_count(remote_repo).must_equal 1 }
+        end
       end
 
       describe 'and a local commit' do
@@ -449,13 +656,21 @@ describe Gitdocs::Repository do
         describe 'and the push conflicts' do
           before { bare_commit(remote_repo, 'file2', 'dead', 'commit', 'A U Thor', 'author@example.com') }
 
-          it { subject ; commit_count(remote_repo).must_equal 2 }
           it { subject.must_equal :conflict }
+
+          describe 'side effects' do
+            before { subject }
+            it { commit_count(remote_repo).must_equal 2 }
+          end
         end
 
         describe 'and the push succeeds' do
           it { subject.must_equal :ok }
-          it { subject ; commit_count(remote_repo).must_equal 2 }
+
+          describe 'side effects' do
+            before { subject }
+            it { commit_count(remote_repo).must_equal 2 }
+          end
         end
       end
     end
@@ -479,12 +694,12 @@ describe Gitdocs::Repository do
 
       describe 'all' do
         let(:last_oid) { nil }
-        it { subject.must_equal({ author1 => 3, author2 => 1 }) }
+        it { subject.must_equal(author1 => 3, author2 => 1) }
       end
 
       describe 'some' do
         let(:last_oid) { @intermediate_oid }
-        it { subject.must_equal({ author1 => 2, author2 => 1 }) }
+        it { subject.must_equal(author1 => 2, author2 => 1) }
       end
 
       describe 'missing oid' do
@@ -494,110 +709,67 @@ describe Gitdocs::Repository do
     end
   end
 
-  describe '#file_meta' do
-    subject { repository.file_meta(file_name) }
+  describe '#write_commit_message' do
+    subject { repository.write_commit_message(commit_message) }
+    before { subject }
 
-    before do
-      write_and_commit('directory0/file0', '', 'initial commit', author1)
-      write_and_commit('directory/file1', 'foo', 'commit1', author1)
-      write_and_commit('directory/file2', 'bar', 'commit2', author2)
-      write_and_commit('directory/file2', 'beef', 'commit3', author2)
-    end
-
-    describe 'on a missing file' do
-      let(:file_name) { 'missing_file' }
-      it { assert_raises(RuntimeError) { subject } }
+    describe 'with missing message' do
+      let(:commit_message) { nil }
+      it { local_file_exist?('.gitmessage~').must_equal(false) }
     end
 
-    describe 'on a file' do
-      describe 'of size zero' do
-        let(:file_name) { 'directory0/file0' }
-        it { subject[:author].must_equal 'Art T. Fish' }
-        it { subject[:size].must_equal -1 }
-        it { subject[:modified].wont_be_nil }
-      end
-
-      describe 'of non-zero size' do
-        let(:file_name) { 'directory/file1' }
-        it { subject[:author].must_equal 'Art T. Fish' }
-        it { subject[:size].must_equal 3 }
-        it { subject[:modified].wont_be_nil }
-      end
+    describe 'with empty message' do
+      let(:commit_message) { '' }
+      it { local_file_exist?('.gitmessage~').must_equal(false) }
     end
 
-    describe 'on a directory' do
-      describe 'of size zero' do
-        let(:file_name) { 'directory0' }
-        it { subject[:author].must_equal 'Art T. Fish' }
-        it { subject[:size].must_equal -1 }
-        it { subject[:modified].wont_be_nil }
-      end
-
-      describe 'of non-zero size' do
-        let(:file_name) { 'directory' }
-        it { subject[:author].must_equal 'A U Thor' }
-        it { subject[:size].must_equal 7 }
-        it { subject[:modified].wont_be_nil }
-      end
+    describe 'with valid message' do
+      let(:commit_message) { 'foobar' }
+      it { local_file_content('.gitmessage~').must_equal('foobar') }
     end
   end
 
-  describe '#file_revisions' do
-    subject { repository.file_revisions('directory') }
+  describe '#commits_for' do
+    subject { repository.commits_for('directory/file', 2) }
 
     before do
       write_and_commit('directory0/file0', '', 'initial commit', author1)
-      @commit1 = write_and_commit('directory/file1', 'foo', 'commit1', author1)
-      @commit2 = write_and_commit('directory/file2', 'bar', 'commit2', author2)
-      @commit3 = write_and_commit('directory/file2', 'beef', 'commit3', author2)
+      write_and_commit('directory/file', 'foo', 'commit1', author1)
+      @commit2 = write_and_commit('directory/file', 'bar', 'commit2', author2)
+      @commit3 = write_and_commit('directory/file', 'beef', 'commit3', author2)
     end
 
-    it { subject.length.must_equal 3 }
-    it { subject.map { |x| x[:author] }.must_equal ['A U Thor', 'A U Thor', 'Art T. Fish'] }
-    it { subject.map { |x| x[:commit] }.must_equal [@commit3[0, 7], @commit2[0, 7], @commit1[0, 7]] }
-    it { subject.map { |x| x[:subject] }.must_equal ['commit3', 'commit2', 'commit1'] }
+    it { subject.map(&:oid).must_equal([@commit3, @commit2]) }
   end
 
-  describe '#file_revision_at' do
-    subject { repository.file_revision_at('directory/file2', @commit) }
+  describe '#last_commit_for' do
+    subject { repository.last_commit_for('directory/file') }
 
     before do
-      write_and_commit('directory0/file0', '', 'initial commit', author1)
-      write_and_commit('directory/file1', 'foo', 'commit1', author1)
-      write_and_commit('directory/file2', 'bar', 'commit2', author2)
-      @commit = write_and_commit('directory/file2', 'beef', 'commit3', author2)
+      write_and_commit('directory/file', 'foo', 'commit1', author1)
+      write_and_commit('directory/file', 'bar', 'commit2', author2)
+      @commit3 = write_and_commit('directory/file', 'beef', 'commit3', author2)
     end
 
-    it { subject.must_equal '/tmp/file2' }
-    it { File.read(subject).must_equal "beef\n" }
+    it { subject.oid.must_equal(@commit3) }
   end
 
-  describe '#file_revert' do
-    subject { repository.file_revert('directory/file2', ref) }
-
-    let(:file_name) { File.join(local_repo_path, 'directory', 'file2') }
+  describe '#blob_at' do
+    subject { repository.blob_at('directory/file', @commit) }
 
     before do
-      @commit0 = write_and_commit('directory0/file0', '', 'initial commit', author1)
-      write_and_commit('directory/file1', 'foo', 'commit1', author1)
-      @commit2 = write_and_commit('directory/file2', 'bar', 'commit2', author2)
-      write_and_commit('directory/file2', 'beef', 'commit3', author2)
-    end
-
-    describe 'file does not include the revision' do
-      let(:ref) { @commit0 }
-      it { subject ; local_file_content('directory', 'file2').must_equal 'beef' }
+      write_and_commit('directory/file', 'foo', 'commit1', author1)
+      @commit = write_and_commit('directory/file', 'bar', 'commit2', author2)
+      write_and_commit('directory/file', 'beef', 'commit3', author2)
     end
 
-    describe 'file does include the revision' do
-      let(:ref) { @commit2 }
-      it { subject ; local_file_content('directory', 'file2').must_equal "bar\n" }
-    end
+    it { subject.text.must_equal('bar') }
   end
 
   ##############################################################################
 
   private
+
   def create_local_repo_with_remote
     FileUtils.rm_rf(local_repo_path)
     repo = Rugged::Repository.clone_at(remote_repo.path, local_repo_path)
@@ -627,6 +799,10 @@ describe Gitdocs::Repository do
     File.write(File.join(local_repo_path, filename), content)
   end
 
+  def rm_rf(filename)
+    FileUtils.rm_rf(File.join(local_repo_path, filename))
+  end
+
   def write_and_commit(filename, content, commit_msg, author)
     mkdir(File.dirname(filename))
     File.write(File.join(local_repo_path, filename), content)
@@ -634,7 +810,7 @@ describe Gitdocs::Repository do
     `cd #{local_repo_path} ; git rev-parse HEAD`.strip
   end
 
-  def bare_commit(repo, filename, content, message, email, name)
+  def bare_commit(repo, filename, content, message, email, name)  # rubocop:disable ParameterLists
     index = Rugged::Index.new
     index.add(
       path: filename,
@@ -642,14 +818,15 @@ describe Gitdocs::Repository do
       mode: 0100644
     )
 
-    Rugged::Commit.create(remote_repo, {
+    Rugged::Commit.create(
+      remote_repo,
       tree:       index.write_tree(repo),
       author:     { email: email, name: name, time: Time.now },
       committer:  { email: email, name: name, time: Time.now },
       message:    message,
-      parents:    repo.empty? ? [] : [ repo.head.target ].compact,
+      parents:    repo.empty? ? [] : [repo.head.target].compact,
       update_ref: 'HEAD'
-    })
+    )
   end
 
   def commit_count(repo)
@@ -680,6 +857,10 @@ describe Gitdocs::Repository do
     files.count
   end
 
+  def local_repo_remote_branch
+    Rugged::Branch.lookup(local_repo, 'origin/master', :remote)
+  end
+
   def local_repo_clean?
     local_repo.diff_workdir(local_repo.head.target, include_untracked: true).deltas.empty?
   end