livetext 0.9.23 → 0.9.26

data/imports/pyggish.rb

@@ -83,21 +83,21 @@ module Pyggish
   end
 
   def fragment
-    lang = @_args.empty? ? :elixir : @_args.first.to_sym   # ruby or elixir
-    @_args = []
+    lang = api.args.empty? ? :elixir : api.args.first.to_sym   # ruby or elixir
+    api.args = []
     send(lang)
-    _out "\n"
+    api.out "\n"
   end
 
   def code       # FIXME ?
     text = ""   
-    _body {|line| _out "    " + line }
+    api.body {|line| api.out "    " + line }
   end
 
   def mono
-    _out "<pre>"
-    _body {|line| _out "    " + line }
-    _out "</pre>"
+    api.out "<pre>"
+    api.body {|line| api.out "    " + line }
+    api.out "</pre>"
   end
 
   def create_code_styles
@@ -145,28 +145,28 @@ module Pyggish
   end
 
   def ruby
-    file = @_args.first 
+    file = api.args.first 
     if file.nil?
       code = "  # Ruby code\n\n"
-      _body {|line| code << "  " + line + "\n" }
+      api.body {|line| code << "  " + line + "\n" }
     else
       code = "# Ruby code\n\n" + ::File.read(file)
     end
 
     html = format_ruby(code)
-    _out html
+    api.out html
   end
 
   def elixir
-    file = @_args.first 
+    file = api.args.first 
     if file.nil?
       code = ""
-      _body {|line| code << "  " + line + "\n" }
+      api.body {|line| code << "  " + line + "\n" }
     else
       code = ::File.read(file)
     end
 
     html = format_elixir(code)
-    _out html
+    api.out html
   end
 end

data/imports/tutorial.rb

@@ -7,22 +7,22 @@ module Tutorial
 
   def title(args = nil, body = nil)
     h1
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def section(args = nil, body = nil)
     h3
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def code(args = nil, body = nil)
     first = true  # dumb hack! fixes blank space
-    _body do |line| 
+    api.body do |line| 
       tag, first = "<pre>", false if first
-      _out "#{tag}   #{escape_html(line)}"   # indentation
+      api.out "#{tag}   #{escape_html(line)}"   # indentation
     end
-    _out "</pre>"
-    _optional_blank_line
+    api.out "</pre>"
+    api.optional_blank_line
   end
 
   def rx(str)
@@ -30,14 +30,14 @@ module Tutorial
   end
 
   def inout(args = nil, body = nil)
-    src, out = _args
+    src, out = api.args
     t1 = ::File.readlines(src) rescue (abort "t1 = #{src}")
     t2 = ::File.readlines(out) rescue (abort "t2 = #{out}")
     # To pacify markdown for README (FIXME later)
     t1 = t1.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
     t2 = t2.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
 
-    _out <<-HTML
+    api.out <<-HTML
       <table width=80% cellpadding=4>
       <tr>
         <td width=50%><b>Input</b></td>
@@ -53,7 +53,7 @@ module Tutorial
       </tr>
       </table>
     HTML
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def put_table(src, exp)
@@ -62,7 +62,7 @@ module Tutorial
     t1 = t1.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
     t2 = t2.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
 
-    _out <<-HTML
+    api.out <<-HTML
       <font size=+1>
       <table width=80% cellpadding=4>
       <tr>
@@ -83,13 +83,13 @@ module Tutorial
   end
 
   def testcase(args = nil, body = nil)
-    name = _args.first
-    _out "\n<font size=+1><b>Test: </font><font size=+2><tt>#{name}</tt></font></b></h3><br>"
+    name = api.args.first
+    api.out "\n<font size=+1><b>Test: </font><font size=+2><tt>#{name}</tt></font></b></h3><br>"
     src, exp = "test/snapshots/#{name}/source.lt3", "test/snapshots/#{name}/expected-output.txt"
-    @_args = [src, exp]   # Better way to do this??
+    api.args = [src, exp]   # Better way to do this??
     put_table(src, exp)
-    _out "<br>"
-    _optional_blank_line
+    api.out "<br>"
+    api.optional_blank_line
   end
 end
 

data/lib/cmdargs.rb

@@ -1,4 +1,3 @@
-# p __FILE__
 
 require_relative 'livetext'
 
@@ -80,13 +79,13 @@ class Livetext::CmdData
   def check_num_args(num)
     num_range = /(\d{0,2})(\.\.)(\d{0,2})/   # Not "really" right...
     min, max = 0, 9999
-    md = num_range.match(@nargs).to_a
+    mdata = num_range.match(@nargs).to_a
     bad_args = nil
     case 
       when @nargs == ":N"          # arbitrary
         # max already set
-      when md[2] == ".."           # range: 4..6 1.. ..4
-        vmin, vmax = md.values_at(1, 2)
+      when mdata[2] == ".."           # range: 4..6 1.. ..4
+        vmin, vmax = mdata.values_at(1, 2)
         min = Integer(vmin) unless vmin.empty?
         max = Integer(vmax) unless vmax.empty?
         min, max = Integer(min), Integer(max)
@@ -100,4 +99,8 @@ class Livetext::CmdData
     raise "Expected #{num} args but found #{@args.size}!" if bad_args
   end
 
+  def strip_comments(str)
+    str.sub!(/ # .*/, "")
+  end
+
 end

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

@@ -1,5 +1,3 @@
-# p __FILE__
-
 
 # More later?
 
@@ -10,8 +8,11 @@ def make_exception(sym, str, target_class = Object)
   define_method(sym) do |*args|
     args = [] unless args.first
     msg = str.dup
-    args.each.with_index {|arg, i| msg.sub!("%#{i+1}", arg) }
+    args.each.with_index {|arg, i| msg.sub!("%#{i+1}", arg.to_s) }
     target_class.class_eval(klass.to_s).new(msg)
   end
 end
 
+make_exception(:EndWithoutOpening, "Error: found .end with no opening command")
+make_exception(:UnknownMethod,     "Error: name '%1' is unknown")
+

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

@@ -1,4 +1,3 @@
-# p __FILE__
 
 require_relative 'parsing'
 require_relative 'funcall'
@@ -21,15 +20,21 @@ class Livetext::FormatLine < StringParser
 
   def self.parse!(line)
     return nil if line.nil?
-    x = self.new(line.chomp)
+    line.chomp!
+    x = self.new(line)
+::Livetext::TTY.puts "\n-- string: #{line.inspect}" if $testme
     t = x.tokenize
-    x.evaluate
+::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
-#   add grab
     loop do 
-      case peek
+      ch = peek
+::Livetext::TTY.puts "\n-- #{__method__}: ch1 = #{ch.inspect}\n " if $testme
+      case ch
         when Escape; grab; add peek; grab
         when "$"
           dollar
@@ -37,7 +42,65 @@ class Livetext::FormatLine < StringParser
           marker peek
           add peek
         when LF
-          break if eos?  # @i >= line.size - 1
+          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
@@ -57,6 +120,20 @@ class Livetext::FormatLine < StringParser
     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)
@@ -64,7 +141,7 @@ class Livetext::FormatLine < StringParser
     loop do
       char = x.grab
       break if char == LF || char == nil
-      x.handle_escaping if char == Escape
+      x.escaped if char == Escape
       x.dollar if char == "$"  # Could be $$
       x.add char
     end
@@ -73,9 +150,20 @@ class Livetext::FormatLine < StringParser
     result
   end
 
-  def handle_escaping
-    grab
-    add grab
+  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)
@@ -139,20 +227,31 @@ class Livetext::FormatLine < StringParser
   end
 
   def dollar
-    grab
-    case peek
-      when LF;  add "$";  add_token :str
-      when " "; add "$ "; add_token :str
-      when nil; add "$";  add_token :str
+    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 
-      add "$" + peek
-      add_token(:string)
+      ch = grab         # "$"
+::Livetext::TTY.puts "\n-- ch3 = #{ch.inspect}\n  self = #{self.inspect}" if $testme
+      add "$" + ch 
+      add_token(:str)
     end
   end
 
@@ -267,7 +366,9 @@ class Livetext::FormatLine < StringParser
   end
 
   def varsub(name)
-    result = Livetext::Vars[name] || "[#{name} is undefined]"
+    live = Livetext.new
+    value = live.vars[name]
+    result = value || "[#{name} is undefined]"
     result
   end
 

data/lib/livetext/funcall.rb

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

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

@@ -1,5 +1,3 @@
-# p __FILE__
-
 
 # Class Functions is where '$$func' functions are stored dynamically... 
 # user-def AND pre-def??

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

@@ -1,14 +1,13 @@
-# p __FILE__
-
 
 module GlobalHelpers
 
   def check_disallowed(name)
+api.tty "GLOBAL cdis"
     raise DisallowedName(name) if disallowed?(name)
   end
 
   def check_file_exists(file)
-    raise FileNotFound(file) unless File.exist?(file)
+    graceful_error FileNotFound(file) unless File.exist?(file)
   end
 
   def grab_file(fname)
@@ -36,4 +35,8 @@ module GlobalHelpers
 	  return nil
   end
 
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
 end

data/lib/{handler → livetext/handler}/import.rb

@@ -1,6 +1,7 @@
 
 require_relative '../helpers'
-require_relative '../global_helpers'
+
+# Handle a .import
 
 class Livetext::Handler::Import
   include Livetext::Helpers
@@ -24,21 +25,16 @@ class Livetext::Handler::Import
     name
   end
 
-  def self.get_module(filename)
+  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
-# TTY.puts "modname = #{modname.inspect}"
     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,33 @@
+
+require_relative '../helpers'
+
+# Handle a .mixin
+
+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
+
+end
+

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

@@ -1,3 +1,3 @@
-# p __FILE__
 
 require_relative 'handler/import'
+require_relative 'handler/mixin'