livetext 0.9.27 → 0.9.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47f377b248a2fdc2136cf68dc4a05596629723072ef84ce52b6aaea0a02edb03
-  data.tar.gz: 3867a6a0ca695985aed1555eefcc93193bb530dc1d43047f2c70c8b9b5f37744
+  metadata.gz: ee3796664666616d6b5428f4b27f81c3f902171fc8afc8fd351631c6c774e730
+  data.tar.gz: 5dd5250915ef13d930dca6b147e84b5e04e42d1a7b9c0f4b1e95d510ea49e476
 SHA512:
-  metadata.gz: c4d46b9519adeee2385e686739b4b29580c76cacf71d6bc8ed3679573378a19e54833c199e000a8a457d7561d1c68855e9b64805cbd599f54eb61bd902f49a38
-  data.tar.gz: 5183aa745907e4680f3b30b5a27dabc76373cc9e7926fb0df936b6f0e812681a9bc51b6533410532bdfe23e37774ba02981926cec8f5e16b4730e899a06a1489
+  metadata.gz: d0e81ca1d3990468ae49f3c5e23ab608160f7db301f692757200fe57b5434f125bd83b3a7af80dd22ea8cc278972dcb39fe3b408f3a800871f3fb243e6c3639c
+  data.tar.gz: 4bc7641f62f63215fbcf52192a74956991e540a2282922da21a5b0ea2a5d959420a9226c52745c635fc91521d860921b4d7d69defb8b540868d73df9b8fbfd99

data/README.lt3

@@ -7,8 +7,9 @@
 
 *[This README is currently mangled. Fixes coming soon!]
 
-Livetext is simply a tool for transforming text from one format into another. The source file
-has commands embedded in it, and the output is dependent on those commands.  
+Livetext is simply a tool for transforming text another format which may be HTML or some arbitrary
+format (text or otherwise). The source file has commands embedded in it, and the output is dependent 
+on those commands.  
 
 Why is this special? It's very flexible, very extensible, and it's extensible _[in Ruby].  
 

data/lib/livetext/expansion.rb

@@ -0,0 +1,106 @@
+
+class Livetext::Expansion
+
+  Ident  = "[[:alpha:]]([[:alnum:]]|_)*"
+  Dotted = "#{Ident}(\\.#{Ident})*"
+  Func   = "\\$\\$"
+  Var    = "\\$"
+  Lbrack = "\\["
+  Colon  = ":"
+
+  def initialize(instance)
+    @live = instance
+  end
+
+  def format(line)   # new/experimental
+    return "" if line == "\n" || line.nil?
+    formatted = Formatter.format(line)
+    with_vars = expand_variables(formatted)
+    with_func = expand_function_calls(with_vars)
+  end
+
+  def expand_variables(str)
+    rx = Regexp.compile("(?<result>" + Var + Dotted + ")")
+    enum = str.each_char
+    buffer = ""
+    loop do |i|
+      case                           # var or func or false alarm
+      when str.empty?                # end of string
+        break
+      when str.slice(0..1) == "$$"   # func?
+        buffer << str.slice!(0..1)    
+      when str.slice(0) == "$"       # var?
+        vmatch = rx.match(str)
+        if vmatch.nil?
+          buffer << str.slice!(0)
+          next
+        end
+        vname = vmatch["result"]
+        str.sub!(vname, "")
+        vsym = vname[1..-1].to_sym
+        vars = @live.vars
+        buffer << vars.get(vsym)
+      else                           # other
+        buffer << str.slice!(0)
+      end
+    end
+    buffer
+  end
+
+  def funcall(name, param)
+    err = "[Error evaluating $$#{name}(#{param})]"
+    name = name.gsub(/\./, "__")
+    return if self.send?(name, param)
+    fobj = ::Livetext::Functions.new
+    result = fobj.send(name, param) rescue err
+    result.to_s
+  end
+
+  def expand_function_calls(str)
+    # Assume variables already resolved
+    pat1 = "(?<result>" + Func + Dotted + ")"
+    colon = ":"
+    lbrack = "\\["
+    rbrack = "\\]"
+    space_eol = "( |$)"
+    prx1 = "(?<param>[^ ]+)"
+    prx2 = "(?<param>.+)"
+    pat2 = "(?<full_param>#{colon}#{prx1})"
+    pat3 = "(?<full_param>#{lbrack}#{prx2}#{rbrack})"
+    rx = Regexp.compile("#{pat1}(#{pat2}|#{pat3})?")
+
+    buffer = ""
+    loop do |i|
+      case             # Var or Func or false alarm
+      when str.nil?
+        return buffer
+      when str.empty?  # end of string
+        break
+      when str.slice(0..1) == "$$"   # Func?
+        fmatch = rx.match(str)
+        fname = fmatch["result"]  # includes $$
+        param = fmatch["param"]   # may be nil
+        full  = fmatch["full_param"]
+        fsym  = fname[2..-1]      # no $$
+=begin
+puts "rx     = #{rx.inspect}"
+puts "fmatch = #{fmatch.inspect}"
+puts "fname  = #{fname.inspect}"
+puts "param  = #{param.inspect}"
+puts "full   = #{full.inspect}"
+puts "fsym   = #{fsym.inspect}"
+=end
+        str.sub!(fname, "")
+        str.sub!(full, "") if full
+        retval = funcall(fsym, param)
+# puts "retval = #{retval.inspect}"
+        buffer << retval
+      else                        # other
+        char = str.slice!(0)
+        buffer << char
+      end
+    end
+    buffer
+  end
+end
+

data/lib/livetext/formatter.rb

@@ -0,0 +1,104 @@
+module Formatter
+  
+  Start = /(?<start>(^| ))/
+  Stop  = /(?<stop> |$)/
+
+  def self.make_regex(sigil, cdata, stop = Stop)
+    rx = /#{Start}#{sigil}#{cdata}#{stop}/
+  end
+
+  def self.iterate(str, rx, tag)
+    loop do
+      str, more = make_string(str, rx, tag)
+      break unless more
+    end
+    str
+  end
+
+  def self.double(str, char, tag)
+    cdata = /(?<cdata>[^ \.,]*?)/
+    stop  = /(?<stop>[\.,]|$)/
+    sigil = Regexp.escape(char+char)
+    rx = make_regex(sigil, cdata, stop)
+    str = iterate(str, rx, tag)
+    str
+  end
+
+  def self.single(str, char, tag)
+    cdata = /((?<cdata>[^$ \[\*][^ ]*))/
+    sigil = Regexp.escape(char)
+    rx = make_regex(sigil, cdata)
+    str = iterate(str, rx, tag)
+    str
+  end
+
+  def self.bracket(str, char, tag)
+    cdata = /(?<cdata>[^\]]*)\]/
+    stop  = /(?<stop> |$)/
+    sigil = Regexp.escape(char + "[")
+    rx = make_regex(sigil, cdata, stop)
+    str = iterate(str, rx, tag)
+    str
+  end
+
+  def self.make_string(str, rx, tag)
+    md = rx.match(str)
+    return [str, false] if md.nil?
+    start, cdata, stop = md.values_at(:start, :cdata, :stop)
+    str = str.sub(rx, start + "<#{tag}>" + cdata + "<\/#{tag}>" + stop)
+    [str, true]
+  end
+  
+  def self.handle(str, char, tag)
+    s2 = double(str, char, tag)  # in this order...
+    s2 = single(s2, char, tag)
+    s2 = bracket(s2, char, tag)
+    s2
+  end
+
+  def self.format(str)
+    s2 = str.chomp
+    s2 = handle(s2, "*", "b")
+    s2 = handle(s2, "_", "i")
+    s2 = handle(s2, "`", "tt")
+    s2 = handle(s2, "~", "strike")
+    s2
+  end
+end
+
+if $0 == __FILE__
+# str = "**bold up front... This is **bold, __italic, and ``code."
+str = "*bold and *bold and **more, and even *[more boldface] and *[still more] "
+max = str.length
+# str = "*bold "
+  s2 = Formatter.format(str)
+  printf "%-#{max}s => %-#{max}s\n", str.inspect, s2.inspect
+exit
+
+strings = ["*bold",
+           " *bold",
+           " *bold ",
+           "**bold.",
+           "**bold,",
+           "**bold",
+           " **bold.",
+           " **bold,",
+           " **bold",
+           " **bold. ",
+           " **bold, ",
+           " **bold ",
+           "*[fiat lux]",
+           " *[fiat lux]",
+           " *[fiat lux] ",
+           " *[fiat lux"
+          ]
+
+max = strings.max_by {|s| s.length }
+max = max.length + 2
+
+strings.each do |str|
+  s2 = Formatter.format(str)
+  printf "%-#{max}s => %-#{max}s\n", str.inspect, s2.inspect
+end
+
+end

data/lib/livetext/functions.rb

@@ -26,6 +26,15 @@ class Livetext::Functions
     "[Error evaluating $$isqrt(#{arg})]"
   end
 
+  def reverse(param=nil)      # again, just for testing
+    arg = param
+    if arg.nil? || arg.empty?
+      return "(reverse: No parameter)" 
+    else
+      return arg.reverse
+    end
+  end
+
   def date(param=nil)
     Time.now.strftime("%F")
   end

data/lib/livetext/helpers.rb

@@ -1,5 +1,6 @@
 
 require_relative 'global_helpers'
+require_relative 'expansion'
 
 module Livetext::Helpers
 
@@ -55,10 +56,10 @@ module Livetext::Helpers
     base  = "#{name}#{ext}"
     paths.each do |path|
       file = path + base
-::Livetext::TTY.puts  "   Checking: #{file}"
+# ::Livetext::TTY.puts  "   Checking: #{file}"
       return file if File.exist?(file)
     end
-::Livetext::TTY.puts  "   ...oops"
+# ::Livetext::TTY.puts  "   ...oops"
     return nil
   end
 
@@ -115,15 +116,16 @@ module Livetext::Helpers
     success
   end
 
-  def invoke_dotcmd(name)
+  def invoke_dotcmd(name, *args)
     # FIXME Add cmdargs stuff... depends on name, etc.
-    retval = @main.send(name)
+    retval = @main.send(name, *args)
     retval
   rescue => err
     graceful_error(err)
   end
 
   def handle_dotcmd(line, indent = 0)
+    # FIXME api.data is broken
     indent = @indentation.last # top of stack
     line = line.sub(/# .*$/, "")   # FIXME Could be problematic?
     name = get_name(line)
@@ -161,11 +163,13 @@ module Livetext::Helpers
     return File.exist?(file)
   end
 
+  def read_variables(file)
+    pairs = File.readlines(file).map {|x| x.chomp.split }
+    @api.setvars(pairs)
+  end
+
   def set_variables(pairs)
-    pairs.each do |pair|
-      var, value = *pair
-      @parent.setvar(var, value)
-    end
+    @api.setvars(pairs)
   end
 
   def grab_file(fname)
@@ -215,26 +219,27 @@ module Livetext::Helpers
   end
 
   def setvar(var, val)
-    str, sym = var.to_s, var.to_sym
-    Livetext::Vars[str] = val
-    Livetext::Vars[sym] = val
-    @_vars[str] = val
-    @_vars[sym] = val
+    api.setvar(var, val)
+#    str, sym = var.to_s, var.to_sym
+#    Livetext::Vars[str] = val
+#    Livetext::Vars[sym] = val
+#    @_vars[str] = val
+#    @_vars[sym] = val
   end
 
   def setfile(file)
     if file
-      setvar(:File, file)
+      api.setvar(:File, file)
       dir = File.dirname(File.expand_path(file))
-      setvar(:FileDir, dir)
+      api.setvar(:FileDir, dir)
     else
-      setvar(:File,    "[no file]")
-      setvar(:FileDir, "[no dir]")
+      api.setvar(:File,    "[no file]")
+      api.setvar(:FileDir, "[no dir]")
     end
   end
 
   def setfile!(file)  # FIXME why does this variant exist?
-    setvar(:File, file)
+    api.setvar(:File, file)
   end
 
 end

data/lib/livetext/html.rb

@@ -29,5 +29,78 @@ module HTMLHelper
     end
     [open, close]
   end
+end
+
+class HTML
+
+  def initialize(api)
+    @api = api
+    @indent = 0
+  end
+
+  def indented
+    " "*@indent
+  end
+
+  def indent(which)
+    case which
+      when :in, :right
+        @indent += 2
+      when :out, :left
+        @indent -= 2
+    else
+      abort "indent(#{which}) is nonsense"
+    end
+  end
+
+  def nav(**details, &block)
+    wrap(:nav, **details, &block)
+  end
 
+  def div(**details, &block)
+    wrap(:div, **details, &block)
+  end
+
+  def ul(**details, &block)
+    wrap(:ul, **details, &block)
+  end
+
+  def li(**details, &block)
+    wrap(:li, **details, &block)
+  end
+
+  def api
+    @api
+  end
+
+  def open_close_tags(*tags)
+    open, close = "", ""
+    tags.each do |tag|
+      open << "<#{tag}>"
+      close.prepend("</#{tag}>")
+    end
+    [open, close]
+  end
+
+  def wrap(*tags, **extras)     # helper
+    open, close = open_close_tags(*tags)
+    extras.each_pair do |name, value|
+      open.sub!(">", " #{name}='#{value}'>")
+    end
+    api.out indented + open 
+    indent(:in)
+    yield
+    indent(:out)
+    api.out indented + close
+  end
+
+  def tag(*tags, cdata: "", **extras)     # helper
+    open, close = open_close_tags(*tags)
+    extras.each_pair do |name, value|
+      open.sub!(">", " #{name}='#{value}'>")
+    end
+    str = indented + open + cdata + close
+    str
+  end
 end
+

data/lib/livetext/more.rb

@@ -6,6 +6,7 @@ class Livetext
   include Helpers
 
   class Variables
+    attr_reader :vars
     def initialize(hash = {})
       @vars = {}
       hash.each_pair {|k, v| @vars[k.to_sym] = v }
@@ -18,6 +19,21 @@ class Livetext
     def []=(var, value)
       @vars[var.to_sym] = value
     end
+
+    def get(var)
+      @vars[var.to_sym] || "[#{var} is undefined]"
+    end
+
+    def set(var, value)
+      @vars[var.to_sym] = value.to_s
+    end
+
+    def setvars(pairs)
+      pairs = pairs.to_a if pairs.is_a?(Hash)
+      pairs.each do |var, value|
+        api.setvar(var, value)
+      end
+    end
   end
 
   Vars = Variables.new
@@ -37,8 +53,10 @@ class Livetext
   end
 
   def self.interpolate(str)
-    parse = Livetext::LineParser.new(str)
-    parse.var_func_parse
+    expand = Livetext::Expansion.new(self) 
+    str2 = expand.expand_variables(str)
+    str3 = expand.expand_function_calls(str2)
+    str3
   end
 
   def self.customize(mix: [], call: [], vars: {})
@@ -47,7 +65,8 @@ class Livetext
     call = Array(call)
     mix.each {|lib| obj.mixin(lib) }
     call.each {|cmd| obj.main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| obj.setvar(var, val.to_s) }
+    # vars.each_pair {|var, val| obj.setvar(var, val.to_s) }
+    api.setvars(vars)
     obj
   end
 
@@ -88,7 +107,8 @@ class Livetext
     call = Array(call)
     mix.each {|lib| mixin(lib) }
     call.each {|cmd| @main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| @api.setvar(var, val.to_s) }
+    # vars.each_pair {|var, val| @api.set(var, val.to_s) }
+    api.setvars(vars)
     self
   end
 

data/lib/livetext/parser/general.rb

@@ -24,7 +24,7 @@ class Livetext::ParseGeneral < StringParser
     lines.each do |line|
       next if line.strip.empty?
       var, value = line.split(" ", 2)
-      val = Livetext.interpolate(value)
+      # val = Livetext.interpolate(value)
       var = prefix + "." + var if prefix
       pairs << [var, value]
     end

data/lib/livetext/parser/set.rb

@@ -53,8 +53,9 @@ class Livetext::ParseSet < StringParser
     var = get_var
     skip_equal
     value = get_value
-    value = Livetext.interpolate(value)
+    # value = Livetext.interpolate(value)
     pair = [var, value]
+    Livetext::Vars[var.to_sym] = value
     pair
   end
 
@@ -115,10 +116,11 @@ class Livetext::ParseSet < StringParser
   end
 
   def unquoted_value
-    char = nil
     value = ""
+    char = nil
     loop do
       char = peek
+      break if char.nil?
       break if eos?
       break if char == " " || char == ","
       value << char
@@ -133,7 +135,12 @@ class Livetext::ParseSet < StringParser
 
   def get_value
     char = peek
-    value = quote?(char) ? quoted_value : unquoted_value
+    flag = quote?(char)
+    if flag
+      value = quoted_value 
+    else
+      value = unquoted_value
+    end
     value
   end
 end

data/lib/livetext/processor.rb

@@ -35,12 +35,17 @@ class Processor
     @indentation = @parent.indentation
     @_mixins = []
     @_imports = []
+    @html = HTML.new(@parent.api)
   end
 
   def api
     @parent.api   # FIXME Is this weird??
   end
 
+  def html
+    @html
+  end
+
   def output=(io)
     @output = io
   end

data/lib/livetext/standard.rb

@@ -45,6 +45,12 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
+#  def setvars(pairs)
+#    pairs.each do |var, value|
+#      api.setvar(var, value)
+#    end
+#  end
+
   def backtrace(args = nil, body = nil)
     @backtrace = onoff(api.args.first)
     api.optional_blank_line
@@ -159,9 +165,9 @@ module Livetext::Standard
   end
 
   def set(args = nil, body = nil)
-    line = api.data.chomp
+    line = api.args.join(" ")  # data.chomp
     pairs = Livetext::ParseSet.new(line).parse
-    set_variables(pairs)
+    api.setvars(pairs)
     api.optional_blank_line
   end
 
@@ -178,7 +184,8 @@ module Livetext::Standard
       lines = api.body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
-    set_variables(pairs)
+STDERR.puts "! pairs = #{pairs.inspect}"
+    api.setvars(pairs)
     api.optional_blank_line
   end
 
@@ -193,7 +200,8 @@ module Livetext::Standard
       lines = api.body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
-    set_variables(pairs)
+STDERR.puts "pairs = #{pairs.inspect}"
+    api.setvars(pairs)
     api.optional_blank_line
   end
 
@@ -207,7 +215,7 @@ module Livetext::Standard
     end
     indent = @parent.indentation.last
     indented = " " * indent
-    api.setvar(var, rhs.chomp)
+    api.set(var, rhs.chomp)
     api.optional_blank_line
   end
 
@@ -271,7 +279,9 @@ module Livetext::Standard
   end
 
   def r(args = nil, body = nil)
-    api.out api.data  # No processing at all
+    # FIXME api.data is broken
+    # api.out api.data  # No processing at all
+    api.out api.args.join(" ")
     api.optional_blank_line
   end