livetext 0.9.30 → 0.9.31

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,19 @@ 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
+#   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 = 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 +54,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 +84,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 +111,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,7 +152,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def dot_def(args = nil, body = nil)
+  def dot_def
 # api.tty "in #{__FILE__}: api id = #{api.inspect}"
     name = api.args[0]
 # api.tty :dd1
@@ -164,7 +167,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 +176,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
@@ -189,7 +192,7 @@ STDERR.puts "! pairs = #{pairs.inspect}"
     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
@@ -205,7 +208,7 @@ STDERR.puts "pairs = #{pairs.inspect}"
     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 +218,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 +230,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.args.first # api.format(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 +249,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 +261,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 +273,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 +283,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,14 +356,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
+  def xtable   # Borrowed from bookish - FIXME
 # TTY.puts "=== #{__method__} #{__FILE__} #{__LINE__}"
     title = api.data
     delim = " :: "
@@ -389,13 +394,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

@@ -48,7 +48,7 @@ class Livetext::UserAPI
   end
 
   def data=(value)
-    @data = value
+    @data = value.dup
     @args = format(@data).chomp.split
   end
 
@@ -104,17 +104,29 @@ class Livetext::UserAPI
     lines = []
     end_found = false
     loop do
+# TTY.puts "BODY 0: @line = #{@line.inspect}"
       @line = @live.nextline
+# TTY.puts "BODY 1: @line = #{@line.inspect}"
       break if @line.nil?
+# TTY.puts "BODY 2: @line = #{@line.inspect}"
       @line.chomp!
+# TTY.puts "BODY 3: @line = #{@line.inspect}"
       break if end?(@line)
+# TTY.puts "BODY 4: @line = #{@line.inspect}"
       next if comment?(@line)
+# TTY.puts "BODY 5: @line = #{@line.inspect}"
       @line = format(@line) unless raw
+# TTY.puts "BODY 6: @line = #{@line.inspect}"
       lines << @line
+# TTY.puts "BODY 7: @line = #{@line.inspect}"
     end
+# TTY.puts "BODY 8: lines = #{lines.inspect}"
     raise "Expected .end, found end of file" unless end?(@line)  # use custom exception
+# TTY.puts "BODY 9: lines = #{lines.inspect}"
     optional_blank_line   # FIXME Delete this??
+# TTY.puts "BODY A: lines = #{lines.inspect}"
     return lines unless block_given?
+# TTY.puts "BODY B: lines = #{lines.inspect}"
     lines.each {|line| yield line }   # FIXME what about $. ?
   end
 
@@ -135,7 +147,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.31"
 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.

data/test/extra/bracketed.rb

@@ -0,0 +1,121 @@
+require 'minitest/autorun'
+
+require 'livetext'
+
+# Just another testing class. Chill.
+
+class TestingLivetextBracketed < MiniTest::Test
+
+  def setup
+    @live = Livetext.new
+  end
+
+  def check_match(exp, actual)
+    if exp.is_a? Regexp
+      assert_match(exp, actual, "actual does not match expected")
+    else
+      assert_equal(exp, actual, "actual != expected")
+    end
+  end
+
+  def test_bracketed_001_single_bracketed_item   
+    # Single bracketed item
+    # No special initialization
+    src = "*[abc]"
+    exp = "<b>abc</b>"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_002_end_of_line_can_replace_bracket   
+    # End of line can replace bracket
+    # No special initialization
+    src = "*[abc"
+    exp = "<b>abc</b>"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_003_end_of_line_can_replace_bracket_again   
+    # End of line can replace bracket again
+    # No special initialization
+    src = "abc *[d"
+    exp = "abc <b>d</b>"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_004_missing_right_bracket_ignored_at_eol_if_empty   
+    # Missing right bracket ignored at eol if empty
+    # No special initialization
+    src = "abc*["
+    exp = "abc*["
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_005_two_simple_bracketed_items   
+    # Two simple bracketed items
+    # No special initialization
+    src = "*[A], *[B], C"
+    exp = "<b>A</b>, <b>B</b>, C"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_006_simple_bracketed_item   
+    # Simple bracketed item
+    # No special initialization
+    src = "Just a *[test]..."
+    exp = "Just a <b>test</b>..."
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_007_bracketed_item_with_space   
+    # Bracketed item with space
+    # No special initialization
+    src = "A *[simple test]"
+    exp = "A <b>simple test</b>"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_008_empty_bracketed_item_results_in_null   
+    # Empty bracketed item results in null
+    # No special initialization
+    src = " *[] "
+    exp = "  "
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_009_bracketed_item_with_space_again   
+    # Bracketed item with space again
+    # No special initialization
+    src = "*[ab c] d"
+    exp = "<b>ab c</b> d"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_010_two_bracketed_items_with_spaces   
+    # Two bracketed items with spaces
+    # No special initialization
+    src = "*[a b] *[c d]"
+    exp = "<b>a b</b> <b>c d</b>"
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+  def test_bracketed_011_solitary_item_missing_right_bracket_ignored_at_eol_if_empty   
+    # Solitary item, missing right bracket ignored at eol if empty
+    # No special initialization
+    src = "*["
+    exp = ""
+    actual = @live.api.format(src)
+    check_match(exp, actual)
+  end
+ 
+
+end