siuying-gitdocs 0.4.14.md

data/lib/gitdocs/public/js/util.js

@@ -0,0 +1,145 @@
+Utils = {
+  getKeys : function(hash) {
+    var keys = [];
+    for(var i in hash) {
+      keys.push(i);
+    }
+    return keys;
+  },
+
+  getValues : function(hash) {
+    var values = [];
+    for(var i in hash) {
+      values.push(hash[i]);
+    }
+    return values;
+  },
+  // humanizeBytes(1234)
+  humanizeBytes : function(filesize) {
+    if (filesize == null || filesize <= 0 || filesize == "") { return "&mdash;" }
+    if (filesize >= 1073741824) {
+         filesize = Utils.number_format(filesize / 1073741824, 2, '.', '') + ' Gb';
+    } else {
+      if (filesize >= 1048576) {
+          filesize = Utils.number_format(filesize / 1048576, 2, '.', '') + ' Mb';
+      } else {
+        if (filesize >= 1024) {
+          filesize = Utils.number_format(filesize / 1024, 0) + ' Kb';
+        } else {
+          filesize = Utils.number_format(filesize, 0) + ' bytes';
+        };
+      };
+    };
+    return filesize;
+  },
+  number_format : function( number, decimals, dec_point, thousands_sep ) {
+      var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
+      var d = dec_point == undefined ? "," : dec_point;
+      var t = thousands_sep == undefined ? "." : thousands_sep, s = n < 0 ? "-" : "";
+      var i = parseInt(n = Math.abs(+n || 0).toFixed(c)) + "", j = (j = i.length) > 3 ? j % 3 : 0;
+      return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");
+  }
+};
+
+// Strings
+StringFormatter = {
+  // autolink text within a plain text file
+  // apply to the wrapper around any text (.autolink)
+  autoLink : function() {
+    $('.autolink:not(.linked)').each(function(index, item) {
+      var result = $(item).html().toString() + ' ';
+      $(result.match(/(https?.*?)[^<\s]*/gm)).each(function(index, linkString) {
+        var link = "<a href='" + linkString + "' target='_blank'>" + linkString + "</a>";
+        result = result.replace(linkString, link);
+        $(item).addClass('linked');
+      });
+      $(item).html(result.slice(0, -1));
+    });
+  }
+};
+
+// DATES
+// RelativeDate.time_ago_in_words(date)
+var RelativeDate = {
+  time_ago_in_words: function(from) {
+          return RelativeDate.distance_of_time_in_words(new Date, RelativeDate.parseISO8601(from));
+
+  },
+  distance_of_time_in_words: function(to, from) {
+      var distance_in_seconds = ((to - from) / 1000);
+      var distance_in_minutes = Math.floor(distance_in_seconds / 60);
+
+      if (distance_in_minutes <= 0) { return 'less than a minute ago'; }
+      if (distance_in_minutes == 1) { return 'a minute ago'; }
+      if (distance_in_minutes < 45) { return distance_in_minutes + ' minutes ago'; }
+      if (distance_in_minutes < 120) { return '1 hour ago'; }
+      if (distance_in_minutes < 1440) { return Math.floor(distance_in_minutes / 60) + ' hours ago'; }
+      if (distance_in_minutes < 2880) { return '1 day ago'; }
+      if (distance_in_minutes < 43200) { return Math.floor(distance_in_minutes / 1440) + ' days ago'; }
+      if (distance_in_minutes < 86400) { return '1 month ago'; }
+      if (distance_in_minutes < 525960) { return Math.floor(distance_in_minutes / 43200) + ' months ago'; }
+      if (distance_in_minutes < 1051199) { return 'about 1 year ago'; }
+
+      return 'over ' + Math.floor(distance_in_minutes / 525960) + ' years ago';
+  },
+  parseISO8601 : function(str) {
+   // we assume str is a UTC date ending in 'Z'
+
+   var parts = str.split('T'),
+   dateParts = parts[0].split('-'),
+   timeParts = parts[1].split('Z'),
+   timeSubParts = timeParts[0].split(':'),
+   timeSecParts = timeSubParts[2].split('.'),
+   timeHours = Number(timeSubParts[0]),
+   _date = new Date;
+
+   _date.setUTCFullYear(Number(dateParts[0]));
+   _date.setUTCMonth(Number(dateParts[1])-1);
+   _date.setUTCDate(Number(dateParts[2]));
+   _date.setUTCHours(Number(timeHours));
+   _date.setUTCMinutes(Number(timeSubParts[1]));
+   _date.setUTCSeconds(Number(timeSecParts[0]));
+   if (timeSecParts[1]) _date.setUTCMilliseconds(Number(timeSecParts[1]));
+
+   // by using setUTC methods the date has already been converted to local time(?)
+   return _date;
+  },
+  humanize : function(str, shortened) {
+    var parts = str.split('T')[0].split('-')
+    var humDate = new Date;
+
+    humDate.setFullYear(Number(parts[0]));
+    humDate.setMonth(Number(parts[1])-1);
+    humDate.setDate(Number(parts[2]));
+
+    switch(humDate.getDay())
+    {
+    case 0:
+      var day = "Sunday";
+      break;
+    case 1:
+      var day = "Monday";
+      break;
+    case 2:
+      var day = "Tuesday";
+      break;
+    case 3:
+      var day = "Wednesday";
+      break;
+    case 4:
+      var day = "Thursday";
+      break;
+    case 5:
+      var day = "Friday";
+      break;
+    case 6:
+      var day = "Saturday";
+      break;
+    }
+    if(shortened) {
+      return humDate.toLocaleDateString();
+    } else {
+      return day + ', ' + humDate.toLocaleDateString();
+    }
+  }
+};

data/lib/gitdocs/runner.rb

@@ -0,0 +1,259 @@
+module Gitdocs
+  class Runner
+    include ShellTools
+
+    attr_reader :root, :listener
+
+    def initialize(share)
+      @share = share
+      @root  = share.path.sub(%r{/+$},'') if share.path
+      @polling_interval = share.polling_interval
+      @icon = File.expand_path("../../img/icon.png", __FILE__)
+    end
+
+    SearchResult = Struct.new(:file, :context)
+    def search(term)
+      return [] if term.empty?
+
+      results = []
+      if result_test = sh_string("git grep -i #{ShellTools.escape(term)}")
+        result_test.scan(/(.*?):([^\n]*)/) do |(file, context)| 
+          if result = results.find { |s| s.file == file }
+            result.context += ' ... ' + context
+          else
+            results << SearchResult.new(file, context)
+          end
+        end
+      end
+      results
+    end
+
+    def run
+      return false unless self.valid?
+
+      @show_notifications = @share.notification
+      @current_remote     = @share.remote_name
+      @current_branch     = @share.branch_name
+      @current_revision   = sh_string("git rev-parse HEAD")
+      Guard::Notifier.turn_on if @show_notifications
+
+      mutex = Mutex.new
+
+      info("Running gitdocs!", "Running gitdocs in `#{@root}'")
+
+      # Pull changes from remote repository
+      syncer = proc do
+        EM.defer(proc do
+          mutex.synchronize { sync_changes }
+        end, proc do
+          EM.add_timer(@polling_interval) {
+            syncer.call
+          }
+        end)
+      end
+      syncer.call
+      # Listen for changes in local repository
+
+      EM.defer(proc{
+        listener = Guard::Listener.select_and_init(@root, :watch_all_modifications => true)
+        listener.on_change { |directories|
+          directories.uniq!
+          directories.delete_if {|d| d =~ /\/\.git/}
+          unless directories.empty?
+            EM.next_tick do
+              EM.defer(proc {
+                mutex.synchronize { push_changes }
+              }, proc {} )
+            end
+          end
+        }
+        listener.start
+      }, proc{EM.stop_reactor})
+    end
+
+    def clear_state
+      @state = nil
+    end
+
+    def sync_changes
+      out, status = sh_with_code("git fetch --all && git merge #{@current_remote}/#{@current_branch}")
+      if status.success?
+        changes = get_latest_changes
+        unless changes.empty?
+          author_list = changes.inject(Hash.new{|h, k| h[k] = 0}) {|h, c| h[c['author']] += 1; h}.to_a.sort{|a,b| b[1] <=> a[1]}.map{|(name, count)| "* #{name} (#{count} change#{count == 1 ? '' : 's'})"}.join("\n")
+          info("Updated with #{changes.size} change#{changes.size == 1 ? '' : 's'}", "In `#{@root}':\n#{author_list}")
+        end
+        push_changes
+      elsif out[/CONFLICT/]
+        conflicted_files = sh("git ls-files -u --full-name -z").split("\0").
+          inject(Hash.new{|h, k| h[k] = []}) {|h, line|
+            parts = line.split(/\t/)
+            h[parts.last] << parts.first.split(/ /)
+            h
+          }
+        warn("There were some conflicts", "#{conflicted_files.keys.map{|f| "* #{f}"}.join("\n")}")
+        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 #{conflict}") or raise
+        end
+        push_changes
+      elsif sh_string("git remote").nil? # no remote to pull from
+        # Do nothing, no remote repo yet
+      else
+        error("There was a problem synchronizing this gitdoc", "A problem occurred in #{@root}:\n#{out}")
+      end
+    end
+
+    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
+      sh 'find . -type d -regex ``./[^.].*'' -empty -exec touch \'{}/.gitignore\' \;'
+      sh 'git add .'
+      sh "git commit -a -m #{ShellTools.escape(message)}" unless sh("git status -s").strip.empty?
+      if @current_revision.nil? || sh('git status')[/branch is ahead/]
+        out, code = sh_with_code("git push #{@current_remote} #{@current_branch}")
+        if code.success?
+          changes = get_latest_changes
+          info("Pushed #{changes.size} change#{changes.size == 1 ? '' : 's'}", "`#{@root}' has been pushed")
+        elsif @current_revision.nil?
+          # ignorable
+        elsif out[/\[rejected\]/]
+          warn("There was a conflict in #{@root}, retrying", "")
+        else
+          error("BAD Could not push changes in #{@root}", out)
+          exit
+        end
+      end
+    end
+
+    def get_latest_changes
+      if @current_revision
+        out = sh "git log #{@current_revision}.. --pretty='format:{\"commit\": \"%H\",%n  \"author\": \"%an <%ae>\",%n  \"date\": \"%ad\",%n  \"message\": \"%s\"%n}'"
+        if out.empty?
+          []
+        else
+          lines = []
+          Yajl::Parser.new.parse(out) do |obj|
+            lines << obj
+          end
+          @current_revision = sh("git rev-parse HEAD").strip
+          lines
+        end
+      else
+        []
+      end
+    end
+
+    IGNORED_FILES = ['.gitignore']
+    # Returns the list of files in a given directory
+    # dir_files("some/dir") => [<Docfile>, <Docfile>]
+    def dir_files(dir_path)
+      Dir[File.join(dir_path, "*")].to_a.map { |path| Docfile.new(path) }
+    end
+
+    # Returns file meta data based on relative file path
+    # file_meta("path/to/file")
+    #  => { :author => "Nick", :size => 1000, :modified => ... }
+    def file_meta(file)
+      result = {}
+      file = file.gsub(%r{^/}, '')
+      full_path = File.expand_path(file, @root)
+      log_result = sh_string("git log --format='%aN|%ai' -n1 #{ShellTools.escape(file)}")
+      result =  {} unless File.exist?(full_path) && log_result
+      author, modified = log_result.split("|")
+      modified = Time.parse(modified.sub(' ', 'T')).utc.iso8601
+      size = if File.directory?(full_path)
+               Dir[File.join(full_path, '**', '*')].inject(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
+      result = { :author => author, :size => size, :modified => modified }
+      result
+    end
+
+    # Returns the revisions available for a particular file
+    # file_revisions("README")
+    def file_revisions(file)
+      file = file.gsub(%r{^/}, '')
+      output = sh_string("git log --format='%h|%s|%aN|%ai' -n100 #{ShellTools.escape(file)}")
+      output.to_s.split("\n").map do |log_result|
+        commit, subject, author, date = log_result.split("|")
+        date = Time.parse(date.sub(' ', 'T')).utc.iso8601
+        { :commit => commit, :subject => subject, :author => author, :date => date }
+      end
+    end
+
+    # Returns the temporary path of a particular revision of a file
+    # file_revision_at("README", "a4c56h") => "/tmp/some/path/README"
+    def file_revision_at(file, ref)
+      file = file.gsub(%r{^/}, '')
+      content = sh_string("git show #{ref}:#{ShellTools.escape(file)}")
+      tmp_path = File.expand_path(File.basename(file), Dir.tmpdir)
+      File.open(tmp_path, 'w') { |f| f.puts content }
+      tmp_path
+    end
+
+    # Revert a file to a particular revision
+    def file_revert(file, ref)
+      if file_revisions(file).map {|r| r[:commit]}.include? ref
+        file = file.gsub(%r{^/}, '')
+        full_path = File.expand_path(file, @root)
+        content = File.read(file_revision_at(file, ref))
+        File.open(full_path, 'w') { |f| f.puts content }
+      end
+    end
+
+    def valid?
+      out, status = sh_with_code "git status"
+      @root.present? && status.success?
+    end
+
+    def warn(title, msg)
+      if @show_notifications
+        Guard::Notifier.notify(msg, :title => title)
+      else
+        Kernel.warn("#{title}: #{msg}")
+      end
+    end
+
+    def info(title, msg)
+      if @show_notifications
+        Guard::Notifier.notify(msg, :title => title, :image => @icon)
+      else
+        puts("#{title}: #{msg}")
+      end
+    end
+
+    def error(title, msg)
+      if @show_notifications
+        Guard::Notifier.notify(msg, :title => title, :image => :failure)
+      else
+        Kernel.warn("#{title}: #{msg}")
+      end
+    end
+
+    # sh_string("git config branch.`git branch | grep '^\*' | sed -e 's/\* //'`.remote", "origin")
+    def sh_string(cmd, default=nil)
+      val = sh(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
+end

data/lib/gitdocs/server.rb

@@ -0,0 +1,154 @@
+require 'thin'
+require 'renee'
+require 'coderay'
+require 'uri'
+require 'haml'
+require 'mimetype_fu'
+require 'pygments'
+
+module Gitdocs
+  class Server
+    def initialize(manager, *gitdocs)
+      @manager = manager
+      @gitdocs = gitdocs
+    end
+
+    def start(port = 8888)
+      gds = @gitdocs
+      manager = @manager
+
+      Tilt.prefer ::MarkdownTemplate, 'md'
+      Tilt.prefer ::MarkdownTemplate, 'mkd'
+      Tilt.prefer ::MarkdownTemplate, 'markdown'
+
+      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::MethodOverride
+        run Renee {
+          if request.path_info == '/'
+            if manager.config.shares.size == 1
+              redirect! "/0"
+            else
+              render! "home", :layout => 'app', :locals => {:conf => manager.config, :nav_state => "home" }
+            end
+          else
+            path 'settings' do
+              get.render! 'settings', :layout => 'app', :locals => {:conf => manager.config, :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 }
+                redirect! '/settings'
+              end
+            end
+
+            path('search').get do
+              render! "search", :layout => 'app', :locals => {:conf => manager.config, :results => manager.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'
+                end
+              end
+            end
+
+            var :int do |idx|
+              gd = gds[idx]
+              halt 404 if gd.nil?
+              file_path = URI.unescape(request.path_info)
+              file_ext  = File.extname(file_path)
+              expanded_path = File.expand_path(".#{file_path}", gd.root)
+              message_file = File.expand_path(".gitmessage~", gd.root)
+              halt 400 unless expanded_path[/^#{Regexp.quote(gd.root)}/]
+              parent = File.dirname(file_path)
+              parent = '' if parent == '/'
+              parent = nil if parent == '.'
+              locals = {:idx => idx, :parent => parent, :root => gd.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' }, [gd.file_meta(file_path).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
+              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 =  gd.dir_files(expanded_path)
+                rendered_readme = nil
+                if readme = Dir[File.expand_path("README.{md,txt}", 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)
+              elsif mode == "revisions" # list revisions
+                revisions = gd.file_revisions(file_path)
+                render! "revisions", :layout => 'app', :locals => locals.merge(:revisions => revisions)
+              elsif mode == "revert" # revert file
+                if revision = request.params['revision']
+                  File.open(message_file, 'w') { |f| f.print "Reverting '#{file_path}' to #{revision}" }
+                  gd.file_revert(file_path, revision)
+                end
+                redirect! "/" + idx.to_s + file_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)
+              elsif mode != 'raw' # render file
+                revision = request.params['revision']
+                expanded_path = gd.file_revision_at(file_path, revision) if revision
+                begin # attempting to render file
+                  contents = '<div class="tilt">' + render(expanded_path) + '</div>'
+                rescue RuntimeError => e # 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>|
+                  end
+                end
+                render! "file", :layout => 'app', :locals => locals.merge(:contents => contents, 
+                  :pygments_css => Pygments.css('.highlight'))
+              else # other file
+                run! Rack::File.new(gd.root)
+              end
+            end
+          end
+        }.setup {
+          views_path File.expand_path("../views", __FILE__)
+        }
+      end
+    end
+  end
+end

data/lib/gitdocs/version.rb

@@ -0,0 +1,3 @@
+module Gitdocs
+  VERSION = "0.4.14.md"
+end

data/lib/gitdocs/views/_ace_scripts.erb

@@ -0,0 +1,8 @@
+<script src="/js/ace/ace.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/theme-tomorrow_night.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/mode-css.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/mode-html.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/mode-markdown.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/mode-javascript.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/ace/mode-ruby.js" type="text/javascript" charset="utf-8"></script>
+<script src="/js/edit.js" type="text/javascript" charset="utf-8"></script>

data/lib/gitdocs/views/_header.haml

@@ -0,0 +1,14 @@
+%h2.path
+  %span.path= request.path_info.empty? ? '/' : request.path_info
+- if file
+  %ul{ :class => "tabs" }
+    %li
+      %a{ :href => "#{request.path}" } View
+    %li
+      %a{ :href => "?mode=raw" } Raw
+    %li
+      %a{ :href => "?mode=edit" } Edit
+    %li
+      %a{ :href => "?mode=revisions" } Revisions
+    %li
+      %a{ :href => "?mode=delete", :onclick => "javascript:return confirm('Are you sure?')" } Delete

data/lib/gitdocs/views/app.haml

@@ -0,0 +1,40 @@
+!!!
+%html
+  %head
+    %meta{ "http-equiv" => "content-type", :content => "text/html; charset=UTF-8" }
+    %title Gitdocs #{Gitdocs::VERSION}
+    %link{ :href => "/css/bootstrap.css", :rel => "stylesheet"}
+    %link{ :href => "/css/app.css", :rel => "stylesheet" }
+    %link{ :href => "/css/tilt.css", :rel => "stylesheet" }
+    %link{ :href => "/css/coderay.css", :rel => "stylesheet" }
+    %script{ :src => "/js/util.js", :type => "text/javascript", :charset => "utf-8" }
+    %script{ :src => "/js/jquery.js", :type => "text/javascript", :charset => "utf-8" }
+    %script{ :src => "/js/jquery.tablesorter.js", :type => "text/javascript", :charset => "utf-8" }
+    %script{ :src => "/js/bootstrap-alerts.js", :type => "text/javascript", :charset => "utf-8" }
+    %script{ :src => "/js/app.js", :type => "text/javascript", :charset => "utf-8" }
+    - if @css
+      %style{:type => "text/css"}
+        = @css
+  %body
+    #nav.topbar
+      .fill
+        .container
+          %a{:class => "brand", :href => "/"} Gitdocs
+          %ul(class="nav")
+            %li{ :class => ("active" if nav_state == "home") }
+              %a(href = "/") Home
+            %li{ :class => ("active" if nav_state == "settings") }
+              %a(href = "/settings") Settings
+          %form{:class => "pull-left", :action => "/search", :method => 'GET'}
+            %input{:type => "text", :placeholder => "Search", :name => 'q'}
+
+    #main.container
+      .content
+        - if @title
+          .page-header
+            %h1= @title
+        .row
+          .span16= preserve(yield)
+
+      %footer
+        %p © Gitdocs v#{Gitdocs::VERSION}

data/lib/gitdocs/views/dir.haml

@@ -0,0 +1,43 @@
+- @title = root
+
+= partial("header", :locals => { :parent => parent, :file => false, :idx => idx })
+
+- if contents && contents.any?
+  %table#fileListing.condensed-table.zebra-striped
+    %thead
+      %tr
+        %th File
+        %th Author
+        %th Last Modified
+        %th Size
+
+    %tbody
+      - contents.each_with_index do |f, i|
+        %tr
+          %td
+            %img{ :src => "/img/#{f.dir? ? 'folder' : 'file'}.png", :width => 16, :height => 16 }
+            %a{ :href => "/#{idx}#{request.path_info}/#{f.name}" }
+              = f.name
+          %td.author
+          %td.modified
+          %td.size
+
+- if contents.empty?
+  %p No files were found in this directory.
+
+.row
+  .span6
+    %form.upload{ :method => "post", :enctype => "multipart/form-data", :action => "/#{idx}#{request.path_info}?mode=upload" }
+      %p Upload file to this directory
+      %input{:type => 'file', :value => "Select a file", :name => "file", :class => "uploader", :size => 12}
+      %input{:type => 'submit', :value => "Upload file", :class => "btn secondary" }
+  .span8
+    %form.add
+      %p Add new file or directory
+      %input{:type => 'text', :name => "path", :class => "edit", :placeholder => "somefile.md or somedir" }
+      %input{:type => 'submit', :value => "New file", :class => "btn secondary file" }
+      %input{:type => 'submit', :value => "New directory", :class => "btn secondary directory" }
+
+- if rendered_readme
+  .contents
+    = preserve rendered_readme