livetext 0.9.25 → 0.9.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f447e149e6724975184b8db2c51ff59c58752c3cb5b4037bb86fb1f355015a6
-  data.tar.gz: 9740fc3b2bb98e92c91c523656f270a66132d882fbcaa9b1a803294d1e10a65a
+  metadata.gz: ee3796664666616d6b5428f4b27f81c3f902171fc8afc8fd351631c6c774e730
+  data.tar.gz: 5dd5250915ef13d930dca6b147e84b5e04e42d1a7b9c0f4b1e95d510ea49e476
 SHA512:
-  metadata.gz: 1ee34071fde07e45b13d8f13aa9889d2b060651901acd8e3876071121ea5222c8bc4b83162c30f772c53fe92e07ea7bada3f28be0c75994f1ad21bcdacbb2905
-  data.tar.gz: ce9ed1ac2cd624818b775d19681a406f0a4c43c2a0b9a7f6f8c1f8fb9834b91301a2b65c10d1faa0c4b664a1abcb741c570d1745d996537f4d438e97b65e3f56
+  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/imports/bookish.rb

@@ -187,8 +187,7 @@ module Bookish
       cells = line.split(delim)
       api.out "<tr>"
       cells.each.with_index do |cell, i| 
-        api.out "  <td width=#{maxw}% valign=top>" + 
-              "#{cell}</td>"
+        api.out "  <td width=#{maxw[i]}% valign=top>#{cell}</td>"
       end
       api.out "</tr>"
     end

data/lib/livetext/errors.rb

@@ -13,3 +13,6 @@ def make_exception(sym, str, target_class = Object)
   end
 end
 
+make_exception(:EndWithoutOpening, "Error: found .end with no opening command")
+make_exception(:UnknownMethod,     "Error: name '%1' is unknown")
+

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/global_helpers.rb

@@ -2,6 +2,7 @@
 module GlobalHelpers
 
   def check_disallowed(name)
+api.tty "GLOBAL cdis"
     raise DisallowedName(name) if disallowed?(name)
   end
 
@@ -34,4 +35,8 @@ module GlobalHelpers
 	  return nil
   end
 
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
 end

data/lib/livetext/handler/import.rb

@@ -1,6 +1,8 @@
 
 require_relative '../helpers'
 
+# Handle a .import
+
 class Livetext::Handler::Import
   include Livetext::Helpers
   include GlobalHelpers
@@ -34,11 +36,5 @@ class Livetext::Handler::Import
     newmod   # return actual module
   end
 
-  private
-
-  def cwd_root?
-    File.dirname(File.expand_path(".")) == "/"
-  end
-
 end
 

data/lib/livetext/handler/mixin.rb

@@ -1,6 +1,8 @@
 
 require_relative '../helpers'
 
+# Handle a .mixin
+
 class Livetext::Handler::Mixin
   include Livetext::Helpers
   include GlobalHelpers
@@ -27,11 +29,5 @@ class Livetext::Handler::Mixin
     [modname, "module ::#{modname}; #{meths}\nend"]
   end
 
-  private
-
-  def cwd_root?
-    File.dirname(File.expand_path(".")) == "/"
-  end
-
 end
 

data/lib/livetext/helpers.rb

@@ -1,5 +1,6 @@
 
 require_relative 'global_helpers'
+require_relative 'expansion'
 
 module Livetext::Helpers
 
@@ -55,8 +56,10 @@ 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
 
@@ -92,12 +95,12 @@ module Livetext::Helpers
   def process_line(line)
     success = true
     case line  # must apply these in order
-      when Comment
-        success = handle_scomment(line)
-      when DotCmd
-        success = handle_dotcmd(line)
-      when DollarDot
-        success = handle_dollar_dot
+    when Comment
+      success = handle_scomment(line)
+    when DotCmd
+      success = handle_dotcmd(line)
+    when DollarDot
+      success = handle_dollar_dot
     else
       api.passthru(line)  # must succeed?
     end
@@ -113,18 +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 NoMethodError => err
-#   graceful_error(err)
   rescue => err
     graceful_error(err)
   end
 
   def handle_dotcmd(line, indent = 0)
-#   TTY.puts ">>> #{__method__} in #{__FILE__}" #  if ENV['debug']
+    # FIXME api.data is broken
     indent = @indentation.last # top of stack
     line = line.sub(/# .*$/, "")   # FIXME Could be problematic?
     name = get_name(line)
@@ -159,15 +160,16 @@ module Livetext::Helpers
   end
 
   def check_file_exists(file)
-#   raise FileNotFound(file) unless File.exist?(file)
-     return File.exist?(file)
+    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)
@@ -217,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

@@ -0,0 +1,178 @@
+
+# Class Livetext reopened (top level).
+
+class Livetext
+
+  include Helpers
+
+  class Variables
+    attr_reader :vars
+    def initialize(hash = {})
+      @vars = {}
+      hash.each_pair {|k, v| @vars[k.to_sym] = v }
+    end
+  
+    def [](var)
+      @vars[var.to_sym]
+    end
+
+    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
+
+  TTY = ::File.open("/dev/tty", "w")
+
+  attr_reader :main, :sources
+  attr_accessor :nopass, :nopara
+  attr_accessor :body, :indentation
+
+  class << self
+    attr_accessor :output      # bad solution?
+  end
+
+  def vars
+    @_vars
+  end
+
+  def self.interpolate(str)
+    expand = Livetext::Expansion.new(self) 
+    str2 = expand.expand_variables(str)
+    str3 = expand.expand_function_calls(str2)
+    str3
+  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) }
+    api.setvars(vars)
+    obj
+  end
+
+  def peek_nextline
+    @main.peek_nextline  # delegate
+  end
+
+  def nextline
+    @main.nextline       # delegate
+  end
+
+  def sources
+    @main.sources        # delegate
+  end
+
+  def save_location
+    @save_location  # delegate
+  end
+
+  def save_location=(where)
+    @save_location = where  # delegate
+  end
+
+  def dump(file = nil)   # not a dot command!
+    file ||= ::STDOUT
+    file.puts @body
+  rescue => err
+    TTY.puts "#dump had an error: #{err.inspect}"
+  end
+
+  def graceful_error(err)
+    dump
+    raise err
+  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.set(var, val.to_s) }
+    api.setvars(vars)
+    self
+  end
+
+  def initialize(output = ::STDOUT)
+    @source = nil
+    @_mixins = []
+    @_imports = []
+    @_outdir = "."
+    @no_puts = output.nil?
+    @body = ""
+    @main = Processor.new(self, output)
+    @indentation = [0]
+    @_vars = Livetext::Vars
+    @api = UserAPI.new(self)
+    initial_vars
+  end
+
+  def api
+    @api
+  end
+
+  def initial_vars
+    # Other predefined variables (see also setfile)
+    @api.setvar(:User, `whoami`.chomp)
+    @api.setvar(:Version, Livetext::VERSION)
+  end
+
+  def transform(text)
+    setfile!("(string)")
+    enum = text.each_line
+    front = text.match(/.*?\n/).to_a.first.chomp rescue ""
+    @main.source(enum, "STDIN: '#{front}...'", 0)
+    loop do 
+      line = @main.nextline
+      break if line.nil?
+      process_line(line)
+    end
+    result = @body
+#   @body = ""
+    result
+  end
+
+  # EXPERIMENTAL and incomplete
+  def xform(*args, file: nil, text: nil, vars: {})
+    case
+      when file && text.nil?
+        xform_file(file)
+      when file.nil? && text
+        transform(text)
+      when file.nil? && text.nil?
+        raise "Must specify file or text"
+      when file && text
+        raise "Cannot specify file and text"
+    end
+    self.process_file(file)
+    self.body
+  end
+
+  def xform_file(file, vars: nil)
+    Livetext::Vars.replace(vars) unless vars.nil?
+    @_vars.replace(vars) unless vars.nil?
+    self.process_file(file)
+    self.body
+  end
+
+end
+