livetext 0.9.24 → 0.9.27

data/lib/{parser → livetext/parser}/string.rb

@@ -11,10 +11,12 @@ class StringParser
     @i = 0
   end
 
-  def grab
+  def grab(n = 1)
+    raise "n <= 0 for #grab" if n <= 0
     return nil if @eos
-    char = @line[@i]
-    @i += 1
+    i2 = @i + n - 1
+    char = @line[@i..i2]
+    @i += n
     check_eos
     char
   end
@@ -25,9 +27,14 @@ class StringParser
   end
 
   def lookahead
+    # Get rid of this?
     @line[@i + 1]
   end
 
+  def remainder
+    @line[@i..-1]
+  end
+
   def prev
     return nil if @i <= 0
     @line[@i-1]
@@ -37,9 +44,11 @@ class StringParser
     @eos
   end
 
-  def peek
+  def peek(n = 1)
+    raise "n <= 0 for #grab" if n <= 0
     return nil if @eos
-    @line[@i]
+    i2 = @i + n - 1
+    @line[@i..i2]
   end
 
   def skip_spaces

data/lib/{parsing.rb → livetext/parsing.rb}

@@ -1,5 +1,3 @@
-# p __FILE__
-
 
 # Constants for parsing
 

data/lib/livetext/paths.rb

@@ -0,0 +1,13 @@
+# Reopening for paths... do differently?
+
+class Livetext
+  def self.get_path(dir = "")
+    path = File.join(File.dirname(__FILE__), dir)
+    File.expand_path(path)
+  end
+
+  Path    = self.get_path
+  Plugins = self.get_path("../plugin")
+  Imports = self.get_path("../imports")
+end
+

data/lib/{processor.rb → livetext/processor.rb}

@@ -1,5 +1,3 @@
-# p __FILE__
-
 
 # Class Processor does the actual work of processing input.
 
@@ -8,7 +6,6 @@ class Processor
   GenericError = Class.new(StandardError)
 
   include Livetext::Standard
-  include Livetext::UserAPI
 
   Disallowed = 
      %i[ __binding__        __id__            __send__          class
@@ -26,15 +23,22 @@ class Processor
          instance_variable_get                instance_variable_set
          remove_instance_variable             instance_variables ]
 
+  attr_reader :parent, :sources
+
   def initialize(parent, output = nil)
     @parent = parent
-    @_nopass = false
-    @_nopara = false
+    @nopass = false
+    @nopara = false
     # Meh?
     @output = ::Livetext.output = (output || File.open("/dev/null", "w"))
     @sources = []
     @indentation = @parent.indentation
     @_mixins = []
+    @_imports = []
+  end
+
+  def api
+    @parent.api   # FIXME Is this weird??
   end
 
   def output=(io)
@@ -46,14 +50,16 @@ class Processor
   end
 
   def _error!(err, raise_error=false, trace=false)   # FIXME much bullshit happens here
-    where = @sources.last || @save_location
+    where = @sources.last || @live.save_location
     error "Error: #{err} (at #{where[1]} line #{where[2]})"
     error(err.backtrace) rescue nil
     raise GenericError.new("Error: #{err}") if raise_error
   end
 
   def disallowed?(name)
-    Disallowed.include?(name.to_sym)
+    flag = Disallowed.include?(name.to_sym)
+# api.tty "disa name = #{name.inspect} flag = #{flag}"
+    flag
   end
 
   def source(enum, file, line)
@@ -61,11 +67,15 @@ class Processor
   end
 
   def peek_nextline
-    line = @sources.last[0].peek
+    return nil if @sources.empty?
+    source = @sources.last
+    line = source[0].peek
+    line
   rescue StopIteration
     @sources.pop
     nil
   rescue => err
+    TTY.puts "#{__method__}: RESCUE err = #{err.inspect}"
     nil
   end
 

data/lib/livetext/reopen.rb

@@ -0,0 +1,12 @@
+# Reopen for convenience... do differently
+
+class Object
+  def send?(meth, *args)
+    if self.respond_to?(meth)
+      self.send(meth, *args)
+    else
+      return nil
+    end
+  end
+end
+

data/lib/livetext/skeleton.rb

@@ -0,0 +1,18 @@
+require_relative 'parser/string'    # FIXME eh, should fix this
+
+# Class Livetext skeleton (top level).
+
+class Livetext
+  module Handler
+  end
+
+  module ParsingConstants
+  end
+
+  class LineParser < StringParser
+    module FunCall
+    end
+  end
+
+end
+

data/lib/{standard.rb → livetext/standard.rb}

@@ -1,4 +1,3 @@
-# p __FILE__
 
 require 'pathname'   # For _seek - remove later??
 
@@ -24,321 +23,343 @@ module Livetext::Standard
      t: ["<font size=+1><tt>", "</tt></font>"],
      s: %w[<strike> </strike>] }
 
-  attr_reader :_data
+  attr_reader :data
 
-  def data=(val)    # FIXME this is weird, let's remove it soonish
-    @_data = val.chomp
-    @_args = val.split rescue []
-    @_mixins = []
+  def data=(val)    # FIXME this is weird, let's remove it soonish  and why are there two???
+# api.tty ">>>> in #{__FILE__}: api id = #{api.object_id}"
+    val = val.chomp
+    api.data = val
+    api.args = format(val).split rescue []
+    @mixins = []
+    @imports = []
   end
 
   # dumb name - bold, italic, teletype, striketrough
-  def bits(args = nil, body = nil)
-    b0, b1, i0, i1, t0, t1, s0, s1 = *@_args
+
+  def bits(args = nil, body = nil)   # FIXME umm what is this?
+    b0, b1, i0, i1, t0, t1, s0, s1 = *api.args
     SimpleFormats[:b] = [b0, b1]
     SimpleFormats[:i] = [i0, i1]
     SimpleFormats[:t] = [t0, t1]
     SimpleFormats[:s] = [s0, s1]
+    api.optional_blank_line
   end
 
   def backtrace(args = nil, body = nil)
-    @backtrace = onoff(@_args.first)
-    _optional_blank_line
+    @backtrace = onoff(api.args.first)
+    api.optional_blank_line
   end
 
   def comment(args = nil, body = nil)
-    _body
-    _optional_blank_line
+    api.body
+    api.optional_blank_line
   end
 
   def shell(args = nil, body = nil)
-    cmd = @_data.chomp
+    cmd = api.data
     system(cmd)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def func(args = nil, body = nil)
-    funcname = @_args[0]
-    check_disallowed(funcname)
+    funcname = api.args[0]
+    # check_disallowed(funcname)  # should any be invalid?
+    funcname = funcname.gsub(/\./, "__")
     func_def = <<~EOS
       def #{funcname}(param)
-        #{_body.to_a.join("\n")}
+        #{api.body.to_a.join("\n")}
       end
     EOS
-    _optional_blank_line
+    api.optional_blank_line
     Livetext::Functions.class_eval func_def
+    return true
   end
 
-  def h1(args = nil, body = nil); _out wrapped(@_data, :h1); end
-  def h2(args = nil, body = nil); _out wrapped(@_data, :h2); end
-  def h3(args = nil, body = nil); _out wrapped(@_data, :h3); end
-  def h4(args = nil, body = nil); _out wrapped(@_data, :h4); end
-  def h5(args = nil, body = nil); _out wrapped(@_data, :h5); end
-  def h6(args = nil, body = nil); _out wrapped(@_data, :h6); end
+  def h1(args = nil, body = nil); api.out wrapped(api.data, :h1); return true; end
+  def h2(args = nil, body = nil); api.out wrapped(api.data, :h2); return true; end
+  def h3(args = nil, body = nil); api.out wrapped(api.data, :h3); return true; end
+  def h4(args = nil, body = nil); api.out wrapped(api.data, :h4); return true; end
+  def h5(args = nil, body = nil); api.out wrapped(api.data, :h5); return true; end
+  def h6(args = nil, body = nil); api.out wrapped(api.data, :h6); return true; end
 
   def list(args = nil, body = nil)
     wrap :ul do
-      _body {|line| _out wrapped(line, :li) }
+      api.body {|line| api.out wrapped(line, :li) }
     end
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def list!(args = nil, body = nil)
     wrap(:ul) do
-      lines = _body.each   # enumerator
+      lines = api.body.each   # enumerator
       loop do
         line = lines.next
-        line = _format(line)
+        line = api.format(line)
         str = line[0] == " " ? line : wrapped(line, :li)
-        _out str
+        api.out str
       end
     end
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def shell!(args = nil, body = nil)
-    cmd = @_data.chomp
+    cmd = api.data
     system(cmd)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def errout(args = nil, body = nil)
-    ::STDERR.puts @_data.chomp
-    _optional_blank_line
+    ::STDERR.puts api.data
+    api.optional_blank_line
   end
 
   def ttyout(args = nil, body = nil)
-    TTY.puts @_data.chomp
-    _optional_blank_line
+    TTY.puts api.data
+    api.optional_blank_line
   end
 
   def say(args = nil, body = nil)
-    str = _format(@_data.chomp)
+    str = api.format(api.data)
     TTY.puts str
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def banner(args = nil, body = nil)
-    str = _format(@_data.chomp)
+    str = api.format(api.data)
     num = str.length
     decor = "-"*num + "\n"
     puts decor + str + "\n" + decor
   end
 
   def quit(args = nil, body = nil)
-    puts @body
-    @body = ""
     @output.close
   end
 
   def cleanup(args = nil, body = nil)
-    @_args.each do |item|
+    api.args.each do |item|
       cmd = ::File.directory?(item) ? "rm -f #{item}/*" : "rm #{item}"
       system(cmd)
     end
+    api.optional_blank_line
   end
 
   def dot_def(args = nil, body = nil)
-    name = @_args[0]
-    str = "def #{name}\n"
+# api.tty "in #{__FILE__}: api id = #{api.inspect}"
+    name = api.args[0]
+# api.tty :dd1
+# api.tty name.inspect
     check_disallowed(name)
+# api.tty :dd2
     # Difficult to avoid eval here
-    str << _body(true).join("\n")
+    str = "def #{name}\n"
+    str << api.body(true).join("\n")
     str << "\nend\n"
     eval str
+    api.optional_blank_line
   end
 
   def set(args = nil, body = nil)
-    line = _data.chomp
+    line = api.data.chomp
     pairs = Livetext::ParseSet.new(line).parse
     set_variables(pairs)
+    api.optional_blank_line
   end
 
   # FIXME really these should be one method...
 
   def variables!(args = nil, body = nil)  # cwd, not FileDir - weird, fix later
-    prefix = _args[0]
-    file = _args[1]
+    prefix = api.args[0]
+    file = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
     if file
       here = ""  # different for ! version
       lines = File.readlines(here + file)
     else
-      lines = _body
+      lines = api.body
     end
-    pairs = Livetext::ParseGeneral.parse_vars(prefix, lines)
+    pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
     set_variables(pairs)
+    api.optional_blank_line
   end
 
   def variables(args = nil, body = nil)
-    prefix = _args[0]
-    file = _args[1]
+    prefix = api.args[0]
+    file = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
     if file
       here = ::Livetext::Vars[:FileDir] + "/"
       lines = File.readlines(here + file)
     else
-      lines = _body
+      lines = api.body
     end
-    pairs = Livetext::ParseGeneral.parse_vars(prefix, lines)
+    pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
     set_variables(pairs)
+    api.optional_blank_line
   end
 
   def heredoc(args = nil, body = nil)
-    var = @_args[0]
-    text = _body.join("\n")
+    var = api.args[0]
+    text = api.body.join("\n")
     rhs = ""
     text.each_line do |line|
-      str = Livetext.interpolate(line.chomp)
+      str = api.format(line.chomp)
       rhs << str + "<br>"
     end
     indent = @parent.indentation.last
     indented = " " * indent
-    @parent.setvar(var, rhs.chomp)
-    _optional_blank_line
+    api.setvar(var, rhs.chomp)
+    api.optional_blank_line
   end
 
   def seek(args = nil, body = nil)    # like include, but search upward as needed
-    file = @_args.first
+    file = api.args.first
 		file = search_upward(file)
     check_file_exists(file)
     @parent.process_file(file)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def dot_include(args = nil, body = nil)   # dot command
-    file = _format(@_args.first)  # allows for variables
+    file = api.format(api.args.first)  # allows for variables
     check_file_exists(file)
     @parent.process_file(file)
-    _optional_blank_line
-  rescue StandardError => err
-# p err
-# puts "-----"
-# err.backtrace.to_a.each {|x| puts x }
-# puts "-----"
-# exit
-TTY.puts ">>> #{__method__}: rescue in process_file!!"
-#    _out @body
+    api.optional_blank_line
   end
 
   def inherit(args = nil, body = nil)
-    file = @_args.first
+    file = api.args.first
     upper = "../#{file}"
     got_upper, got_file = File.exist?(upper), File.exist?(file)
     good = got_upper || got_file
-    _error!("File #{file} not found (local or parent)") unless good
+    STDERR.puts "File #{file} not found (local or parent)" unless good
 
     @parent.process_file(upper) if got_upper
     @parent.process_file(file)  if got_file
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def mixin(args = nil, body = nil)
-    name = @_args.first   # Expect a module name
-    return if @_mixins.include?(name)
-    @_mixins << name
-#   mod = Livetext::ParseMixin.get_module(name)
-    mod = Livetext::Handler::Mixin.get_module(name)
+    name = api.args.first   # Expect a module name
+    return if @mixins.include?(name)
+    @mixins << name
+    mod = Livetext::Handler::Mixin.get_module(name, @parent)
     self.extend(mod)
     init = "init_#{name}"
     self.send(init) rescue nil  # if self.respond_to? init
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def import(args = nil, body = nil)
-    name = @_args.first   # Expect a module name
-    return if @_mixins.include?(name)
-    @_mixins << name
-    mod = Livetext::Handler::Import.get_module(name)
+    name = api.args.first   # Expect a module name
+    return if @imports.include?(name)
+    @imports << name
+    mod = Livetext::Handler::Import.get_module(name, @parent)
     self.extend(mod)
     init = "init_#{name}"
     self.send(init) rescue nil  # if self.respond_to? init
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def copy(args = nil, body = nil)
-    file = @_args.first
-    check_file_exists(file)
-    _out grab_file(file)
-    _optional_blank_line
+    file = api.args.first
+    ok = check_file_exists(file)
+
+    self.parent.graceful_error FileNotFound(file) unless ok   # FIXME seems weird?
+      api.out grab_file(file)
+    api.optional_blank_line
+    [ok, file]
   end
 
   def r(args = nil, body = nil)
-    _out @_data.chomp  # No processing at all
+    api.out api.data  # No processing at all
+    api.optional_blank_line
   end
 
   def raw(args = nil, body = nil)
     # No processing at all (terminate with __EOF__)
-    _raw_body {|line| _out line }  # no formatting
+    api.raw_body {|line| api.out line }  # no formatting
+    api.optional_blank_line
   end
 
   def debug(args = nil, body = nil)
-    self._debug = onoff(@_args.first)
+    self._debug = onoff(api.args.first)
+    api.optional_blank_line
   end
 
   def passthru(args = nil, body = nil)
     # FIXME - add check for args size? (helpers)
-    @_nopass = ! onoff(_args.first)
+    @nopass = ! onoff(api.args.first)
+    api.optional_blank_line
   end
 
   def nopass(args = nil, body = nil)
-    @_nopass = true
+    @nopass = true
+    api.optional_blank_line
   end
 
   def para(args = nil, body = nil)
     # FIXME - add check for args size? (helpers)
-    @_nopara = ! onoff(_args.first)
+    @nopara = ! onoff(api.args.first)
+    api.optional_blank_line
   end
 
   def nopara(args = nil, body = nil)
-    @_nopara = true
+    @nopara = true
+    api.optional_blank_line
   end
 
   def heading(args = nil, body = nil)
-    _print "<center><font size=+1><b>"
-    _print @_data.chomp
-    _print "</b></font></center>"
+    api.print "<center><font size=+1><b>"
+    api.print api.data
+    api.print "</b></font></center>"
+    api.optional_blank_line
   end
 
   def newpage(args = nil, body = nil)
-    _out '<p style="page-break-after:always;"></p>'
-    _out "<p/>"
+    api.out '<p style="page-break-after:always;"></p>'
+    api.out "<p/>"
+    api.optional_blank_line
   end
 
   def mono(args = nil, body = nil)
     wrap ":pre" do
-      _body(true) {|line| _out line }
+      api.body(true) {|line| api.out line }
     end
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def dlist(args = nil, body = nil)
-    delim = _args.first
+    delim = api.args.first
     wrap(:dl) do
-      _body do |line|
-        line = _format(line)
+      api.body do |line|
+        line = api.format(line)
         term, defn = line.split(delim)
-        _out wrapped(term, :dt)
-        _out wrapped(defn, :dd)
+        api.out wrapped(term, :dt)
+        api.out wrapped(defn, :dd)
       end
     end
+    api.optional_blank_line
   end
 
   def link(args = nil, body = nil)
-    url = _args.first
-    text = _args[2..-1].join(" ")
-    _out "<a style='text-decoration: none' href='#{url}'>#{text}</a>"
+    url = api.args.first
+    text = api.args[2..-1].join(" ")
+    api.out "<a style='text-decoration: none' href='#{url}'>#{text}</a>"
+    api.optional_blank_line
   end
 
   def xtable(args = nil, body = nil)   # Borrowed from bookish - FIXME
-    title = @_data.chomp
+# TTY.puts "=== #{__method__} #{__FILE__} #{__LINE__}"
+    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
+    processed = []
     lines.each do |line|
-      line = _format(line)
+      line = api.format(line)
       line.gsub!(/\n+/, "<br>")
+      processed << line
       cells = line.split(delim)
       wide = cells.map {|cell| cell.length }
       maxw = [0] * cells.size
@@ -348,32 +369,36 @@ TTY.puts ">>> #{__method__}: rescue in process_file!!"
     sum = maxw.inject(0, :+)
     maxw.map! {|x| (x/sum*100).floor }
 
-    lines.each do |line|
+    processed.each do |line|
       cells = line.split(delim)
       wrap :tr do
-        cells.each {|cell| _out "  <td valign=top>#{cell}</td>" }
+        cells.each {|cell| api.out "  <td valign=top>#{cell}</td>" }
       end
     end
-    _out "</table></center>"
+    api.out "</table></center>"
+    api.optional_blank_line
   end
 
   def image(args = nil, body = nil)
-    name = @_args[0]
-    _out "<img src='#{name}'></img>"
+    name = api.args[0]
+    api.out "<img src='#{name}'></img>"
+    api.optional_blank_line
   end
 
   def br(args = nil, body = nil)
-    num = _args.first || "1"
-    out = ""
-    num.to_i.times { out << "<br>" }
-    _out out
+    num = api.args.first || "1"
+    str = ""
+    num.to_i.times { str << "<br>" }
+    api.out str
+    api.optional_blank_line
   end
 
   def reflection   # strictly experimental!
     list = self.methods
     obj  = Object.instance_methods
     diff = (list - obj).sort
-    _out "#{diff.size} methods:"
-    _out diff.inspect
+    api.out "#{diff.size} methods:"
+    api.out diff.inspect
+    api.optional_blank_line
   end
 end