livetext 0.9.27 → 0.9.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47f377b248a2fdc2136cf68dc4a05596629723072ef84ce52b6aaea0a02edb03
-  data.tar.gz: 3867a6a0ca695985aed1555eefcc93193bb530dc1d43047f2c70c8b9b5f37744
+  metadata.gz: c6069fc394894011ca9f5ed2db3022b62a3a8c541c51566126551297e60eec74
+  data.tar.gz: b95803194c64a840262b4912e9116905c27a1879e4f6ec4309ae48404b31fa7e
 SHA512:
-  metadata.gz: c4d46b9519adeee2385e686739b4b29580c76cacf71d6bc8ed3679573378a19e54833c199e000a8a457d7561d1c68855e9b64805cbd599f54eb61bd902f49a38
-  data.tar.gz: 5183aa745907e4680f3b30b5a27dabc76373cc9e7926fb0df936b6f0e812681a9bc51b6533410532bdfe23e37774ba02981926cec8f5e16b4730e899a06a1489
+  metadata.gz: '046369b5d8a1c659fc210eea5134e79d9c8c0cfff0a2a833fff84b89001b115f4bd326fcf10cddcabc284e3abf964ad59e43330f7b4783dc4fba7d4255e66db9'
+  data.tar.gz: 20fb083bbd8d727c5e5774c784afa49f9a0edd58e339bdd4b7966916ffa94cbe335c6f702c841b67b75c053c88592b7b864eb9abef60aa96a9a949f5171769e0

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/imports/bookish.rb

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

data/lib/livetext/expansion.rb

@@ -0,0 +1,108 @@
+
+class Livetext::Expansion
+
+  Ident  = "[[:alpha:]]([[:alnum:]]|_)*"
+  Dotted = "#{Ident}(\\.#{Ident})*"
+  Func   = "\\$\\$"
+  Var    = "\\$"
+  Lbrack = "\\["
+  Colon  = ":"
+
+  def initialize(instance)
+    @live = instance
+  end
+
+  def format(line)
+    return "" if line == "\n" || line.nil?
+    with_vars = expand_variables(line)
+    with_func = expand_function_calls(with_vars)
+    formatted = Formatter.format(with_func)
+  end
+
+  def expand_variables(str)
+    rx = Regexp.compile("(?<result>" + Var + Dotted + ")")
+    buffer = ""
+    loop do |i|
+      case                           # var or func or false alarm
+      when str.empty?                # end of string
+        break
+      when str.slice(0..1) == "\\$"  # escaped, ignore it
+        str.slice!(0..1)    
+        buffer << "$"
+      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
+        char = str.slice!(0)
+        buffer << char
+      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 $$
+#STDERR.puts "rx     = #{rx.inspect}"
+#STDERR.puts "fmatch = #{fmatch.inspect}"
+#STDERR.puts "fname  = #{fname.inspect}"
+#STDERR.puts "param  = #{param.inspect}"
+#STDERR.puts "full   = #{full.inspect}"
+#STDERR.puts "fsym   = #{fsym.inspect}"
+        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
+# STDERR.puts "buffer     = #{buffer.inspect}"
+    buffer
+  end
+end
+

data/lib/livetext/formatter.rb

@@ -0,0 +1,223 @@
+module Formatter
+
+## Hmmm...
+# 
+#  Double:  b, i, t, s
+#  Single:  bits
+#  Brackt:  bits
+# 
+
+
+  def self.format(str)
+    str = str.chomp
+    s2 = Double.process(str.chomp)
+    s3 = Bracketed.process(s2)
+    s4 = Single.process(s3)
+    s4
+  end
+  
+  class Delimited
+    def initialize(str, marker, tag)
+      @str, @marker, @tag = str.dup, marker, tag
+      @buffer = ""
+      @cdata  = ""
+      @state  = :INITIAL
+    end
+
+    def status(where)
+      if $debug
+        STDERR.printf "%-11s %-7s #{@marker.inspect} \n #{' '*11} state = %-8s  str = %-20s  buffer = %-20s  cdata = %-20s\n", 
+          where, self.class, @state, @str.inspect, @buffer.inspect, @cdata.inspect
+      end
+    end
+
+    def front
+      @str[0]
+    end
+
+    def grab(n=1)
+      char = @str.slice!(0..(n-1))   # grab n chars
+      char
+    end
+
+    def grab_terminator
+      status("** grabterm 0")
+      @state = :LOOPING
+      # goes onto buffer by default
+      # Don't? what if searching for space_marker?
+      # @buffer << grab  
+    end
+
+    def eol?
+      @str.empty?
+    end
+
+    def space?
+      front == " "
+    end
+
+    def escape?
+      front == "\\"
+    end
+
+    def terminated?
+      space?   # Will be overridden except in Single
+    end
+
+    def marker?
+      @str.start_with?(@marker)
+    end
+
+    def space_marker?
+      @str.start_with?(" " + @marker)
+    end
+
+    def wrap(text)
+      status("** wrap 0")
+      if text.empty?
+        result = @marker
+        result = "" if @marker[1] == "["
+        return result
+      end
+      "<#{@tag}>#{text}</#{@tag}>"
+    end
+    
+    def initial
+      status("** init 0")
+      n = @marker.length
+      case
+      when escape?
+        status("** esc i0")
+        grab               # backslash
+        status("** esc i1")
+        @buffer << grab    # char
+        status("** esc i2")
+      when space_marker?
+        status("** init 1")
+        @buffer << grab   # append the space
+        grab(n)           # eat the marker
+        @state = :CDATA
+      when marker?
+        status("** init 2")
+        grab(n)  # Eat the marker
+        @state = :CDATA
+      when eol?
+        status("** init 3")
+        @state = :FINAL
+      else
+        status("** init 4")
+        @state = :BUFFER
+      end
+    end
+
+    def buffer
+      status("** buffer 0")
+      @buffer << grab
+      @state = :LOOPING
+    end
+
+    def cdata
+      status("** cdata 0")
+      case
+      when eol?
+        status("** cdata 1")
+        if @cdata.empty?
+          status("** cdata 2")
+          @buffer << @marker unless @marker[1] == "["
+        else
+          status("** cdata 3")
+          @buffer << wrap(@cdata)
+        end
+        @state = :FINAL
+      when terminated?
+        status("** cdata 4")
+        @buffer << wrap(@cdata)
+        grab_terminator    # "*a *b"  case???
+        @cdata = ""
+        @state = :LOOPING
+      else
+        status("** cdata 5")
+        @cdata << grab
+        @state = :CDATA
+      end
+    end
+
+    def looping
+      n = @marker.length
+      case
+      when escape?
+        status("** esc l0")
+        grab               # backslash
+        status("** esc l1")
+        @buffer << grab    # char
+        status("** esc l2")
+      when space_marker?
+        @buffer << grab   # append the space
+        grab(n)           # eat the marker
+        @state = :CDATA
+      when eol?
+        @state = :FINAL
+      else   # includes marker not preceded by space!
+        @buffer << grab
+      end
+    end
+
+    def handle
+      loop do
+        break if @state == :FINAL
+        meth = @state.downcase
+        send(meth)
+      end
+      return @buffer
+    end
+
+    def self.process(str)
+      bold = self.new(str, "*", "b")
+      sb   = bold.handle
+# return sb
+      ital = self.new(sb, "_", "i")
+      si   = ital.handle
+      code = self.new(si, "`", "tt")
+      sc   = code.handle
+      stri = self.new(sc, "~", "strike")
+      si   = stri.handle
+      si
+    end
+  end
+
+  class Single < Delimited
+    # Yeah, this one is that simple
+  end
+
+  class Double < Delimited
+    def initialize(str, sigil, tag)
+      super
+      # Convention: marker is "**", sigil is "*"
+      @marker = sigil + sigil
+    end
+
+    def terminated?
+      terms = [" ", ".", ","]
+      terms.include?(front)
+    end
+  end
+
+  class Bracketed < Delimited
+    def initialize(str, sigil, tag)
+      super
+      # Convention: marker is "*[", sigil is "*"
+      @marker = sigil + "["
+    end
+
+    def terminated?
+      front == "]" || eol?
+    end
+
+    def grab_terminator
+      @state = :LOOPING
+      grab
+    end
+  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
 
@@ -9,6 +10,8 @@ module Livetext::Helpers
   ESCAPING = { "'" => ''', '&' => '&', '"' => '"',
                '<' => '&lt;', '>' => '&gt;' }
 
+  TTY = ::File.open("/dev/tty", "w")
+
   def friendly_error(err)
     return graceful_error(err) if self.respond_to?(:graceful_error)
     return self.parent.graceful_error(err) if self.respond_to?(:parent)
@@ -55,10 +58,8 @@ module Livetext::Helpers
     base  = "#{name}#{ext}"
     paths.each do |path|
       file = path + base
-::Livetext::TTY.puts  "   Checking: #{file}"
       return file if File.exist?(file)
     end
-::Livetext::TTY.puts  "   ...oops"
     return nil
   end
 
@@ -99,14 +100,14 @@ module Livetext::Helpers
     when DotCmd
       success = handle_dotcmd(line)
     when DollarDot
-      success = handle_dollar_dot
+      success = handle_dollar_dot(line)
     else
       api.passthru(line)  # must succeed?
     end
     success
   end
 
-  def handle_dollar_dot
+  def handle_dollar_dot(line)
     indent = line.index("$") + 1
     @indentation.push(indent)
     line.sub!(/^ *\$/, "")
@@ -115,9 +116,11 @@ module Livetext::Helpers
     success
   end
 
-  def invoke_dotcmd(name)
-    # FIXME Add cmdargs stuff... depends on name, etc.
-    retval = @main.send(name)
+  def invoke_dotcmd(name, data0="")
+    api.data = data0.dup   # should permit _ in function names at least
+    args0 = data0.split
+    api.args = args0.dup
+    retval = @main.send(name)  # , *args)
     retval
   rescue => err
     graceful_error(err)
@@ -126,13 +129,13 @@ module Livetext::Helpers
   def handle_dotcmd(line, indent = 0)
     indent = @indentation.last # top of stack
     line = line.sub(/# .*$/, "")   # FIXME Could be problematic?
-    name = get_name(line)
+    name, data = get_name_data(line)
     success = true  # Be optimistic...  :P
     case
       when name == :end   # special case
         graceful_error EndWithoutOpening()
       when @main.respond_to?(name)
-        success = invoke_dotcmd(name)
+        success = invoke_dotcmd(name, data)
     else
       graceful_error UnknownMethod(name)
     end
@@ -143,14 +146,20 @@ module Livetext::Helpers
     return true
   end
 
-  def get_name(line)
-    name, data = line.split(" ", 2)
-    name = name[1..-1]  # chop off sigil
+  def get_name_data(line)
+    line = line.chomp
+    blank = line.index(" ")
+    if blank
+      name = line[1..(blank-1)]
+      data0 = line[(blank+1)..-1]
+    else
+      name = line[1..-1]
+      data0 = ""
+    end
     name = "dot_" + name if %w[include def].include?(name)
     @main.check_disallowed(name)
-    @main.data = data
-    @main.api.data = data
-    name.to_sym
+    @main.api.data = data0  # FIXME kill this?
+    [name.to_sym, data0]
   end
 
   def check_disallowed(name)
@@ -161,11 +170,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 +226,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,18 +53,10 @@ class Livetext
   end
 
   def self.interpolate(str)
-    parse = Livetext::LineParser.new(str)
-    parse.var_func_parse
-  end
-
-  def self.customize(mix: [], call: [], vars: {})
-    obj = self.new
-    mix  = Array(mix)
-    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) }
-    obj
+    expand = Livetext::Expansion.new(self) 
+    str2 = expand.expand_variables(str)
+    str3 = expand.expand_function_calls(str2)
+    str3
   end
 
   def peek_nextline
@@ -83,12 +91,24 @@ class Livetext
     raise err
   end
 
+  def self.customize(mix: [], call: [], vars: {})
+    obj = self.new
+    mix  = Array(mix)
+    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) }
+    obj.api.setvars(vars)
+    obj
+  end
+
   def customize(mix: [], call: [], vars: {})
     mix  = Array(mix)
     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