livetext 0.9.21 → 0.9.25

data/imports/pyggish.rb

@@ -1,5 +1,7 @@
 require 'rouge'
 
+# FIXME This file has suboptimal juju. See plugin/pyggish.rb also
+
 module Pyggish
   def self.pyg_change(code, klass, style)
     color = style[0..6]
@@ -29,7 +31,6 @@ module Pyggish
 
   def self.pyg_finalize(code, lexer=:elixir)
     Styles.each_pair {|klass, style| pyg_change(code, klass, style) }
-File.open("debug-pf1", "w") {|f| f.puts code }
     code.sub!(/<pre>/, "<pre>\n")
     code.gsub!(/<span class="[np]">/, "")
     code.gsub!(/<\/span>/, "")
@@ -37,9 +38,7 @@ File.open("debug-pf1", "w") {|f| f.puts code }
     code.sub!(/<td class="linenos"/, "<td width=2%></td><td width=5% bgcolor=#{color}")
     code.gsub!(/<td/, "<td valign=top ")
     code.gsub!(/ class="[^"]*?"/, "")    # Get rid of remaining Pygments CSS
-File.open("debug-pf2", "w") {|f| f.puts code }
     lines = code.split("\n")
-#   lines.each {|line| line << "\n" }
     n1 = lines.index {|x| x =~ /<pre>/ }
     n2 = lines.index {|x| x =~ /<\/pre>/ }
     # FIXME ?
@@ -48,12 +47,10 @@ File.open("debug-pf2", "w") {|f| f.puts code }
     lines[n1].sub!(/ 1$/, "  1 ")
     (n1+1).upto(n2) {|n| lines[n].replace(" " + lines[n] + " ") }
     code = lines.join("\n")
-File.open("debug-pf3", "w") {|f| f.puts code }
     code
   end
 
   def _process_code(text)
-  File.open("debug-pc1", "w") {|f| f.puts text }
     lines = text.split("\n")
     lines = lines.select {|x| x !~ /##~ omit/ }
     @refs = {}
@@ -66,7 +63,6 @@ File.open("debug-pf3", "w") {|f| f.puts code }
     end
     lines.map! {|line| "  " + line }
     text2 = lines.join("\n")
-  File.open("debug-pc2", "w") {|f| f.puts text2 }
     text.replace(text2)
   end
 
@@ -86,50 +82,22 @@ File.open("debug-pf3", "w") {|f| f.puts code }
     result
   end
 
-  def OLD_ruby
-    file = @_args.first 
-    if file.nil?
-      code = "# Ruby code\n"
-      _body {|line| code << line + "\n" }
-    else
-      code = "# Ruby code\n\n" + ::File.read(file)
-    end
-
-    _process_code(code)
-    html = _colorize(code, :ruby)
-    _out "\n#{html}\n "
-  end
-
-  def OLD_elixir
-    file = @_args.first 
-    if file.nil?
-      code = ""
-      _body {|line| code << line + "\n" }
-    else
-      code = ::File.read(file)
-    end
-
-    _process_code(code)
-    html = _colorize(code, :elixir)
-    _out "\n#{html}\n "
-  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
@@ -177,28 +145,28 @@ File.open("debug-pf3", "w") {|f| f.puts code }
   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

@@ -1,28 +1,28 @@
-# require 'cgi'
-
 require 'helpers'
 
+# Created as an "ad hoc" lib for generating the README
+
 module Tutorial
-  include Helpers
+  include Livetext::Helpers
 
   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,3 +1,4 @@
+
 require_relative 'livetext'
 
 =begin
@@ -65,27 +66,26 @@ class Livetext::CmdData
     # body:  true => this command has a body + .end
     # how raw is raw?
     #   remove comment - always/sometimes/never?
-    #   var_func_parse - always/sometimes/never?
-    #   var_func_parse inside body??
+    #   interpolate - always/sometimes/never?
+    #   interpolate inside body??
     @data = data.dup     # comment? vars? funcs?
     @raw  = data.dup     # comment? vars? funcs?
     @args  = data.split  # simple array
     @nargs = nargs       # not really "needed"
     check_num_args(nargs)
-    
     # @varfunc = Livetext.interpolate(data.dup)
   end
 
   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)
@@ -99,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}

@@ -8,7 +8,7 @@ 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

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

@@ -1,28 +1,13 @@
+
+require_relative 'parsing'
+require_relative 'funcall'
+
 # Class FormatLine handles the parsing of comments, dot commands, and 
 # simple formatting characters.
 
-class FormatLine < StringParser
-  SimpleFormats     = {}
-  SimpleFormats[:b] = %w[<b> </b>]
-  SimpleFormats[:i] = %w[<i> </i>]
-  SimpleFormats[:t] = ["<font size=+1><tt>", "</tt></font>"]
-  SimpleFormats[:s] = %w[<strike> </strike>]
- 
-  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 }
+class Livetext::FormatLine < StringParser
+  include Livetext::ParsingConstants
+  include Livetext::FormatLine::FunCall
 
   attr_reader :out
   attr_reader :tokenlist
@@ -37,22 +22,20 @@ class FormatLine < StringParser
     return nil if line.nil?
     x = self.new(line.chomp)
     t = x.tokenize
-# TTY.puts "tokens = \n#{t.inspect}\n "
     x.evaluate
   end
 
   def tokenize
-#   add grab
     loop do 
       case peek
-        when Escape; grab; add peek; grab; add peek
+        when Escape; grab; add peek; grab
         when "$"
           dollar
         when "*", "_", "`", "~"
           marker peek
           add peek
         when LF
-          break if eos?  # @i >= line.size - 1
+          break if eos?
         when nil
           break
         else
@@ -72,6 +55,20 @@ class FormatLine < StringParser
     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)
@@ -80,7 +77,7 @@ class FormatLine < StringParser
       char = x.grab
       break if char == LF || char == nil
       x.handle_escaping if char == Escape
-      x.dollar if char == "$"
+      x.dollar if char == "$"  # Could be $$
       x.add char
     end
     x.add_token(:str)
@@ -107,22 +104,10 @@ class FormatLine < StringParser
       break if token.nil? 
       sym, val = *token
       case sym
-        when :str
-          @out << val unless val == "\n"   # BUG
-        when :var
-          @out << varsub(val)
-        when :func 
-          param = nil
-          arg = gen.peek
-          if [:colon, :brackets].include? arg[0] 
-            arg = gen.next  # for real
-            param = arg[1]
-            param = Livetext.interpolate(param)
-          end
-          @out << funcall(val, param)
-        when :b, :i, :t, :s
-          val = Livetext.interpolate(val)
-          @out << embed(sym, val)
+        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
@@ -131,48 +116,6 @@ class FormatLine < StringParser
     @out
   end
 
-  def grab_colon_param
-    grab  # grab :
-    param = ""
-    loop do 
-      case next!
-        when Escape
-          grab
-          param << next!
-          grab
-        when Space, LF, nil; break
-      else
-        param << next!
-        grab
-      end
-    end
-
-    param = nil if param.empty?
-    param
-  end
-
-  def grab_func_param
-    grab # [
-    param = ""
-    loop do 
-      case next!
-        when Escape
-          grab
-          param << next!
-          grab
-        when "]", LF, nil; break
-      else
-        param << next!
-        grab
-      end
-    end
-
-    add peek
-    grab
-    param = nil if param.empty?
-    param
-  end
-
   def add(str)
     @token << str unless str.nil?
   end
@@ -189,7 +132,7 @@ class FormatLine < StringParser
     loop do
       break if eos?
       str << peek
-      break if terminate?(NoAlpha, next!)
+      break if terminate?(NoAlpha, lookahead)
       grab
     end
     str
@@ -201,7 +144,7 @@ class FormatLine < StringParser
     loop do
       break if peek.nil?   # eos?
       str << peek
-      break if terminate?(NoAlphaDot, next!)
+      break if terminate?(NoAlphaDot, lookahead)
       grab
     end
     str
@@ -216,7 +159,7 @@ class FormatLine < StringParser
       when "$"; double_dollar
 #     when "."; dollar_dot
       when /[A-Za-z]/
-       add_token :str
+        add_token :str
         var = peek + grab_alpha_dot
         add_token(:var, var)
     else 
@@ -225,23 +168,6 @@ class FormatLine < StringParser
     end
   end
 
-  def double_dollar
-    case next!
-      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)
-        case next!
-          when ":"; param = grab_colon_param; add_token(:colon, param)
-          when "["; param = grab_func_param; add_token(:brackets, param)
-        end
-      else
-        grab; add_token :str, "$$" + peek; return
-    end
-  end
-
 # def dollar_dot
 #   add_token :ddot, @line[@i..-1]
 # end
@@ -276,7 +202,7 @@ class FormatLine < StringParser
   def double_marker(char)
     sym = Syms[char]
     kind = sym
-    case next!   # first char after **
+    case lookahead   # first char after **
       when Space, LF, nil
         pre, post = SimpleFormats[sym]
         add_token kind
@@ -317,13 +243,12 @@ class FormatLine < StringParser
     add str
     str
   rescue => err
-    STDERR.puts "ERR = #{err}\n#{err.backtrace}"
-    STDERR.puts "=== str = #{str.inspect}"
+    ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
   end
 
   def escaped
-    grab
-    ch = grab
+    grab        # Eat the backslash
+    ch = grab   # Take next char
     ch
   end
 
@@ -350,28 +275,47 @@ class FormatLine < StringParser
     add str
     str
   rescue => err
-    STDERR.puts "ERR = #{err}\n#{err.backtrace}"
-    STDERR.puts "=== str = #{str.inspect}"
-  end
-
-  def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
-    result = 
-      if self.respond_to?("func_" + name.to_s)
-        self.send("func_" + name.to_s, param)
-      else
-        fobj = ::Livetext::Functions.new
-        fobj.send(name, param) rescue err
-      end
-    result
+    ::STDERR.puts "ERR = #{err}\n#{err.backtrace}"
   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
 
   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

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