oaktree 0.4.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75d3078e95fe1e754b7ec050599c359309ac9987
+  data.tar.gz: e8922bf74025c7677559e57e930c38d75ac4ac6f
+SHA512:
+  metadata.gz: 5bc2963c2cf05e06f91b260463b8f744ed60e10046044098abd75ce52660cfe42ec806f9e2d18d3fe450b87c7ca6f2de048603e02fc1ce1409307f3a4a406fe3
+  data.tar.gz: ef0ececc42e093219f6442aeb1a2f5485f06c4e119b5d22336942ce00dcedc68df73da2acb203900fdd1da451461e50fbdc52b4697356eb4b533182ba6f0c44e

data/COPYING

@@ -0,0 +1,6 @@
+ Copyright (C) 2012 Noel Cower <ncower@gmail.com>
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.md

@@ -0,0 +1,46 @@
+# OakTree
+
+## What in the nine hells is OakTree?
+
+OakTree is an odd little static HTML blog gem thingy written by Noel R. Cower (hereinafter "yours truly" or just "I," because writing in the third person about my work is annoying).  It is designed to fit my purposes - which is to say a very simple blog with very simple needs (has text, posts, some links, and my template).  At present, it works moderately well at generating simple blogs – that is, HTML-only, no RSS feeds yet.
+
+The entire interface for OakTree goes through its lone executable, `oak`.  `oak` is intended to allow you to create posts, watch for changes, generate output HTML, and so on.  If it's not obvious, this is all designed to be _very_ simple, because complex setups would be overkill.
+
+## How do I get all up in this OakTree?
+
+For one, I apologize that I've used the phrase "get all up in X."  For two, the only way to use OakTree is to download this and build the gem and install it yourself.  This is actually fairly simple, provided I didn't commit something which opened a portal to hell.  You really just want to do something like this:
+
+	$ rake package
+	$ cd pkg
+	$ gem install oaktree-<version>.gem
+	... or, more likely ...
+	$ sudo gem install oaktree-<version>.gem
+
+And, if you use rbenv, run `rbenv rehash` afterward, of course.  I don't know what to tell you about RVM (aside from it being the destroyer of worlds, but that's another issue entirely), but you can figure it out.  It's probably got a manpage or something.
+
+After that, hop into some empty directory and run `oak init` to start a blog.  At this point, you can being creating posts by either a) creating your own files in the _source/_ directory or using `oak newpost [title]` (where `[title]` is the title of your post).  If you want to customize the blog's template, which I imagine you will, head on into _template/_ and begin tweaking _blog.mustache_.  You will probably want to break things up into smaller template pieces to avoid getting bogged down with figuring out what's where in the mess of mustaches.  For documentation on all available template tags, read _tags.md_.  Finally, you'll want to configure your _blog_spec_ file.  See _specs.md_ for info what options are available there, or just read _specification.rb_.
+
+Once you've got all those things sorted out and you want to generate a blog, run `oak sync` in the same directory as your _blog_spec_ (I might do something git-ier later for that).  This will build the HTML for your blog under _public/_.  If you make further changes to the source files, you can run `oak sync` again and it will rebuild only files that need to be rebuilt (hopefully).  Should you make changes to the template, you'll need to run `oak rebuild` to rebuild the entire blog (or delete the contents of _public/_), as `oak sync` does not account for template changes (it's a lot harder to figure out template dependencies accurately and doing it poorly seems like a bad idea, so I don't do it at all).
+
+You may now commence uploading or using rsync or what have you to shunt your blog up somewhere.  This may also be compatible with GitHub pages, but I'm not sure.  Give it a shot.
+
+## What kind of license is OakTree under?
+
+How kind of you to ask.  OakTree is licensed under the WTFPL-2:
+
+    Copyright (C) 2012 Noel Cower <ncower@gmail.com>
+    
+               DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+      TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+    
+     0. You just DO WHAT THE FUCK YOU WANT TO.
+
+If you have any questions about licensing, please direct them to the incinerator, because the license (also found in the _COPYING_ file that should have accompanied this repository) already answered those questions.
+
+## Anything else I should know?
+
+No, but I'll reiterate this point again: **OakTree is unfinished, very unstable, and very much a work in progress.**  If you attempt to make use of it, there's a good chance I cannot do anything to make your life better or help you, because you've already sealed your fate.
+
+## Why is it called 'OakTree?'
+
+Because it's easy to type and `oak` is even easier to type.  There is a possibility that the entire project will just be renamed to 'oak' just to make me happy and remove four characters that I would otherwise have to type.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems/package_task'
+require 'rake/testtask'
+require 'rake/clean'
+
+spec = Gem::Specification.load 'oaktree.gemspec'
+
+desc 'Run tests'
+Rake::TestTask.new { |task|
+  task.libs << 'test'
+  files = FileList['test/**/test_*.rb'].to_a
+  task.test_files = files
+}
+
+desc "Build #{spec.name} #{spec.version.to_s}"
+Gem::PackageTask.new(spec) { |task|
+  task.need_zip = true
+}
+
+CLEAN.include 'pkg'
+
+task :default => :test

data/bin/oak

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby
+
+require 'oaktree'
+require 'fileutils'
+
+# Constants
+
+APP_NAME = 'oak'
+
+GEM_NAME = 'oaktree'
+
+HELP_TEXT = <<EOH
+#{APP_NAME} <command> ...
+
+COMMANDS
+* -n, newpost [title]
+Creates a new post.  If no title is given, the post's title is "Untitled".
+The new post is placed in the blog's source/ directory
+
+* -i, init [dir]
+Creates a 'blog_spec' file and required directories in the given directory
+if blog_spec doesn't already exist.  If no directory is provided, oak uses
+the working directory.
+
+* -s, sync
+Builds HTML files for changed posts.  This does not rebuild files following
+template changes.  If you've made changes to templates, you should use the
+rebuild command.
+
+* -r, rebuild
+Builds HTML files for all posts, regardless of whether they've been changed.
+
+* -v, version
+Shows the version of oak and the oaktree gem.
+
+* -h, help
+Shows this help text.
+
+EOH
+
+BLOG_TEMPLATE = <<EOT
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
+  <title>{{blog_title}}{{#post}} &raquo; {{title}}{{/post}}</title>
+</head>
+<body>
+
+  <div id="header">
+    <h1 id="blog-title"><a href="{{blog_url}}index.html">{{blog_title}}</a></h1>
+    <p>
+      <span class="blog-description">{{blog_description}}<br/></span>
+      <span class="blog-byline">By {{blog_author}}</span>
+    </p>
+  </div><!-- title -->
+
+  <div id="posts">
+    {{#posts}}
+    <div class="post">
+      <div class="post-header">
+        <h2 class="post-title">
+          <a href="{{url}}">{{#source_link?}}&#x2192; {{/source_link?}}{{title}}</a>
+        </h2>
+        <span class="post-time">{{#time}}%-d %B %Y{{/time}}</span>
+      </div><!-- post-header -->
+      <div class="post-body">
+        {{{content}}}
+      </div><!-- post-body -->
+    </div><!-- post: {{title}} -->
+    {{/posts}}
+  </div><!-- posts -->
+
+  {{#paged?}}
+  <div id="nav-bar">
+    {{#has_previous?}}<a href="{{previous_url}}">&#x2190;
+      {{#archive}}{{#previous_archive}}{{#date}}%B %Y{{/date}}{{/previous_archive}}{{/archive}}{{^archive}}older{{/archive}}
+    </a>{{/has_previous?}}
+    {{#has_next?}}{{#has_previous?}} &mdash; {{/has_previous?}}{{/has_next?}}
+    {{#has_next?}}<a href="{{next_url}}">
+      {{#archive}}{{#next_archive}}{{#date}}%B %Y{{/date}}{{/next_archive}}{{/archive}}{{^archive}}newer{{/archive}}
+    &#x2192;</a>{{/has_next?}}
+
+  </div>
+  {{/paged?}}
+
+  <div id="archives">
+    <h4>Archives</h4>
+    <ul>
+    {{#archives}}
+      <li>
+        {{^open?}}<a href="{{permalink}}">{{/open?}}
+          {{#date}}%B %Y{{/date}}
+        {{^open?}}</a>{{/open?}}
+      </li>
+    {{/archives}}
+    </ul>
+  </div><!-- archives -->
+
+  <div class="copyright">
+    Copyright &copy; {{#today}}%Y{{/today}} {{blog_author}}. All rights reserved.
+    Made with <a href="https://github.com/nilium/oaktree">OakTree</a>.
+  </div><!-- copyright -->
+
+</body>
+</html>
+EOT
+
+RSS_FEED_TEMPLATE = <<EOT
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>{{blog_title}}</title>
+    <link>{{blog_url}}</link>
+    <description>{{blog_description}}</description>
+    <pubDate>{{#today}}%a, %d %b %Y %T %z{{/today}}</pubDate>
+    <docs>http://www.rssboard.org/rss-2-0-1</docs>
+    {{#posts}}<item>
+      <title>{{title}}</title>
+      <link>{{permalink}}</link>
+      <description><![CDATA[{{{content}}}]]></description>
+    </item>{{/posts}}
+  </channel>
+</rss>
+EOT
+
+# Commands
+
+# Generate a new blog_spec and create 'source' and 'public' directories under
+# the given directory.
+def init_blog directory
+  if ! (File.exists?(directory) && File.directory?(directory)) && directory != '.'
+    FileUtils.mkdir_p directory
+  end
+
+  Dir.chdir(directory) { |path|
+    if File.exists? 'blog_spec' then
+      raise "blog_spec already exists in #{directory}"
+    end
+
+    Dir.mkdir 'source'
+    Dir.mkdir 'public'
+    Dir.mkdir 'template'
+
+    File.open('blog_spec', 'w') { |io| io.write OakTree::Specification.new.export_string }
+    File.open('template/blog.mustache', 'w') { |io| io.write BLOG_TEMPLATE }
+    File.open('template/rss_feed.mustache', 'w') { |io| io.write RSS_FEED_TEMPLATE }
+  }
+end
+
+
+# Show the version
+def show_version
+  version = OakTree::VERSION
+
+  puts "#{GEM_NAME} version #{version} (ruby #{RUBY_VERSION} #{RUBY_PLATFORM} #{RUBY_RELEASE_DATE})"
+end
+
+
+# Show the help text for oak
+def show_help
+  puts HELP_TEXT
+  show_version
+end
+
+
+# Generate a new post file for the blog
+def new_post spec, title
+  title = title.gsub(/[\n\t]+/, '').strip
+
+  today = DateTime.now
+
+  titleslug = title.gsub(/[^_\w\s]/, '').strip.gsub(/\s+/, '_').downcase
+  timeslug = today.strftime '%Y-%m-%d'
+
+  file = "#{spec.sources_root}#{timeslug}_#{titleslug}.md"
+
+  head = <<HEADSTR
+title: #{title}
+time: #{today.strftime '%Y-%m-%d %H:%M:%S %z'}
+----
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
+incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis
+nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu
+fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
+culpa qui officia deserunt mollit anim id est laborum.
+HEADSTR
+
+  IO.write file, head
+
+  return file
+end
+
+
+def sync_changes spec, force
+  raise "No blog_spec found" if spec.nil?
+
+  blog = OakTree.new spec
+  blog.generate force
+end
+
+# Command selector majigger
+def dispatch_command cmd, *args
+
+
+  spec = (File.exists? 'blog_spec') ? (OakTree::Specification.from_file 'blog_spec') : nil
+
+  case cmd
+
+    when 'newpost', '-n'
+      raise "Not in a blog directory" unless File.exists? 'blog_spec'
+
+      open_editor = false
+      title = ''
+
+      until args.empty?
+        arg = args.shift
+
+        # finnagling with arguments
+        if arg =~ /^(--[^=]+)=(.*)$/
+          arg = $1
+          args.unshift $2
+        end
+
+        if arg =~ /^(-[t])(.+)$/
+          arg = $1
+          args.unshift $2
+        end
+
+        case arg
+          when '-t', '--time'
+            output_dir = args.shift
+            break unless title.empty?
+          when '-e', '--edit'
+            open_editor = true
+          else
+            title = "#{title} #{arg}"
+        end
+      end
+
+      title = 'Untitled' if title.empty?
+      title = args.join ' ' unless args.empty?
+      file = new_post(spec, title)
+
+      if open_editor
+        editor = ENV['EDITOR'] || 'open'
+        %x["#{editor}" "#{file}"]
+      end
+
+    when 'init', '-i'
+      directory = '.'
+      directory = args[0] unless args.empty?
+      init_blog directory
+
+    when 'version', '-v'
+      show_version
+
+    when 'help', '-h'
+      show_help
+
+    when 'rebuild', '-r'
+      sync_changes spec, true
+
+    when 'sync', '-s'
+      sync_changes spec, false
+
+    else
+      puts "Unrecognized command '#{cmd}'\n\n"
+
+      show_help
+
+  end
+
+end
+
+
+# Main logic
+
+if ARGV.empty? then
+  show_help
+else
+  dispatch_command ARGV[0], *ARGV[1..ARGV.length]
+end

data/lib/oaktree/kramdown/oak_html.rb

@@ -0,0 +1,48 @@
+require 'kramdown'
+require 'kramdown/element'
+
+class OakTree
+  
+  module Kramdown
+    
+    class OakHtml < ::Kramdown::Converter::Html
+      
+      def convert_footnote el, indent
+        if @options[:auto_id_prefix]
+          el.options[:name] = @options[:auto_id_prefix] + el.options[:name]
+        end
+        super
+      end
+      
+      def convert_div el, indent
+        "<#{el.type}#{html_attributes el.attr}>\n#{inner el, indent+1}\n</#{el.type}>"
+      end
+      
+      def footnote_content
+        return '' if @footnotes.empty?
+        
+        block = ::Kramdown::Element.new(:div, nil, {'class' => 'footnotes'})
+        block.children << (list = ::Kramdown::Element.new(:ol))
+        
+        @footnotes.each { |fn_name, fn_elem|
+          item = ::Kramdown::Element.new(:li, nil, {'id' => "fn:#{fn_name}"})
+          # because we'll end up manipulating a child, we may as well do a deep copy
+          item.children = Marshal.load(Marshal.dump(fn_elem.children))
+          
+          # basically what kramdown already does here
+          last = (last = item.children.last).type == :p ? last : (::Kramdown::Element.new(:p))
+          # yes, I'm using rev, shut up
+          last.children << (anchor = ::Kramdown::Element.new(:a, nil, {'href' => "#fnref:#{fn_name}", 'rev' => 'footnote'}))
+          anchor.children << ::Kramdown::Element.new(:raw, '&#8617;')
+
+          list.children << item
+        }
+        
+        convert(block, 2)
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/oaktree/post_data.rb

@@ -0,0 +1,236 @@
+require 'date'
+require 'digest'
+require 'psych'
+
+class OakTree ; end
+
+
+# Contains the contents of a single post under the sources/ directory. Unlike
+# past versions of PostData, this does not synchronize with the source file
+# every time a member is accessed. It's assumed that what you got when you
+# loaded the post is what you wanted and that any further changes must be
+# explicitly synchronized.
+#
+class OakTree::PostData
+
+  attr_accessor :source_name
+  attr_accessor :source_path
+  # The path to the HTML file that's written when compiling the post.
+  attr_accessor :public_path
+  attr_accessor :title
+  attr_accessor :link
+  attr_accessor :permalink
+  attr_reader :time
+  # The post's slug, a filesystem- and URL-friendly string.
+  attr_reader :slug
+  # The post's body -- that is, the actual content of the blog post.
+  attr_accessor :content
+  # The time when the file was last read. Used to determine if sync_changes will
+  # reload the file. Defaults to the Unix epoch.
+  attr_accessor :last_read_time
+  # The kind of post this is. Expected to be either :post or :static, though
+  # the value is arbitrary.
+  attr_reader :kind
+  # The post's status. Either :published or :unpublished, though only :published
+  # holds meaning -- other values are assumed to be unpublished.
+  attr_reader :status
+  attr_accessor :hash
+  attr_accessor :spec
+
+  protected :source_path=, :public_path=, :title=, :link=, :content=,
+            :last_read_time=, :hash=, :spec=, :permalink=, :source_name=
+
+  # Loads a new post from the source file using the given Specification. The
+  # source file should be the full filename of the source file, but without any
+  # other path components.
+  #
+  def initialize(source_name, spec)
+    set_post_defaults
+
+    self.spec = spec
+
+    self.hash = nil
+    self.last_read_time = Time.at(0).to_datetime
+
+    self.source_name = source_name
+    self.source_path = File.absolute_path(source_name,
+                                          spec.sources_root).freeze()
+
+    raise "File doesn't exist: #{@source_path}"  if ! File.exists? @source_path
+
+    sync_changes true
+  end # initialize
+
+  # Returns the default 'kind' a post should be. Typically means :post, though
+  # it may change in the future.
+  #
+  def self.default_kind
+    :post
+  end
+
+  # Returns the default 'status' a post should have. Typically :published, but
+  # this may change in the future.
+  #
+  def self.default_status
+    :published
+  end
+
+  # The regexp for identifying the line that separates the post head from the
+  # post body. This is typically three or more hyphens.
+  def self.metadata_separator
+    /^-{3,}\s*$/
+  end
+
+  #   Synchronizes changes between the post's file and the post data object. If
+  #   'forced' is true (or non-false/nil), it will reload the file regardless of
+  #   whether it's considered necessary.
+  #
+  #   A "necessary" reload is when the file's hash changes or the file's last
+  #   modification time is more recent than what the post data last read.
+  #
+  def sync_changes(forced = false)
+    raise "Source file does not exist."  unless File.exists? @source_path
+
+    source_differs  = !! forced
+    source_mtime    = File.mtime(@source_path).to_datetime()
+    source_contents = File.open(@source_path, 'r') { |io| io.read }
+    source_hash     = Digest::SHA1.hexdigest(source_contents).freeze()
+
+    if ! forced
+      # Check that the source differs from what was last checked.
+      source_differs = (hash != source_hash)
+      public_exists  = (@public_path && File.exists?(@public_path))
+
+      # Check if the public file is older than the current source file.
+      if ! source_differs && public_exists
+        public_mtime = File.mtime(@public_path).to_datetime()
+
+        source_differs = true  if public_mtime < source_mtime
+      end
+
+      if ! source_differs && @last_read_time < source_mtime
+        source_differs = true
+      end
+    end # ! forced
+
+    return  if ! source_differs
+
+    self.last_read_time = source_mtime
+
+    # Reset the post's members to an unloaded state
+    set_post_defaults
+    self.hash = source_hash
+
+    source_split = source_contents.partition(self.class.metadata_separator)
+
+    load_header source_split[0]
+    self.content = source_split[2]
+
+    self
+  end # sync_changes
+
+  protected
+
+  # The regular expression used to fix post slugs. Basically matches groups of
+  # non-alphanumeric characters. This is used to replace slug-unfriendly chunks
+  # of new slugs with slug word separators.
+  #
+  def self.slug_fix_regexp
+    %r{(?:[^[:alnum:]] | [[:space:]])+}x
+  end
+
+  # Sets the default values for the post's data-related instance variables, so
+  # anything loaded during synchronization gets reset by this. Includes the
+  # post title, date, status, etc.
+  #
+  def set_post_defaults
+    self.public_path = nil
+    self.title       = nil
+    self.link        = nil
+    self.permalink   = nil
+    self.time        = nil
+    self.slug        = ''.freeze()
+
+    self.kind        = self.class.default_kind
+    self.status      = self.class.default_status
+  end # set_post_defaults
+
+  # Reads the header from the header_source string into the post data. Currently
+  # uses Psych to parse the header as YAML.
+  #
+  def load_header(header_source)
+    begin
+      header_hash = Psych.load(header_source)
+    rescue Psych::SyntaxError => ex
+      puts "Failed to parse header for #{@source_name}"
+      raise
+    end
+
+    header_hash.each {
+      |key, value|
+      setter_sym = "#{key.to_s}=".to_sym
+      if self.respond_to?(setter_sym, true)
+        self.send setter_sym, value
+      else
+        raise "Invalid key/value for header: #{key} => #{value}."
+      end
+    }
+
+    self.slug = title  if ! slug || slug.empty?
+
+    # Set the public HTML path and the permalink now that we have enough info
+    # about the post.
+    root = spec.blog_root
+    url = spec.base_url
+
+    link_path = String.new(spec.post_path)
+    link_path << @time.strftime(spec.date_path_format)  if kind == :post
+    link_path << slug
+
+    self.public_path = "#{root}public/#{link_path}/index.html".freeze()
+    self.permalink = "#{url}#{link_path}"
+
+    nil
+  end # load_header
+
+  # Assigns a new time to the post -- the time must be a DateTime object or a
+  # String capable of being parsed by DateTime.parse.
+  def time=(new_time)
+    @time = if new_time
+              case new_time.class
+              when DateTime ; new_time
+              when String ; DateTime.parse new_time
+              else new_time.to_datetime
+              end
+            else
+              Time.at(0).to_datetime
+            end
+  end
+
+  # Sets the post slug, ensuring it's formatted properly.
+  def slug=(new_slug)
+    slug_temp = new_slug
+    if slug_temp
+      slug_temp = String.new(new_slug)
+      slug_temp.strip!
+
+      unless slug_temp.empty?
+        slug_temp.downcase!
+        slug_temp.gsub!(self.class.slug_fix_regexp, @spec.slug_separator)
+      end
+    else
+      slug_temp = ''
+    end
+
+    @slug = slug_temp.freeze()
+  end # slug=
+
+  def kind=(new_kind)
+    @kind = new_kind.to_sym
+  end
+
+  def status=(new_status)
+    @status = new_status.to_sym
+  end
+
+end