runeblog 0.2.43 → 0.2.48

data/lib/publish.rb

@@ -21,29 +21,28 @@ class RuneBlog::Publishing
   end
 
   def to_h
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     {user: @user, server: @server, docroot: @docroot,
      path: @path, proto: @proto}
   end
 
   def url
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     vname = @blog.view.name # .gsub(/_/, "\\_")
     url = "#@proto://#@server/#@path"  # /#{vname}"
   end
 
   def system!(str)
-    log!(enter: __method__, args: [str])
+    log!(enter: __method__, args: [str], level: 1)
     rc = system(str)
     rc
   end
 
   def publish(files, assets=[])
-    log!(enter: __method__, args: [files, assets])
+    log!(enter: __method__, args: [files, assets], level: 1)
     dir = @docroot/@path
     view_name = @blog.view.name
     viewpath = dir # /view_name
-#   result = system!("ssh #@user@#@server -x mkdir -p #{viewpath}") 
     result = system!("ssh #@user@#@server -x mkdir -p #{viewpath}/assets") 
     files.each do |file|
       dest = "#@user@#@server:" + dir  # /view_name

data/lib/repl.rb

@@ -7,18 +7,19 @@ make_exception(:PublishError,  "Error during publishing")
 make_exception(:EditorProblem, "Could not edit $1")
 
 module RuneBlog::REPL
-
   def edit_file(file)
     result = system!("#{@blog.editor} #{file}")
     raise EditorProblem(file) unless result
     sleep 0.1
-    STDSCR.clear
+    cmd_clear(nil)
   end
 
   def cmd_quit(arg, testing = false)
     check_empty(arg)
     RubyText.stop
-    system!("tput clear")
+    sleep 0.1
+    cmd_clear(nil)
+    sleep 0.1
     exit
   end
 
@@ -99,6 +100,13 @@ module RuneBlog::REPL
     result = system!("open #{local}")
     raise CantOpen(local) unless result
     @out
+  rescue => err
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def cmd_publish(arg, testing = false)
@@ -136,6 +144,13 @@ module RuneBlog::REPL
       output! "...finished.\n"
     end
     return @out
+  rescue => err
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def cmd_rebuild(arg, testing = false)
@@ -144,7 +159,15 @@ module RuneBlog::REPL
     check_empty(arg)
     puts unless testing
     @blog.generate_view(@blog.view)
+    @blog.generate_index(@blog.view)
     @out
+  rescue => err
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def cmd_change_view(arg, testing = false)
@@ -178,18 +201,30 @@ module RuneBlog::REPL
     @out
   rescue ViewAlreadyExists
     puts 'Blog already exists'
+  rescue => err
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def cmd_new_post(arg, testing = false)
     reset_output
     check_empty(arg)
     title = ask("\nTitle: ")
+    puts
     @blog.create_new_post(title)
 #   STDSCR.clear
     @out
   rescue => err
-    puts err
-    puts err.backtrace.join("\n")
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def _remove_post(arg, testing=false)
@@ -199,7 +234,6 @@ module RuneBlog::REPL
   end
 
   def cmd_remove_post(arg, testing = false)
-puts "arg = #{arg.inspect} is a #{arg.class}"
     reset_output
     args = arg.split
     args.each do |x| 
@@ -211,14 +245,12 @@ puts "arg = #{arg.inspect} is a #{arg.class}"
     @out
   end
 
-  #-- FIXME affects linking, building, publishing...
-
   def cmd_edit_post(arg, testing = false)
     reset_output
     id = get_integer(arg)
     # Simplify this
     tag = "#{'%04d' % id}"
-    files = Find.find(@blog.root+"/drafts").to_a
+    files = ::Find.find(@blog.root+"/drafts").to_a
     files = files.grep(/#{tag}-.*lt3/)
     files = files.map {|f| File.basename(f) }
     if files.size > 1
@@ -238,6 +270,13 @@ puts "arg = #{arg.inspect} is a #{arg.class}"
     draft = "#{@blog.root}/drafts/#{file}"
     result = edit_file(draft)
     @blog.generate_post(draft)
+  rescue => err
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
   end
 
   def cmd_list_views(arg, testing = false)
@@ -321,7 +360,10 @@ puts "arg = #{arg.inspect} is a #{arg.class}"
 
   def cmd_ssh(arg, testing = false)
     pub = @blog.view.publisher
-    system!("ssh #{pub.user}@#{pub.server}")
+    puts
+    system!("tputs clear; ssh #{pub.user}@#{pub.server}")
+    sleep 0.1
+    cmd_clear(nil)
   end
 
   def cmd_INVALID(arg, testing = false)
@@ -384,6 +426,5 @@ puts "arg = #{arg.inspect} is a #{arg.class}"
     puts unless testing
     @out
   end
-
 end
 

data/lib/runeblog.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'find'
 
 require 'logging'
 
@@ -42,6 +43,15 @@ class RuneBlog
 
   include Helpers
 
+  def _tmp_error(err)   # FIXME move to helpers
+    out = "/tmp/blog#{rand(100)}.txt"
+    File.open(out, "w") do |f|
+      f.puts err
+      f.puts err.backtrace.join("\n")
+    end
+    puts "Error: See #{out}"
+  end
+
   def self.create_new_blog_repo(dir = ".blogs")
     log!(enter: __method__, args: [dir])
     raise ArgumentError unless dir.is_a?(String) && ! dir.empty?
@@ -53,7 +63,7 @@ class RuneBlog
   end
 
   def self.create(root = ".blogs")
-    log!(enter: __method__, args: [root])
+    log!(enter: __method__, args: [root], level: 1)
     # Crude - FIXME later -  # What views are there? Publishing, etc.
     self.blog = self   # Weird. Like a singleton - dumbass circular dependency?
     root = Dir.pwd/root
@@ -63,13 +73,13 @@ class RuneBlog
       create_dirs(:drafts, :views, :posts)
       new_sequence
     end
-#   put_config(root: root)
     x = OpenStruct.new
     x.root, x.current_view, x.editor = root, "test_view", "/usr/bin/vim "   # dumb - FIXME later
     write_config(x, root/ConfigFile)
     @blog = self.new(root)
-    @blog.create_view("test_view")
     @blog
+  rescue => err
+    _tmp_error(err)
   end
 
   def self.open(root = ".blogs")
@@ -78,6 +88,8 @@ class RuneBlog
     self.blog = self   # Weird. Like a singleton - dumbass circular dependency?
     root = Dir.pwd/root
     blog = self.new(root)
+  rescue => err
+    _tmp_error(err)
   end
 
   def initialize(root_dir = ".blogs")   # always assumes existing blog
@@ -101,11 +113,13 @@ class RuneBlog
   end
 
   def _deploy_local(dir)
-    log!(enter: __method__, args: [dir])
+    log!(enter: __method__, args: [dir], level: 1)
     Dir.chdir(dir) do
       views = _retrieve_metadata(:views)
       views.each {|v| system!("cp *html #@root/views/#{v}/remote") }
     end
+  rescue => err
+    _tmp_error(err)
   end
 
   def _retrieve_metadata(key)
@@ -129,19 +143,23 @@ class RuneBlog
       raise "Too many #{key} instances in metadata.txt!"
     end
     return result
+  rescue => err
+    _tmp_error(err)
   end
 
   def process_post(sourcefile)
-    log!(enter: __method__, args: [dir])
+    log!(enter: __method__, args: [dir], level: 2)
     nslug = sourcefile.sub(/.lt3/, "")
     dir = @root/:posts/nslug
     create_dir(dir)
     xlate cwd: dir, src: sourcefile  # , debug: true
     _deploy_local(dir)
+  rescue => err
+    _tmp_error(err)
   end
 
   def inspect
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     str = "blog: "
     ivars = ["@root", "@sequence"]   # self.instance_variables
     ivars.each do |iv| 
@@ -152,30 +170,32 @@ class RuneBlog
   end
 
   def view?(name)
-    log!(enter: __method__, args: [name])
+    log!(enter: __method__, args: [name], level: 3)
     raise ArgumentError unless name.is_a?(String) && ! name.empty?
     views.any? {|x| x.name == name }
   end
 
   def view(name = nil)
-    log!(enter: __method__, args: [name])
+    log!(enter: __method__, args: [name], level: 3)
     raise ArgumentError unless name.nil? || (name.is_a?(String) && ! name.empty?)
     name.nil? ? @view : str2view(name)
   end
 
   def str2view(str)
-    log!(enter: __method__, args: [str])
+    log!(enter: __method__, args: [str], level: 3)
     raise ArgumentError unless str.is_a?(String) && ! str.empty?
     @views.find {|x| x.name == str }
   end
 
   def _set_publisher
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     @view.publisher = RuneBlog::Publishing.new(@view.to_s)  # FIXME refactor
+  rescue => err
+    _tmp_error(err)
   end
 
   def view=(arg)
-    log!(enter: __method__, args: [arg])
+    log!(enter: __method__, args: [arg], level: 2)
     case arg
       when RuneBlog::View
         @view = arg
@@ -188,22 +208,24 @@ class RuneBlog
       else 
         raise CantAssignView(arg.class.to_s)
     end
+  rescue => err
+    _tmp_error(err)
   end
 
   def get_sequence
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     File.read(@root/:sequence).to_i
   end
 
   def next_sequence
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     @sequence += 1
     dump(@sequence, @root/:sequence)
     @sequence
   end
 
   def viewdir(v = nil)   # delete?
-    log!(enter: __method__, args: [v])
+    log!(enter: __method__, args: [v], level: 3)
     v = str2view(v) if v.is_a?(String)
     raise ArgumentError unless v.nil? || v.is_a?(RuneBlog::View)
     v ||= @view
@@ -211,17 +233,17 @@ class RuneBlog
   end
 
   def self.exist?
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     Dir.exist?(DotDir) && File.exist?(DotDir/ConfigFile)
   end
 
   def mark_last_published(str)
-    log!(enter: __method__, args: [str])
+    log!(enter: __method__, args: [str], level: 2)
     dump(str, "#{self.view.dir}/last_published")
   end
 
   def add_view(view_name)
-    log!(enter: __method__, args: [view_name])
+    log!(enter: __method__, args: [view_name], level: 2)
     view = RuneBlog::View.new(view_name)
     @view = view    # current view
     @views << view  # all views
@@ -229,15 +251,17 @@ class RuneBlog
   end
 
   def make_empty_view_tree(view_name)
-    log!(enter: __method__, args: [view_name])
+    log!(enter: __method__, args: [view_name], level: 2)
     Dir.chdir(@root) do
       cmd = "cp -r #{RuneBlog::Path}/../empty_view views/#{view_name}"
       system!(cmd)
     end
+  rescue => err
+    _tmp_error(err)
   end
 
   def check_valid_new_view(view_name)
-    log!(enter: __method__, args: [view_name])
+    log!(enter: __method__, args: [view_name], level: 3)
     raise ArgumentError unless view_name.is_a?(String)
     raise ArgumentError if view_name.empty?
     names = self.views.map(&:to_s)
@@ -249,11 +273,13 @@ class RuneBlog
   end
 
   def create_view(view_name)
-    log!(enter: __method__, args: [view_name])
+    log!(enter: __method__, args: [view_name], level: 2)
     check_valid_new_view(view_name)
     make_empty_view_tree(view_name)
     add_view(view_name)
     mark_last_published("Initial creation")
+  rescue => err
+    _tmp_error(err)
   end
 
   def delete_view(name, force = false)
@@ -267,7 +293,7 @@ class RuneBlog
   end
 
   def view_files
-    log!(enter: __method__)
+    log!(enter: __method__, level: 2)
     vdir = self.view.dir
     files = [vdir/"index.html"]
     files += posts.map {|x| vdir/x }
@@ -275,7 +301,7 @@ class RuneBlog
   end
 
   def post_lookup(postid)    # side-effect?
-    log!(enter: __method__, args: [postid])
+    log!(enter: __method__, args: [postid], level: 2)
     slug = title = date = teaser_text = nil
 
     dir_posts = @vdir/:posts
@@ -287,10 +313,12 @@ class RuneBlog
     postdir = post.first
     vp = RuneBlog::ViewPost.new(self.view, postdir)
     vp
+  rescue => err
+    _tmp_error(err)
   end
 
   def index_entry(slug)
-    log!(enter: __method__, args: [slug])
+    log!(enter: __method__, args: [slug], level: 2)
     id = slug.to_i
     text = nil
     @theme = @view.dir/"themes/standard"
@@ -302,28 +330,37 @@ class RuneBlog
       vp.nslug, vp.aslug, vp.title, vp.date, vp.teaser_text
     path = vp.path
     url = aslug + ".html"
+# puts "--- vp = #{[vp.nslug, vp.aslug, vp.title, vp.date, vp.teaser_text].inspect}"; gets
     date = ::Date.parse(date)
     date = date.strftime("%B %e<br><div style='float: right'>%Y</div>")
     text = interpolate(@_post_entry, binding)
     text
+  rescue => err
+    _tmp_error(err)
   end
 
   def collect_recent_posts(file)
-    log!(enter: __method__, args: [file])
+    log!(enter: __method__, args: [file], level: 3)
     posts = nil
     dir_posts = @vdir/:posts
     entries = Dir.entries(dir_posts)
     posts = entries.grep(/^\d\d\d\d/).map {|x| dir_posts/x }
     posts.select! {|x| File.directory?(x) }
     # directories that start with four digits
-    posts = posts.sort {|a, b| b.to_i <=> a.to_i }  # sort descending
+    posts = posts.sort do |a, b| 
+      ai = a.index(/\d\d\d\d-/)
+      bi = b.index(/\d\d\d\d-/)
+      na = a[ai..(ai+3)].to_i
+      nb = b[bi..(bi+3)].to_i
+      nb <=> na
+    end  # sort descending
     posts = posts[0..19]  # return 20 at most
     text = <<-HTML
       <html>
       <head><link rel="stylesheet" href="etc/blog.css"></head>
       <body>
     HTML
-    wanted = [5, posts.size].min  # estimate how many we want?
+    wanted = [8, posts.size].min  # estimate how many we want?
     enum = posts.each
     wanted.times do
       postid = File.basename(enum.next)
@@ -332,28 +369,30 @@ class RuneBlog
     end
     text << "</body></html>"
     File.write(@vdir/:remote/file, text)
+  rescue => err
+    _tmp_error(err)
   end
 
-  def create_new_post(title, testing = false, teaser: nil, body: nil, views: [])
-    log!(enter: __method__, args: [title, testing, teaser, body, views])
+  def create_new_post(title, testing = false, teaser: nil, body: nil, 
+                      pubdate: Time.now.strftime("%Y-%m-%d"), views: [])
+    log!(enter: __method__, args: [title, testing, teaser, body, views], level: 1, stderr: true)
     meta = nil
     views = views + [self.view.to_s]
+    views.uniq!
     Dir.chdir(@root/:posts) do
-      post = Post.create(title: title, teaser: teaser, body: body, views: views)
+      post = Post.create(title: title, teaser: teaser, body: body, pubdate: pubdate, views: views)
       post.edit unless testing
       post.build
       meta = post.meta
     end
     return meta.num
   rescue => err
-    puts err
-    puts err.backtrace.join("\n")
+    _tmp_error(err)
   end
 
   def edit_initial_post(file, testing = false)
-    log!(enter: __method__, args: [file, testing])
+    log!(enter: __method__, args: [file, testing], level: 3)
     debug "=== edit_initial_post #{file.inspect}  => #{sourcefile}"
-    sourcefile = @root/:drafts/file
     result = system!("#@editor #{sourcefile} +8") unless testing
     raise EditorProblem(sourcefile) unless result
     process_post(sourcefile)
@@ -363,20 +402,20 @@ class RuneBlog
   end
 
   def posts
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     dir = self.view.dir/:posts
     posts = Dir.entries(dir).grep(/^\d{4}/)
     posts
   end
 
   def drafts
-    log!(enter: __method__)
+    log!(enter: __method__, level: 3)
     dir = @root/:drafts
     drafts = Dir.entries(dir).grep(/^\d{4}.*/)
   end
 
   def change_view(view)
-    log!(enter: __method__, args: [view])
+    log!(enter: __method__, args: [view], level: 3)
     raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
     x = OpenStruct.new
     x.root, x.current_view, x.editor = @root, view.to_s, @editor   # dumb - FIXME later
@@ -389,40 +428,38 @@ class RuneBlog
     raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
     @vdir = @root/:views/view
     collect_recent_posts("recent.html")
+  rescue => err
+    _tmp_error(err)
   end
 
   def generate_view(view)  # huh?
     log!(enter: __method__, args: [view])
-#   generate_index(view)   # recent posts (recent.html)
     vdir = @root/:views/view
     @theme = @root/:views/view/:themes/:standard
     xlate cwd: vdir/"themes/standard/etc",
           src: "blog.css.lt3", copy: vdir/"remote/etc/blog.css" # , debug: true
     xlate cwd: vdir/"themes/standard",
           src: "blog/generate.lt3", dst: vdir/:remote/"index.html"
-    generate_index(view)   # recent posts (recent.html)
-#   ^ HERE
     copy("#{vdir}/assets/*", "#{vdir}/remote/assets/")
   rescue => err
-    puts err
-    puts err.backtrace.join("\n")
-    print "Pause... "
-    gets
+    _tmp_error(err)
   end
 
   def _get_views(draft)
-    log!(enter: __method__, args: [draft])
+    log!(enter: __method__, args: [draft], level: 2)
     # FIXME dumb code
     view_line = File.readlines(draft).grep(/^.views /)
     raise "More than one .views call!" if view_line.size > 1
     raise "No .views call!" if view_line.size < 1
     view_line = view_line.first
     views = view_line[7..-1].split
-    views 
+    views.uniq 
+  rescue => err
+    _tmp_error(err)
   end
 
   def _copy_get_dirs(draft, view)
-    log!(enter: __method__, args: [draft, view])
+    log!(enter: __method__, args: [draft, view], level: 2)
     fname = File.basename(draft)
     noext = fname.sub(/.lt3$/, "")
     vdir = @root/:views/view
@@ -432,21 +469,24 @@ class RuneBlog
     viewdir, slugdir, aslug = vdir, dir, noext[5..-1]
     theme = viewdir/:themes/:standard
     [noext, viewdir, slugdir, aslug, theme]
+  rescue => err
+    _tmp_error(err)
   end
 
   def _post_metadata(draft, pdraft)
-    log!(enter: __method__, args: [draft, pdraft])
+    log!(enter: __method__, args: [draft, pdraft], level: 2)
     # FIXME store this somewhere
     fname = File.basename(draft)       # 0001-this-is-a-post.lt3
     nslug = fname.sub(/.lt3$/, "")     # 0001-this-is-a-post
     aslug = nslug.sub(/\d\d\d\d-/, "") # this-is-a-post
-    pnum = nslug[0..3]                  # 0001
+    pnum = nslug[0..3]                 # 0001
     Dir.chdir(pdraft) do 
       excerpt = File.read("teaser.txt")
       date = _retrieve_metadata(:date)
       longdate = ::Date.parse(date).strftime("%B %e, %Y")
       title = _retrieve_metadata(:title)
       tags = _retrieve_metadata(:tags)
+      # FIXME simplify
       vars = <<~LIVE
         .set post.num = #{pnum}
         .heredoc post.aslug
@@ -467,10 +507,12 @@ class RuneBlog
       LIVE
       File.open(pdraft/"vars.lt3", "w") {|f| f.puts vars }
     end
+  rescue => err
+    _tmp_error(err)
   end
 
   def copy_widget_html(view)
-    log!(enter: __method__)
+    log!(enter: __method__, level: 2)
     vdir = @root/:views/view
     remote = vdir/:remote
     wdir = vdir/:themes/:standard/:widgets
@@ -481,12 +523,15 @@ class RuneBlog
       create_dirs(rem)
       files = Dir[w/"*"]
       files = files.select {|x| x =~ /(html|css)$/ }
-      files.each {|file| system!("cp #{file} #{rem}") }
+      tag = File.basename(w)
+      files.each {|file| system!("cp #{file} #{rem}", show: (tag == "zzz")) }
     end
+  rescue => err
+    _tmp_error(err)
   end
 
-  def _handle_post(draft, view)
-    log!(enter: __method__, args: [draft, view])
+  def _handle_post(draft, view_name = self.view.to_s)
+    log!(enter: __method__, args: [draft, view_name], level: 2)
     # break into separate methods?
 
     fname = File.basename(draft)       # 0001-this-is-a-post.lt3
@@ -494,55 +539,34 @@ class RuneBlog
     aslug = nslug.sub(/\d\d\d\d-/, "") # this-is-a-post
     ahtml = aslug + ".html"            # this-is-a-post.html
     pdraft = @root/:posts/nslug
-    remote = @root/:views/view/:remote
-    @theme = @root/:views/view/:themes/:standard
+    remote = @root/:views/view_name/:remote
+    @theme = @root/:views/view_name/:themes/:standard
     # Step 1...
     create_dirs(pdraft)
-    xlate cwd: pdraft, src: draft, dst: "guts.html"
+    xlate cwd: pdraft, src: draft, dst: "guts.html", debug: true
     _post_metadata(draft, pdraft)
     # Step 2...
-    vposts = @root/:views/view/:posts
+    vposts = @root/:views/view_name/:posts
     copy!(pdraft, vposts)    # ??
     # Step 3..
     copy(pdraft/"guts.html", @theme/:post) 
     copy(pdraft/"vars.lt3",  @theme/:post) 
     # Step 4...
-    xlate cwd: @theme/:post, src: "generate.lt3", 
-          dst: remote/ahtml, copy: @theme/:post  # , debug: true
+    xlate cwd: @theme/:post, src: "generate.lt3", force: true, 
+          dst: remote/ahtml, copy: @theme/:post, debug: true
     xlate cwd: @theme/:post, src: "permalink.lt3", 
           dst: remote/:permalink/ahtml  # , debug: true
-    copy_widget_html(view)
+    copy_widget_html(view_name)
+  rescue => err
+    _tmp_error(err)
   end
 
   def generate_post(draft)
-    log!(enter: __method__, args: [draft])
+    log!(enter: __method__, args: [draft], level: 1)
     views = _get_views(draft)
-    views.each do |view| 
-      _handle_post(draft, view)
-#     generate_view(view)  # FIXME leads to inefficiency?
-#     ^ HERE
-    end
-  end
-
-  def OLD_index_entry(view, meta)
-    log!(enter: __method__, args: [view, meta])
-    debug "=== index_entry #{view.to_s.inspect}  #{meta.num} #{meta.title.inspect}"
-    check_meta(meta, "index_entry1")
-    raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
-    check_meta(meta, "index_entry2")
-    self.make_slug(meta)
-    check_meta(meta, "index_entry3")
-    # FIXME clean up and generalize
-    ref = view/meta.slug/"index.html"
-    <<-HTML
-      <font size=-1>#{meta.date}&nbsp;&nbsp;</font> <br>
-      <font size=+2 color=blue><a href=../#{ref} style="text-decoration: none">#{meta.title}</font></a>
-      <br>
-      <font size=+1>#{meta.teaser}&nbsp;&nbsp;</font>
-      <a href=../#{ref} style="text-decoration: none">Read more...</a>
-      <br>
-      <hr>
-    HTML
+    views.each {|view| _handle_post(draft, view) }
+  rescue => err
+    _tmp_error(err)
   end
 
   def rebuild_post(file)
@@ -556,12 +580,11 @@ class RuneBlog
     @views_dirty.flatten!
     @views_dirty.uniq!
   rescue => err
-    error(err)
-    getch
+    _tmp_error(err)
   end
 
   def remove_post(num)
-    log!(enter: __method__, args: [num])
+    log!(enter: __method__, args: [num], level: 1)
     raise ArgumentError unless num.is_a?(Integer)
     # FIXME update original draft .views
     tag = prefix(num)
@@ -578,7 +601,7 @@ class RuneBlog
   end
 
   def undelete_post(num)
-    log!(enter: __method__, args: [num])
+    log!(enter: __method__, args: [num], level: 1)
     raise ArgumentError unless num.is_a?(Integer)
     files = Find.find(@root/:views).to_a
     tag = prefix(num)
@@ -594,14 +617,14 @@ class RuneBlog
   end
 
   def delete_draft(num)
-    log!(enter: __method__, args: [num])
+    log!(enter: __method__, args: [num], level: 1)
     raise ArgumentError unless num.is_a?(Integer)
     tag = prefix(num)
     system!("rm -rf #@root/drafts/#{tag}-*")
   end
 
   def make_slug(meta)
-    log!(enter: __method__, args: [meta])
+    log!(enter: __method__, args: [meta], level: 3)
     raise ArgumentError unless meta.title.is_a?(String)
     label = '%04d' % meta.num   # FIXME can do better
     slug0 = meta.title.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
@@ -609,6 +632,5 @@ class RuneBlog
     meta.slug = str
     str
   end
-
 end