livetext 0.9.30 → 0.9.33

data/lib/livetext/standard.rb

@@ -17,6 +17,8 @@ module Livetext::Standard
   include HTMLHelper
   include Livetext::Helpers
 
+  TTY = ::File.open("/dev/tty", "w")
+
   SimpleFormats =     # Move this?
    { b: %w[<b> </b>],
      i: %w[<i> </i>],
@@ -25,18 +27,9 @@ module Livetext::Standard
 
   attr_reader :data
 
-  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)   # FIXME umm what is this?
+  def bits   # FIXME umm what is this?
     b0, b1, i0, i1, t0, t1, s0, s1 = *api.args
     SimpleFormats[:b] = [b0, b1]
     SimpleFormats[:i] = [i0, i1]
@@ -51,29 +44,29 @@ module Livetext::Standard
 #    end
 #  end
 
-  def backtrace(args = nil, body = nil)
+  def backtrace
     @backtrace = onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def comment(args = nil, body = nil)
+  def comment
     api.body
     api.optional_blank_line
   end
 
-  def shell(args = nil, body = nil)
+  def shell
     cmd = api.data
     system(cmd)
     api.optional_blank_line
   end
 
-  def func(args = nil, body = nil)
+  def func
     funcname = api.args[0]
     # check_disallowed(funcname)  # should any be invalid?
     funcname = funcname.gsub(/\./, "__")
     func_def = <<~EOS
       def #{funcname}(param)
-        #{api.body.to_a.join("\n")}
+        #{api.body(true).to_a.join("\n")}
       end
     EOS
     api.optional_blank_line
@@ -81,21 +74,21 @@ module Livetext::Standard
     return true
   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 h1; api.out wrapped(api.data, :h1); return true; end
+  def h2; api.out wrapped(api.data, :h2); return true; end
+  def h3; api.out wrapped(api.data, :h3); return true; end
+  def h4; api.out wrapped(api.data, :h4); return true; end
+  def h5; api.out wrapped(api.data, :h5); return true; end
+  def h6; api.out wrapped(api.data, :h6); return true; end
 
-  def list(args = nil, body = nil)
+  def list
     wrap :ul do
       api.body {|line| api.out wrapped(line, :li) }
     end
     api.optional_blank_line
   end
 
-  def list!(args = nil, body = nil)
+  def list!
     wrap(:ul) do
       lines = api.body.each   # enumerator
       loop do
@@ -108,40 +101,40 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def shell!(args = nil, body = nil)
+  def shell!
     cmd = api.data
     system(cmd)
     api.optional_blank_line
   end
 
-  def errout(args = nil, body = nil)
+  def errout
     ::STDERR.puts api.data
     api.optional_blank_line
   end
 
-  def ttyout(args = nil, body = nil)
+  def ttyout
     TTY.puts api.data
     api.optional_blank_line
   end
 
-  def say(args = nil, body = nil)
+  def say
     str = api.format(api.data)
     TTY.puts str
     api.optional_blank_line
   end
 
-  def banner(args = nil, body = nil)
+  def banner
     str = api.format(api.data)
     num = str.length
     decor = "-"*num + "\n"
     puts decor + str + "\n" + decor
   end
 
-  def quit(args = nil, body = nil)
+  def quit
     @output.close
   end
 
-  def cleanup(args = nil, body = nil)
+  def cleanup
     api.args.each do |item|
       cmd = ::File.directory?(item) ? "rm -f #{item}/*" : "rm #{item}"
       system(cmd)
@@ -149,13 +142,9 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def dot_def(args = nil, body = nil)
-# api.tty "in #{__FILE__}: api id = #{api.inspect}"
+  def dot_def
     name = api.args[0]
-# api.tty :dd1
-# api.tty name.inspect
     check_disallowed(name)
-# api.tty :dd2
     # Difficult to avoid eval here
     str = "def #{name}\n"
     str << api.body(true).join("\n")
@@ -164,7 +153,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def set(args = nil, body = nil)
+  def set
     line = api.args.join(" ")  # data.chomp
     pairs = Livetext::ParseSet.new(line).parse
     api.setvars(pairs)
@@ -173,7 +162,7 @@ module Livetext::Standard
 
   # FIXME really these should be one method...
 
-  def variables!(args = nil, body = nil)  # cwd, not FileDir - weird, fix later
+  def variables!  # cwd, not FileDir - weird, fix later
     prefix = api.args[0]
     file = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
@@ -184,12 +173,11 @@ module Livetext::Standard
       lines = api.body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
-STDERR.puts "! pairs = #{pairs.inspect}"
     api.setvars(pairs)
     api.optional_blank_line
   end
 
-  def variables(args = nil, body = nil)
+  def variables
     prefix = api.args[0]
     file = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
@@ -200,12 +188,11 @@ STDERR.puts "! pairs = #{pairs.inspect}"
       lines = api.body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
-STDERR.puts "pairs = #{pairs.inspect}"
     api.setvars(pairs)
     api.optional_blank_line
   end
 
-  def heredoc(args = nil, body = nil)
+  def heredoc
     var = api.args[0]
     text = api.body.join("\n")
     rhs = ""
@@ -215,11 +202,11 @@ STDERR.puts "pairs = #{pairs.inspect}"
     end
     indent = @parent.indentation.last
     indented = " " * indent
-    api.set(var, rhs.chomp)
+    api.setvar(var, rhs.chomp)
     api.optional_blank_line
   end
 
-  def seek(args = nil, body = nil)    # like include, but search upward as needed
+  def seek    # like include, but search upward as needed
     file = api.args.first
 		file = search_upward(file)
     check_file_exists(file)
@@ -227,14 +214,14 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def dot_include(args = nil, body = nil)   # dot command
-    file = api.format(api.args.first)  # allows for variables
+  def dot_include   # dot command
+    file = api.expand_variables(api.args.first)  # allows for variables
     check_file_exists(file)
     @parent.process_file(file)
     api.optional_blank_line
   end
 
-  def inherit(args = nil, body = nil)
+  def inherit
     file = api.args.first
     upper = "../#{file}"
     got_upper, got_file = File.exist?(upper), File.exist?(file)
@@ -246,8 +233,9 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def mixin(args = nil, body = nil)
+  def mixin
     name = api.args.first   # Expect a module name
+    @mixins ||= []
     return if @mixins.include?(name)
     @mixins << name
     mod = Livetext::Handler::Mixin.get_module(name, @parent)
@@ -257,8 +245,9 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def import(args = nil, body = nil)
+  def import
     name = api.args.first   # Expect a module name
+    @imports ||= []
     return if @imports.include?(name)
     @imports << name
     mod = Livetext::Handler::Import.get_module(name, @parent)
@@ -268,7 +257,7 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def copy(args = nil, body = nil)
+  def copy
     file = api.args.first
     ok = check_file_exists(file)
 
@@ -278,67 +267,67 @@ STDERR.puts "pairs = #{pairs.inspect}"
     [ok, file]
   end
 
-  def r(args = nil, body = nil)
+  def r
     # FIXME api.data is broken
     # api.out api.data  # No processing at all
     api.out api.args.join(" ")
     api.optional_blank_line
   end
 
-  def raw(args = nil, body = nil)
+  def raw
     # No processing at all (terminate with __EOF__)
     api.raw_body {|line| api.out line }  # no formatting
     api.optional_blank_line
   end
 
-  def debug(args = nil, body = nil)
+  def debug
     self._debug = onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def passthru(args = nil, body = nil)
+  def passthru
     # FIXME - add check for args size? (helpers)
     @nopass = ! onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def nopass(args = nil, body = nil)
+  def nopass
     @nopass = true
     api.optional_blank_line
   end
 
-  def para(args = nil, body = nil)
+  def para
     # FIXME - add check for args size? (helpers)
     @nopara = ! onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def nopara(args = nil, body = nil)
+  def nopara
     @nopara = true
     api.optional_blank_line
   end
 
-  def heading(args = nil, body = nil)
+  def heading
     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)
+  def newpage
     api.out '<p style="page-break-after:always;"></p>'
     api.out "<p/>"
     api.optional_blank_line
   end
 
-  def mono(args = nil, body = nil)
+  def mono
     wrap ":pre" do
       api.body(true) {|line| api.out line }
     end
     api.optional_blank_line
   end
 
-  def dlist(args = nil, body = nil)
+  def dlist
     delim = api.args.first
     wrap(:dl) do
       api.body do |line|
@@ -351,15 +340,14 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def link(args = nil, body = nil)
+  def link
     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
-# TTY.puts "=== #{__method__} #{__FILE__} #{__LINE__}"
+  def xtable   # Borrowed from bookish - FIXME
     title = api.data
     delim = " :: "
     api.out "<br><center><table width=90% cellpadding=5>"
@@ -389,13 +377,13 @@ STDERR.puts "pairs = #{pairs.inspect}"
     api.optional_blank_line
   end
 
-  def image(args = nil, body = nil)
+  def image
     name = api.args[0]
     api.out "<img src='#{name}'></img>"
     api.optional_blank_line
   end
 
-  def br(args = nil, body = nil)
+  def br
     num = api.args.first || "1"
     str = ""
     num.to_i.times { str << "<br>" }

data/lib/livetext/userapi.rb

@@ -31,13 +31,26 @@ class Livetext::UserAPI
     @live
   end
 
+  def include_file(file)
+    api.data = file
+    api.dot_include
+  end
+
+  def expand_variables(str)
+    @expander.expand_variables(str)
+  end
+
+  def expand_functions(str)
+    @expander.expand_functions(str)
+  end
+
   def setvar(var, val)   # FIXME
-    # Livetext::Vars[var] = val  # Now indifferent and "safe"
     @live.vars.set(var, val)
   end
 
   def setvars(pairs)
-    pairs = pairs.to_a if pairs.is_a?(Hash)
+    # STDERR.puts "#{__method__}: pairs = #{pairs.inspect} (#{pairs.class})"
+    pairs = pairs.to_a   # could be Hash or Variables
     pairs.each do |var, value|
       @live.vars.set(var, value)
     end
@@ -48,8 +61,9 @@ class Livetext::UserAPI
   end
 
   def data=(value)
-    @data = value
-    @args = format(@data).chomp.split
+    @data = value.dup
+#   @args = format(@data).chomp.split
+    @data
   end
 
   def data
@@ -135,7 +149,6 @@ class Livetext::UserAPI
   end
 
   def format(line)
-    return "" if line == "\n" || line.nil?
     line2 = @expander.format(line)
     line2
   end

data/lib/livetext/version.rb

@@ -2,5 +2,5 @@
 # Defining VERSION
 
 class Livetext
-  VERSION = "0.9.30"
+  VERSION = "0.9.33"
 end

data/plugin/bookish.rb

@@ -173,7 +173,7 @@ def simple_table(args = nil, body = nil)
   lines = api.body(true)
   maxw = nil
   lines.each do |line|
-    api.format(line)
+    # api.format(line)
     cells = line.split(delim)
     wide = cells.map {|x| x.length }
     maxw = [0] * cells.size

data/test/extra/README.txt

@@ -0,0 +1,149 @@
+The testgen.rb tool takes a .txt and generates a corresponding file
+of MiniTest code.
+
+   $ ruby testgen.rb variables.txt    # produces variables.rb
+
+The tests here include:
+
+   variables.txt     Variable expansion
+   functions.txt     Function call evaluation
+   single.txt        Single sigil (see Formatting below)
+   double.txt        Double sigil (see Formatting below)
+   bracketed.txt     Bracketed sigil (see Formatting below)
+
+
+Variables:
+----------
+
+1. A variable begins with a $ and is followed by an alpha; periods may
+   be embedded, but each separate piece must "look like" an identifier
+
+      $x          yes
+      $xyz        yes
+      $xyz.abc    yes
+      $x123       yes
+      $x.123      no
+      $345        no
+      
+2. Rather than causing an error, invalid variables are rendered "as-is"
+   as soon as possible:
+      " $ "   => " $ "
+      " $5 "  => " $5 "
+      "...$"  => "...$"  (end of line)
+
+3. Actual variables may be user-defined or predefined. The latter usually
+   begin with a capital. This is only a convention so far, nothing that is
+   enforced.
+
+4. The $ may be escaped as needed. This is problematic.
+
+5. An unknown variable will not raise an error, but will be replaced with 
+   a warning string.
+
+
+Functions:
+----------
+
+1. A function looks like a variable name, but it has two $ in front. 
+
+2. If followed by space, comma, end of line, or similar delimiter, it is 
+   called with no parameter.
+
+3. Note that a function name may contain periods, but may not end with
+   one. "$$func." is parsed as a function call (with no parameter) plus a 
+   period.
+
+4. Use a colon to pass a single parameter delimited by a space or end of line.
+   Colon at end of line is valid but probably pointless.
+   
+5. Use brackets to pass a single parameter that contains spaces. The bracketed 
+   parameter may be terminated by end of line instead of right bracket.
+
+6. Only one parameter (a string) may be passed, but the function may parse it
+   however it needs to.
+
+7. There is no enforcement of a parameter being "present or absent" except what
+   the function itself may enforce.
+
+8. An unknown function will not raise an error, but will be replaced with a warning 
+   string.
+
+
+Formatting:
+-----------
+
+1. My formatting notation would be considered quirky by many people.
+   The sigils or markers are:
+     * bold   
+     _ underscore  
+     ` code/teletype  
+     ~ strikethrough
+
+1. A single sigil is recognized basically at beginning of line or after a space.
+    my_func_name   No italics here
+    M*A*S*H        No boldface here
+
+2. A single sigil is terminated by a space or end of line.
+
+3. A single sigil "by itself" is rendered as-is (asterisk, underscore, whatever).
+
+4. An escaped single sigil is rendered as-is. (This is problematic.)
+
+5. A double sigil is recognized at start of line or after a space
+
+6. A double sigil is terminated by a space OR a comma OR a period. (The comma
+   and period cases seem very common to me; they are the whole justification
+   for the double sigil.) End of line also terminates it.
+
+7. A double sigil by itself is rendered as-is.
+
+8. A bracketed sigil is in general a sigil followed by:  [ data ]
+
+9. An empty bracketed sigil simply "goes away"
+   " *[] "  => "  "
+
+10. End of line can terminate instead of right bracket -- but it may still be empty
+    and therefore go away.
+
+11. NOTE: These tests use only asterisks (bold), but the logic "should" be the same
+    for all sigils.
+
+
+
+Order of evaluation, etc.:
+--------------------------
+
+1. This logic is always a compromise between syntax and the code that parses it.
+   I prefer simplicity whenever possible, though it may introduce complexity in
+   other situations. I believe that the acceptable complexity of a workaround
+   depends on how commonplace the situation is and how onerous the workaround is.
+   These are both highly subjective.
+
+2. For example: Note that the simple formatting sigils may not be nested. However,
+   there are functions like $$bits provided (with the silly mnemonic "bold, italic,
+   teletype, strikthrough"). Every combination is provided (e.g., $$bi, $$bt).
+
+3. Note also: Formatting is only intra-line; it doesn't span lines. If you need to
+   work around this, use a heredoc or make your own .def for this.
+
+4. Finally: HTML or CSS may be inserted at will (possibly with some escaping). This
+   can be inline or "a file at a time" via such commands as .copy and .include
+
+5. For these reasons: Parsing is naive and simple. Variables are parsed first. 
+
+6. Next, function calls are parsed. I said variables are parsed first; this implies 
+   that a variable can be embedded in a function parameter. But be aware these are 
+   "naive" substitutions (like C macros).
+       .set alpha = "some value"
+       Calling $$myfunc:$alpha         (means: Calling $$myfunc:some value)
+       Better to say $$myfunc[$alpha]  (means: Better to say $$myfunc[some value]
+
+7. Formatting is handled last. The four sigils (* _ ` ~) and their three modes 
+   (single, double, bracketed) make 12 passes necessary for formatting. As this is 
+   always single-line, it has not been observed to cause a delay so far.
+
+8. The call api.format(line) essentially expands variables, calls functions, and
+   finally does simple formatting. See classes Expansion and Formatter.
+
+9. User code (e.g. inside a .def) may also call expand_variables, expand_functions,
+   and Formatter.format separately.