livetext 0.9.17 → 0.9.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d027612469e45b953a3e8589ebbedf1f746f87f50c4a90b502f4daac56d28605
-  data.tar.gz: b811285f434d3b2760e201eb403f864ba31cb12e31f21105fc8c4fe5e3b743a2
+  metadata.gz: 27c2715e2e3ac638609f0ad19b2427d3da68be25f08bea8196d574b0efdbc115
+  data.tar.gz: 7edbc57a07ae50aa240561ad6f250da79a76248cc4c46941df7353cccb3b663c
 SHA512:
-  metadata.gz: 1e1b08d7d900ae551d7777576a7284d776422d2039813a764c3d9d9b0495ac14eec4e53225e1e0f3b97a1a548377f14b861e72d4b24d2a52055cd0f75404d2bf
-  data.tar.gz: 025055edd14e392750b482f4b0a9a973f213b24a5991bb9c7e9939c225a21bfe77398cc118983599a0fd1ccf1c1aa4c8bbf62874745a2cf5257410b747db72ee
+  metadata.gz: bbe056fd07c4198012ae2f0fc9f9af3e6eb45d2d3b68d9b8653c29b84081852ed40f05f63f59ccee7d6face5e68675f2293ca1ff3d9b92c12bbb2ca51cbc06df
+  data.tar.gz: 1b0f1b84ffd1cbbc41812f76516d39f7d805a53f89f4ef525962cf90128f6e738c81e671e8e98b6d83549b6959f03c844b312cac41a0445fd55472170c888d2c

data/imports/bookish.rb

@@ -0,0 +1,288 @@
+module Bookish
+  def hardbreaks(args = nil, body = nil)
+    @hard = false
+    @hard = true unless @_args.first == "off"
+  end
+
+  def hardbreaks?
+    @hard
+  end
+
+  def credit(args = nil, body = nil)
+    # really just a place marker in source
+  end
+
+  # These are duplicated. Remove safely
+
+  def h1; _out "<h1>#{@_data}</h1>"; end
+  def h2; _out "<h2>#{@_data}</h2>"; end
+  def h3; _out "<h3>#{@_data}</h3>"; end
+
+  def alpha_columns(args = nil, body = nil)
+    n = @_args.first.to_i   # FIXME: what if missing?
+    words = []
+    _body do |line| 
+      words << line.chomp
+    end
+    words.sort!
+    _out "<table cellpadding=2>"
+    words.each_slice(n) do |w|
+      items = w.map {|x| "<tt>#{x}</tt>" }
+      _out "<tr><td width=5% valign=top></td><td>" + items.join("</td><td>") + "</td></tr>"
+    end
+    _out "</table>"
+  end
+
+  # def comment
+  #   _body { }  # ignore body
+  # end
+
+  def _errout(*args)
+    ::STDERR.puts *args
+  end
+
+  def _nbsp(n)
+    "&nbsp;"*n
+  end
+
+  def _slug(str)
+    s2 = str.chomp.strip.gsub(/[?:,()'"\/]/,"").gsub(/ /, "-").downcase
+  # _errout "SLUG: #{str} => #{s2}"
+    s2
+  end
+
+
+  # FIXME duplicated?
+  def image(args = nil, body = nil)
+    name = @_args[0]
+    _out "<img src='#{name}'></img>"
+  end
+
+  def figure(args = nil, body = nil)
+    name = @_args[0]
+    num = @_args[1]
+    title = @_args[2..-1].join(" ")
+    title = _format(title)
+    _out "<img src='#{name}'></img>"
+    _out "<center><b>Figure #{num}</b> #{title}</center>"
+  end
+
+  def chapter(args = nil, body = nil)
+  # _errout("chapter")
+    @chapter = @_args.first.to_i
+    @sec = @sec2 = 0
+    title = @_data.split(" ",2)[1]
+    @toc << "<br><b>#@chapter</b> #{title}<br>"
+    @_data = _slug(title)
+    next_output
+    _out "<title>#{@chapter}. #{title}</title>"
+    _out <<-HTML
+      <h2>Chapter #{@chapter}</h2>
+      <h1>#{title}</h1>
+
+    HTML
+  end
+
+  def chapterN(args = nil, body = nil)
+    @chapter += 1
+    @sec = @sec2 = 0
+    title = @_data    # .split(" ",2)[1]
+    _errout("Chapter #@chapter: #{title}")
+    @toc << "<br><b>#@chapter</b> #{title}<br>"
+    @_data = _slug(title)
+    next_output
+    _out "<title>#{@chapter}. #{title}</title>"
+    _out <<-HTML
+      <h2>Chapter #{@chapter}</h2>
+      <h1>#{title}</h1>
+
+    HTML
+  end
+
+  def sec(args = nil, body = nil)
+    @sec += 1
+    @sec2 = 0
+    @section = "#@chapter.#@sec"
+    title = @_data.dup
+    @toc << "#{_nbsp(3)}<b>#@section</b> #{title}<br>"
+    @_data = _slug(@_data)
+    next_output
+    _out "<h3>#@section #{title}</h3>\n"
+  rescue => err
+    STDERR.puts "#{err}\n#{err.backtrace}"
+    exit
+  end
+
+  def subsec(args = nil, body = nil)
+    @sec2 += 1
+    @subsec = "#@chapter.#@sec.#@sec2"
+    title = @_data.dup
+    @toc << "#{_nbsp(6)}<b>#@subsec</b> #{title}<br>"
+    @_data = _slug(@_data)
+    next_output
+    _out "<h3>#@subsec #{title}</h3>\n"
+  end
+
+  def definition_table(args = nil, body = nil)
+    title = @_data
+    wide = "95"
+    delim = " :: "
+    _out "<br><center><table width=#{wide}% cellpadding=5>"
+    lines = _body(true)
+    lines.map! {|line| _format(line) }
+
+    lines.each do |line|
+      cells = line.split(delim)
+      _out "<tr>"
+      cells.each.with_index do |cell, i| 
+        width = (i == 0) ? "width=15%" : ""
+        _out "  <td #{width} valign=top>#{cell}</td>"
+      end
+      _out "</tr>"
+    end
+    _out "</table></center><br><br>"
+
+    _optional_blank_line
+  end
+
+  def table2(args = nil, body = nil)
+    title = @_data
+    wide = "90"
+    extra = _args[2]
+    delim = " :: "
+    _out "<br><center><table width=#{wide}% cellpadding=5>"
+    lines = _body(true)
+    lines.map! {|line| _format(line) }
+
+    lines.each do |line|
+      cells = line.split(delim)
+      percent = (100/cells.size.to_f).round
+      _out "<tr>"
+      cells.each do |cell| 
+        _out "  <td width=#{percent}% valign=top " + 
+              "#{extra}>#{cell}</td>"
+      end
+      _out "</tr>"
+    end
+    _out "</table></center><br><br>"
+
+    _optional_blank_line
+  end
+
+  def simple_table(args = nil, body = nil)
+    title = @_data
+    delim = " :: "
+    _out "<table cellpadding=2>"
+    lines = _body(true)
+    maxw = nil
+    lines.each do |line|
+      _format(line)
+      cells = line.split(delim)
+      wide = cells.map {|x| x.length }
+      maxw = [0] * cells.size
+      maxw = maxw.map.with_index {|x, i| [x, wide[i]].max }
+    end
+
+    sum = maxw.inject(0, :+)
+    maxw.map! {|x| (x/sum*100).floor }
+
+    lines.each do |line|
+      cells = line.split(delim)
+      _out "<tr>"
+      cells.each.with_index do |cell, i| 
+        _out "  <td width=#{maxw}% valign=top>" + 
+              "#{cell}</td>"
+      end
+      _out "</tr>"
+    end
+    _out "</table>"
+  end
+
+  def table(args = nil, body = nil)
+    @table_num ||= 0
+    @table_num += 1
+    title = @_data
+    delim = " :: "
+    _out "<br><center><table width=90% cellpadding=5>"
+    lines = _body(true)
+    maxw = nil
+    lines.each do |line|
+      _format(line)
+      cells = line.split(delim)
+      wide = cells.map {|x| x.length }
+      maxw = [0] * cells.size
+      maxw = maxw.map.with_index {|x, i| [x, wide[i]+2].max }
+    end
+
+    sum = maxw.inject(0, :+)
+    maxw.map! {|x| (x/sum*100).floor }
+
+    lines.each do |line|
+      cells = line.split(delim)
+      _out "<tr>"
+      cells.each.with_index do |cell, i| 
+        _out "  <td width=#{maxw}% valign=top>" + 
+              "#{cell}</td>"
+      end
+      _out "</tr>"
+    end
+    _out "</table>"
+    @toc << "#{_nbsp(8)}<b>Table #@chapter.#@table_num</b> #{title}<br>"
+  # _next_output(_slug("table_#{title}"))
+    _out "<b>Table #@chapter.#@table_num &nbsp;&nbsp; #{title}</b></center><br>"
+  end
+
+  def toc!(args = nil, body = nil)
+    _debug "Closing TOC"
+    @toc.close
+  rescue => err
+     puts @parent.body
+     @parent.body = ""
+    _errout "Exception: #{err.inspect}"
+  end
+
+  def toc2(args = nil, body = nil)
+    file = @_args[0]
+    @toc.close
+    ::File.write(file, <<-EOS)
+  <p style="page-break-after:always;"></p>
+  <meta charset='UTF-8'>
+
+  <center><h2>Fake (non-hyperlinked) Table of Contents</h2></center>
+
+  EOS
+    system("cat toc.tmp >>#{file}")
+  end
+
+  def missing(args = nil, body = nil)
+    @toc << "#{_nbsp(8)}<font color=red>TBD: #@_data</font><br>"
+    stuff = @_data.empty? ? "" : ": #@_data"
+    _out "<br><font color=red><i>[Material missing#{stuff}]</i></font><br>\n "
+  end
+
+  def TBC(args = nil, body = nil)
+    @toc << "#{_nbsp(8)}<font color=red>To be continued...</font><br>"
+    _out "<br><font color=red><i>To be continued...</i></font><br>"
+  end
+
+  def note(args = nil, body = nil)
+    _out "<br><font color=red><i>Note: "
+    _out @_data 
+    _out "</i></font><br>\n "
+  end
+
+  def quote(args = nil, body = nil)
+    _out "<blockquote>"
+    _body {|line| _out line }
+    _out "</blockquote>"
+  rescue => err
+    STDERR.puts "#{err}\n#{err.backtrace}"
+    exit
+  end
+
+  def init_bookish
+    @toc_file = "toc.tmp"
+    @toc = ::File.new(@toc_file, "w")
+    @chapter = -1
+  end
+end

data/imports/calibre.rb

@@ -0,0 +1,28 @@
+require 'fileutils'
+
+module Calibre 
+  def epub!(args = nil, body = nil)
+    out = _format(@_args[0])
+    src = @_args[1]
+    @cover = @_args[2]
+    if ::File.directory?(src)
+      files = ::Dir["#{src}/*"].grep /\.html$/
+      files = files.sort  # why is this necessary now?
+      cmd = "cat #{files.join(' ')} >TEMP.html"
+      system(cmd)
+    else
+      raise "Not supported yet"
+    end
+
+    cmd = "ebook-convert "
+    cmd << "TEMP.html #{out}.epub "
+    cmd << "--cover #@cover " if @cover
+    system(cmd)
+
+    system("links -dump TEMP.html >/tmp/links.out")
+    str = `wc -w /tmp/links.out`
+    nw = str.split[0]
+    puts "Approx words: #{nw}"
+    # ::FileUtils.rm("TEMP.html")
+  end
+end

data/imports/livemagick.rb

@@ -0,0 +1,133 @@
+require 'rmagick'
+
+module Livemagick     # FIXME auto-mangle names
+  include ::Magick
+
+  def image(args = nil, body = nil)
+    xx, yy, bg = _args
+    xx, yy = xx.to_i, yy.to_i
+    @image = Image.new(xx,yy) { self.background_color = bg }
+    _optional_blank_line
+  end
+
+  def canvas(args = nil, body = nil)
+    color, width, opacity = _args
+    opacity, width = opacity.to_i, width.to_i
+    @canvas = Draw.new
+    @canvas.fill_opacity(0)
+    @canvas.stroke('black')
+    @canvas.stroke_width(1)
+    _optional_blank_line
+  end
+
+  def rectangle(args = nil, body = nil)
+    xy, wxh, stroke_color, stroke_width = _args
+    x, y = xy.split(",").map(&:to_i)
+    width, height = wxh.split("x").map(&:to_i)
+    stroke_width = stroke_width.to_i
+    _debug "rectangle: x=#{x} y=#{y} width=#{width} height=#{height} "
+    @canvas.stroke(stroke_color)
+    @canvas.stroke_width(stroke_width)
+    @canvas.rectangle(x, y, x+width, y+height)
+  end
+
+  def pen(args = nil, body = nil)
+    @fill, @stroke = _args
+    @stroke = "black" if @stroke.nil? || @stroke.empty?
+    _debug "pen: fill=#@fill stroke=#@stroke"
+    _optional_blank_line
+  end
+
+  def font(args = nil, body = nil)
+    size, font = _args
+    font = "Helvetica" if font.nil? || font.empty? 
+    size = "32" if size.nil? || size.empty? 
+    @size, @font = size.to_i, font
+    _debug "font: size=#@size font=#@font"
+    _optional_blank_line
+  end
+
+  def _text(xy, wxh, str, weight, gravity)
+    x, y = xy.split(",").map(&:to_i)
+    width, height = wxh.split("x").map(&:to_i)
+    font, fill, stroke, size = @font, @fill, @stroke, @size
+    @canvas.annotate(@image, width, height, x, y, str) do 
+      self.font_family = font
+      self.fill = fill
+      self.stroke = stroke
+      self.pointsize = size
+      self.font_weight = weight
+      self.gravity = gravity
+    end
+  end
+
+  def text(args = nil, body = nil)
+    xy, wxh, str = _data.split
+    weight, gravity = BoldWeight, CenterGravity
+    _text(xy, wxh, str, weight, gravity)
+    _optional_blank_line
+  end
+
+  def text!(args = nil, body = nil)
+    xy, wxh = _data.split
+    str = _body_text  # .join
+    weight, gravity = BoldWeight, CenterGravity
+    _text(xy, wxh, str, weight, gravity)
+    _optional_blank_line
+  end
+
+  def draw(args = nil, body = nil)
+    @canvas.draw(@image)
+    _optional_blank_line
+  end
+
+  def save(args = nil, body = nil)
+    @image.write(_args.first)
+    _optional_blank_line
+  end
+
+  def save!(args = nil, body = nil)
+    save
+    system("open #{_args.first}")
+    _optional_blank_line
+  end
+end
+=begin
+draw.annotate(img, width, height, x, y, text) [ { additional parameters } ] -> draw
+Description
+
+Annotates a image with text. The text is positioned according to the gravity attribute around the rectangle described by the x, y, width, and height arguments. If either of the width or height arguments are 0, uses the image width-x and the image height-y to compute the rectangle width and height. The attributes described in annotate attributes, below, influence the appearance and position of the text. These attributes may be set in the Draw object before calling annotate, or within annotate's optional additional parameters block.
+
+Note: all of the annotate attributes are set-only.
+Arguments
+
+img
+    the image or imagelist to be annotated
+width
+    width of the rectangle within which the text is positioned
+height
+    height of the rectangle within which the text is positioned
+x
+    x offset of the rectangle
+y
+    y offset of the rectangle
+text
+    the text
+
+Returns
+
+self
+Example
+
+This example is an excerpt of colors.rb. Many other examples also use annotate.
+
+title.annotate(montage, 0,0,0,40, 'Named Colors') {
+    self.font_family = 'Helvetica'
+    self.fill = 'white'
+    self.stroke = 'transparent'
+    self.pointsize = 32
+    self.font_weight = BoldWeight
+    self.gravity = NorthGravity
+}
+
+=end

data/imports/markdown.rb

@@ -0,0 +1,44 @@
+# This file is intended to be used via a Livetext .mixin  
+# or the equivalent.
+
+module Markdown
+  SimpleFormats = {}
+  SimpleFormats[:b] = %w[* *]
+  SimpleFormats[:i] = %w[_ _]
+  SimpleFormats[:t] = %w[` `]
+  SimpleFormats[:s] = %w[<strike> </strike>]
+
+
+  def h1(args = nil, body = nil); _out "# #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end       # atx style for now
+  def h2(args = nil, body = nil); _out "## #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+  def h3(args = nil, body = nil); _out "### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+  def h4(args = nil, body = nil); _out "#### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+  def h5(args = nil, body = nil); _out "##### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+  def h6(args = nil, body = nil); _out "###### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+
+  def title(args = nil, body = nil)
+    h1
+  end
+
+  def section(args = nil, body = nil)
+    h3
+  end
+
+  def bq(args = nil, body = nil)   # block quote
+    _body {|line| _out "> #{line}" }
+  end
+
+  def list(args = nil, body = nil)
+    _body {|line| _out " * #{line}" }
+  end
+
+  def olist(args = nil, body = nil)   # Doesn't handle paragraphs yet
+    n = 0
+    _body do |line|
+      n += 1
+      _out "#{n}. #{_format(line)}"
+    end
+  end
+
+  alias nlist olist
+end

data/imports/markdown_importable.rb

@@ -0,0 +1,46 @@
+# This file is intended to be used via a Livetext .mixin
+# or the equivalent.
+
+require_relative '../lib/livetext/importable'
+
+  class MarkdownImportable < LiveText::Importable
+
+    SimpleFormats[:b] = %w[* *]
+    SimpleFormats[:i] = %w[_ _]
+    SimpleFormats[:t] = %w[` `]
+    SimpleFormats[:s] = %w[<strike> </strike>]
+
+    def h1; _out "# #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end       # atx style for now
+    def h2; _out "## #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+    def h3; _out "### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+    def h4; _out "#### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+    def h5; _out "##### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+    def h6; _out "###### #{FormatLine.var_func_parse(@_data)}"; _optional_blank_line end
+
+    def title
+      h1
+    end
+
+    def section
+      h3
+    end
+
+    def bq   # block quote
+      _body {|line| _out "> #{line}" }
+    end
+
+    def list
+      _body {|line| _out " * #{line}" }
+    end
+
+    def olist   # Doesn't handle paragraphs yet
+      n = 0
+      _body do |line|
+        n += 1
+        _out "#{n}. #{_format(line)}"
+      end
+    end
+
+    alias nlist olist
+  end
+end

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/livetext.rb

@@ -1,7 +1,7 @@
 # Class Livetext skeleton (top level).
 
 class Livetext
-  VERSION = "0.9.17"
+  VERSION = "0.9.19"
   Path  = File.expand_path(File.join(File.dirname(__FILE__)))
 
   module Handler

data/livetext.gemspec

@@ -15,7 +15,8 @@ Gem::Specification.new do |s|
   s.executables << "livetext"
   
   # Files...
-  main = Find.find("bin").to_a + Find.find("lib").to_a + Find.find("plugin").to_a 
+  main = Find.find("bin").to_a + Find.find("lib").to_a + 
+         Find.find("plugin").to_a + Find.find("imports").to_a 
   misc = %w[./README.lt3 ./README.md livetext.gemspec]
   test = Find.find("test").to_a
 

data/test/snapshots/clusion.txt

@@ -3,7 +3,21 @@
 # Blank lines and comments are ignored.
 # Other lines:  name_of_snapshot and any comments here are ignored (no # needed)
 
-# i to include, x to exclude
+# You can start by uncommenting one of these:
+# Default INCLUDE all
+# Default EXCLUDE all
+# If you use neither, INCLUDE is the default (but explicit is better)
+
+# If you include all, you can specify exclusions with an x:
+# x  my_test_name           # this is a comment
+
+# Likewise if you EXCLUDE all, you can specify inclusions with an i:
+# i  some_other_test        # this is a comment
+
+# The i and x (to include/exclude) must be the first token on
+#   the line (preceding the test name)
+
+# Note that QUIT (on a line by itself) will stop processing the file
 
 x  error_no_such_inc        # Output BEFORE error doesn't get passed through ("leading" output)
 x  error_no_such_copy       # ^ Same behavior as  error_no_such_inc

data/test/snapshots.rb

@@ -43,6 +43,69 @@ class TestingLivetext < MiniTest::Test
     EXP_OUT,    EXP_ERR    = "expected-output.txt", "expected-error.txt"
     MATCH_OUT,  MATCH_ERR  =  "match-output.txt", "match-error.txt"
 
+    TTY = File.open("/dev/tty","w")
+
+    def self.get_dir   # FIXME - uh what?
+      cmdline = ARGV.first == "cmdline"   # FIXME remove??
+      if cmdline
+        dir = "../"
+        Dir.chdir `livetext --path`.chomp.chomp
+      else
+        dir = ""
+      end
+    end
+
+    args = ARGV - ["cmdline"]
+
+    dir = self.get_dir
+
+    Data = "#{dir}test/snapshots"
+    Dir.chdir(Data)
+
+    TestDirs = Dir.entries(".").reject {|fname| ! File.directory?(fname) } - %w[. ..]
+
+
+    def self.filter  # TODO move subset/omit logic here??
+      all = Dir.entries(Data).reject {|fname| ! File.directory?(fname) } - %w[. ..]
+      included, excluded = [], []
+      @iflag, @eflag = true, false   # defaults to INCLUDE
+      control = File.new("clusion.txt")
+      control.each_line do |line|
+        line.sub!(/#.*/, "")
+        line.strip!
+        lower = line.downcase
+        dejavu = false
+        case
+          when lower.empty?
+            # ignore
+          when lower == "default include all"
+            raise "Only one 'default' allowed" if dejavu
+            @iflag, @eflag = true, false   # defaults to INCLUDE
+            dejavu = true
+          when lower == "default exclude all"
+            raise "Only one 'default' allowed" if dejavu
+            @iflag, @eflag = false, true
+            dejavu = true
+          when lower == "quit"
+            break
+          when lower[0] == "i"
+            TTY.puts "Warning: Can't include with 'i' when that is default" if @iflag
+            included << line.split(" ", 2)[1] # add to included
+          when lower[0] == "x"
+            TTY.puts "Warning: Can't exclude with 'x' when that is default" if @eflag
+            excluded << line.split(" ", 2)[1] # add to excluded
+            # add to excluded
+        end
+        [included, excluded]
+      end
+    end
+
+    i, e = self.filter
+    p i
+    p e
+
+    exit
+
     def initialize(base, assertion = nil)
       @assertion = assertion
       @base = base
@@ -109,9 +172,6 @@ class TestingLivetext < MiniTest::Test
       system("rm -f #{ACTUAL_OUT} #{ACTUAL_ERR} *sdiff.txt")
     end
 
-    def filter  # TODO move subset/omit logic here??
-    end
-
     def run
       @errors = false   # oops, need to reset
       Dir.chdir(@base) do
@@ -124,27 +184,6 @@ class TestingLivetext < MiniTest::Test
     end
   end
 
-  def self.get_dir   # FIXME - uh what?
-    cmdline = ARGV.first == "cmdline"   # FIXME remove??
-    if cmdline
-      dir = "../"
-      Dir.chdir `livetext --path`.chomp.chomp
-    else
-      dir = ""
-    end
-  end
-
-  TTY = File.open("/dev/tty","w")
-
-  args = ARGV - ["cmdline"]
-
-  dir = self.get_dir
-
-  Data = "#{dir}test/snapshots"
-  Dir.chdir(Data)
-
-  TestDirs = Dir.entries(".").reject {|fname| ! File.directory?(fname) } - %w[. ..]
-
   if args.empty?
     selected = File.readlines("subset.txt").map(&:chomp)
     omitfile = "OMIT.txt"
@@ -166,7 +205,6 @@ class TestingLivetext < MiniTest::Test
     Subset = args
   end
 
-
   Subset.each do |tdir|
     define_method("test_#{tdir}") do
       myproc = Proc.new {|bool, info| assert bool, info }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: livetext
 version: !ruby/object:Gem::Version
-  version: 0.9.17
+  version: 0.9.19
 platform: ruby
 authors:
 - Hal Fulton
@@ -20,6 +20,13 @@ files:
 - "./README.lt3"
 - "./README.md"
 - bin/livetext
+- imports/bookish.rb
+- imports/calibre.rb
+- imports/livemagick.rb
+- imports/markdown.rb
+- imports/markdown_importable.rb
+- imports/pyggish.rb
+- imports/tutorial.rb
 - lib/cmdargs.rb
 - lib/errors.rb
 - lib/formatline.rb