livetext 0.9.26 → 0.9.31

data/lib/livetext/lineparser.rb

@@ -1,441 +0,0 @@
-
-require_relative 'parsing'
-require_relative 'funcall'
-
-# Class LineParser handles the parsing of comments, dot commands, and 
-# simple formatting characters, as well as variables and functions.
-
-class Livetext::LineParser < StringParser
-  include Livetext::ParsingConstants
-  include Livetext::LineParser::FunCall
-
-  FMTS = %w[* _ ~ `]
-
-  attr_reader :out
-  attr_reader :tokenlist
-
-  def initialize(line)
-    super
-    @token = Null.dup
-    @tokenlist = []
-    @live = Livetext.new
-  end
-
-  def self.api
-    Livetext.new.main.api
-  end
-
-  def api
-    @live.main.api
-  end
-
-  def self.parse!(line)
-    return nil if line.nil?
-    line.chomp!
-    x = self.new(line)
-api.tty "\n-- string: #{line.inspect}" if $testme
-    t = x.tokenize
-api.tty "-- Tokens: #{t.inspect}" if $testme
-    result = x.evaluate
-api.tty "-- result: #{result.inspect}" if $testme
-    result
-  end
-
- def parse_formatting
-   loop do 
-     case peek
-       when Escape; grab; add peek; grab
-       when "*", "_", "`", "~"
-         marker peek
-         add peek
-       when LF
-         break if eos?
-       when nil
-         break
-       else
-         add peek
-     end
-     grab
-   end
-   add_token(:str)
-   @tokenlist
- end
- 
- def self.parse_formatting(str)
-   fmt = self.new(str)
-   loop do 
-     case fmt.peek
-       when Escape; fmt.grab; fmt.add fmt.peek; fmt.grab
-       when "*", "_", "`", "~"
-         fmt.marker fmt.peek
-         fmt.add fmt.peek
-       when LF
-         break if fmt.eos?
-       when nil
-         break
-       else
-         fmt.add fmt.peek
-     end
-     fmt.grab
-   end
-   fmt.add_token(:str)
-   fmt.tokenlist
- end
- 
- def self.parse_variables(str)
-   return nil if str.nil?
-   x = self.new(str.chomp)
-   char = x.peek
-   loop do
-     char = x.grab
-     break if char == LF || char == nil
-     x.escaped if char == Escape
-     x.dollar if char == "$"  # Could be $$
-     x.add char
-   end
-   x.add_token(:str)
-   result = x.evaluate
-   result
- end
-
- def embed(sym, str)
-   pre, post = SimpleFormats[sym]
-   pre + str + post
- end
-
-#########
-
- def handle_simple_formatting(ch)
- # api.tty "ch = #{ch.inspect}"
-   marker ch
-   add ch
- # api.tty "token = #{@token.inspect}  #{@tokenlist.inspect}"
-   c2 = grab
- # api.tty "c2 = #{c2.inspect}"
- end
-
- def grab_string
-   weird = ["$", nil]  # [Escape, "$", nil]
-   ch = grab
-   add ch           # api.tty "-- gs  @token = #{@token.inspect}"
-   loop do
-     ch = peek      #    api.tty "gs1  ch = #{ch.inspect}"
-     break if weird.include?(ch)
-     break if FMTS.include?(ch) && (self.prev == " ")
-     break if eos?  #    ch = grab     # advance pointer #    api.tty "gs3  ch = #{ch.inspect}"
-     add grab
-   end              #  ch = grab     # advance pointer #  api.tty "-- gs4  ch = #{ch.inspect}"; sleep 0.01
-   add_token :str
- end
-
- def grab_token(ch)
-   finish = false
-# api.tty "#{__method__}: ch = #{ch.inspect}"
-   case ch
-     when nil;    finish = true # do nothing
-     when LF;     finish = true # do nothing  - break if eos?
-     when Escape; ch = self.escaped; add ch
-     when "$";    dollar
-     when *FMTS;  handle_simple_formatting(ch)
-     else         grab_string
-   end
-# api.tty "#{__method__}: AFTER CASE:  api.data = #{api.data.inspect}"
-   [ch, finish, @token, @tokenlist]
- end
-
- def tokenize
-   ch = peek
-   loop do 
-     ch = peek
-     stuff = grab_token(ch)
-     ch, finish, t, tlist = *stuff
-     break if finish
-   end
-# api.tty "tokenize:  i = #{self.i}" 
-# api.tty "tokenize:  token = #{@token.inspect}  tokenlist = #{@tokenlist.inspect}"
-   @tokenlist
- end
-
-#  def self.get_vars
-#    grab
-#    case peek
-#      when LF, " ", nil
-#        add "$"
-#        add_token :str
-#      when "$"; double_dollar
-##     when "."; dollar_dot
-#      when /[A-Za-z]/
-#        add_token :str
-#        var = peek + grab_alpha_dot
-#        add_token(:var, var)
-#    else 
-#      add "$" + peek
-#      add_token(:str)
-#    end
-#  end
-#
-#  def self.parse_var_func   # FIXME Hmm...
-#    loop do 
-#      case peek
-#        when "$"
-#          dollar
-#        when LF
-#          break if eos?
-#        when nil
-#          break
-#        else
-#          add peek
-#      end
-#      grab
-#    end
-#    add_token(:str)
-#    @tokenlist
-#  end
-
- def terminate?(terminators, ch)
-   if terminators.is_a? Regexp
-     terminators === ch
-   else
-     terminators.include?(ch)
-   end
- end
-
- def var_func_parse
-   char = self.peek
-   loop do
-     char = self.grab
-     break if char == LF || char == nil
-     self.escaped if char == Escape
-     self.dollar if char == "$"  # Could be $$
-     self.add char
-   end
-   self.add_token(:str)
-   result = self.evaluate
-   result
- end
-
- def self.var_func_parse(str)
-   return nil if str.nil?
-   x = self.new(str.chomp)
-   char = x.peek
-   loop do
-     char = x.grab
-     break if char == LF || char == nil
-     x.escaped if char == Escape
-     x.dollar if char == "$"  # Could be $$
-     x.add char
-   end
-   x.add_token(:str)
-   result = x.evaluate
-   result
- 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;   eval_str(val)
-       when :var;   eval_var(val)
-       when :func;  eval_func(val, gen)
-       when *BITS;  eval_bits(sym, val)
-     else
-       add_token :str
-     end
-     token = gen.next
-   end
-   @out
- end
-
- def add(str)
-   @token << str unless str.nil?
- end
-
- def add_token(kind, token = @token)
-   return if token.nil?
-   @tokenlist << [kind, token] unless token.empty?
-   @token = Null.dup
- end
-
- def grab_alpha
-   str = grab
-   loop do
-     break if eos?
-     break if terminate?(NoAlpha, peek)
-     str << grab
-   end
-   str
- end
-
- def grab_alpha_dot
-   str = grab    # Null.dup
-   loop do
-     break if eos?
-     break if terminate?(NoAlphaDot, peek)
-     str << grab
-   end
-   str
- end
-
- def dollar
-   c1 = grab    # $
-   c2 = grab    # ...
-   case c2
-     when " ";        add_token :str, "$ "
-     when LF, nil;    add_token :str, "$"
-     when "$";        double_dollar
-     when ".";        dollar_dot
-     when /[A-Za-z]/; add_token(:var, c2 + grab_alpha_dot)
-     else             add_token(:str, "$" + c2)
-   end
- end
-
- def finish_token(str, kind)
-   add str
-   add_token :str
-   grab
- end
-
- def marker(char)
-   add_token :str
-   sym = Syms[char]
-   return if embedded?
-   grab
-   case peek
-     when Space;   finish_token(char + " ", :str)
-     when LF, nil; finish_token(char, :str)
-     when char;    double_marker(char)
-     when LBrack;  long_marker(char)
-   else
-     str = peek + collect!(sym, Blank)
-     add str
-     add_token sym, str
-     grab
-   end
- end
-
- def double_marker(char)
-   sym = Syms[char]
-   kind = sym
-   case lookahead   # first char after **
-     when Space, LF, nil
-       pre, post = SimpleFormats[sym]
-       add_token kind
-     else
-       str = collect!(sym, Punc)
-       add_token kind, str
-       grab 
-   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
- end
-
- def collect_bracketed(sym, terminators)
-   str = Null.dup   # next is not " ","*","["
-   grab   # ZZZ
-   loop do
-     if peek == Escape
-       grab
-       str << grab
-       next
-     end
-     if terminate?(terminators, peek)
-       break 
-     end
-     str << peek    # not a terminator
-     grab
-   end
-
-   if peek == "]" # skip right bracket
-     grab 
-   end
-   add str
-   str
- rescue => err
-   ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
- end
-
- def escaped
-   grab        # Eat the backslash
-   ch = grab   # Take next char
-   ch
- end
-
- def collect!(sym, terminators, bracketed=nil)
-   return collect_bracketed(sym, terminators) if bracketed
-   str = Null.dup   # next is not " ","*","["
-   grab   # ZZZ
-   loop do
-     case
-     when peek.nil?
-       return str
-     when peek == Escape
-       str << escaped
-       next
-     when terminate?(terminators, peek)
-       break 
-     else
-       str << peek    # not a terminator
-     end
-     grab
-   end
-   ungrab
-   add str
-   str
- rescue => err
-   ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
- end
-
- def varsub(name)
-   live = Livetext.new
-   value = live.vars[name]
-   result = value || "[#{name} is undefined]"
-   result
- end
-
- def embedded?
-   ! (['"', "'", " ", nil].include? prev)
- end
-
-# private 
-
- def eval_bits(sym, val)
-# api.tty "eb: #{[sym, val].inspect}"
-   val = Livetext.interpolate(val)
-   @out << embed(sym, val)
- end
-
- def eval_func(val, gen)
-   param = nil
-   arg = gen.peek rescue :bogus
-   unless arg == :bogus
-     if [:colon, :brackets].include? arg[0] 
-       arg = gen.next  # for real
-       param = arg[1]
-       # FIXME - unsure - interpolate again??
-       # param = Livetext.interpolate(param)
-     end
-   end
-   str = funcall(val, param)
-   @out << str
- end
-
- def eval_var(val)
-   @out << varsub(val)
- end
-
- def eval_str(val)
-   @out << val unless val == "\n"   # BUG
- end
-
-end

data/test/snapshots/basic_formatting/actual-output.txt

@@ -1,13 +0,0 @@
-Here are examples of <b>boldface</b>
-and <i>italics</i>
-and <font size=+1><tt>code</tt></font>
-as well as <b>ore complex</b>*examples 
-of <i>talicized text</i>
-and <font size=+1><tt>ode font</tt></font>
-<p>
-
-Here are some random punctuation marks:
-; # . * * ` ` @ % ^ & $
-<p>
-
-No need to escape these:  * * `

data/test/snapshots/basic_formatting/err-sdiff.txt

@@ -1 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    

data/test/snapshots/basic_formatting/out-sdiff.txt

@@ -1,14 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    
-Here are examples of <b>boldface</b>                        | Here are examples of <b>boldface</b> 
-and <i>italics</i>                                            and <i>italics</i>
-and <font size=+1><tt>code</tt></font>                        and <font size=+1><tt>code</tt></font>
-as well as <b>ore complex</b>*examples                      | as well as <b>more complex</b> examples 
-of <i>talicized text</i>                                    | of <i>italicized text</i>
-and <font size=+1><tt>ode font</tt></font>                  | and <font size=+1><tt>code font</tt></font>.
-<p>                                                           <p>
-
-Here are some random punctuation marks:                       Here are some random punctuation marks:
-; # . * * ` ` @ % ^ & $                                     | ; # . * _ ` : @ % ^ & $
-<p>                                                           <p>
-
-No need to escape these:  * * `                             | No need to escape these:  * _ `

data/test/snapshots/error_inc_line_num/README.txt

@@ -1,20 +0,0 @@
----- File: source.lt3
-
-This is my 
-source file
-which includes file2 here:
-.include file2.lt3
-
-And here we are
-back in the
-original file.
-
---- File: file2.lt3
-
-  This is file2
-  which has an error
-  about an unknown command
-  in line 5
-.foobar
-
-  And this is file2 line 7.

data/test/snapshots/error_invalid_name/foo

@@ -1,5 +0,0 @@
-T
-a
-t
-<p>
-

data/test/snapshots/more_functions/actual-output.txt

@@ -1,37 +0,0 @@
-Testing some more functions here...
-<p>
-
-Here I am calling a function  with 
-a colon parameter...
-<p>
-
-<p>
-
-Next let's <b>do</b>*something with our parameter:
-<p>
-
-I'll call these variants...
-<p>
-
-"Motel" spelled backwards is letom :)
-<p>
-
-"lamina" reversed is animal
-<p>
-
-I can also use the erutaef tekcarb here.
-<p>
-
-If I don't use a parameter for [Error evaluating $$reverse()] - it gives
-me an error. (Bug or feature??)
-<p>
-
-What if a function doesn't use parameters at all, but
-we pass them? Hmm...
-<p>
-
-Now we succeed and succeed some more
-and finally we succeed in life.
-<p>
-
-But can we succeed, when our beds are burning?

data/test/snapshots/more_functions/err-sdiff.txt

@@ -1 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    

data/test/snapshots/more_functions/out-sdiff.txt

@@ -1,38 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    
-Testing some more functions here...                           Testing some more functions here...
-<p>                                                           <p>
-
-Here I am calling a function  with                            Here I am calling a function  with 
-a colon parameter...                                          a colon parameter...
-<p>                                                           <p>
-
-<p>                                                           <p>
-
-Next let's <b>do</b>*something with our parameter:          | Next let's <b>do</b> something with our parameter:
-<p>                                                           <p>
-
-I'll call these variants...                                   I'll call these variants...
-<p>                                                           <p>
-
-"Motel" spelled backwards is letom :)                         "Motel" spelled backwards is letom :)
-<p>                                                           <p>
-
-"lamina" reversed is animal                                   "lamina" reversed is animal
-<p>                                                           <p>
-
-I can also use the erutaef tekcarb here.                      I can also use the erutaef tekcarb here.
-<p>                                                           <p>
-
-If I don't use a parameter for [Error evaluating $$reverse(   If I don't use a parameter for [Error evaluating $$reverse(
-me an error. (Bug or feature??)                               me an error. (Bug or feature??)
-<p>                                                           <p>
-
-What if a function doesn't use parameters at all, but         What if a function doesn't use parameters at all, but
-we pass them? Hmm...                                          we pass them? Hmm...
-<p>                                                           <p>
-
-Now we succeed and succeed some more                          Now we succeed and succeed some more
-and finally we succeed in life.                               and finally we succeed in life.
-<p>                                                           <p>
-
-But can we succeed, when our beds are burning?                But can we succeed, when our beds are burning?

data/test/snapshots/simple_vars/actual-output.txt

@@ -1,6 +0,0 @@
-Just
-some text.
-Hi, there.
-GulliverFoyle is my name, and Terra is my nation.
-I'm GulliverFoyle, from Terra
-That's all.

data/test/snapshots/simple_vars/err-sdiff.txt

@@ -1 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    

data/test/snapshots/simple_vars/out-sdiff.txt

@@ -1,7 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    
-Just                                                          Just
-some text.                                                    some text.
-Hi, there.                                                    Hi, there.
-GulliverFoyle is my name, and Terra is my nation.             GulliverFoyle is my name, and Terra is my nation.
-I'm GulliverFoyle, from Terra                               | I'm GulliverFoyle, from Terra.
-That's all.                                                   That's all.

data/test/snapshots/var_into_func/actual-output.txt

@@ -1,16 +0,0 @@
-<p>
-
-Testing STILL more functions here...
-<p>
-
-<p>
-
-Now... let's try passing a variable to a function. Will this work??
-<p>
-
-Variable \regal is regal, which reversed is ahpla$
-<p>
-
-That's all.
-<p>
-

data/test/snapshots/var_into_func/err-sdiff.txt

@@ -1 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    

data/test/snapshots/var_into_func/out-sdiff.txt

@@ -1,17 +0,0 @@
-ACTUAL                                                      | EXPECTED                                                    
-<p>                                                           <p>
-
-Testing STILL more functions here...                          Testing STILL more functions here...
-<p>                                                           <p>
-
-<p>                                                           <p>
-
-Now... let's try passing a variable to a function. Will thi   Now... let's try passing a variable to a function. Will thi
-<p>                                                           <p>
-
-Variable \regal is regal, which reversed is ahpla$          | Variable $alpha is regal, which reversed is lager
-<p>                                                           <p>
-
-That's all.                                                   That's all.
-<p>                                                           <p>
-

data/test/testlines.rb

@@ -1,37 +0,0 @@
-require '../lib/livetext'
-require '../lib/formatline'
-
-  def red(str)
-    "" + str + ""
-  end
-
-input = ARGV.first || "test/data/lines.txt"
-data = File.readlines(input)
-
-pass = fail = 0
-data.each_slice(4).with_index do |lines, i|
-  title, input, expected, blank = *lines
-  lnum = i*4 + 1
-  input.chomp!
-  expected.chomp!
-  expected = eval(expected) if expected[0] == "/"
-  
-
-  actual = FormatLine.parse!(input)
-  if expected === actual
-    pass += 1
-#   puts "PASS:      #{title}"
-    next
-  end
-
-  fail += 1
-  puts "----------------------------- (line #{lnum})"
-  puts "Test:  #{title}"
-  puts "Input: #{input}"
-  puts "  #{red('FAIL Expected: ')} #{expected.inspect}"
-  puts "  #{red('     Actual  : ')} #{actual.inspect}"
-  puts 
-end
-
-puts
-puts "#{pass} passes   #{fail} fails"