livetext 0.8.77 → 0.8.78

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 904d935b6923cb3dd8a70dc6042b03a95dcd18851d7e3dfb4d9cae61cc0653b9
-  data.tar.gz: afdfa6c79db3beeb644bd12de6ab2ee061c48b786f87fdc4b6fb10dbeb706f45
+  metadata.gz: 14f8d44bfa9cd1fbcd49da2f848df5ed1e8dd6086555a8b163d43e0137303284
+  data.tar.gz: f695e704124133507245e5ec0c7e596aa1b4c97117e14c2ac79b6497a83224c8
 SHA512:
-  metadata.gz: 7f18d43dd7672ad30d7c4029e39ddda2eb27316d31f0312cc68f2e751ad34f818949150cb6306dd513194e73d2d54e88b457ce34b37003162f12df3aae476264
-  data.tar.gz: c533499a1aeb11bcdaf5937dd9ce25fed799c0e8c02034cff9c6fe845ae57159b8d2a8f5211eeece89eb09e34d1777b69bb36a65d54b40b142dfb877f22b53a0
+  metadata.gz: 39c10beb0b76dbcfa9221bba0b0dccde17294b943d4a50639b7b1e66766040ce32a780d1849df3512efdfeb016abbccdd78298bde802001d8f131bee06f0ee39
+  data.tar.gz: 794dbdb41daed694e3d1f3fce433c7cfaa2a5846ffb7b03610b35ce9ab8b52d48b4d1ebf66a7a1bb15da41dd59baa380fcfc82f97d0d719512034372799f99a0

data/lib/SAVE.formatline

@@ -0,0 +1,297 @@
+class FormatLine
+
+  EOL    = :eol
+  Alpha  = /[a-z]/
+  Alpha2 = /[a-z0-9_]/
+  Other  = Object
+
+  SimpleFormats     = {}
+  SimpleFormats[:b] = %w[<b> </b>]
+  SimpleFormats[:i] = %w[<i> </i>]
+  SimpleFormats[:t] = ["<font size=+1><tt>", "</tt></font>"]
+  SimpleFormats[:s] = %w[<strike> </strike>]
+
+  def initialize
+    @buffer, @vname, @fname, @param, @substr = "", "", "", "", ""
+  end
+
+  def peek
+    @enum.peek
+  rescue StopIteration
+    EOL
+  end
+
+  def grab
+    @enum.next
+  rescue StopIteration
+    EOL
+  end
+
+  def skip
+    @enum.next
+    @enum.peek
+  rescue StopIteration
+    EOL
+  end
+
+  def keep(initial = "")
+    @buffer << initial
+    @buffer << @enum.next
+  rescue StopIteration
+    EOL
+  end
+
+  def emit(str = "")
+    @buffer << str
+  end
+
+  def funcall(name, param)
+    if self.respond_to?("func_" + name.to_s)
+      self.send("func_" + name.to_s, param)
+    else
+      fobj = ::Livetext::Functions.new
+      ::Livetext::Functions.param = param        # is this 
+      ::Livetext::Functions.context = @context   #   screwed up???
+      fobj.send(name)
+    end
+  end
+
+  def vsub
+    @buffer << Livetext::Vars[@vname]
+    @vname = ""
+  end
+
+  def fcall
+    @buffer << funcall(@fname, @param)
+    @fname, @param = "", ""
+  end
+
+# FIXME Much of this should be done via CSS
+# FIXME In particular, strike is deprecated.
+
+  def bold
+    d0, d1 = SimpleFormats[:b]
+    @buffer << "#{d0}#@substr#{d1}"
+    @substr = ""
+  end
+
+  def ttype
+    d0, d1 = SimpleFormats[:t]
+    @buffer << "#{d0}#@substr#{d1}"
+    @substr = ""
+  end
+
+  def italics
+    d0, d1 = SimpleFormats[:i]
+    @buffer << "#{d0}#@substr#{d1}"
+    @substr = ""
+  end
+
+  def strike
+    d0, d1 = SimpleFormats[:s]
+    @buffer << "#{d0}#@substr#{d1}"
+    @substr = ""
+  end
+
+  def parse(line, context = nil)
+    context ||= binding
+    @context = context
+    @enum = line.chomp.each_char
+    @buffer = ""
+    @substr = ""
+    @fname  = ""
+    @vname  = ""
+    @param  = ""
+
+    # FIXME - refactor, generalize, clarify
+    
+    loop do   # starting state
+      char = peek
+      case char
+        when "\\"
+          char = skip
+          case char
+            when "$", "*", "_", "`", "~"
+              emit(char)
+              skip
+            when " "
+              emit("\\ ")
+              skip
+            when EOL
+              emit("\\")
+              break
+            when Other
+              emit("\\")   # logic??
+          end
+        when EOL
+          break
+        when "$"        # var or func or $
+          case skip
+            when EOL
+              emit("$")
+              break
+            when Alpha
+              loop { ch = peek; break if ch == EOL; @vname << grab; break unless Alpha2 === peek } 
+              vsub
+            when "$" 
+              case skip
+                when EOL
+                  emit("$$")
+                  break
+                when Alpha
+                  loop { ch = peek; break if ch == EOL; @fname << grab; break unless Alpha2 === peek }
+                  case peek
+                    when " "   # no param - just call
+                      @param = nil
+                      fcall    # no param? Hmm
+                    when "["   # long param
+                      skip
+                      loop do 
+                        if peek == "\\"
+                          skip
+                          @param << grab
+                        end
+                        break if ["]", EOL].include?(peek)
+                        @param << grab
+                      end
+                      skip
+                      fcall
+                    when ":"   # param (single token or to-eol)
+                      case skip
+                        when ":"   # param to eol
+                          skip
+                          loop { break if peek == EOL; @param << grab }
+                        when Other # grab until space or eol
+                          loop { @param << grab; break if [" ", EOL].include?(peek) }
+                          fcall
+                      end
+                    when Other # no param - just call
+                      fcall
+                  end
+                when Other
+                  emit "$$"
+              end
+            when Other
+              emit "$"
+          end
+        when "*"
+          case skip
+            when EOL
+              emit "*"
+            when " "
+              emit "*"
+            when "["
+              skip
+              loop do
+                if peek == "\\"
+                  skip
+                  @substr << grab
+                  next
+                end
+                break if ["]", EOL].include?(peek)
+                @substr << grab
+              end
+              skip
+              bold
+            when Other
+              loop { @substr << grab; break if [" ", EOL].include?(peek) }
+              bold
+          end
+        when "_"
+          case skip
+            when EOL
+              emit "_"
+            when " "
+              emit "_"
+            when "["
+              skip
+              loop do
+                if peek == "\\"
+                  skip
+                  @substr << grab
+                  next
+                end
+                break if ["]", EOL].include?(peek)
+                @substr << grab
+              end
+              skip
+              italics
+            when "_"   # doubled...
+              skip
+              loop do
+                if peek == "\\"
+                  skip
+                  @substr << grab
+                  next
+                end
+                break if [".", ",", ")", EOL].include?(peek)
+                @substr << grab
+              end
+              italics
+            when Other
+              loop { @substr << grab; break if [" ", EOL].include?(peek) }
+              italics
+          end
+        when "`"
+          case skip
+            when EOL
+              emit "`"
+            when " "
+              emit "`"
+            when "["
+              skip
+              loop do
+                if peek == "\\"
+                  skip
+                  @substr << grab
+                  next
+                end
+                break if ["]", EOL].include?(peek)
+                @substr << grab
+              end
+              skip
+              ttype
+            when "`"   # doubled...
+              skip
+              loop { break if [".", ",", ")", EOL].include?(peek); @substr << grab }   # ";" ?? FIXME
+              ttype
+            when Other
+              loop { @substr << grab; break if [" ", EOL].include?(peek) }
+              ttype
+          end
+        when "~"
+          case skip
+            when EOL
+              emit "~"
+            when " "
+              emit "~"
+            when "["
+              skip
+              loop do
+                if peek == "\\"
+                  skip
+                  @substr << grab
+                  next
+                end
+                break if ["]", EOL].include?(peek)
+                @substr << grab
+              end
+              skip
+              strike
+            when "~"   # doubled...
+              skip
+              loop { break if [".", ",", ")", EOL].include?(peek); @substr << grab }   # ";" ?? FIXME
+              strike
+            when Other
+              loop { @substr << grab; break if [" ", EOL].include?(peek) }
+              strike
+          end
+        when Other
+          keep
+      end
+    end
+
+    @buffer
+  end
+end
+

data/lib/SAVE2.formatline.rb

@@ -0,0 +1,707 @@
+class FormatLine
+
+  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_]/
+  Param   = ["]", "\n", nil]
+  Escape  = "\\"   # not an ESC char
+
+  def terminate?(terminators, ch)
+    if terminators.is_a? Regexp
+      terminators === ch
+    else
+      terminators.include?(ch)
+    end
+  end
+
+  attr_reader :out
+
+  def initialize(line, context)
+    context ||= binding
+    @context = context
+    @line = line
+    @i = -1
+    @token = Null.dup
+    @tokenlist = []
+  end
+
+  def old_initialize(line, context)
+    context ||= binding
+    @context = context
+    @line = line
+    chars = [nil] + line.scan(/./) + [nil] + [nil]
+    @gen = chars.each_cons(3)
+    @cc = 0  # char count
+    go   #  @prev, @ch, @next = *@gen.next
+    @out = ""
+    loop do 
+      case @ch
+        when "\\"
+          go
+          emit @ch
+          next
+        when "$"; dollar
+        when "*"; asterisk
+        when "_"; underscore
+        when "`"; backtick
+        when "~"; tilde; # showme("after tilde")
+        when nil; break
+        else
+          emit @ch; # STDERR.puts "--- else - emitted #{@ch.inspect}"
+      end
+      go
+    end
+  end
+
+  def self.parse(line, context = nil)
+    x = self.new(line, context)
+    x.out
+  end
+
+  def self.parse!(line, context = nil)
+    x = self.new(line.chomp, context)
+    x.tokenize(line)
+#   x.evaluate    # (context)
+#   x.out
+    x.evaluate
+  end
+
+############ new methods
+
+  def tokenize(line)
+    grab
+    loop do 
+# puts "*** char #{curr}"
+      case curr
+        when Escape; go; add curr; grab
+        when "$"
+          _dollar
+        when "*", "_", "`", "~"
+          marker curr
+          add curr
+        when LF, nil
+          break
+        else
+          add curr
+      end
+      grab
+#     add_token(:str)
+    end
+    add_token(:str)
+# p @tokenlist
+    @tokenlist
+  end
+
+  def embed(sym, str)
+    pre, post = SimpleFormats[sym]
+    pre + str + post
+  end
+
+  def evaluate(tokens = @tokenlist)
+    @out = ""
+    return "" if tokens.empty?
+    gen = tokens.each
+    token = gen.next
+    loop do 
+      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]
+          end
+          @out << funcall(val, param)
+        when :b, :i, :t, :s
+          @out << embed(sym, val)
+      else
+        add_token :str
+      end
+      token = gen.next
+    end
+# p @out
+    @out
+  end
+
+  def curr
+    @line[@i]
+  end
+
+  def prev
+    @line[@i-1]
+  end
+
+  def next!
+    @line[@i+1]
+  end
+
+  def grab
+    @line[@i+=1]
+  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 curr
+    grab
+    param = nil if param.empty?
+    param
+  end
+
+  def add(str)
+    @token << str unless str.nil?
+  end
+
+  Syms = { "*" => :b, "_" => :i, "`" => :t, "~" => :s }
+
+  def self.format(line, context = nil)
+    x = self.new(line, context)
+    x.format
+  end
+
+  def format
+    grab
+    loop do 
+      case curr
+        when Escape; go; add curr; grab
+        when "$"
+          _dollar
+        when "*", "_", "`", "~"
+          marker curr
+        when LF, nil
+          break
+        else
+          add curr
+      end
+      grab
+    end
+    add_token(:str)
+    @tokenlist
+  end
+
+  def add_token(kind, token = @token)
+    @tokenlist << [kind, token] unless token.empty?
+    @token = Null.dup
+  end
+
+  def grab_alpha
+    str = Null.dup
+    grab
+    loop do
+      break if curr.nil?
+      str << curr
+      break if terminate?(NoAlpha, next!)
+      grab
+    end
+    str
+  end
+
+  def _dollar
+    grab
+    case curr
+      when LF;  add "$";  add_token :str
+      when " "; add "$ "; add_token :str
+      when nil; add "$";  add_token :str
+      when "$"; _double_dollar
+      when "."; _dollar_dot
+      when /[A-Za-z]/
+       add_token :str
+        var = curr + grab_alpha
+        add_token(:var, var)
+    else 
+      add "$" + curr
+      add_token(:string)
+    end
+  end
+
+  def handle_function_call
+  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)
+          else  # do nothing
+        end
+      else
+        grab; add_token :str, "$$" + curr; return
+    end
+  end
+
+  def dollar_dot
+    add_token :ddot, @line[@i..-1]
+  end
+
+  def marker(char)
+    add_token :str
+    sym = Syms[char]
+    if embedded?
+      add char    # ??? add_token "*", :string
+      return 
+    end
+    grab
+    case curr
+      when Space
+        add char + " "
+        add_token :str
+        grab
+      when LF, nil
+        add char
+        add_token :str
+      when char;   double_marker(char)
+      when LBrack; long_marker(char)
+    else
+      add curr
+      str = collect!(sym, Blank)
+      add_token sym, str
+      add curr  # next char onto next token... 
+    end
+  end
+
+  def double_marker(char)
+    sym = Syms[char]
+    grab
+    kind = sym   # "string_#{char}".to_sym
+    case next!   # first char after **
+      when Space, LF, nil
+        pre, post = SimpleFormats[sym]
+        add_token kind
+      else
+        str = collect!(sym, Punc)
+        grab unless next!.nil?
+        add_token kind, str
+    end
+  end
+
+  def long_marker(char)
+    sym = Syms[char]
+    # grab  # skip left bracket
+    kind = sym  # "param_#{sym}".to_sym
+    arg = collect!(sym, Param, true)
+    add_token kind, arg
+#   add curr
+  end
+
+  def collect!(sym, terminators, param=false)
+    str = Null.dup   # next is not " ","*","["
+    grab
+    loop do
+      if curr == Escape
+        str << grab # ch = escaped char
+        grab
+        next
+      end
+      break if terminate?(terminators, curr)
+      str << curr    # not a terminator
+      grab
+    end
+    grab if param && curr == "]" # skip right bracket
+#   str << curr  #  if @ch
+#   add curr  # next char onto next token...
+    add str
+  end
+
+############
+
+  ### From FormatLine:
+
+  def funcall(name, param)
+    result = 
+      if self.respond_to?("func_" + name.to_s)
+        self.send("func_" + name.to_s, param)
+      else
+        fobj = ::Livetext::Functions.new
+        ::Livetext::Functions.param = param        # is this 
+        ::Livetext::Functions.context = @context   #   screwed up???
+        fobj.send(name)
+      end
+    result
+  end
+
+  def varsub(name)
+    result = Livetext::Vars[name]
+    result
+  end
+
+  #####
+
+  def showme(tag)
+    char = @line[@cc]
+    puts "--- #{tag}: ch=#{@ch.inspect} next=#{@next.inspect} (cc=#@cc:#{char.inspect})   out=#{@out.inspect}"
+  end
+
+  def accumulate!(sym, terminators, param=false)
+    # already ate *[   - ch=[
+    str = ""   # next is not " ","*","["
+    go
+    loop do
+      if @ch == "\\"
+        go    # ch = escaped char
+        str << @ch
+        go
+        next
+      end
+      break if terminate?(terminators, @ch)
+      str << @ch    # not a terminator
+      go
+    end
+    pre, post = SimpleFormats[sym]
+    str = (pre + str + post)
+    go if param && @ch == "]" # skip right bracket
+    str << @ch if @ch
+    emit str
+  end
+
+  def go
+    @cc += 1   # char count
+    @prev, @ch, @next = *@gen.next
+  end
+
+  def blank?(ch)
+    [" ", nil, "\n"].include? ch
+  end
+
+  def term_punc?(ch)
+    [")", ",", ".", " ", "\n"].include? ch
+  end
+
+  def not_alphanum?(ch)
+    ch !~ /[A-Za-z0-9_]/
+  end
+
+  def term_param?(ch)
+    ["]", "\n", nil].include? ch
+  end
+
+  def embedded?
+    ! (['"', "'", " ", nil].include? @prev)
+  end
+
+  def _embedded?
+    ! (['"', "'", " ", nil].include? prev)
+  end
+
+  def emit(str)
+return if str.nil? || str.empty?
+    str ||= ""
+    @out << str
+  end
+
+  ### dollar...
+
+  def dollar
+    go
+    case @ch
+      when " "; emit "$ "
+      when nil; emit "$"
+      when "$"; double_dollar
+      when "."; dollar_dot
+      when /[A-Za-z]/
+        var = @ch + get_alpha
+        str = varsub(var)
+        emit str
+    else 
+      emit "$" + @ch
+    end
+  end
+
+  def get_alpha
+    str = ""
+    grab
+    loop do
+      str << @ch
+      break if terminate?(NoAlpha, @next)
+      grab
+    end
+    str
+  end
+
+  def collect(terminators = NoAlpha)
+    str = ""
+    go
+    loop do
+      if @ch == "\\"
+        go    # ch = escaped char
+        str << @ch
+        go
+        next
+      else
+        str << @ch
+      end
+      break if terminate?(terminators, @ch)
+      go
+    end
+    str
+  end
+
+  def get_colon_param
+    go  # grab :
+    param = ""
+    loop do 
+      case @next
+        when "\\" 
+          go
+          param << @next
+          go
+        when " ", "\n", nil; break
+      else
+        param << @next
+        go
+      end
+    end
+
+    param = nil if param.empty?
+    param
+  end
+
+  def get_func_param
+    go  # grab [
+    param = ""
+    loop do 
+      case @next
+        when "\\" 
+          go
+          param << @next
+          go
+        when "]", "\n", nil; break
+      else
+        param << @next
+        go
+      end
+    end
+
+    go
+    param = nil if param.empty?
+    param
+  end
+
+  def get_func_call
+    func = get_alpha
+    param = nil
+    case @next
+      when "["
+        param = get_func_param 
+      when ":"
+        param = get_colon_param 
+    end
+    [func, param]
+  end
+
+  def double_dollar
+    case @next
+      when " "
+        emit "$$ "
+        go
+        return
+      when /[A-Za-z]/
+        func, param = get_func_call
+    else
+      go
+      emit "$$" + (@ch || "")
+      return
+    end
+
+    str = funcall(func, param)
+    save = @ch.dup  # save last char
+    emit str   # if str && ! @ch.nil?
+#   emit save if @next.nil?   ### HERE
+  end
+
+  def dollar_dot
+    go
+    dot = collect { not_alphanum?(@ch) }
+    emit "DOT(#{dot})"  # not implemented yet
+  end
+
+  ### asterisk...
+
+  def asterisk
+    return emit("*") if embedded?
+    case @next
+      when " ", nil; emit "*"
+      when "*";      double_asterisk
+      when "[";      long_asterisk
+    else
+      accumulate!(:b, Blank)
+    end
+  end
+
+  def double_asterisk
+    go
+    case @next  # first char after **
+      when " ", nil; emit "<b>*</b>"
+    else
+      accumulate!(:b, Punc)
+      go unless @next.nil?
+      emit @ch 
+    end
+  end
+
+  def long_asterisk
+    go   # skip left bracket
+    accumulate!(:b, Param, true)
+  end
+
+  ### underscore...
+
+  def underscore
+    return emit("_") if embedded?
+    case @next
+      when " ", nil; emit "_"
+      when "_";      double_underscore
+      when "[";      long_underscore
+    else
+      accumulate!(:i, Blank)
+#     emit @ch unless @ch.nil?
+    end
+  end
+
+  def double_underscore
+    go
+    case @next  # first char after __
+      when " ", nil; emit "<i>_</i>"
+    else
+      accumulate!(:i, Punc)
+      go unless @next.nil?
+      emit @ch 
+    end
+  end
+
+  def long_underscore
+    go   # skip left bracket
+    accumulate!(:i, Param, true)
+  end
+
+  ### backtick...
+
+  def backtick
+    return emit("`") if embedded?
+    case @next
+      when " ", nil; emit "`"
+      when "`";      double_backtick
+      when "[";      long_backtick
+    else
+      accumulate!(:t, Blank)
+    end
+  end
+
+  def double_backtick
+    go
+    case @next  # first char after ``
+      when " ", nil; emit "<tt>*</tt>"
+    else
+      accumulate!(:t, Punc)
+      go unless @next.nil?
+      emit @ch 
+    end
+  end
+
+  def long_backtick
+    go   # skip left bracket
+    accumulate!(:t, Param, true)
+  end
+
+  ### tilde...
+
+  def tilde
+    return emit("~") if embedded?
+    case @next
+      when " ", nil; emit "~"
+      when "~";      double_tilde
+      when "[";      long_tilde
+    else
+      accumulate!(:s, Blank)
+    end
+  end
+
+  def double_tilde
+    go
+    case @next  # first char after ~~
+      when " ", nil; emit "<strike>~</strike>"
+    else
+      accumulate!(:s, Punc)
+      go unless @next.nil?
+      emit @ch 
+    end
+  end
+
+  def long_tilde
+    go   # skip left bracket
+    accumulate!(:s, Param, true)
+  end
+
+end
+
+
+# LineParser.new("Here's a $ dollar sign, a $$function, a $variable, and a $.dot_command.")
+# LineParser.new("This is *bold and _italics and `code and ~strike")
+# LineParser.new("This is **bold, but with two asterisks.")
+# LineParser.new("Bold asterisk ** here.")
+# LineParser.new("What about an embedded asterisk like X*Y situation?")
+# LineParser.new("What about multiple_embedded_underscores and such?")
+# LineParser.new("Try a bolded *string_with_underscores")
+# LineParser.new("Bolded *[arbitrary parameter with stuff: * _ ` ~ ]...")
+# LineParser.new("Bold *[until end of line")
+# LineParser.new("This is **bold, __italics, ``code, and ~~strike.")
+# LineParser.new("This is *[bold stuff], _[italics stuff], `[code stuff], and ~[strike stuff].")
+
+