whisperblog 0.6

data/lib/whisper/entry.rb

@@ -0,0 +1,44 @@
+require "whisper/common"
+require "whisper/text"
+
+module Whisper
+
+## a blog entry. a text plus a title, basically.
+class Entry
+  include Loggy
+  include Dependency
+
+  def initialize meta_file, content_file
+    @text = Text.new meta_file, content_file
+    dependency_init
+  end
+
+  def dependencies; [@text] end
+  def title type; content type end
+  def build old, type
+    case type
+      when :html, :rss; build_html_title
+      when :txt, :email; build_textile_title
+      else raise ArgumentError, "unknown type #{type.inspect}"
+    end
+  end
+
+  [:labels, :published, :updated, :id, :author, :meta_file, :content_file].each { |m| define_method(m) { @text.send m } }
+  def body format, opts={}; @text.body format, opts end
+
+private
+
+  def build_html_title
+    debug "rendering HTML title for #{@text.meta_file.path}"
+    RedCloth.new(@text.meta[:title]).to_html.gsub(%r,^<p>|</p>$,, "") # TODO: figure out a better way to remove these
+  end
+
+  ## since the title typically is one line and without any of the textile stuff
+  ## we actually want to tweak, we also use this for the text title.
+  def build_textile_title
+    debug "rendering textile title"
+    @text.meta[:title]
+  end
+end
+
+end

data/lib/whisper/entry_set.rb

@@ -0,0 +1,41 @@
+require "whisper/common"
+require "whisper/dir_set"
+require "whisper/entry"
+
+module Whisper
+
+## the set of all entries
+class EntrySet
+  include Loggy
+  include Dependency
+
+  def initialize dir
+    @dirset = DirSet.new dir, Entry
+    @entries = []
+    dependency_init
+  end
+
+  def dependencies; [@dirset] + @entries end
+
+  %w(entries entries_by_id entries_by_label entries_by_author entries_by_page).each do |f|
+    f = f.intern
+    define_method(f) { content[f] }
+  end
+
+  def size; entries.size end
+
+private
+
+  def build old
+    debug "resorting entries and recompiling entry indices"
+
+    @entries = @dirset.things.sort_by { |e| e.published }.reverse
+    { :entries => @entries,
+      :entries_by_id => @entries.map_by { |e| e.id },
+      :entries_by_author => @entries.group_by { |e| e.author.obfuscated_name },
+      :entries_by_label => @entries.group_by_multiple { |e| e.labels },
+    }
+  end
+end
+
+end

data/lib/whisper/handler.rb

@@ -0,0 +1,99 @@
+require 'cgi'
+require "whisper/common"
+require "whisper/timed_map"
+
+module Whisper
+
+class InvalidPageError < StandardError; end
+
+## I borrowed a bit from Rails's syntax, but the semantics are not the same.
+## Anything with + signs will be treated as a substitutable path component.
+## You can optionally end the path spec with :format or /:page:format.
+class Handler
+  include Loggy
+
+  DEFAULT_FORMAT = "html"
+
+  def initialize request_method, pathspec, &page_creator
+    @request_method = request_method
+    @pathspec = pathspec
+    @page_creator = page_creator
+    @map = TimedMap.new
+    @uses_page = @uses_format = false
+
+    re = @pathspec.gsub(/\+(\w+)/) do
+      '([^\.\/][^\/]*?)' # regular path components must start with a non-., non-/, followed by 0 or more non-/es
+    end.sub(/\/:page:format$/) do
+      @uses_page = @uses_format = true
+      '\/?(\d+)?(?:\.([^\/]+))?'
+    end.sub(/:format$/) do
+      @uses_format = true
+      '(?:\.([a-zA-Z]+))?'
+    end
+    @re = /^#{re}$/
+  end
+
+  def handle path, params, request_method, route
+    #debug "comparing #{request_method.inspect} against #{@request_method.inspect}"
+    return unless (request_method == @request_method) ||   # special case:
+      (request_method == :head && @request_method == :get) # proceed!
+
+    #debug "comparing #{path.inspect} against #{@re} => #{@re.match(path) ? true : false}"
+    match = @re.match(path) or return
+    #debug "have captures: #{match.captures.inspect}"
+
+    ## assemble the variables to be passed to the caller function
+    vars = match.captures
+    vars[vars.length - 1] ||= DEFAULT_FORMAT if @uses_format
+    vars[vars.length - 2] = (vars[vars.length - 2].to_i || 0) if @uses_page
+    vars << params
+
+    ## make a key from the path and the query parameters, if any. the key is basically
+    ## a normalized query string.
+    key = path + "?" + params.sort_by { |k, v| [k, v] }.map { |k, v| k + "=" + v }.join("&")
+
+    case request_method
+    when :post # don't cache
+      make route, vars
+    else
+      @map.prune!
+      @map[key] ||= begin
+        make(route, vars) || :invalid
+      rescue SystemCallError => e
+        :invalid
+      end
+    end
+  end
+
+  def contents; @map.values end
+
+  def url_for opts={}
+    url = @pathspec.gsub(/[:+](\w+)/) do
+      spec = $1.intern
+      val = opts[spec]
+      val = CGI.escape(val.to_s) if val
+      case spec
+      when :format; val.nil? || (val == DEFAULT_FORMAT) ? "" : ".#{val}"
+      when :page; val == "0" ? "" : val
+      else
+        raise ArgumentError, "missing required path spec #{spec}" unless val
+        val
+      end
+    end
+    url += "##{opts[:anchor]}" if opts[:anchor]
+    url.gsub!(/\/\.([^\/\.]+)$/, ".\\1")
+    url
+  end
+
+private
+
+  def make route, vars
+    begin
+      @page_creator.call route, *vars
+    rescue InvalidPageError => e
+      :invalid
+    end
+  end
+end
+
+end

data/lib/whisper/mbox.rb

@@ -0,0 +1,141 @@
+require 'rmail'
+require 'thread'
+require "whisper/common"
+require "whisper/rfc2047"
+
+## stolen from sup
+class RMail::Message
+  def charset
+    if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/i
+      $1
+    end
+  end
+end
+
+module Whisper
+
+class Mbox
+  include Loggy
+
+  attr_reader :offset
+
+  def initialize fn, start_offset
+    @fn = fn
+    @offset = start_offset
+    @mutex = Mutex.new
+  end
+
+  def eof?
+    @mutex.synchronize { @offset >= File.size(@fn) }
+  end
+
+  def next_message
+    m = @mutex.synchronize do
+      debug "reading #{@fn}@#{@offset}..."
+      with_filehandle do |f|
+        string = ""
+        l = f.gets
+        string << l until f.eof? || is_break_line?(l = f.gets)
+        debug "read #{string.size} bytes"
+        return nil if string.empty?
+        @offset += string.size
+        begin
+          RMail::Parser.read string
+        rescue ArgumentError # sigh. invalid utf throws this completely generic exception
+          nil
+        end
+      end
+    end
+
+    return if m.nil? # hit EOF
+
+    headers = {
+      "message-id" => m.header["message-id"],
+      "in-reply-to" => m.header["in-reply-to"],
+      "date" => m.header["date"],
+      "from" => Rfc2047.decode_to("utf-8", m.header["from"]),
+    }
+
+    text_part = find_text_part m
+    debug "text part of message has size #{text_part.body.size}: #{text_part.body[0..50].inspect}..."
+    body = if text_part
+      x = text_part.decode
+      x = Iconv.easy_decode("utf-8", text_part.charset, x) if text_part.charset
+      munge_body x
+    else
+      "_[This message contains no text/plain part. Bad commenter, no cookie! --ed.]_\n"
+    end
+
+    [body, headers]
+  end
+
+private
+
+  ## recurse through MIME structure looking for text
+  def find_text_part m
+    if m.header.content_type.nil? || m.header.content_type == "text/plain"
+      m
+    elsif m.multipart?
+      m.body.find { |p| find_text_part p }
+    end
+  end
+
+  def with_filehandle
+    begin
+      f = File.open @fn
+      f.seek @offset
+      correction = correct_offset f
+      if correction > 0
+        @offset += correction
+        f.seek @offset
+        debug "corrected offset forward by #{correction} bytes"
+      end
+      x = yield f
+      f.close
+      x
+    rescue SystemCallError => e
+      warn "can't open mbox: #{e.message}"
+      nil
+    end
+  end
+
+  def munge_body body
+    ## ok, not sure why this is happening, but at least in gmail messages
+    ## random spaces seem to turn into =A0's in a quoted-printable
+    ## encoding, which then turn into \240's when decoded. so i'm manually
+    ## forcing these back to spaces. whether this is a good idea or not
+    ## i don't know.
+    body#.
+      #gsub("\240", " ").
+      #gsub("\302", " ") # here's another one. what is this shit?
+  end
+
+private
+
+  BREAK_RE = /^From \S+ (.+)$/ # stolen from sup
+  require 'time'
+  def is_break_line? l # stolen from sup
+    time = begin
+      l =~ BREAK_RE or return false
+      $1
+    rescue ArgumentError # happens with invalid utf-8, for example
+      return false
+    end
+    begin
+      ## hack -- make Time.parse fail when trying to substitute values from Time.now
+      Time.parse time, 0
+      true
+    rescue NoMethodError
+      false
+    end
+  end
+
+  def correct_offset f # stolen from sup
+    string = ""
+    until f.eof? || is_break_line?(l = f.gets)
+      string << l
+    end
+    string.size
+  end
+end
+end

data/lib/whisper/page.rb

@@ -0,0 +1,118 @@
+require 'erb'
+require 'cgi'
+require "whisper/common"
+
+module Whisper
+
+class Page
+  include Loggy
+  include Dependency
+
+  ## kind of insane the amount of stuff this thing actually needs
+  def initialize opts, &rebuilder
+    @format = opts[:format]
+    @url_vars = opts[:url_vars] # used for making links to related pages
+    @master_template = opts[:master_template]
+    @template = opts[:template]
+    @helper = opts[:helper]
+    @rebuilder = rebuilder
+    @dependencies = opts[:extra_deps] + [@master_template, @template, @helper]
+    @config = opts[:config]
+    @router = opts[:router]
+    @entryset = opts[:entryset]
+
+    dependency_init
+  end
+
+  attr_reader :dependencies
+
+  def content_type
+    case @format
+    when "html"; "text/html"
+    when "rss"; "application/rss+xml"
+    when "txt"; "text/plain"
+    else raise "unknown format #@format"
+    end
+  end
+
+  ## an environment for erb
+  class HTMLBuilder
+    attr_accessor :content, :entryset
+
+    def initialize entryset, config, router, page_vars, url_vars, format
+      @entryset = entryset
+      @config = config
+      @router = router
+      @page_vars = page_vars
+      @url_vars = url_vars
+      @format = format
+      @content = nil
+    end
+
+    def method_missing m, *a
+      if @page_vars.member?(m) && a.empty?
+        @page_vars[m]
+      elsif @config.respond_to? m
+        @config.send m, *a
+      else
+        raise NoMethodError, "undefined method '#{m}' for #{self.class}. Possible ERB error."
+      end
+    end
+
+    ## utility methods for templates. TODO: move to router
+    def url_for opts={}; @router.url_for({ :format => @format }.merge(opts)) end
+    def full_url_for opts={}; @config.public_url_root + url_for(opts) end
+
+    def url_for_current opts={}; url_for @url_vars.merge(opts) end
+    def full_url_for_current opts={}; @config.public_url_root + url_for_current(opts) end
+
+    def link_to text, opts={}
+      raise "bad: #{text.inspect}, #{opts.inspect}" unless opts.is_a?(Hash)
+      html_opts = (opts[:html_opts] || {}).map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+      "<a #{html_opts} href=\"" + url_for(opts) + "\">#{text}</a>"
+    end
+
+    def link_to_current text, opts={}
+      html_opts = (opts[:html_opts] || {}).map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+      "<a #{html_opts} href=\"" + url_for_current(opts) + "\">#{text}</a>"
+    end
+
+    def my_binding; binding end
+
+    def self.install content, filename; eval content, binding, filename end
+  end
+
+private
+
+  def build old
+    debug "building erb -> #{@format} from #{@template.path}"
+    bc = case @format
+      when "html"; HTMLBuilder
+      when "rss"; HTMLBuilder
+      when "txt"; HTMLBuilder
+      else raise "unknown format #@format"
+    end
+    erb = ERB.new @template.content, nil, "%-"
+    erb.filename = @template.path
+
+    bc.install @helper.content, @helper.path
+    b = bc.new @entryset, @config, @router, @rebuilder.call, @url_vars, @format
+    b.content = rewrite_image_links_in erb.result(b.my_binding)
+
+    erb = ERB.new @master_template.content, nil, "%-"
+    erb.filename = @master_template.path
+    erb.result b.my_binding
+  end
+
+  ## rewrite any image HTML links in here to the static location
+  ## (these links are created by redcloth)
+  def rewrite_image_links_in text
+    text.gsub(/<img src=\"(.*?)\"/) do |x|
+      path = $1
+      next x if path =~ /^\w+:/
+      "<img src=\"/static/#{path}\""
+    end
+  end
+end
+
+end

data/lib/whisper/rfc2047.rb

@@ -0,0 +1,79 @@
+## from: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/101949
+
+# $Id: rfc2047.rb,v 1.4 2003/04/18 20:55:56 sam Exp $
+# MODIFIED slightly by William Morgan
+#
+# An implementation of RFC 2047 decoding.
+#
+# This module depends on the iconv library by Nobuyoshi Nakada, which I've 
+# heard may be distributed as a standard part of Ruby 1.8. Many thanks to him
+# for helping with building and using iconv.
+#
+# Thanks to "Josef 'Jupp' Schugt" <jupp / gmx.de> for pointing out an error with
+# stateful character sets.
+#
+# Copyright (c) Sam Roberts <sroberts / uniserve.com> 2004
+#
+# This file is distributed under the same terms as Ruby.
+
+require 'iconv'
+
+## stolen from sup
+class Iconv
+  def self.easy_decode target, charset, text
+    return text if charset =~ /^(x-unknown|unknown[-_ ]?8bit|ascii[-_ ]?7[-_ ]?bit)$/i
+    charset = case charset
+                when /UTF[-_ ]?8/i; "utf-8"
+                when /(iso[-_ ])?latin[-_ ]?1$/i; "ISO-8859-1"
+                when /iso[-_ ]?8859[-_ ]?15/i; 'ISO-8859-15'
+                when /unicode[-_ ]1[-_ ]1[-_ ]utf[-_]7/i; "utf-7"
+                else charset
+              end
+
+    # Convert:
+    #
+    # Remember - Iconv.open(to, from)!
+    Iconv.iconv(target + "//IGNORE", charset, text + " ").join[0 .. -2]
+  end
+end
+
+module Rfc2047
+  WORD = %r{=\?([!\#$%&'*+-/0-9A-Z\\^\`a-z{|}~]+)\?([BbQq])\?([!->@-~]+)\?=} # :nodoc: 'stupid ruby-mode
+  WORDSEQ = %r{(#{WORD.source})\s+(?=#{WORD.source})}
+
+  def Rfc2047.is_encoded? s; s =~ WORD end
+
+  # Decodes a string, +from+, containing RFC 2047 encoded words into a target
+  # character set, +target+. See iconv_open(3) for information on the
+  # supported target encodings. If one of the encoded words cannot be
+  # converted to the target encoding, it is left in its encoded form.
+  def Rfc2047.decode_to(target, from)
+    from = from.gsub(WORDSEQ, '\1')
+    out = from.gsub(WORD) do |word|
+      charset, encoding, text = $1, $2, $3
+
+      # B64 or QP decode, as necessary:
+      case encoding
+        when 'b', 'B'
+          text = text.unpack('m*')[0]
+
+        when 'q', 'Q'
+          # RFC 2047 has a variant of quoted printable where a ' ' character
+          # can be represented as an '_', rather than =32, so convert
+          # any of these that we find before doing the QP decoding.
+          text = text.tr("_", " ")
+          text = text.unpack('M*')[0]
+
+        # Don't need an else, because no other values can be matched in a
+        # WORD.
+      end
+
+      begin
+        Iconv.easy_decode target, charset, text
+      rescue Iconv::InvalidCharacter => e
+        puts "ICONV ERROR: #{e.message}"
+        text
+      end
+    end
+  end
+end