whisperblog 0.6

data/lib/whisper/router.rb

@@ -0,0 +1,50 @@
+require "whisper/common"
+require "whisper/handler"
+
+module Whisper
+
+## nothing special. maintains a list of handlers, translates
+## from paths to content, and from url descriptions to urls
+class Router
+  include Loggy
+
+  def initialize root
+    root = root.sub(/\/$/, "")
+    @root_re = /^#{Regexp.escape root}/
+    @handlers = []
+    @handlers_by_route = {}
+  end
+
+  attr_reader :handlers
+
+  def add_handler route, request_method, path, &block
+    handler = Handler.new request_method, path, &block
+    @handlers_by_route[route] = handler
+    @handlers << [handler, route]
+  end
+
+  def expire!; @handlers.each { |h| h.expire! } end
+
+  def get_content_for path, params, request_method
+    path = path.sub @root_re, ""
+    case(result = @handlers.argfind { |h, route| h.handle path, params, request_method, route })
+    when nil, :invalid; nil # a handler matched but didn't like the request
+    when Array; result
+    else
+      result.refresh!
+      begin
+        [result.content, result.content_type]
+      rescue InvalidPageError => e
+        nil
+      end
+    end
+  end
+
+  def url_for opts={}
+    route = opts[:route] or raise ArgumentError, "no :route specified"
+    handler = @handlers_by_route[opts[:route]] or raise ArgumentError, "no such route: #{route.inspect} (have #{@handlers_by_route.keys.join(', ')})"
+    handler.url_for opts
+  end
+end
+
+end

data/lib/whisper/server.rb

@@ -0,0 +1,88 @@
+require 'rack'
+require 'cgi'
+require "whisper/common"
+
+class Rack::Response
+  attr_reader :length
+  def content_type= t; headers["Content-Type"] = t end
+  def content_length= t; headers["Content-Length"] = t.to_s end
+end
+
+module Whisper
+
+class Server
+  include Loggy
+
+  PRODUCTION_REFRESH_DELAY = 60 # seconds
+
+  def initialize blog, mode, static_dir, x_accel_redirect
+    @blog = blog
+    @static_dir = static_dir
+    @x_accel_redirect = x_accel_redirect
+    @production = mode == :production
+  end
+
+  def call env
+    start = Time.now
+    req = Rack::Request.new env
+    res = Rack::Response.new
+
+    deny = false
+    path = CGI.unescape req.path_info
+
+    ok = if req.scheme != "http"
+      false
+    elsif path == "/favicon.ico"
+      handle_static "favicon.ico", res
+    elsif path =~ /^\/static\/(.+)$/
+      handle_static $1, res
+    elsif(x = @blog.get_content_for path, req.params, req.request_method.downcase.intern)
+      content, content_type = x # oh ruby!
+
+      if req.request_method == "HEAD"
+        res.content_length = content.size
+        res.content_type = content_type
+      else
+        res.write content
+        res.content_type = content_type
+      end
+      true
+    else
+      false
+    end
+
+    unless ok
+      res.content_type = "text/plain"
+      res.status = 404
+      res.write "No such intarweb resource"
+    end
+
+    result = res.finish
+    elapsed = (Time.now - start) * 1000000
+    info "#{res.status} #{sprintf '%5dus', elapsed} #{sprintf '%5.1fk', res.length / 1024.to_f} #{req.request_method} #{req.path_info} #{deny ? '' : res.content_type}"
+    result
+  end
+
+private
+
+  def handle_static path, res
+    if @production && @x_accel_redirect
+      res.header["X-Accel-Redirect"] = File.join @x_accel_redirect, path
+      res.content_type = CachedFile.content_type_for path
+      true
+    else
+      begin
+        fn = File.join @static_dir, path.gsub("../", "")
+        return false unless File.file? fn
+        res.content_type = CachedFile.content_type_for fn
+        res.write IO.read(fn)
+        true
+      rescue SystemCallError => e
+        warn "static file unreadable: #{e.message}"
+        false
+      end
+    end
+  end
+end
+
+end

data/lib/whisper/text.rb

@@ -0,0 +1,252 @@
+# encoding: UTF-8
+
+require 'yaml'
+require 'redcloth'
+require "whisper/common"
+
+module Whisper
+
+## a text object, capable of converting itself from "enhanced textile" to html,
+## plain text, and other formats.
+##
+## this class deals with the gory details of textile, comments, and
+## format-specific regions, each of which conflict with each other in horrible
+## ways.
+##
+## comment and post format is basically textile, EXCEPT:
+## 1. there can be quoted regions, prefixed with "> ", which can be nested
+##    (a la email)
+## 2. there can be arbitrary, non-nested regions, which the user can define
+##    their own boundary markers and formatters for, which cannot be nested.
+class Text
+  include Loggy
+  include Dependency
+
+  class << self
+    def formatters; @formatters ||= [] end
+    attr_reader :quote_formatter
+
+    def format start_tag, end_tag, &block
+      @formatters ||= []
+      @formatters << [start_tag, end_tag, block]
+    end
+
+    def format_quote &block; @quote_formatter = block end
+  end
+
+  attr_reader :meta_file, :body_file
+
+  def initialize meta_file, body_file
+    @meta_file = meta_file
+    @body_file = body_file
+
+    dependency_init
+  end
+
+  def dependencies; [@meta_file, @body_file] end
+  def build old, meta_or_body, format
+    case meta_or_body
+    when :meta; build_metas
+    when :body; build_body format
+    else raise ArgumentError, "unknown selector #{meta_or_body.inspect}"
+    end
+  end
+
+  def body format, opts={}
+    c = content :body, format
+    if opts[:prefix]
+      c.lines.map { |l| opts[:prefix] + l }
+    else
+      c
+    end
+  end
+  def meta; content(:meta, nil) end
+
+  ## pass all these through to the metainfo container
+  [:labels, :entry_id, :published, :updated, :id, :author, :content_file, :parent_id, :message_id].each do |m|
+    define_method(m) { meta[m] }
+  end
+
+private
+
+  def build_metas
+    #debug "loading meta-info from #{@meta_file.path}"
+    meta = YAML.load @meta_file.body
+    meta[:id] = meta[:id].to_s
+    meta
+  end
+
+  ## the grunt work of formatting the body. general approach is: first,
+  ## separate into quoted regions and the main text region. these have a
+  ## recursive structure (i.e. you can embed quotes within quotes). within each
+  ## of those, replace all formatted regions within each of those with a
+  ## sentinel value. run each of these results through RedCloth.  finally,
+  ## substitute in the output of the custom formatters in the result of that
+  ## process for the sentinels.
+  def build_body format
+    debug "rendering #{format} body for #{@body_file.path}"
+    body = @body_file.body
+
+    region_tree = parse_body body
+
+    ## drop large comments (typically just entire quotes)
+    unquoted_length = region_tree.map { |n| n.is_a?(Hash) ?  n[:content].length : 0 }.sum
+    elide_large_quotes region_tree, (unquoted_length * 5)
+
+    ## if the last thing is a quote, elide it too
+    l = region_tree.last
+    if l.is_a?(Array) && l.size == 1
+      l.first[:content] = "_[Useless final quote elided. Bad commenter, no cookie! -- ed.]_"
+    end
+
+    format_region_tree format, region_tree, 0
+  end
+
+  def elide_large_quotes t, max_length, depth=0
+    t.each do |n|
+      if n.is_a?(Hash) && (depth == 1) && n[:content].length > max_length
+        n[:content] = "_[Excessively-large quote elided. Bad commenter, no cookie! -- ed.]_"
+      elsif n.is_a?(Array) && (depth == 0)
+        elide_large_quotes n, max_length, 1
+      end
+    end
+  end
+
+  def format_region_tree format, t, depth
+    result = t.map do |n|
+      case n
+      when Hash; format_region format, n[:content]
+      when Array; format_region_tree format, n, depth + 1
+      end
+    end.join
+
+    if depth > 0 # it's a quote
+      Text.quote_formatter.call format, result, (t.first.is_a?(Hash) && t.first[:attribution])
+    else
+      result
+    end
+  end
+
+  def format_region format, content
+    sentinels = {}
+    self.class.formatters.each do |start_tag, end_tag, block|
+      start_tag = Regexp::escape start_tag unless start_tag.is_a?(Regexp)
+      end_tag = Regexp::escape end_tag unless end_tag.is_a?(Regexp)
+      re = /#{start_tag}(.*?)#{end_tag}/m
+      content = content.gsub(re) do |r|
+        ## horrible, but we need to know which portions correpond to which
+        ## regexp and this is the only way i can figure out how to do it.
+        all_matches = /^#{start_tag}(.*?)#{end_tag}$/m.match r
+        start_matches = /^#{start_tag}/.match r
+        end_matches = /#{end_tag}$/.match r
+
+        inner = all_matches[start_matches.size]
+        sentinel = "WHISPERSENTINEL#{sentinels.size}"
+
+        ## if the block returns nil, we substitute in the original value
+        ## so not handling a particular format is the same as passing it through
+        sentinels[sentinel] = block.call(format, inner, start_matches, end_matches) || inner
+        sentinel
+      end
+    end
+
+    content = case format
+      when :txt, :email; plaintextify content
+      when :html, :rss; redclothify content
+      else; raise ArgumentError, "unknown format #{format.inspect}"
+    end
+
+    ## now resubstitute
+    content.gsub(/WHISPERSENTINEL\d+/) { |x| sentinels[x] }
+  end
+
+  TEXT_WIDTH = 78
+  def plaintextify body
+    ## replace urls with footnotes
+    urls = []
+    body.gsub!(/"([^"]+?)":(\S+[^\.,\?!\s])/m) do |x|
+      text, url = $1, $2
+      urls << url
+      "#{text} [#{urls.size}]"
+    end
+
+    ## replace image markers
+    body.gsub!(/!(.*?)!/) { |x| "[image: #{$1}]" }
+
+    ## wrap
+    body = body.reformat TEXT_WIDTH
+
+    ## prettify blockquotes by rewrapping them
+    body.gsub!(/bq.\s+(.+?)\n\n/m) do |x|
+      text = "\"#{$1}\""
+      text.reformat(TEXT_WIDTH - 8).gsub(/^/m, "    ")[1..-1] + "\n"
+    end
+
+    ## rewrite #'s into numbers. fucks up if there's more than
+    ## one separate list. fixing that would be complicated.
+    num = 0
+    body.gsub!(/^# /) { "#{num += 1}. " }
+
+    unless urls.empty?
+      body << "\n"
+      urls.each_with_index { |u, i| body << "[#{i + 1}] #{u}\n" }
+    end
+
+    body
+  end
+
+  def redclothify body
+    rc = RedCloth.new body
+    rc.hard_breaks = false
+    rc.filter_html = true
+    html = rc.to_html
+    ## rewrite some of the redcloth HTML output
+    html.sub! "<p>", "<p class='first'>" if html.length > 256
+    html.gsub! /(^|[>\s])(http:\/\/[^\s<]+)([\s<]|$)/, "\\1<a href='\\2'>\\2</a>\\3"
+    html
+  end
+
+  def parse_quoting_for_line s
+    s =~ /^((>\s*)*)(.*)$/ or raise "unparseable: #{s.inspect}"
+    quoting, content = $1, $3
+    [quoting.count(">"), content]
+  end
+
+  def parse_body content
+    regions, last_line = parse_regions content.lines.to_a, 0, 0, nil
+    regions
+  end
+
+  ## make a tree of content from nested comments
+  def parse_regions lines, quote_level, i, attribution
+    lines ||= []
+    regions = []
+    while i < lines.length
+      l, next_l = lines[i], lines[i + 1]
+      this_quote_level, content = parse_quoting_for_line l
+      is_attribution = next_l && content =~ /:\s*$/ && begin
+        next_quote_level, next_content = parse_quoting_for_line next_l
+        next_quote_level == quote_level + 1
+      end
+      if is_attribution
+        attribution = content
+        ## and don't do anything else
+      else
+        if this_quote_level == quote_level
+          regions << {content: "", attribution: attribution} unless regions.last.is_a? Hash
+          regions.last[:content] << (content + "\n")
+        elsif this_quote_level > quote_level
+          nested_regions, i = parse_regions(lines, quote_level + 1, i, attribution)
+          regions << nested_regions
+          attribution = nil
+        else # less than
+          break
+        end
+      end
+      i += 1
+    end
+    [regions, i - 1]
+  end
+
+end
+end

data/lib/whisper/timed_map.rb

@@ -0,0 +1,43 @@
+module Whisper
+
+class TimedMap
+  include Loggy
+
+  class << self
+    attr_accessor :expiration_interval
+  end
+
+  def initialize
+    @h = {}
+    TimedMap.expiration_interval ||= 60
+  end
+
+  def []= k, v
+    @h[k] = [v, Time.now]; v
+  end
+
+  def [] k
+    @h[k] && @h[k][0]
+  end
+
+  def each
+    @h.each { |k, (a, b)| yield k, a }
+  end
+
+  def values
+    @h.values.map { |a, b| a }
+  end
+
+  def prune!
+    @h.each do |k, v|
+      if (v[1] + TimedMap.expiration_interval) < Time.now
+        debug "expiring #{k.inspect} because it was generated more than #{TimedMap.expiration_interval}s ago"
+        @h.delete k 
+      end
+    end
+  end
+
+  def method_missing(m, *a); @h.send(m, *a) end
+end
+
+end

data/lib/whisper/version.rb

@@ -0,0 +1,3 @@
+module Whisper
+  VERSION = "0.6"
+end

data/share/whisper/comment-email.rtxt

@@ -0,0 +1,36 @@
+From: <%= author.email_name %> (on <%= blog_title %>) <<%= from_address %>>
+To: <%= to_address %>
+Subject: Re: [<%= blog_title %>] <%= entry.title(:email) %>
+Date: <%= Time.now %>
+Message-Id: <<%= message_id %>>
+In-Reply-To: <<%= reply_to_message_id %>>
+
+<% if web_request -%>
+; Hi there! This is an email containing the post or a comment from
+; <%= full_url_for :route => :entry, :id => entry.id %>. Someone (hopefully you!)
+; requested this email in order to leave a comment.
+;
+; To leave a comment, simply reply to this message, quoting as normal.
+; You can use Textile markup: http://hobix.com/textile/
+; DO NOT top-post: http://en.wikipedia.org/wiki/Top-posting#Top-posting
+;
+; Future comments on this post may also be sent to you via email, depending on
+; the setting below.
+;
+; SETTINGS:
+;
+; Lines starting with a ;, like these, will be stripped out, even if quoted.
+; Lines starting with a !, like those below, allow you to configure settings.
+; Just edit them in place and leave them in your reply (quoted is fine).
+;
+! <%= Comment::RESEND_SETTING %>: <%= settings["send future comments to me"] || "all" %>
+;   (one of "all", "replies-only", or "none")
+! <%= Comment::URL_SETTING %>: <%= settings["my url"] || "" %>
+;   (a url to link your name to)
+<% else -%>
+; A reply to this message will be posted at
+;   <%= full_url_for :route => :entry, :id => entry.id %>
+; and emailed to any subscribers to this thread.
+<% end -%>
+
+<%= comment.body :email %>