livetext 0.9.10 → 0.9.15

data/lib/livetext.rb

@@ -1,34 +1,43 @@
+# Class Livetext skeleton (top level).
+
 class Livetext
-  VERSION = "0.9.10"
+  VERSION = "0.9.15"
   Path  = File.expand_path(File.join(File.dirname(__FILE__)))
 end
 
-require 'fileutils'
+# $LOAD_PATH << Livetext::Path
 
-$: << Livetext::Path
+require 'fileutils'
 
-require 'functions'
-require 'userapi'
-require 'standard'
-require 'formatline'
-require 'processor'
+require_relative 'errors'
+require_relative 'functions'
+require_relative 'userapi'
+require_relative 'standard'
+require_relative 'formatline'
+require_relative 'processor'
+require_relative 'helpers'
 
 Plugins = File.expand_path(File.join(File.dirname(__FILE__), "../plugin"))
 
 TTY = ::File.open("/dev/tty", "w")
 
+make_exception(:EndWithoutOpening, "Error: found .end with no opening command")
+
+# Class Livetext reopened (top level).
+
 class Livetext
+
+  include Helpers
+
   Vars = {}
 
+
   attr_reader :main
   attr_accessor :no_puts
   attr_accessor :body, :indentation
 
-  # FIXME - phase out stupid 'parameters' method
-
   class << self
-    attr_accessor :parameters  # from outside world (process_text)
-    attr_accessor :output      # both bad solutions?
+    attr_accessor :output      # bad solution?
   end
 
   def vars
@@ -41,30 +50,20 @@ class Livetext
     call = Array(call)
     mix.each {|lib| obj.mixin(lib) }
     call.each {|cmd| obj.main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| obj._setvar(var, val.to_s) }
+    vars.each_pair {|var, val| obj.setvar(var, val.to_s) }
     obj
   end
 
   def customize(mix: [], call: [], vars: {})
     mix  = Array(mix)
     call = Array(call)
+    # FIXME HF won't this break??
     mix.each {|lib| mixin(lib) }
     call.each {|cmd| @main.send(cmd[1..-1]) }  # ignores leading dot, no param
-    vars.each_pair {|var, val| _setvar(var, val.to_s) }
+    vars.each_pair {|var, val| setvar(var, val.to_s) }
     self
   end
 
-  Space = " "
-  Sigil = "." # Can't change yet
-
-  def self.rx(str, space=nil)
-    Regexp.compile("^" + Regexp.escape(str) + "#{space}")
-  end
-
-  Comment  = rx(Sigil, Livetext::Space)
-  Dotcmd   = rx(Sigil)
-  Ddotcmd  = /^ *\$\.[A-Za-z]/
-
   def initialize(output = ::STDOUT)
     @source = nil
     @_mixins = []
@@ -74,73 +73,17 @@ class Livetext
     @main = Processor.new(self, output)
     @indentation = [0]
     @_vars = Livetext::Vars
+    initial_vars
   end
 
-  def _parse_colon_args(args, hash)  # really belongs in livetext
-    h2 = hash.dup
-    e = args.each
-    loop do
-      arg = e.next.chop.to_sym
-      raise "_parse_args: #{arg} is unknown" unless hash.keys.include?(arg)
-      h2[arg] = e.next
-    end
-    h2 = h2.reject {|k,v| v.nil? }
-    h2.each_pair {|k, v| raise "#{k} has no value" if v.empty? }
-    h2
-  end
-
-  def _get_arg(name, args)  # really belongs in livetext
-    raise "(#{name}) Expected an array" unless args.is_a? Array
-    raise "(#{name}) Expected an arg" if args.empty?
-    raise "(#{name}) Too many args: #{args.inspect}" if args.size > 1
-    val = args[0]
-    raise "Expected an argument '#{name}'" if val.nil?
-    val
-  end
-
-  def mixin(mod)
-    @main._mixin(mod)
-  end
-
-  def _setvar(var, val)
-    str, sym = var.to_s, var.to_sym
-    Livetext::Vars[str] = val
-    Livetext::Vars[sym] = val
-    @_vars[str] = val
-    @_vars[sym] = val
-  end
-
-  def _setfile(file)
-    _setvar(:File, file)
-    dir = File.dirname(File.expand_path(file))
-    _setvar(:FileDir, dir)
-  end
-
-  def _setfile!(file)
-    _setvar(:File, file)
-  end
-
-  def process_line(line)  # FIXME inefficient?
-    nomarkup = true
-    case line  # must apply these in order
-      when Comment
-        handle_scomment(line)
-      when Dotcmd
-#       STDERR.puts "line = #{line.inspect}"
-        handle_dotcmd(line)
-      when Ddotcmd
-        indent = line.index("$") + 1
-        @indentation.push(indent)
-        line.sub!(/^ *\$/, "")
-        handle_dotcmd(line)
-        indentation.pop
-    else
-      @main._passthru(line)
-    end
+  def initial_vars
+    # Other predefined variables (see also setfile)
+    setvar(:User, `whoami`.chomp)
+    setvar(:Version, Livetext::VERSION)
   end
 
   def transform(text)
-    _setfile!("(string)")
+    setfile!("(string)")
     enum = text.each_line
     front = text.match(/.*?\n/).to_a.first.chomp rescue ""
     @main.source(enum, "STDIN: '#{front}...'", 0)
@@ -177,66 +120,5 @@ class Livetext
     self.body
   end
 
-## FIXME process_file[!] should call process[_text]
-
-  def process_file(fname, btrace=false)
-    _setfile(fname)
-    text = File.readlines(fname)
-    enum = text.each
-    @backtrace = btrace
-    @main.source(enum, fname, 0)
-    line = nil
-    loop do 
-      line = @main.nextline
-      break if line.nil?
-      process_line(line)
-    end
-    val = @main.finalize if @main.respond_to? :finalize
-    @body
-  rescue => err
-    STDERR.puts "[process_file] fname = #{fname.inspect}\n    line = #{line.inspect}"
-    STDERR.puts "ERROR #{err} in process_file"
-    err.backtrace.each {|x| STDERR.puts "   " + x }
-    @body = ""
-  end
-
-  def handle_scomment(line)
-  end
-
-  def _check_name(name)
-    @main._error! "Name '#{name}' is not permitted" if @main._disallowed?(name)
-    @main._error! "Mismatched 'end'" if name == "end"
-    name = "_" + name if %w[def include].include?(name)
-    name
-  end
-
-  def _get_name(line)
-    name, data = line.split(" ", 2)
-    name = name[1..-1]  # chop off sigil
-    @main.data = data
-    name = _check_name(name)
-  end
-
-  def handle_dotcmd(line, indent = 0)
-    indent = @indentation.last # top of stack
-    line = line.sub(/# .*$/, "")
-    name = _get_name(line).to_sym
-    result = nil
-    if @main.respond_to?(name)
-      result = @main.send(name)
-    else
-      @main._error! "Name '#{name}' is unknown"
-      return
-    end
-    result
-  rescue => err
-    STDERR.puts "Error was: #{err.inspect} (calling @main._error!)"
-    STDERR.puts err.backtrace
-    @main._error!(err)
-    # puts @body
-    @body = ""
-    return @body
-  end
-
 end
 

data/lib/parser/file.rb

@@ -0,0 +1,8 @@
+
+require_relative '../livetext'
+
+# Hmm. not today?
+
+class Livetext::ParseFile
+
+end

data/lib/parser/general.rb

@@ -0,0 +1,38 @@
+
+require_relative '../livetext'
+require_relative 'string'
+
+make_exception(:MismatchedQuotes, "Error: mismatched quotes")
+make_exception(:NilValue,         "Error: nil value")
+make_exception(:NullString,       "Error: null string")
+make_exception(:ExpectedString,   "Error: expected a string")
+
+class Livetext::ParseGeneral < StringParser
+
+  def initialize(str)
+    super
+  end
+
+  def strip_quotes
+    raise NullString if @line.empty?
+    start, stop = @line[0], @line[-1]
+    return @line unless %['"].include?(start)
+    raise MismatchedQuotes if start != stop
+    @line[1..-2]
+  end
+
+  def self.parse_vars(lines, prefix: nil)
+    lines.map! {|line| line.sub(/# .*/, "").strip }  # strip comments
+    pairs = []
+    lines.each do |line|
+      next if line.strip.empty?
+      var, value = line.split(" ", 2)
+      val = FormatLine.var_func_parse(value)
+      var = prefix + "." + var if prefix
+      pairs << [var, value]
+    end
+    pairs
+  end
+
+end
+

data/lib/parser/import.rb

@@ -0,0 +1,17 @@
+
+require '../livetext/importable'
+
+make_exception(:BadVariableName, "Error: invalid variable name")
+make_exception(:NoEqualSign,     "Error: no equal sign found")
+
+# FIXME probably belongs elsewhere?
+
+class Livetext::ParseImport
+  def use_import(name)
+    require name
+    include name
+    init = "init_#{name}"
+    self.send(init) if self.respond_to? init
+  end
+end
+

data/lib/parser/mixin.rb

@@ -0,0 +1,53 @@
+require_relative '../livetext'
+require_relative '../helpers'
+require_relative 'string'
+
+make_exception(:BadVariableName, "Error: invalid variable name")
+make_exception(:NoEqualSign,     "Error: no equal sign found")
+
+# FIXME probably belongs elsewhere?
+
+class Livetext::ParseMixin   # < StringParser
+
+  include Helpers
+
+  def initialize(name)
+    @name = name
+    @file = find_file(name)
+  end
+
+  def self.get_module(name)
+    parse = self.new(name)
+    modname, code = parse.read_mixin
+    eval(code)   # Avoid in the future
+    newmod = Object.const_get("::" + modname)
+    # return actual module
+    newmod
+  end
+
+  def read_mixin
+    modname = @name.gsub("/","_").capitalize
+    meths = grab_file(@file)
+    [modname, "module ::#{modname}; #{meths}\nend"]
+  end
+
+  private
+
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
+  def find_file(name, ext=".rb")
+    base = "./#{name}#{ext}"
+    file = "#{Plugins}/#{base}"
+    return file if File.exist?(file)
+
+    file = base
+    return file if File.exist?(file)
+
+    raise "No such mixin '#{name}'" if cwd_root?
+    Dir.chdir("..") { find_file(name) }
+  end
+
+end
+

data/lib/parser/set.rb

@@ -0,0 +1,145 @@
+
+require_relative '../livetext'
+require_relative 'string'
+
+make_exception(:BadVariableName, "Error: invalid variable name")
+make_exception(:NoEqualSign,     "Error: no equal sign found")
+
+class Livetext::ParseSet < StringParser
+
+  attr_reader :line, :eos, :i, :len
+
+  def self.parse(str)
+    self.new(str).parse
+  end
+
+  def initialize(line)
+    super
+  end
+
+  def wtf(note="")
+    TTY.puts "| PARSER: @i = #@i   @len = #@len"
+    TTY.puts "|#{note}"
+    TTY.puts "| [" + @line.gsub(" ", "_") + "]"
+    TTY.print "|  "    # 0-based (one extra space)
+    @i.times { TTY.print "-" }
+    TTY.puts "^"
+    TTY.puts
+  end
+
+  def parse
+    pairs = []
+    char = nil
+    loop do
+      break if eos?   # end of string
+      char = skip_spaces
+      raise "Expected alpha to start var name" unless char =~ /[a-z]/i
+      pairs << assignment
+      char = skip_spaces
+      break if eos?   # end of string
+      case char
+        when nil  # end of string
+        when ","
+          char = grab  # skip comma
+          char = skip_spaces
+      else
+        raise "Expected comma or end of string (found #{char.inspect})"
+      end
+    end
+    pairs
+  end
+
+  def assignment   # one single var=value
+    pair = nil
+    var = value = nil
+    return if eos?
+    var = get_var
+    skip_equal
+    value = get_value
+    value = FormatLine.var_func_parse(value)    # FIXME broken now?
+    pair = [var, value]
+    pair
+  end
+
+  def get_var
+    name = ""
+    loop do
+      char = peek
+      break if eos?   # end of string
+      case char
+        when /[a-zA-Z_\.0-9]/
+          name << grab
+          next
+        when /[ =]/
+          return name
+      else
+        raise BadVariableName, char, name
+      end
+    end
+    raise NoEqualSign
+  end
+
+  def skip_equal
+    found = false
+    skip_spaces
+    raise NoEqualSign unless peek == "="
+    found = true
+    grab         # skip =
+    skip_spaces  # skip spaces too
+    return peek  # just for testing
+  rescue StopIteration
+    raise NoEqualSign unless found
+    return nil
+  end
+
+  def escaped
+    grab   # skip backslash
+    grab   # return following char
+  end
+
+  make_exception(:BadQuotedString, "Bad quoted string: %1")
+
+  def quoted_value
+    quote = grab   # opening quote...
+    value = ""
+    char = nil
+    loop do
+      char = grab
+      break if eos?
+      break if char == quote
+#     break if char.nil?
+      char = escaped if char == "\\"
+      value << char
+    end
+    if char == quote
+      # char = grab
+      return value
+    end
+    raise BadQuotedString, quote + value
+  end
+
+  def unquoted_value
+    char = nil
+    value = ""
+    loop do
+      char = peek
+      break if eos?  #     FIXME oops???
+#     break if char.nil?
+      break if char == " " || char == ","
+      value << char
+      char = grab
+    end
+    value
+  end
+
+  def quote?(char)
+    char == ?" || char == ?'
+  end
+
+  def get_value
+    char = peek
+    value = quote?(char) ? quoted_value : unquoted_value
+    value
+  end
+end
+

data/lib/parser/string.rb

@@ -0,0 +1,70 @@
+class StringParser
+
+  attr_reader :line, :eos, :i, :len
+
+  def initialize(line)
+    raise NilValue if line.nil?
+    raise ExpectedString unless String === line
+    @line = line
+    @len = @line.length
+    @eos = @len == 0 ? true : false
+    @i = 0
+  end
+
+  def grab
+    return nil if @eos
+    char = @line[@i]
+    @i += 1
+    @eos = true if @i > @len
+    char
+  end
+
+  def ungrab
+    @i -= 1    # FIXME what about eos...?
+  end
+
+  def next!
+    @line[@i + 1]
+  end
+
+  def prev
+    return nil if @i <= 0
+    @line[@i-1]
+  end
+
+  def last?
+    @i > @len - 1
+  end
+
+  def eos?
+    @eos = true if last? # duh?
+    @eos
+  end
+
+  def peek
+    return nil if @eos
+    @line[@i]
+  end
+
+  def skip_spaces
+    char = nil
+    loop do
+      char = peek
+      break if eos?
+      break if char != " "
+      grab
+    end
+    char
+  end
+
+end
+
+=begin
+  skip
+  next! skip! peek!(?)
+  expect_alpha
+  expect_number
+  skip_spaces
+  expect_eos
+=end
+

data/lib/parser.rb

@@ -0,0 +1,5 @@
+
+require_relative 'parser/string'
+require_relative 'parser/general'
+require_relative 'parser/set'
+require_relative 'parser/mixin'

data/lib/processor.rb

@@ -1,21 +1,27 @@
+# Class Livetext is the actual top-level class.
+
 class Livetext
 
+  # Class Processor does the actual work of processing input.
+
   class Processor
+
+    GenericError = Class.new(StandardError)
+
     include Livetext::Standard
     include Livetext::UserAPI
 
-    Disallowed = [:nil?, :===, :=~, :!~, :eql?, :hash, :<=>, 
-                  :class, :singleton_class, :clone, :dup, :taint, :tainted?, 
-                  :untaint, :untrust, :untrusted?, :trust, :freeze, :frozen?, 
-                  :to_s, :inspect, :methods, :singleton_methods, :protected_methods, 
-                  :private_methods, :public_methods, :instance_variables, 
-                  :instance_variable_get, :instance_variable_set, 
-                  :instance_variable_defined?, :remove_instance_variable, 
-                  :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, 
-                  :respond_to?, :extend, :display, :method, :public_method, 
-                  :singleton_method, :define_singleton_method, :object_id, :to_enum, 
-                  :enum_for, :pretty_inspect, :==, :equal?, :!, :!=, :instance_eval, 
-                  :instance_exec, :__send__, :__id__, :__binding__]
+    Disallowed = %i[ !  !=  !~  <=>  ==  ===   =~         __binding__   __id__    __send__   class
+                     clone      define_singleton_method   display       dup      enum_for    eql?       
+                     equal?     extend      freeze        frozen?       hash     inspect     instance_eval          
+                     instance_exec          instance_of?  instance_variable_defined?         
+                     instance_variable_get  instance_variable_set       instance_variables   is_a?          
+                     kind_of?               method        methods       nil?                 object_id          
+                     pretty_inspect         private_methods             protected_methods    public_method          
+                     public_methods         public_send                 remove_instance_variable          
+                     respond_to?            send          singleton_class                    singleton_method          
+                     singleton_methods      taint         tainted?      tap                  to_enum          
+                     to_s                   trust         untaint       untrust              untrusted?]
 
     def initialize(parent, output = nil)
       @parent = parent
@@ -32,18 +38,14 @@ class Livetext
       @output = io
     end
 
-    def _error!(err, abort=true, trace=false)
+    def _error!(err, raise_error=false, trace=false)   # FIXME much bullshit happens here
       where = @sources.last || @save_location
-      # puts @parent.body
-      puts "[lib/processor] Error: #{err}"
-      puts err.backtrace.join("\n") if err.respond_to?(:backtrace)
-      STDERR.puts "[lib/processor] Error: #{err}"  #  (at #{where[1]} line #{where[2]})"
-      raise "lib/processor error!"
+      STDERR.puts "Error: #{err} (at #{where[1]} line #{where[2]})"
       STDERR.puts err.backtrace if err.respond_to?(:backtrace) # && trace
-      exit if abort
+      raise GenericError.new("Error: #{err}") if raise_error
     end
 
-    def _disallowed?(name)
+    def disallowed?(name)
       Disallowed.include?(name.to_sym)
     end
 
@@ -56,7 +58,7 @@ class Livetext
     rescue StopIteration
       @sources.pop
       nil
-    rescue 
+    rescue => err
       nil
     end
 
@@ -69,11 +71,5 @@ class Livetext
       @sources.pop
       nil
     end
-
-    def grab_file(fname)
-      File.read(fname)
-    end
-
   end
-
 end