runeblog 0.0.45 → 0.0.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1e459ba25edc955fe31efb2e59f314c3049347c
-  data.tar.gz: 5eb31fa2ca94d0caa3980fb846a90ba8bad6ecbf
+  metadata.gz: acf9dddd4d4831cf3be7477a5dfa9835cf9bc02f
+  data.tar.gz: 4a55905bf1eaf9b00b3aa0cdcf17d352c99a3108
 SHA512:
-  metadata.gz: ea2bf26873cceedfc76cf85f8ac8721b8140877aa33781f8b2b9ecfcd5e4f81505528a4e2cf32cfc2cc63abde263778842bf692092de56aff79352018e8fcd42
-  data.tar.gz: e2c050a292b68017a1ec0bbd5bbb97bae042ca7bc9f2c414e9b608b89d24f52e5e4c089d3ab6ab0635eee228ae10df7cc804a2de1d809a528d2469a60541d128
+  metadata.gz: e5a6c7faf63b9e3564df736b747637d7f0d2256cf8f1f59a660fb268151151b7dfd26161e159b5bb89dcd5b2d2768a3e0ff64ccd2efce2b8ceeb7ec22ba3302e
+  data.tar.gz: 2ac106c905e58b85948a2adb85b636a0bb9e1ca72bee6d2bf192b83a214508cb34a680211aaf2ae1b5d28227edcb93c8c9223948ad5771ede2ef979ad064c945

data/bin/blog

@@ -22,28 +22,25 @@ STDOUT.sync = true
 
 cmd, arg = get_argv
 
-read_config
+open_blog
 
 puts red("\n  RuneBlog v #{RuneBlog::VERSION}")
 
 if cmd.nil?   # REPL
   puts
   loop do
-    print red("blog> ")
-    begin
-      cmd = gets.chomp
-      meth, params = Command.choose_method(cmd)
-    rescue => err
-      puts err
-      next 
-    end
+    print red("\nblog> ")
+    cmd = gets
+    cmd_quit([]) if cmd.nil?   # ^D
+    cmd.chomp!
+    meth, params = RuneBlog::Command.choose_method(cmd)
     send(meth, params)
   end
 else  # one command
   raise "Not working right now"
   file = File.open("/dev/tty")
   STDIN.reopen(file)    # avoid ARGF dumbness
-  meth, params = Command.choose_method(cmd)
+  meth, params = RuneBlog::Command.choose_method(cmd)
   parse_cmd(ARGV.join(" "))
   execute_command
 end

data/data/VERSION

@@ -1 +1 @@
-RuneBlog v 0.0.45   2018-08-27
+RuneBlog v 0.0.48   2018-08-30

data/lib/blogcmds.rb

@@ -1,12 +1,11 @@
-# help
-# list views
-# new view $viewname
-
-class Command 
+class RuneBlog::Command 
   Patterns = 
     {"help"              => :cmd_help, 
      "h"                 => :cmd_help,
 
+     "version"           => :cmd_version,
+     "v"                 => :cmd_version,
+
      "list views"        => :cmd_list_views, 
      "lsv"               => :cmd_list_views, 
 
@@ -16,8 +15,9 @@ class Command
      "p"                 => :cmd_new_post,
      "post"              => :cmd_new_post,
 
-     "change view $name" => :cmd_change_views,
-     "cv $name"          => :cmd_change_views,
+     "change view $name" => :cmd_change_view,
+     "cv $name"          => :cmd_change_view,
+     "cv"                => :cmd_change_view,  # 0-arity must come second
 
      "list posts"        => :cmd_list_posts,
      "lsp"               => :cmd_list_posts,
@@ -56,12 +56,13 @@ class Command
     rx = Regexp.new(rx)
     Regexes[rx] = meth
   end
-  
+
   def self.choose_method(cmd)
     found = nil
     params = []
     Regexes.each_pair do |rx, meth|
       m = cmd.match(rx)
+# puts "#{rx} =~ #{cmd.inspect}  --> #{m.to_a.inspect}"
       result = m ? m.to_a : nil
       next unless result
       found = meth
@@ -73,23 +74,3 @@ class Command
   end
 end
 
-# test_cmds = [
-#              "fake cmd foo bar",
-#              "help", 
-#              "h",
-#              "list views", 
-#              "lsv",
-#              "new view foo",
-#              "not valid",
-#              "help invalid",
-#              "new view",
-#              "new view too many args"]
-# 
-# loop do 
-#   print "\nCmd = "
-#   cmd = gets.chomp.strip
-#   meth, params = Command.choose_method(cmd)
-#   puts "  Calling: #{meth}(#{params.inspect})"
-# end
-
-

data/lib/newruneblog.rb

@@ -0,0 +1,106 @@
+require 'find'
+require 'yaml'
+require 'livetext'
+
+class RuneBlog
+  VERSION = "0.0.45"
+
+  Path  = File.expand_path(File.join(File.dirname(__FILE__)))
+  DefaultData = Path + "/../data"
+
+  BlogHeaderPath  = DefaultData + "/custom/blog_header.html"
+  BlogTrailerPath = DefaultData + "/custom/blog_trailer.html"
+
+  BlogHeader  = File.read(BlogHeaderPath)  rescue "not found"
+  BlogTrailer = File.read(BlogTrailerPath) rescue "not found"
+end
+
+# Continued below...
+
+class RuneBlog::Config
+  attr_reader :root, :views, :view, :sequence
+  attr_writer :view  # FIXME
+
+  def self.create(cfg_file = ".blog")
+    RuneBlog.create_new_blog
+  end
+
+  def initialize(cfg_file = ".blog")
+    # What views are there? Deployment, etc.
+    # Crude - FIXME later
+
+    lines = File.readlines(cfg_file).map {|x| x.chomp }
+    @root = lines[0]
+    @view = lines[1]
+    dirs = Dir.entries("#@root/views/") - %w[. ..]
+    dirs.reject! {|x| ! File.directory?("#@root/views/#{x}") }
+    @root = root
+    @views = dirs
+    @sequence = File.read(root + "/sequence").to_i
+  end
+
+  def next_sequence
+    @sequence += 1
+    File.open("#@root/sequence", "w") {|f| f.puts @sequence }
+    @sequence
+  end
+
+  def viewdir(v)
+    @root + "/views/#{v}/"
+  end
+
+end
+
+# Reopening...
+
+class RuneBlog
+
+  def self.exist?
+    File.exist?(".blog")
+  end
+
+  def get_config
+  end
+
+# def initialize
+#   # ?
+# end
+
+  def self.create_new_blog
+    #-- what if data already exists?
+    result = system("cp -r #{RuneBlog::DefaultData} .")
+    raise "Error copying default data" unless result
+
+    File.open(".blog", "w") do |f| 
+      f.puts "data" 
+      f.puts "no_default"
+    end
+    File.open("data/VERSION", "a") {|f| f.puts "\nBlog created: " + Time.now.to_s }
+  end
+
+# def self.open_blog
+# end
+
+#   def self.create_new_post(title, date, view)
+#     @template = <<-EOS
+# .mixin liveblog
+# 
+# .title #{title}
+# .pubdate #{date}
+# .views #{view}
+# 
+# .teaser
+# Teaser goes here.
+# .end
+# Remainder of post goes here.
+#   EOS
+# 
+#     @slug = make_slug(title)
+#     @fname = @slug + ".lt3"
+#     File.open("#@root/src/#@fname", "w") {|f| f.puts @template }
+#     @fname
+#   rescue => err
+#     error(err, __LINE__, __FILE__)
+#   end
+
+end

data/lib/oldrepl.rb

@@ -0,0 +1,628 @@
+require 'runeblog'
+
+require 'ostruct'
+
+=begin
+  Instance vars in original code:
+    @bloghead
+    @blogtail
+    @config
+    @date
+    @deploy
+    @fname
+    @main
+    @meta
+    @root
+    @sequence
+    @slug
+    @template
+    @title
+    @today
+    @view
+=end
+
+module RuneBlog::REPL
+
+  ### error
+
+  def error(err, line, file)
+    str = "\n  Error: #{red(err)}"
+    puts err.backtrace
+  end
+
+  ### ask
+
+  def ask(prompt, meth = :to_s)
+    print prompt
+    STDOUT.flush
+    STDIN.gets.chomp.send(meth)
+  end
+
+  def yesno(prompt, meth = :to_s)
+    print prompt
+    STDOUT.flush
+    STDIN.gets.chomp.upcase[0] == "Y"
+  end
+
+  ### quit
+
+  def cmd_quit(arg)
+    raise "Glitch: Got an argument" if arg != []
+    puts "\n "
+    exit
+  end
+
+  ### version
+
+  def cmd_version(arg)
+    raise "Glitch: Got an argument" if arg != []
+    puts "\n  " + RuneBlog::VERSION
+  end
+
+  ### new_blog!
+
+  def cmd_new_blog!(arg)
+    raise "Glitch: Got an argument" if arg != []
+    return if RuneBlog.exist?
+    yn = yesno(red("  No .blog found. Create new blog? "))
+    RuneBlog.create_new_blog if yn
+  rescue => err
+    error(err)
+  end 
+
+  ### make_slug
+
+  # What to do with this?
+
+  def make_slug(title, seq=nil)
+    num = '%04d' % (seq || @config.next_sequence)   # FIXME can do better
+    slug = title.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+    "#{num}-#{slug}"
+  end
+
+  ### read_config
+
+  def read_config # Crude - FIXME later
+    cmd_new_blog!([]) unless RuneBlog.exist?
+    @config = RuneBlog::Config.new
+    @view = @config.view     # current view
+    @sequence = @config.sequence
+    @root = @config.root
+    @config
+  rescue => err
+    error(err)
+  end
+
+  ### create_empty_post
+
+  def create_empty_post
+    @template = <<-EOS
+.mixin liveblog
+
+.title #@title
+.pubdate #@date
+.views #@view
+
+.teaser
+Teaser goes here.
+.end
+Remainder of post goes here.
+  EOS
+
+    @slug = make_slug(@title)
+    @fname = @slug + ".lt3"
+    File.open("#@root/src/#@fname", "w") {|f| f.puts @template }
+    @fname
+  rescue => err
+    error(err)
+  end
+
+  ### edit_initial_post
+
+  def edit_initial_post(file)
+    result = system("vi #@root/src/#{file} +8 ")
+    raise "Problem editing #@root/src/#{file}" unless result
+  rescue => err
+    error(err, __LINE__, __FILE__)
+  end
+
+  ### browse
+
+  def cmd_browse
+    raise "Glitch: Got an argument" if arg != []
+    @deploy ||= {}
+    return puts red("\n  Deploy first.") unless @deploy[@view]
+
+    lines = @deploy[@view]
+    user, server, sroot, spath = *lines
+    result = system("open 'http://#{server}/#{spath}'")
+    raise "Problem opening http://#{server}/#{spath}" unless result
+  rescue => err
+    error(err)
+  end
+
+  ### open_local
+
+  def open_local
+    result = system("open #{@config.viewdir(@view)}/index.html")
+    raise "Problem opening #{@config.viewdir(@view)}/index.html" unless result
+  rescue => err
+    error(err)
+  end
+
+  def cmd_deploy(arg)
+    # TBD clunky FIXME 
+    raise "Glitch: Got an argument" if arg != []
+    @deploy ||= {}
+    deployment = @config.viewdir(@view) + "deploy"
+    raise "File '#{deployment}' not found" unless File.exist?(deployment)
+
+    lines = File.readlines(deployment).map {|x| x.chomp }
+    @deploy[@view] = lines
+    user, server, sroot, spath = *lines
+    vdir = @config.viewdir(@view)
+    files = ["#{vdir}/index.html"]
+    files += Dir.entries(vdir).grep(/^\d\d\d\d/).map {|x| "#{vdir}/#{x}" }
+    files.reject! {|f| File.mtime(f) < File.mtime("#{vdir}/last_deployed") }
+    return puts red("\n  No files to deploy") if files.empty?
+
+    puts "\n  Files:"
+    files.each {|f| puts "    " + f }
+    puts
+    dir = "#{sroot}/#{spath}"
+    # FIXME - may or may not already exist
+    result = system("ssh root@#{server} mkdir #{dir}") 
+
+    cmd = "scp -r #{files.join(' ')} root@#{server}:#{dir} >/dev/null 2>&1"
+    print red("\n  Deploying #{files.size} files... ")
+    result = system(cmd)
+    raise "Problem occurred in deployment" unless result
+
+    File.write("#{vdir}/last_deployed", files)
+    puts red("finished.")
+  rescue => err
+    error(err)
+  end
+
+  ### process_post
+
+  def process_post(file)
+    @main ||= Livetext.new
+    @main.main.output = File.new("/tmp/WHOA","w")
+    path = @root + "/src/#{file}"
+    @meta = @main.process_file(path, binding)
+    raise "process_file returned nil" if @meta.nil?
+
+    @meta.slug = make_slug(@meta.title, @config.sequence)
+    @meta.slug = file.sub(/.lt3$/, "")
+    @meta
+  rescue => err
+    error(err)
+  end
+
+  ### reload_post
+
+  def reload_post(file)
+    @main ||= Livetext.new
+    @main.main.output = File.new("/tmp/WHOA","w")
+    @meta = process_post(file)
+    @meta.slug = file.sub(/.lt3$/, "")
+    @meta
+  rescue => err
+    error(err)
+  end
+
+  ### posting
+
+  def posting(view, meta)
+    ref = "#{view}/#{meta.slug}/index.html"
+    <<-HTML
+      <br>
+      <font size=+1>#{meta.pubdate}&nbsp;&nbsp;</font>
+      <font size=+2 color=blue><a href=../#{ref} style="text-decoration: none">#{meta.title}</font></a>
+      <br>
+      #{meta.teaser}  
+      <a href=../#{ref} style="text-decoration: none">Read more...</a>
+      <br><br>
+      <hr>
+    HTML
+  end
+
+  ### generate_index
+
+  def generate_index(view)
+    # Gather all posts, create list
+    vdir = "#@root/views/#{view}"
+    posts = Dir.entries(vdir).grep /^\d\d\d\d/
+    posts = posts.sort.reverse
+
+    # Add view header/trailer
+    head = File.read("#{vdir}/custom/blog_header.html") rescue RuneBlog::BlogHeader
+    tail = File.read("#{vdir}/custom/blog_trailer.html") rescue RuneBlog::BlogTrailer
+    @bloghead = interpolate(head)
+    @blogtail = interpolate(tail)
+
+    # Output view
+    posts.map! {|post| YAML.load(File.read("#{vdir}/#{post}/metadata.yaml")) }
+    File.open("#{vdir}/index.html", "w") do |f|
+      f.puts @bloghead
+      posts.each {|post| f.puts posting(view, post) }
+      f.puts @blogtail
+    end
+  rescue => err
+    error(err)
+  end
+
+  ### create_dir
+
+  def create_dir(dir)
+    cmd = "mkdir -p #{dir} >/dev/null 2>&1"
+    result = system(cmd) 
+    raise "Can't create #{dir}" unless result
+  end
+
+  ### link_post_view
+
+  def link_post_view(view)
+    # Create dir using slug (index.html, metadata?)
+    vdir = @config.viewdir(view)
+    dir = vdir + @meta.slug + "/"
+    create_dir(dir + "assets") 
+    File.write("#{dir}/metadata.yaml", @meta.to_yaml)
+    template = File.read(vdir + "custom/post_template.html")
+    post = interpolate(template)
+    File.write(dir + "index.html", post)
+    generate_index(view)
+  rescue => err
+    error(err)
+  end
+
+  ### find_asset
+
+#   def find_asset(asset)    # , views)
+# # STDERR.puts "repl find_asset: @meta = #{@meta.inspect}"
+#     views = @meta.views
+#     views.each do |view| 
+#       vdir = @config.viewdir(view)
+#       post_dir = "#{vdir}#{@meta.slug}/assets/"
+#       path = post_dir + asset
+#       STDERR.puts "          Seeking #{path}"
+#       return path if File.exist?(path)
+#     end
+#     views.each do |view| 
+#       dir = @config.viewdir(view) + "/assets/"
+#       path = dir + asset
+#       STDERR.puts "          Seeking #{path}"
+#       return path if File.exist?(path)
+#     end
+#     top = @root + "/assets/"
+#     path = top + asset
+#     STDERR.puts "          Seeking #{path}"
+#     return path if File.exist?(path)
+# 
+#     return nil
+#   end
+# 
+#   ### find_all_assets
+# 
+#   def find_all_assets(list, views)
+# #   STDERR.puts "\n  Called find_all_assets with #{list.inspect}"
+#     list ||= []
+#     list.each {|asset| puts "#{asset} => #{find_asset(asset, views)}" }
+#   end
+
+  ### publish_post
+
+  def publish_post(meta)
+    puts "  #{colored_slug(meta.slug)}"
+    # First gather the views
+    views = meta.views
+    print "       Views: "
+    views.each do |view| 
+      print "#{view} "
+      link_post_view(view)
+    end
+#   assets = find_all_assets(@meta.assets, views)
+    puts
+  rescue => err
+    error(err)
+  end
+
+  ### rebuild_post
+  
+  def rebuild_post(file)
+    reload_post(file)
+    publish_post(@meta)       # FIXME ??
+  rescue => err
+    error(err)
+  end
+
+  ### rebuild
+
+  def cmd_rebuild(arg)
+    raise "Glitch: Got an argument" if arg != []
+    puts
+    files = Dir.entries("#@root/src/").grep /\d\d\d\d.*.lt3$/
+    files.map! {|f| File.basename(f) }
+    files = files.sort.reverse
+    files.each {|file| rebuild_post(file) }
+  rescue => err
+    error(err)
+  end
+
+  ### relink
+
+  def cmd_relink(arg)
+    raise "Glitch: Got an argument" if arg != []
+    @config.views.each {|view| generate_index(view) }
+  rescue => err
+   error(err)
+  end
+
+#  ### publish?
+#
+#  def publish?
+#    yn = ask(red("  Publish? y/n "))
+#    yn.upcase == "Y"
+#  end
+
+  ### list_views
+
+  def cmd_list_views(arg)
+    abort "Config file not read"  unless @config
+    raise "Glitch: Got an argument" if arg != []
+    puts
+    @config.views.each {|v| puts "  #{v}" }
+  rescue => err
+    error(err)
+  end
+
+  ### change_view
+
+  def cmd_change_view(arg)
+    if arg.empty?
+      puts "\n  #@view"
+    else
+      arg = arg.first
+      list = @config.views.grep /^#{arg}/
+      if list.size == 1
+        @view = @config.view = list.first
+        puts red("\n  View: #{@view}") if arg != @view
+      else
+        puts "view #{arg.inspect} does not exist"
+      end
+    end
+  rescue => err
+    error(err)
+  end
+
+  ### new_view
+
+  def cmd_new_view(arg)
+    arg = arg.first
+    read_config unless @config
+    arg ||= ask("New view: ")  # check validity later
+    raise "view #{arg} already exists" if @config.views.include?(arg)
+
+    dir = @root + "/views/" + arg + "/"
+    create_dir(dir + 'custom')
+    create_dir(dir + 'assets')
+
+    # Something more like this?  RuneBlog.new_view(arg)
+    File.write(dir + "custom/blog_header.html",  RuneBlog::BlogHeader)
+    File.write(dir + "custom/blog_trailer.html", RuneBlog::BlogTrailer)
+    File.write(dir + "last_deployed", "Initial creation")
+    @config.views << arg
+  rescue => err
+    error(err)
+  end
+
+  ### import
+
+  def import(arg = nil)
+    read_config unless @config
+    arg = nil if arg == ""
+    arg ||= ask("Filename: ")  # check validity later
+    name = arg
+    grep = `grep ^.title #{name}`
+    @title = grep.sub(/^.title /, "")
+    @slug = make_slug(@title)
+    @fname = @slug + ".lt3"
+    result = system("cp #{name} #@root/src/#@fname")
+    raise "Could not copy #{name} to #@root/src/#@fname" unless result
+
+    edit_initial_post(@fname)
+    process_post(@fname)
+    publish_post(@meta) # if publish?
+  rescue => err
+    error(err)
+  end
+
+  ### new_post
+
+  def cmd_new_post(arg)
+    raise "Glitch: Got an argument" if arg != []
+    read_config unless @config
+    @title = ask("Title: ")
+    @today = Time.now.strftime("%Y%m%d")
+    @date = Time.now.strftime("%Y-%m-%d")
+
+    file = create_empty_post
+    edit_initial_post(file)
+  # file = @root + "/src/" + file
+    process_post(file)  #- FIXME handle each view
+    publish_post(@meta) # if publish?
+  rescue => err
+    error(err)
+  end
+
+  ### remove_multiple_posts
+  
+  def remove_multiple_posts(str)
+    args = str.split
+    args.each {|arg| remove_post(arg, false) }
+  end
+
+  ### remove_post
+
+  #-- FIXME affects linking, building, deployment...
+
+  def cmd_remove_post(arg, safe=true)
+    arg = arg.first
+    id = Integer(arg) rescue raise("'#{arg}' is not an integer")
+    tag = "#{'%04d' % id}"
+    files = Find.find(@root).to_a
+    files = files.grep(/#{tag}-/)
+    return puts red("\n  No such post found (#{id})") if files.empty?
+
+    if safe
+      puts
+      files.each {|f| puts "  #{f}" }
+      ques = files.size > 1 ? "\n  Delete all these? " : "\n  Delete? "
+      yn = ask red(ques)
+      if yn.downcase == "y"
+        result = system("rm -rf #{files.join(' ')}")
+        raise "Problem deleting file(s)" unless result
+        puts red("\n  Deleted")
+      else
+        puts red("\n  No action taken")
+      end
+    else
+      result = system("rm -rf #{files.join(' ')}")
+      puts red("\n  Deleted:")
+      files.each {|f| puts "    #{f}" }
+      raise "Problem mass-deleting file(s)" unless result
+    end
+  rescue => err
+    puts err
+    puts err.backtrace
+    puts
+  end
+
+  ### edit_post
+
+  #-- FIXME affects linking, building, deployment...
+
+  def cmd_edit_post(arg)
+    arg = arg.first
+    id = Integer(arg) rescue raise("'#{arg}' is not an integer")
+    tag = "#{'%04d' % id}"
+    files = Find.find(@root+"/src").to_a
+    files = files.grep(/#{tag}-/)
+    files = files.map {|f| File.basename(f) }
+    return puts red("Multiple files: #{files}") if files.size > 1
+    return puts red("\n  No such post found (#{id})") if files.empty?
+
+    file = files.first
+    result = system("vi #@root/src/#{file}")
+    raise "Problem editing #{file}" unless result
+
+    rebuild_post(file)
+  rescue => err
+    puts err
+    puts err.backtrace
+    puts
+  end
+
+  ### list_posts
+
+  def cmd_list_posts(arg)
+    raise "Glitch: Got an argument" if arg != []
+    dir = @config.viewdir(@view)
+    Dir.chdir(dir) do
+      posts = Dir.entries(".").grep(/^0.*/)
+      if posts.empty?
+        puts "\n  " + @view + ":" + red("  No posts")
+      else
+        puts "\n  " + @view + ":\n "
+        posts.each {|post| puts "  #{colored_slug(post)}" }
+      end
+    end
+  rescue 
+    puts "Oops? cwd = #{Dir.pwd}   dir = #{dir}"
+    puts err.backtrace
+    exit
+  end
+
+  ### list_drafts
+
+  def cmd_list_drafts(arg)
+    raise "Glitch: Got an argument" if arg != []
+    dir = "#@root/src"
+    Dir.chdir(dir) do
+      posts = Dir.entries(".").grep(/^0.*.lt3/)
+      puts
+      if posts.empty?
+        puts red("  No posts")
+      else
+        posts.each {|post| puts "  #{colored_slug(post.sub(/.lt3$/, ""))}" }
+      end
+    end
+  rescue 
+    puts "Oops? cwd = #{Dir.pwd}   dir = #{dir}"
+    puts err.backtrace
+    exit
+  end
+
+  def cmd_INVALID(arg)
+    puts "\n  Command '#{red(arg)}' was not understood."
+  end
+
+  def cmd_help(arg)
+    raise "Glitch: Got an argument" if arg != []
+    puts <<-EOS
+  
+    Commands:
+  
+       #{red('h, help       ')}    This message
+       #{red('q, quit        ')}   Exit the program
+       #{red('v, version    ')}    Print version information
+  
+       #{red('change view VIEW ')} Change current view
+       #{red('cv VIEW          ')} Change current view
+       #{red('new view         ')} Create a new view
+       #{red('list views       ')} List all views available
+       #{red('lsv              ')} Same as: list views
+  
+       #{red('p, post          ')} Create a new post
+       #{red('new post         ')} Same as post (create a post)
+       #{red('lsp, list posts  ')} List posts in current view
+       #{red('lsd, list drafts ')} List all posts regardless of view
+  
+       #{red('rm ID            ')} Remove a post
+       #{red('edit ID          ')} Edit a post
+  
+       #{red('preview          ')} Look at current (local) view in browser
+       #{red('browse           ')} Look at current (deployed) view in browser
+       #{red('relink           ')} Regenerate index for all views
+       #{red('rebuild          ')} Regenerate all posts and relink
+       #{red('deploy           ')} Deploy (current view)
+    EOS
+  end
+
+  def clear
+    puts "\e[H\e[2J"  # clear screen
+  end
+
+  def red(text)
+    "\e[31m#{text}\e[0m"
+  end
+
+  def blue(text)
+    "\e[34m#{text}\e[0m"
+  end
+
+  def bold(str)
+    "\e[1m#{str}\e[22m"
+  end
+
+  def interpolate(str)
+    wrap = "<<-EOS\n#{str}\nEOS"
+    eval wrap
+  end
+
+  def colored_slug(slug)
+    red(slug[0..3])+blue(slug[4..-1])
+  end
+
+end