whisperblog 0.6

data/lib/whisper/cached_file.rb

@@ -0,0 +1,65 @@
+require 'mime/types'
+require "whisper/common"
+
+module Whisper
+
+## just a simple ol' thing that just holds a lazily-loaded cached copy of a
+## File in memory, updates itself upon command, and exposes a timestamp for
+## dependeny calculation purposes.
+##
+## TODO: do we actually need min_scan_interval? might be taken care of by
+## Dependency.min_refresh_interval. Liekwise for DirScanner.
+class CachedFile
+  include Loggy
+  include Dependency
+  attr_reader :path
+
+  class << self; attr_accessor :min_scan_interval end
+
+  def initialize path
+    @path = path
+    @content_type = nil
+    @mtime = File.mtime @path
+    @last_check = Time.at 0
+
+    dependency_init
+    CachedFile.min_scan_interval ||= 10
+  end
+
+  def dependencies; [] end
+  def build old_content
+    debug "reading #{@path} from disk"
+    @mtime = File.mtime(@path)
+    IO.read @path
+  end
+  def check
+    return false unless @last_check + CachedFile.min_scan_interval < Time.now
+
+    changed = begin
+      File.mtime(@path) > @mtime
+    rescue SystemCallError => e
+      warn e.message
+      true
+    end
+    @last_check = Time.now
+    #debug "checking mtime for #{@path}: #{changed}"
+    changed
+  end
+  def body; content end
+
+  def content_type; @content_type ||= CachedFile.content_type_for @path end
+
+  def self.content_type_for path
+    type = MIME::Types.type_for(path).first
+    if type
+      type.content_type
+    elsif path =~ /\.js$/i
+      "application/x-javascript"
+    else
+      warn "unknown MIME type for #{path}"
+      "application/binary"
+    end
+  end
+end
+
+end

data/lib/whisper/comment.rb

@@ -0,0 +1,35 @@
+require "whisper/common"
+require "whisper/text"
+
+module Whisper
+
+class Comment
+  include Loggy
+  include Dependency
+
+  RESEND_SETTING = "send future comments to me"
+  URL_SETTING = "my url"
+
+  def initialize meta_file, content_file
+    @text = Text.new meta_file, content_file
+    dependency_init
+  end
+
+  def dependencies; [@text] end
+  def build old, type
+    ## nothing yet
+  end
+
+  [:id, :entry_id, :published, :updated, :id, :author, :meta_file, :content_file, :parent_id, :message_id].each { |m| define_method(m) { @text.send m } }
+
+  ## these next two may not exist in imported and older comments, so we provide defaults here
+  def resend_setting; @text.meta[:resend_setting] || "none" end
+  def url_setting; @text.meta[:url_setting] end
+
+  def body format, opts={}; @text.body format, opts end
+
+private
+
+end
+
+end

data/lib/whisper/comment_set.rb

@@ -0,0 +1,41 @@
+require "whisper/common"
+require "whisper/dir_set"
+require "whisper/comment"
+
+module Whisper
+
+## the set of all entries
+class CommentSet
+  include Loggy
+  include Dependency
+
+  def initialize dir
+    @dirset = DirSet.new dir, Comment
+    dependency_init
+  end
+
+  def dependencies; [@dirset] end
+
+  %w(comments comments_by_id comments_by_entry_id comment_tree_by_entry_id comments_by_message_id).each do |f|
+    f = f.intern
+    define_method(f) { content[f] }
+  end
+
+  def size; comments.size end
+
+private
+
+  def build old
+    debug "recompiling comment indices"
+
+    comments = @dirset.things.sort_by { |c| c.published }.reverse
+    { :comments => comments,
+      :comments_by_id => comments.map_by { |c| c.id },
+      :comments_by_entry_id => comments.group_by { |c| c.entry_id },
+      :comments_by_message_id => comments.map_by { |c| c.message_id },
+      :comment_tree_by_entry_id => comments.group_by { |c| c.entry_id }.maphash { |eid, cs| cs.thread(:id, :parent_id) },
+    }
+  end
+end
+
+end

data/lib/whisper/common.rb

@@ -0,0 +1,276 @@
+require 'thread'
+require 'yaml'
+
+class Time
+  alias :old_to_yaml :to_yaml
+  def to_yaml *a
+    utc.old_to_yaml(*a)
+  end
+end
+
+class Array
+  def paginate page_size
+    (0 .. ((size - 1) / page_size)).map { |p| self[(p * page_size) ... ((p + 1) * page_size)] }
+  end
+end
+
+module Enumerable
+  def map_by
+    inject({}) { |h, e| h[yield(e)] = e; h }
+  end
+
+  def group_by
+    inject({}) { |h, e| x = yield e; h[x] = (h[x] || []) << e; h }
+  end
+
+  def group_by_multiple
+    inject({}) { |h, e| yield(e).each { |x| h[x] = (h[x] || []) << e }; h }
+  end
+
+  def max_of &b; map(&b).max end
+
+  def argfind
+    each { |e| x = yield(e) and return x; }; nil
+  end
+
+  def sum; inject(0) { |a, b| a + b } end
+
+  def thread id_method, parent_id_method
+    branches = { :root => [:root, []] }
+
+    each do |e|
+      id = e.send(id_method) or next
+      parent_id = e.send(parent_id_method) || :root
+      if branches[id]
+        thing, children = branches[id]
+        raise ArgumentError, "multiple objects with #{id_method} #{id.inspect}" if thing
+        branches[id] = [e, children]
+      else
+        branches[id] = [e, []]
+      end
+      branches[parent_id] ||= [nil, []]
+      branches[parent_id][1] << e
+    end
+
+    tree = {}
+    branches.each { |label, (thing, children)| tree[thing] = children }
+    tree
+  end
+end
+
+class Hash
+  def maphash
+    each { |k, v| self[k] = yield(k, v) }
+    self
+  end
+end
+
+class Numeric
+  def pluralize s
+    nicenice + " " + (self == 1 ? s : s.plural_form)
+  end
+
+  def nicenice
+    %w(no one two three four five six)[self] || to_s
+  end
+end
+
+class String
+  EMAIL_RE = /"?(.+?)"? <(\S+@\S+?)>/
+
+  def plural_form
+    case self
+    when "reply"; "replies"
+    else self + "s"
+    end
+  end
+
+  def email_name
+    self =~ EMAIL_RE && $1
+  end
+
+  def email_address
+    self =~ EMAIL_RE && $2
+  end
+
+  def obfuscated_name
+    email_name
+  end
+
+  def escape
+    gsub("&", "&amp;").gsub(">", "&gt;").gsub("<", "&lt;")
+  end
+
+  def unescape
+    gsub("&gt;", ">").gsub("&lt;", "<").gsub("&amp;", "&")
+  end
+
+  def reformat width
+    lines = []
+    body = self.clone
+
+    if body =~ /\A(\n+)/ # preserve any leading newlines
+      newlines = $1
+      lines << newlines
+      body = body[newlines.size .. -1]
+    end
+
+    while body
+      newline_point = body.index(/\n([\n\*\#])/) || width
+
+      split_point, appendage = if newline_point < width
+        [newline_point + 1, "\n#{$1}"]
+      elsif body.length < width
+        [body.length, "\n"]
+      else # regular: find a split point
+        split_point = body.rindex(/\s/, width) # look backwards
+        split_point ||= body.index(/\s/, width) # nope, look forward 
+        split_point ||= body.length # nope, use everything (don't think this will ever occur)
+        [split_point, "\n"]
+      end
+
+      start_split = split_point - 1
+      start_split -= 1 while start_split > 0 && [?\ , ?\n].include?(body[start_split])
+
+      lines << body[0 .. start_split].chomp.gsub(/\n/, " ") + appendage
+      body = body[(split_point + 1) .. -1]
+    end
+
+    lines << body if body
+    lines.pop if lines.last == "\n"
+    lines.join("")
+  end
+end
+
+class Module # oh ruby
+  def bool_reader *args
+    args.each { |sym| class_eval %{ def #{sym}?; @#{sym}; end } }
+  end
+  def bool_writer *args; attr_writer(*args); end
+  def bool_accessor *args
+    bool_reader(*args)
+    bool_writer(*args)
+  end
+end
+
+module Whisper
+
+## quick replacement for Ruby's crappy Logger class
+class Logger
+  LOG_LEVELS = %w(debug info warn error fatal)
+
+  ## keep one instance around
+  class << self; attr_accessor :instance end
+
+  def initialize stream, level
+    level = level.to_s
+    raise ArgumentError, "log level must be one of #{LOG_LEVELS.join ', '}" unless LOG_LEVELS.include? level
+
+    @stream = stream
+    @level = level
+    @level_index = LOG_LEVELS.index(@level)
+
+    LOG_LEVELS[0 ... @level_index].each do |m|
+      self.class.instance_eval do
+        define_method(m) { |s, where=nil| }
+        define_method("#{m}?") { false }
+        define_method("if_#{m}?") { |&b| }
+      end
+    end
+    LOG_LEVELS[@level_index .. -1].each do |m|
+      self.class.instance_eval do
+        define_method(m) { |s, where=nil| send_message m, s, where }
+        define_method("#{m}?") { true }
+        define_method("if_#{m}?") { |&b| b.call }
+      end
+    end
+
+    Logger.instance ||= self
+  end
+
+  def send_message level, msg, where=nil
+    m = format_message level, msg, where
+    @stream.print m
+    @stream.flush
+  end
+
+  def format_message level, msg, where
+    where_s = where.nil? ? "" : "(#{where.sub("Whisper::", "")}) "
+    "[#{Time.now}] #{where_s}#{level.upcase}: #{msg}\n"
+  end
+end
+
+module Loggy
+  Logger::LOG_LEVELS.each { |m| define_method(m) { |s| Logger.instance.send(m, s, self.class.name) if Logger.instance } }
+end
+
+## model dependency behaviors.
+##
+## methods provided:
+## #content -- get the latest content, built lazily
+## #refresh! -- do a check, invalidate content if necessary
+##
+## methods you must define:
+##
+## #dependencies: returns the set of dependencies, i.e. the set of objects
+##   which, if they change, this object should change too.
+## #build(old_content): rebuild the content (i.e. from the dependencies' contents)
+##
+## optional methods you can define:
+## #check: check for dirtiness (from external sources; we take care
+##   of the rest), returning true iff dirty. if this is an expensive method,
+##   you should limit operation to once every N seconds or something like that.
+##
+## this module requires initialization, so you should call
+## #dependency_init in your constructor
+##
+## also, no cycle checking, so DAGs only.
+##
+## also, allows for different types of content, if you pass arguments to #content
+module Dependency
+  include Loggy
+
+  class << self; attr_accessor :min_refresh_interval end
+
+  def dependency_init
+    @mutex = Mutex.new
+    @timestamp = Time.now
+    @last_refresh = Time.at 0
+    @old_content = {}
+    @content = {}
+
+    Dependency.min_refresh_interval ||= 10
+  end
+
+  def timestamp; @mutex.synchronize { @timestamp } end
+
+  def refresh!
+    @mutex.synchronize do
+      return if (@last_refresh + Dependency.min_refresh_interval) > Time.now
+      #debug "[dep] refresh called, checking #{dependencies.size} deps (content empty is #{@content.empty?}; respond_to check is #{respond_to?(:check)})"
+      dependencies.each { |d| d.refresh! }
+      dep_changed = dependencies.find { |d| d.timestamp > @timestamp }
+      i_changed = !dep_changed && respond_to?(:check) && check
+      if !@content.empty? && (dep_changed || i_changed)
+        #debug "[dep #{self.class}:#{object_id}] dep #{dep_changed.class}:#{dep_changed.object_id} changed (#{dep_changed.timestamp} vs #{@timestamp}), invalidating content" if dep_changed
+        #debug "[dep #{self.class}:#{object_id}] i changed, invalidating content" if i_changed
+        @timestamp = Time.now
+        @old_content = @content
+        @content = {}
+      end
+      @last_refresh = Time.now
+    end
+  end
+
+  def content *a
+    @mutex.synchronize do
+      unless @content.member?(a)
+        @content[a] = build @old_content[a], *a
+        #debug "[dep #{self.class}:#{object_id}] content was rebuilt"
+      end
+    end
+    @content[a]
+  end
+end
+
+end

data/lib/whisper/config.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+
+module Whisper
+
+class Config
+  class Error < StandardError; end
+
+  REQUIRED = [ :whisper_dir, :title, :tagline, :root, :public_url_root, :from_email_address, :comment_mbox ]
+  OPTIONAL = [ :post_dir, :comment_dir, :template_dir, :static_dir, :helper_dir, :draft_dir, :sendmail,
+               :development_port, :port, :page_size, :rack_handler, :mbox_offset_filename, :author_dir,
+               :x_accel_redirect, :formatter_dir]
+  ALL = REQUIRED + OPTIONAL
+
+  ALL.each { |k| define_method(k) { @hash[k] } }
+
+  def initialize fn, base_dir, mode=:development
+    @mode = mode
+    @hash = YAML.load_file fn
+    @hash[:whisper_dir] = base_dir
+    REQUIRED.each { |k| raise Error, "missing required configuration value '#{k}'" unless @hash[k] }
+    @hash.keys.each { |k| raise Error, "unknown configuration value '#{k}'" unless ALL.member? k }
+    fill_defaults!
+  end
+
+  attr_reader :mode
+
+  def use_this_port; @mode == :development ? @hash[:development_port] : @hash[:port] end
+
+private
+
+  def fill_defaults!
+    @hash[:post_dir] ||= File.join @hash[:whisper_dir], "posts"
+    @hash[:comment_dir] ||= File.join @hash[:whisper_dir], "comments"
+    @hash[:template_dir] ||= File.join @hash[:whisper_dir], "templates"
+    @hash[:static_dir] ||= File.join @hash[:whisper_dir], "static"
+    @hash[:draft_dir] ||= File.join @hash[:whisper_dir], "drafts"
+    @hash[:author_dir] ||= File.join @hash[:whisper_dir], "authors"
+    @hash[:helper_dir] ||= @hash[:whisper_dir]
+    @hash[:formatter_dir] ||= @hash[:whisper_dir]
+    @hash[:mbox_offset_filename] ||= File.join @hash[:whisper_dir], "offset.txt"
+    @hash[:sendmail] ||= "/usr/sbin/sendmail -oem -ti"
+    @hash[:port] ||= 80
+    @hash[:development_port] ||= 9292
+    @hash[:page_size] ||= 10
+    @hash[:rack_handler] ||= "Thin"
+  end
+end
+
+end