site.rb in gollum-site-0.1.0

- old
+ new
@@ -3,94 +3,138 @@
     def self.default_layout_dir()
       ::File.join(::File.dirname(::File.expand_path(__FILE__)), "layout")
     end
 
     attr_reader :output_path
+    attr_reader :layouts
+    attr_reader :pages
 
-    def initialize(wiki, options = {})
-      @wiki = wiki
+    def initialize(path, options = {})
+      @wiki = Gollum::Wiki.new(path, {
+                                 # markup_class should work after v1.1.0 of Gollum
+                                 # need to change class name in markup.rb
+                                 #:markup_class => Gollum::SiteMarkup,
+                                 :page_class => Gollum::SitePage,
+                                 :base_path => options[:base_path]
+                               })
+      @wiki.site = self
       @output_path = options[:output_path] || "_site"
-      if (@include_default_layout = options[:include_default_layout]).nil?
-        @include_default_layout = true
-      end
+      set_version(options[:version] || "master")
     end
 
-    # Public: generate a static site
-    #
-    # version - The String version ID to generate (default: "master").
-    #
-    def generate(version = 'master')
-      ::Dir.mkdir(@output_path) unless ::File.exists? @output_path
+    # Prepare site for specified version
+    def set_version(version)
+      @version = version
+      @pages = {}
+      @files = {}
+      @layouts = {}
 
-      layouts = {}
-      items = @wiki.tree_map_for(version).inject([]) do |list, entry|
-        if entry.name =~ /^_Footer./
-          # Ignore
-        elsif entry.name == "_Layout.html"
-          layout = ::Liquid::Template.parse(entry.blob(@wiki.repo).data)
-          layouts[::File.dirname(entry.path)] = layout
-        elsif @wiki.page_class.valid_page_name?(entry.name)
-          sha = @wiki.ref_map[version] || version
-          page = entry.page(@wiki, @wiki.repo.commit(sha))
-          list << page
-        else
-          list << entry
-        end
-        list
-      end
+      @commit = version == :working ? @wiki.repo.commit("HEAD") : @wiki.repo.commit(version)
+      items = self.ls(version)
 
-      if layouts["."].nil? and @include_default_layout
-        dir = Gollum::Site.default_layout_dir()
-        default_layout = ::File.join(dir, "_Layout.html")
-        layout = ::Liquid::Template.parse(IO.read(default_layout))
-        layouts["."] = layout
-        css = ::File.join(dir, "css")
-        javascript = ::File.join(dir, "javascript")
-        FileUtils.cp_r([css, javascript], @output_path)
-      end
-
       items.each do |item|
-        if item.is_a?(@wiki.page_class)
-          path = ::File.join(@output_path, @wiki.page_class.cname(item.name))
-          layout = get_layout(layouts, ::File.dirname(item.path))
-          data = render_page(item, layout)
+        filename = ::File.basename(item.path)
+        dirname = ::File.dirname(item.path)
+        if filename =~ /^_Footer./
+          # ignore
+        elsif filename =~ /^_Layout.html/
+          # layout
+          @layouts[item.path] = ::Liquid::Template.parse(item.data)
+        elsif @wiki.page_class.valid_page_name?(filename)
+          # page
+          page = @wiki.page_class.new(@wiki)
+          blob = OpenStruct.new(:name => filename, :data => item.data)
+          page.populate(blob, dirname)
+          page.version = @commit
+          @pages[page.name.downcase] = page
         else
-          path = ::File.join(@output_path, item.path)
-          ::FileUtils.mkdir_p(::File.dirname(path))
-          data = item.blob(@wiki.repo).data
+          # file
+          @files[item.path] = item.data
         end
-        f = ::File.new(path, "w")
-        f.write(data)
-        f.close
       end
     end
 
-    def get_layout(layouts, path)
-      if path == ""
-        layouts["."]
+    def ls(version = 'master')
+      if version == :working
+        ls_opts = {
+          :others => true,
+          :exclude_standard => true,
+          :cached => true,
+          :z => true
+        }
+
+        ls_opts_del = {
+          :deleted => true,
+          :exclude_standard => true,
+          :z => true
+        }
+
+        # if output_path is in work_tree, it should be excluded
+        if ::File.expand_path(@output_path).match(::File.expand_path(@wiki.repo.git.work_tree))
+          ls_opts[:exclude] = @output_path
+          ls_opts_del[:exclude] = @output_path
+        end
+
+        cwd = Dir.pwd # need to change directories for git ls-files -o
+        Dir.chdir(@wiki.repo.git.work_tree)
+        deleted = @wiki.repo.git.native(:ls_files, ls_opts_del).split("\0")
+        working = @wiki.repo.git.native(:ls_files, ls_opts).split("\0")
+        work_tree = (working - deleted).map do |path|
+          path = @wiki.decode_git_path(path)
+          OpenStruct.new(:path => path, :data => IO.read(path))
+        end
+        Dir.chdir(cwd) # change back to original directory
+        return work_tree
       else
-        layouts[path] or get_layout(layouts, path.split("/")[0..-2].join("/"))
+        return @wiki.tree_map_for(version).map do |entry|
+          OpenStruct.new(:path => entry.path, :data => entry.blob(@wiki.repo).data)
+        end
       end
     end
 
-    def render_page(page, layout=nil)
-      if layout.nil?
-        return page.formatted_data
+    # path must be relative to top level of wiki repo
+    def update_working_item(path)
+      filename = ::File.basename(path)
+      dirname = ::File.dirname(path)
+      if filename =~ /^_Footer./
+        # ignore
+      elsif filename =~ /^_Layout.html/
+        # layout
+      elsif @wiki.page_class.valid_page_name?(filename)
+        # page
+        abspath = ::File.join(@wiki.repo.git.work_tree, path)
+        page = @wiki.page_class.new(@wiki)
+        blob = OpenStruct.new(:name => filename, :data => IO.read(abspath))
+        page.populate(blob, dirname)
+        page.version = @commit
+        @pages[page.name.downcase] = page
+        page.generate(@output_path, @version)
       else
-        return layout.render( 'page' => page_to_liquid(page),
-                              'wiki' => wiki_to_liquid(page.wiki))
+        # file
+        data = IO.read(abspath)
+        @files[path] = data
+        path = ::File.join(@output_path, path)
+        ::FileUtils.mkdir_p(::File.dirname(path))
+        ::File.open(path, "w") do |f|
+          f.write(data)
+        end
       end
     end
 
-    def page_to_liquid(page)
-      {"content" => page.formatted_data,
-        "title" => page.title,
-        "format" => page.format.to_s,
-        "author" => page.version.author.name,
-        "date" => page.version.authored_date.strftime("%Y-%m-%d %H:%M:%S")}
-    end
+    # Public: generate the static site
+    def generate()
+      ::Dir.mkdir(@output_path) unless ::File.exists? @output_path
 
-    def wiki_to_liquid(wiki)
-      {"base_path" => wiki.base_path}
+      @pages.each do |name, page|
+        page.generate(@output_path, @version)
+      end
+
+      @files.each do |path, data|
+        path = ::File.join(@output_path, path)
+        ::FileUtils.mkdir_p(::File.dirname(path))
+        ::File.open(path, "w") do |f|
+          f.write(data)
+        end
+      end
     end
   end
 end