livetext 0.9.14 → 0.9.20

data/imports/pyggish.rb

@@ -0,0 +1,204 @@
+require 'rouge'
+
+module Pyggish
+  def self.pyg_change(code, klass, style)
+    color = style[0..6]
+    modifier = style[8]
+    mod_open = modifier ? "<#{modifier}>" : ""
+    mod_close = modifier ? "</#{modifier}>" : ""
+    rx = /<span class="#{klass}">(?<cname>[^<]+?)<\/span>/
+    loop do
+      md = rx.match(code)
+      break if md.nil?
+      str = md[:cname]
+      result = code.sub!(rx, "<font color=#{color}>#{mod_open}#{str}#{mod_close}</font>")
+      break if result.nil?
+    end
+  end
+
+  def self._codebar_color(lexer)
+    color = case lexer
+      when :elixir
+        "#fc88fc"
+      when :ruby
+        "#fc8888"
+      else
+        raise "Unknown lexer"
+    end
+  end
+
+  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>/, "")
+    color = _codebar_color(lexer)
+    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 ?
+    n1 ||= 0
+    n2 ||= -1
+    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 = {}
+    lines.each.with_index do |line, i|
+      if line =~ /##~ ref/
+        frag, name = line.split(/ *##~ ref/)
+        @refs[name.strip] = i
+        line.replace(frag)
+      end
+    end
+    lines.map! {|line| "  " + line }
+    text2 = lines.join("\n")
+  File.open("debug-pc2", "w") {|f| f.puts text2 }
+    text.replace(text2)
+  end
+
+  def _colorize(code, lexer=:elixir)
+    text = ::Pygments.highlight(code, lexer: lexer, options: {linenos: "table"})
+    _debug "--- in _colorize: text = #{text.inspect}"
+    text2 = PygmentFix.pyg_finalize(text, lexer)
+    result = "<!-- colorized code -->\n" + text2
+    result
+  end
+
+  def _colorize!(code, lexer=:elixir)
+    text = ::Pygments.highlight(code, lexer: lexer, options: {})
+    _debug "--- in _colorize!: text = #{text.inspect}"
+    text2 = PygmentFix.pyg_finalize(text, lexer)
+    result = "<!-- colorized code -->\n" + text2
+    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 = []
+    send(lang)
+    _out "\n"
+  end
+
+  def code       # FIXME ?
+    text = ""   
+    _body {|line| _out "    " + line }
+  end
+
+  def mono
+    _out "<pre>"
+    _body {|line| _out "    " + line }
+    _out "</pre>"
+  end
+
+  def create_code_styles
+    dir = @_outdir || "."
+    theme, back = "Github", "white"
+    css = Rouge::Themes.const_get(theme).render(scope: '.rb_highlight')
+    added = <<~CSS
+      .rb_highlight { 
+      font-family: 'Monaco', 'Andale Mono', 'Lucida Grande', 'Courier', 'Lucida Console', 'Courier New', monospace;
+      white-space: pre; 
+      background-color: #{back} 
+      }
+    CSS
+
+    css.gsub!(/{\n/, "{\n  font-family: courier;")
+    css = added + "\n" + css
+    # STDERR.puts "Writing #{theme} theme to ruby.css"
+    File.write("#{dir}/ruby.css", css)
+
+    css = Rouge::Themes.const_get(theme).render(scope: '.ex_highlight')
+    added = added.sub(/rb/, "ex")
+    css.gsub!(/{\n/, "{\n  font-family: courier;")
+    css = added + "\n" + css 
+    # STDERR.puts "Writing #{theme} theme to elixir.css"
+    File.write("#{dir}/elixir.css", css)
+  end
+
+
+  def format_ruby(source, theme = "Github", back = "black")
+    # theme/back not used now
+    formatter = Rouge::Formatters::HTML.new
+    lexer = Rouge::Lexers::Ruby.new
+    body = formatter.format(lexer.lex(source))
+    text = "<div class=rb_highlight>#{body}</div>"
+    text
+  end
+
+  def format_elixir(source, theme = "Github", back = "black")
+    # theme/back not used now
+    formatter = Rouge::Formatters::HTML.new
+    lexer = Rouge::Lexers::Elixir.new
+    body = formatter.format(lexer.lex(source))
+    text = "<div class=ex_highlight>#{body}</div>"
+    text
+  end
+
+  def ruby
+    file = @_args.first 
+    if file.nil?
+      code = "  # Ruby code\n\n"
+      _body {|line| code << "  " + line + "\n" }
+    else
+      code = "# Ruby code\n\n" + ::File.read(file)
+    end
+
+    html = format_ruby(code)
+    _out html
+  end
+
+  def elixir
+    file = @_args.first 
+    if file.nil?
+      code = ""
+      _body {|line| code << "  " + line + "\n" }
+    else
+      code = ::File.read(file)
+    end
+
+    html = format_elixir(code)
+    _out html
+  end
+end

data/imports/tutorial.rb

@@ -0,0 +1,95 @@
+# require 'cgi'
+
+require 'helpers'
+
+module Tutorial
+  include Helpers
+
+  def title(args = nil, body = nil)
+    h1
+    _optional_blank_line
+  end
+
+  def section(args = nil, body = nil)
+    h3
+    _optional_blank_line
+  end
+
+  def code(args = nil, body = nil)
+    first = true  # dumb hack! fixes blank space
+    _body do |line| 
+      tag, first = "<pre>", false if first
+      _out "#{tag}   #{escape_html(line)}"   # indentation
+    end
+    _out "</pre>"
+    _optional_blank_line
+  end
+
+  def rx(str)
+    ::Regexp.compile(::Regexp.escape(str))
+  end
+
+  def inout(args = nil, body = nil)
+    src, out = _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
+      <table width=80% cellpadding=4>
+      <tr>
+        <td width=50%><b>Input</b></td>
+        <td width=50%><b>Output</b></td>
+      </tr>
+      <tr>
+        <td width=50% bgcolor=#fee0fe valign=top>
+          <pre>#{t1}</pre>
+        </td>
+        <td width=50% bgcolor=#eeeeee valign=top>
+          <pre>#{t2}</pre>
+        </td>
+      </tr>
+      </table>
+    HTML
+    _optional_blank_line
+  end
+
+  def put_table(src, exp)
+    t1 = ::File.readlines(src) rescue (abort "t1 = #{src}")
+    t2 = ::File.readlines(exp) rescue (abort "t2 = #{out}")
+    t1 = t1.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
+    t2 = t2.map {|x| " " + x.sub(/ +$/,"").gsub(/_/, "\\_") }.join
+
+    _out <<-HTML
+      <font size=+1>
+      <table width=80% cellpadding=4>
+      <tr>
+        <td width=50%><b>Input</b></td>
+        <td width=50%><b>Output</b></td>
+      </tr>
+      <tr>
+        <td width=50% bgcolor=#fee0fe valign=top>
+          <pre>#{t1}</pre>
+        </td>
+        <td width=50% bgcolor=#eeeeee valign=top>
+          <pre>#{t2}</pre>
+        </td>
+      </tr>
+      </table>
+      </font>
+    HTML
+  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>"
+    src, exp = "test/data/#{name}/source.lt3", "test/data/#{name}/expected-output.txt"
+    @_args = [src, exp]   # Better way to do this??
+    put_table(src, exp)
+    _out "<br>"
+    _optional_blank_line
+  end
+end
+

data/lib/cmdargs.rb

@@ -0,0 +1,93 @@
+require_relative 'livetext'
+
+=begin
+  Weird concepts to understand here...
+
+    1. A Livetext dot-command (flush left) usually looks like:
+       .foobar
+    2. A dot-command (left-indented) usually looks like:
+           $.foobar
+    3. More generally, it may have any number of parameters (0, 1, ...)
+       .redirect somefile.txt append
+    4. Variables and functions *can* appear (rare in practice??)
+       .redirect somefile$my_suffix $$my_mode
+    5. A trailing # comment may appear 
+       a. Stripped... saved in #raw ? #data ? #comment ? elsewhere?
+       b. NOT the "dot" as a comment!
+    6. .foobar  # This here is a comment
+    7. #data accessor returns all data on the .foo line...
+       a. ...After the initial space
+       b. ...Including spaces
+       c. Including comment??
+       d. .foo This is  o n l y   a test.
+          # #data returns: "This is  o n l y   a test."
+       e. What about formatting???
+       f. What about: comments? variables? functions? 
+
+    7. Some commands have NO body while others have an OPTIONAL or REQUIRED body
+       a. Assume .cmd1 definition forbids a body (then a body is an error)
+          .cmd1   # may NOT have a body
+       b. Assume .cmd2 definition PERMITS a body
+          .cmd2   # may or MAY NOT have body/.end  
+       c. Assume .cmd3 definition PERMITS a body
+          .cmd3   # REQUIRES a body/.end  
+          . stuff...
+          .end
+    8. Inside a body:
+    8a. Leading dot has no special meaning (though the associated method may parse it!)
+    8b. BUG? Currently leading dot is a comment INSIDE a body?
+    8a. No leading char is special (though the associated method may parse it!)
+    8a. No trailing #-comments (though the associated method may parse it!)
+    8c. ?? We should or shouldn't look for variables/functions? or make it an option?
+    8d. .end may naturally not be used (but see .raw where it may)
+    9. the args accessor is a simple array of strings
+
+
+=end
+
+class Livetext::CmdData
+
+  attr_reader :data, :args, :nargs, :arity, :comment, :raw  # , ...?
+
+  def initialize(data, body: false, arity: :N)   # FIXME maybe just add **options ??
+    # arity:  (num)   fixed number 0 or more
+    #        :N       arbitrary number
+    #        n1..n2   range
+    # 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??
+    @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 = _var_func_parse(data.dup)
+  end
+
+  def check_num_args(num)
+    num_range = /(\d{0,2})(\.\.)(\d{0,2})/
+    min, max = 0, 9999
+    md = 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)
+        min = Integer(vmin) unless vmin.empty?
+        max = Integer(vmax) unless vmax.empty?
+        min, max = Integer(min), Integer(max)
+      when %r[^\d+$] =~ num
+        min = max = Integer(num)  # can raise error
+      else
+        raise "Invalid value or range '#{num.inspect}'"
+    end
+
+    bad_args = @args.size.between?(min, max)
+    raise "Expected #{num} args but found #{@args.size}!" if bad_args
+  end
+
+end

data/lib/formatline.rb

@@ -1,7 +1,7 @@
 # Class FormatLine handles the parsing of comments, dot commands, and 
 # simple formatting characters.
 
-class FormatLine
+class FormatLine < StringParser
   SimpleFormats     = {}
   SimpleFormats[:b] = %w[<b> </b>]
   SimpleFormats[:i] = %w[<i> </i>]
@@ -24,20 +24,11 @@ class FormatLine
 
   Syms = { "*" => :b, "_" => :i, "`" => :t, "~" => :s }
 
-  def terminate?(terminators, ch)
-    if terminators.is_a? Regexp
-      terminators === ch
-    else
-      terminators.include?(ch)
-    end
-  end
-
   attr_reader :out
   attr_reader :tokenlist
 
   def initialize(line)
-    @line = line
-    @i = -1
+    super
     @token = Null.dup
     @tokenlist = []
   end
@@ -45,26 +36,27 @@ class FormatLine
   def self.parse!(line)
     return nil if line.nil?
     x = self.new(line.chomp)
-    t = x.tokenize(line)
+    t = x.tokenize
+# TTY.puts "tokens = \n#{t.inspect}\n "
     x.evaluate
   end
 
-  def tokenize(line)
-    grab
+  def tokenize
+#   add grab
     loop do 
-      case curr
-        when Escape; grab; add curr; grab; add curr
+      case peek
+        when Escape; grab; add peek; grab; add peek
         when "$"
           dollar
         when "*", "_", "`", "~"
-          marker curr
-          add curr
+          marker peek
+          add peek
         when LF
           break if @i >= line.size - 1
         when nil
           break
         else
-          add curr
+          add peek
       end
       grab
     end
@@ -72,24 +64,33 @@ class FormatLine
     @tokenlist
   end
 
+  def terminate?(terminators, ch)
+    if terminators.is_a? Regexp
+      terminators === ch
+    else
+      terminators.include?(ch)
+    end
+  end
+
   def self.var_func_parse(str)
     return nil if str.nil?
     x = self.new(str.chomp)
-    x.grab
-    loop do 
-      case x.curr
-        when Escape; x.grab; x.add x.curr; x.grab
-        when "$"
-          x.dollar
-        when LF, nil
-          break
-        else
-          x.add x.curr
-      end
-      x.grab
+    char = x.peek
+    loop do
+      char = x.grab
+      break if char == LF || char == nil
+      x.handle_escaping if char == Escape
+      x.dollar if char == "$"
+      x.add char
     end
     x.add_token(:str)
-    x.evaluate
+    result = x.evaluate
+    result
+  end
+
+  def handle_escaping
+    grab
+    add grab
   end
 
   def embed(sym, str)
@@ -130,27 +131,6 @@ class FormatLine
     @out
   end
 
-  def curr
-    @line[@i]
-  end
-
-  def prev
-    return nil if @i <= 0
-    @line[@i-1]
-  end
-
-  def next!
-    @line[@i+1]
-  end
-
-  def grab
-    @line[@i+=1]
-  end
-
-  def ungrab
-    @line[@i-=1]
-  end
-
   def grab_colon_param
     grab  # grab :
     param = ""
@@ -187,7 +167,7 @@ class FormatLine
       end
     end
 
-    add curr
+    add peek
     grab
     param = nil if param.empty?
     param
@@ -207,8 +187,8 @@ class FormatLine
     str = Null.dup
     grab
     loop do
-      break if curr.nil?
-      str << curr
+      break if eos?
+      str << peek
       break if terminate?(NoAlpha, next!)
       grab
     end
@@ -219,8 +199,8 @@ class FormatLine
     str = Null.dup
     grab
     loop do
-      break if curr.nil?
-      str << curr
+      break if eos?   # peek.nil?
+      str << peek
       break if terminate?(NoAlphaDot, next!)
       grab
     end
@@ -229,7 +209,7 @@ class FormatLine
 
   def dollar
     grab
-    case curr
+    case peek
       when LF;  add "$";  add_token :str
       when " "; add "$ "; add_token :str
       when nil; add "$";  add_token :str
@@ -237,10 +217,10 @@ class FormatLine
 #     when "."; dollar_dot
       when /[A-Za-z]/
        add_token :str
-        var = curr + grab_alpha_dot
+        var = peek + grab_alpha_dot
         add_token(:var, var)
     else 
-      add "$" + curr
+      add "$" + peek
       add_token(:string)
     end
   end
@@ -258,7 +238,7 @@ class FormatLine
           when "["; param = grab_func_param; add_token(:brackets, param)
         end
       else
-        grab; add_token :str, "$$" + curr; return
+        grab; add_token :str, "$$" + peek; return
     end
   end
 
@@ -275,7 +255,7 @@ class FormatLine
     end
 
     grab
-    case curr
+    case peek
       when Space
         add char + " "
         add_token :str
@@ -286,7 +266,7 @@ class FormatLine
       when char;   double_marker(char)
       when LBrack; long_marker(char)
     else
-      str = curr + collect!(sym, Blank)
+      str = peek + collect!(sym, Blank)
       add str
       add_token sym, str
       grab
@@ -319,21 +299,19 @@ class FormatLine
     str = Null.dup   # next is not " ","*","["
     grab   # ZZZ
     loop do
-      if curr == Escape
-        str << grab # ch = escaped char
+      if peek == Escape
         grab
+        str << grab
         next
       end
-      if terminate?(terminators, curr)
+      if terminate?(terminators, peek)
         break 
       end
-                  # STDERR.puts "#{curr.inspect} is not a terminator"
-      str << curr    # not a terminator
+      str << peek    # not a terminator
       grab
-                  # STDERR.puts "After grab, curr is #{curr.inspect}"
     end
 
-    if curr == "]" # skip right bracket
+    if peek == "]" # skip right bracket
       grab 
     end
     add str
@@ -344,8 +322,8 @@ class FormatLine
   end
 
   def escaped
-    ch = grab
     grab
+    ch = grab
     ch
   end
 
@@ -356,15 +334,15 @@ class FormatLine
     grab   # ZZZ
     loop do
       case
-        when curr.nil?
+        when peek.nil?
           return str
-        when curr == Escape
+        when peek == Escape
           str << escaped
           next
-        when terminate?(terminators, curr)
+        when terminate?(terminators, peek)
           break 
       else
-        str << curr    # not a terminator
+        str << peek    # not a terminator
       end
       grab
     end
@@ -376,17 +354,14 @@ class FormatLine
     STDERR.puts "=== str = #{str.inspect}"
   end
 
-############
-
-  ### From FormatLine:
-
   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)
+        fobj.send(name, param) rescue err
       end
     result
   end
@@ -396,8 +371,6 @@ class FormatLine
     result
   end
 
-  #####
-
   def embedded?
     ! (['"', "'", " ", nil].include? prev)
   end