gitdocs 0.5.0.pre3 → 0.5.0.pre5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MWMzMjFmOGM0ZDE0OTBhMjVlNmIxYzIzNGZhODFhOGYyZDhiN2YyYw==
+    YzYxMWM5MTg3ZWYzMzllZDNhY2NiNDdlNTA2NmNmMWEyNTVjMzFkNQ==
   data.tar.gz: !binary |-
-    NmFmYWFiOWE2M2Y0YTVkNDVlMThmY2UwZmNkNjNjZWM1YjE5NDVkMg==
+    Njc0MTAxYjFlODI1ZjE5NjdmZGE0YmNmODc2MmJkMDc4NWQ5MzY5Ng==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YmM0ODM5NWM2ODg0OTc3YWEyMTZmNWIyYWI3NDBmZjQxODg4OTdiNjFiYjU1
-    OWRhZWNhNzljOWIzY2Q3MmNmZjYzNThiMTY5NWQ1NTJlYWMyN2RjZDliYTc2
-    MDRhOTg0ZTlmYmRkYWM5MjA0Zjk1ODA1ZjE0NjBkZGYwMjEyZDI=
+    NDFkODRiMDJjMGU3MWNkZGY4NjdhZWQ4OTM3N2EyNjRiNjM5MjAwYmQ5NWQ1
+    MTBlZTA5NGFkNWU1ODM2MWJhYmY1NWI0NDg3ZmVhMGI1YTBjODY0MTE1YjQ4
+    Njc1YjIyN2ZjMjAyN2M3YjZiNWM1OGE2ZDViMmZjOTgxZjkwMTY=
   data.tar.gz: !binary |-
-    ZjQxM2EwMDNhY2RkMGUwNjMzMTVmMmM4YWNkZTkwMGZhNDYzYTQzMGQyZjUw
-    ZTdlMDg2NjgzZjU0NmNiZDA4ZmQwYWU3MWI3YjYxMDk4MzM5Y2I3MzU0ODI3
-    M2E1ZGNhNTNhMDg1MGYwYjYzNjU3ZmE3NDFjYzk2YjgxZTZhNzY=
+    NzRjMzZmZDRhZjUzZDAyODNhMzRjNjFmNGRjZmViZmM5OTk1MzkzMWZmYzA2
+    ODMxMmNiY2U0NTVkOGEwODIyM2UxZTJkMTZiN2I2MWE0YzZkMjNjOTM4Mjkx
+    YjUzMzNjMTIzZmUzMzIzZGQ1ZDRkYjQ5OTQxODNiNzE0NTgyNzQ=

data/CHANGELOG

@@ -1,3 +1,15 @@
+0.5.0.pre5 (May 14th 2014)
+
+ * Cleanup behavior on empty commits
+ * Improve pre-commit working directory change
+ * More rugged / grit conversions
+ * Update remote check to rugged
+ * Re-write empty directory tagging to use Find
+
+0.5.0.pre4 (April 15th 2014)
+
+ * Fix a performance bug related to using Rugged for the "push" (@acant)
+
 0.5.0.pre3 (3/30/2014)
 
  * Eliminate sleep from sync integration test (@acant)

data/lib/gitdocs/repository.rb

@@ -1,14 +1,14 @@
 # -*- encoding : utf-8 -*-
+require 'find'
 
 # Wrapper for accessing the shared git repositories.
-# Rugged, grit, or shell will be used in that order of preference depending
+# Rugged or Grit will be used, in that order of preference, depending
 # upon the features which are available with each option.
 #
 # @note If a repository is invalid then query methods will return nil, and
 #   command methods will raise exceptions.
 #
 class Gitdocs::Repository
-  include ShellTools
   attr_reader :invalid_reason
 
   # Initialize the repository on the specified path. If the path is not valid
@@ -26,9 +26,10 @@ class Gitdocs::Repository
       @branch_name = path_or_share.branch_name
     end
 
-    @rugged         = Rugged::Repository.new(path)
-    @grit           = Grit::Repo.new(path)
-    @invalid_reason = nil
+    @rugged               = Rugged::Repository.new(path)
+    @grit                 = Grit::Repo.new(path)
+    Grit::Git.git_timeout = 120
+    @invalid_reason       = nil
   rescue Rugged::OSError
     @invalid_reason = :directory_missing
   rescue Rugged::RepositoryError
@@ -129,6 +130,7 @@ class Gitdocs::Repository
     Rugged::Branch.each_name(@rugged, :local).sort
   end
 
+  # @return [nil] if there are no commits present
   # @return [String] oid of the HEAD of the working directory
   def current_oid
     @rugged.head.target
@@ -150,33 +152,45 @@ class Gitdocs::Repository
     return nil unless valid?
     return :no_remote unless has_remote?
 
-    out, status = sh_with_code("cd #{root} ; git fetch --all 2>/dev/null && git merge #{@remote_name}/#{@branch_name} 2>/dev/null")
-
-    if status.success?
-      :ok
-    elsif out[/CONFLICT/]
-      # Find the conflicted files
-      conflicted_files = sh('git ls-files -u --full-name -z').split("\0")
-        .reduce(Hash.new { |h, k| h[k] = [] }) do|h, line|
-          parts = line.split(/\t/)
-          h[parts.last] << parts.first.split(/ /)
-          h
-        end
-
-      # Mark the conflicted files
-      conflicted_files.each do |conflict, ids|
-        conflict_start, conflict_end = conflict.scan(/(.*?)(|\.[^\.]+)$/).first
-        ids.each do |(mode, sha, id)|
-          author =  ' original' if id == '1'
-          system("cd #{root} && git show :#{id}:#{conflict} > '#{conflict_start} (#{sha[0..6]}#{author})#{conflict_end}'")
-        end
-        system("cd #{root} && git rm --quiet #{conflict} >/dev/null 2>/dev/null") || fail
+    begin
+      @rugged.remotes.each { |x| @grit.remote_fetch(x.name) }
+    rescue Grit::Git::GitTimeout
+      return "Fetch timed out for #{root}"
+    rescue Grit::Git::CommandFailed => e
+      return e.err
+    end
+
+    return :ok if remote_branch.nil? || remote_branch.tip.oid == current_oid
+
+    @grit.git.merge({ raise: true, chdir: root }, "#{@remote_name}/#{@branch_name}")
+    :ok
+  rescue Grit::Git::GitTimeout
+    "Merged command timed out for #{root}"
+  rescue Grit::Git::CommandFailed => e
+    # HACK: The rugged in-memory index will not have been updated after the
+    # Grit merge command. Reload it before checking for conflicts.
+    @rugged.index.reload
+    return e.err unless @rugged.index.conflicts?
+
+    conflicted_paths = @rugged.index.map do |index_entry|
+      filename, extension = index_entry[:path].scan(/(.*?)(|\.[^\.]+)$/).first
+
+      author       = ' original' if index_entry[:stage] == 1
+      short_oid    = index_entry[:oid][0..6]
+      new_filename = "#{filename} (#{short_oid}#{author})#{extension}"
+      File.open(File.join(root, new_filename), 'wb') do |f|
+        f.write(Rugged::Blob.lookup(@rugged, index_entry[:oid]).content)
       end
 
-      conflicted_files.keys
-    else
-      out # return the output on error
+      index_entry[:path]
     end
+
+    conflicted_paths.uniq!
+    conflicted_paths.each { |path| FileUtils.remove(File.join(root, path), force: true) }
+
+    # NOTE: leave the commit until the next push
+
+    conflicted_paths
   end
 
   # Commit and push the repository
@@ -191,19 +205,34 @@ class Gitdocs::Repository
     return :no_remote unless has_remote?
 
     #add and commit
-    Dir.glob(File.join(root, '**', '*'))
-      .select { |x| File.directory?(x) && Dir.glob("#{x}/*").empty? }
-      .each { |x| FileUtils.touch(File.join(x, '.gitignore')) }
-    Dir.chdir(root) do
-      @rugged.index.add_all
-      @rugged.index.update_all
+    Find.find(root).each do |path|
+      Find.prune if File.basename(path) == '.git'
+      if File.directory?(path) && Dir.entries(path).count == 2
+        FileUtils.touch(File.join(path, '.gitignore'))
+      end
+    end
+
+    # Check if there are uncommitted changes
+    dirty =
+      if current_oid.nil?
+        Dir.glob(File.join(root, '*')).any?
+      else
+        @rugged.diff_workdir(current_oid, include_untracked: true).deltas.any?
+      end
+
+    # Commit any changes in the working directory.
+    if dirty
+      Dir.chdir(root) do
+        @rugged.index.add_all
+        @rugged.index.update_all
+      end
+      @rugged.index.write
+      @grit.commit_index(message)
     end
-    @rugged.index.write
-    @grit.commit_index(message) if @rugged.index.count
 
-    remote_branch = Rugged::Branch.lookup(@rugged, "#{@remote_name}/#{@branch_name}", :remote)
+    return :nothing if current_oid.nil?
 
-    if last_synced_oid.nil? || remote_branch.nil? || remote_branch.tip.oid != @rugged.head.target
+    if last_synced_oid.nil? || remote_branch.nil? || remote_branch.tip.oid != current_oid
       begin
         @grit.git.push({ raise: true }, @remote_name, @branch_name)
         :ok
@@ -330,7 +359,18 @@ class Gitdocs::Repository
   private
 
   def has_remote?
-    sh_string('git remote')
+    @rugged.remotes.any?
+  end
+
+  # HACK: This will return nil if there are no commits in the remote branch.
+  # It is not the response that I would expect but it mostly gets the job
+  # done. This should probably be reviewed when upgrading to the next version
+  # of Rugged.
+  #
+  # @return [nil] if the remote branch does not exist
+  # @return [Rugged::Remote]
+  def remote_branch
+    Rugged::Branch.lookup(@rugged, "#{@remote_name}/#{@branch_name}", :remote)
   end
 
   def head_walker
@@ -339,16 +379,4 @@ class Gitdocs::Repository
     walker.push(@rugged.head.target)
     walker
   end
-
-  # sh_string("git config branch.`git branch | grep '^\*' | sed -e 's/\* //'`.remote", "origin")
-  def sh_string(cmd, default = nil)
-    val = sh("cd #{root} ; #{cmd}").strip rescue nil
-    val.nil? || val.empty? ? default : val
-  end
-
-  # Run in shell, return both status and output
-  # @see #sh
-  def sh_with_code(cmd)
-    ShellTools.sh_with_code(cmd, root)
-  end
 end

data/lib/gitdocs/version.rb

@@ -1,3 +1,3 @@
 module Gitdocs
-  VERSION = '0.5.0.pre3'
+  VERSION = '0.5.0.pre5'
 end

data/test/repository_test.rb

@@ -8,7 +8,7 @@ describe Gitdocs::Repository do
 
   before do
     FileUtils.rm_rf('tmp/unit')
-    FileUtils.mkdir_p(local_repo_path)
+    mkdir
     repo = Rugged::Repository.init_at(local_repo_path)
     repo.config['user.email'] = 'afish@example.com'
     repo.config['user.name']  = 'Art T. Fish'
@@ -21,7 +21,6 @@ describe Gitdocs::Repository do
   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 }
 
@@ -118,7 +117,6 @@ describe Gitdocs::Repository do
       it { subject.must_equal [] }
     end
 
-
     describe 'term found' do
       let(:term) { 'foo' }
       before do
@@ -205,19 +203,55 @@ describe Gitdocs::Repository 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'
-        )
+    describe 'with a valid remote with no initial commits' do
+      before { create_local_repo_with_remote }
+
+      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' }
+      end
+
+      describe 'when there are no local commits' do
+        it { subject.must_equal :ok }
+      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 }
+      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 '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 ' 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
       end
-      it { subject.must_equal "Fetching origin\n" }
     end
 
-    describe 'with a valid remote' do
-      before { create_local_repo_with_remote }
+    describe 'with a valid remote with commits' do
+      before { create_local_repo_with_remote_with_commit }
 
       describe 'when there is nothing to pull' do
         it { subject.must_equal :ok }
@@ -236,13 +270,19 @@ describe Gitdocs::Repository do
 
         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)' }
+        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' }
       end
 
-      describe 'when new commits are pulled and merged' do
+      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 }
+      end
+
+      describe 'when new remote commits are pulled and merged' do
         before do
           bare_commit(
             remote_repo,
@@ -252,7 +292,7 @@ describe Gitdocs::Repository do
           )
         end
         it { subject.must_equal :ok }
-        it { subject ; File.exists?(File.join(local_repo_path, 'file2')).must_equal true }
+        it { subject ; local_file_exist?('file2').must_equal true }
         it { subject ; commit_count(local_repo).must_equal 2 }
       end
     end
@@ -278,7 +318,7 @@ describe Gitdocs::Repository do
       it { subject.must_equal :no_remote }
     end
 
-    describe 'remote exists' do
+    describe 'remote exists with no commits' do
       before { create_local_repo_with_remote }
 
       describe 'last sync is nil' do
@@ -292,6 +332,116 @@ describe Gitdocs::Repository do
             )
           end
           it { subject.must_equal :nothing }
+          it { subject ; commit_count(local_repo).must_equal 0 }
+        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 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          it { subject.must_equal :nothing }
+        end
+
+        describe 'and there are empty directories to push' do
+          before do
+            mkdir('directory')
+            mkdir('.hidden_empty')
+          end
+          it { subject.must_equal :ok }
+          it { subject ; commit_count(local_repo).must_equal 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          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 'directory' }
+          it { subject ; head_tree_files(remote_repo).must_include '.hidden_empty' }
+          it { subject ; Dir.glob("#{local_repo_path}/**/.gitignore", File::FNM_DOTMATCH).count.must_equal 2 }
+        end
+
+        describe 'and there is a directory with a hidden file' do
+          before do
+            mkdir('directory')
+            write('directory/.hidden', '')
+          end
+          it { subject.must_equal :ok }
+          it { subject ; local_file_exist?('directory', '.gitignore').must_equal false }
+          it { subject ; commit_count(local_repo).must_equal 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          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 'directory' }
+        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 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          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 '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')
+
+            # Simulate an error occurring during the push
+            Grit::Git.any_instance.stubs(:push).raises(
+              Grit::Git::CommandFailed.new('', 1, 'error message')
+            )
+          end
+          it { subject.must_equal 'error message' }
+        end
+
+        describe 'and this is nothing to push' do
+          it { subject.must_equal :nothing }
+          it { subject ; commit_count(local_repo).must_equal 0 }
+        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 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          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 1 }
+          it { subject ; commit_count(remote_repo).must_equal 1 }
+          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 'file2' }
+        end
+      end
+    end
+
+    describe 'remote exists' do
+      before { create_local_repo_with_remote_with_commit }
+
+      describe 'last sync is nil' do
+        let(:last_oid) { nil }
+
+        describe 'and there is an error on push' do
+          # Simulate an error occurring during the push
+          before do
+            Grit::Git.any_instance.stubs(:push).raises(
+              Grit::Git::CommandFailed.new('', 1, '')
+            )
+          end
+          it { subject.must_equal :nothing }
+          it { subject ; commit_count(local_repo).must_equal 1 }
         end
 
         describe 'and there is a conflicted file to push' do
@@ -304,9 +454,29 @@ describe Gitdocs::Repository do
           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')) }
+        describe 'and there are empty directories to push' do
+          before do
+            mkdir('directory')
+            mkdir('.hidden_empty')
+          end
+          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 3 }
+          it { subject ; head_tree_files(remote_repo).must_include 'file1' }
+          it { subject ; head_tree_files(remote_repo).must_include 'directory' }
+          it { subject ; head_tree_files(remote_repo).must_include '.hidden_empty' }
+          it { subject ; Dir.glob("#{local_repo_path}/**/.gitignore", File::FNM_DOTMATCH).count.must_equal 2 }
+        end
+
+        describe 'and there is a directory with a hidden file' do
+          before do
+            mkdir('directory')
+            write('directory/.hidden', '')
+          end
           it { subject.must_equal :ok }
+          it { subject ; local_file_exist?('directory', '.gitignore').must_equal false }
           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" }
@@ -354,6 +524,7 @@ describe Gitdocs::Repository do
 
         describe 'and this is nothing to push' do
           it { subject.must_equal :nothing }
+          it { subject ; commit_count(local_repo).must_equal 1 }
         end
 
         describe 'and there is a conflicted commit to push' do
@@ -505,20 +676,26 @@ describe Gitdocs::Repository do
 
     describe 'file does not include the revision' do
       let(:ref) { @commit0 }
-      it { subject ; File.read(file_name).must_equal 'beef' }
+      it { subject ; local_file_content('directory', 'file2').must_equal 'beef' }
     end
 
     describe 'file does include the revision' do
       let(:ref) { @commit2 }
-      it { subject ; File.read(file_name).must_equal "bar\n" }
+      it { subject ; local_file_content('directory', 'file2').must_equal "bar\n" }
     end
   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)
+    repo.config['user.email'] = 'afish@example.com'
+    repo.config['user.name']  = 'Art T. Fish'
+  end
+
+  def create_local_repo_with_remote_with_commit
     bare_commit(
       remote_repo,
       'file1', 'foobar',
@@ -531,13 +708,17 @@ describe Gitdocs::Repository do
     repo.config['user.name']  = 'Art T. Fish'
   end
 
+  def mkdir(*path)
+    FileUtils.mkdir_p(File.join(local_repo_path, *path))
+  end
+
   def write(filename, content)
-    FileUtils.mkdir_p(File.join(local_repo_path, File.dirname(filename)))
+    mkdir(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)))
+    mkdir(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
@@ -565,21 +746,38 @@ describe Gitdocs::Repository do
     walker = Rugged::Walker.new(repo)
     walker.push(repo.head.target)
     walker.count
+  rescue Rugged::ReferenceError
+    # The repo does not have a head => no commits.
+    0
   end
 
   def head_commit(repo)
     walker = Rugged::Walker.new(repo)
     walker.push(repo.head.target)
     walker.first
+  rescue Rugged::ReferenceError
+    # The repo does not have a head => no commits => no head commit.
+    nil
   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
+  # NOTE: This method is ignoring hidden files.
+  def local_file_count
+    files = Dir.chdir(local_repo_path) do
       Dir.glob('*')
     end
+    files.count
+  end
+
+  def local_file_exist?(*path_elements)
+    File.exist?(File.join(local_repo_path, *path_elements))
+  end
+
+  def local_file_content(*path_elements)
+    local_file_exist?(*path_elements).must_equal true
+    File.read(File.join(local_repo_path, *path_elements))
   end
 end

data/test/runner_test.rb

@@ -1,142 +1,114 @@
 require File.expand_path('../test_helper', __FILE__)
 
 describe 'gitdocs runner' do
-  before { ENV['TEST'] = 'true' }
-
-  describe 'syncing' do
-    it 'should clone files' do
-      with_clones(3) do |clone1, clone2, clone3|
-        File.open(File.join(clone1, 'test'), 'w') { |f| f << 'testing' }
-        sleep 3
-        assert_equal 'testing', File.read(File.join(clone1, 'test'))
-        assert_equal 'testing', File.read(File.join(clone2, 'test'))
-        assert_equal 'testing', File.read(File.join(clone3, 'test'))
-      end
-    end
+  let(:runner) { Gitdocs::Runner.new(share)}
+
+  let(:share)      { stub(polling_interval: 1, notification: true) }
+  let(:notifier)   { stub }
+  let(:repository) { stub(root: 'root_path') }
+  before do
+    Gitdocs::Notifier.stubs(:new).with(true).returns(notifier)
+    Gitdocs::Repository.stubs(:new).with(share).returns(repository)
+  end
 
-    it 'should resolve conflicts files' do
-      with_clones(3) do |clone1, clone2, clone3|
-        File.open(File.join(clone1, 'test.txt'), 'w') { |f| f << 'testing' }
-        sleep 3
-        File.open(File.join(clone1, 'test.txt'), 'w') { |f| f << "testing\n1" }
-        File.open(File.join(clone2, 'test.txt'), 'w') { |f| f << "testing\n2" }
-        sleep 3
-        assert_includes 2..3, Dir[File.join(clone2, '*.txt')].to_a.size
-        assert_includes 2..3, Dir[File.join(clone3, '*.txt')].to_a.size
-      end
-    end
+  describe '#root' do
+    subject { runner.root }
+    it { subject.must_equal 'root_path' }
   end
 
-  describe 'public methods' do
-    let(:runner) { Gitdocs::Runner.new(share)}
+  describe '#sync_changes' do
+    subject { runner.sync_changes }
 
-    let(:share)      { stub(polling_interval: 1, notification: true) }
-    let(:notifier)   { stub }
-    let(:repository) { stub(root: 'root_path') }
-    before do
-      Gitdocs::Notifier.stubs(:new).with(true).returns(notifier)
-      Gitdocs::Repository.stubs(:new).with(share).returns(repository)
-    end
+    before { repository.expects(:pull).returns(pull_result) }
 
-    describe '#root' do
-      subject { runner.root }
-      it { subject.must_equal 'root_path' }
+    describe 'when invalid' do
+      let(:pull_result) { nil }
+      it { subject.must_equal nil }
     end
 
-    describe '#sync_changes' do
-      subject { runner.sync_changes }
-
-      before { repository.expects(:pull).returns(pull_result) }
-
-      describe 'when invalid' do
-        let(:pull_result) { nil }
-        it { subject.must_equal nil }
-      end
-
-      describe 'when no remote present' do
-        let(:pull_result) { :no_remote }
-        it { subject.must_equal nil }
-      end
+    describe 'when no remote present' do
+      let(:pull_result) { :no_remote }
+      it { subject.must_equal nil }
+    end
 
-      describe 'when merge is conflicted' do
-        let(:pull_result) { ['file'] }
-        before do
-          notifier.expects(:warn).with(
-            'There were some conflicts',
-            "* file"
-          )
-          runner.expects(:push_changes)
-        end
-        it { subject.must_equal nil }
+    describe 'when merge is conflicted' do
+      let(:pull_result) { ['file'] }
+      before do
+        notifier.expects(:warn).with(
+          'There were some conflicts',
+          "* file"
+        )
+        runner.expects(:push_changes)
       end
+      it { subject.must_equal nil }
+    end
 
-      describe 'when merge is ok' do
-        let(:pull_result) { :ok }
-        before do
-          runner.instance_variable_set(:@last_synced_revision, :oid)
-          repository.stubs(:current_oid).returns(:next_oid)
-          repository.stubs(:author_count).with(:oid).returns('Alice' => 1, 'Bob' => 2)
-          notifier.expects(:info).with(
-            'Updated with 3 changes',
-            "In 'root_path':\n* Alice (1 change)\n* Bob (2 changes)"
-          )
-          runner.expects(:push_changes)
-        end
-        it { subject.must_equal nil }
-        it { subject ; runner.instance_variable_get(:@last_synced_revision).must_equal :next_oid }
+    describe 'when merge is ok' do
+      let(:pull_result) { :ok }
+      before do
+        runner.instance_variable_set(:@last_synced_revision, :oid)
+        repository.stubs(:current_oid).returns(:next_oid)
+        repository.stubs(:author_count).with(:oid).returns('Alice' => 1, 'Bob' => 2)
+        notifier.expects(:info).with(
+          'Updated with 3 changes',
+          "In 'root_path':\n* Alice (1 change)\n* Bob (2 changes)"
+        )
+        runner.expects(:push_changes)
       end
+      it { subject.must_equal nil }
+      it { subject ; runner.instance_variable_get(:@last_synced_revision).must_equal :next_oid }
     end
+  end
 
-    describe '#push_changes' do
-      subject { runner.push_changes }
+  describe '#push_changes' do
+    subject { runner.push_changes }
 
-      before { repository.expects(:push).returns(push_result) }
+    before { repository.expects(:push).returns(push_result) }
 
-      describe 'when invalid' do
-        let(:push_result) { nil }
-        it { subject.must_equal nil }
-      end
+    describe 'when invalid' do
+      let(:push_result) { nil }
+      it { subject.must_equal nil }
+    end
 
-      describe 'when no remote present' do
-        let(:push_result) { :no_remote }
-        it { subject.must_equal nil }
-      end
+    describe 'when no remote present' do
+      let(:push_result) { :no_remote }
+      it { subject.must_equal nil }
+    end
 
-      describe 'when nothing happened' do
-        let(:push_result) { :nothing }
-        it { subject.must_equal nil }
-      end
+    describe 'when nothing happened' do
+      let(:push_result) { :nothing }
+      it { subject.must_equal nil }
+    end
 
-      describe 'when there is an error' do
-        let(:push_result) { 'error' }
-        before do
-          notifier.expects(:error)
-            .with('BAD Could not push changes in root_path', 'error')
-        end
-        it { subject.must_equal nil }
+    describe 'when there is an error' do
+      let(:push_result) { 'error' }
+      before do
+        notifier.expects(:error)
+          .with('BAD Could not push changes in root_path', 'error')
       end
+      it { subject.must_equal nil }
+    end
 
-      describe 'when push is conflicted' do
-        let(:push_result) { :conflict }
-        before do
-          notifier.expects(:warn)
-            .with('There was a conflict in root_path, retrying', '')
-        end
-        it { subject.must_equal nil }
+    describe 'when push is conflicted' do
+      let(:push_result) { :conflict }
+      before do
+        notifier.expects(:warn)
+          .with('There was a conflict in root_path, retrying', '')
       end
+      it { subject.must_equal nil }
+    end
 
-      describe 'when merge is ok' do
-        let(:push_result) { :ok }
-        before do
-          runner.instance_variable_set(:@last_synced_revision, :oid)
-          repository.stubs(:current_oid).returns(:next_oid)
-          repository.stubs(:author_count).with(:oid).returns('Alice' => 1, 'Bob' => 2)
-          notifier.expects(:info)
-            .with('Pushed 3 changes', "'root_path' has been pushed")
-        end
-        it { subject.must_equal nil }
-        it { subject ; runner.instance_variable_get(:@last_synced_revision).must_equal :next_oid }
+    describe 'when merge is ok' do
+      let(:push_result) { :ok }
+      before do
+        runner.instance_variable_set(:@last_synced_revision, :oid)
+        repository.stubs(:current_oid).returns(:next_oid)
+        repository.stubs(:author_count).with(:oid).returns('Alice' => 1, 'Bob' => 2)
+        notifier.expects(:info)
+          .with('Pushed 3 changes', "'root_path' has been pushed")
       end
+      it { subject.must_equal nil }
+      it { subject ; runner.instance_variable_get(:@last_synced_revision).must_equal :next_oid }
     end
   end
 end

data/test/test_helper.rb

@@ -2,54 +2,4 @@ require 'rubygems'
 require 'minitest/autorun'
 $LOAD_PATH.unshift File.expand_path('../../lib')
 require 'gitdocs'
-require 'fakeweb'
 require 'mocha/setup'
-
-FakeWeb.allow_net_connect = false
-
-## Kernel Extensions
-require 'stringio'
-
-class MiniTest::Spec
-  def with_clones(count = 3)
-    FileUtils.rm_rf('/tmp/gitdocs')
-    master_path = '/tmp/gitdocs/master'
-    FileUtils.mkdir_p('/tmp/gitdocs/master')
-    ShellTools.capture { `git init /tmp/gitdocs/master --bare` }
-    sub_paths = count.times.map do |c|
-      ShellTools.capture { `cd /tmp/gitdocs && git clone file://#{master_path} #{c}` }
-      ShellTools.capture { `cd /tmp/gitdocs/#{c} && git config --local user.email "afish@example.com" && git config --local user.name "Art T. Fish"` }
-      conf_path = "/tmp/gitdocs/config/#{c}"
-      FileUtils.mkdir_p(conf_path)
-      ["/tmp/gitdocs/#{c}", conf_path]
-    end
-    pids = sub_paths.map do |(path, conf_path)|
-      fork do
-        unless ENV['DEBUG']
-          STDOUT.reopen(File.open('/dev/null', 'w'))
-          STDERR.reopen(File.open('/dev/null', 'w'))
-        end
-        begin
-          puts 'RUNNING!'
-          Gitdocs.start(config_path: conf_path) do |conf|
-            conf.global.update_attributes(load_browser_on_startup: false, start_web_frontend: false)
-            conf.add_path(path, polling_interval: 0.1, notification: false)
-          end
-        rescue
-          puts 'RATHER BAD ~~~~~'
-          puts $ERROR_INFO.message
-          puts $ERROR_INFO.backtrace.join("\n  ")
-        end
-      end
-    end
-
-    begin
-      sleep 1
-      yield sub_paths.map { |sp| sp.first }
-    ensure
-      pids.each { |pid| Process.kill('INT', pid) rescue nil }
-    end
-  ensure
-    FileUtils.rm_rf('/tmp/gitdocs') unless ENV['DEBUG']
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitdocs
 version: !ruby/object:Gem::Version
-  version: 0.5.0.pre3
+  version: 0.5.0.pre5
 platform: ruby
 authors:
 - Josh Hull
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-31 00:00:00.000000000 Z
+date: 2014-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: joshbuddy-guard