livetext 0.9.08 → 0.9.13

data/lib/standard.rb

@@ -1,5 +1,21 @@
+require 'pathname'   # For _seek - remove later??
+
+require_relative 'parser'   # nested requires
+require_relative 'html'
+require_relative 'helpers'
+
+make_exception(:ExpectedOnOff,    "Error: expected 'on' or 'off'")
+make_exception(:DisallowedName,   "Error: name %1 is invalid")
+make_exception(:FileNotFound,     "Error: file %1 not found")
+
+
+# Module Standard comprises most of the standard or "common" methods.
+
 module Livetext::Standard
 
+  include HTMLHelper
+  include Helpers
+
   SimpleFormats =     # Move this?
    { b: %w[<b> </b>],
      i: %w[<i> </i>],
@@ -8,7 +24,7 @@ module Livetext::Standard
 
   attr_reader :_data
 
-  def data=(val)
+  def data=(val)    # FIXME this is weird, let's not do it
     @_data = val.chomp
     @_args = val.split rescue []
     @_mixins = []
@@ -23,69 +39,75 @@ module Livetext::Standard
   end
 
   def backtrace
-    arg = @_args.first
-    @backtrace = true
-    @backtrace = false if arg == "off"
+    @backtrace = onoff(@_args.first)
+    _optional_blank_line
   end
 
   def comment
     _body
+    _optional_blank_line
   end
 
   def shell
     cmd = @_data.chomp
-#   _errout("Running: #{cmd}")
     system(cmd)
+    _optional_blank_line
   end
 
   def func
     funcname = @_args[0]
-    _error! "Illegal name '#{funcname}'" if _disallowed?(funcname)
-    func_def = <<-EOS
+    check_disallowed(funcname)
+    func_def = <<~EOS
       def #{funcname}(param)
         #{_body.to_a.join("\n")}
       end
-EOS
+    EOS
     _optional_blank_line
-    
+
     Livetext::Functions.class_eval func_def
   end
 
-  def h1; _out "<h1>#{@_data}</h1>"; end
-  def h2; _out "<h2>#{@_data}</h2>"; end
-  def h3; _out "<h3>#{@_data}</h3>"; end
-  def h4; _out "<h4>#{@_data}</h4>"; end
-  def h5; _out "<h5>#{@_data}</h5>"; end
-  def h6; _out "<h6>#{@_data}</h6>"; end
+  def h1; _out wrapped(@_data, :h1); end
+  def h2; _out wrapped(@_data, :h2); end
+  def h3; _out wrapped(@_data, :h3); end
+  def h4; _out wrapped(@_data, :h4); end
+  def h5; _out wrapped(@_data, :h5); end
+  def h6; _out wrapped(@_data, :h6); end
 
   def list
-    _out "<ul>"
-    _body {|line| _out "<li>#{line}</li>" }
-    _out "</ul>"
+    wrap :ul do
+      _body {|line| _out wrapped(line, :li) }
+    end
+    _optional_blank_line
   end
 
   def list!
-    _out "<ul>"
-    lines = _body.each   # {|line| _out "<li>#{line}</li>" }
-    loop do 
-      line = lines.next
-      line = _format(line)
-      if line[0] == " "
-        _out line
-      else
-        _out "<li>#{line}</li>"
+    wrap(:ul) do
+      lines = _body.each   # enumerator
+      loop do
+        line = lines.next
+        line = _format(line)
+        str = line[0] == " " ? line : wrapped(line, :li)
+        _out str
       end
     end
-    _out "</ul>"
+    _optional_blank_line
   end
 
   def shell!
     cmd = @_data.chomp
     system(cmd)
+    _optional_blank_line
   end
 
   def errout
+    STDERR.puts @_data.chomp
+    _optional_blank_line
+  end
+
+  def ttyout
     TTY.puts @_data.chomp
+    _optional_blank_line
   end
 
   def say
@@ -96,133 +118,40 @@ EOS
 
   def banner
     str = _format(@_data.chomp)
-    n = str.length - 1
-    puts "-"*n
-    puts str
-    puts "-"*n
+    num = str.length - 1
+    decor = "-"*num + "\n"
+    puts decor + str + "\n" + decor
   end
 
   def quit
     puts @body
     @body = ""
     @output.close
-#   exit!
   end
 
-
   def cleanup
-    @_args.each do |item| 
-      if ::File.directory?(item)
-        system("rm -f #{item}/*")
-      else
-        ::FileUtils.rm(item)
-      end
+    @_args.each do |item|
+      cmd = ::File.directory?(item) ? "rm -f #{item}/*" : "rm #{item}"
+      system(cmd)
     end
   end
 
   def _def
     name = @_args[0]
     str = "def #{name}\n"
-    raise "Illegal name '#{name}'" if _disallowed?(name)
-    str += _body(true).join("\n")
-    str += "\nend\n"
+    check_disallowed(name)
+    # Difficult to avoid eval here
+    str << _body(true).join("\n")
+    str << "\nend\n"
     eval str
-  rescue => err
-    _error!(err)
+# rescue => err
+#   _error!(err)
   end
 
   def set
-    # FIXME bug -- .set var="RIP, Hope Gallery"
-    assigns = @_data.chomp.split(/, */)
-    # Do a better way?
-    # FIXME *Must* allow for vars/functions
-    assigns.each do |a| 
-      var, val = a.split("=")
-      var.strip!
-      val.strip!
-      val = val[1..-2] if val[0] == ?" && val[-1] == ?"
-      val = val[1..-2] if val[0] == ?' && val[-1] == ?'
-      val = FormatLine.var_func_parse(val)
-      @parent._setvar(var, val)
-    end
-    _optional_blank_line
-  end
-
-  def _assign_get_var(c, e)
-    name = c
-    loop do 
-      c = e.peek
-      case c
-        when /[a-zA-Z_\.0-9]/
-          name << e.next
-          next
-        when / =/ 
-          return name
-      else
-        raise "Error: did not expect #{c.inspect} in variable name"
-      end
-    end
-    raise "Error: loop ended parsing variable name"
-  end
-
-  def _assign_skip_equal(e)
-    loop { break if e.peek != " "; e.next }
-    if e.peek == "="
-      e.next  # skip spaces too
-      loop { break if e.peek != " "; e.next }
-    else
-      raise "Error: expect equal sign"
-    end
-  end
-
-  def _quoted_value(quote, e)
-    value = ""
-    loop do 
-      c = e.next
-      break if c == quote
-      value << c
-    end
-    value
-  end
-
-  def _unquoted_value(e)
-    value = ""
-    loop do 
-      c = e.next
-      break if c == " " || c == ","
-      value << c
-    end
-    value
-  end
-
-  def _assign_get_value
-    c = e.peek
-    value = ""
-    case c
-      when ?", ?'
-        value = _quoted_value(c, e)
-    else
-      value = _unquoted_value(e)
-    end
-    c = e.peek
-    value
-  end
-
-  def set_NEW
     line = _data.chomp
-    e = line.each_char  # enum
-    loop do 
-      c = e.next
-      case c
-        when /a-z/i
-          _assign_get_var(c, e)
-          _assign_skip_equal
-        when " "
-          next
-      else
-        raise "set: Huh? line = #{line}"
-      end
-    end
+    pairs = Livetext::ParseSet.new(line).parse
+    set_variables(pairs)
   end
 
   def variables!  # cwd, not FileDir - weird, fix later
@@ -235,14 +164,8 @@ EOS
     else
       lines = _body
     end
-    lines.map! {|x| x.sub(/# .*/, "").strip }  # strip comments
-    lines.each do |line|
-      next if line.strip.empty?
-      var, val = line.split(" ", 2)
-      val = FormatLine.var_func_parse(val)
-      var = prefix + "." + var if prefix
-      @parent._setvar(var, val)
-    end
+    pairs = Livetext::ParseMisc.parse_vars(prefix, lines)
+    set_variables(pairs)
   end
 
   def variables
@@ -255,89 +178,63 @@ EOS
     else
       lines = _body
     end
-    lines.map! {|x| x.sub(/# .*/, "").strip }  # strip comments
-    lines.each do |line|
-      next if line.strip.empty?
-      var, val = line.split(" ", 2)
-      val = FormatLine.var_func_parse(val)
-      var = prefix + "." + var if prefix
-      @parent._setvar(var, val)
-    end
-  end
-
-  def reval
-    eval _data.chomp
-  end
-
-  def heredoc!   # adds <br>...
-    _heredoc(true)
+    pairs = Livetext::ParseMisc.parse_vars(prefix, lines)
+    set_variables(pairs)
   end
 
   def heredoc
-    _heredoc
-  end
-
-  def _heredoc(bang=false)
     var = @_args[0]
-    str = _body.join("\n")
-    s2 = ""
-    str.each_line do |s|
-      str = FormatLine.var_func_parse(s.chomp)
-      s2 << str + "<br>"
+    text = _body.join("\n")
+    rhs = ""
+    text.each_line do |line|
+      str = FormatLine.var_func_parse(line.chomp)
+      rhs << str + "<br>"
     end
     indent = @parent.indentation.last
     indented = " " * indent
-    @parent._setvar(var, s2.chomp)
+    @parent._setvar(var, rhs.chomp)
     _optional_blank_line
   end
 
   def _seek(file)
-    require 'pathname'   # ;)
     value = nil
-    if File.exist?(file)
-      return file
-    else
-      count = 1
-      loop do
-        front = "../" * count
-        count += 1
-        here = Pathname.new(front).expand_path.dirname.to_s
-        break if here == "/"
-        path = front + file
-        value = path if File.exist?(path)
-        break if value
-      end
-		end
+    return file if File.exist?(file)
+
+    count = 1
+    loop do
+      front = "../" * count
+      count += 1
+      here = Pathname.new(front).expand_path.dirname.to_s
+      break if here == "/"
+      path = front + file
+      value = path if File.exist?(path)
+      break if value
+    end
     STDERR.puts "Cannot find #{file.inspect} from #{Dir.pwd}" unless value
 	  return value
   rescue
     STDERR.puts "Can't find #{file.inspect} from #{Dir.pwd}"
 	  return nil
   end
-	
-  def seek
-    # like include, but search upward as needed
+
+  def seek    # like include, but search upward as needed
     file = @_args.first
 		file = _seek(file)
-    _error!("No such include file #{file.inspect}") unless file
+    check_file_exists(file)
     @parent.process_file(file)
     _optional_blank_line
-  rescue => err
-    STDERR.puts ".seek error - #{err}"
-    STDERR.puts err.inspect
-	  return nil
   end
 
   def in_out  # FIXME dumb name!
     file, dest = *@_args
-    _check_existence(file, "No such include file #{file.inspect}")
+    check_file_exists(file)
     @parent.process_file(file, dest)
     _optional_blank_line
   end
 
-  def _include
-    file = @_args.first
-    _check_existence(file, "No such include file #{file.inspect}")
+  def _include   # dot command
+    file = _format(@_args.first)  # allows for variables
+    check_file_exists(file)
     @parent.process_file(file)
     _optional_blank_line
   end
@@ -350,62 +247,37 @@ EOS
   def inherit
     file = @_args.first
     upper = "../#{file}"
-    good = (File.exist?(upper) || File.exist?(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
 
-    @parent.process_file(upper) if File.exist?(upper)
-    @parent.process_file(file)  if File.exist?(file)
+    @parent.process_file(upper) if got_upper
+    @parent.process_file(file)  if got_file
     _optional_blank_line
   end
 
-#   def include!    # FIXME huh?
-#     file = @_args.first
-#     return unless File.exist?(file)
-# 
-#     lines = @parent.process_file(file)
-# #?    File.delete(file)
-#     _optional_blank_line
-#   end
-
-  def _mixin(name)
-    @_args = [name]
-    mixin
-  end
-
   def mixin
     name = @_args.first   # Expect a module name
-    file = "#{Plugins}/" + name.downcase + ".rb"
     return if @_mixins.include?(name)
-    file = "./#{name}.rb" unless File.exist?(file)
-    if File.exist?(file)
-      # Just keep going...
-    else
-      if File.dirname(File.expand_path(".")) != "/"
-        Dir.chdir("..") { mixin }
-        return
-      else
-        STDERR.puts "No such mixin '#{name}'"
-        puts @body
-        exit!
-      end
-    end
+    @_mixins << name
+    parse = Livetext::ParseMixin.new(name)  # FIXME??
+    file = parse.find_mixin(name)
+    parse.use_mixin(name, file)
+    _optional_blank_line
+  end
 
+  def import
+    name = @_args.first   # Expect a module name
+    return if @_mixins.include?(name)
     @_mixins << name
-    meths = grab_file(file)
-    modname = name.gsub("/","_").capitalize
-    string = "module ::#{modname}; #{meths}\nend"
-
-    eval(string)
-    newmod = Object.const_get("::" + modname)
-    self.extend(newmod)
-    init = "init_#{name}"
-    self.send(init) if self.respond_to? init
+    parse = Livetext::ParseImport.new(name)
+    parse.use_import(name)
     _optional_blank_line
   end
 
   def copy
     file = @_args.first
-    _check_existence(file, "No such file '#{file}' to copy")
+    check_file_exists(file)
     _out grab_file(file)
     _optional_blank_line
   end
@@ -416,24 +288,16 @@ EOS
 
   def raw
     # No processing at all (terminate with __EOF__)
-    _raw_body {|x| _out x }  # no formatting
+    _raw_body {|line| _out line }  # no formatting
   end
 
   def debug
-    arg = @_args.first
-    self._debug = true
-    self._debug = false if arg == "off"
+    self._debug = onoff(@_args.first)
   end
 
   def passthru
-    # FIXME - add check for args size (helpers); _onoff helper??
-    onoff = _args.first
-    case onoff
-      when nil;   @_nopass = false
-      when "on";  @_nopass = false
-      when "off"; @_nopass = true
-      else _error!("Unknown arg '#{onoff}'")
-    end
+    # FIXME - add check for args size? (helpers)
+    @_nopass = ! onoff(_args.first)
   end
 
   def nopass
@@ -441,13 +305,20 @@ EOS
   end
 
   def para
-    # FIXME - add check for args size (helpers); _onoff helper??
-    onoff = _args.first
-    case onoff
-      when nil;   @_nopara = false
-      when "on";  @_nopara = false
-      when "off"; @_nopara = true
-      else _error!("Unknown arg '#{onoff}'")
+    # FIXME - add check for args size? (helpers)
+    @_nopara = ! onoff(_args.first)
+  end
+
+  def onoff(arg)   # helper
+    arg ||= "on"
+    raise ExpectedOnOff unless String === arg
+    case arg.downcase
+      when "on"
+        return true
+      when "off"
+        return false
+    else
+      raise ExpectedOnOff
     end
   end
 
@@ -466,39 +337,23 @@ EOS
     _out "<p/>"
   end
 
-  def invoke(str)
-  end
-
   def mono
-    _out "<pre>"
-    _body(true) {|line| _out line }
-    _out "</pre>"
+    wrap ":pre" do
+      _body(true) {|line| _out line }
+    end
     _optional_blank_line
   end
 
   def dlist
     delim = _args.first
-    _out "<dl>"
-    _body do |line|
-      line = _format(line)
-      term, defn = line.split(delim)
-      _out "<dt>#{term}</dt>"
-      _out "<dd>#{defn}</dd>"
-    end
-    _out "</dl>"
-  end
-
-  def old_dlist
-    delim = _args.first
-    _out "<table>"
-    _body do |line|
-      line = _format(line)
-      term, defn = line.split(delim)
-      _out "<tr>"
-      _out "<td width=3%><td width=10%>#{term}</td><td>#{defn}</td>"
-      _out "</tr>"
+    wrap(:dl) do
+      _body do |line|
+        line = _format(line)
+        term, defn = line.split(delim)
+        _out wrapped(term, :dt)
+        _out wrapped(defn, :dd)
+      end
     end
-    _out "</table>"
   end
 
   def link
@@ -517,21 +372,19 @@ EOS
       line = _format(line)
       line.gsub!(/\n+/, "<br>")
       cells = line.split(delim)
-      wide = cells.map {|x| x.length }
+      wide = cells.map {|cell| cell.length }
       maxw = [0] * cells.size
       maxw = maxw.map.with_index {|x, i| [x, wide[i]].max }
     end
-  
+
     sum = maxw.inject(0, :+)
     maxw.map! {|x| (x/sum*100).floor }
-  
+
     lines.each do |line|
       cells = line.split(delim)
-      _out "<tr>"
-      cells.each.with_index do |cell, i| 
-        _out "  <td valign=top>#{cell}</td>"
+      wrap :tr do
+        cells.each {|cell| _out "  <td valign=top>#{cell}</td>" }
       end
-      _out "</tr>"
     end
     _out "</table></center>"
   end
@@ -542,10 +395,10 @@ EOS
   end
 
   def br
-    n = _args.first || "1"
+    num = _args.first || "1"
     out = ""
-    n.to_i.times { out << "<br>" }
+    num.to_i.times { out << "<br>" }
     _out out
   end
 
-end 
+end

data/lib/userapi.rb

@@ -1,7 +1,8 @@
 # User API
 
-require 'formatline'
+require_relative 'formatline'
 
+# UserAPI deals mostly with user-level methods.
 module Livetext::UserAPI
 
   def setvar(var, val)
@@ -93,10 +94,10 @@ module Livetext::UserAPI
     else
       lines
     end
-  rescue => err
-    str = err.inspect + "\n"
-    str << err.backtrace.map {|x| "  " + x }.join("\n")
-    _error!(str)
+# rescue => err
+#   str = err.inspect + "\n"
+#   str << err.backtrace.map {|x| "  " + x }.join("\n")
+#   _error!(str)
   end
 
   def _body_text(raw=false)

data/livetext.gemspec

@@ -1,8 +1,7 @@
 require 'date'
 require 'find'
 
-$: << "."
-require "lib/livetext"
+require_relative "lib/livetext"
 
 Gem::Specification.new do |s|
   system("rm -f *.gem")

data/test/all.rb

@@ -0,0 +1,3 @@
+
+require_relative 'unit/all'
+require_relative 'snapshots'             # snapshots

data/test/formatting.rb

@@ -1,13 +1,6 @@
-def minitest?
-  require 'minitest/autorun'
-end
-
-abort "minitest gem is not installed" unless minitest?
-
-
-$LOAD_PATH << "./lib"
+require 'minitest/autorun'
 
-require 'livetext'
+require_relative '../lib/livetext'
 
 class TestingLivetext < MiniTest::Test