livetext 0.9.21 → 0.9.25

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

@@ -1,6 +1,4 @@
 
-require_relative 'standard'  # FIXME  umm, why is this necessary??
-
 # Class Functions is where '$$func' functions are stored dynamically... 
 # user-def AND pre-def??
 
@@ -13,6 +11,21 @@ class Livetext::Functions
     attr_accessor :param   # kill this?
   end
 
+# FIXME Function parameters need to be fixed...
+
+  def isqrt(param = nil)      # "integer square root" - Just for testing
+    arg = num = param         #  Takes any number
+    if num.nil? || num.empty?
+      arg = "NO PARAM"        # Just for error text
+    end
+    # Integer()/Float() can raise error
+    num = num.include?(".") ? Float(num) : Integer(num)   
+    # Returns truncated integer
+    Math.sqrt(num).to_i       # user need not do to_s
+  rescue => err               # Malformed number? negative?
+    "[Error evaluating $$isqrt(#{arg})]"
+  end
+
   def date(param=nil)
     Time.now.strftime("%F")
   end
@@ -40,7 +53,7 @@ class Livetext::Functions
     "<br>"*n
   end
 
-  def yt(param)
+  def yt(param)   # FIXME uh, this is crap
     param = self.class.param
     "https://www.youtube.com/watch?v=#{param}"
   end

data/lib/livetext/global_helpers.rb

@@ -0,0 +1,37 @@
+
+module GlobalHelpers
+
+  def check_disallowed(name)
+    raise DisallowedName(name) if disallowed?(name)
+  end
+
+  def check_file_exists(file)
+    graceful_error FileNotFound(file) unless File.exist?(file)
+  end
+
+  def grab_file(fname)
+    File.read(fname)
+  end
+
+  def search_upward(file)
+    value = nil
+    return file if File.exist?(file)
+
+    count = 1
+    loop do
+      front = "../" * count
+      count += 1
+      here = Pathname.new(front).expand_path.dirname.to_s
+      break if here == "/"
+      path = front + file
+      value = path if File.exist?(path)
+      break if value
+    end
+    ::STDERR.puts "Cannot find #{file.inspect} from #{Dir.pwd}" unless value
+	  return value
+  rescue
+    ::STDERR.puts "Can't find #{file.inspect} from #{Dir.pwd}"
+	  return nil
+  end
+
+end

data/lib/livetext/handler/import.rb

@@ -0,0 +1,44 @@
+
+require_relative '../helpers'
+
+class Livetext::Handler::Import
+  include Livetext::Helpers
+  include GlobalHelpers
+
+  attr_reader :file
+
+  def initialize(name)
+    @name = name
+    @file = find_file(name)
+  end
+
+  def self.get_mod_name
+    file = File.new(@file + ".rb")
+    str = nil
+    file.each_line do |line| 
+      str = line
+      break if str =~ /^module /
+    end
+    junk, name, junk2 = str.split
+    name
+  end
+
+  def self.get_module(filename, parent)
+# TTY.puts "#{__method__}: filename = #{filename.inspect}"
+    handler = self.new(filename)
+    parent.graceful_error FileNotFound(filename) if handler.file.nil?
+    @file = handler.file.sub(/.rb$/, "")
+    require @file   # + ".rb"
+    modname = get_mod_name
+    newmod = Object.const_get("::" + modname)
+    newmod   # return actual module
+  end
+
+  private
+
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
+end
+

data/lib/livetext/handler/mixin.rb

@@ -0,0 +1,37 @@
+
+require_relative '../helpers'
+
+class Livetext::Handler::Mixin
+  include Livetext::Helpers
+  include GlobalHelpers
+
+  attr_reader :file
+
+  def initialize(name, parent)
+    @name = name
+    @file = find_file(name, ".rb", "plugin")
+    parent.graceful_error FileNotFound(name) if @file.nil?
+  end
+
+  def self.get_module(filename, parent)
+    handler = self.new(filename, parent)
+    modname, code = handler.read_mixin
+    eval(code)   # Avoid in the future
+    newmod = Object.const_get("::" + modname)
+    newmod   # return actual module
+  end
+
+  def read_mixin
+    modname = @name.gsub("/","_").capitalize
+    meths = grab_file(@file)  # already has .rb?
+    [modname, "module ::#{modname}; #{meths}\nend"]
+  end
+
+  private
+
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
+end
+

data/lib/livetext/handler.rb

@@ -0,0 +1,3 @@
+
+require_relative 'handler/import'
+require_relative 'handler/mixin'

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

@@ -1,5 +1,7 @@
 
-module Helpers
+require_relative 'global_helpers'
+
+module Livetext::Helpers
 
   Space = " "
   Sigil = "." # Can't change yet
@@ -7,6 +9,14 @@ module 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?
@@ -23,108 +33,115 @@ module Helpers
     string.gsub(/['&\"<>]/, ESCAPING)
   end
 
-  def find_file(name, ext=".rb")
-    paths = [Livetext::Path.sub(/lib/, "imports/"), "./"]
+  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.livetext/, "#{which}/"), "./"]
     base  = "#{name}#{ext}"
     paths.each do |path|
       file = path + base
       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) }
+    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
     @backtrace = btrace
     @main.source(enum, fname, 0)
     line = nil
-    loop do 
+    loop do
       line = @main.nextline
       break if line.nil?
-      process_line(line)
+      success = process_line(line)
+      break unless success
     end
-    val = @main.finalize if @main.respond_to? :finalize
-    @body
+    val = @main.finalize rescue nil
+    @body    # FIXME?   @body.join("\n")  # array
+    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
+        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 NoMethodError => err
+#   graceful_error(err)
+  rescue => err
+    graceful_error(err)
   end
 
   def handle_dotcmd(line, indent = 0)
+#   TTY.puts ">>> #{__method__} in #{__FILE__}" #  if ENV['debug']
     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)
@@ -133,15 +150,17 @@ module 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)
+#   raise FileNotFound(file) unless File.exist?(file)
+     return File.exist?(file)
   end
 
   def set_variables(pairs)
@@ -153,6 +172,9 @@ module Helpers
 
   def grab_file(fname)
     File.read(fname)
+  rescue
+    ::STDERR.puts "Can't find #{fname.inspect} \n "
+	  return nil
   end
 
   def search_upward(file)
@@ -169,15 +191,15 @@ module Helpers
       value = path if File.exist?(path)
       break if value
     end
-    STDERR.puts "Cannot find #{file.inspect} from #{Dir.pwd}" unless value
+    ::STDERR.puts "Cannot find #{file.inspect} from #{Dir.pwd}" unless value
 	  return value
   rescue
-    STDERR.puts "Can't find #{file.inspect} from #{Dir.pwd}"
+    ::STDERR.puts "Can't find #{file.inspect} from #{Dir.pwd}"
 	  return nil
   end
 
   def include_file(file)
-    @_args = [file]
+    api.args = [file]
     dot_include
   end
 

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

@@ -1,3 +1,4 @@
+
 module HTMLHelper
 
   def wrapped(str, *tags)   # helper
@@ -15,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/{parser → livetext/parser}/general.rb

@@ -1,7 +1,4 @@
 
-require_relative '../livetext'
-require_relative 'string'
-
 make_exception(:MismatchedQuotes, "Error: mismatched quotes")
 make_exception(:NilValue,         "Error: nil value")
 make_exception(:NullString,       "Error: null string")

data/lib/{parser → livetext/parser}/set.rb

@@ -1,7 +1,4 @@
 
-require_relative '../livetext'
-require_relative 'string'
-
 make_exception(:BadVariableName, "Error: invalid variable name")
 make_exception(:NoEqualSign,     "Error: no equal sign found")
 
@@ -107,7 +104,6 @@ class Livetext::ParseSet < StringParser
       char = grab
       break if eos?
       break if char == quote
-#     break if char.nil?
       char = escaped if char == "\\"
       value << char
     end
@@ -123,8 +119,7 @@ class Livetext::ParseSet < StringParser
     value = ""
     loop do
       char = peek
-      break if eos?  #     FIXME oops???
-#     break if char.nil?
+      break if eos?
       break if char == " " || char == ","
       value << char
       char = grab

data/lib/{parser → livetext/parser}/string.rb

@@ -24,7 +24,7 @@ class StringParser
     check_eos
   end
 
-  def next!
+  def lookahead
     @line[@i + 1]
   end
 
@@ -62,7 +62,7 @@ end
 
 =begin
   skip
-  next! skip! peek!(?)
+  lookahead skip! peek!(?)
   expect_alpha
   expect_number
   skip_spaces

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

@@ -2,4 +2,3 @@
 require_relative 'parser/string'
 require_relative 'parser/general'
 require_relative 'parser/set'
-require_relative 'parser/mixin'

data/lib/livetext/parsing.rb

@@ -0,0 +1,29 @@
+
+# Constants for parsing
+
+module Livetext::ParsingConstants
+  SimpleFormats     = {}
+  SimpleFormats[:b] = %w[<b> </b>]
+  SimpleFormats[:i] = %w[<i> </i>]
+  SimpleFormats[:t] = ["<font size=+1><tt>", "</tt></font>"]
+  SimpleFormats[:s] = %w[<strike> </strike>]
+
+  BITS = SimpleFormats.keys
+ 
+  Null   = ""
+  Space  = " "
+  Alpha  = /[A-Za-z]/
+  AlNum  = /[A-Za-z0-9_]/
+  LF     = "\n"
+  LBrack = "["
+
+  Blank   = [" ", nil, "\n"]
+  Punc    = [")", ",", ".", " ", "\n"]
+  NoAlpha = /[^A-Za-z0-9_]/
+  NoAlphaDot = /[^.A-Za-z0-9_]/
+  Param   = ["]", "\n", nil]
+  Escape  = "\\"   # not an ESC char
+
+  Syms = { "*" => :b, "_" => :i, "`" => :t, "~" => :s }
+
+end

data/lib/livetext/paths.rb

@@ -0,0 +1,13 @@
+# Reopening for paths... do differently?
+
+class Livetext
+  def self.get_path(dir = "")
+    path = File.join(File.dirname(__FILE__), dir)
+    File.expand_path(path)
+  end
+
+  Path    = self.get_path
+  Plugins = self.get_path("../plugin")
+  Imports = self.get_path("../imports")
+end
+

data/lib/livetext/processor.rb

@@ -0,0 +1,89 @@
+
+# Class Processor does the actual work of processing input.
+
+class Processor
+
+  GenericError = Class.new(StandardError)
+
+  include Livetext::Standard
+
+  Disallowed = 
+     %i[ __binding__        __id__            __send__          class
+         clone              display           dup               enum_for
+         eql?               equal?            extend            freeze
+         frozen?            hash              inspect           instance_eval   
+         instance_exec      instance_of?      is_a?             kind_of?
+         method             methods           nil?              object_id          
+         pretty_inspect     private_methods   protected_methods public_method
+         public_methods     public_send       respond_to?       send
+         singleton_class    singleton_method  singleton_methods taint
+         tainted?           tap               to_enum           to_s
+         trust              untaint           untrust           untrusted?
+         define_singleton_method              instance_variable_defined?
+         instance_variable_get                instance_variable_set
+         remove_instance_variable             instance_variables ]
+
+  attr_reader :parent, :sources
+
+  def initialize(parent, output = nil)
+    @parent = parent
+    @nopass = false
+    @nopara = false
+    # Meh?
+    @output = ::Livetext.output = (output || File.open("/dev/null", "w"))
+    @sources = []
+    @indentation = @parent.indentation
+    @_mixins = []
+    @_imports = []
+  end
+
+  def api
+    @parent.api   # FIXME Is this weird??
+  end
+
+  def output=(io)
+    @output = io
+  end
+
+  def error(*args)
+    ::STDERR.puts *args
+  end
+
+  def _error!(err, raise_error=false, trace=false)   # FIXME much bullshit happens here
+    where = @sources.last || @live.save_location
+    error "Error: #{err} (at #{where[1]} line #{where[2]})"
+    error(err.backtrace) rescue nil
+    raise GenericError.new("Error: #{err}") if raise_error
+  end
+
+  def disallowed?(name)
+    Disallowed.include?(name.to_sym)
+  end
+
+  def source(enum, file, line)
+    @sources.push([enum, file, line])
+  end
+
+  def peek_nextline
+    return nil if @sources.empty?
+    source = @sources.last
+    line = source[0].peek
+    line
+  rescue StopIteration
+    @sources.pop
+    nil
+  rescue => err
+    TTY.puts "#{__method__}: RESCUE err = #{err.inspect}"
+    nil
+  end
+
+  def nextline
+    return nil if @sources.empty?
+    line = @sources.last[0].next
+    @sources.last[2] += 1
+    line
+  rescue StopIteration
+    @sources.pop
+    nil
+  end
+end

data/lib/livetext/reopen.rb

@@ -0,0 +1,12 @@
+# Reopen for convenience... do differently
+
+class Object
+  def send?(meth, *args)
+    if self.respond_to?(meth)
+      self.send(meth, *args)
+    else
+      return nil
+    end
+  end
+end
+

data/lib/livetext/skeleton.rb

@@ -0,0 +1,17 @@
+require_relative 'parser/string'    # FIXME eh, should fix this
+
+# Class Livetext skeleton (top level).
+
+class Livetext
+  module Handler
+  end
+
+  module ParsingConstants
+  end
+
+  class FormatLine < StringParser
+    module FunCall
+    end
+  end
+end
+