livetext 0.9.23 → 0.9.26

data/lib/livetext.rb

@@ -1,157 +1,19 @@
-# p __FILE__
 
-require_relative 'parser/string'
+require_relative 'livetext/skeleton'
+require_relative 'livetext/version'
+require_relative 'livetext/paths'
 
-# Class Livetext skeleton (top level).
+require_relative 'livetext/reopen'
 
-class Livetext
-  VERSION = "0.9.23"
-  Path  = File.expand_path(File.join(File.dirname(__FILE__)))
+require_relative 'livetext/errors'
+require_relative 'livetext/standard'
+require_relative 'livetext/functions'
+require_relative 'livetext/userapi'
+# require_relative 'livetext/formatline'
+require_relative 'livetext/lineparser'
+require_relative 'livetext/processor'
+require_relative 'livetext/helpers'
+require_relative 'livetext/handler'
 
-  module Handler
-  end
-
-  module ParsingConstants
-  end
-
-  class FormatLine < StringParser
-    module FunCall
-    end
-  end
-end
-
-require 'fileutils'
-
-class Object
-  def send?(meth, *args)
-    if self.respond_to?(meth)
-      self.send(meth, *args)
-    else
-      return nil
-    end
-  end
-end
-
-require_relative 'errors'
-require_relative 'standard'
-require_relative 'functions'
-require_relative 'userapi'
-require_relative 'formatline'
-require_relative 'processor'
-require_relative 'helpers'
-require_relative 'handler'
-
-
-Plugins = File.expand_path(File.join(File.dirname(__FILE__), "../plugin"))
-Imports = File.expand_path(File.join(File.dirname(__FILE__), "../imports"))
-
-TTY = ::File.open("/dev/tty", "w")
-
-make_exception(:EndWithoutOpening, "Error: found .end with no opening command")
-
-# Class Livetext reopened (top level).
-
-class Livetext
-
-  include Helpers
-
-  Vars = {}
-
-
-  attr_reader :main
-  attr_accessor :no_puts
-  attr_accessor :body, :indentation
-
-  class << self
-    attr_accessor :output      # bad solution?
-  end
-
-  def vars
-    Livetext::Vars.dup
-  end
-
-  def self.interpolate(str)
-    # FIXME There are issues here...
-    Livetext::FormatLine.var_func_parse(str)
-  end
-
-  def self.customize(mix: [], call: [], vars: {})
-    obj = self.new
-    mix  = Array(mix)
-    call = Array(call)
-    mix.each {|lib| obj.mixin(lib) }
-    call.each {|cmd| obj.main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| obj.setvar(var, val.to_s) }
-    obj
-  end
-
-  def customize(mix: [], call: [], vars: {})
-    mix  = Array(mix)
-    call = Array(call)
-    mix.each {|lib| mixin(lib) }  # FIXME HF won't this break??
-    call.each {|cmd| @main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| setvar(var, val.to_s) }
-    self
-  end
-
-  def initialize(output = ::STDOUT)
-    @source = nil
-    @_mixins = []
-    @_outdir = "."
-    @no_puts = output.nil?
-    @body = ""
-    @main = Processor.new(self, output)
-    @indentation = [0]
-    @_vars = Livetext::Vars
-    initial_vars
-  end
-
-  def interpolate(str)
-  end
-
-  def initial_vars
-    # Other predefined variables (see also setfile)
-    setvar(:User, `whoami`.chomp)
-    setvar(:Version, Livetext::VERSION)
-  end
-
-  def transform(text)
-    setfile!("(string)")
-    enum = text.each_line
-    front = text.match(/.*?\n/).to_a.first.chomp rescue ""
-    @main.source(enum, "STDIN: '#{front}...'", 0)
-    loop do 
-      line = @main.nextline
-      break if line.nil?
-      process_line(line)
-    end
-    result = @body
-    @body = ""
-    result
-  end
-
-  # EXPERIMENTAL and incomplete
-  def xform(*args, file: nil, text: nil, vars: {})
-    case
-      when file && text.nil?
-        xform_file(file)
-      when file.nil? && text
-        transform(text)
-      when file.nil? && text.nil?
-        raise "Must specify file or text"
-      when file && text
-        raise "Cannot specify file and text"
-    end
-    self.process_file(file)
-    self.body
-  end
-
-  def xform_file(file, vars: nil)
-    Livetext::Vars.replace(vars) unless vars.nil?
-    @_vars.replace(vars) unless vars.nil?
-    self.process_file(file)
-    self.body
-  end
-
-end
+require_relative 'livetext/more'
 

data/plugin/bookish.rb

@@ -1,6 +1,6 @@
 def hardbreaks(args = nil, body = nil)
   @hard = false
-  @hard = true unless @_args.first == "off"
+  @hard = true unless api.args.first == "off"
 end
 
 def hardbreaks?
@@ -13,27 +13,27 @@ end
 
 # These are duplicated. Remove safely
 
-def h1; _out "<h1>#{@_data}</h1>"; end
-def h2; _out "<h2>#{@_data}</h2>"; end
-def h3; _out "<h3>#{@_data}</h3>"; end
+def h1; api.out "<h1>#{api.data}</h1>"; end
+def h2; api.out "<h2>#{api.data}</h2>"; end
+def h3; api.out "<h3>#{api.data}</h3>"; end
 
 def alpha_columns(args = nil, body = nil)
-  n = @_args.first.to_i   # FIXME: what if it's missing?
+  n = api.args.first.to_i   # FIXME: what if it's missing?
   words = []
-  _body do |line| 
+  api.body do |line| 
     words << line.chomp
   end
   words.sort!
-  _out "<table cellpadding=2>"
+  api.out "<table cellpadding=2>"
   words.each_slice(n) do |w|
     items = w.map {|x| "<tt>#{x}</tt>" }
-    _out "<tr><td width=5% valign=top></td><td>" + items.join("</td><td>") + "</td></tr>"
+    api.out "<tr><td width=5% valign=top></td><td>" + items.join("</td><td>") + "</td></tr>"
   end
-  _out "</table>"
+  api.out "</table>"
 end
 
 # def comment
-#   _body { }  # ignore body
+#   api.body { }  # ignore body
 # end
 
 def _errout(*args)
@@ -53,28 +53,28 @@ end
 # FIXME duplicated?
 
 def image(args = nil, body = nil)
-  name = @_args[0]
-  _out "<img src='#{name}'></img>"
+  name = api.args[0]
+  api.out "<img src='#{name}'></img>"
 end
 
 def figure(args = nil, body = nil)
-  name = @_args[0]
-  num = @_args[1]
-  title = @_args[2..-1].join(" ")
-  title = _format(title)
-  _out "<img src='#{name}'></img>"
-  _out "<center><b>Figure #{num}</b> #{title}</center>"
+  name = api.args[0]
+  num = api.args[1]
+  title = api.args[2..-1].join(" ")
+  title = api.format(title)
+  api.out "<img src='#{name}'></img>"
+  api.out "<center><b>Figure #{num}</b> #{title}</center>"
 end
 
 def chapter(args = nil, body = nil)
-  @chapter = @_args.first.to_i
+  @chapter = api.args.first.to_i
   @sec = @sec2 = 0
-  title = @_data.split(" ",2)[1]
+  title = api.data.split(" ",2)[1]
   @toc << "<br><b>#@chapter</b> #{title}<br>"
-  @_data = _slug(title)
+  api.data = _slug(title)
   next_output
-  _out "<title>#{@chapter}. #{title}</title>"
-  _out <<-HTML
+  api.out "<title>#{@chapter}. #{title}</title>"
+  api.out <<-HTML
     <h2>Chapter #{@chapter}</h2>
     <h1>#{title}</h1>
 
@@ -84,13 +84,13 @@ end
 def chapterN(args = nil, body = nil)
   @chapter += 1
   @sec = @sec2 = 0
-  title = @_data    # .split(" ",2)[1]
+  title = api.data    # .split(" ",2)[1]
   _errout("Chapter #@chapter: #{title}")
   @toc << "<br><b>#@chapter</b> #{title}<br>"
-  @_data = _slug(title)
+  api.data = _slug(title)
   next_output
-  _out "<title>#{@chapter}. #{title}</title>"
-  _out <<-HTML
+  api.out "<title>#{@chapter}. #{title}</title>"
+  api.out <<-HTML
     <h2>Chapter #{@chapter}</h2>
     <h1>#{title}</h1>
 
@@ -101,11 +101,11 @@ def sec(args = nil, body = nil)
   @sec += 1
   @sec2 = 0
   @section = "#@chapter.#@sec"
-  title = @_data.dup
+  title = api.data.dup
   @toc << "#{_nbsp(3)}<b>#@section</b> #{title}<br>"
-  @_data = _slug(@_data)
+  api.data = _slug(api.data)
   next_output
-  _out "<h3>#@section #{title}</h3>\n"
+  api.out "<h3>#@section #{title}</h3>\n"
 rescue => err
   ::STDERR.puts "#{err}\n#{err.backtrace}"
   exit
@@ -114,67 +114,66 @@ end
 def subsec(args = nil, body = nil)
   @sec2 += 1
   @subsec = "#@chapter.#@sec.#@sec2"
-  title = @_data.dup
+  title = api.data.dup
   @toc << "#{_nbsp(6)}<b>#@subsec</b> #{title}<br>"
-  @_data = _slug(@_data)
+  api.data = _slug(api.data)
   next_output
-  _out "<h3>#@subsec #{title}</h3>\n"
+  api.out "<h3>#@subsec #{title}</h3>\n"
 end
 
 def definition_table(args = nil, body = nil)
-  title = @_data
+  title = api.data
   wide = "95"
   delim = " :: "
-  _out "<br><center><table width=#{wide}% cellpadding=5>"
-  lines = _body(true)
-  lines.map! {|line| _format(line) }
+  api.out "<br><center><table width=#{wide}% cellpadding=5>"
+  lines = api.body(true)
+  lines.map! {|line| api.format(line) }
 
   lines.each do |line|
     cells = line.split(delim)
-    _out "<tr>"
+    api.out "<tr>"
     cells.each.with_index do |cell, i| 
       width = (i == 0) ? "width=15%" : ""
-      _out "  <td #{width} valign=top>#{cell}</td>"
+      api.out "  <td #{width} valign=top>#{cell}</td>"
     end
-    _out "</tr>"
+    api.out "</tr>"
   end
-  _out "</table></center><br><br>"
+  api.out "</table></center><br><br>"
 
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def table2(args = nil, body = nil)
-  title = @_data
+  title = api.data
   wide = "90"
-  extra = _args[2]
+  extra = api.args[2]
   delim = " :: "
-  _out "<br><center><table width=#{wide}% cellpadding=5>"
-  lines = _body(true)
-  lines.map! {|line| _format(line) }
+  api.out "<br><center><table width=#{wide}% cellpadding=5>"
+  lines = api.body(true)
+  lines.map! {|line| api.format(line) }
 
   lines.each do |line|
     cells = line.split(delim)
     percent = (100/cells.size.to_f).round
-    _out "<tr>"
+    api.out "<tr>"
     cells.each do |cell| 
-      _out "  <td width=#{percent}% valign=top " + 
+      api.out "  <td width=#{percent}% valign=top " + 
             "#{extra}>#{cell}</td>"
     end
-    _out "</tr>"
+    api.out "</tr>"
   end
-  _out "</table></center><br><br>"
-
-  _optional_blank_line
+  api.out "</table></center><br><br>"
+  api.optional_blank_line
 end
 
 def simple_table(args = nil, body = nil)
-  title = @_data
+  title = api.data
   delim = " :: "
-  _out "<table cellpadding=2>"
-  lines = _body(true)
+  api.out "<table cellpadding=2>"
+  lines = api.body(true)
   maxw = nil
   lines.each do |line|
-    _format(line)
+    api.format(line)
     cells = line.split(delim)
     wide = cells.map {|x| x.length }
     maxw = [0] * cells.size
@@ -186,26 +185,27 @@ def simple_table(args = nil, body = nil)
 
   lines.each do |line|
     cells = line.split(delim)
-    _out "<tr>"
+    api.out "<tr>"
     cells.each.with_index do |cell, i| 
-      _out "  <td width=#{maxw}% valign=top>" + 
+      api.out "  <td width=#{maxw}% valign=top>" + 
             "#{cell}</td>"
     end
-    _out "</tr>"
+    api.out "</tr>"
   end
-  _out "</table>"
+  api.out "</table>"
+  api.optional_blank_line
 end
 
 def table(args = nil, body = nil)
   @table_num ||= 0
   @table_num += 1
-  title = @_data
+  title = api.data
   delim = " :: "
-  _out "<br><center><table width=90% cellpadding=5>"
-  lines = _body(true)
+  api.out "<br><center><table width=90% cellpadding=5>"
+  lines = api.body(true)
   maxw = nil
   lines.each do |line|
-    _format(line)
+    api.format(line)
     cells = line.split(delim)
     wide = cells.map {|x| x.length }
     maxw = [0] * cells.size
@@ -217,17 +217,18 @@ def table(args = nil, body = nil)
 
   lines.each do |line|
     cells = line.split(delim)
-    _out "<tr>"
+    api.out "<tr>"
     cells.each.with_index do |cell, i| 
-      _out "  <td width=#{maxw}% valign=top>" + 
+      api.out "  <td width=#{maxw}% valign=top>" + 
             "#{cell}</td>"
     end
-    _out "</tr>"
+    api.out "</tr>"
   end
-  _out "</table>"
+  api.out "</table>"
   @toc << "#{_nbsp(8)}<b>Table #@chapter.#@table_num</b> #{title}<br>"
 # _next_output(_slug("table_#{title}"))
-  _out "<b>Table #@chapter.#@table_num &nbsp;&nbsp; #{title}</b></center><br>"
+  api.out "<b>Table #@chapter.#@table_num &nbsp;&nbsp; #{title}</b></center><br>"
+  api.optional_blank_line
 end
 
 def toc!(args = nil, body = nil)
@@ -240,7 +241,7 @@ rescue => err
 end
 
 def toc2(args = nil, body = nil)
-  file = @_args[0]
+  file = api.args[0]
   @toc.close
   ::File.write(file, <<-EOS)
 <p style="page-break-after:always;"></p>
@@ -253,26 +254,26 @@ EOS
 end
 
 def missing(args = nil, body = nil)
-  @toc << "#{_nbsp(8)}<font color=red>TBD: #@_data</font><br>"
-  stuff = @_data.empty? ? "" : ": #@_data"
-  _out "<br><font color=red><i>[Material missing#{stuff}]</i></font><br>\n "
+  @toc << "#{_nbsp(8)}<font color=red>TBD: #{api.data}</font><br>"
+  stuff = api.data.empty? ? "" : ": #{api.data}"
+  api.out "<br><font color=red><i>[Material missing#{stuff}]</i></font><br>\n "
 end
 
 def TBC(args = nil, body = nil)
   @toc << "#{_nbsp(8)}<font color=red>To be continued...</font><br>"
-  _out "<br><font color=red><i>To be continued...</i></font><br>"
+  api.out "<br><font color=red><i>To be continued...</i></font><br>"
 end
 
 def note(args = nil, body = nil)
-  _out "<br><font color=red><i>Note: "
-  _out @_data 
-  _out "</i></font><br>\n "
+  api.out "<br><font color=red><i>Note: "
+  api.out api.data 
+  api.out "</i></font><br>\n "
 end
 
 def quote(args = nil, body = nil)
-  _out "<blockquote>"
-  _body {|line| _out line }
-  _out "</blockquote>"
+  api.out "<blockquote>"
+  api.body {|line| api.out line }
+  api.out "</blockquote>"
 rescue => err
   ::STDERR.puts "#{err}\n#{err.backtrace}"
   exit

data/plugin/calibre.rb

@@ -1,9 +1,9 @@
 require 'fileutils'
 
 def epub!(args = nil, body = nil)
-  out = _format(@_args[0])
-  src = @_args[1]
-  @cover = @_args[2]
+  out = api.format(api.args[0])
+  src = api.args[1]
+  @cover = api.args[2]
   if ::File.directory?(src)
     files = ::Dir["#{src}/*"].grep /\.html$/
     files = files.sort  # why is this necessary now?

data/plugin/livemagick.rb

@@ -2,24 +2,24 @@ require 'rmagick'
 include ::Magick
 
 def image(args = nil, body = nil)
-  xx, yy, bg = _args
+  xx, yy, bg = api.args
   xx, yy = xx.to_i, yy.to_i
   @image = Image.new(xx,yy) { self.background_color = bg }
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def canvas(args = nil, body = nil)
-  color, width, opacity = _args
+  color, width, opacity = api.args
   opacity, width = opacity.to_i, width.to_i
   @canvas = Draw.new
   @canvas.fill_opacity(0)
   @canvas.stroke('black')
   @canvas.stroke_width(1)
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def rectangle(args = nil, body = nil)
-  xy, wxh, stroke_color, stroke_width = _args
+  xy, wxh, stroke_color, stroke_width = api.args
   x, y = xy.split(",").map(&:to_i)
   width, height = wxh.split("x").map(&:to_i)
   stroke_width = stroke_width.to_i
@@ -30,19 +30,19 @@ def rectangle(args = nil, body = nil)
 end
 
 def pen(args = nil, body = nil)
-  @fill, @stroke = _args
+  @fill, @stroke = api.args
   @stroke = "black" if @stroke.nil? || @stroke.empty?
   _debug "pen: fill=#@fill stroke=#@stroke"
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def font(args = nil, body = nil)
-  size, font = _args
+  size, font = api.args
   font = "Helvetica" if font.nil? || font.empty? 
   size = "32" if size.nil? || size.empty? 
   @size, @font = size.to_i, font
   _debug "font: size=#@size font=#@font"
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def _text(xy, wxh, str, weight, gravity)
@@ -60,34 +60,34 @@ def _text(xy, wxh, str, weight, gravity)
 end
 
 def text(args = nil, body = nil)
-  xy, wxh, str = _data.split
+  xy, wxh, str = api.data.split
   weight, gravity = BoldWeight, CenterGravity
   _text(xy, wxh, str, weight, gravity)
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def text!(args = nil, body = nil)
-  xy, wxh = _data.split
-  str = _body_text  # .join
+  xy, wxh = api.data.split
+  str = api.body_text  # .join
   weight, gravity = BoldWeight, CenterGravity
   _text(xy, wxh, str, weight, gravity)
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def draw(args = nil, body = nil)
   @canvas.draw(@image)
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def save(args = nil, body = nil)
   @image.write(_args.first)
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 def save!(args = nil, body = nil)
   save
   system("open #{_args.first}")
-  _optional_blank_line
+  api.optional_blank_line
 end
 
 =begin

data/plugin/markdown.rb

@@ -8,12 +8,12 @@ SimpleFormats[:t] = %w[` `]
 SimpleFormats[:s] = %w[<strike> </strike>]
 
 
-def h1(args = nil, body = nil); _out "# #{Livetext.interpolate(@_data)}"; _optional_blank_line end       # atx style for now
-def h2(args = nil, body = nil); _out "## #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-def h3(args = nil, body = nil); _out "### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-def h4(args = nil, body = nil); _out "#### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-def h5(args = nil, body = nil); _out "##### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-def h6(args = nil, body = nil); _out "###### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+def h1(args = nil, body = nil); api.out "# #{Livetext.interpolate(api.data)}"; api.optional_blank_line end       # atx style for now
+def h2(args = nil, body = nil); api.out "## #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+def h3(args = nil, body = nil); api.out "### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+def h4(args = nil, body = nil); api.out "#### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+def h5(args = nil, body = nil); api.out "##### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+def h6(args = nil, body = nil); api.out "###### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
 
 def title(args = nil, body = nil)
   h1
@@ -24,18 +24,18 @@ def section(args = nil, body = nil)
 end
 
 def bq(args = nil, body = nil)   # block quote
-  _body {|line| _out "> #{line}" }
+  api.body {|line| api.out "> #{line}" }
 end
 
 def list(args = nil, body = nil)
-  _body {|line| _out " * #{line}" }
+  api.body {|line| api.out " * #{line}" }
 end
 
 def olist(args = nil, body = nil)   # Doesn't handle paragraphs yet
   n = 0
-  _body do |line|
+  api.body do |line|
     n += 1
-    _out "#{n}. #{_format(line)}"
+    api.out "#{n}. #{_format(line)}"
   end
 end