tarsius-cheat 1.2.2

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2006 Chris Wanstrath
+
+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

@@ -0,0 +1,38 @@
+== Cheat
+
+Cheat is a simple command line reference utility.  Use it to retrieve handy
+information from the cheat sheet repository.
+
+$ cheat sheets
+$ cheat cheat
+$ cheat recent
+
+To freshen your local cache, supply the --new edit.
+
+$ cheat sheets --new
+
+To edit a cheat sheet, use the --edit switch.
+
+$ cheat markaby --edit
+
+To add a cheat sheet, use the --add switch.
+
+$ cheat readme --add
+
+To execute a sheet, use the --execute or -x switch.
+
+$ cheat rspec_rails_install_edge --execute
+$ cheat rspec_rails_install_edge --x
+
+Special Thanks To:
+- Evan Weaver
+- Kevin Marsh
+- Jeremy Apthorp
+
+The Cheat Sheet Repository:
+- http://cheat.errtheblog.com/
+
+Enjoy.
+
+>> Chris Wanstrath
+=> chris[at]ozmm[dot]org

data/bin/cheat

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'cheat'
+Cheat.sheets(ARGV)

data/lib/cheat.rb

@@ -0,0 +1,240 @@
+$:.unshift File.dirname(__FILE__)
+%w[rubygems tempfile fileutils net/http yaml open-uri wrap].each { |f| require f }
+
+module Cheat
+  extend self
+
+  HOST = ARGV.include?('debug') ? 'localhost' : 'cheat.errtheblog.com'
+  PORT = ARGV.include?('debug') ? 3001 : 80
+  SUFFIX = ''
+
+  def sheets(args)
+    args = args.dup
+
+    return unless parse_args(args)
+
+    FileUtils.mkdir(cache_dir) unless File.exists?(cache_dir) if cache_dir
+
+    uri = "http://#{cheat_uri}/y/"
+
+    if %w[sheets all recent].include? @sheet
+      options = headers.update(proxy_options)
+      uri = uri.sub('/y/', @sheet == 'recent' ? '/yr/' : '/ya/')
+      return open(uri,options) { |body| process(body.read) }
+    end
+
+    return process(File.read(cache_file)) if File.exists?(cache_file) rescue clear_cache if cache_file 
+
+    fetch_sheet(uri + @sheet) if @sheet
+  end
+
+  def fetch_sheet(uri, try_to_cache = true)
+    options = headers.update(proxy_options)
+    open(uri, options) do |body|
+      sheet = body.read
+      FileUtils.mkdir_p(cache_dir) unless File.exists?(cache_dir)
+      File.open(cache_file, 'w') { |f| f.write(sheet) } if try_to_cache && cache_file && !@edit 
+      @edit ? edit(sheet) : show(sheet)
+    end 
+    exit
+  rescue OpenURI::HTTPError => e
+    puts "Whoa, some kind of Internets error!", "=> #{e} from #{uri}"
+  end
+
+  def parse_args(args)
+    puts "Looking for help?  Try http://cheat.errtheblog.com or `$ cheat cheat'" and return if args.empty?
+
+    if args.delete('--clear-cache') || args.delete('--new')
+      clear_cache
+      return if args.empty?
+    end
+
+    if i = args.index('--diff')
+      diff_sheets(args.first, args[i+1]) 
+    end
+
+    show_versions(args.first) if args.delete('--versions')
+
+    add(args.shift) and return if args.delete('--add')
+    clear_cache if @edit = args.delete('--edit')
+    
+    @execute = true if args.delete("--execute") || args.delete("-x")
+    @sheet = args.shift
+
+    true
+  end
+
+  # $ cheat greader --versions
+  def show_versions(sheet)
+    fetch_sheet("http://#{cheat_uri}/h/#{sheet}/", false)
+  end
+
+  # $ cheat greader --diff 1[:3]
+  def diff_sheets(sheet, version)
+    return unless version =~ /^(\d+)(:(\d+))?$/
+    old_version, new_version = $1, $3
+
+    uri = "http://#{cheat_uri}/d/#{sheet}/#{old_version}"
+    uri += "/#{new_version}" if new_version
+
+    fetch_sheet(uri, false) 
+  end
+
+  def cache_file
+    "#{cache_dir}/#{@sheet}.yml" if cache_dir
+  end
+
+  def headers
+    { 'User-Agent' => 'cheat!', 'Accept' => 'text/yaml' } 
+  end
+  
+  def proxy_options
+    if ENV['HTTP_PROXY'] || ENV['http_proxy']
+      proxy_array = []
+      proxy_array << (ENV['HTTP_PROXY'] || ENV['http_proxy'])
+      proxy_array << (ENV['HTTP_PROXY_USER'] || ENV['http_proxy_user'] || '')
+      proxy_array << (ENV['HTTP_PROXY_PASS'] || ENV['http_proxy_pass'] || '')
+      {:proxy_http_basic_authentication => proxy_array}
+    else
+      {}
+    end
+  end
+
+  def cheat_uri
+    "#{HOST}:#{PORT}#{SUFFIX}"
+  end
+
+  def execute(sheet_yaml)
+    sheet_body = YAML.load(sheet_yaml).to_a.flatten.last
+    puts "\n  " + sheet_body.gsub("\r",'').gsub("\n", "\n  ").wrap
+    puts "\nWould you like to execute the above sheet? (Y/N)"
+    answer = STDIN.gets
+    case answer.chomp
+    when "Y" then system YAML.load(sheet_yaml).to_a.flatten.last
+    when "N" then puts "Not executing sheet."
+    else
+      puts "Must be Y or N!"
+    end
+  rescue Errno::EPIPE
+    # do nothing
+  rescue
+    puts "That didn't work.  Maybe try `$ cheat cheat' for help?" # Fix Emacs ruby-mode highlighting bug: `"
+  end
+
+  def process(sheet_yaml)
+    if @execute
+      execute(sheet_yaml)
+    else
+      show(sheet_yaml)
+    end
+  end
+
+  def show(sheet_yaml)
+    sheet = YAML.load(sheet_yaml).to_a.first
+    sheet[-1] = sheet.last.join("\n") if sheet[-1].is_a?(Array)
+    run_pager
+    puts sheet.first + ':'
+    puts '  ' + sheet.last.gsub("\r",'').gsub("\n", "\n  ").wrap
+  rescue Errno::EPIPE
+    # do nothing
+  rescue
+    puts "That didn't work.  Maybe try `$ cheat cheat' for help?" # Fix Emacs ruby-mode highlighting bug: `"
+  end
+
+  def edit(sheet_yaml)
+    sheet = YAML.load(sheet_yaml).to_a.first
+    sheet[-1] = sheet.last.gsub("\r", '')
+    body, title = write_to_tempfile(*sheet), sheet.first
+    return if body.strip == sheet.last.strip
+    res = post_sheet(title, body)
+    check_errors(res, title, body)
+  end
+
+  def add(title)
+    body = write_to_tempfile(title)
+    res = post_sheet(title, body, true)
+    check_errors(res, title, body)
+  end
+
+  def post_sheet(title, body, new = false)
+    uri = "http://#{cheat_uri}/w/"
+    uri += title unless new
+    Net::HTTP.post_form(URI.parse(uri), "sheet_title" => title, "sheet_body" => body.strip, "from_gem" => true)
+  end
+
+  def write_to_tempfile(title, body = nil)
+    # god dammit i hate tempfile, this is so messy but i think it's
+    # the only way.
+    tempfile = Tempfile.new(title + '.cheat')
+    tempfile.write(body) if body
+    tempfile.close
+    system "#{editor} #{tempfile.path}"
+    tempfile.open
+    body = tempfile.read
+    tempfile.close
+    body
+  end
+
+  def check_errors(result, title, text)
+    if result.body =~ /<p class="error">(.+?)<\/p>/m
+      puts $1.gsub(/\n/, '').gsub(/<.+?>/, '').squeeze(' ').wrap(80)
+      puts 
+      puts "Here's what you wrote, so it isn't lost in the void:" 
+      puts text
+    else
+      puts "Success!  Try it!", "$ cheat #{title} --new"
+    end
+  end
+
+  def editor
+    ENV['VISUAL'] || ENV['EDITOR'] || "vim" 
+  end
+
+  def cache_dir
+    PLATFORM =~ /win32/ ? win32_cache_dir : File.join(File.expand_path("~"), ".cheat")
+  end
+
+  def win32_cache_dir
+    unless File.exists?(home = ENV['HOMEDRIVE'] + ENV['HOMEPATH'])
+      puts "No HOMEDRIVE or HOMEPATH environment variable.  Set one to save a" +
+           "local cache of cheat sheets."
+      return false
+    else
+      return File.join(home, 'Cheat')
+    end
+  end
+
+  def clear_cache
+    FileUtils.rm_rf(cache_dir) if cache_dir
+  end
+
+  def run_pager
+    return if PLATFORM =~ /win32/
+    return unless STDOUT.tty?
+
+    read, write = IO.pipe
+
+    unless Kernel.fork # Child process
+      STDOUT.reopen(write)
+      STDERR.reopen(write) if STDERR.tty?
+      read.close
+      write.close
+      return
+    end
+
+    # Parent process, become pager
+    STDIN.reopen(read)
+    read.close
+    write.close
+
+    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+    # wait until we have input before we start the pager
+    Kernel.select [STDIN]
+    pager = ENV['PAGER'] || 'less'
+    exec pager rescue exec "/bin/sh", "-c", pager
+  rescue
+  end
+end
+
+Cheat.sheets(ARGV) if __FILE__ == $0

data/lib/diffr.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+
+module Cheat
+  class Diffr
+    def self.diff(sheet_old, sheet_new)
+      format, lines, output = :unified, 10000, ''
+      file_length_difference = 0
+
+      data_old = sheet_old.body.wrap.split(/\n/).map! { |e| e.chomp }
+      data_new = sheet_new.body.wrap.split(/\n/).map! { |e| e.chomp }
+
+      diffs = Diff::LCS.diff(data_old, data_new)
+      return if diffs.empty?
+
+      header = ''
+      ft = sheet_old.updated_at
+      header << "#{'-' * 3} #{sheet_new.title} version #{sheet_old.version}\t#{ft}\n"
+      ft = sheet_new.updated_at
+      header <<  "#{'+' * 3} #{sheet_new.title} version #{sheet_new.version}\t#{ft}\n"
+
+      oldhunk = hunk = nil
+
+      diffs.each do |piece|
+        begin
+          hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, lines, file_length_difference)
+          file_length_difference = hunk.file_length_difference
+
+          next unless oldhunk
+
+          if lines > 0 && hunk.overlaps?(oldhunk)
+            hunk.unshift(oldhunk)
+          else
+            output << oldhunk.diff(format)
+          end
+        ensure
+          oldhunk = hunk
+          output << "\n"
+        end
+      end
+
+      output << oldhunk.diff(format)
+      output << "\n"
+
+      return header + output.lstrip
+    end
+  end
+end

data/lib/responder.rb

@@ -0,0 +1,42 @@
+# class Something < R 'route'
+#   include Responder
+#   
+#   def get
+#    ... important code ...
+#
+#     respond_to do |wants|
+#       wants.html { render :something }
+#       wants.text { "Just some text." }
+#       wants.yaml { "Something neat!".to_yaml }
+#       wants.xml  { "Also, XML.".to_xml }
+#     end
+#   end
+# end
+module Cheat::Controllers
+  module Responder
+    def respond_to
+      yield response = Response.new(env.HTTP_ACCEPT)
+      @headers['Content-Type'] = response.content_type
+      response.body
+    end
+
+    class Response
+      attr_reader :body, :content_type
+      def initialize(accept) @accept = accept end
+
+      TYPES = { 
+        :yaml => %w[application/yaml text/yaml],
+        :text => %w[text/plain],
+        :html => %w[text/html */* application/html],
+        :xml  => %w[application/xml]
+      }
+
+      def method_missing(method, *args)
+        if TYPES[method] && @accept =~ Regexp.union(*TYPES[method])
+          @content_type = TYPES[method].first 
+          @body = yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/site.rb

@@ -0,0 +1,611 @@
+#
+# According to Wikipedia, Cheat can refer to:
+#   Cheating, to take advantage of a situation by the breaking of accepted rules 
+#     or standards
+#   Cheating (casino)
+#   Cheating in poker
+#   Cheating in online games
+#   In relationships, to have an affair
+#   A cheat code, a hidden means of gaining an advantage in a video game
+#   Cheating, parasitic abuse of symbiotic relationships
+#   The Cheat, a character in the cartoon series Homestar Runner
+#   Cheat!, a television show on the G4 network
+#   The Cheat, a 1915 Cecil B. DeMille movie about a wealthy and domineering 
+#     Asian gentleman taking advantage of an American female
+#   Cheats, a 2002 comedy, starring Matthew Lawrence and Mary Tyler Moore
+#   Cheat, a song by The Clash from the UK version of their album The Clash 
+#   Bullshit, sometimes known as "Cheat," a card game
+#   An alternate term for defection in the prisoner's dilemma in game theory
+#   Cheat River, a tributary of the Monongahela River in Appalachia; the Cheat 
+#     starts in West Virginia, and flows westward
+#   Cheat Lake, a nearby resevoir
+#   Cheat Mountain, one of the highest mountains in the Alleghenies
+#
+%w[rubygems camping camping/db erb rubygems/open-uri acts_as_versioned wrap diffr responder ambition].each { |f| require f }
+gem 'camping', '>=1.4.152'
+
+Camping.goes :Cheat
+
+# for defunkt. campistrano.
+if ARGV.include? '--update'
+  ssh = 'ssh deploy@errtheblog.com'
+  puts `#{ssh} 'cd /var/www/cheat; svn up'`
+  system "#{ssh} 'sudo /etc/init.d/rv restart'"
+  exit 
+end
+
+URL  = ARGV.include?('debug') ? 'http://localhost:8020' : 'http://cheat.errtheblog.com' 
+FEED = 'http://feeds.feedburner.com/cheatsheets' # rss feed
+
+module Cheat::Models
+  class Sheet < Base
+    validates_uniqueness_of :title
+    validates_format_of     :title, :with => /^[a-z]+[a-z0-9_]*$/i
+    validates_presence_of   :title, :body    
+    before_save { |r| r.title = r.title.gsub(' ', '_').underscore.downcase }
+    acts_as_versioned
+  end
+
+  class SetUpUsTheCheat < V 1.0
+    def self.up
+      create_table :cheat_sheets, :force => true do |t|
+        t.column :id,         :integer,   :null => false
+        t.column :title,      :string,    :null => false
+        t.column :body,       :text
+        t.column :created_at, :datetime,  :null => false
+        t.column :updated_at, :datetime,  :null => false
+      end
+      Sheet.create_versioned_table
+      Sheet.reset_column_information
+    end
+    def self.down
+      drop_table :cheat_sheets
+      Sheet.drop_versioned_table
+    end
+  end
+end
+
+module Cheat::Controllers
+  class APIShow < R '/y/(\w+)'
+    def get(title)
+      @headers['Content-Type'] = 'text/plain'
+
+      sheet = Sheet.detect { |s| s.title == title }
+      return { 'Error!' => "Cheat sheet `#{title}' not found." }.to_yaml unless sheet
+
+      return { sheet.title => sheet.body }.to_yaml
+    end
+  end
+
+  class APIRecent < R '/yr'
+    def get
+      @headers['Content-Type'] = 'text/plain'
+
+      sheets = Sheet.sort_by { |s| -s.created_at }.first(15).map(&:title)
+      return { 'Recent Cheat Sheets' => sheets }.to_yaml
+    end
+  end
+
+  class APIAll < R '/ya'
+    def get
+      @headers['Content-Type'] = 'text/plain'
+
+      sheets = Sheet.sort_by(&:title).map(&:title)
+      return { 'All Cheat Sheets' => sheets }.to_yaml
+    end
+  end
+
+  class Feed < R '/f'
+    def get
+      @headers['Content-Type'] = 'application/xml'
+      return Cheat::Views.feed
+    end
+  end
+
+  class Index < R '/'
+    def get
+      render :index
+    end
+  end
+  
+  class Add < R '/a'
+    def get
+      @sheet = Sheet.new
+      render :add
+    end
+  end
+  
+  class Edit < R '/e/(\w+)/(\d+)', '/e/(\w+)'
+    def get(title, version = nil)
+      @sheet = Sheet.detect { |s| s.title == title }
+
+      @error = "Cheat sheet not found." unless @sheet
+      unless version.nil? || version == @sheet.version.to_s        
+        @sheet = @sheet.find_version(version)
+      end
+      render @error ? :error : :edit
+    end
+  end
+  
+  class Write < R '/w', '/w/(\w+)'
+    def post(title = nil)
+      @sheet = title ? Sheet.find_by_title(title) : Sheet.new
+      @sheet = title ? Sheet.detect { |s| s.title == title } : Sheet.new
+  
+      check_captcha! unless input.from_gem
+
+      if !@error && @sheet.update_attributes(:title => input.sheet_title, :body => input.sheet_body)
+        redirect "#{URL}/s/#{@sheet.title}"
+      else
+        @error = true
+        render title ? :edit : :add
+      end
+    end
+
+    def check_captcha!
+      @error ||= !(@cookies[:passed] ||= captcha_pass?(input.chunky, input.bacon))
+    end
+
+    def captcha_pass?(session, answer)
+      open("http://captchator.com/captcha/check_answer/#{session}/#{answer}").read.to_i.nonzero? rescue false
+    end
+  end
+  
+  class Browse < R '/b'
+    def get
+      @sheets = Sheet.sort_by(&:title)
+      render :browse
+    end
+  end
+  
+  class Show < R '/s/(\w+)', '/s/(\w+)/(\d+)'
+    def get(title, version = nil)
+      @sheet = Sheet.detect { |s| s.title == title }
+      @sheet = @sheet.find_version(version) if version && @sheet    
+
+      @sheet ? render(:show) : redirect("#{URL}/b/")
+    end
+  end
+
+  # we are going to start consolidating classes with respond_to and what not.
+  # diff is the first, as the api and the site will use the same code
+  class Diff < R '/d/(\w+)/(\d+)', '/d/(\w+)/(\d+)/(\d+)'
+    include Responder
+
+    def get(title, old_version, new_version = nil)
+      redirect "#{URL}/b/" and return unless old_version.to_i.nonzero?
+
+      @sheet = Sheet.detect { |s| s.title == title }
+      @old_sheet = @sheet.find_version(old_version)
+      @new_sheet = (new_version ? @sheet.find_version(new_version) : @sheet)
+
+      @diffed = Diffr.diff(@old_sheet, @new_sheet) rescue nil
+
+      respond_to do |wants|
+        wants.html { render :diff }
+        wants.yaml { { @sheet.title => @diffed }.to_yaml }
+      end
+    end
+  end
+
+  class History < R '/h/(\w+)'
+    include Responder
+
+    def get(title)
+      if sheets = Sheet.detect { |s| s.title == title }
+        @sheets = sheets.find_versions(:order => 'version DESC')
+      end
+
+      respond_to do |wants|
+        wants.html { render :history }
+        wants.yaml { { @sheets.first.title => @sheets.map(&:version) }.to_yaml }
+      end
+    end
+  end
+end
+
+module Cheat::Views
+  def layout
+    html {
+      head {
+        _style
+        link :href => FEED, :rel => "alternate", :title => "Recently Updated Cheat Sheets", :type => "application/atom+xml"
+        title @page_title ? "$ cheat #{@page_title}" : "$ command line ruby cheat sheets"
+      }
+      body {
+        div.main {
+          div.header { 
+            h1 { logo_link 'cheat sheets.' } 
+            code.header @sheet_title ? "$ cheat #{@sheet_title}" : "$ command line ruby cheat sheets"
+            }
+          div.content { self << yield }         
+          div.side { _side }
+          div.clear { '' }          
+          div.footer { _footer }
+        }
+        _clicky
+      }
+    }
+  end
+
+  def _clicky
+    text '<script src="http://getclicky.com/1070.js"> </script><noscript><img height=0 width=0 src="http://getclicky.com/1070ns.gif"></noscript>'
+  end
+  
+  def error
+    @page_title = "error"
+    p "An error:"
+    code.version @error
+    p ":("
+  end
+  
+  def show
+    @page_title = @sheet.title
+    @sheet_title = @sheet.title
+    pre.sheet { text h(@sheet.body.wrap) }
+    div.version {
+      text "Version "
+      strong sheet.version
+      text ", updated "
+      text last_updated(@sheet)
+      text " ago.  "
+      br
+      text ". o 0 ( "
+      if @sheet.version == current_sheet.version
+        a "edit", :href => R(Edit, @sheet.title)
+      end
+      if @sheet.version > 1
+        text " | "
+        a "previous", :href => R(Show, @sheet.title, @sheet.version - 1)
+      end
+      text " | "
+      a "history", :href => R(History, @sheet.title)
+      unless @sheet.version == current_sheet.version
+        text " | "        
+        a "revert to", :href => R(Edit, @sheet.title, @sheet.version)
+        text " | "        
+        a "current", :href => R(Show, @sheet.title)
+      end
+      diff_version = 
+        if @sheet.version == current_sheet.version 
+          @sheet.version == 1 ? nil : @sheet.version - 1
+        else
+          @sheet.version
+        end
+      if diff_version
+        text " | "
+        a "diff", :href => R(Diff, @sheet.title, diff_version) 
+      end
+      text " )"
+     }
+  end
+
+  def diff
+    @page_title = @sheet.title
+    @sheet_title = @sheet.title
+    pre.sheet { color_diff(h(@diffed)) if @diffed }
+    div.version {
+      text ". o 0 ("
+      if @old_sheet.version > 1
+        a "diff previous", :href => R(Diff, @sheet.title, @old_sheet.version - 1)
+        text " | "
+      end
+      a "history", :href => R(History, @sheet.title)
+      text " | "
+      a "current", :href => R(Show, @sheet.title)
+      text " )"
+    }
+  end
+  
+  def browse
+    @page_title = "browse"
+    p { "Wowzers, we've got <strong>#{@sheets.size}</strong> cheat sheets hereabouts." }
+    ul {
+      @sheets.each do |sheet|
+        li { sheet_link sheet.title }
+      end
+    }
+    p {
+      text "Are we missing a cheat sheet?  Why don't you do the whole world a favor and "
+      a "add it", :href => R(Add)
+      text " yourself!"
+    }
+  end
+
+  def history
+    @page_title  = "history"
+    @sheet_title = @sheets.first.title
+    h2 @sheets.first.title
+    ul {
+      @sheets.each_with_index do |sheet, i|
+        li { 
+          a "version #{sheet.version}", :href => R(Show, sheet.title, sheet.version)
+          text " - created "
+          text last_updated(sheet)
+          text " ago"
+          strong " (current)" if i.zero?
+          text " "
+          a "(diff to current)", :href => R(Diff, sheet.title, sheet.version) if i.nonzero?
+        }
+      end
+    }
+  end
+  
+  def add
+    @page_title = "add"
+    p {
+      text "Thanks for wanting to add a cheat sheet.  If you need an example of
+       the standard cheat sheet format, check out the "
+       a "cheat", :href => R(Show, 'cheat')
+       text " cheat sheet.  (There's really no standard format, though)."
+     }
+    _form
+  end
+  
+  def edit
+    @page_title = "edit"
+    _form
+  end
+  
+  def _form
+    if @error
+      p.error {
+        strong "HEY!  "
+        text "Something is wrong!  You can't give your cheat sheet the same name 
+              as another, alphanumeric titles only, and you need to make sure 
+              you filled in all (two) of the fields.  Okay?"
+      }
+    end
+    form :method => 'post', :action => R(Write, @sheet.title) do
+      p {
+        p { 
+          text 'Cheat Sheet Title: '
+          input :value => @sheet.title, :name => 'sheet_title', :size => 30, 
+                :type => 'text'
+          small " [ no_spaces_alphanumeric_only ]"
+        }
+        p {
+          text 'Cheat Sheet:'
+          br
+          textarea @sheet.body, :name => 'sheet_body', :cols => 80, :rows => 30
+          unless @cookies[:passed]
+            random = rand(10_000)
+            br
+            img :src => "http://captchator.com/captcha/image/#{random}"
+            input :name => 'chunky', :type => 'hidden', :value => random
+            input :name => 'bacon', :size => 10, :type => 'text'
+          end
+        }
+      }
+      p "Your cheat sheet will be editable (fixable) by anyone.  Each cheat 
+         sheet is essentially a wiki page.  It may also be used by millions of
+         people for reference purposes from the comfort of their command line.
+         If this is okay with you, please save."
+      input :value => "Save the Damn Thing!", :name => "save", :type => 'submit'
+    end
+  end
+
+  def index
+    p {
+      text "Welcome.  You've reached the central repository for "
+      strong "cheat"
+      text ", the RubyGem which puts Ruby-centric cheat sheets right into your 
+            terminal.  The inaugural blog entry "
+      a "is here", :href => "http://errtheblog.com/post/23"
+      text "."
+    }
+    p "Get started:"
+    code "$ sudo gem install cheat"
+    br
+    code "$ cheat strftime"
+    p "A magnificent cheat sheet for Ruby's strftime method will be printed to 
+       your terminal."
+    p "To get some help on cheat itself:"
+    code "$ cheat cheat"
+    p "How meta."
+    p {
+      text "Cheat sheets are basically wiki pages accessible from the command 
+            line.  You can "
+      a 'browse', :href => R(Browse)
+      text ', '
+      a 'add', :href => R(Add)
+      text ', or '
+      a 'edit', :href => R(Edit, 'cheat')
+      text ' cheat sheets.  Try to keep them concise.  For a style guide, check
+            out the '
+      a 'cheat', :href => R(Edit, 'cheat')            
+      text ' cheat sheet.'
+    }
+    p "To access a cheat sheet, simply pass the program the desired sheet's 
+       name:"
+    code "$ cheat <sheet name>"
+    p 
+  end
+
+  def self.feed
+    xml = Builder::XmlMarkup.new(:indent => 2)
+
+    xml.instruct!
+    xml.feed "xmlns"=>"http://www.w3.org/2005/Atom" do
+
+      xml.title "Recently Updated Cheat Sheets"
+      xml.id URL + '/'
+      xml.link "rel" => "self", "href" => FEED
+
+      sheets = Cheat::Models::Sheet.sort_by { |s| -s.updated_at }.first(20)
+      xml.updated sheets.first.updated_at.xmlschema
+
+      sheets.each do |sheet|
+        xml.entry do
+          xml.id URL + '/s/' + sheet.title
+          xml.title sheet.title
+          xml.author { xml.name "An Anonymous Cheater" }
+          xml.updated sheet.updated_at.xmlschema
+          xml.link "rel" => "alternate", "href" => URL + '/s/' + sheet.title
+          xml.summary "A cheat sheet about #{sheet.title}.  Run it: `$ cheat #{sheet.title}'"
+          xml.content 'type' => 'html' do 
+            xml.text! sheet.body.gsub("\n", '<br/>').gsub("\r", '') 
+          end
+        end
+      end   
+    end
+  end
+  
+  def _side
+    text '( '
+    a 'add new', :href => R(Add)
+    text ' | '
+    a 'see all', :href => R(Browse)
+    text ' )'
+    ul {
+      li { strong "updated sheets" }
+      li do
+        a :href => FEED do
+          img(:border => 0, :alt => "Recently Updated Cheat Sheets Feed", :src => "http://errtheblog.com/images/feed.png")
+        end
+      end
+      recent_sheets.each do |sheet|
+        li { sheet_link sheet.title }
+      end
+    }
+  end
+  
+  def _footer
+    text "Powered by "
+    a 'Camping', :href => "http://code.whytheluckystiff.net/camping"
+    text ", "
+    a 'Mongrel', :href => "http://mongrel.rubyforge.org/"            
+    text " and, to a lesser extent, " 
+    a 'Err the Blog', :href => "http://errtheblog.com/"
+    text "."
+  end
+
+  def _style
+    bg    = "#fff"
+    h1    = "#4fa3da"
+    link  = h1
+    hover = "#f65077"
+    dash  = hover    
+    version = "#fcf095"
+    style :type => "text/css" do
+      text %[
+        body { font-family: verdana, sans-serif; background-color: #{bg};
+               line-height: 20px; }
+        a:link, a:visited { color: #{link}; }                
+        a:hover { text-decoration: none; color: #{hover}; }
+        div.header { border-bottom: 1px dashed #{dash}; } 
+        code.header { margin-left: 30px; font-weight: bold; 
+                      background-color: #{version}; }       
+        h1 { font-size: 5em; margin: 0; padding-left: 30px; color: #{h1}; 
+             clear: both; font-weight: bold; letter-spacing: -5px; }
+        h1 a { text-decoration: none; }
+        div.main    { float: left; width: 100%; }
+        div.content { float: left; width: 70%; padding: 15px 0 15px 30px;
+                      line-height: 20px; }
+        div.side    { float: left; padding: 10px; text-align: right; 
+                      width: 20%; }
+        div.footer  { text-align: center; border-top: 1px dashed #{dash};
+                      padding-top: 10px; font-size: small; }
+        div.sheet { font-size: .8em; line-height: 17px; padding: 5px;
+                    font-family: courier, fixed-width; background-color: #e8e8e8; }
+        pre.sheet { line-height: 15px; }
+        li { list-style: none; }
+        div.version { background-color: #{version}; padding: 5px; 
+                       width: 450px; margin-top: 50px; }
+        p.error { background-color: #{version}; padding: 5px; }               
+        div.clear    { clear: both; }
+        div.clear_10 { clear: both; font-size: 10px; line-height: 10px; }
+        textarea { font-family: courier; }
+        code { background-color: #{version} }
+        span.diff_cut { color: #f65077; }
+        span.diff_add { color: #009933; }
+        @media print {
+          .side, .version, .footer { display: none; }
+          div.content { width: 100%; }
+          h1 a:link, h1 a:visited { color: #eee;}
+          .header code { font-size: 18px; background: none; }
+          div.header { border-bottom: none; }
+        }
+      ].gsub(/(\s{2,})/, '').gsub("\n", '')
+    end
+  end
+end
+
+module Cheat::Helpers
+  def logo_link(title)
+    ctr = Cheat::Controllers
+    if @sheet && !@sheet.new_record? && @sheet.version != current_sheet.version
+      a title, :href => R(ctr::Show, @sheet.title)
+    else
+      a title, :href => R(ctr::Index)
+    end
+  end
+  
+  def current_sheet
+    title = @sheet.title
+    @current_sheet ||= Cheat::Models::Sheet.detect { |s| s.title == title }
+  end
+  
+  def recent_sheets
+    Cheat::Models::Sheet.sort_by { |s| -s.updated_at }.first(15)
+  end
+  
+  def sheet_link(title, version = nil)
+    a title, :href => R(Cheat::Controllers::Show, title, version)
+  end
+  
+  def last_updated(sheet)
+    from = sheet.updated_at.to_i
+    to = Time.now.to_i
+    from = from.to_time if from.respond_to?(:to_time)
+    to = to.to_time if to.respond_to?(:to_time)
+    distance = (((to - from).abs)/60).round
+    case distance
+      when 0..1       then return (distance==0) ? 'less than a minute' : '1 minute'
+      when 2..45      then "#{distance} minutes"
+      when 46..90     then 'about 1 hour'
+      when 90..1440   then "about #{(distance.to_f / 60.0).round} hours"
+      when 1441..2880 then '1 day'
+      else                 "#{(distance / 1440).round} days"
+    end
+  end
+
+  def self.h(text)
+    ERB::Util::h(text)
+  end
+
+  def h(text)
+    ::Cheat::Helpers.h(text)
+  end
+
+  def color_diff(diff)
+    diff.split("\n").map do |line|
+      action = case line
+               when /^-/  then 'cut'
+               when /^\+/ then 'add'
+               end
+      action ? span.send("diff_#{action}", line) : line
+    end * "\n"
+  end
+end
+
+def Cheat.create
+  Cheat::Models.create_schema
+end
+
+if __FILE__ == $0
+  begin
+    require 'mongrel/camping'
+  rescue LoadError => e
+    abort "** Try running `camping #$0' instead."
+  end
+
+  Cheat::Models::Base.establish_connection :adapter => 'mysql', :user => 'root', :database => 'camping', :host => 'localhost'
+  Cheat::Models::Base.logger = nil
+  Cheat::Models::Base.threaded_connections = false
+  Cheat.create
+
+  server = Mongrel::Camping.start("0.0.0.0", 8020, "/", Cheat)
+  puts "** Cheat is running at http://0.0.0.0:8020/"
+  server.run.join
+end

data/lib/wrap.rb

@@ -0,0 +1,42 @@
+# >> Evan Weaver
+# => http://blog.evanweaver.com/articles/2006/09/03/smart-plaintext-wrapping
+class String
+  def wrap(width = 80, hanging_indent = 0, magic_lists = false)
+    lines = self.split(/\n/)
+
+    lines.collect! do |line|
+
+      if magic_lists 
+        line =~ /^([\s\-\d\.\:]*\s)/
+      else 
+        line =~ /^([\s]*\s)/
+      end
+
+      indent = $1.length + hanging_indent rescue hanging_indent
+
+      buffer = ""
+      first = true
+
+      while line.length > 0
+        first ? (i, first = 0, false) : i = indent              
+        pos = width - i
+
+        if line.length > pos and line[0..pos] =~ /^(.+)\s/
+          subline = $1
+        else 
+          subline = line[0..pos]
+        end
+        buffer += " " * i + subline + "\n"
+        line.tail!(subline.length)
+      end
+      buffer[0..-2]
+    end
+
+    lines.join("\n")
+  end
+
+  def tail!(pos)
+    self[0..pos] = ""
+    strip!
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: tarsius-cheat
+version: !ruby/object:Gem::Version 
+  version: 1.2.2
+platform: ruby
+authors: 
+- Chris Wanstrath
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2006-11-10 00:00:00 -08:00
+default_executable: cheat
+dependencies: []
+
+description: Cheat is a simple command line utility reference program.  Use it to, well, cheat.
+email: chris@ozmm.org
+executables: 
+- cheat
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- bin/cheat
+- lib/cheat
+- lib/cheat.rb
+- lib/diffr.rb
+- lib/new_cheat.rb
+- lib/responder.rb
+- lib/site.rb
+- lib/wrap.rb
+- lib/cheat/commands.rb
+- test/fixtures
+- test/test_cheat.rb
+has_rdoc: false
+homepage: http://cheat.errtheblog.com/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 1
+summary: Cheat is a simple command line utility reference program.
+test_files: []
+