runeblog 0.3.02

data/lib/logging.rb

@@ -0,0 +1,44 @@
+unless self.respond_to?("log!")
+  $logging = true
+  $log = File.new("/tmp/runeblog.log","w")
+
+  def outlog(str = "", stderr: false)
+    $log.puts str
+    STDERR.puts str if stderr
+  end
+
+  def log!(str: "", enter: nil, args: [], pwd: false, dir: false, level: 0, stderr: false)
+    return unless $logging
+    @err_level ||= ENV['RUNEBLOG_ERROR_LEVEL']
+    @err_level ||= 0
+    return if level < @err_level 
+
+    time = Time.now.strftime("%H:%M:%S")
+
+    meth = ""
+    meth = "#{enter}" if enter
+
+    para = "(#{args.inspect[1..-2]})"
+
+    source = caller[0].sub(/.*\//, " in ").sub(/:/, " line ").sub(/:.*/, "")
+    source = "in #{source} (probably liveblog.rb)" if source.include? "(eval)"
+
+    str = "  ... #{str}" unless str.empty?
+    indent = " "*12
+
+    outlog "#{time} #{meth}#{para}"
+    outlog "#{indent} #{str} " unless str.empty?
+    outlog "#{indent} #{source}"
+    outlog "#{indent} pwd = #{Dir.pwd} " if pwd
+    if dir
+      files = (Dir.entries('.') - %w[. ..]).join(" ")
+      outlog "#{indent} dir/* = #{files}"
+    end
+#   outlog "#{indent} livetext params = #{livedata.inpect} " unless livedata.nil?
+    outlog 
+    $log.close
+    $log = File.new("/tmp/runeblog.log","a")
+  end
+
+end
+

data/lib/lowlevel.rb

@@ -0,0 +1,73 @@
+
+  def dump(obj, name)
+    File.write(name, obj)
+  end
+
+  def system!(str, show: false)
+    log!(enter: __method__, args: [str], level: 2)
+    STDERR.puts str if show
+    rc = system(str)
+    return rc if rc
+    STDERR.puts "FAILED: #{str.inspect}"
+    STDERR.puts "\ncaller = \n#{caller.join("\n  ")}\n"
+    if defined?(RubyText)
+      sleep 6
+      RubyText.stop
+      exit
+    end
+    return rc
+  end
+
+  def _get_data?(file)   # File need not exist
+    if File.exist?(file)
+      _get_data(file)
+    else
+      []
+    end
+  end
+
+  def _get_data(file)
+    lines = File.readlines(file)
+    lines.reject! {|line| line[0] == "-" }  # allow rejection of lines
+    lines = lines.map do |line|
+      line.sub(/ *# .*$/, "")               # allow trailing comments
+    end
+    lines
+  end
+
+  def copy(src, dst)
+    log!(enter: __method__, args: [src, dst], level: 2)
+    cmd = "cp #{src} #{dst} 2>/dev/null"
+    system!(cmd)
+  end
+
+  def copy!(src, dst)
+    log!(enter: __method__, args: [src, dst], level: 2)
+    cmd = "cp -r #{src} #{dst} 2>/dev/null"
+    system!(cmd)
+  end
+
+  def create_dirs(*dirs)
+    log!(enter: __method__, args: [*dirs], level: 3)
+    dirs.each do |dir|
+      dir = dir.to_s  # symbols allowed
+      next if Dir.exist?(dir)
+      cmd = "mkdir -p #{dir} >/dev/null"
+      result = system!(cmd) 
+      raise CantCreateDir(dir) unless result
+    end
+  end
+
+  def interpolate(str, bind)
+    log!(enter: __method__, args: [str, bind], level: 3)
+    wrap = "<<-EOS\n#{str}\nEOS"
+    eval wrap, bind
+  end
+
+  def error(err)
+    log!(str: err, enter: __method__, args: [err], level: 2)
+    str = "\n  Error: #{err}"
+    puts str
+    puts err.backtrace.join("\n")
+  end
+

data/lib/pathmagic.rb

@@ -0,0 +1,14 @@
+module PathSep
+  def /(right)
+    s1 = self.to_s.dup
+    s2 = right.to_s.dup
+    s1 << "/" unless s1.end_with?("/") || s2.start_with?("/")
+    path = s1 + s2
+    path.gsub!("//", "/")
+    path
+  end
+end
+
+String.include(PathSep)
+Symbol.include(PathSep)
+

data/lib/post.rb

@@ -0,0 +1,211 @@
+require 'runeblog'
+require 'pathmagic'
+
+class RuneBlog::Post
+
+  attr_reader :num, :title, :date, :views, :num, :slug
+  attr_accessor :meta, :blog, :draft
+
+  include RuneBlog::Helpers
+
+  
+  def self.load(post)
+    log!(enter: __method__, args: [post], level: 3)
+    raise "Doesn't work right now"
+    raise NoBlogAccessor if RuneBlog.blog.nil?
+    # "post" is a slug
+    pdir = RuneBlog.blog.root/:drafts/post
+    meta = nil
+    Dir.chdir(pdir) do
+      meta = read_config("metadata.txt")
+      meta.date = Date.parse(meta.date)
+      meta.views = meta.views.split
+      meta.tags = meta.tags.split
+      meta.teaser = File.read("teaser.txt")
+#     meta.body = File.read("body.txt")
+    end
+    meta
+  end
+
+  def write_metadata(meta)   # FIXME ???
+    log!(enter: __method__, args: [meta], level: 3)
+    debug "=== write_metadata:"
+    debug "-----\n#{meta.inspect}\n-----"
+    fname2 = "metadata.txt"
+    hash = meta.to_h
+
+    File.write("teaser.txt", hash[:teaser])
+    hash.delete(:teaser)
+    hash.delete(:body)
+
+    hash[:views] = hash[:views].join(" ")
+    hash[:tags]  = hash[:tags].join(" ")
+
+    fields = [:num, :title, :date, :pubdate, :views, :tags]
+
+    f2 = File.new(fname2, "w")
+    fields.each {|fld| f2.puts "#{fld}: #{hash[fld]}" }
+    f2.close
+  end
+
+  def initialize
+    log!(enter: __method__, level: 3)
+    @blog = RuneBlog.blog || raise(NoBlogAccessor)
+    @meta = OpenStruct.new
+  end
+
+  def self.create(title:, teaser:, body:, pubdate: Time.now.strftime("%Y-%m-%d"),
+                  views:[], file: nil)
+    log!(enter: __method__, args: [title, teaser, body, pubdate, views], stderr: true)
+    post = self.new
+    # NOTE: This is the ONLY place next_sequence is called!
+    num = post.meta.num   = post.blog.next_sequence
+
+    # new_metadata
+    post.meta.title, post.meta.teaser, post.meta.body, post.meta.pubdate = 
+      title, teaser, body, pubdate
+    post.meta.views = [post.blog.view.to_s] + views
+    post.meta.tags = []
+    post.blog.make_slug(post.meta)  # adds to meta
+
+    # create_draft
+    viewhome = post.blog.view.publisher.url
+    meta = post.meta
+    if file.nil?
+      text = RuneBlog.post_template(num: meta.num, title: meta.title, date: meta.pubdate, 
+                 view: meta.view, teaser: meta.teaser, body: meta.body,
+                 views: meta.views, tags: meta.tags, home: viewhome)
+      srcdir = post.blog.root/:drafts + "/"
+      vpdir = post.blog.root/:drafts + "/"
+      fname  = meta.slug + ".lt3"
+      post.draft = srcdir + fname
+      dump(text, post.draft)
+    else
+      dump(File.read(file), post.draft)
+    end
+    return post
+  end
+
+  def edit
+    log!(enter: __method__)
+    result = system!("vi #@draft +8")  # TODO improve this
+    raise EditorProblem(draft) unless result
+    nil
+  rescue => err
+    error(err)
+  end 
+
+  def build
+    log!(enter: __method__)
+    post = self
+    views = post.meta.views
+    text = File.read(@draft)
+    @blog.generate_post(@draft)
+  end
+end
+
+class RuneBlog::ViewPost
+  attr_accessor :nslug, :aslug, :num, :view, :blog
+  attr_accessor :path, :title, :date, :teaser_text
+
+  def self.make(blog:, view:, nslug:)
+    raise "No numeric prefix on #{nslug}" unless nslug =~ /^\d{4}-/
+    raise "Not expecting an extension" if nslug.end_with?(".lt3") || nslug.end_with?(".html")
+    view = view.to_s
+    view.define_singleton_method :path do |subdir = ""|
+      str = blog.root/:views/view
+      str << "/#{subdir}" unless subdir.empty?
+      str
+    end
+    view.define_singleton_method :standard do |subdir = ""|
+      str = blog.root/:views/view/:themes/:standard
+      str << "/#{subdir}" unless subdir.empty?
+      str
+    end
+    view.define_singleton_method :postdir do |file = ""|
+      file = file.to_s
+      str = blog.root/:views/view/:posts/nslug
+      str = str/file unless file.empty?
+      str
+    end 
+    view.define_singleton_method :remote do |dir: "", file: ""|
+      subdir = subdir.to_s
+      file = file.to_s
+      str = blog.root/:views/view/:remote
+      str = str/subdir unless subdir.empty?
+      str = str/file unless file.empty?
+      str
+    end
+    obj = RuneBlog::ViewPost.new(view, nslug)
+    obj.blog = blog
+    obj.view = view
+    obj.nslug = nslug
+    obj.aslug = nslug[5..-1]
+    obj.num = nslug[0..3]
+    obj
+  end
+
+  def repo(subdir = "")
+    subdir = subdir.to_s
+    unless subdir.empty?
+      raise "Expected 'posts' or 'drafts'" unless %w[posts drafts].include?(subdir)
+    end
+    str = blog.root
+    str = str/subdir unless subdir.empty?
+    str
+  end
+
+  alias root repo
+
+  def slug(num = true, ext = "")
+    ext = ext.to_s
+    str = ""
+    str << @num << "-" if num
+    str << @aslug 
+    str << ext
+    str
+  end
+              
+=begin
+  aslug          this-is-a-post
+  aslug_live     this-is-a-post.lt3
+  aslug_html     this-is-a-post.lt3
+  nslug          0001-this-is-a-post
+
+  slug(:num, ext = "")
+=end
+
+  def initialize(view, postdir)
+    log!(enter: __method__, args: [view, postdir], level: 3)
+    # Assumes already parsed/processed
+    @blog = RuneBlog.blog || raise(NoBlogAccessor)
+    @path = postdir.dup
+    @nslug = @path.split("/").last
+    @aslug = @nslug[5..-1]
+    fname = "#{postdir}/teaser.txt"            # ???
+    @teaser_text = File.read(fname).chomp
+    # FIXME dumb hacks...
+    mdfile = postdir/"metadata.txt"
+    lines = File.readlines(mdfile)
+    @title = lines.grep(/title:/).first[7..-1].chomp
+    @date  = lines.grep(/pubdate:/).first[9..-1].chomp
+# print "-- date = #{@date.inspect} "; gets
+  rescue => err
+    STDERR.puts "--- #{err}\n #{err.backtrace.join("\n  ")}"
+  end
+
+  def get_dirs
+    log!(enter: __method__, args: [view, postdir], level: 3)
+    fname = File.basename(draft)
+    noext = fname.sub(/.lt3$/, "")
+    vdir = @root/:views/view
+    dir = vdir/:posts/noext + "/"
+    Dir.mkdir(dir) unless Dir.exist?(dir)
+    system!("cp #{draft} #{dir}")
+    viewdir, slugdir, aslug = vdir, dir, noext[5..-1]
+    theme = viewdir/:themes/:standard
+    [noext, viewdir, slugdir, aslug, theme]
+  end
+
+end
+

data/lib/processing.rb

@@ -0,0 +1,60 @@
+if ! defined?(LIVE)
+
+require 'livetext'
+
+LIVE = Livetext.new
+LEXT = ".lt3"
+
+def newer?(f1, f2)
+  File.mtime(f1) > File.mtime(f2)
+end
+
+def stale?(src, dst, deps, force = false)
+  meh = File.new("/tmp/dammit-#{src.gsub(/\//, "-")}", "w")
+  log!(enter: __method__, args: [src, dst], level: 3)
+  raise "Source #{src} not found in #{Dir.pwd}" unless File.exist?(src)
+  return true if force
+  return true unless File.exist?(dst)
+  return true if newer?(src, dst)
+  deps.each {|dep| return true if newer?(dep, dst) }
+  return false
+end
+
+def preprocess(cwd: Dir.pwd, src:, 
+          dst: nil, strip: false,
+          deps: [], copy: nil, debug: false, force: false, 
+          mix: [], call: [], vars: {})
+  src += LEXT unless src.end_with?(LEXT)
+  if strip
+    dst = File.basename(src).sub(/.lt3$/,"")
+  else
+    dst += ".html" unless dst.end_with?(".html")
+  end
+  sp = " "*12
+  Dir.chdir(cwd) do
+    if debug
+      STDERR.puts "#{sp} -- preprocess "
+      STDERR.puts "#{sp}      src:  #{src}"
+      STDERR.puts "#{sp}      dst:  #{dst}"
+      STDERR.puts "#{sp}      in:   #{Dir.pwd}"
+      STDERR.puts "#{sp}      from: #{caller[0]}"
+      STDERR.puts "#{sp}      copy: #{copy}" if copy
+    end
+    stale = stale?(src, dst, deps, force)
+    if stale
+      live = Livetext.customize(mix: "liveblog", call: call, vars: vars)
+      out = live.xform_file(src)
+      File.write(dst, out)
+      system!("cp #{dst} #{copy}") if copy
+    end
+    puts "#{sp} -- ^ Already up to date!" if debug && ! stale
+  end
+end
+
+def get_live_vars(src)
+  live = Livetext.customize(call: [".nopara"])
+  live.xform_file(src)
+  live
+end
+
+end

data/lib/publish.rb

@@ -0,0 +1,73 @@
+if ! defined?(Already_publish)
+
+  Already_publish = nil
+
+require 'pathmagic'
+require 'processing'
+
+class RuneBlog::Publishing
+  attr_reader :user, :server, :docroot, :path
+
+  BadRemoteLogin = Exception.new("Can't login remotely")
+  BadRemotePerms = Exception.new("Bad remote permissions")
+
+  def initialize(view)
+    log!(enter: __method__, args: [view.to_s])
+    @blog = RuneBlog.blog
+    dir = @blog.root/:views/view/"themes/standard/"
+    gfile = dir/"global.lt3"
+    return unless File.exist?(gfile)  # FIXME Hackish as hell
+
+    live = get_live_vars(gfile)
+    @user    = live.vars["publish.user"]
+    @server  = live.vars["publish.server"]
+    @docroot = live.vars["publish.docroot"]
+    @path    = live.vars["publish.path"]
+    @proto   = live.vars["publish.proto"]
+  end
+
+  def to_h
+    log!(enter: __method__, level: 3)
+    {user: @user, server: @server, docroot: @docroot,
+     path: @path, proto: @proto}
+  end
+
+  def url
+    log!(enter: __method__, level: 3)
+    vname = @blog.view.name # .gsub(/_/, "\\_")
+    url = "#@proto://#@server/#@path"  # /#{vname}"
+  end
+
+  def publish
+    log!(enter: __method__, level: 1)
+    dir = @docroot/@path
+    view_name = @blog.view.name
+    viewpath = dir # /view_name
+    # FIXME rsync doesn't work
+    cmd = "rsync -r -z #{@blog.root}/views/#{@blog.view}/remote/ #@user@#@server:#{viewpath}/"
+    system!(cmd)
+    dump("#{@blog.view} at #{Time.now}", "#{@blog.view.dir}/last_published")
+    true
+  end
+
+  def remote_login?
+    log!(enter: __method__)
+    cmd = "ssh -o BatchMode=yes #@user@#@server -x date >/dev/null 2>&1"
+    result = system(cmd)
+    return nil unless result
+    true
+  end
+
+  def remote_permissions?
+    log!(enter: __method__)
+    dir = @docroot/@path
+    temp = @path/"__only_testing" 
+    try1 = system("ssh -o BatchMode=yes -o ConnectTimeout=1 #@user@#@server -x mkdir -p #{temp} >/dev/null 2>&1")
+    return nil unless try1
+    try2 = system("ssh -o BatchMode=yes -o ConnectTimeout=1 #@user@#@server -x rmdir #{temp} >/dev/null 2>&1")
+    return nil unless try2
+    true
+  end
+end
+
+end