livetext 0.9.24 → 0.9.25

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

@@ -1,4 +1,3 @@
-# p __FILE__
 
 require 'pathname'   # For _seek - remove later??
 
@@ -24,321 +23,339 @@ 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 = []
+    api.data = val.chomp
+#   @args = val.split rescue []
+    @mixins = []
+    @imports = []
+    ###
+    # api.data = val
   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]
+    funcname = api.args[0]
     check_disallowed(funcname)
     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]
+    name = api.args[0]
     str = "def #{name}\n"
     check_disallowed(name)
     # Difficult to avoid eval here
-    str << _body(true).join("\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)
     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)
     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)
+#   @parent.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 +365,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

data/lib/livetext/userapi.rb

@@ -0,0 +1,153 @@
+
+require_relative 'formatline'
+
+# Encapsulate the UserAPI as a class
+
+class Livetext::UserAPI
+
+  attr_accessor :data, :args
+
+  def initialize(live)
+    @live = live
+    @vars = live.vars
+  end
+
+  def setvar(var, val)
+    # FIXME don't like this...
+    str, sym = var.to_s, var.to_sym
+    Livetext::Vars[str] = val
+    Livetext::Vars[sym] = val
+  end
+
+  def check_existence(file, msg)
+    STDERR.puts msg unless File.exist?(file)
+  end
+
+  def data=(value)
+    @data = value
+    @args = format(@data).chomp.split
+  end
+
+  def args
+    return @args unless block_given?
+    @args.each {|arg| yield arg }
+  end
+
+  def vars
+    @vars
+  end
+
+  def optional_blank_line
+    peek = @live.peek_nextline  # ???
+    return if peek.nil?
+    @line = @live.nextline if peek =~ /^ *$/
+    return true  # This way, dot commands will usually return true
+  end
+
+  def comment?(str)
+    sigil = Livetext::Sigil
+    c1 = sigil + Livetext::Space
+    str.index(c1) == 0
+  end
+
+  def trailing?(char)
+    return true if ["\n", " ", nil].include?(char)
+    return false
+  end
+
+  def end?(str)
+    return true if str == ".end" || str =~ / *\$\.end/
+    return false
+  end
+
+  def raw_body(tag = "__EOF__")
+    lines = []
+    @live.save_location = @live.sources.last
+    loop do
+      @line = @live.nextline
+      break if @line.nil?
+      break if @line.chomp.strip == tag
+      lines << @line
+    end
+    optional_blank_line
+    return lines unless block_given?
+    lines.each {|line| yield line }
+  end
+
+  def body(raw=false)
+    lines = []
+    end_found = false
+    loop do
+      @line = @live.nextline
+      break if @line.nil?
+      @line.chomp!
+      break if end?(@line)
+      next if comment?(@line)
+      @line = format(@line) unless raw
+      lines << @line 
+    end
+    raise "Expected .end, found end of file" unless end?(@line)  # use custom exception
+    optional_blank_line   # FIXME Delete this??
+    return lines unless block_given?
+    lines.each {|line| yield line }   # FIXME what about $. ?
+  end
+
+  def body_text(raw=false)
+    raw_body.join("\n")
+  end
+
+  def raw_body!
+    raw_body(Livetext::Sigil).join("\n")
+  end
+
+  def handle_escapes(str, set)
+    str = str.dup
+    set.each_char do |ch|
+      str.gsub!("\\#{ch}", ch)
+    end
+    str
+  end
+
+  def format(line)
+    return "" if line == "\n" || line.nil?
+    line2 = Livetext::FormatLine.parse!(line)
+#   line.replace(line2)
+    line2
+  end
+
+  def passthru(line)
+    return if @live.nopass
+    out "<p>" if line == "\n" and ! @live.nopara
+    line = format(line)
+    out line
+  end
+
+  def out(str = "", file = nil)
+    return if str.nil?
+    return file.puts str unless file.nil?
+    @live.body << str 
+    @live.body << "\n" unless str.end_with?("\n")
+  end
+
+  def out!(str = "")
+    @live.body << str  # no newline
+  end
+
+  def puts(*args)
+    @live.output.puts *args 
+  end
+
+  def print(*args)
+    @live.output.print *args 
+  end
+
+  def debug=(val)
+    @live.debug = val
+  end
+
+  def debug(*args)
+    TTY.puts *args if @live.debug
+  end
+
+end
+

data/lib/livetext/version.rb

@@ -0,0 +1,6 @@
+
+# Defining VERSION
+
+class Livetext
+  VERSION = "0.9.25"
+end