livetext 0.9.25 → 0.9.30

data/lib/livetext/formatline.rb

@@ -1,321 +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?
-    x = self.new(line.chomp)
-    t = x.tokenize
-    x.evaluate
-  end
-
-  def tokenize
-    loop do 
-      case peek
-        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
-      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.handle_escaping 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.handle_escaping if char == Escape
-      x.dollar if char == "$"  # Could be $$
-      x.add char
-    end
-    x.add_token(:str)
-    result = x.evaluate
-    result
-  end
-
-  def handle_escaping
-    grab
-    add grab
-  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
-    grab
-    case peek
-      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 = peek + grab_alpha_dot
-        add_token(:var, var)
-    else 
-      add "$" + peek
-      add_token(:string)
-    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,84 +0,0 @@
-
-require_relative '../livetext'
-
-# Parse function calls
-
-module Livetext::FormatLine::FunCall
-
-  include Livetext::ParsingConstants
-
-  def param_loop(char)
-    param = ""
-    loop do
-      case lookahead
-        when Escape
-          param << escaped
-        when char, LF, nil
-          break
-      else
-        param << lookahead
-        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

data/test/snapshots/error_inc_line_num/OUT

@@ -1,17 +0,0 @@
-This is my 
-source file
-which includes file2 here:
-  This is file2
-  which has an error
-  about an unknown command
-  in line 5
-This is my 
-source file
-which includes file2 here:
-  This is file2
-  which has an error
-  about an unknown command
-  in line 5
-<p>
-
-  And this is file2 line 7.

data/test/snapshots/error_no_such_copy/duh

@@ -1,26 +0,0 @@
-####  
-self = 
-  #<Processor:0x00007fd5ec14d290 
-  @parent=#<Livetext:0x00007fd5ec14d358 
-        @source=nil, 
-        @_mixins=[], 
-        @_imports=[], 
-        @_outdir=".", 
-        @no_puts=false, 
-        @body="Make sure a\nnonexistent file with .copy\ngives an error.\n<p>\n\n", 
-        @main=#<Processor:0x00007fd5ec14d290 ...>, 
-              @indentation=[0], 
-              @_vars={"User"=>"Hal", :User=>"Hal", "Version"=>"0.9.24", :Version=>"0.9.24", 
-                      "File"=>"source.lt3", :File=>"source.lt3", 
-                      "FileDir"=>"/Users/Hal/Dropbox/topx/git/livetext/test/snapshots/error_no_such_copy", 
-                      :FileDir=>"/Users/Hal/Dropbox/topx/git/livetext/test/snapshots/error_no_such_copy"}, 
-            @backtrace=true>, 
-            @_nopass=false, 
-            @_nopara=false, 
-            @output=#<IO:<STDOUT>>, 
-            @sources=[[#<Enumerator: ["Make sure a", "nonexistent file with .copy", "gives an error.", "\n", ".copy nosuchfile.txt\n", "\n", "Nothing to\n", "see here.\n"]:each>, "source.lt3", 5]], 
-  @indentation=nil, 
-  @_mixins=[], 
-  @_imports=[], 
-  @_data="nosuchfile.txt", 
-  @_args=["nosuchfile.txt"]>

data/test/snapshots/error_no_such_copy/mystery.txt

@@ -1,36 +0,0 @@
-livetext:78:in `parse_command_line'
-livetext:78:in `loop'
-livetext:92:in `block in parse_command_line'
-helpers.rb:72:in `process_file'
-helpers.rb:72:in `loop'
-helpers.rb:75:in `block in process_file'
-helpers.rb:95:in `process_line'
-helpers.rb:124:in `handle_dotcmd'
-standard.rb:273:in `copy': Error: file 'nosuchfile.txt' not found (FileNotFound)
-
-
-parse_command_line
-process_file
-process_line
-handle_dotcmd
-copy
-
-
-
-
-livetext "main"     rescue unexpected
-process_file        ret Bool, print warning, rescue unex, no raise 
-process_line        ret Bool, no rescue, no raise   
-handle_dotcmd       ret Bool, no rescue, 2 custom exceptions
-copy                ret Bool, rescue only unexpected
-check_file_exists   returns Boolean, no rescue, no raise
-
-
-METHOD                RETURNS             RESCUE              RAISES              OTHER
--------------------   -----------------   -----------------   -----------------   -----------------   
-parse_command_line    nothing             only unexpected            
-process_file
-process_line
-handle_dotcmd
-copy
-

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"