livetext 0.9.30 → 0.9.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3796664666616d6b5428f4b27f81c3f902171fc8afc8fd351631c6c774e730
-  data.tar.gz: 5dd5250915ef13d930dca6b147e84b5e04e42d1a7b9c0f4b1e95d510ea49e476
+  metadata.gz: 769c4da93282df68e38011277d71ee8334fd14d4f87061c803d3d9643564afc7
+  data.tar.gz: 9b8611007ecbc2d4e899575cf504e6f87c9b1887df2b59ef8ff56a072f5e9e92
 SHA512:
-  metadata.gz: d0e81ca1d3990468ae49f3c5e23ab608160f7db301f692757200fe57b5434f125bd83b3a7af80dd22ea8cc278972dcb39fe3b408f3a800871f3fb243e6c3639c
-  data.tar.gz: 4bc7641f62f63215fbcf52192a74956991e540a2282922da21a5b0ea2a5d959420a9226c52745c635fc91521d860921b4d7d69defb8b540868d73df9b8fbfd99
+  metadata.gz: 2904613247a614b01a8b80ecefb9197ba070e69ebad4d292e3ce77b3f4ddf5b60850ad554333c1e2f8a54cf56b765c799ae52fd7491fd24648b570313ba401c6
+  data.tar.gz: e698ca1431dc18d64d1b44fc9edebe033c382dcc49252602cbf74c398c8f6fc38fea2dbe3d3a056fe550eca6291157bfba53e240d416a97bd1f3cca8ea4ec141

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

@@ -12,21 +12,23 @@ class Livetext::Expansion
     @live = instance
   end
 
-  def format(line)   # new/experimental
+  def format(line)
     return "" if line == "\n" || line.nil?
-    formatted = Formatter.format(line)
-    with_vars = expand_variables(formatted)
+    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 + ")")
-    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) == "\\$"  # escaped, ignore it
+        str.slice!(0..1)    
+        buffer << "$"
       when str.slice(0..1) == "$$"   # func?
         buffer << str.slice!(0..1)    
       when str.slice(0) == "$"       # var?
@@ -41,7 +43,8 @@ class Livetext::Expansion
         vars = @live.vars
         buffer << vars.get(vsym)
       else                           # other
-        buffer << str.slice!(0)
+        char = str.slice!(0)
+        buffer << char
       end
     end
     buffer
@@ -82,14 +85,12 @@ class Livetext::Expansion
         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
+#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)
@@ -100,6 +101,7 @@ puts "fsym   = #{fsym.inspect}"
         buffer << char
       end
     end
+# STDERR.puts "buffer     = #{buffer.inspect}"
     buffer
   end
 end

data/lib/livetext/formatter.rb

@@ -1,104 +1,223 @@
 module Formatter
-  
-  Start = /(?<start>(^| ))/
-  Stop  = /(?<stop> |$)/
 
-  def self.make_regex(sigil, cdata, stop = Stop)
-    rx = /#{Start}#{sigil}#{cdata}#{stop}/
+## 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 self.iterate(str, rx, tag)
-    loop do
-      str, more = make_string(str, rx, tag)
-      break unless more
+    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
-    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 front
+      @str[0]
+    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 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 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
+    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
 
-  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]
+  class Single < Delimited
+    # Yeah, this one is that simple
   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
+
+  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
 
-  def self.format(str)
-    s2 = str.chomp
-    s2 = handle(s2, "*", "b")
-    s2 = handle(s2, "_", "i")
-    s2 = handle(s2, "`", "tt")
-    s2 = handle(s2, "~", "strike")
-    s2
+  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
 
-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/helpers.rb

@@ -10,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)
@@ -100,14 +102,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!(/^ *\$/, "")
@@ -116,25 +118,27 @@ module Livetext::Helpers
     success
   end
 
-  def invoke_dotcmd(name, *args)
+  def invoke_dotcmd(name, data="")
     # FIXME Add cmdargs stuff... depends on name, etc.
-    retval = @main.send(name, *args)
+    api.data = data   # should permit _ in function names at least
+    args = data.split
+    api.args = args
+    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)
+    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
@@ -145,14 +149,21 @@ 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.data = data       # FIXME kill this
+    @main.api.data = data0  # FIXME kill this?
+    [name.to_sym, data0]
   end
 
   def check_disallowed(name)