livetext 0.9.26 → 0.9.31

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/lib/livetext/funcall.rb

@@ -1,168 +0,0 @@
-
-require_relative '../livetext'
-
-# Parse function calls
-
-module Livetext::LineParser::FunCall
-
-  include Livetext::ParsingConstants
-
-  def param_loop(char)
-    param = ""
-    loop do
-      case peek
-        when Escape
-          param << escaped
-        when char, LF, nil
-          break
-      else
-        param << grab
-      end
-    end
-    param = nil if param.empty?
-    param
-  end
-
-  def grab_colon_param
-    grab  # grab :
-    param = param_loop(Space)
-  end
-
-  def grab_bracket_param
-    grab # [
-    param = param_loop("]")
-    grab  # "]"
-    param
-  end
-
-  def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
-    result = 
-      if self.send?(name, param)
-        # do nothing
-      else
-        fobj = ::Livetext::Functions.new
-        fobj.send(name, param) rescue err
-      end
-    result.to_s
-  end
-
-  def grab_func_with_param
-    add_token(:str, @token)
-    func = grab_alpha
-    add_token(:func, func)
-    param = grab_func_param    # may be null/missing
-    param
-  end
-
-  def double_dollar
-    case peek
-      when Space;   add_token :string, "$$ "; grab
-      when LF, nil; add "$$ "; add_token :str
-      when Alpha;   param = grab_func_with_param
-      else          grab; add_token :str, "$$" + peek
-    end
-  end
-
-  def grab_func_param
-    case peek
-      when "["
-        param = grab_bracket_param
-        add_token(:brackets, param)
-      when ":"
-        param = grab_colon_param
-        add_token(:colon, param)
-    else  # do nothing
-    end
-  end
-
-  def escaped
-    grab        # Eat the backslash
-    ch = grab   # Take next char
-    ch
-  end
-
-end
-
-
-# FIXME...
-
-module Livetext::FormatLine::FunCall
-
-  include Livetext::ParsingConstants
-
-  def param_loop(char)
-    param = ""
-    loop do
-      case peek
-        when Escape
-          param << escaped
-        when char, LF, nil
-          break
-      else
-        param << peek
-        grab
-      end
-    end
-    param = nil if param.empty?
-    param
-  end
-
-  def grab_colon_param
-    grab  # grab :
-    param = param_loop(Space)
-  end
-
-  def grab_bracket_param
-    grab # [
-    param = param_loop("]")
-    grab  # "]"
-    param
-  end
-
-  def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
-    func_name = name  # "func_" + name.to_s
-    result = 
-      if self.send?(func_name, param)  # self.respond_to?(func_name)
-        # do nothing
-      else
-        fobj = ::Livetext::Functions.new
-        fobj.send(name, param) rescue err
-      end
-    result.to_s
-  end
-
-  def double_dollar
-    case lookahead
-      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)
-        param = grab_func_param    # may be null/missing
-      else
-        grab; add_token :str, "$$" + peek; return
-    end
-  end
-
-  def grab_func_param
-    case lookahead
-      when "["
-        param = grab_bracket_param
-        add_token(:brackets, param)
-      when ":"
-        param = grab_colon_param
-        add_token(:colon, param)
-    else  # do nothing
-    end
-  end
-
-  def escaped
-    grab        # Eat the backslash
-    ch = grab   # Take next char
-    ch
-  end
-
-end