smeagol 0.5.9 → 0.6.0

data/lib/smeagol/controller.rb

@@ -0,0 +1,275 @@
+module Smeagol
+
+  # Shared controller.
+  class Controller
+
+    # Initialize new Controller instance.
+    #
+    # wiki - Gollum::Wiki
+    #
+    def initialize(wiki)
+      @wiki  = wiki
+      #@views = Hash.new{ |h,k| h[k]={} }
+      #@media = Hash.new{ |h,k| h[k]={} }
+      #@preloaded = {}
+    end
+
+    # Access to Gollum::Wiki.
+    attr :wiki
+
+    # Public: The Smeagol wiki settings. These can be found in the _settings.yml
+    # file at the root of the repository.
+    # This method caches the settings for all subsequent calls.
+    #
+    # TODO: Should settings be coming from current file or from repo version?
+    #       This can be tricky. Right now they come from current file, but
+    #       In future we probably may need to split this into two config files.
+    #       One that comes from version and one that is current.
+    #
+    # Returns a Settings object.
+    def settings
+      @settings ||= Settings.load(wiki.path)
+    end
+
+    #def view(wiki_file, version='master')
+    #  @views[version][wiki_file] ||= create_view(wiki_file, version)
+    #end
+
+    # Lookup view by wiki file and version.
+    def view(wiki_file, version='master')
+      case wiki_file
+      when Gollum::Page
+        if wiki_file.post?
+          Views::Post.new(self, wiki_file, version)
+        else
+          Views::Page.new(self, wiki_file, version)
+        end
+      when Gollum::File
+        if wiki_file.extname == '.mustache'
+          Views::Form.new(self, wiki_file, version)
+        else
+          nil #Views::Raw.new(self, wiki_file, version)
+        end
+      end
+    end
+
+    # Returns a list of filtered wiki files.
+    def wiki_files
+      filter(wiki.files + wiki.pages)
+    end
+
+    # Collect a list of all views.
+    def views(version='master')
+      list = []
+      wiki_files.each do |file|
+        view = view(file, version)
+        list << view if view
+      end
+      list
+    end
+
+    # Collect a list of all posts.
+    def posts(version='master')
+      list = []
+      wiki_files.each do |file|
+        next unless Gollum::Page === file && file.post?
+        list << view(file, version)
+      end
+      list
+    end
+
+    # Returns Array of views.
+    #def views(version='master')
+    #  wiki_files.map{ |wf| view(wf) }.compact
+    #end
+
+    # Media are raw files that simply need to be passed long.
+    # Unlike assets they are versioned, but they do not need
+    # to be rendered via a view. 
+    #def media(version='master')
+    #  preload(version)
+    #  @media[version].values
+    #end
+
+    # Collect a list of all files in assets directory.
+    # These files are never versioned.
+    def assets
+      files = collect_files(wiki.path, 'assets')
+      filter(files)
+    end
+
+=begin
+    #
+    def preload(version='master')
+      @preloaded[version] ||= (
+        filtered_files.each do |file|
+          if file.extname == '.mustache'
+            view(file, version)
+          else
+            @media[version][file] = file
+          end
+        end
+        filtered_pages.each do |page|
+          view(page, version)
+        end
+        true
+      )
+    end
+=end
+
+
+    #
+    #def filtered_files
+    #  @filtered_files ||= filter(wiki.files)
+    #end
+
+    #
+    #def filtered_pages
+    #  @filtered_pages ||= filter(wiki.pages)
+    #end
+
+    #
+    def collect_files(base, offset)
+      list = []
+      dir  = ::File.join(base, offset)
+      return list unless File.directory?(dir)
+
+      ::Dir.entries(dir).each do |path|
+        next if path == '.' or path == '..'
+        subdir = ::File.join(dir, path)
+        if ::File.directory?(subdir)
+          sublist = collect_files(base, File.join(offset, path))
+          list.concat(sublist)
+        else
+          list << ::File.join(offset, path)
+        end
+      end
+      list
+    end
+
+    # Filter files according to settings `include` and `exclude` fields.
+    # Selection block can be given to further filter the list.
+    #
+    # files - Array of wiki files to be filtered.
+    #
+    # Returns [Array<String>].
+    def filter(files, &selection)
+      result = []
+      files.map do |file|
+        path = (String === file ? file : file.path)
+        unless settings.include.any?{ |x| File.fnmatch?(x, path) }
+          # TODO: If we enforce the use of underscore the we would
+          #       not need to filter out settings, partials and static locations.
+          # exclude settings file
+          next if path == Settings::FILE
+#          # exlcude assets
+#          next if path.index('assets') == 0
+          # exclude template directory (TODO: future version may allow this)
+          next if path.index(settings.partials) == 0
+          # exclude any files starting with `.` or `_`
+          next if path.split('/').any? do |x|
+            x.start_with?('_') or x.start_with?('.')
+          end
+          # exclude any files specifically exluded by settings
+          next if settings.exclude.any? do |x|
+            ::File.fnmatch?(x, path) ||
+              x.end_with?('/') && path.index(x) == 0
+          end
+        end
+        result << file
+      end
+      result = result.select(&selection) if selection
+      result
+    end
+
+    # Render wiki file.
+    #
+    # wiki_file - Gollum::Page or Gollum::File.
+    # version   - Commit id, branch or tag.
+    #
+    # Returns [String].
+    def render(wiki_file, version='master')
+      view = view(wiki_file, version)
+      render_view(view)
+    end
+
+    # Render view.
+    #
+    # view - Views::Base subclass.
+    #
+    # Returns [String].
+    def render_view(view)
+      if view.layout
+        content = Mustache.render(view.layout, view)
+      else
+        content = view.content
+      end
+
+      return content
+    end
+
+    ## For static sites we cannot depend on the web server to default a link
+    ## to a directory to the index.html file within it. So we need to append
+    ## index.html to any href links for which we have wiki pages.
+    ## This is not a prefect solution, but there may not be a better one.
+    ##
+    #def index_directory_hrefs(html)
+    #  html.gsub(/href=\"(.*)\"/) do |match|
+    #    link = "#{$1}/index.html"
+    #    if @pages[link] #if File.directory?(File.join(current_directory, $1))
+    #      "href=\"#{link}\""
+    #    else
+    #      match  # no change
+    #    end
+    #  end
+    # end
+
+    # Public: Get a list of plugin files.
+    #
+    # Returns Array of plugin files.
+    #def plugins
+    #  files.map do |f|
+    #    File.fnmatch?('_plugins/*.rb', f.path)
+    #  end
+    #end
+
+=begin
+    # Collect list of pages.
+    def pages
+      @pages ||= filtered_pages.select{ |p| !p.post? }
+    end
+
+    # Collect list of posts.
+    def posts
+      @posts ||= filtered_pages.select{ |p| p.post? }
+    end
+
+    # Collect list of non-page files to be rendered.
+    def files
+      @files ||= filtered_files.select{ |f| f.extname == '.mustache' }
+    end
+
+    # Collect list of raw asset files.
+    def assets
+      @assets ||= filtered_files.select{ |f| f.extname != '.mustache' } 
+    end
+
+    #
+    def page_views(version='master')
+      @page_views ||= pages.map{ |page| Views::Page.new(page, version) }
+    end
+
+    #
+    def post_views(version='master')
+      @post_views ||= posts.map{ |post| Views::Post.new(post, version) }
+    end
+
+    #
+    def file_views(version='master')
+      @file_views ||= files.map{ |post| Views::Template.new(file, versionb) }
+    end
+=end
+
+  end
+
+end

data/lib/smeagol/core_ext.rb

@@ -0,0 +1,12 @@
+require 'ostruct'
+
+class OpenStruct
+  def [](key)
+    __send__(key)
+  end
+
+  def []=(key, value)
+    __send__("#{key}=", value)
+  end
+end
+

data/lib/smeagol/gollum/blob_entry.rb

@@ -0,0 +1,17 @@
+module Gollum
+  class BlobEntry
+
+    # Gets a File instance for this blob.
+    #
+    # wiki - Gollum::Wiki instance for the Gollum::Page
+    #
+    # Returns a Gollum::File instance.
+    def file(wiki, commit)
+      blob = self.blob(wiki.repo)
+      file = wiki.file_class.new(wiki).populate(blob, self.dir)
+      file.version = commit
+      file
+    end
+
+  end
+end

data/lib/smeagol/gollum/file.rb

@@ -0,0 +1,44 @@
+module Gollum
+  class File
+
+    #alias :filename :name
+
+    # Populate the Page with information from the Blob.
+    #
+    # blob - The Grit::Blob that contains the info.
+    # path - The String directory path of the page file.
+    #
+    # Returns the populated Gollum::Page.
+    def populate(blob, path=nil)
+      @blob = blob
+      @path = "#{path}/#{blob.name}"[1..-1]
+      self
+    end
+
+    #
+    attr_reader :wiki
+
+    # Public: The current version of the page.
+    #
+    # Returns the Grit::Commit.
+    attr_accessor :version
+
+    # Recent addition to Gollum.
+    alias filename name unless method_defined?(:filename)
+
+    # Public: The title will be constructed from the
+    # filename by stripping the extension and replacing any dashes with
+    # spaces.
+    #
+    # Returns the fully sanitized String title.
+    def title
+      Sanitize.clean(name).strip
+    end
+
+    #
+    def extname
+      ::File.extname(path)
+    end
+
+  end
+end

data/lib/smeagol/gollum/page.rb

@@ -0,0 +1,47 @@
+module Gollum
+
+  class Page
+    def post?
+      /^(\d\d\d\d-\d\d-\d\d)/.match(filename)
+    end
+  end
+
+  class Markup
+
+    # Attempt to process the tag as a page link tag.
+    #
+    # tag       - The String tag contents (the stuff inside the double
+    #             brackets).
+    #
+    # Returns the String HTML if the tag is a valid page link tag or nil
+    #   if it is not.
+    def process_page_link_tag(tag)
+      parts = tag.split('|')
+      parts.reverse! if @format == :mediawiki
+
+      name, page_name = *parts.compact.map(&:strip)
+      cname = @wiki.page_class.cname(page_name || name)
+
+      if name =~ %r{^https?://} && page_name.nil?
+        %{<a href="#{name}">#{name}</a>}
+      else
+        presence    = "absent"
+        link_name   = cname
+        page, extra = find_page_from_name(cname)
+        if page
+          link_name = @wiki.page_class.cname(page.name)
+          presence  = "present"
+        end
+        link = ::File.join(@wiki.base_path, CGI.escape(link_name))
+
+        # TODO: This is a temporary hack for posts until actual subdirs are supported.
+        #       Also, this needs to be improved so /\d-/ does match if part of actual title.
+        link = link.gsub(/(\d)-/, '\1/')
+
+        %{<a class="internal #{presence}" href="#{link}#{extra}">#{name}</a>}
+      end
+    end
+
+  end
+
+end

data/lib/smeagol/gollum/wiki.rb

@@ -0,0 +1,31 @@
+module Gollum
+  class Wiki
+
+    # Public: Lists all non-page files for this wiki.
+    #
+    # treeish - The String commit ID or ref to find  (default:  @ref)
+    #
+    # Returns an Array of Gollum::File instances.
+    def files(treeish = nil)
+      file_list(treeish || @ref)
+    end
+
+    # Fill an array with a list of files.
+    #
+    # ref - A String ref that is either a commit SHA or references one.
+    #
+    # Returns a flat Array of Gollum::File instances.
+    def file_list(ref)
+      if sha = @access.ref_to_sha(ref)
+        commit = @access.commit(sha)
+        tree_map_for(sha).inject([]) do |list, entry|
+          next list if @page_class.valid_page_name?(entry.name)
+          list << entry.file(self, commit)
+        end
+      else
+        []
+      end
+    end
+
+  end
+end

data/lib/smeagol/helpers/rss.rb

@@ -0,0 +1,96 @@
+# TODO: Techincally @pages should probably be called @files since 
+#       it includes all files that end up in the site.
+
+require 'rss/maker'
+
+module Smeagol
+  class RSS
+    #
+    # Initialize a new Smeagol::RSS instance.
+    #
+    def initialize(ctrl, options={})
+      @ctrl    = ctrl
+      @wiki    = ctrl.wiki
+      @version = options[:version] || 'master'
+      @posts   = options[:posts]
+    end
+
+    ##
+    ## Collect the items to include in the RSS from the pages.
+    ## Only pages with post_dates are included.
+    ##
+    #def items
+    #  list = []
+    #  @pages.each do |page|
+    #    next unless Smeagol::Views::Page === page
+    #    list << page if page.post_date
+    #  end
+    #  list
+    #end
+
+    #
+    # Build the RSS instance and cache the result.
+    #
+    # Returns an RSS::Rss object.
+    #
+    def rss
+      @rss ||= build_rss
+    end
+
+    #
+    # Build an RSS instance using Ruby's RSS::Maker library.
+    #
+    # Returns an RSS::Rss object.
+    #
+    def build_rss
+     ::RSS::Maker.make('2.0') do |maker|
+        maker.channel.link         = @wiki.settings.url
+        maker.channel.title        = @wiki.settings.title
+        maker.channel.description  = @wiki.settings.description.to_s
+        maker.channel.author       = @wiki.settings.author.to_s
+        maker.channel.updated      = Time.now.to_s
+        maker.items.do_sort        = true
+
+        posts.each do |post|
+          html = post.content
+          date = Time.parse(post.post_date)
+
+          next if date > Time.now unless @wiki.settings.future
+
+          if i = html.index('</p>')
+            text = html[0..i+4]
+          else
+            text = html
+          end
+
+          maker.items.new_item do |item|
+            item.title = post.title
+            item.link  = File.join(@wiki.settings.url, post.href)
+            item.date  = date
+            item.description = text
+          end
+        end
+      end
+    end
+
+    #
+    # Convert the RSS object to XML string.
+    #
+    def to_s
+      rss.to_s
+    end
+
+    #
+    def posts
+      @ctrl.views(@version).select{ |p| p.post? }
+      #@posts ||= (
+      #  @wiki.pages.map do |page|
+      #    next unless page.post?
+      #    Smeagol::Views::Post.new(@ctrl, page)
+      #  end.compact
+      #)
+    end
+
+  end
+
+end