livetext 0.9.20 → 0.9.24

data/bin/livetext

@@ -82,8 +82,6 @@ loop do
     when "-i", "--install"
       lib = ARGV.shift
       system("cp #{lib} #{Livetext::Path}/../plugin/")
-#   when /-.*/
-#     raise "Unknown argument '#{arg}'"
     when Object
       x.process_file(arg, true)  # , @backtrace)
   end

data/imports/bookish.rb

@@ -33,10 +33,6 @@ module Bookish
     _out "</table>"
   end
 
-  # def comment
-  #   _body { }  # ignore body
-  # end
-
   def _errout(*args)
     ::STDERR.puts *args
   end
@@ -46,13 +42,15 @@ module Bookish
   end
 
   def _slug(str)
-    s2 = str.chomp.strip.gsub(/[?:,()'"\/]/,"").gsub(/ /, "-").downcase
-  # _errout "SLUG: #{str} => #{s2}"
-    s2
+    str2 = str.chomp.strip
+    str2 = str2.gsub(/[?:,()'"\/]/,"")
+    str2 = str2.gsub(/ /, "-")
+    str2.downcase!
+    str2
   end
 
-
   # FIXME duplicated?
+
   def image(args = nil, body = nil)
     name = @_args[0]
     _out "<img src='#{name}'></img>"
@@ -109,7 +107,7 @@ module Bookish
     next_output
     _out "<h3>#@section #{title}</h3>\n"
   rescue => err
-    STDERR.puts "#{err}\n#{err.backtrace}"
+    ::STDERR.puts "#{err}\n#{err.backtrace}"
     exit
   end
 
@@ -276,7 +274,7 @@ module Bookish
     _body {|line| _out line }
     _out "</blockquote>"
   rescue => err
-    STDERR.puts "#{err}\n#{err.backtrace}"
+    ::STDERR.puts "#{err}\n#{err.backtrace}"
     exit
   end
 

data/imports/markdown.rb

@@ -9,12 +9,12 @@ module Markdown
   SimpleFormats[:s] = %w[<strike> </strike>]
 
 
-  def h1(args = nil, body = nil); _out "# #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end       # atx style for now
-  def h2(args = nil, body = nil); _out "## #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
-  def h3(args = nil, body = nil); _out "### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
-  def h4(args = nil, body = nil); _out "#### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
-  def h5(args = nil, body = nil); _out "##### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
-  def h6(args = nil, body = nil); _out "###### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+  def h1(args = nil, body = nil); _out "# #{Livetext.interpolate(@_data)}"; _optional_blank_line end       # atx style for now
+  def h2(args = nil, body = nil); _out "## #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+  def h3(args = nil, body = nil); _out "### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+  def h4(args = nil, body = nil); _out "#### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+  def h5(args = nil, body = nil); _out "##### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+  def h6(args = nil, body = nil); _out "###### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
 
   def title(args = nil, body = nil)
     h1

data/imports/pyggish.rb

@@ -1,5 +1,7 @@
 require 'rouge'
 
+# FIXME This file has suboptimal juju. See plugin/pyggish.rb also
+
 module Pyggish
   def self.pyg_change(code, klass, style)
     color = style[0..6]
@@ -29,7 +31,6 @@ module Pyggish
 
   def self.pyg_finalize(code, lexer=:elixir)
     Styles.each_pair {|klass, style| pyg_change(code, klass, style) }
-File.open("debug-pf1", "w") {|f| f.puts code }
     code.sub!(/<pre>/, "<pre>\n")
     code.gsub!(/<span class="[np]">/, "")
     code.gsub!(/<\/span>/, "")
@@ -37,9 +38,7 @@ File.open("debug-pf1", "w") {|f| f.puts code }
     code.sub!(/<td class="linenos"/, "<td width=2%></td><td width=5% bgcolor=#{color}")
     code.gsub!(/<td/, "<td valign=top ")
     code.gsub!(/ class="[^"]*?"/, "")    # Get rid of remaining Pygments CSS
-File.open("debug-pf2", "w") {|f| f.puts code }
     lines = code.split("\n")
-#   lines.each {|line| line << "\n" }
     n1 = lines.index {|x| x =~ /<pre>/ }
     n2 = lines.index {|x| x =~ /<\/pre>/ }
     # FIXME ?
@@ -48,12 +47,10 @@ File.open("debug-pf2", "w") {|f| f.puts code }
     lines[n1].sub!(/ 1$/, "  1 ")
     (n1+1).upto(n2) {|n| lines[n].replace(" " + lines[n] + " ") }
     code = lines.join("\n")
-File.open("debug-pf3", "w") {|f| f.puts code }
     code
   end
 
   def _process_code(text)
-  File.open("debug-pc1", "w") {|f| f.puts text }
     lines = text.split("\n")
     lines = lines.select {|x| x !~ /##~ omit/ }
     @refs = {}
@@ -66,7 +63,6 @@ File.open("debug-pf3", "w") {|f| f.puts code }
     end
     lines.map! {|line| "  " + line }
     text2 = lines.join("\n")
-  File.open("debug-pc2", "w") {|f| f.puts text2 }
     text.replace(text2)
   end
 
@@ -86,34 +82,6 @@ File.open("debug-pf3", "w") {|f| f.puts code }
     result
   end
 
-  def OLD_ruby
-    file = @_args.first 
-    if file.nil?
-      code = "# Ruby code\n"
-      _body {|line| code << line + "\n" }
-    else
-      code = "# Ruby code\n\n" + ::File.read(file)
-    end
-
-    _process_code(code)
-    html = _colorize(code, :ruby)
-    _out "\n#{html}\n "
-  end
-
-  def OLD_elixir
-    file = @_args.first 
-    if file.nil?
-      code = ""
-      _body {|line| code << line + "\n" }
-    else
-      code = ::File.read(file)
-    end
-
-    _process_code(code)
-    html = _colorize(code, :elixir)
-    _out "\n#{html}\n "
-  end
-
   def fragment
     lang = @_args.empty? ? :elixir : @_args.first.to_sym   # ruby or elixir
     @_args = []

data/imports/tutorial.rb

@@ -1,9 +1,9 @@
-# require 'cgi'
-
 require 'helpers'
 
+# Created as an "ad hoc" lib for generating the README
+
 module Tutorial
-  include Helpers
+  include Livetext::Helpers
 
   def title(args = nil, body = nil)
     h1
@@ -85,7 +85,7 @@ module Tutorial
   def testcase(args = nil, body = nil)
     name = _args.first
     _out "\n<font size=+1><b>Test: </font><font size=+2><tt>#{name}</tt></font></b></h3><br>"
-    src, exp = "test/data/#{name}/source.lt3", "test/data/#{name}/expected-output.txt"
+    src, exp = "test/snapshots/#{name}/source.lt3", "test/snapshots/#{name}/expected-output.txt"
     @_args = [src, exp]   # Better way to do this??
     put_table(src, exp)
     _out "<br>"

data/lib/cmdargs.rb

@@ -1,47 +1,58 @@
+# p __FILE__
+
 require_relative 'livetext'
 
 =begin
   Weird concepts to understand here...
 
     1. A Livetext dot-command (flush left) usually looks like:
-       .foobar
+         .foobar
+
     2. A dot-command (left-indented) usually looks like:
-           $.foobar
+         $.foobar
+
     3. More generally, it may have any number of parameters (0, 1, ...)
-       .redirect somefile.txt append
+         .redirect somefile.txt append
+
     4. Variables and functions *can* appear (rare in practice??)
-       .redirect somefile$my_suffix $$my_mode
+         .redirect somefile$my_suffix $$my_mode
+
     5. A trailing # comment may appear 
        a. Stripped... saved in #raw ? #data ? #comment ? elsewhere?
        b. NOT the "dot" as a comment!
+
     6. .foobar  # This here is a comment
+
     7. #data accessor returns all data on the .foo line...
        a. ...After the initial space
-       b. ...Including spaces
+       b. ...Including later spaces
        c. Including comment??
        d. .foo This is  o n l y   a test.
           # #data returns: "This is  o n l y   a test."
        e. What about formatting???
        f. What about: comments? variables? functions? 
 
-    7. Some commands have NO body while others have an OPTIONAL or REQUIRED body
+    8. Some commands have NO body while others have an OPTIONAL or REQUIRED body
        a. Assume .cmd1 definition forbids a body (then a body is an error)
           .cmd1   # may NOT have a body
        b. Assume .cmd2 definition PERMITS a body
           .cmd2   # may or MAY NOT have body/.end  
-       c. Assume .cmd3 definition PERMITS a body
+       c. Assume .cmd3 definition REQUIRES a body
           .cmd3   # REQUIRES a body/.end  
           . stuff...
           .end
-    8. Inside a body:
-    8a. Leading dot has no special meaning (though the associated method may parse it!)
-    8b. BUG? Currently leading dot is a comment INSIDE a body?
-    8a. No leading char is special (though the associated method may parse it!)
-    8a. No trailing #-comments (though the associated method may parse it!)
-    8c. ?? We should or shouldn't look for variables/functions? or make it an option?
-    8d. .end may naturally not be used (but see .raw where it may)
-    9. the args accessor is a simple array of strings
 
+    9. Inside a body:
+       a. Leading dot has no special meaning (though the associated method may parse it!)
+       b. BUG? Currently leading dot is a comment INSIDE a body?
+       c. No leading char is special (though the associated method may parse it!)
+       d. No trailing #-comments (though the associated method may parse it!)
+       e. ?? We should or shouldn't look for variables/functions? or make it an option?
+       f. .end may naturally not be used (but see .raw where it may)
+
+   10. The args accessor is a simple array of strings
+       a. there is also raw_args (without variables/functions, etc.)
+       b. Much of this HAS NOT been thought through yet!      
 
 =end
 
@@ -56,19 +67,18 @@ class Livetext::CmdData
     # body:  true => this command has a body + .end
     # how raw is raw?
     #   remove comment - always/sometimes/never?
-    #   var_func_parse - always/sometimes/never?
-    #   var_func_parse inside body??
+    #   interpolate - always/sometimes/never?
+    #   interpolate inside body??
     @data = data.dup     # comment? vars? funcs?
     @raw  = data.dup     # comment? vars? funcs?
     @args  = data.split  # simple array
     @nargs = nargs       # not really "needed"
     check_num_args(nargs)
-    
-    # @varfunc = _var_func_parse(data.dup)
+    # @varfunc = Livetext.interpolate(data.dup)
   end
 
   def check_num_args(num)
-    num_range = /(\d{0,2})(\.\.)(\d{0,2})/
+    num_range = /(\d{0,2})(\.\.)(\d{0,2})/   # Not "really" right...
     min, max = 0, 9999
     md = num_range.match(@nargs).to_a
     bad_args = nil

data/lib/errors.rb

@@ -1,3 +1,5 @@
+# p __FILE__
+
 
 # More later?
 

data/lib/formatline.rb

@@ -1,28 +1,13 @@
+
+require_relative 'parsing'
+require_relative 'funcall'
+
 # Class FormatLine handles the parsing of comments, dot commands, and 
 # simple formatting characters.
 
-class FormatLine < StringParser
-  SimpleFormats     = {}
-  SimpleFormats[:b] = %w[<b> </b>]
-  SimpleFormats[:i] = %w[<i> </i>]
-  SimpleFormats[:t] = ["<font size=+1><tt>", "</tt></font>"]
-  SimpleFormats[:s] = %w[<strike> </strike>]
- 
-  Null   = ""
-  Space  = " "
-  Alpha  = /[A-Za-z]/
-  AlNum  = /[A-Za-z0-9_]/
-  LF     = "\n"
-  LBrack = "["
-
-  Blank   = [" ", nil, "\n"]
-  Punc    = [")", ",", ".", " ", "\n"]
-  NoAlpha = /[^A-Za-z0-9_]/
-  NoAlphaDot = /[^.A-Za-z0-9_]/
-  Param   = ["]", "\n", nil]
-  Escape  = "\\"   # not an ESC char
-
-  Syms = { "*" => :b, "_" => :i, "`" => :t, "~" => :s }
+class Livetext::FormatLine < StringParser
+  include Livetext::ParsingConstants
+  include Livetext::FormatLine::FunCall
 
   attr_reader :out
   attr_reader :tokenlist
@@ -37,7 +22,6 @@ class FormatLine < StringParser
     return nil if line.nil?
     x = self.new(line.chomp)
     t = x.tokenize
-# TTY.puts "tokens = \n#{t.inspect}\n "
     x.evaluate
   end
 
@@ -45,14 +29,14 @@ class FormatLine < StringParser
 #   add grab
     loop do 
       case peek
-        when Escape; grab; add peek; grab; add peek
+        when Escape; grab; add peek; grab
         when "$"
           dollar
         when "*", "_", "`", "~"
           marker peek
           add peek
         when LF
-          break if @i >= line.size - 1
+          break if eos?  # @i >= line.size - 1
         when nil
           break
         else
@@ -80,7 +64,7 @@ class FormatLine < StringParser
       char = x.grab
       break if char == LF || char == nil
       x.handle_escaping if char == Escape
-      x.dollar if char == "$"
+      x.dollar if char == "$"  # Could be $$
       x.add char
     end
     x.add_token(:str)
@@ -107,22 +91,10 @@ class FormatLine < StringParser
       break if token.nil? 
       sym, val = *token
       case sym
-        when :str
-          @out << val unless val == "\n"   # BUG
-        when :var
-          @out << varsub(val)
-        when :func 
-          param = nil
-          arg = gen.peek
-          if [:colon, :brackets].include? arg[0] 
-            arg = gen.next  # for real
-            param = arg[1]
-            param = FormatLine.var_func_parse(param)
-          end
-          @out << funcall(val, param)
-        when :b, :i, :t, :s
-          val = FormatLine.var_func_parse(val)
-          @out << embed(sym, val)
+        when :str;   eval_str(val)
+        when :var;   eval_var(val)
+        when :func;  eval_func(val, gen)
+        when *BITS;  eval_bits(sym, val)
       else
         add_token :str
       end
@@ -131,48 +103,6 @@ class FormatLine < StringParser
     @out
   end
 
-  def grab_colon_param
-    grab  # grab :
-    param = ""
-    loop do 
-      case next!
-        when Escape
-          grab
-          param << next!
-          grab
-        when Space, LF, nil; break
-      else
-        param << next!
-        grab
-      end
-    end
-
-    param = nil if param.empty?
-    param
-  end
-
-  def grab_func_param
-    grab # [
-    param = ""
-    loop do 
-      case next!
-        when Escape
-          grab
-          param << next!
-          grab
-        when "]", LF, nil; break
-      else
-        param << next!
-        grab
-      end
-    end
-
-    add peek
-    grab
-    param = nil if param.empty?
-    param
-  end
-
   def add(str)
     @token << str unless str.nil?
   end
@@ -189,7 +119,7 @@ class FormatLine < StringParser
     loop do
       break if eos?
       str << peek
-      break if terminate?(NoAlpha, next!)
+      break if terminate?(NoAlpha, lookahead)
       grab
     end
     str
@@ -199,9 +129,9 @@ class FormatLine < StringParser
     str = Null.dup
     grab
     loop do
-      break if eos?   # peek.nil?
+      break if peek.nil?   # eos?
       str << peek
-      break if terminate?(NoAlphaDot, next!)
+      break if terminate?(NoAlphaDot, lookahead)
       grab
     end
     str
@@ -216,7 +146,7 @@ class FormatLine < StringParser
       when "$"; double_dollar
 #     when "."; dollar_dot
       when /[A-Za-z]/
-       add_token :str
+        add_token :str
         var = peek + grab_alpha_dot
         add_token(:var, var)
     else 
@@ -225,23 +155,6 @@ class FormatLine < StringParser
     end
   end
 
-  def double_dollar
-    case next!
-      when Space; add_token :string, "$$ "; grab; return
-      when LF, nil; add "$$"; add_token :str
-      when Alpha
-        add_token(:str, @token)
-        func = grab_alpha
-        add_token(:func, func)
-        case next!
-          when ":"; param = grab_colon_param; add_token(:colon, param)
-          when "["; param = grab_func_param; add_token(:brackets, param)
-        end
-      else
-        grab; add_token :str, "$$" + peek; return
-    end
-  end
-
 # def dollar_dot
 #   add_token :ddot, @line[@i..-1]
 # end
@@ -276,7 +189,7 @@ class FormatLine < StringParser
   def double_marker(char)
     sym = Syms[char]
     kind = sym
-    case next!   # first char after **
+    case lookahead   # first char after **
       when Space, LF, nil
         pre, post = SimpleFormats[sym]
         add_token kind
@@ -317,13 +230,12 @@ class FormatLine < StringParser
     add str
     str
   rescue => err
-    STDERR.puts "ERR = #{err}\n#{err.backtrace}"
-    STDERR.puts "=== str = #{str.inspect}"
+    ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
   end
 
   def escaped
-    grab
-    ch = grab
+    grab        # Eat the backslash
+    ch = grab   # Take next char
     ch
   end
 
@@ -350,28 +262,47 @@ class FormatLine < StringParser
     add str
     str
   rescue => err
-    STDERR.puts "ERR = #{err}\n#{err.backtrace}"
-    STDERR.puts "=== str = #{str.inspect}"
-  end
-
-  def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
-    result = 
-      if self.respond_to?("func_" + name.to_s)
-        self.send("func_" + name.to_s, param)
-      else
-        fobj = ::Livetext::Functions.new
-        fobj.send(name, param) rescue err
-      end
-    result
+    ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
   end
 
   def varsub(name)
-    result = Livetext::Vars[name] || "[#{name} is undefined]"
+    live = Livetext.new
+    value = live.vars[name]
+    result = value || "[#{name} is undefined]"
     result
   end
 
   def embedded?
     ! (['"', "'", " ", nil].include? prev)
   end
+
+  private 
+
+  def eval_bits(sym, val)
+    val = Livetext.interpolate(val)
+    @out << embed(sym, val)
+  end
+
+  def eval_func(val, gen)
+    param = nil
+    arg = gen.peek rescue :bogus
+    unless arg == :bogus
+      if [:colon, :brackets].include? arg[0] 
+        arg = gen.next  # for real
+        param = arg[1]
+        # FIXME - unsure - interpolate again??
+        # param = Livetext.interpolate(param)
+      end
+    end
+    @out << funcall(val, param)
+  end
+
+  def eval_var(val)
+    @out << varsub(val)
+  end
+
+  def eval_str(val)
+    @out << val unless val == "\n"   # BUG
+  end
+
 end

data/lib/funcall.rb

@@ -0,0 +1,84 @@
+
+require_relative 'livetext'
+
+# Parse function calls
+
+module Livetext::FormatLine::FunCall
+
+  include Livetext::ParsingConstants
+
+  def param_loop(char)
+    param = ""
+    loop do
+      case lookahead
+        when Escape
+          param << escaped
+        when char, LF, nil
+          break
+      else
+        param << lookahead
+        grab
+      end
+    end
+    param = nil if param.empty?
+    param
+  end
+
+  def grab_colon_param
+    grab  # grab :
+    param = param_loop(Space)
+  end
+
+  def grab_bracket_param
+    grab # [
+    param = param_loop("]")
+    grab  # "]"
+    param
+  end
+
+  def funcall(name, param)
+    err = "[Error evaluating $$#{name}(#{param})]"
+    func_name = name  # "func_" + name.to_s
+    result = 
+      if self.send?(func_name, param)  # self.respond_to?(func_name)
+        # do nothing
+      else
+        fobj = ::Livetext::Functions.new
+        fobj.send(name, param) rescue err
+      end
+    result.to_s
+  end
+
+  def double_dollar
+    case lookahead
+      when Space; add_token :string, "$$ "; grab; return
+      when LF, nil; add "$$"; add_token :str
+      when Alpha
+        add_token(:str, @token)
+        func = grab_alpha
+        add_token(:func, func)
+        param = grab_func_param    # may be null/missing
+      else
+        grab; add_token :str, "$$" + peek; return
+    end
+  end
+
+  def grab_func_param
+    case lookahead
+      when "["
+        param = grab_bracket_param
+        add_token(:brackets, param)
+      when ":"
+        param = grab_colon_param
+        add_token(:colon, param)
+    else  # do nothing
+    end
+  end
+
+  def escaped
+    grab        # Eat the backslash
+    ch = grab   # Take next char
+    ch
+  end
+
+end

data/lib/functions.rb

@@ -1,5 +1,5 @@
+# p __FILE__
 
-require_relative 'standard'  # FIXME  umm, why is this necessary??
 
 # Class Functions is where '$$func' functions are stored dynamically... 
 # user-def AND pre-def??
@@ -13,6 +13,21 @@ class Livetext::Functions
     attr_accessor :param   # kill this?
   end
 
+# FIXME Function parameters need to be fixed...
+
+  def isqrt(param = nil)      # "integer square root" - Just for testing
+    arg = num = param         #  Takes any number
+    if num.nil? || num.empty?
+      arg = "NO PARAM"        # Just for error text
+    end
+    # Integer()/Float() can raise error
+    num = num.include?(".") ? Float(num) : Integer(num)   
+    # Returns truncated integer
+    Math.sqrt(num).to_i       # user need not do to_s
+  rescue => err               # Malformed number? negative?
+    "[Error evaluating $$isqrt(#{arg})]"
+  end
+
   def date(param=nil)
     Time.now.strftime("%F")
   end
@@ -40,7 +55,7 @@ class Livetext::Functions
     "<br>"*n
   end
 
-  def yt(param)
+  def yt(param)   # FIXME uh, this is crap
     param = self.class.param
     "https://www.youtube.com/watch?v=#{param}"
   end