livetext 0.9.26 → 0.9.27

data/lib/livetext/formatline.rb

@@ -1,408 +0,0 @@
-
-require_relative 'parsing'
-require_relative 'funcall'
-
-# Class FormatLine handles the parsing of comments, dot commands, and 
-# simple formatting characters.
-
-class Livetext::FormatLine < StringParser
-  include Livetext::ParsingConstants
-  include Livetext::FormatLine::FunCall
-
-  attr_reader :out
-  attr_reader :tokenlist
-
-  def initialize(line)
-    super
-    @token = Null.dup
-    @tokenlist = []
-  end
-
-  def self.parse!(line)
-    return nil if line.nil?
-    line.chomp!
-    x = self.new(line)
-::Livetext::TTY.puts "\n-- string: #{line.inspect}" if $testme
-    t = x.tokenize
-::Livetext::TTY.puts "\n-- Tokens: #{t.inspect}" if $testme
-    result = x.evaluate
-::Livetext::TTY.puts "\n-- result: #{result.inspect}\n " if $testme
-    result
-  end
-
-  def tokenize
-    loop do 
-      ch = peek
-::Livetext::TTY.puts "\n-- #{__method__}: ch1 = #{ch.inspect}\n " if $testme
-      case ch
-        when Escape; grab; add peek; grab
-        when "$"
-          dollar
-        when "*", "_", "`", "~"
-          marker peek
-          add peek
-        when LF
-          break if eos?
-        when nil
-          break
-        else
-          add peek
-      end
-      ch = grab
-#     add ch
-::Livetext::TTY.puts "\n-- #{__method__}: !!! ch2 = #{ch.inspect}\n " if $testme
-    end
-    add_token(:str)
-    @tokenlist
-  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.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 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 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 = Null.dup
-    grab
-    loop do
-      break if eos?
-      str << peek
-      break if terminate?(NoAlpha, lookahead)
-      grab
-    end
-    str
-  end
-
-  def grab_alpha_dot
-    str = Null.dup
-    grab
-    loop do
-      break if peek.nil?   # eos?
-      str << peek
-      break if terminate?(NoAlphaDot, lookahead)
-      grab
-    end
-    str
-  end
-
-  def dollar
-    ch = grab         # "$"
-::Livetext::TTY.puts "\n-- #{__method__}: ch1 = #{ch.inspect}\n  self = #{self.inspect}" if $testme
-    ch = peek
-::Livetext::TTY.puts "\n-- #{__method__}: ch2 = #{ch.inspect}\n  self = #{self.inspect}" if $testme
-    case ch
-      when " "
-::Livetext::TTY.puts "\n-- #{__method__}: (space)" if $testme
-        add "$ "
-        add_token :str
-      when LF, nil
-::Livetext::TTY.puts "\n-- #{__method__}: (LF/nil)" if $testme
-        add "$"
-        add_token :str
-      when "$"; double_dollar
-#     when "."; dollar_dot
-      when /[A-Za-z]/
-::Livetext::TTY.puts "\n-- #{__method__}: (Alpha)" if $testme
-        add_token :str
-        var = peek + grab_alpha_dot
-        add_token(:var, var)
-    else 
-      ch = grab         # "$"
-::Livetext::TTY.puts "\n-- ch3 = #{ch.inspect}\n  self = #{self.inspect}" if $testme
-      add "$" + ch 
-      add_token(:str)
-    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 peek
-      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
-      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)
-    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
-    @out << funcall(val, param)
-  end
-
-  def eval_var(val)
-    @out << varsub(val)
-  end
-
-  def eval_str(val)
-    @out << val unless val == "\n"   # BUG
-  end
-
-end

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/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"