gollum-lib 0.0.1

data/lib/gollum-lib/committer.rb

@@ -0,0 +1,236 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  # Responsible for handling the commit process for a Wiki.  It sets up the
+  # Git index, provides methods for modifying the tree, and stores callbacks
+  # to be fired after the commit has been made.  This is specifically
+  # designed to handle multiple updated pages in a single commit.
+  class Committer
+    # Gets the instance of the Gollum::Wiki that is being updated.
+    attr_reader :wiki
+
+    # Gets a Hash of commit options.
+    attr_reader :options
+
+    # Initializes the Committer.
+    #
+    # wiki    - The Gollum::Wiki instance that is being updated.
+    # options - The commit Hash details:
+    #           :message   - The String commit message.
+    #           :name      - The String author full name.
+    #           :email     - The String email address.
+    #           :parent    - Optional Grit::Commit parent to this update.
+    #           :tree      - Optional String SHA of the tree to create the
+    #                        index from.
+    #           :committer - Optional Gollum::Committer instance.  If provided,
+    #                        assume that this operation is part of batch of
+    #                        updates and the commit happens later.
+    #
+    # Returns the Committer instance.
+    def initialize(wiki, options = {})
+      @wiki      = wiki
+      @options   = options
+      @callbacks = []
+    end
+
+    # Public: References the Git index for this commit.
+    #
+    # Returns a Grit::Index.
+    def index
+      @index ||= begin
+        idx = @wiki.repo.index
+        if tree   = options[:tree]
+          idx.read_tree(tree)
+        elsif parent = parents.first
+          idx.read_tree(parent.tree.id)
+        end
+        idx
+      end
+    end
+
+    # Public: The committer for this commit.
+    #
+    # Returns a Grit::Actor.
+    def actor
+      @actor ||= begin
+        @options[:name]  = @wiki.default_committer_name  if @options[:name].to_s.empty?
+        @options[:email] = @wiki.default_committer_email if @options[:email].to_s.empty?
+        Grit::Actor.new(@options[:name], @options[:email])
+      end
+    end
+
+    # Public: The parent commits to this pending commit.
+    #
+    # Returns an array of Grit::Commit instances.
+    def parents
+      @parents ||= begin
+        arr = [@options[:parent] || @wiki.repo.commit(@wiki.ref)]
+        arr.flatten!
+        arr.compact!
+        arr
+      end
+    end
+
+    # Adds a page to the given Index.
+    #
+    # dir    - The String subdirectory of the Gollum::Page without any
+    #          prefix or suffix slashes (e.g. "foo/bar").
+    # name   - The String Gollum::Page filename_stripped.
+    # format - The Symbol Gollum::Page format.
+    # data   - The String wiki data to store in the tree map.
+    # allow_same_ext - A Boolean determining if the tree map allows the same
+    #                  filename with the same extension.
+    #
+    # Raises Gollum::DuplicatePageError if a matching filename already exists.
+    # This way, pages are not inadvertently overwritten.
+    #
+    # Returns nothing (modifies the Index in place).
+    def add_to_index(dir, name, format, data, allow_same_ext = false)
+      # spaces must be dashes
+      dir.gsub!(' ', '-')
+      name.gsub!(' ', '-')
+
+      path = @wiki.page_file_name(name, format)
+
+      dir = '/' if dir.strip.empty?
+
+      fullpath = ::File.join(*[@wiki.page_file_dir, dir, path].compact)
+      fullpath = fullpath[1..-1] if fullpath =~ /^\//
+
+      if index.current_tree && tree = index.current_tree / (@wiki.page_file_dir || '/')
+        tree = tree / dir unless tree.nil?
+      end
+
+      if tree
+        downpath = path.downcase.sub(/\.\w+$/, '')
+
+        tree.blobs.each do |blob|
+          next if page_path_scheduled_for_deletion?(index.tree, fullpath)
+          
+          existing_file = blob.name.downcase.sub(/\.\w+$/, '')
+          existing_file_ext = ::File.extname(blob.name).sub(/^\./, '')
+
+          new_file_ext = ::File.extname(path).sub(/^\./, '')
+
+          if downpath == existing_file && !(allow_same_ext && new_file_ext == existing_file_ext)
+            raise DuplicatePageError.new(dir, blob.name, path)
+          end
+        end
+      end
+
+      fullpath = fullpath.force_encoding('ascii-8bit') if fullpath.respond_to?(:force_encoding)
+
+      index.add(fullpath, @wiki.normalize(data))
+    end
+
+    # Update the given file in the repository's working directory if there
+    # is a working directory present.
+    #
+    # dir    - The String directory in which the file lives.
+    # name   - The String name of the page or the stripped filename
+    #          (should be pre-canonicalized if required).
+    # format - The Symbol format of the page.
+    #
+    # Returns nothing.
+    def update_working_dir(dir, name, format)
+      unless @wiki.repo.bare
+        if @wiki.page_file_dir
+          dir = dir.size.zero? ? @wiki.page_file_dir : ::File.join(dir, @wiki.page_file_dir)
+        end
+
+        path =
+          if dir == ''
+            @wiki.page_file_name(name, format)
+          else
+            ::File.join(dir, @wiki.page_file_name(name, format))
+          end
+
+        path = path.force_encoding('ascii-8bit') if path.respond_to?(:force_encoding)
+
+        Dir.chdir(::File.join(@wiki.repo.path, '..')) do
+          if file_path_scheduled_for_deletion?(index.tree, path)
+            @wiki.repo.git.rm({'f' => true}, '--', path)
+          else
+            @wiki.repo.git.checkout({}, 'HEAD', '--', path)
+          end
+        end
+      end
+    end
+
+    # Writes the commit to Git and runs the after_commit callbacks.
+    #
+    # Returns the String SHA1 of the new commit.
+    def commit
+      sha1 = index.commit(@options[:message], parents, actor, nil, @wiki.ref)
+      @callbacks.each do |cb|
+        cb.call(self, sha1)
+      end
+      sha1
+    end
+
+    # Adds a callback to be fired after a commit.
+    #
+    # block - A block that expects this Committer instance and the created
+    #         commit's SHA1 as the arguments.
+    #
+    # Returns nothing.
+    def after_commit(&block)
+      @callbacks << block
+    end
+
+    # Determine if a given page (regardless of format) is scheduled to be
+    # deleted in the next commit for the given Index.
+    #
+    # map   - The Hash map:
+    #         key - The String directory or filename.
+    #         val - The Hash submap or the String contents of the file.
+    # path - The String path of the page file. This may include the format
+    #         extension in which case it will be ignored.
+    #
+    # Returns the Boolean response.
+    def page_path_scheduled_for_deletion?(map, path)
+      parts = path.split('/')
+      if parts.size == 1
+        deletions = map.keys.select { |k| !map[k] }
+        downfile = parts.first.downcase.sub(/\.\w+$/, '')
+        deletions.any? { |d| d.downcase.sub(/\.\w+$/, '') == downfile }
+      else
+        part = parts.shift
+        if rest = map[part]
+          page_path_scheduled_for_deletion?(rest, parts.join('/'))
+        else
+          false
+        end
+      end
+    end
+
+    # Determine if a given file is scheduled to be deleted in the next commit
+    # for the given Index.
+    #
+    # map   - The Hash map:
+    #         key - The String directory or filename.
+    #         val - The Hash submap or the String contents of the file.
+    # path - The String path of the file including extension.
+    #
+    # Returns the Boolean response.
+    def file_path_scheduled_for_deletion?(map, path)
+      parts = path.split('/')
+      if parts.size == 1
+        deletions = map.keys.select { |k| !map[k] }
+        deletions.any? { |d| d == parts.first }
+      else
+        part = parts.shift
+        if rest = map[part]
+          file_path_scheduled_for_deletion?(rest, parts.join('/'))
+        else
+          false
+        end
+      end
+    end
+
+    # Proxies methods t
+    def method_missing(name, *args)
+      args.map! { |item| item.respond_to?(:force_encoding) ? item.force_encoding('ascii-8bit') : item }
+      index.send(name, *args)
+    end
+  end
+end

data/lib/gollum-lib/file.rb

@@ -0,0 +1,101 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  class File
+    Wiki.file_class = self
+
+    # Public: Initialize a file.
+    #
+    # wiki - The Gollum::Wiki in question.
+    #
+    # Returns a newly initialized Gollum::File.
+    def initialize(wiki)
+      @wiki = wiki
+      @blob = nil
+      @path = nil
+    end
+
+    # Public: The url path required to reach this page within the repo.
+    #
+    # Returns the String url_path
+    def url_path
+      path = self.path
+      path = path.sub(/\/[^\/]+$/, '/') if path.include?('/')
+      path
+    end
+
+    # Public: The url_path, but CGI escaped.
+    #
+    # Returns the String url_path
+    def escaped_url_path
+      CGI.escape(self.url_path).gsub('%2F','/')
+    end
+
+    # Public: The on-disk filename of the file.
+    #
+    # Returns the String name.
+    def name
+      @blob && @blob.name
+    end
+    alias filename name
+
+    # Public: The raw contents of the page.
+    #
+    # Returns the String data.
+    def raw_data
+      return nil unless @blob
+
+      if !@wiki.repo.bare && @blob.is_symlink
+        new_path = @blob.symlink_target(::File.join(@wiki.repo.path, '..', self.path))
+        return IO.read(new_path) if new_path
+      end
+
+      @blob.data
+    end
+
+    # Public: The Grit::Commit version of the file.
+    attr_accessor :version
+
+    # Public: The String path of the file.
+    attr_reader :path
+
+    # Public: The String mime type of the file.
+    def mime_type
+      @blob.mime_type
+    end
+
+    # Populate the File with information from the Blob.
+    #
+    # blob - The Grit::Blob that contains the info.
+    # path - The String directory path of the file.
+    #
+    # Returns the populated Gollum::File.
+    def populate(blob, path=nil)
+      @blob = blob
+      @path = "#{path}/#{blob.name}"[1..-1]
+      self
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # Find a file in the given Gollum repo.
+    #
+    # name    - The full String path.
+    # version - The String version ID to find.
+    #
+    # Returns a Gollum::File or nil if the file could not be found.
+    def find(name, version)
+      checked = name.downcase
+      map     = @wiki.tree_map_for(version)
+      if entry = map.detect { |entry| entry.path.downcase == checked }
+        @path    = name
+        @blob    = entry.blob(@wiki.repo)
+        @version = version.is_a?(Grit::Commit) ? version : @wiki.commit_for(version)
+        self
+      end
+    end
+  end
+end

data/lib/gollum-lib/file_view.rb

@@ -0,0 +1,155 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+=begin
+  FileView requires that:
+    - All files in root dir are processed first
+    - Then all the folders are sorted and processed
+=end
+  class FileView
+    # common use cases:
+    # set pages to wiki.pages and show_all to false
+    # set pages to wiki.pages + wiki.files and show_all to true
+    def initialize pages, options = {}
+      @pages = pages
+      @show_all = options[:show_all] || false
+      @checked = options[:collapse_tree] ? '' : "checked"
+    end
+
+    def enclose_tree string
+      %Q(<ol class="tree">\n) + string + %Q(</ol>)
+    end
+
+    def new_page page
+      name = page.name
+      url  = url_for_page page
+      %Q(  <li class="file"><a href="#{url}"><span class="icon"></span>#{name}</a></li>)
+    end
+
+    def new_folder folder_path
+      new_sub_folder folder_path
+    end
+
+    def new_sub_folder path
+      <<-HTML
+      <li>
+        <label>#{path}</label> <input type="checkbox" #{@checked} />
+        <ol>
+      HTML
+    end
+
+    def end_folder
+      "</ol></li>\n"
+    end
+
+    def url_for_page page
+      url = ''
+      if @show_all
+        # Remove ext for valid pages.
+        filename = page.filename
+        filename = Page::valid_page_name?(filename) ? filename.chomp(::File.extname(filename)) : filename
+
+        url = ::File.join(::File.dirname(page.path), filename)
+      else
+        url = ::File.join(::File.dirname(page.path), page.filename_stripped)
+      end
+      url = url[2..-1] if url[0,2] == './'
+      url
+    end
+
+    def render_files
+      html = ''
+      count = @pages.size
+      folder_start = -1
+
+      # Process all pages until folders start
+      count.times do | index |
+        page = @pages[ index ]
+        path = page.path
+
+        unless path.include? '/'
+          # Page processed (not contained in a folder)
+          html += new_page page
+        else
+          # Folders start at the next index
+          folder_start = index
+          break # Pages finished, move on to folders
+        end
+      end
+
+      # If there are no folders, then we're done.
+      return enclose_tree(html) if folder_start <= -1
+
+      # Handle special case of only one folder.
+      if (count - folder_start == 1)
+        page = @pages[ folder_start ]
+        html += <<-HTML
+        <li>
+          <label>#{::File.dirname(page.path)}</label> <input type="checkbox" #{@checked} />
+          <ol>
+          #{new_page page}
+         </ol>
+        </li>
+        HTML
+
+        return enclose_tree html
+      end
+
+      sorted_folders = []
+      (folder_start).upto count - 1 do | index |
+        sorted_folders += [[ @pages[ index ].path, index ]]
+      end
+
+      # http://stackoverflow.com/questions/3482814/sorting-list-of-string-paths-in-vb-net
+      sorted_folders.sort! do |first,second| 
+        a = first[0]
+        b = second[0]
+
+        # use :: operator because gollum defines its own conflicting File class
+        dir_compare = ::File.dirname(a) <=> ::File.dirname(b)
+
+        # Sort based on directory name unless they're equal (0) in
+        # which case sort based on file name.
+        if dir_compare == 0
+          ::File.basename(a) <=> ::File.basename(b)
+        else
+          dir_compare
+        end
+      end
+
+      # keep track of folder depth, 0 = at root.
+      cwd_array = []
+      changed = false
+
+      # process rest of folders
+      (0...sorted_folders.size).each do | index |
+          page =  @pages[ sorted_folders[ index ][ 1 ] ]
+          path = page.path
+          folder = ::File.dirname path
+
+          tmp_array = folder.split '/'
+
+          (0...tmp_array.size).each do | index |
+            if cwd_array[ index ].nil? || changed
+              html += new_sub_folder tmp_array[ index ]
+              next
+            end
+
+            if cwd_array[ index ] != tmp_array[ index ]
+              changed = true
+              (cwd_array.size - index).times do
+                html += end_folder
+              end
+              html += new_sub_folder tmp_array[ index ]
+            end
+          end
+
+          html += new_page page
+          cwd_array = tmp_array
+          changed = false
+      end
+
+      # return the completed html
+      enclose_tree html
+    end # end render_files
+  end # end FileView class
+end # end Gollum module