oaktree 0.4.4

data/lib/oaktree/specification.rb

@@ -0,0 +1,145 @@
+require 'date'
+
+class OakTree
+
+  # Specifications for the blog, operates similar to Gem::Specification.
+  # URLs and paths are strings and should not end in a slash.
+  class Specification
+    @@KEY_VALUE_PATTERN = /^\s*(?<key>[\w_]+)\s*:\s*(?<value>.*?)\s*(#|$)/
+    @@DEFAULT_DATE_PATH_FORMAT = '%Y/%m/'
+    @@DEFAULT_SLUG_SEPARATOR = '_'
+
+    def self.default_date_path_format
+      @@DEFAULT_DATE_PATH_FORMAT
+    end
+
+    def self.default_slug_separator
+      @@DEFAULT_SLUG_SEPARATOR
+    end
+
+    # The blog's title
+    attr_accessor :title
+    # A description of the blog
+    attr_accessor :description
+    # The blog root, where files are stored locally.
+    # Beneath this directory, there should be /source and /public directories,
+    # where post sources and the blog output, respectively, are stored. If these
+    # don't exist, they'll be created when generating the blog.
+    # This cannot be changed.
+    attr_reader :blog_root
+    # The name of the blog's author (currently assumes a single author)
+    attr_accessor :author
+    # The number of posts displayed per page
+    attr_accessor :posts_per_page
+    # Whether the timeline is reversed
+    attr_accessor :reversed
+    # The date format for post paths
+    attr_accessor :date_path_format
+    # The separator for words in slugs. May not be whitespace if loaded from a
+    # blog_spec file.
+    attr_accessor :slug_separator
+    # The length of the RSS feed in number of posts. Defaults to 20-most-recent.
+    attr_accessor :rss_length
+
+    # Sets the post path (i.e., the subdirectory where posts are stored).
+    # Should not begin with a slash, but can have a trailing slash if you want.
+    # If there is no trailing slash, it will be part of the filename up to a
+    # a point.
+    def post_path= path
+      raise "post_path provided is nil" if path.nil?
+      raise "post_path provided is not a string" unless path.kind_of?(String)
+
+      @post_path = path.clone().freeze()
+    end
+
+    # Gets the post path (i.e., the subdirectory where posts are stored).
+    def post_path
+      @post_path
+    end
+
+    def date_path_format= format
+      if format.empty?
+        @date_path_format = self.class.default_date_path_format
+      else
+        @date_path_format = format
+      end
+    end
+
+    # Sets the base URL of the blog (i.e., http://localhost/blog) - should have
+    # a trailing slash.
+    def base_url= url
+      url = String.new(url)
+      url << '/'  unless url.end_with? '/'
+      @base_url = url.freeze()
+    end
+
+    # Gets the base URL of the blog (i.e., http://localhost/blog).
+    def base_url
+      @base_url
+    end
+
+    def sources_root
+      @sources_root ||= "#{@blog_root}source/"
+    end
+
+    # Loads a specification from a file.
+    def self.from_file(path)
+      raise "Spec file does not exist" unless File.exists? path
+
+      self.new { |spec|
+
+        spec_contents = File.open(path, 'r') { |io| io.read }
+        spec_hash = Psych.load(spec_contents)
+        spec_hash.each {
+          |key, value|
+          setter_sym = :"#{key}="
+          if spec.respond_to? setter_sym
+            spec.send setter_sym, value
+          else
+            raise "Invalid key/value in spec: #{key} => #{value}"
+          end
+        }
+
+        Dir.chdir(File.dirname(path))
+
+      }
+    end
+
+    # Initializes the Specification with its default values.
+    def initialize
+      # initialize default values for most properties
+      self.title = ''
+      self.description = ''
+      self.base_url = ''
+      self.post_path = 'post/'
+      self.author = ''
+      self.posts_per_page = 10
+      self.reversed = false
+      self.date_path_format = self.class.default_date_path_format
+      self.slug_separator = self.class.default_slug_separator
+      self.rss_length = 20
+
+      yield self if block_given?
+
+      @blog_root = File.expand_path(Dir.getwd) + '/'
+    end
+
+    def export_string
+      <<-EOT
+# metadata
+title:  #{@title}
+description: #{@description}
+author: #{@author}
+posts_per_page: 10
+
+# public URL
+base_url:  #{@base_url}
+
+# public content paths
+post_path: #{@post_path}
+      EOT
+    end
+
+  end # Specification
+
+end # OakTree

data/lib/oaktree/template/base.rb

@@ -0,0 +1,26 @@
+require 'date'
+require 'mustache'
+require 'oaktree/template'
+
+class OakTree
+
+  module Template
+
+    class Base < Mustache
+      DEFAULT_DATETIME_FORMAT = '%-d %B %Y @ %l:%M %p'
+
+      def proc_for_datetime time
+        proc { |format|
+          format ||= DEFAULT_DATETIME_FORMAT
+
+          render(time.strftime(format))
+        }
+      end
+
+      self.template_path = 'template'
+
+    end # Base
+
+  end # Template
+
+end # OakTree

data/lib/oaktree/template/blog.rb

@@ -0,0 +1,340 @@
+require 'mustache'
+require 'date'
+require 'oaktree/template/base'
+require 'oaktree/template/post'
+require 'oaktree/template/post_archive'
+require 'uri'
+
+class OakTree
+
+  module Template
+
+    class Blog < Base
+
+      @@MODES = [:home, :archive, :single, :statics, :rss_feed].freeze()
+      @@MODE_TEMPLATES = {
+        :home => 'home'.freeze(),
+        :archive => 'archive'.freeze(),
+        :single => 'single'.freeze(),
+        :statics => 'statics'.freeze(),
+        :rss_feed => 'rss_feed'.freeze()
+      }
+
+      def self.modes
+        @@MODES
+      end
+
+      # tag to provide simple URL encoding
+      def url_encode
+        proc {
+          |input|
+          render(URI.encode_www_form_component(render(input)))
+        }
+      end
+
+      # returns an enumerator for all modes supported by the template
+      def modes
+        self.class.modes
+      end
+
+      # the default template file
+      self.template_name = 'blog'
+
+      def self.template_for_mode(mode)
+        tmp = @@MODE_TEMPLATES[mode]
+        tpath = File.expand_path("#{self.template_path}/#{tmp}.mustache")
+        (tmp && File.exists?(tpath)) ? tmp : self.template_name
+      end
+
+      def initialize tree, options = {}
+        @tree = tree
+        @spec = tree.blogspec
+        @page_index = 0
+        self.mode = options[:mode] || :home
+        raise "Invalid mode" unless @@MODES.include? @mode
+
+        @postdata = tree.posts.map { |post|
+          Post.new(@spec, post)
+        }.select(&:published?)
+
+        @posts = @postdata.select(&:post?)
+        @sorted_posts = @posts.sort_by { |p| p.post_data.time }.reverse!
+        @statics = @postdata.select(&:static?)
+
+        @posts.freeze
+        @statics.freeze
+
+        # build the archive
+        @archive = []
+        @posts.map { |post|
+          data = post.post_data
+          time = data.time
+
+          arch = @archive.last
+          if arch.nil? || arch.year != time.year || arch.month != time.month
+            arch = PostArchive.new(time.year, time.month, [], @spec, self) { |a|
+              a.next_archive = arch
+              arch.previous_archive = a unless arch.nil?
+            }
+            @archive << arch
+          end
+
+          arch.posts << post
+        }
+        @archive.freeze
+
+        page = options[:page]
+        page = page.nil? ? 0 : page - 1
+        @page_index = page
+      end
+
+      def mode= mode
+        raise "Invalid mode" unless @@MODES.include? mode
+        return mode  if @mode == mode
+        @mode = mode
+        self.template_name = self.class.template_for_mode(mode)
+      end
+
+      def mode
+        @mode
+      end
+
+      ### blog tags
+
+      def local_path
+        path = @spec.blog_root + "public/"
+        date_format = @spec.date_path_format
+
+        if home? && @page_index == 0
+          path << "index.html"
+        elsif single? || statics?
+          return post.post_data.public_path
+        elsif rss_feed?
+          path << 'feeds/rss.xml'
+        else
+          path << @spec.post_path
+
+          case mode
+            when :home
+              path << "#{@page_index}.html"
+            when :archive
+              arch = @archive[@page_index]
+              archdate = DateTime.new(arch.year, arch.month, 1)
+              path << "#{archdate.strftime(date_format)}"
+          end
+
+          path << 'index.html' if path.end_with? '/'
+        end
+
+        path
+      end
+
+      def blog_title
+        @spec.title
+      end
+
+      def blog_author
+        @spec.author
+      end
+
+      def blog_description
+        @spec.description
+      end
+
+      def blog_url
+        @spec.base_url
+      end
+
+      ### page tags
+
+      def archive?
+        @mode == :archive
+      end
+
+      def single?
+        @mode == :single
+      end
+
+      def home?
+        @mode == :home
+      end
+
+      def statics?
+        @mode == :statics
+      end
+
+      def rss_feed?
+        @mode == :rss_feed
+      end
+
+      def rss_feed_url
+        "#{@spec.base_url}feeds/rss.xml"
+      end
+
+      # uses the input as a format string for the first day of the month and year
+      # of the archive page.
+      # this returns nil if not in archive mode.
+      def archive_date
+        return nil unless archive?
+        proc_for_datetime(@archive[@page_index])
+      end
+
+      def statics
+        @statics
+      end
+
+      # returns the number of pages
+      def pages
+        case mode
+          # you can render multiple home pages, but it's not something I recommend
+          # since re-syncing all homepage posts is a nightmare at some point
+          when :home
+            if @spec.posts_per_page > 0
+              (@posts.length / @spec.posts_per_page) + 1
+            else
+              1
+            end
+
+          when :archive ; @archive.length
+          when :single ; @posts.length
+          when :statics ; @statics.length
+          when :rss_feed ; 1
+        end
+      end
+
+      # returns the current page number
+      def page
+        @page_index + 1
+      end
+
+      def page= page_num
+        @next_url_cache = nil
+        @prev_url_cache = nil
+        @posts_cache = nil
+        @page_index = (page_num - 1)
+      end
+
+      def paged?
+        has_previous? || has_next?
+      end
+
+      # determines whether there's a previous page.  previous also means older.
+      def has_previous?
+        self.page < self.pages
+      end
+
+      # determines whether there is a next page.  next also means newer.
+      def has_next?
+        1 < self.page
+      end
+
+      def next_url
+        return "" unless has_next?
+
+        @next_url_cache ||= case mode
+          when :home
+            if @page_index == 1
+              blog_url
+            else
+              blog_url + @spec.post_path + "#{@page_index - 1}.html"
+            end
+          when :archive ; @archive[@page_index - 1].permalink
+          when :single ; @posts[@page_index - 1].permalink
+        end
+      end
+
+      def previous_url
+        return "" unless has_previous?
+
+        @prev_url_cache ||= case mode
+          when :home ; blog_url + @spec.post_path + "#{@page_index + 1}.html"
+          when :archive ; @archive[@page_index + 1].permalink
+          when :single ; @posts[@page_index + 1].permalink
+        end
+      end
+
+      ### archive tags
+
+      def archives
+        @archive
+      end
+
+      # the current archive
+      def archive
+        @archive[@page_index] if archive?
+      end
+
+      ### post tags
+
+      # returns all visible posts
+      # note: visible means whatever is in the current page
+      def posts
+        @posts_cache ||= case mode
+          when :home
+            if @spec.posts_per_page > 0
+              page_start = @page_index * @spec.posts_per_page
+              page_end = page_start + @spec.posts_per_page - 1
+              if @posts.length < page_end
+                page_end = @posts.length
+              end
+
+              return [] unless page_start < @posts.length
+
+              @posts[page_start .. page_end]
+            else
+              @posts[0..-1]
+            end
+
+          when :archive ; @archive[@page_index].posts
+          when :single ; [@posts[@page_index]]
+          when :statics ; [@statics[@page_index]]
+
+          when :rss_feed
+            rss_length = @spec.rss_length - 1
+            rss_length = -1  if rss_length < -1
+            @sorted_posts[0..(rss_length - 1)]
+        end
+      end
+
+      # if there's only one post being displayed, this returns its template.
+      # only works in single mode.
+      def post
+        case mode
+        when :single ; @posts[@page_index]
+        when :statics ; @statics[@page_index]
+        end
+      end
+
+      # returns the next post (you generally shouldn't use this except to get
+      # some small bit of info about the next post).
+      # only works in single mode.
+      def next_post
+        single? && has_next? ? @posts[page_index - 1] : nil
+      end
+
+      # returns the previous post.
+      # only works in single mode.
+      def previous_post
+        single? && has_previous? ? @posts[page_index + 1] : nil
+      end
+
+      def next_archive
+        archive? && has_next? ? @archive[page_index - 1] : nil
+      end
+
+      def previous_archive
+        archive? && has_previous? ? @archive[page_index + 1] : nil
+      end
+
+      ### general tags
+
+      # treats the input text as a format string for today's date and time
+      def today
+        proc_for_datetime(DateTime.now)
+      end
+
+    end # Blog
+
+  end # Template
+
+end # OakTree

data/lib/oaktree/template/post.rb

@@ -0,0 +1,91 @@
+require 'kramdown'
+require 'oaktree/template'
+require 'oaktree/kramdown/oak_html'
+
+class OakTree
+
+  module Template
+
+    class Post < Base
+
+      self.template_name = 'post'
+
+      def initialize spec, post
+        @post = post
+        @content = nil
+        @spec = spec
+        document = ::Kramdown::Document.new(@post.content)
+        @content, warnings = ::OakTree::Kramdown::OakHtml.convert(document.root, :auto_id_prefix => @post.time.strftime('%Y_%m_%d_'))
+        puts warnings unless warnings.empty?
+      end
+
+      def post_data
+        @post
+      end
+
+      def title
+        @post.title
+      end
+
+      def url
+        if source_link?
+          source_link
+        else
+          permalink
+        end
+      end
+
+      def permalink
+        @post.permalink
+      end
+
+      def source_link
+        @post.link
+      end
+
+      def source_link?
+        plink = @post.link
+        ! (plink.nil? || plink.empty?)
+      end
+
+      def static?
+        @post.kind == :static
+      end
+
+      def post?
+        @post.kind == :post
+      end
+
+      def content
+        @content
+      end
+
+      def time
+        proc_for_datetime(@post.time)
+      end
+
+      def public_path
+        @post.public_path
+      end
+
+      def slug
+        @post.slug
+      end
+
+      def published?
+        @post.status == :published
+      end
+
+      def unpublished?
+        ! published?
+      end
+
+      def status
+        @post.status
+      end
+
+    end # Post
+
+  end # Template
+
+end # OakTree

data/lib/oaktree/template/post_archive.rb

@@ -0,0 +1,53 @@
+require 'oaktree/template/base'
+require 'mustache'
+require 'date'
+
+class OakTree
+
+  module Template
+
+    class PostArchive < Base
+      self.template_name = "postarchive"
+
+      attr_accessor :year
+      attr_accessor :month
+      attr_accessor :posts
+      # the next most recent archive
+      attr_accessor :next_archive
+      # the next oldest archive
+      attr_accessor :previous_archive
+
+      def initialize year=1, month=1, posts=[], spec, blog
+        @year = year
+        @month = month
+        @posts = posts
+        @spec = spec
+        @blog = blog
+        @datetime = DateTime.new(year, month, 1)
+        formatted_date = @datetime.strftime(@spec.date_path_format)
+        @permalink = "#{@spec.base_url}#{@spec.post_path}#{formatted_date}"
+
+        yield self if block_given?
+      end
+
+      def date
+        proc_for_datetime(@datetime)
+      end
+
+      def datetime
+        @datetime
+      end
+
+      def permalink
+        @permalink
+      end
+
+      def open?
+        self == @blog.archive
+      end
+
+    end
+
+  end
+
+end

data/lib/oaktree/template.rb

@@ -0,0 +1,19 @@
+require 'mustache'
+require 'date'
+
+class OakTree
+  
+  module Template
+    
+    # Probably shouldn't do this, but it simplifies life.
+    Mustache.template_path = 'template'
+    
+    autoload :Base, 'oaktree/template/base'
+    autoload :PostArchive, 'oaktree/template/post_archive'
+    autoload :Post, 'oaktree/template/post'
+    autoload :Blog, 'oaktree/template/blog'
+    
+  end # Template
+  
+end # OakTree
+