gitdocs 0.5.0.pre6 → 0.5.0.pre7

data/lib/gitdocs/repository/path.rb

@@ -0,0 +1,166 @@
+# -*- encoding : utf-8 -*-
+
+# Class for executing File and Git operations on a specific path in the
+# repository.
+class Gitdocs::Repository::Path
+  attr_reader :relative_path
+
+  # @param [Gitdocs::Repository] repository
+  # @param [String] relative_path
+  def initialize(repository, relative_path)
+    @repository    = repository
+    @relative_path = relative_path.gsub(/^\//, '')
+    @absolute_path = File.join(
+      File.absolute_path(@repository.root), @relative_path
+    )
+  end
+
+  # Write the content to the path and create any necessary directories.
+  #
+  # @param [String] content
+  # @param [String] commit_message
+  def write(content, commit_message)
+    FileUtils.mkdir_p(File.dirname(@absolute_path))
+    File.open(@absolute_path, 'w') { |f| f.puts(content) }
+
+    @repository.write_commit_message(commit_message)
+  end
+
+  # Touch and path and create any necessary directories.
+  def touch
+    FileUtils.mkdir_p(File.dirname(@absolute_path))
+    FileUtils.touch(@absolute_path)
+  end
+
+  # Create the path as a directory.
+  def mkdir
+    FileUtils.mkdir_p(@absolute_path)
+  end
+
+  # Remove the path, but only if it is a file.
+  def remove
+    return nil unless File.file?(@absolute_path)
+    FileUtils.rm(@absolute_path)
+  end
+
+  # @return [Boolean]
+  def text?
+    return false unless File.file?(@absolute_path)
+    mime_type = File.mime_type?(File.open(@absolute_path))
+    !!(mime_type =~ /text\/|x-empty/) # rubocop:disable DoubleNegation
+  end
+
+  # Returns file meta data based on relative file path
+  #
+  # @example
+  #  meta
+  #  => { :author => "Nick", :size => 1000, :modified => ... }
+  #
+  # @raise [RuntimeError] if the file is not found in any commits
+  #
+  # @return [Hash<:author => String, :size => Integer, modified => Time>]
+  def meta
+    commit = @repository.last_commit_for(@relative_path)
+
+    # FIXME: This should actually just return an empty hash
+    fail("File #{@relative_path} not found") unless commit
+
+    {
+      author:   commit.author[:name],
+      size:     total_size,
+      modified: commit.author[:time]
+    }
+  end
+
+  def exist?
+    File.exist?(@absolute_path)
+  end
+
+  def directory?
+    File.directory?(@absolute_path)
+  end
+
+  def absolute_path(ref = nil)
+    return @absolute_path unless ref
+
+    blob    = @repository.blob_at(@relative_path, ref)
+    content = blob ? blob.text : ''
+    tmp_path = File.expand_path(File.basename(@relative_path), Dir.tmpdir)
+    File.open(tmp_path, 'w') { |f| f.puts content }
+    tmp_path
+  end
+
+  def readme_path
+    return nil unless directory?
+    Dir.glob(File.join(@absolute_path, 'README.{md}')).first
+  end
+
+  DirEntry = Struct.new(:name, :is_directory)
+
+  # @return [Array<DirEntry>] entries in the directory
+  #   * excluding any git related directories
+  #   * sorted by filename, ignoring any leading '.'s
+  def file_listing
+    return nil unless directory?
+
+    Dir.glob(File.join(@absolute_path, '{*,.*}'))
+      .reject  { |x| x.match(/\/\.(\.|git|gitignore|gitmessage~)?$/) }
+      .sort_by { |x| File.basename(x).sub(/^\./, '') }
+      .map     { |x| DirEntry.new(File.basename(x), File.directory?(x)) }
+  end
+
+  def content
+    return nil unless File.file?(@absolute_path)
+    File.read(@absolute_path)
+  end
+
+  # Returns the revisions available for a particular file
+  #
+  # @param [String] file
+  #
+  # @return [Array<Hash>]
+  def revisions
+    @repository.commits_for(@relative_path, 100).map do |commit|
+      {
+        commit:  commit.oid[0, 7],
+        subject: commit.message.split("\n")[0],
+        author:  commit.author[:name],
+        date:    commit.author[:time]
+      }
+    end
+  end
+
+  # Revert file to the specified ref
+  #
+  # @param [String] ref
+  def revert(ref)
+    return unless ref
+
+    blob = @repository.blob_at(@relative_path, ref)
+    # 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
+
+    write(blob.text, "Reverting '#{@relative_path}' to #{ref}")
+  end
+
+  #############################################################################
+
+  private
+
+  def total_size
+    result =
+      if File.directory?(@absolute_path)
+        Dir[File.join(@absolute_path, '**', '*')].reduce(0) do |size, filename|
+          File.symlink?(filename) ? size : size + File.size(filename)
+        end
+      else
+        File.symlink?(@absolute_path) ? 0 : File.size(@absolute_path)
+      end
+
+    # HACK: A value of 0 breaks the table sort for some reason
+    return -1 if result == 0
+    result
+  end
+end

data/lib/gitdocs/runner.rb

@@ -1,3 +1,5 @@
+# -*- encoding : utf-8 -*-
+
 module Gitdocs
   class Runner
     def self.start_all(shares)
@@ -40,14 +42,16 @@ module Gitdocs
       # Listen for changes in local repository
 
       EM.defer(proc do
-        listener = Guard::Listener.select_and_init(root, watch_all_modifications: true)
+        listener = Guard::Listener.select_and_init(
+          root, watch_all_modifications: true
+        )
         listener.on_change do |directories|
           directories.uniq!
           directories.delete_if { |d| d =~ /\/\.git/ }
           unless directories.empty?
             EM.next_tick do
               EM.defer(proc do
-                mutex.synchronize { push_changes }
+                mutex.synchronize { sync_changes }
               end, proc {})
             end
           end
@@ -61,70 +65,33 @@ module Gitdocs
     end
 
     def sync_changes
-      result = @repository.pull
-
-      return if result.nil? || result == :no_remote
-
-      if result.kind_of?(String)
-        @notifier.error(
-          'There was a problem synchronizing this gitdoc',
-          "A problem occurred in #{root}:\n#{result}"
-        )
-        return
-      end
+      # Commit #################################################################
+      @repository.commit if @share.sync_type == 'full'
 
-      if result == :ok
-        author_change_count = latest_author_count
-        unless author_change_count.empty?
-          author_list = author_change_count.map { |author, count| "* #{author} (#{change_count(count)})" }.join("\n")
-          @notifier.info(
-            "Updated with #{change_count(author_change_count)}",
-            "In '#{root}':\n#{author_list}"
-          )
-        end
-      else
-        #assert result.kind_of?(Array)
-        @notifier.warn(
-          'There were some conflicts',
-          result.map { |f| "* #{f}" }.join("\n")
-        )
-      end
+      # Fetch ##################################################################
+      fetch_result = @repository.fetch
+      return unless fetch_result == :ok
+      return if @share.sync_type == 'fetch'
 
-      push_changes
-    end
+      # Merge ##################################################################
+      merge_result = @repository.merge
+      merge_result = latest_author_count if merge_result == :ok
+      @notifier.merge_notification(merge_result, root)
+      return if merge_result.is_a?(String)
 
-    def push_changes
-      message_file = File.expand_path('.gitmessage~', root)
-      if File.exist?(message_file)
-        message = File.read(message_file)
-        File.delete(message_file)
-      else
-        message = 'Auto-commit from gitdocs'
-      end
-
-      @repository.commit(message)
+      # Push ###################################################################
       result = @repository.push
-
-      return if result.nil? || result == :no_remote || result == :nothing
-      level, title, message = case result
-      when :ok       then [:info, "Pushed #{change_count(latest_author_count)}", "'#{root}' has been pushed"]
-      when :conflict then [:warn, "There was a conflict in #{root}, retrying", '']
-      else
-        # assert result.kind_of?(String)
-        [:error, "BAD Could not push changes in #{root}", result]
-        # TODO: need to add a status on shares so that the push problem can be
-        # displayed.
-      end
-      @notifier.send(level, title, message)
+      result = latest_author_count if result == :ok
+      @notifier.push_notification(result, root)
     rescue => e
       # Rescue any standard exceptions which come from the push related
       # commands. This will prevent problems on a single share from killing
       # the entire daemon.
-      @notifier.error("Unexpected error pushing changes in #{root}", "#{e}")
-      # TODO: get logging and/or put the error message into a status field in the database
+      @notifier.error("Unexpected error syncing changes in #{root}", "#{e}")
     end
 
     ############################################################################
+
     private
 
     # Update the author count for the last synced changes, and then update the
@@ -137,15 +104,5 @@ module Gitdocs
 
       @repository.author_count(last_oid)
     end
-
-    def change_count(count_or_hash)
-      count = if count_or_hash.respond_to?(:values)
-        count_or_hash .values.reduce(:+)
-      else
-        count_or_hash
-      end
-
-      "#{count} change#{count == 1 ? '' : 's'}"
-    end
   end
 end

data/lib/gitdocs/search.rb

@@ -0,0 +1,35 @@
+class Gitdocs::Search
+  RepoDescriptor = Struct.new(:name, :index)
+  SearchResult   = Struct.new(:file, :context)
+
+  # @param [Array<Gitdocs::Repository>] repositories
+  def initialize(repositories)
+    @repositories = repositories
+  end
+
+  def search(term)
+    results = {}
+    @repositories.each_with_index do |repository, index|
+      descriptor = RepoDescriptor.new(repository.root, index)
+      results[descriptor] = search_repository(repository, term)
+    end
+    results.delete_if { |_key, value| value.empty? }
+  end
+
+  private
+
+  def search_repository(repository, term)
+    return [] if term.empty?
+
+    results = []
+    repository.grep(term) do |file, context|
+      result = results.find { |s| s.file == file }
+      if result
+        result.context += ' ... ' + context
+      else
+        results << SearchResult.new(file, context)
+      end
+    end
+    results
+  end
+end

data/lib/gitdocs/server.rb

@@ -1,3 +1,11 @@
+# -*- encoding : utf-8 -*-
+
+# Disable style checks that are invalid for Renee
+# rubocop:disable Blocks, MultilineBlockChain
+#
+# TODO: extract the WebApp into its own class but until then...
+# rubocop:disable LineLength, ClassLength, CyclomaticComplexity, BlockNesting
+
 require 'thin'
 require 'renee'
 require 'coderay'
@@ -12,6 +20,17 @@ module Gitdocs
       @manager      = manager
       @port         = port.to_i
       @repositories = repositories
+      @search       = Gitdocs::Search.new(repositories)
+    end
+
+    def self.start_and_wait(manager, override_port, repositories)
+      return false unless manager.start_web_frontend
+
+      web_port = override_port || manager.web_frontend_port
+      server = Server.new(manager, web_port, repositories)
+      server.start
+      server.wait_for_start
+      true
     end
 
     def start
@@ -19,134 +38,152 @@ module Gitdocs
       manager      = @manager
       Thin::Logging.debug = @manager.debug
       Thin::Server.start('127.0.0.1', @port) do
-        use Rack::Static, urls: ['/css', '/js', '/img', '/doc'], root: File.expand_path('../public', __FILE__)
+        use Rack::Static, urls: %w(/css /js /img /doc), root: File.expand_path('../public', __FILE__)
         use Rack::MethodOverride
         run Renee {
           if request.path_info == '/'
-            if manager.config.shares.size == 1
+            if manager.shares.size == 1
               redirect! '/0'
             else
-              render! 'home', layout: 'app', locals: { conf: manager.config, nav_state: 'home' }
+              render!(
+                'home',
+                layout: 'app',
+                locals: { shares: manager.shares, nav_state: 'home' }
+              )
             end
           else
             path 'settings' do
-              get.render! 'settings', layout: 'app', locals: { conf: manager.config, nav_state: 'settings' }
+              get.render!(
+                'settings',
+                layout: 'app',
+                locals: { conf: manager, nav_state: 'settings' }
+              )
               post do
-                shares = manager.config.shares
-                manager.config.global.update_attributes(request.POST['config'])
-                request.POST['share'].each do |idx, share|
-                  if remote_branch = share.delete('remote_branch')
-                    share['remote_name'], share['branch_name'] = remote_branch.split('/', 2)
-                  end
-                  # Update paths
-                  if share['path'] && !share['path'].empty?
-                    shares[Integer(idx)].update_attributes(share)
-                  end
-                end
-                EM.add_timer(0.1) { manager.restart }
+                manager.update_all(request.POST)
                 redirect! '/settings'
               end
             end
 
             path('search').get do
-              render! 'search', layout: 'app', locals: { conf: manager.config, results: Gitdocs::Repository.search(request.GET['q'], repositories), nav_state: nil }
+              render!(
+                'search',
+                layout: 'app',
+                locals: { results: @search.search(request.GET['q']), nav_state: nil }
+              )
             end
 
             path('shares') do
-              post do
-                Configuration::Share.create
-                redirect! '/settings'
-              end
-
               var(:int) do |id|
                 delete do
-                  share = manager.config.shares.find { |s| s.id == id }
-                  halt 404 if share.nil?
-                  share.destroy
-                  redirect! '/settings'
+                  halt(404) unless manager.remove_by_id(id)
+                  redirect!('/settings')
                 end
               end
             end
 
             var :int do |idx|
-              repository = repositories[idx]
+              halt(404) unless repositories[idx]
+              path = Gitdocs::Repository::Path.new(
+                repositories[idx], URI.unescape(request.path_info)
+              )
+
+              mode   = request.params['mode']
+              default_locals = {
+                idx:       idx,
+                root:      repositories[idx].root,
+                nav_state: nil
+              }
 
-              halt 404 if repository.nil?
-              file_path = URI.unescape(request.path_info)
-              expanded_path = File.expand_path(".#{file_path}", repository.root)
-              message_file = File.expand_path('.gitmessage~', repository.root)
-              halt 400 unless expanded_path[/^#{Regexp.quote(repository.root)}/]
-              parent = File.dirname(file_path)
-              parent = '' if parent == '/'
-              parent = nil if parent == '.'
-              locals = { idx: idx, parent: parent, root: repository.root, file_path: expanded_path, nav_state: nil }
-              mime = File.mime_type?(File.open(expanded_path)) if File.file?(expanded_path)
-              mode = request.params['mode']
               if mode == 'meta' # Meta
-                halt 200, { 'Content-Type' => 'application/json' }, [repository.file_meta(file_path).to_json]
+                halt 200, { 'Content-Type' => 'application/json' }, [path.meta.to_json]
               elsif mode == 'save' # Saving
-                File.open(expanded_path, 'w') { |f| f.print request.params['data'] }
-                File.open(message_file, 'w') { |f| f.print request.params['message'] } unless request.params['message'] == ''
-                redirect! '/' + idx.to_s + file_path
+                path.write(request.params['data'], request.params['message'])
+                redirect!("/#{idx}/#{path.relative_path}")
               elsif mode == 'upload'  # Uploading
-                halt 404 unless file = request.params['file']
-                tempfile, filename = file[:tempfile], file[:filename]
-                FileUtils.mv(tempfile.path, File.expand_path(filename, expanded_path))
-                redirect! '/' + idx.to_s + file_path + '/' + filename
-              elsif !File.exist?(expanded_path) && !request.params['dir'] # edit for non-existent file
-                FileUtils.mkdir_p(File.dirname(expanded_path))
-                FileUtils.touch(expanded_path)
-                redirect!  '/' + idx.to_s + file_path + '?mode=edit'
-              elsif !File.exist?(expanded_path) && request.params['dir'] # create directory
-                FileUtils.mkdir_p(expanded_path)
-                redirect!  '/' + idx.to_s + file_path
-              elsif File.directory?(expanded_path) # list directory
-                contents =  Dir[File.join(expanded_path, '*')].map { |x| Docfile.new(x) }
-                rendered_readme = nil
-                if readme = Dir[File.expand_path('README.{md}', expanded_path)].first
-                  rendered_readme = '<h3>' + File.basename(readme) + '</h3><div class="tilt">' + render(readme) + '</div>'
-                end
-                render! 'dir', layout: 'app', locals: locals.merge(contents: contents, rendered_readme: rendered_readme)
+                file = request.params['file']
+                halt 404 unless file
+                tempfile = file[:tempfile]
+                filename = file[:filename]
+                FileUtils.mv(tempfile.path, path.absolute_path)
+                redirect!("/#{idx}/#{path.relative_path}/#{filename}")
+              elsif !path.exist? && !request.params['dir'] # edit for non-existent file
+                path.touch
+                redirect!("/#{idx}/#{path.relative_path}?mode=edit")
+              elsif !path.exist? && request.params['dir'] # create directory
+                path.mkdir
+                redirect!("/#{idx}/#{path.relative_path}")
+              elsif path.directory? # list directory
+                rendered_readme =
+                  if path.readme_path
+                    <<-EOS.gusb(/^\s+/, '')
+                      <h3>#{File.basename(path.readme_path)}</h3>
+                      <div class="tilt">#{render(path.readme_path)}</div>
+                    EOS
+                  else
+                    nil
+                  end
+                render!(
+                  'dir',
+                  layout: 'app',
+                  locals: default_locals.merge(
+                    contents:        path.file_listing,
+                    rendered_readme: rendered_readme
+                  )
+                )
               elsif mode == 'revisions' # list revisions
-                revisions = repository.file_revisions(file_path)
-                render! 'revisions', layout: 'app', locals: locals.merge(revisions: revisions)
+                render!(
+                  'revisions',
+                  layout: 'app',
+                  locals: default_locals.merge(revisions: path.revisions)
+                )
               elsif mode == 'revert' # revert file
-                if revision = request.params['revision']
-                  File.open(message_file, 'w') { |f| f.print "Reverting '#{file_path}' to #{revision}" }
-                  repository.file_revert(file_path, revision)
-                end
-                redirect! '/' + idx.to_s + file_path
+                path.revert(request.params['revision'])
+                redirect!("/#{idx}/#{path.relative_path}")
               elsif mode == 'delete' # delete file
-                FileUtils.rm(expanded_path)
-                redirect! '/' + idx.to_s + parent
-              elsif mode == 'edit' && (mime.match(%r{text/}) || mime.match(%r{x-empty})) # edit file
-                contents = File.read(expanded_path)
-                render! 'edit', layout: 'app', locals: locals.merge(contents: contents)
+                path.remove
+                parent = File.dirname(path.relative_path)
+                parent = '' if parent == '/'
+                parent = nil if parent == '.'
+                redirect!("/#{idx}#{parent}")
+              elsif mode == 'edit' && path.text? # edit file
+                render!(
+                  'edit',
+                  layout: 'app',
+                  locals: default_locals.merge(contents: path.content)
+                )
               elsif mode != 'raw' # render file
-                revision = request.params['revision']
-                expanded_path = repository.file_revision_at(file_path, revision) if revision
-                begin # attempting to render file
-                  contents = '<div class="tilt">' + render(expanded_path) + '</div>'
-                rescue RuntimeError # not tilt supported
-                  contents = if mime.match(%r{text/})
-                    '<pre class="CodeRay">' + CodeRay.scan_file(expanded_path).encode(:html) + '</pre>'
-                  else
-                    %|<embed class="inline-file" src="/#{idx}#{request.path_info}?mode=raw"></embed>|
+                revision_path = path.absolute_path(request.params['revision'])
+                contents =
+                  begin # attempting to render file
+                    %(<div class="tilt">#{render(revision_path)}</div>)
+                  rescue RuntimeError # not tilt supported
+                    if path.text?
+                      <<-EOS.gsub(/^\s+/, '')
+                        <pre class="CodeRay">
+                          #{CodeRay.scan_file(revision_path).encode(:html)}
+                        </pre>
+                      EOS
+                    else
+                      %(<embed class="inline-file" src="/#{idx}#{request.path_info}?mode=raw"></embed>)
+                    end
                   end
-                end
-                render! 'file', layout: 'app', locals: locals.merge(contents: contents)
+                render!(
+                  'file',
+                  layout: 'app',
+                  locals: default_locals.merge(contents: contents)
+                )
               else # other file
-                run! Rack::File.new(repository.root)
+                run! Rack::File.new(repositories[idx].root)
               end
             end
           end
         }.setup {
-          views_path File.expand_path('../views', __FILE__)
+          views_path(File.expand_path('../views', __FILE__))
         }
       end
     end
 
-    def wait_for_start_and_open(restarting)
+    def wait_for_start
       wait_for_web_server = proc do
         i = 0
         begin