toto_prerelease 0.4.7prerelease

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+nbproject

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 cloudhead
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,162 @@
+toto
+====
+
+the tiniest blogging engine in Oz!
+
+introduction
+------------
+
+toto is a git-powered, minimalist blog engine for the hackers of Oz. The engine weighs around ~300 sloc at its worse.
+There is no toto client, at least for now; everything goes through git.
+
+blog in 10 seconds
+------------------
+
+    $ git clone git://github.com/cloudhead/dorothy.git myblog
+    $ cd myblog
+    $ heroku create myblog
+    $ git push heroku master
+
+philosophy
+----------
+
+Everything that can be done better with another tool should be, but one should not have too much pie to stay fit.
+In other words, toto does away with web frameworks or DSLs such as sinatra, and is built right on top of **rack**.
+There is no database or ORM either, we use plain text files.
+
+Toto was designed to be used with a reverse-proxy cache, such as [Varnish](http://varnish-cache.org).
+This makes it an ideal candidate for [heroku](http://heroku.com).
+
+Oh, and everything that can be done with git, _is_.
+
+how it works
+------------
+
+- content is entirely managed through **git**; you get full fledged version control for free.
+- articles are stored as _.txt_ files, with embeded metadata (in yaml format).
+- articles are processed through a markdown converter (rdiscount) by default.
+- templating is done through **ERB**.
+- toto is built right on top of **Rack**.
+- toto was built to take advantage of _HTTP caching_.
+- toto was built with heroku in mind.
+- comments are handled by [disqus](http://disqus.com)
+- individual articles can be accessed through urls such as _/2009/11/21/blogging-with-toto_
+- the archives can be accessed by year, month or day, wih the same format as above.
+- arbitrary metadata can be included in articles files, and accessed from the templates.
+- summaries are generated intelligently by toto, following the `:max` setting you give it.
+- you can also define how long your summary is, by adding `~` at the end of it (`:delim`).
+
+dorothy
+-------
+
+Dorothy is toto's default template, you can get it at <http://github.com/cloudhead/dorothy>. It
+comes with a very minimalistic but functional template, and a _config.ru_ file to get you started.
+It also includes a _.gems_ file, for heroku.
+
+synopsis
+--------
+
+One would start by installing _toto_, with `sudo gem install toto`, and then forking or
+cloning the `dorothy` repo, to get a basic skeleton:
+
+    $ git clone git://github.com/cloudhead/dorothy.git weblog
+    $ cd weblog/
+
+One would then edit the template at will, it has the following structure:
+
+    templates/
+    |
+    +- layout.rhtml      # the main site layout, shared by all pages
+    |
+    +- index.builder     # the builder template for the atom feed
+    |
+    +- pages/            # pages, such as home, about, etc go here
+       |
+       +- index.rhtml    # the default page loaded from `/`, it displays the list of articles
+       |
+       +- article.rhtml  # the article (post) partial and page
+       |
+       +- about.rhtml
+
+One could then create a .txt article file in the `articles/` folder, and make sure it has the following format:
+
+    title: The Wonderful Wizard of Oz
+    author: Lyman Frank Baum
+    date: 1900/05/17
+
+    Dorothy lived in the midst of the great Kansas prairies, with Uncle Henry,
+    who was a farmer, and Aunt Em, who was the farmer's wife.
+
+If one is familiar with webby or aerial, this shouldn't look funny. Basically the top of the file is in YAML format,
+and the rest of it is the blog post. They are delimited by an empty line `/\n\n/`, as you can see above.
+None of the information is compulsory, but it's strongly encouraged you specify it.
+Note that one can also use `rake` to create an article stub, with `rake new`.
+
+Once he finishes writing his beautiful tale, one can push to the git repo, as usual:
+
+    $ git add articles/wizard-of-oz.txt
+    $ git commit -m 'wrote the wizard of oz.'
+    $ git push remote master
+
+Where `remote` is the name of your remote git repository. The article is now published.
+
+### deployment
+
+Toto is built on top of **Rack**, and hence has a **rackup** file: _config.ru_.
+
+#### on your own server
+
+Once you have created the remote git repo, and pushed your changes to it, you can run toto with any Rack compliant web server,
+such as **thin**, **mongrel** or **unicorn**.
+
+With thin, you would do something like:
+
+    $ thin start -R config.ru
+
+With unicorn, you can just do:
+
+    $ unicorn
+
+#### on heroku
+
+Toto was designed to work well with [heroku](http://heroku.com), it makes the most out of it's state-of-the-art caching,
+by setting the _Cache-Control_ and _Etag_ HTTP headers. Deploying on Heroku is really easy, just get the heroku gem,
+create a heroku app with `heroku create`, and push with `git push heroku master`.
+
+    $ heroku create weblog
+    $ git push heroku master
+    $ heroku open
+
+### configuration
+
+You can configure toto, by modifying the _config.ru_ file. For example, if you want to set the blog author to 'John Galt',
+you could add `set :author, 'John Galt'` inside the `Toto::Server.new` block. Here are the defaults, to get you started:
+
+    set :author,      ENV['USER']                               # blog author
+    set :title,       Dir.pwd.split('/').last                   # site title
+    set :url,         'http://example.com'                      # site root URL
+    set :prefix,      ''                                        # common path prefix for all pages
+    set :root,        "index"                                   # page to load on /
+    set :date,        lambda {|now| now.strftime("%d/%m/%Y") }  # date format for articles
+    set :markdown,    :smart                                    # use markdown + smart-mode
+    set :disqus,      false                                     # disqus id, or false
+    set :summary,     :max => 150, :delim => /~\n/              # length of article summary and delimiter
+    set :ext,         'txt'                                     # file extension for articles
+    set :cache,       28800                                     # cache site for 8 hours
+
+    set :to_html   do |path, page, ctx|                         # returns an html, from a path & context
+      ERB.new(File.read("#{path}/#{page}.rhtml")).result(ctx)
+    end
+
+    set :error     do |code|                                    # The HTML for your error page
+      "<font style='font-size:300%'>toto, we're not in Kansas anymore (#{code})</font>"
+    end
+
+thanks
+------
+
+To heroku for making this easy as pie.
+To adam wiggins, as I stole a couple of ideas from Scanty.
+To the developpers of Rack, for making such an awesome platform.
+
+Copyright (c) 2009-2010 cloudhead. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "toto"
+    gem.summary = %Q{the tiniest blog-engine in Oz}
+    gem.description = %Q{the tiniest blog-engine in Oz.}
+    gem.email = "self@cloudhead.net"
+    gem.homepage = "http://github.com/cloudhead/toto"
+    gem.authors = ["cloudhead"]
+    gem.add_development_dependency "riot"
+    gem.add_dependency "builder"
+    gem.add_dependency "rack"
+    if RUBY_PLATFORM =~ /win32/
+      gem.add_dependency "maruku"
+    else
+      gem.add_dependency "rdiscount"
+    end
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+task :default => :test

data/TODO

@@ -0,0 +1,2 @@
+TODO
+====

data/VERSION

@@ -0,0 +1 @@
+0.4.7prerelease

data/lib/ext/ext.rb

@@ -0,0 +1,46 @@
+class Object
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval do
+      define_method(name, &blk)
+    end
+  end
+end
+
+class String
+  def slugize
+    self.downcase.gsub(/&/, 'and').gsub(/\s+/, '-').gsub(/[^a-z0-9-]/, '')
+  end
+
+  def humanize
+    self.capitalize.gsub(/[-_]+/, ' ')
+  end
+end
+
+class Fixnum
+  def ordinal
+    # 1 => 1st
+    # 2 => 2nd
+    # 3 => 3rd
+    # ...
+    case self % 100
+      when 11..13; "#{self}th"
+    else
+      case self % 10
+        when 1; "#{self}st"
+        when 2; "#{self}nd"
+        when 3; "#{self}rd"
+        else    "#{self}th"
+      end
+    end
+  end
+end
+
+class Date
+  # This check is for people running Toto with ActiveSupport, avoid a collision
+  unless respond_to? :iso8601
+    # Return the date as a String formatted according to ISO 8601.
+    def iso8601
+      ::Time.utc(year, month, day, 0, 0, 0, 0).iso8601
+    end
+  end
+end

data/lib/toto.rb

@@ -0,0 +1,358 @@
+require 'yaml'
+require 'date'
+require 'erb'
+require 'rack'
+require 'digest'
+require 'open-uri'
+
+if RUBY_PLATFORM =~ /win32/
+  require 'maruku'
+  Markdown = Maruku
+else
+  require 'rdiscount'
+end
+
+require 'builder'
+
+$:.unshift File.dirname(__FILE__)
+
+require 'ext/ext'
+
+module Toto
+  Paths = {
+    :templates => "templates",
+    :pages => "templates/pages",
+    :articles => "articles"
+  }
+
+  def self.env
+    ENV['RACK_ENV'] || 'production'
+  end
+
+  def self.env= env
+    ENV['RACK_ENV'] = env
+  end
+
+  module Template
+    def to_html page, config, &blk
+      path = ([:layout, :repo].include?(page) ? Paths[:templates] : Paths[:pages])
+      config[:to_html].call(path, page, binding)
+    end
+
+    def markdown text
+      if (options = @config[:markdown])
+        Markdown.new(text.to_s.strip, *(options.eql?(true) ? [] : options)).to_html
+      else
+        text.strip
+      end
+    end
+
+    def method_missing m, *args, &blk
+      self.keys.include?(m) ? self[m] : super
+    end
+
+    def self.included obj
+      obj.class_eval do
+        define_method(obj.to_s.split('::').last.downcase) { self }
+      end
+    end
+  end
+
+  class Site
+    def initialize config
+      @config = config
+    end
+
+    def [] *args
+      @config[*args]
+    end
+
+    def []= key, value
+      @config.set key, value
+    end
+
+    def index type = :html
+      articles = type == :html ? self.articles.reverse : self.articles
+      {:articles => articles.map do |article|
+        Article.new article, @config
+      end}.merge archives
+    end
+
+    def archives filter = ""
+      entries = ! self.articles.empty??
+        self.articles.select do |a|
+          filter !~ /^\d{4}/ || File.basename(a) =~ /^#{filter}/
+        end.reverse.map do |article|
+          Article.new article, @config
+        end : []
+
+      return :archives => Archives.new(entries, @config)
+    end
+
+    def article route
+      Article.new("#{Paths[:articles]}/#{route.join('-')}.#{self[:ext]}", @config).load
+    end
+
+    def /
+      self[:root]
+    end
+
+    def go route, env, type = :html
+      route << self./ if route.empty?
+      type, path = type =~ /html|xml|json/ ? type.to_sym : :html, route.join('/')
+      context = lambda do |data, page|
+        Context.new(data, @config, path, env).render(page, type)
+      end
+
+      body, status = if Context.new.respond_to?(:"to_#{type}")
+        if route.first =~ /\d{4}/
+          case route.size
+            when 1..3
+              context[archives(route * '-'), :archives]
+            when 4
+              context[article(route), :article]
+            else http 400
+          end
+        elsif respond_to?(path)
+          context[send(path, type), path.to_sym]
+        elsif (repo = @config[:github][:repos].grep(/#{path}/).first) &&
+              !@config[:github][:user].empty?
+          context[Repo.new(repo, @config), :repo]
+        else
+          context[{}, path.to_sym]
+        end
+      else
+        http 400
+      end
+
+    rescue Errno::ENOENT => e
+      return :body => http(404).first, :type => :html, :status => 404
+    else
+      return :body => body || "", :type => type, :status => status || 200
+    end
+
+  protected
+
+    def http code
+      [@config[:error].call(code), code]
+    end
+
+    def articles
+      self.class.articles self[:ext]
+    end
+
+    def self.articles ext
+      Dir["#{Paths[:articles]}/*.#{ext}"].sort_by {|entry| File.basename(entry) }
+    end
+
+    class Context
+      include Template
+      attr_reader :env
+
+      def initialize ctx = {}, config = {}, path = "/", env = {}
+        @config, @context, @path, @env = config, ctx, path, env
+        @articles = Site.articles(@config[:ext]).reverse.map do |a|
+          Article.new(a, @config)
+        end
+
+        ctx.each do |k, v|
+          meta_def(k) { ctx.instance_of?(Hash) ? v : ctx.send(k) }
+        end
+      end
+
+      def title
+        @config[:title]
+      end
+
+      def render page, type
+        content = to_html page, @config
+        type == :html ? to_html(:layout, @config, &Proc.new { content }) : send(:"to_#{type}", page)
+      end
+
+      def to_xml page
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        instance_eval File.read("#{Paths[:templates]}/#{page}.builder")
+      end
+      alias :to_atom to_xml
+
+      def method_missing m, *args, &blk
+        @context.respond_to?(m) ? @context.send(m, *args, &blk) : super
+      end
+    end
+  end
+
+  class Repo < Hash
+    include Template
+
+    README = "http://github.com/%s/%s/raw/master/README.%s"
+
+    def initialize name, config
+      self[:name], @config = name, config
+    end
+
+    def readme
+      markdown open(README %
+        [@config[:github][:user], self[:name], @config[:github][:ext]]).read
+    rescue Timeout::Error, OpenURI::HTTPError => e
+      "This page isn't available."
+    end
+    alias :content readme
+  end
+
+  class Archives < Array
+    include Template
+
+    def initialize articles, config
+      self.replace articles
+      @config = config
+    end
+
+    def [] a
+      a.is_a?(Range) ? self.class.new(self.slice(a) || [], @config) : super
+    end
+
+    def to_html
+      super(:archives, @config)
+    end
+    alias :to_s to_html
+    alias :archive archives
+  end
+
+  class Article < Hash
+    include Template
+
+    def initialize obj, config = {}
+      @obj, @config = obj, config
+      self.load if obj.is_a? Hash
+    end
+
+    def load
+      data = if @obj.is_a? String
+        meta, self[:body] = File.read(@obj).split(/\n\n/, 2)
+
+        # use the date from the filename, or else toto won't find the article
+        @obj =~ /\/(\d{4}-\d{2}-\d{2})[^\/]*$/
+        ($1 ? {:date => $1} : {}).merge(YAML.load(meta))
+      elsif @obj.is_a? Hash
+        @obj
+      end.inject({}) {|h, (k,v)| h.merge(k.to_sym => v) }
+
+      self.taint
+      self.update data
+      self[:date] = Date.parse(self[:date].gsub('/', '-')) rescue Date.today
+      self
+    end
+
+    def [] key
+      self.load unless self.tainted?
+      super
+    end
+
+    def slug
+      self[:slug] || self[:title].slugize
+    end
+
+    def summary length = nil
+      config = @config[:summary]
+      sum = if self[:body] =~ config[:delim]
+        self[:body].split(config[:delim]).first
+      else
+        self[:body].match(/(.{1,#{length || config[:length] || config[:max]}}.*?)(\n|\Z)/m).to_s
+      end
+      markdown(sum.length == self[:body].length ? sum : sum.strip.sub(/\.\Z/, '&hellip;'))
+    end
+
+    def url
+      "http://#{(@config[:url].sub("http://", '') + self.path).squeeze('/')}"
+    end
+    alias :permalink url
+
+    def body
+      markdown self[:body].sub(@config[:summary][:delim], '') rescue markdown self[:body]
+    end
+
+    def path
+      "/#{@config[:prefix]}#{self[:date].strftime("/%Y/%m/%d/#{slug}/")}".squeeze('/')
+    end
+
+    def title()   self[:title] || "an article"               end
+    def date()    @config[:date].call(self[:date])           end
+    def author()  self[:author] || @config[:author]          end
+    def to_html() self.load; super(:article, @config)        end
+    alias :to_s to_html
+  end
+
+  class Config < Hash
+    Defaults = {
+      :author => ENV['USER'],                               # blog author
+      :title => Dir.pwd.split('/').last,                    # site title
+      :root => "index",                                     # site index
+      :url => "http://127.0.0.1",                           # root URL of the site
+      :prefix => "",                                        # common path prefix for the blog
+      :date => lambda {|now| now.strftime("%d/%m/%Y") },    # date function
+      :markdown => :smart,                                  # use markdown
+      :disqus => false,                                     # disqus name
+      :summary => {:max => 150, :delim => /~\n/},           # length of summary and delimiter
+      :ext => 'txt',                                        # extension for articles
+      :cache => 28800,                                      # cache duration (seconds)
+      :github => {:user => "", :repos => [], :ext => 'md'}, # Github username and list of repos
+      :to_html => lambda {|path, page, ctx|                 # returns an html, from a path & context
+        ERB.new(File.read("#{path}/#{page}.rhtml")).result(ctx)
+      },
+      :error => lambda {|code|                              # The HTML for your error page
+        "<font style='font-size:300%'>toto, we're not in Kansas anymore (#{code})</font>"
+      }
+    }
+    def initialize obj
+      self.update Defaults
+      self.update obj
+    end
+
+    def set key, val = nil, &blk
+      if val.is_a? Hash
+        self[key].update val
+      else
+        self[key] = block_given?? blk : val
+      end
+    end
+  end
+
+  class Server
+    attr_reader :config, :site
+
+    def initialize config = {}, &blk
+      @config = config.is_a?(Config) ? config : Config.new(config)
+      @config.instance_eval(&blk) if block_given?
+      @site = Toto::Site.new(@config)
+    end
+
+    def call env
+      @request  = Rack::Request.new env
+      @response = Rack::Response.new
+
+      return [400, {}, []] unless @request.get?
+
+      path, mime = @request.path_info.split('.')
+      route = (path || '/').split('/').reject {|i| i.empty? }
+
+      response = @site.go(route, env, *(mime ? mime : []))
+
+      @response.body = [response[:body]]
+      @response['Content-Length'] = response[:body].length.to_s unless response[:body].empty?
+      @response['Content-Type']   = Rack::Mime.mime_type(".#{response[:type]}")
+
+      # Set http cache headers
+      @response['Cache-Control'] = if Toto.env == 'production'
+        "public, max-age=#{@config[:cache]}"
+      else
+        "no-cache, must-revalidate"
+      end
+
+      @response['ETag'] = %("#{Digest::SHA1.hexdigest(response[:body])}")
+
+      @response.status = response[:status]
+      @response.finish
+    end
+  end
+end
+