brad-toto 0.4.3

data/.document

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

data/.gitignore

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

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,156 @@
+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
+    |
+    +- feed.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 :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
+
+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 cloudhead. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "brad-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"
+    gem.add_dependency "rdiscount"
+  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/VERSION

@@ -0,0 +1 @@
+0.4.3

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,360 @@
+require 'yaml'
+require 'date'
+require 'erb'
+require 'rack'
+require 'digest'
+require 'open-uri'
+
+require 'rdiscount'
+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
+      case type
+        when :html
+          {:articles => self.articles.reverse.map do |article|
+              Article.new article, @config
+          end }.merge archives
+        when :xml, :json
+          return :articles => self.articles.map do |article|
+            Article.new article, @config
+          end
+        else return {}
+      end
+    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
+      begin
+        Article.new("#{Paths[:articles]}/#{route.join('-')}.#{self[:ext]}", @config).load
+      rescue
+        Site.articles(@config[:ext]).reverse.map do |a|
+          Article.new(a, @config)
+        end.first do |article|
+          article.title == route
+        end.load
+      end
+    end
+
+
+    def /
+      self[:root]
+    end
+
+    def go route, 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).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
+      return ["<font style='font-size:300%'>toto, we're not in Kansas anymore (#{code})</font>", 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
+
+      def initialize ctx = {}, config = {}, path = "/"
+        @config, @context, @path = config, ctx, path
+        @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
+        type == :html ? to_html(:layout, @config, &Proc.new { to_html page, @config }) : send(:"to_#{type}", :feed)
+      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) : 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 title()   self[:title] || "an article"               end
+    def date()    @config[:date].call(self[:date])           end
+    def path()    self[:date].strftime("/%Y/%m/%d/#{slug}/") 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",
+      :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)
+      }
+    }
+    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
+
+    def initialize config = {}, &blk
+      @config = config.is_a?(Config) ? config : Config.new(config)
+      @config.instance_eval(&blk) if block_given?
+    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 = Toto::Site.new(@config).go(route, *(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
+

data/test/articles/1900-05-17-the-wonderful-wizard-of-oz.txt

@@ -0,0 +1,5 @@
+title: The Wonderful Wizard of Oz
+date: 17/05/1900
+
+_Once upon a time_...
+

data/test/articles/2001-01-01-two-thousand-and-one.txt

@@ -0,0 +1,5 @@
+title: the wizard of oz
+date: 12/10/1932
+
+Once upon a time...
+

data/test/articles/2009-04-01-tilt-factor.txt

@@ -0,0 +1,5 @@
+title: the wizard of oz
+date: 12/10/1932
+
+Once upon a time...
+

data/test/articles/2009-12-04-some-random-article.txt

@@ -0,0 +1,5 @@
+title: the wizard of oz
+date: 12/10/1932
+
+Once upon a time...
+

data/test/articles/2009-12-11-the-dichotomy-of-design.txt

@@ -0,0 +1,5 @@
+title: the wizard of oz
+date: 12/10/1932
+
+Once upon a time...
+

data/test/autotest.rb

@@ -0,0 +1,34 @@
+#
+# Convenience Methods
+#
+def run(cmd)
+  print "\n\n"
+  puts(cmd)
+  system(cmd)
+  print "\n\n"
+end
+
+def run_all_tests
+  # see Rakefile for the definition of the test:all task
+  system("rake -s test:all VERBOSE=true")
+end
+
+#
+# Watchr Rules
+#
+watch('^test/.*?_test\.rb'   ) {|m| run("ruby -rubygems %s"              % m[0]) }
+watch('^lib/(.*)\.rb'        ) {|m| run("ruby -rubygems test/%s_test.rb" % m[1]) }
+watch('^lib/toto/(.*)\.rb'   ) {|m| run("ruby -rubygems test/%s_test.rb" % m[1]) }
+watch('^test/test_helper\.rb') { run_all_tests }
+
+#
+# Signal Handling
+#
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }

data/test/templates/about.rhtml

@@ -0,0 +1 @@
+<span id="count"><%= @articles.length %></span>

data/test/templates/archives.rhtml

@@ -0,0 +1,5 @@
+<h1><%= @path %></h1>
+<% for entry in archives %>
+  <li class="entry"><%= entry.title %></li>
+<% end %>
+

data/test/templates/article.rhtml

@@ -0,0 +1,4 @@
+<h2><%= title %></h2>
+<span><%= date %></h2>
+<p><%= body %></p>
+

data/test/templates/feed.builder

@@ -0,0 +1,21 @@
+xml.instruct!
+xml.feed "xmlns" => "http://www.w3.org/2005/Atom" do
+  xml.title @config[:title]
+  xml.id @config[:url]
+  xml.updated articles.first[:date].iso8601 unless articles.empty?
+  xml.author { xml.name @config[:author] }
+
+  articles.each do |article|
+    xml.entry do
+      xml.title article.title
+      xml.link "rel" => "alternate", "href" => article.url
+      xml.id article.url
+      xml.published article[:date].iso8601
+      xml.updated article[:date].iso8601
+      xml.author { xml.name @config[:author] }
+      xml.summary article.summary, "type" => "html"
+      xml.content article.body, "type" => "html"
+    end
+  end
+end
+

data/test/templates/index.rhtml

@@ -0,0 +1,9 @@
+<ul id="articles">
+  <% for article in articles[0...3] %>
+    <li><%= article %></li>
+  <% end %>
+</ul>
+<div id="archives">
+  <%= archives[3...5] %>
+</div>
+

data/test/templates/layout.rhtml

@@ -0,0 +1,4 @@
+<html>
+  <%= yield %>
+</html>
+

data/test/templates/repo.rhtml

@@ -0,0 +1 @@
+<%= readme %>

data/test/test_helper.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'hpricot'
+require 'riot'
+
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'toto'
+
+module Toto
+  class IncludesHTMLMacro < Riot::AssertionMacro
+    register :includes_html
+
+    def evaluate(actual, expected)
+      doc = Hpricot.parse(actual)
+      expected = expected.to_a.flatten
+
+      if (doc/expected.first).empty?
+        fail("expected #{actual} to contain a <#{expected.first}>")
+      elsif !(doc/expected.first).inner_html.match(expected.last)
+        fail("expected <#{expected.first}> to contain #{expected.last}")
+      else
+        pass
+      end
+    end
+  end
+
+  class IncludesElementsMacro < Riot::AssertionMacro
+    register :includes_elements
+
+    def evaluate(actual, selector, count)
+      doc = Hpricot.parse(actual)
+      (doc/selector).size == count ? pass : fail("expected #{actual} to contain #{count} #{selector}(s)")
+    end
+  end
+
+  class WithinMacro < Riot::AssertionMacro
+    register :within
+
+    def evaluate(actual, expected)
+      expected.include?(actual) ? pass : fail("expected #{actual} to be within #{expected}")
+    end
+  end
+end

data/test/toto_test.rb

@@ -0,0 +1,216 @@
+require 'test/test_helper'
+require 'date'
+
+URL = "http://toto.oz"
+AUTHOR = "toto"
+
+context Toto do
+  setup do
+    @config = Toto::Config.new(:markdown => true, :author => AUTHOR, :url => URL)
+    @toto = Rack::MockRequest.new(Toto::Server.new(@config))
+    Toto::Paths[:articles] = "test/articles"
+    Toto::Paths[:pages] = "test/templates"
+    Toto::Paths[:templates] = "test/templates"
+  end
+
+  context "GET /" do
+    setup { @toto.get('/') }
+
+    asserts("returns a 200")                { topic.status }.equals 200
+    asserts("body is not empty")            { not topic.body.empty? }
+    asserts("content type is set properly") { topic.content_type }.equals "text/html"
+    should("include a couple of article")   { topic.body }.includes_elements("#articles li", 3)
+    should("include an archive")            { topic.body }.includes_elements("#archives li", 2)
+
+    context "with no articles" do
+      setup { Rack::MockRequest.new(Toto::Server.new(@config.merge(:ext => 'oxo'))).get('/') }
+
+      asserts("body is not empty")          { not topic.body.empty? }
+      asserts("returns a 200")              { topic.status }.equals 200
+    end
+
+    context "with a user-defined to_html" do
+      setup do
+        @config[:to_html] = lambda do |path, page, binding|
+          ERB.new(File.read("#{path}/#{page}.rhtml")).result(binding)
+        end
+        @toto.get('/')
+      end
+
+      asserts("returns a 200")                { topic.status }.equals 200
+      asserts("body is not empty")            { not topic.body.empty? }
+      asserts("content type is set properly") { topic.content_type }.equals "text/html"
+      should("include a couple of article")   { topic.body }.includes_elements("#articles li", 3)
+      should("include an archive")            { topic.body }.includes_elements("#archives li", 2)
+    end
+  end
+
+  context "GET /about" do
+    setup { @toto.get('/about') }
+    asserts("returns a 200")                { topic.status }.equals 200
+    asserts("body is not empty")            { not topic.body.empty? }
+    should("have access to @articles")      { topic.body }.includes_html("#count" => /5/)
+  end
+
+  context "GET a single article" do
+    setup { @toto.get("/1900/05/17/the-wonderful-wizard-of-oz") }
+    asserts("returns a 200")                { topic.status }.equals 200
+    asserts("content type is set properly") { topic.content_type }.equals "text/html"
+    should("contain the article")           { topic.body }.includes_html("p" => /<em>Once upon a time<\/em>/)
+  end
+
+  context "GET to the archive" do
+    context "through a year" do
+      setup { @toto.get('/2009') }
+      asserts("returns a 200")                     { topic.status }.equals 200
+      should("includes the entries for that year") { topic.body }.includes_elements("li.entry", 3)
+    end
+
+    context "through a year & month" do
+      setup { @toto.get('/2009/12') }
+      asserts("returns a 200")                      { topic.status }.equals 200
+      should("includes the entries for that month") { topic.body }.includes_elements("li.entry", 2)
+      should("includes the year & month")           { topic.body }.includes_html("h1" => /2009\/12/)
+    end
+
+    context "through /archive" do
+      setup { @toto.get('/archive') }
+    end
+  end
+
+  context "GET to an unknown route" do
+    setup { @toto.get('/unknown') }
+    should("returns a 404") { topic.status }.equals 404
+  end
+
+  context "Request is invalid" do
+    setup { @toto.delete('/invalid') }
+    should("returns a 400") { topic.status }.equals 400
+  end
+
+  context "GET /index.xml (atom feed)" do
+    setup { @toto.get('/index.xml') }
+    asserts("content type is set properly") { topic.content_type }.equals "application/xml"
+    asserts("body should be valid xml")     { topic.body }.includes_html("feed > entry" => /.+/)
+    asserts("summary shouldn't be empty")   { topic.body }.includes_html("summary" => /.{10,}/)
+  end
+
+  context "GET to a repo name" do
+    setup do
+      class Toto::Repo
+        def readme() "#{self[:name]}'s README" end
+      end
+    end
+
+    context "when the repo is in the :repos array" do
+      setup do
+        @config[:github] = {:user => "cloudhead", :repos => ['the-repo']}
+        @toto.get('/the-repo')
+      end
+      should("return the-repo's README") { topic.body }.includes("the-repo's README")
+    end
+
+    context "when the repo is not in the :repos array" do
+      setup do
+        @config[:github] = {:user => "cloudhead", :repos => []}
+        @toto.get('/the-repo')
+      end
+      should("return a 404") { topic.status }.equals 404
+    end
+  end
+
+  context "creating an article" do
+    setup do
+      @config[:markdown] = true
+      @config[:date] = lambda {|t| "the time is #{t.strftime("%Y/%m/%d %H:%M")}" }
+      @config[:summary] = {:length => 50}
+    end
+
+    context "with the bare essentials" do
+      setup do
+        Toto::Article.new({
+          :title => "Toto & The Wizard of Oz.",
+          :body => "#Chapter I\nhello, *stranger*."
+        }, @config)
+      end
+
+      should("have a title")               { topic.title }.equals "Toto & The Wizard of Oz."
+      should("parse the body as markdown") { topic.body }.equals "<h1>Chapter I</h1>\n\n<p>hello, <em>stranger</em>.</p>\n"
+      should("create an appropriate slug") { topic.slug }.equals "toto-and-the-wizard-of-oz"
+      should("set the date")               { topic.date }.equals "the time is #{Date.today.strftime("%Y/%m/%d %H:%M")}"
+      should("create a summary")           { topic.summary == topic.body }
+      should("have an author")             { topic.author }.equals AUTHOR
+      should("have a path")                { topic.path }.equals Date.today.strftime("/%Y/%m/%d/toto-and-the-wizard-of-oz/")
+      should("have a url")                 { topic.url }.equals Date.today.strftime("#{URL}/%Y/%m/%d/toto-and-the-wizard-of-oz/")
+    end
+
+    context "with a user-defined summary" do
+      setup do
+        Toto::Article.new({
+          :title => "Toto & The Wizard of Oz.",
+          :body => "Well,\nhello ~\n, *stranger*."
+        }, @config.merge(:markdown => false, :summary => {:max => 150, :delim => /~\n/}))
+      end
+
+      should("split the article at the delimiter") { topic.summary }.equals "Well,\nhello"
+      should("not have the delimiter in the body") { topic.body !~ /~/ }
+    end
+
+    context "with everything specified" do
+      setup do
+        Toto::Article.new({
+          :title  => "The Wizard of Oz",
+          :body   => ("a little bit of text." * 5) + "\n" + "filler" * 10,
+          :date   => "19/10/1976",
+          :slug   => "wizard-of-oz",
+          :author => "toetoe"
+        }, @config)
+      end
+
+      should("parse the date") { [topic[:date].month, topic[:date].year] }.equals [10, 1976]
+      should("use the slug")   { topic.slug }.equals "wizard-of-oz"
+      should("use the author") { topic.author }.equals "toetoe"
+
+      context "and long first paragraph" do
+        should("create a valid summary") { topic.summary }.equals "<p>" + ("a little bit of text." * 5).chop + "&hellip;</p>\n"
+      end
+
+      context "and a short first paragraph" do
+        setup do
+          @config[:markdown] = false
+          Toto::Article.new({:body => "there ain't such thing as a free lunch\n" * 10}, @config)
+        end
+
+        should("create a valid summary") { topic.summary.size }.within 75..80
+      end
+    end
+  end
+
+  context "using Config#set with a hash" do
+    setup do
+      conf = Toto::Config.new({})
+      conf.set(:summary, {:delim => /%/})
+      conf
+    end
+
+    should("set summary[:delim] to /%/") { topic[:summary][:delim].source }.equals "%"
+    should("leave the :max intact") { topic[:summary][:max] }.equals 150
+  end
+
+  context "using Config#set with a block" do
+    setup do
+      conf = Toto::Config.new({})
+      conf.set(:to_html) {|path, p, _| path + p }
+      conf
+    end
+
+    should("set the value to a proc") { topic[:to_html] }.respond_to :call
+  end
+
+  context "extensions to the core Ruby library" do
+
+    should("respond to iso8601") { Date.today }.respond_to?(:iso8601)
+  end
+end
+
+

data/toto.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{toto}
+  s.version = "0.4.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["cloudhead"]
+  s.date = %q{2010-03-15}
+  s.description = %q{the tiniest blog-engine in Oz.}
+  s.email = %q{self@cloudhead.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/ext/ext.rb",
+     "lib/toto.rb",
+     "test/articles/1900-05-17-the-wonderful-wizard-of-oz.txt",
+     "test/articles/2001-01-01-two-thousand-and-one.txt",
+     "test/articles/2009-04-01-tilt-factor.txt",
+     "test/articles/2009-12-04-some-random-article.txt",
+     "test/articles/2009-12-11-the-dichotomy-of-design.txt",
+     "test/autotest.rb",
+     "test/templates/about.rhtml",
+     "test/templates/archives.rhtml",
+     "test/templates/article.rhtml",
+     "test/templates/feed.builder",
+     "test/templates/index.rhtml",
+     "test/templates/layout.rhtml",
+     "test/templates/repo.rhtml",
+     "test/test_helper.rb",
+     "test/toto_test.rb",
+     "toto.gemspec"
+  ]
+  s.homepage = %q{http://github.com/cloudhead/toto}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{the tiniest blog-engine in Oz}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/toto_test.rb",
+     "test/autotest.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<riot>, [">= 0"])
+      s.add_runtime_dependency(%q<builder>, [">= 0"])
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_runtime_dependency(%q<rdiscount>, [">= 0"])
+    else
+      s.add_dependency(%q<riot>, [">= 0"])
+      s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<rdiscount>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<riot>, [">= 0"])
+    s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<rdiscount>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: brad-toto
+version: !ruby/object:Gem::Version 
+  version: 0.4.3
+platform: ruby
+authors: 
+- cloudhead
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-15 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: riot
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: the tiniest blog-engine in Oz.
+email: self@cloudhead.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/ext/ext.rb
+- lib/toto.rb
+- test/articles/1900-05-17-the-wonderful-wizard-of-oz.txt
+- test/articles/2001-01-01-two-thousand-and-one.txt
+- test/articles/2009-04-01-tilt-factor.txt
+- test/articles/2009-12-04-some-random-article.txt
+- test/articles/2009-12-11-the-dichotomy-of-design.txt
+- test/autotest.rb
+- test/templates/about.rhtml
+- test/templates/archives.rhtml
+- test/templates/article.rhtml
+- test/templates/feed.builder
+- test/templates/index.rhtml
+- test/templates/layout.rhtml
+- test/templates/repo.rhtml
+- test/test_helper.rb
+- test/toto_test.rb
+- toto.gemspec
+has_rdoc: true
+homepage: http://github.com/cloudhead/toto
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: the tiniest blog-engine in Oz
+test_files: 
+- test/test_helper.rb
+- test/toto_test.rb
+- test/autotest.rb