gitdocs 0.5.0.pre6 → 0.5.0.pre7

data/lib/gitdocs/rendering.rb

@@ -1,12 +1,17 @@
-# This shouldn't exist but I can't find any other way to prevent redcarpet from complaining
-# WARN: tilt autoloading 'redcarpet' in a non thread-safe way; explicit require 'redcarpet' suggested.
-# !! Unexpected error while processing request: Input must be UTF-8 or US-ASCII, ASCII-8BIT given
-# Input must be UTF-8 or US-ASCII, ASCII-8BIT given
-#   gems/redcarpet-2.0.1/lib/redcarpet.rb:70:in `render'
-#   gems/redcarpet-2.0.1/lib/redcarpet.rb:70:in `to_html'
-#   gems/tilt-1.3.3/lib/tilt/markdown.rb:38:in `evaluate'
-#   gems/tilt-1.3.3/lib/tilt/markdown.rb:61:in `evaluate'
-#   gems/tilt-1.3.3/lib/tilt/template.rb:76:in `render'
+# -*- encoding : utf-8 -*-
+
+# rubocop:disable LineLength
+
+# This should not exist but I cannot find any other way to prevent redcarpet
+# from complaining
+# > WARN: tilt autoloading 'redcarpet' in a non thread-safe way; explicit require'redcarpet' suggested.
+# > !! Unexpected error while processing request: Input must be UTF-8 or US-ASCII, ASCII-8BIT given
+# > Input must be UTF-8 or US-ASCII, ASCII-8BIT given
+# >  gems/redcarpet-2.0.1/lib/redcarpet.rb:70:in `render'
+# >  gems/redcarpet-2.0.1/lib/redcarpet.rb:70:in `to_html'
+# >  gems/tilt-1.3.3/lib/tilt/markdown.rb:38:in `evaluate'
+# >  gems/tilt-1.3.3/lib/tilt/markdown.rb:61:in `evaluate'
+# >  gems/tilt-1.3.3/lib/tilt/template.rb:76:in `render'
 
 require 'redcarpet'
 

data/lib/gitdocs/repository.rb

@@ -1,13 +1,17 @@
 # -*- encoding : utf-8 -*-
+
 require 'find'
 
+# rubocop:disable ClassLength
+# This class is long, but at the moment everything in it seems to be
+# appropriate.
+
 # Wrapper for accessing the shared git repositories.
 # 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
   attr_reader :invalid_reason
 
@@ -30,6 +34,7 @@ class Gitdocs::Repository
     @grit                 = Grit::Repo.new(path)
     Grit::Git.git_timeout = 120
     @invalid_reason       = nil
+    @commit_message_path  = abs_path('.gitmessage~')
   rescue Rugged::OSError
     @invalid_reason = :directory_missing
   rescue Rugged::RepositoryError
@@ -53,56 +58,10 @@ class Gitdocs::Repository
     repository = new(path)
     fail("Unable to clone into #{path}") unless repository.valid?
     repository
-  rescue Grit::Git::GitTimeout => e
-    fail("Unable to clone into #{path} because it timed out")
-  rescue Grit::Git::CommandFailed => e
-    fail("Unable to clone into #{path} because of #{e.err}")
-  end
-
-  RepoDescriptor = Struct.new(:name, :index)
-
-  # Search across multiple repositories
-  #
-  # @param [String] term
-  # @param [Array<Repository>} repositories
-  #
-  # @return [Hash<RepoDescriptor, Array<SearchResult>>]
-  def self.search(term, repositories)
-    results = {}
-    repositories.each_with_index do |repository, index|
-      descriptor = RepoDescriptor.new(repository.root, index)
-      results[descriptor] = repository.search(term)
-    end
-    results.delete_if { |key, value| value.empty? }
-  end
-
-  SearchResult = Struct.new(:file, :context)
-
-  # Search a single repository
-  #
-  # @param [String] term
-  #
-  # @return [Array<SearchResult>]
-  def search(term)
-    return [] if term.empty?
-
-    results = []
-    options = { raise: true, bare: false, chdir: root, ignore_case: true }
-    @grit.git.grep(options, term).scan(/(.*?):([^\n]*)/) do |(file, context)|
-      if result = results.find { |s| s.file == file }
-        result.context += ' ... ' + context
-      else
-        results << SearchResult.new(file, context)
-      end
-    end
-    results
-  rescue Grit::Git::GitTimeout => e
-    # TODO: add logging to record the error details
-    []
+  rescue Grit::Git::GitTimeout
+    raise("Unable to clone into #{path} because it timed out")
   rescue Grit::Git::CommandFailed => e
-    # TODO: add logging to record the error details if they are not just
-      # nothing found
-    []
+    raise("Unable to clone into #{path} because of #{e.err}")
   end
 
   # @return [String]
@@ -138,107 +97,113 @@ class Gitdocs::Repository
     nil
   end
 
-  # Fetch and merge the repository
+  # Is the working directory dirty
   #
-  # @raise [RuntimeError] if there is a problem processing conflicted files
+  # @return [Boolean]
+  def dirty?
+    return false unless valid?
+
+    return Dir.glob(abs_path('*')).any? unless current_oid
+    @rugged.diff_workdir(current_oid, include_untracked: true).deltas.any?
+  end
+
+  # @return [Boolean]
+  def need_sync?
+    return false unless valid?
+    return false unless remote?
+
+    return !!current_oid unless remote_branch # rubocop:disable DoubleNegation
+    remote_branch.tip.oid != current_oid
+  end
+
+  # @param [String] term
+  # @yield [file, context] Gives the files and context for each of the results
+  # @yieldparam file [String]
+  # @yieldparam context [String]
+  def grep(term, &block)
+    @grit.git.grep(
+      { raise: true, bare: false, chdir: root, ignore_case: true },
+      term
+    ).scan(/(.*?):([^\n]*)/, &block)
+  rescue Grit::Git::GitTimeout
+    # TODO: add logging to record the error details
+    ''
+  rescue Grit::Git::CommandFailed
+    # TODO: add logging to record the error details if they are not just
+    # nothing found
+    ''
+  end
+
+  # Fetch all the remote branches
   #
   # @return [nil] if the repository is invalid
   # @return [:no_remote] if the remote is not yet set
   # @return [String] if there is an error return the message
-  # @return [Array<String>] if there is a conflict return the Array of
-  #   conflicted file names
-  # @return [:ok] if pulled and merged with no errors or conflicts
-  def pull
+  # @return [:ok] if the fetch worked
+  def fetch
     return nil unless valid?
-    return :no_remote unless has_remote?
-
-    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 :no_remote unless remote?
 
-    return :ok if remote_branch.nil? || remote_branch.tip.oid == current_oid
+    @rugged.remotes.each { |x| @grit.remote_fetch(x.name) }
+    :ok
+  rescue Grit::Git::GitTimeout
+    "Fetch timed out for #{root}"
+  rescue Grit::Git::CommandFailed => e
+    e.err
+  end
 
-    @grit.git.merge({ raise: true, chdir: root }, "#{@remote_name}/#{@branch_name}")
+  # Merge the repository
+  #
+  # @return [nil] if the repository is invalid
+  # @return [:no_remote] if the remote is not yet set
+  # @return [String] if there is an error return the message
+  # @return [Array<String>] if there is a conflict return the Array of
+  #   conflicted file names
+  # @return [:ok] if the merged with no errors or conflicts
+  def merge
+    return nil        unless valid?
+    return :no_remote unless remote?
+
+    return :ok        unless remote_branch
+    return :ok        if 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}"
+    "Merge 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?
-
-    # Collect all the index entries by their paths.
-    index_path_entries = Hash.new { |h, k| h[k] = Array.new }
-    @rugged.index.map do |index_entry|
-      index_path_entries[index_entry[:path]].push(index_entry)
-    end
-
-    # Filter to only the conflicted entries.
-    conflicted_path_entries = index_path_entries.delete_if { |_k, v| v.length == 1 }
-
-    conflicted_path_entries.each_pair do |path, index_entries|
-      # Write out the different versions of the conflicted file.
-      index_entries.each 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
-      end
-
-      # And remove the original.
-      FileUtils.remove(File.join(root, path), force: true)
-    end
-
-    # NOTE: Let commit be handled by the next regular commit.
-
-    conflicted_path_entries.keys
+    mark_conflicts
   end
 
   # Commit the working directory
   #
-  # @param [String] message
-  #
   # @return [nil] if the repository is invalid
   # @return [Boolean] whether a commit was made or not
-  def commit(message)
+  def commit
     return nil unless valid?
 
-    # Mark any empty directories so they will be committed
-    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
+    # Do this first to allow the message file to be deleted, if it exists.
+    message = read_and_delete_commit_message_file
 
-    # 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
+    mark_empty_directories
+
+    return false unless dirty?
 
     # 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)
-      true
-    else
-      false
+    Dir.chdir(root) do
+      @rugged.index.add_all
+      @rugged.index.update_all
     end
+    @rugged.index.write
+    @grit.commit_index(message)
+    true
   end
 
   # Push the repository
@@ -250,21 +215,16 @@ class Gitdocs::Repository
   # @return [:ok] if committed and pushed without errors or conflicts
   def push
     return nil unless valid?
-    return :no_remote unless has_remote?
+    return :no_remote unless remote?
 
     return :nothing if current_oid.nil?
+    return :nothing if remote_branch && remote_branch.tip.oid == current_oid
 
-    if remote_branch.nil? || remote_branch.tip.oid != current_oid
-      begin
-        @grit.git.push({ raise: true }, @remote_name, @branch_name)
-        :ok
-      rescue Grit::Git::CommandFailed => e
-        return :conflict if e.err[/\[rejected\]/]
-        e.err # return the output on error
-      end
-    else
-      :nothing
-    end
+    @grit.git.push({ raise: true }, @remote_name, @branch_name)
+    :ok
+  rescue Grit::Git::CommandFailed => e
+    return :conflict if e.err[/\[rejected\]/]
+    e.err # return the output on error
   end
 
   # Get the count of commits by author from the head to the specified oid.
@@ -275,7 +235,7 @@ class Gitdocs::Repository
   def author_count(last_oid)
     walker = head_walker
     walker.hide(last_oid) if last_oid
-    walker.inject(Hash.new(0)) do |result, commit|
+    walker.reduce(Hash.new(0)) do |result, commit|
       result["#{commit.author[:name]} <#{commit.author[:email]}>"] += 1
       result
     end
@@ -285,101 +245,51 @@ class Gitdocs::Repository
     {}
   end
 
-  # Returns file meta data based on relative file path
-  #
-  # @example
-  #  file_meta("path/to/file")
-  #  => { :author => "Nick", :size => 1000, :modified => ... }
-  #
-  # @param [String] file relative path to file in repository
-  #
-  # @raise [RuntimeError] if the file is not found in any commits
-  #
-  # @return [Hash<Symbol=>String,Integer,Time>] the author, size and
-  #   modification date of the file
-  def file_meta(file)
-    file = file.gsub(%r{^/}, '')
-
-    commit = head_walker.find { |x| x.diff(paths: [file]).size > 0 }
-
-    fail "File #{file} not found" unless commit
-
-    full_path = File.expand_path(file, root)
-    size = if File.directory?(full_path)
-      Dir[File.join(full_path, '**', '*')].reduce(0) do |size, file|
-        File.symlink?(file) ? size : size += File.size(file)
-      end
-    else
-      File.symlink?(full_path) ? 0 : File.size(full_path)
-    end
-    size = -1 if size == 0 # A value of 0 breaks the table sort for some reason
+  # @param [String] message
+  def write_commit_message(message)
+    return unless message
+    return if message.empty?
 
-    { author: commit.author[:name], size: size, modified: commit.author[:time] }
+    File.open(@commit_message_path, 'w') { |f| f.print(message) }
   end
 
-  # Returns the revisions available for a particular file
+  # Excluding the initial commit (without a parent) which keeps things
+  # consistent with the original behaviour.
+  # TODO: reconsider if this is the correct behaviour
   #
-  # @example
-  #   file_revisions("README")
+  # @param [String] relative_path
+  # @param [Integer] limit the number of commits which will be returned
   #
-  # @param [String] file
-  #
-  # @return [Array<Hash>]
-  def file_revisions(file)
-    file = file.gsub(%r{^/}, '')
-    # Excluding the initial commit (without a parent) which keeps things
-    # consistent with the original behaviour.
-    # TODO: reconsider if this is the correct behaviour
-    head_walker.select{|x| x.parents.size == 1 && x.diff(paths: [file]).size > 0 }
-      .first(100)
-      .map do |commit|
-        {
-          commit:  commit.oid[0, 7],
-          subject: commit.message.split("\n")[0],
-          author:  commit.author[:name],
-          date:    commit.author[:time]
-        }
-      end
+  # @return [Array<Rugged::Commit>]
+  def commits_for(relative_path, limit)
+    # TODO: should add a filter here for checking that the commit actually has
+    # an associated blob.
+    commits = head_walker.select do |commit|
+      commit.parents.size == 1 && commit.diff(paths: [relative_path]).size > 0
+    end
+    # TODO: should re-write this limit in a way that will skip walking all of
+    # the commits.
+    commits.first(limit)
   end
 
-  # Put the contents of the specified file revision into a temporary file
-  #
-  # @example
-  #   file_revision_at("README", "a4c56h")
-  #   => "/tmp/some/path/README"
-  #
-  # @param [String] file
-  # @param [String] ref
+  # @param [String] relative_path
   #
-  # @return [String] path of the temporary file
-  def file_revision_at(file, ref)
-    file = file.gsub(%r{^/}, '')
-    content = @rugged.blob_at(ref, file).text
-    tmp_path = File.expand_path(File.basename(file), Dir.tmpdir)
-    File.open(tmp_path, 'w') { |f| f.puts content }
-    tmp_path
+  # @return [Rugged::Commit]
+  def last_commit_for(relative_path)
+    head_walker.find { |commit| commit.diff(paths: [relative_path]).size > 0 }
   end
 
-  # Revert file to the specified ref
-  #
-  # @param [String] file
-  # @param [String] ref
-  def file_revert(file, ref)
-    file = file.gsub(%r{^/}, '')
-    blob = @rugged.blob_at(ref, file)
-    # Silently fail if the file/ref do not existing in the repository.
-    # Which is consistent with the original behaviour.
-    # TODO: should consider throwing an exception on this condition
-    return unless blob
-
-    File.open(File.expand_path(file, root), 'w') { |f| f.puts(blob.text) }
+  # @param [String] relative_path
+  # @param [String] oid
+  def blob_at(relative_path, ref)
+    @rugged.blob_at(ref, relative_path)
   end
 
   ##############################################################################
 
   private
 
-  def has_remote?
+  def remote?
     @rugged.remotes.any?
   end
 
@@ -400,4 +310,58 @@ class Gitdocs::Repository
     walker.push(@rugged.head.target)
     walker
   end
+
+  def read_and_delete_commit_message_file
+    return 'Auto-commit from gitdocs' unless File.exist?(@commit_message_path)
+
+    message = File.read(@commit_message_path)
+    File.delete(@commit_message_path)
+    message
+  end
+
+  def mark_empty_directories
+    Find.find(root).each do |path| # rubocop:disable Style/Next
+      Find.prune if File.basename(path) == '.git'
+      if File.directory?(path) && Dir.entries(path).count == 2
+        FileUtils.touch(File.join(path, '.gitignore'))
+      end
+    end
+  end
+
+  def mark_conflicts
+    # assert(@rugged.index.conflicts?)
+
+    # Collect all the index entries by their paths.
+    index_path_entries = Hash.new { |h, k| h[k] = Array.new }
+    @rugged.index.map do |index_entry|
+      index_path_entries[index_entry[:path]].push(index_entry)
+    end
+
+    # Filter to only the conflicted entries.
+    conflicted_path_entries = index_path_entries.delete_if { |_k, v| v.length == 1 }
+
+    conflicted_path_entries.each_pair do |path, index_entries|
+      # Write out the different versions of the conflicted file.
+      index_entries.each 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(abs_path(new_filename), 'wb') do |f|
+          f.write(Rugged::Blob.lookup(@rugged, index_entry[:oid]).content)
+        end
+      end
+
+      # And remove the original.
+      FileUtils.remove(abs_path(path), force: true)
+    end
+
+    # NOTE: Let commit be handled by the next regular commit.
+
+    conflicted_path_entries.keys
+  end
+
+  def abs_path(*path)
+    File.join(root, *path)
+  end
 end