gitdocs 0.5.0.pre1 → 0.5.0.pre2

data/test/configuration_test.rb

@@ -1,7 +1,9 @@
 require File.expand_path('../test_helper', __FILE__)
 
+
 describe 'gitdocs configuration' do
   before do
+    ENV['TEST'] = 'true'
     ShellTools.capture { @config = Gitdocs::Configuration.new('/tmp/gitdocs') }
   end
 

data/test/integration/full_sync_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe 'fully synchronizing repositories' do
+  before do
+    git_clone_and_gitdocs_add(git_init_remote, 'clone1', 'clone2', 'clone3')
+
+    # TODO: apply this configuration through the CLI in future
+    configuration = Gitdocs::Configuration.new
+    configuration.shares.each do |share|
+      share.update_attributes(polling_interval: 0.1, notification: false)
+    end
+    configuration.global.update_attributes(load_browser_on_startup: false)
+
+    start_cmd = 'gitdocs start --debug --pid=gitdocs.pid --port 7777'
+    run(start_cmd, 15)
+    assert_success(true)
+    assert_partial_output('Started gitdocs', output_from(start_cmd))
+  end
+
+  it 'should sync new files' do
+    write_file('clone1/newfile', 'testing')
+
+    sleep 3
+    check_file_presence(['clone2/newfile', 'clone3/newfile'], true)
+    check_exact_file_content('clone1/newfile', 'testing')
+    check_exact_file_content('clone2/newfile', 'testing')
+    check_exact_file_content('clone3/newfile', 'testing')
+  end
+
+  it 'should sync changes to an existing file' do
+    write_file('clone1/file', 'testing')
+    sleep(3) # Allow the initial files to sync
+
+    append_to_file('clone3/file', "\nfoobar")
+
+    sleep(3)
+    check_exact_file_content('clone1/file', "testing\nfoobar")
+    check_exact_file_content('clone2/file', "testing\nfoobar")
+    check_exact_file_content('clone3/file', "testing\nfoobar")
+  end
+
+  it 'should sync empty directories' do
+    in_current_dir { _mkdir('clone1/empty_dir') }
+    sleep(3)
+
+    check_directory_presence(
+      ['clone1/empty_dir', 'clone2/empty_dir', 'clone3/empty_dir'],
+      true
+    )
+  end
+
+  it 'should mark unresolvable conflicts' do
+    write_file('clone1/file', 'testing')
+    sleep(3) # Allow the initial files to sync
+
+    append_to_file('clone2/file', 'foobar')
+    append_to_file('clone3/file', 'deadbeef')
+
+    sleep(3)
+    in_current_dir do
+      # Remember expected file counts include '.', '..', and '.git'
+      assert_equal(6, Dir.entries('clone1').count)
+      assert_equal(6, Dir.entries('clone2').count)
+      assert_equal(6, Dir.entries('clone3').count)
+    end
+  end
+end

data/test/integration/share_management_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe 'Manage which shares are being watched' do
+  it 'should add a local repository' do
+    git_init_local
+    gitdocs_add
+    gitdocs_status
+    assert_gitdocs_status_contains(abs_current_dir('local'))
+  end
+
+  it 'should add a remote repository' do
+    git_init_remote
+    abs_remote_path = abs_current_dir('remote')
+    cmd = "gitdocs create local #{abs_remote_path} --pid=gitdocs.pid"
+    run_simple(cmd, true, 15)
+    assert_success(true)
+    assert_partial_output("Added path local to doc list", output_from(cmd))
+  end
+
+  it 'should remove a share' do
+    git_init_local
+    gitdocs_add
+
+    cmd = 'gitdocs rm local --pid=gitdocs.pid'
+    run_simple(cmd, true, 15)
+    assert_success(true)
+    assert_partial_output("Removed path local from doc list", output_from(cmd))
+  
+    gitdocs_status
+    assert_gitdocs_status_not_contain(abs_current_dir('local'))
+  end
+
+  it 'should clear all existing shares' do
+    ['local1', 'local2', 'local3'].each { |x| git_init_local(x) ; gitdocs_add(x) }
+
+    cmd = 'gitdocs clear --pid=gitdocs.pid'
+    run_simple(cmd, true, 15)
+    assert_success(true)
+    assert_partial_output('Cleared paths from gitdocs', output_from(cmd))
+
+    gitdocs_status
+    assert_gitdocs_status_not_contain(abs_current_dir('local1'))
+    assert_gitdocs_status_not_contain(abs_current_dir('local2'))
+    assert_gitdocs_status_not_contain(abs_current_dir('local3'))
+  end
+end

data/test/integration/status_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe 'CLI with display daemon and share status' do
+  it 'should display information about the daemon' do
+    gitdocs_status
+    assert_gitdocs_status_contains(Gitdocs::VERSION)
+    assert_gitdocs_status_contains('Running: false')
+  end
+
+  it 'should display information about the shares' do
+    git_clone_and_gitdocs_add(git_init_remote, 'clone1', 'clone2', 'clone3')
+
+    gitdocs_status
+
+    assert_gitdocs_status_contains(abs_current_dir('clone1'))
+    assert_gitdocs_status_contains(abs_current_dir('clone2'))
+    assert_gitdocs_status_contains(abs_current_dir('clone3'))
+  end
+end

data/test/integration/test_helper.rb

@@ -0,0 +1,130 @@
+require 'rubygems'
+require 'minitest/autorun'
+$LOAD_PATH.unshift File.expand_path('../../lib')
+require 'gitdocs'
+require 'aruba'
+require 'aruba/api'
+
+module MiniTest::Aruba
+  class ArubaApiWrapper
+    include Aruba::Api
+  end
+
+  def aruba
+    @aruba ||= ArubaApiWrapper.new
+  end
+
+  def run(*args)
+    if args.length == 0
+      super
+    else
+      aruba.run(*args)
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    aruba.send(method, *args, &block)
+  end
+
+  def before_setup
+    super
+    original = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
+    set_env('PATH', ([File.expand_path('bin')] + original).join(File::PATH_SEPARATOR))
+    FileUtils.rm_rf(current_dir)
+  end
+
+  def after_teardown
+    super
+    restore_env
+    processes.clear
+  end
+end
+
+module Helper
+  include MiniTest::Aruba
+
+  def before_setup
+    super
+    set_env('HOME', abs_current_dir)
+    ENV['TEST'] = nil
+  end
+
+  def after_teardown
+    super
+
+    terminate_processes!
+    prep_for_fs_check do
+      next unless File.exists?('gitdocs.pid')
+
+      pid = IO.read('gitdocs.pid').to_i
+      Process.kill('KILL', pid)
+      begin
+        Process.wait(pid)
+      rescue SystemCallError
+        # This means that the process is already gone.
+        # Nothing to do.
+      end
+    end
+  end
+
+  # @overload abs_current_dir
+  #   @return [String] absolute path for current_dir
+  # @overload abs_current_dir(relative_path)
+  #   @param [String] relative_path to the current directory
+  #   @return [String] the absolute path
+  def abs_current_dir(relative_path = nil)
+    return File.absolute_path(File.join(current_dir)) unless relative_path
+    File.absolute_path(File.join(current_dir, relative_path))
+  end
+
+  # @return [String] the absolute path for the repository
+  def git_init_local(path = 'local')
+    abs_path = abs_current_dir(path)
+    Rugged::Repository.init_at(abs_path)
+    abs_path
+  end
+
+  # @return [String] the absolute path for the repository
+  def git_init_remote(path = 'remote')
+    abs_path = abs_current_dir(path)
+    Rugged::Repository.init_at(abs_path, :bare)
+    abs_path
+  end
+
+  def gitdocs_add(path = 'local')
+    add_cmd = "gitdocs add #{path} --pid=gitdocs.pid"
+    run_simple(add_cmd, true, 15)
+    assert_success(true)
+    assert_partial_output("Added path #{path} to doc list", output_from(add_cmd))
+  end
+
+  def git_clone_and_gitdocs_add(remote_path, *clone_paths)
+    clone_paths.each do |clone_path|
+      repo = Rugged::Repository.clone_at(
+        "file://#{remote_path}",
+        abs_current_dir(clone_path)
+      )
+      repo.config['user.email'] = 'afish@example.com'
+      repo.config['user.name']  = 'Art T. Fish'
+      gitdocs_add(clone_path)
+    end
+  end
+
+  def gitdocs_status
+    @status_cmd = 'gitdocs status --pid=gitdocs.pid'
+    run(@status_cmd, 15)
+    assert_success(true)
+  end
+
+  def assert_gitdocs_status_contains(expected)
+    assert_partial_output(expected, output_from(@status_cmd))
+  end
+
+  def assert_gitdocs_status_not_contain(expected)
+    assert_no_partial_output(expected, output_from(@status_cmd))
+  end
+end
+
+class MiniTest::Spec
+  include Helper
+end

data/test/notifier_test.rb

@@ -0,0 +1,68 @@
+# -*- encoding : utf-8 -*-
+require File.expand_path('../test_helper', __FILE__)
+
+describe Gitdocs::Notifier do
+  let(:notifier) { Gitdocs::Notifier.new(show_notifications) }
+
+  describe '#info' do
+    subject { notifier.info('title', 'message') }
+
+    describe 'without notifications' do
+      let(:show_notifications) { false }
+      before { notifier.expects(:puts).with('title: message') }
+      it { subject }
+    end
+
+    describe 'with notifications' do
+      let(:show_notifications) { true }
+      before do
+        Guard::Notifier.expects(:turn_on)
+        Guard::Notifier.expects(:notify)
+          .with(
+            'message',
+            title: 'title',
+            image: File.expand_path('../../lib/img/icon.png', __FILE__)
+          )
+      end
+      it { subject }
+    end
+  end
+
+  describe '#warn' do
+    subject { notifier.warn('title', 'message') }
+
+    describe 'without notifications' do
+      let(:show_notifications) { false }
+      before { Kernel.expects(:warn).with('title: message') }
+      it { subject }
+    end
+
+    describe 'with notifications' do
+      let(:show_notifications) { true }
+      before do
+        Guard::Notifier.expects(:turn_on)
+        Guard::Notifier.expects(:notify).with('message', title: 'title',)
+      end
+      it { subject }
+    end
+  end
+
+  describe '#error' do
+    subject { notifier.error('title', 'message') }
+
+    describe 'without notifications' do
+      let(:show_notifications) { false }
+      before { Kernel.expects(:warn).with('title: message') }
+      it { subject }
+    end
+
+    describe 'with notifications' do
+      let(:show_notifications) { true }
+      before do
+        Guard::Notifier.expects(:turn_on)
+        Guard::Notifier.expects(:notify).with('message', title: 'title', image: :failure)
+      end
+      it { subject }
+    end
+  end
+end

data/test/repository_test.rb

@@ -0,0 +1,578 @@
+# -*- encoding : utf-8 -*-
+require File.expand_path('../test_helper', __FILE__)
+
+describe Gitdocs::Repository do
+  let(:local_repo_path) { 'tmp/unit/local' }
+  let(:author1)         { 'Art T. Fish <afish@example.com>' }
+  let(:author2)         { 'A U Thor <author@example.com>' }
+
+  before do
+    FileUtils.rm_rf('tmp/unit')
+    FileUtils.mkdir_p(local_repo_path)
+    repo = Rugged::Repository.init_at(local_repo_path)
+    repo.config['user.email'] = 'afish@example.com'
+    repo.config['user.name']  = 'Art T. Fish'
+  end
+
+  let(:repository) { Gitdocs::Repository.new(path_or_share) }
+  # Default path for the repository object, which can be overridden by the
+  # tests when necessary.
+  let(:path_or_share) { local_repo_path }
+  let(:remote_repo)   { Rugged::Repository.init_at('tmp/unit/remote', :bare) }
+  let(:local_repo)    { Rugged::Repository.new(local_repo_path) }
+
+
+  describe 'initialize' do
+    subject { repository }
+
+    describe 'with a missing path' do
+      let(:path_or_share) { 'tmp/unit/missing_path' }
+      it { subject.must_be_kind_of Gitdocs::Repository }
+      it { subject.valid?.must_equal false }
+      it { subject.invalid_reason.must_equal :directory_missing }
+    end
+
+    describe 'with a path that is not a repository' do
+      let(:path_or_share) { 'tmp/unit/not_a_repo' }
+      before { FileUtils.mkdir_p(path_or_share) }
+      it { subject.must_be_kind_of Gitdocs::Repository }
+      it { subject.valid?.must_equal false }
+      it { subject.invalid_reason.must_equal :no_repository }
+    end
+
+    describe 'with a string path that is a repository' do
+      it { subject.must_be_kind_of Gitdocs::Repository }
+      it { subject.valid?.must_equal true }
+      it { subject.invalid_reason.must_be_nil }
+      it { subject.instance_variable_get(:@rugged).wont_be_nil }
+      it { subject.instance_variable_get(:@grit).wont_be_nil }
+    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'
+      ) }
+      it { subject.must_be_kind_of Gitdocs::Repository }
+      it { subject.valid?.must_equal true }
+      it { subject.invalid_reason.must_be_nil }
+      it { subject.instance_variable_get(:@rugged).wont_be_nil }
+      it { subject.instance_variable_get(:@grit).wont_be_nil }
+      it { subject.instance_variable_get(:@branch_name).must_equal 'branch' }
+      it { subject.instance_variable_get(:@remote_name).must_equal 'remote' }
+    end
+  end
+
+  describe '.clone' do
+    subject { Gitdocs::Repository.clone(path, remote) }
+
+    let(:path)   { 'tmp/unit/clone' }
+    let(:remote) { 'tmp/unit/remote' }
+
+    describe 'with invalid remote' do
+      it { assert_raises(RuntimeError) { subject } }
+    end
+
+    describe 'with valid remote' do
+      before { Rugged::Repository.init_at(remote, :bare) }
+      it { subject.must_be_kind_of Gitdocs::Repository }
+      it { subject.valid?.must_equal true }
+    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 }
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when valid' do
+      it { subject.must_equal File.expand_path(local_repo_path) }
+    end
+  end
+
+  describe '#available_remotes' do
+    subject { repository.available_remotes }
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when valid' do
+      it { subject.must_equal [] }
+    end
+  end
+
+  describe '#available_branches' do
+    subject { repository.available_branches }
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when valid' do
+      it { subject.must_equal [] }
+    end
+  end
+
+  describe '#current_oid' do
+    subject { repository.current_oid }
+
+    describe 'no commits' do
+      it { subject.must_equal nil }
+    end
+
+    describe 'has commits' do
+      before { @head_oid = write_and_commit('touch_me', '', 'commit', author1) }
+      it { subject.must_equal @head_oid }
+    end
+  end
+
+  describe '#pull' do
+    subject { repository.pull }
+
+    let(:path_or_share) { stub(
+      path:        local_repo_path,
+      remote_name: 'origin',
+      branch_name: 'master'
+    ) }
+
+    describe 'when invalid' do
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when there is no remote' do
+      it { subject.must_equal :no_remote }
+    end
+
+    describe 'when there is an error' do
+      before do
+        Rugged::Remote.add(
+            Rugged::Repository.new(local_repo_path),
+            'origin',
+            'file:///bad/remote'
+        )
+      end
+      it { subject.must_equal "Fetching origin\n" }
+    end
+
+    describe 'with a valid remote' do
+      before { create_local_repo_with_remote }
+
+      describe 'when there is nothing to pull' do
+        it { subject.must_equal :ok }
+      end
+
+      describe 'when there is a conflict' do
+        before do
+          bare_commit(
+            remote_repo,
+            'file1', 'dead',
+            'second commit',
+            'author@example.com', 'A U Thor'
+          )
+          write_and_commit('file1', 'beef', 'conflict commit', author1)
+        end
+
+        it { subject.must_equal ['file1'] }
+        it { subject ; commit_count(local_repo).must_equal 2 }
+        it { subject ; local_repo_files.count.must_equal 3 }
+        it { subject ; local_repo_files.must_include 'file1 (f6ea049 original)' }
+        it { subject ; local_repo_files.must_include 'file1 (18ed963)' }
+        it { subject ; local_repo_files.must_include 'file1 (7bfce5c)' }
+      end
+
+      describe 'when new commits are pulled and merged' do
+        before do
+          bare_commit(
+            remote_repo,
+            'file2', 'deadbeef',
+            'second commit',
+            'author@example.com', 'A U Thor'
+          )
+        end
+        it { subject.must_equal :ok }
+        it { subject ; File.exists?(File.join(local_repo_path, 'file2')).must_equal true }
+        it { subject ; commit_count(local_repo).must_equal 2 }
+      end
+    end
+  end
+
+  describe '#push' do
+    subject { repository.push(last_oid, 'message') }
+
+    let(:path_or_share) { stub(
+      path:        local_repo_path,
+      remote_name: 'origin',
+      branch_name: 'master'
+    ) }
+
+    describe 'when invalid' do
+      let(:last_oid)      { nil }
+      let(:path_or_share) { 'tmp/unit/missing' }
+      it { subject.must_be_nil }
+    end
+
+    describe 'when no remote' do
+      let(:last_oid) { nil }
+      it { subject.must_equal :no_remote }
+    end
+
+    describe 'remote exists' do
+      before { create_local_repo_with_remote }
+
+      describe 'last sync is nil' do
+        let(:last_oid) { nil }
+
+        describe 'and there is an error on push' do
+          # Force an error to occur in the push
+          before { repository.instance_variable_set(:@branch_name, 'missing') }
+          it { subject.must_equal :nothing }
+        end
+
+        describe 'and there is a conflicted file to push' do
+          before do
+            bare_commit(remote_repo, 'file1', 'dead', 'commit', 'A U Thor', 'author@example.com')
+            write('file1', 'beef')
+          end
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject.must_equal :nothing }
+        end
+
+        describe 'and there is an empty directory to push' do
+          before { FileUtils.mkdir_p(File.join(local_repo_path, 'directory')) }
+          it { subject.must_equal :ok }
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject ; head_commit(remote_repo).message.must_equal "message\n" }
+          it { subject ; head_tree_files(remote_repo).count.must_equal 2 }
+          it { subject ; head_tree_files(remote_repo).must_include 'file1' }
+          it { subject ; head_tree_files(remote_repo).must_include 'directory' }
+        end
+
+        describe 'and there is an existing file update to push' do
+          before { write('file1', 'deadbeef') }
+          it { subject.must_equal :ok }
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject ; head_commit(remote_repo).message.must_equal "message\n" }
+          it { subject ; head_tree_files(remote_repo).count.must_equal 1 }
+          it { subject ; head_tree_files(remote_repo).must_include 'file1' }
+        end
+
+        describe 'and there is a new file to push' do
+          before { write('file2', 'foobar') }
+          it { subject.must_equal :ok }
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject ; head_commit(remote_repo).message.must_equal "message\n" }
+          it { subject ; head_tree_files(remote_repo).count.must_equal 2 }
+          it { subject ; head_tree_files(remote_repo).must_include 'file1' }
+          it { subject ; head_tree_files(remote_repo).must_include 'file2' }
+        end
+      end
+
+      describe 'last sync is not nil' do
+        let(:last_oid) { 'oid' }
+
+        describe 'and this is an error on the push' do
+          before do
+            write('file2', 'foobar')
+            # Force an error to occur in the push
+            repository.instance_variable_set(:@branch_name, 'missing')
+          end
+          it { subject.must_be_kind_of String }
+        end
+
+        describe 'and this is nothing to push' do
+          it { subject.must_equal :nothing }
+        end
+
+        describe 'and there is a conflicted commit to push' do
+          before do
+            bare_commit(remote_repo, 'file1', 'dead', 'commit', 'A U Thor', 'author@example.com')
+            write('file1', 'beef')
+          end
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject.must_equal :conflict }
+        end
+
+        describe 'and there is a commit to push' do
+          before { write('file2', 'foobar') }
+          it { subject.must_equal :ok }
+          it { subject ; commit_count(local_repo).must_equal 2 }
+          it { subject ; commit_count(remote_repo).must_equal 2 }
+          it { subject ; head_commit(remote_repo).message.must_equal "message\n" }
+          it { subject ; head_tree_files(remote_repo).count.must_equal 2 }
+          it { subject ; head_tree_files(remote_repo).must_include 'file1' }
+          it { subject ; head_tree_files(remote_repo).must_include 'file2' }
+        end
+      end
+    end
+  end
+
+  describe '#author_count' do
+    subject { repository.author_count(last_oid) }
+
+    describe 'no commits' do
+      let(:last_oid) { nil }
+      it { subject.must_equal({}) }
+    end
+
+    describe 'commits' do
+      before do
+        @intermediate_oid = write_and_commit('touch_me', 'first', 'initial commit', author1)
+        write_and_commit('touch_me', 'second', 'commit', author1)
+        write_and_commit('touch_me', 'third', 'commit', author2)
+        write_and_commit('touch_me', 'fourth', 'commit', author1)
+      end
+
+      describe 'all' do
+        let(:last_oid) { nil }
+        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 }) }
+      end
+
+      describe 'missing oid' do
+        let(:last_oid) { 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'  }
+        it { subject.must_equal({}) }
+      end
+    end
+  end
+
+  describe '#file_meta' do
+    subject { repository.file_meta(file_name) }
+
+    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 } }
+    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
+    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
+    end
+  end
+
+  describe '#file_revisions' do
+    subject { repository.file_revisions('directory') }
+
+    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)
+    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'] }
+  end
+
+  describe '#file_revision_at' do
+    subject { repository.file_revision_at('directory/file2', @commit) }
+
+    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)
+    end
+
+    it { subject.must_equal '/tmp/file2' }
+    it { File.read(subject).must_equal "beef\n" }
+  end
+
+  describe '#file_revert' do
+    subject { repository.file_revert('directory/file2', ref) }
+
+    let(:file_name) { File.join(local_repo_path, 'directory', 'file2') }
+
+    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 ; File.read(file_name).must_equal 'beef' }
+    end
+
+    describe 'file does include the revision' do
+      let(:ref) { @commit2 }
+      it { subject ; File.read(file_name).must_equal "bar\n" }
+    end
+  end
+
+  ##############################################################################
+
+  private
+
+  def create_local_repo_with_remote
+    bare_commit(
+      remote_repo,
+      'file1', 'foobar',
+      'initial commit',
+      'author@example.com', 'A U Thor'
+    )
+    FileUtils.rm_rf(local_repo_path)
+    repo = Rugged::Repository.clone_at(remote_repo.path, local_repo_path)
+    repo.config['user.email'] = 'afish@example.com'
+    repo.config['user.name']  = 'Art T. Fish'
+  end
+
+  def write(filename, content)
+    FileUtils.mkdir_p(File.join(local_repo_path, File.dirname(filename)))
+    File.write(File.join(local_repo_path, filename), content)
+  end
+
+  def write_and_commit(filename, content, commit_msg, author)
+    FileUtils.mkdir_p(File.join(local_repo_path, File.dirname(filename)))
+    File.write(File.join(local_repo_path, filename), content)
+    `cd #{local_repo_path} ; git add #{filename}; git commit -m '#{commit_msg}' --author='#{author}'`
+    `cd #{local_repo_path} ; git rev-parse HEAD`.strip
+  end
+
+  def bare_commit(repo, filename, content, message, email, name)
+    index = Rugged::Index.new
+    index.add(
+      path: filename,
+      oid:  repo.write(content, :blob),
+      mode: 0100644
+    )
+
+    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,
+      update_ref: 'HEAD'
+    })
+  end
+
+  def commit_count(repo)
+    walker = Rugged::Walker.new(repo)
+    walker.push(repo.head.target)
+    walker.count
+  end
+
+  def head_commit(repo)
+    walker = Rugged::Walker.new(repo)
+    walker.push(repo.head.target)
+    walker.first
+  end
+
+  def head_tree_files(repo)
+    head_commit(repo).tree.map { |x| x[:name] }
+  end
+
+  def local_repo_files
+    Dir.chdir(local_repo_path) do
+      Dir.glob('*')
+    end
+  end
+end