livetext 0.9.23 → 0.9.26

data/lib/{helpers.rb → livetext/helpers.rb}

@@ -1,5 +1,5 @@
-# p __FILE__
 
+require_relative 'global_helpers'
 
 module Livetext::Helpers
 
@@ -9,6 +9,14 @@ module Livetext::Helpers
   ESCAPING = { "'" => ''', '&' => '&', '"' => '"',
                '<' => '&lt;', '>' => '&gt;' }
 
+  def friendly_error(err)
+    return graceful_error(err) if self.respond_to?(:graceful_error)
+    return self.parent.graceful_error(err) if self.respond_to?(:parent)
+    raise err
+  rescue => myerr
+    TTY.puts "--- Warning: friendly_error #{myerr.inspect}"
+  end
+
   def escape_html(string)
     enc = string.encoding
     unless enc.ascii_compatible?
@@ -25,34 +33,47 @@ module Livetext::Helpers
     string.gsub(/['&\"<>]/, ESCAPING)
   end
 
+  def showme(obj, tag = "")
+    whence = caller[0]
+    file, line, meth = whence.split(":")
+    file = File.basename(file)
+    meth = meth[4..-2]
+    tag << " =" if tag
+    hide_class = [true, false, nil].include?(obj)
+    klass = hide_class ? "" : "(#{obj.class}) "
+    puts " #{tag} #{klass}#{obj.inspect}  in ##{meth}  [#{file} line #{line}]"
+  end
+
+  def debug(*args)
+    puts(*args) if ENV['debug']
+  end
+
   def find_file(name, ext=".rb", which="imports")
     failed = "#{__method__}: expected 'imports' or 'plugin'"
     raise failed unless %w[imports plugin].include?(which)
-    paths = [Livetext::Path.sub(/lib/, "#{which}/"), "./"]
+    paths = [Livetext::Path.sub(/lib.livetext/, "#{which}/"), "./"]
     base  = "#{name}#{ext}"
     paths.each do |path|
       file = path + base
+::Livetext::TTY.puts  "   Checking: #{file}"
       return file if File.exist?(file)
     end
-
-    raise "No such mixin '#{name}'"
-
-    # # Really want to search upward??
-    # raise "No such mixin '#{name}'" if cwd_root?
-    # Dir.chdir("..") { find_file(name) }
+::Livetext::TTY.puts  "   ...oops"
+    return nil
   end
 
   def self.rx(str, space=nil)
     Regexp.compile("^" + Regexp.escape(str) + "#{space}")
   end
 
-  Comment  = rx(Sigil, Space)
-  Dotcmd   = rx(Sigil)
-  Ddotcmd  = /^ *\$\.[A-Za-z]/
+  Comment   = rx(Sigil, Space)
+  DotCmd    = rx(Sigil)
+  DollarDot = /^ *\$\.[A-Za-z]/
 
-## FIXME process_file[!] should call process[_text]
+## FIXME process_file[!] should call process[_text] ?
 
   def process_file(fname, btrace=false)
+    graceful_error FileNotFound(fname) unless File.exist?(fname)
     setfile(fname)
     text = File.readlines(fname)
     enum = text.each
@@ -62,77 +83,64 @@ module Livetext::Helpers
     loop do
       line = @main.nextline
       break if line.nil?
-      process_line(line)
+      success = process_line(line)
+      break unless success
     end
     val = @main.finalize rescue nil
     @body    # FIXME?   @body.join("\n")  # array
-  rescue StandardError => err
-# TTY.puts ">>> rescue in process_file!! (helpers)"
-#     TTY.puts @body
-    raise err
+    return true
   end
 
   def process_line(line)
-    nomarkup = true
+    success = true
     case line  # must apply these in order
-      when Comment
-        handle_scomment(line)
-      when Dotcmd
-        handle_dotcmd(line)
-      when Ddotcmd
-        indent = line.index("$") + 1
-        @indentation.push(indent)
-        line.sub!(/^ *\$/, "")
-        handle_dotcmd(line)
-        indentation.pop
+    when Comment
+      success = handle_scomment(line)
+    when DotCmd
+      success = handle_dotcmd(line)
+    when DollarDot
+      success = handle_dollar_dot
     else
-      @main._passthru(line)
+      api.passthru(line)  # must succeed?
     end
+    success
+  end
+
+  def handle_dollar_dot
+    indent = line.index("$") + 1
+    @indentation.push(indent)
+    line.sub!(/^ *\$/, "")
+    success = handle_dotcmd(line)
+    indentation.pop
+    success
+  end
+
+  def invoke_dotcmd(name)
+    # FIXME Add cmdargs stuff... depends on name, etc.
+    retval = @main.send(name)
+    retval
+  rescue => err
+    graceful_error(err)
   end
 
   def handle_dotcmd(line, indent = 0)
     indent = @indentation.last # top of stack
-    line = line.sub(/# .*$/, "")
-    name = get_name(line).to_sym
-    result = nil
+    line = line.sub(/# .*$/, "")   # FIXME Could be problematic?
+    name = get_name(line)
+    success = true  # Be optimistic...  :P
     case
       when name == :end   # special case
-        puts @body
-        raise EndWithoutOpening()
+        graceful_error EndWithoutOpening()
       when @main.respond_to?(name)
-        result = @main.send(name)
-
-        # NOTE: The above line is where the magic happens!
-        # A name like 'foobar' results in an invocation of
-        # @main.foobar (where @main is a Processor, and any
-        # new methods (e.g. from a mixin) are added to @main
-        #
-        # So all the functionality from _args and _raw_args
-        # and _data (among others?) will be encapsulated in
-        # 'some' kind of PORO which handles access to all
-        # these things as well as the 'body' between the
-        # command and its corresponding .end
-        #
-        # The 'body' functionality is so commonly used, I plan
-        # to pass it in separately as needed (even though the
-        # args object should make it available also).
-        #
-        # Every method corresponding to a dot commmand will
-        # get args and body passed in as needed. Every one of
-        # the signatures already has (args = nil, body = nil)
-        # but nothing is being passed in that way yet.
-        #
-        # Refer to lib/cmdargs.rb for more! This is *strictly*
-        # experimental and a "work in progress."
+        success = invoke_dotcmd(name)
     else
-      puts @body  # earlier correct output, not flushed yet
-      raise "Name '#{name}' is unknown"
-      return
+      graceful_error UnknownMethod(name)
     end
-    result
+    success
   end
 
   def handle_scomment(line)
+    return true
   end
 
   def get_name(line)
@@ -141,15 +149,16 @@ module Livetext::Helpers
     name = "dot_" + name if %w[include def].include?(name)
     @main.check_disallowed(name)
     @main.data = data
-    name
+    @main.api.data = data
+    name.to_sym
   end
 
   def check_disallowed(name)
-    raise DisallowedName(name) if disallowed?(name)
+    friendly_error DisallowedName(name) if disallowed?(name)
   end
 
   def check_file_exists(file)
-    raise FileNotFound(file) unless File.exist?(file)
+    return File.exist?(file)
   end
 
   def set_variables(pairs)
@@ -161,6 +170,9 @@ module Livetext::Helpers
 
   def grab_file(fname)
     File.read(fname)
+  rescue
+    ::STDERR.puts "Can't find #{fname.inspect} \n "
+	  return nil
   end
 
   def search_upward(file)
@@ -185,7 +197,7 @@ module Livetext::Helpers
   end
 
   def include_file(file)
-    @_args = [file]
+    api.args = [file]
     dot_include
   end
 

data/lib/{html.rb → livetext/html.rb}

@@ -1,4 +1,3 @@
-# p __FILE__
 
 module HTMLHelper
 
@@ -17,9 +16,9 @@ module HTMLHelper
 
   def wrap(*tags)     # helper
     open, close = open_close_tags(*tags)
-    _out open
+    api.out open
     yield
-    _out close
+    api.out close
   end
 
   def open_close_tags(*tags)

data/lib/livetext/lineparser.rb

@@ -0,0 +1,441 @@
+
+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