livetext 0.9.21 → 0.9.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90efd2fa7302e61cfe5ed140c8f954afd2b7c699ec705d8ff0c1d36bd6641fa4
-  data.tar.gz: b551f8a5dc4eda7435fe73b4680604c8468a59417286c01194672d319bdaf411
+  metadata.gz: 3f447e149e6724975184b8db2c51ff59c58752c3cb5b4037bb86fb1f355015a6
+  data.tar.gz: 9740fc3b2bb98e92c91c523656f270a66132d882fbcaa9b1a803294d1e10a65a
 SHA512:
-  metadata.gz: 213f8d126a548e54a34ce1c4f551d9f4ab208df618bb4e1d069ee5c6f430d03daeef6054c71e205dc1431b1bea6c6bb05d9362985c8be280ed982781b139b047
-  data.tar.gz: ef50d633131bf82ac06c7807ea53edbc11ba032e0ea3db7eade09afed2e5e954656515872ead7fb38a798c7079fb0d73e742a18b4b258d29baab13de6b8e28d5
+  metadata.gz: 1ee34071fde07e45b13d8f13aa9889d2b060651901acd8e3876071121ea5222c8bc4b83162c30f772c53fe92e07ea7bada3f28be0c75994f1ad21bcdacbb2905
+  data.tar.gz: ce9ed1ac2cd624818b775d19681a406f0a4c43c2a0b9a7f6f8c1f8fb9834b91301a2b65c10d1faa0c4b664a1abcb741c570d1745d996537f4d438e97b65e3f56

data/README.lt3

@@ -1,5 +1,5 @@
-.icanhaz tutorial
-.icanhaz markdown
+.import tutorial
+.import markdown
 
 . copy basic.css
 
@@ -186,7 +186,7 @@ the text. Here's an example.
 
   . This is also a comment, by the way.
   .def chapter
-     params = _args
+     params = api.args
      raise "chapter: expecting at least two args" unless params.size > 1
      num, *title = params     # Chapter number + title
      title = title.join(" ")  # Join all words into one string
@@ -195,7 +195,7 @@ the text. Here's an example.
      <h2>#{title}</h2>
      <hr>
      HTML
-     _puts text
+     api.puts text
   .end
   . Now let's invoke it...
   .chapter 1 Why I Went to the Woods
@@ -270,16 +270,16 @@ in here (and nothing else).
 # File: mylib.rb
 
 def alpha
-  cols = _args.first
+  cols = api.args.first
   cols = "1" if cols == ""
   cols = cols.to_i
   raise "Columns must be 1-5" unless cols.between?(1,5)
-  text = _body.join
+  text = api.body.join
   text.gsub!(/\n/, " ")
   words = text.split.sort
   words.each_slice(cols) do |row| 
-    row.each {|w| _print '%-15s' % w }
-    _puts 
+    row.each {|w| api.print '%-15s' % w }
+    api.puts 
   end
 end
 .end

data/bin/livetext

@@ -4,12 +4,8 @@ require 'rubygems'
 
 require_relative '../lib/livetext'
 
-def handle_lt3(src)
-  abort "Unknown file extension" unless src =~ /.lt3$/
-end
-
 def usage
-  puts <<-EOF
+  STDERR.puts <<~EOF
   Usage: 
     livetext filename
 
@@ -41,50 +37,71 @@ def usage
     Install plugin:
       livetext -i filename.rb
       livetext -install filename.rb
+
   EOF
-  puts
   exit
 end
 
-# Main
+def version
+  puts "#{Livetext::VERSION}\n "
+end
 
-x = Livetext.new
+def testing
+  file = "#{Livetext::Path}/../test/test.rb"
+  flag = @backtrace ? "-back" : ""
+  cmd = "ruby #{file} cmdline#{flag}"
+  puts cmd
+  system(cmd)
+end
 
-@backtrace = false
+def mixin_flag
+  mod = ARGV.shift
+  @live.mixin(ARGV.shift)
+end
+
+def read_stdin
+  src = STDIN.read
+  @live.process(src)
+end
+
+def install_plugin
+  lib = ARGV.shift
+  system("cp #{lib} #{Livetext::Path}/../plugin/")
+end
 
-usage if ARGV.empty?
-
-loop do
-  arg = ARGV.shift
-  break if arg.nil?
-  case arg
-    when "-v", "--version"
-      puts "#{Livetext::VERSION}\n "
-    when "-t", "--test"
-      file = "#{Livetext::Path}/../test/test.rb"
-      flag = @backtrace ? "-back" : ""
-      cmd = "ruby #{file} cmdline#{flag}"
-      puts cmd
-      system(cmd)
-    when "-p", "--path"
-      puts Livetext::Path
-    when "-b", "--backtrace"
-      @backtrace = true
+def parse_command_line
+  usage if ARGV.empty?
+  success = true
+  loop do
+    arg = ARGV.shift
+    break if arg.nil?
+    case arg
+    when "-v", "--version";   version
+    when "-t", "--test";      testing
+    when "-p", "--path";      puts Livetext::Path
+    when "-b", "--backtrace"; @backtrace = true
     when "-m", "--mixin"
-      mod = ARGV.shift
-      x.mixin(ARGV.shift)
+      mixin_flag
       next
-    when "-s", "--stdin"
-      src = STDIN.read
-      x.process(src)
-    when "-h", "--help"
-      usage
-    when "-i", "--install"
-      lib = ARGV.shift
-      system("cp #{lib} #{Livetext::Path}/../plugin/")
-    when Object
-      x.process_file(arg, true)  # , @backtrace)
+    when "-s", "--stdin";     read_stdin
+    when "-h", "--help";      usage
+    when "-i", "--install";   install_plugin
+    when Object;              @live.process_file(arg, true)  # , @backtrace)
+    else
+      success = false
+      STDERR.puts "Command line - #{arg.inspect} is  unknown"
+    end
   end
+  @live.dump if success
+# rescue => err
+#   STDERR.puts "Unexpected error! #{err.inspect}"
 end
 
-puts x.body
+# Main
+
+@live = Livetext.new
+
+@backtrace = false
+
+parse_command_line
+

data/imports/bookish.rb

@@ -1,7 +1,7 @@
 module Bookish
   def hardbreaks(args = nil, body = nil)
     @hard = false
-    @hard = true unless @_args.first == "off"
+    @hard = true unless api.args.first == "off"
   end
 
   def hardbreaks?
@@ -14,29 +14,25 @@ module Bookish
 
   # 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 h1; api.out "<h1>#{api.data}</h1>"; end
+  def h2; api.out "<h2>#{api.data}</h2>"; end
+  def h3; api.out "<h3>#{api.data}</h3>"; end
 
   def alpha_columns(args = nil, body = nil)
-    n = @_args.first.to_i   # FIXME: what if missing?
+    n = api.args.first.to_i   # FIXME: what if missing?
     words = []
-    _body do |line| 
+    api.body do |line| 
       words << line.chomp
     end
     words.sort!
-    _out "<table cellpadding=2>"
+    api.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>"
+      api.out "<tr><td width=5% valign=top></td><td>" + items.join("</td><td>") + "</td></tr>"
     end
-    _out "</table>"
+    api.out "</table>"
   end
 
-  # def comment
-  #   _body { }  # ignore body
-  # end
-
   def _errout(*args)
     ::STDERR.puts *args
   end
@@ -46,37 +42,39 @@ module Bookish
   end
 
   def _slug(str)
-    s2 = str.chomp.strip.gsub(/[?:,()'"\/]/,"").gsub(/ /, "-").downcase
-  # _errout "SLUG: #{str} => #{s2}"
-    s2
+    str2 = str.chomp.strip
+    str2 = str2.gsub(/[?:,()'"\/]/,"")
+    str2 = str2.gsub(/ /, "-")
+    str2.downcase!
+    str2
   end
 
-
   # FIXME duplicated?
+
   def image(args = nil, body = nil)
-    name = @_args[0]
-    _out "<img src='#{name}'></img>"
+    name = api.args[0]
+    api.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>"
+    name = api.args[0]
+    num = api.args[1]
+    title = api.args[2..-1].join(" ")
+    title = api.format(title)
+    api.out "<img src='#{name}'></img>"
+    api.out "<center><b>Figure #{num}</b> #{title}</center>"
   end
 
   def chapter(args = nil, body = nil)
   # _errout("chapter")
-    @chapter = @_args.first.to_i
+    @chapter = api.args.first.to_i
     @sec = @sec2 = 0
-    title = @_data.split(" ",2)[1]
+    title = api.data.split(" ",2)[1]
     @toc << "<br><b>#@chapter</b> #{title}<br>"
-    @_data = _slug(title)
+    api.data = _slug(title)
     next_output
-    _out "<title>#{@chapter}. #{title}</title>"
-    _out <<-HTML
+    api.out "<title>#{@chapter}. #{title}</title>"
+    api.out <<-HTML
       <h2>Chapter #{@chapter}</h2>
       <h1>#{title}</h1>
 
@@ -86,13 +84,13 @@ module Bookish
   def chapterN(args = nil, body = nil)
     @chapter += 1
     @sec = @sec2 = 0
-    title = @_data    # .split(" ",2)[1]
+    title = api.data    # .split(" ",2)[1]
     _errout("Chapter #@chapter: #{title}")
     @toc << "<br><b>#@chapter</b> #{title}<br>"
-    @_data = _slug(title)
+    api.data = _slug(title)
     next_output
-    _out "<title>#{@chapter}. #{title}</title>"
-    _out <<-HTML
+    api.out "<title>#{@chapter}. #{title}</title>"
+    api.out <<-HTML
       <h2>Chapter #{@chapter}</h2>
       <h1>#{title}</h1>
 
@@ -103,80 +101,79 @@ module Bookish
     @sec += 1
     @sec2 = 0
     @section = "#@chapter.#@sec"
-    title = @_data.dup
+    title = api.data.dup
     @toc << "#{_nbsp(3)}<b>#@section</b> #{title}<br>"
-    @_data = _slug(@_data)
+    api.data = _slug(api.data)
     next_output
-    _out "<h3>#@section #{title}</h3>\n"
+    api.out "<h3>#@section #{title}</h3>\n"
   rescue => err
-    STDERR.puts "#{err}\n#{err.backtrace}"
+    ::STDERR.puts "#{err}\n#{err.backtrace}"
     exit
   end
 
   def subsec(args = nil, body = nil)
     @sec2 += 1
     @subsec = "#@chapter.#@sec.#@sec2"
-    title = @_data.dup
+    title = api.data.dup
     @toc << "#{_nbsp(6)}<b>#@subsec</b> #{title}<br>"
-    @_data = _slug(@_data)
+    api.data = _slug(api.data)
     next_output
-    _out "<h3>#@subsec #{title}</h3>\n"
+    api.out "<h3>#@subsec #{title}</h3>\n"
   end
 
   def definition_table(args = nil, body = nil)
-    title = @_data
+    title = api.data
     wide = "95"
     delim = " :: "
-    _out "<br><center><table width=#{wide}% cellpadding=5>"
-    lines = _body(true)
-    lines.map! {|line| _format(line) }
+    api.out "<br><center><table width=#{wide}% cellpadding=5>"
+    lines = api.body(true)
+    lines.map! {|line| api.format(line) }
 
     lines.each do |line|
       cells = line.split(delim)
-      _out "<tr>"
+      api.out "<tr>"
       cells.each.with_index do |cell, i| 
         width = (i == 0) ? "width=15%" : ""
-        _out "  <td #{width} valign=top>#{cell}</td>"
+        api.out "  <td #{width} valign=top>#{cell}</td>"
       end
-      _out "</tr>"
+      api.out "</tr>"
     end
-    _out "</table></center><br><br>"
+    api.out "</table></center><br><br>"
 
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def table2(args = nil, body = nil)
-    title = @_data
+    title = api.data
     wide = "90"
-    extra = _args[2]
+    extra = api.args[2]
     delim = " :: "
-    _out "<br><center><table width=#{wide}% cellpadding=5>"
-    lines = _body(true)
-    lines.map! {|line| _format(line) }
+    api.out "<br><center><table width=#{wide}% cellpadding=5>"
+    lines = api.body(true)
+    lines.map! {|line| api.format(line) }
 
     lines.each do |line|
       cells = line.split(delim)
       percent = (100/cells.size.to_f).round
-      _out "<tr>"
+      api.out "<tr>"
       cells.each do |cell| 
-        _out "  <td width=#{percent}% valign=top " + 
+        api.out "  <td width=#{percent}% valign=top " + 
               "#{extra}>#{cell}</td>"
       end
-      _out "</tr>"
+      api.out "</tr>"
     end
-    _out "</table></center><br><br>"
-
-    _optional_blank_line
+    api.out "</table></center><br><br>"
+    api.optional_blank_line
   end
 
   def simple_table(args = nil, body = nil)
-    title = @_data
+    title = api.data
     delim = " :: "
-    _out "<table cellpadding=2>"
-    lines = _body(true)
+    api.out "<table cellpadding=2>"
+    lines = api.body(true)
     maxw = nil
     lines.each do |line|
-      _format(line)
+      api.format(line)
       cells = line.split(delim)
       wide = cells.map {|x| x.length }
       maxw = [0] * cells.size
@@ -188,26 +185,27 @@ module Bookish
 
     lines.each do |line|
       cells = line.split(delim)
-      _out "<tr>"
+      api.out "<tr>"
       cells.each.with_index do |cell, i| 
-        _out "  <td width=#{maxw}% valign=top>" + 
+        api.out "  <td width=#{maxw}% valign=top>" + 
               "#{cell}</td>"
       end
-      _out "</tr>"
+      api.out "</tr>"
     end
-    _out "</table>"
+    api.out "</table>"
+    api.optional_blank_line
   end
 
   def table(args = nil, body = nil)
     @table_num ||= 0
     @table_num += 1
-    title = @_data
+    title = api.data
     delim = " :: "
-    _out "<br><center><table width=90% cellpadding=5>"
-    lines = _body(true)
+    api.out "<br><center><table width=90% cellpadding=5>"
+    lines = api.body(true)
     maxw = nil
     lines.each do |line|
-      _format(line)
+      api.format(line)
       cells = line.split(delim)
       wide = cells.map {|x| x.length }
       maxw = [0] * cells.size
@@ -219,17 +217,18 @@ module Bookish
 
     lines.each do |line|
       cells = line.split(delim)
-      _out "<tr>"
+      api.out "<tr>"
       cells.each.with_index do |cell, i| 
-        _out "  <td width=#{maxw}% valign=top>" + 
+        api.out "  <td width=#{maxw}% valign=top>" + 
               "#{cell}</td>"
       end
-      _out "</tr>"
+      api.out "</tr>"
     end
-    _out "</table>"
+    api.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>"
+    api.out "<b>Table #@chapter.#@table_num &nbsp;&nbsp; #{title}</b></center><br>"
+    api.optional_blank_line
   end
 
   def toc!(args = nil, body = nil)
@@ -242,7 +241,7 @@ module Bookish
   end
 
   def toc2(args = nil, body = nil)
-    file = @_args[0]
+    file = api.args[0]
     @toc.close
     ::File.write(file, <<-EOS)
   <p style="page-break-after:always;"></p>
@@ -255,28 +254,28 @@ module Bookish
   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 "
+    @toc << "#{_nbsp(8)}<font color=red>TBD: #{api.data}</font><br>"
+    stuff = api.data.empty? ? "" : ": #{api.data}"
+    api.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>"
+    api.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 "
+    api.out "<br><font color=red><i>Note: "
+    api.out api.data 
+    api.out "</i></font><br>\n "
   end
 
   def quote(args = nil, body = nil)
-    _out "<blockquote>"
-    _body {|line| _out line }
-    _out "</blockquote>"
+    api.out "<blockquote>"
+    api.body {|line| api.out line }
+    api.out "</blockquote>"
   rescue => err
-    STDERR.puts "#{err}\n#{err.backtrace}"
+    ::STDERR.puts "#{err}\n#{err.backtrace}"
     exit
   end
 

data/imports/calibre.rb

@@ -2,9 +2,9 @@ require 'fileutils'
 
 module Calibre 
   def epub!(args = nil, body = nil)
-    out = _format(@_args[0])
-    src = @_args[1]
-    @cover = @_args[2]
+    out = api.format(api.args[0])
+    src = api.args[1]
+    @cover = api.args[2]
     if ::File.directory?(src)
       files = ::Dir["#{src}/*"].grep /\.html$/
       files = files.sort  # why is this necessary now?

data/imports/livemagick.rb

@@ -4,24 +4,24 @@ module Livemagick     # FIXME auto-mangle names
   include ::Magick
 
   def image(args = nil, body = nil)
-    xx, yy, bg = _args
+    xx, yy, bg = api.args
     xx, yy = xx.to_i, yy.to_i
     @image = Image.new(xx,yy) { self.background_color = bg }
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def canvas(args = nil, body = nil)
-    color, width, opacity = _args
+    color, width, opacity = api.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
+    api.optional_blank_line
   end
 
   def rectangle(args = nil, body = nil)
-    xy, wxh, stroke_color, stroke_width = _args
+    xy, wxh, stroke_color, stroke_width = api.args
     x, y = xy.split(",").map(&:to_i)
     width, height = wxh.split("x").map(&:to_i)
     stroke_width = stroke_width.to_i
@@ -32,19 +32,19 @@ module Livemagick     # FIXME auto-mangle names
   end
 
   def pen(args = nil, body = nil)
-    @fill, @stroke = _args
+    @fill, @stroke = api.args
     @stroke = "black" if @stroke.nil? || @stroke.empty?
     _debug "pen: fill=#@fill stroke=#@stroke"
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def font(args = nil, body = nil)
-    size, font = _args
+    size, font = api.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
+    api.optional_blank_line
   end
 
   def _text(xy, wxh, str, weight, gravity)
@@ -62,34 +62,34 @@ module Livemagick     # FIXME auto-mangle names
   end
 
   def text(args = nil, body = nil)
-    xy, wxh, str = _data.split
+    xy, wxh, str = api.data.split
     weight, gravity = BoldWeight, CenterGravity
     _text(xy, wxh, str, weight, gravity)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def text!(args = nil, body = nil)
-    xy, wxh = _data.split
-    str = _body_text  # .join
+    xy, wxh = api.data.split
+    str = api.body_text  # .join
     weight, gravity = BoldWeight, CenterGravity
     _text(xy, wxh, str, weight, gravity)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def draw(args = nil, body = nil)
     @canvas.draw(@image)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def save(args = nil, body = nil)
     @image.write(_args.first)
-    _optional_blank_line
+    api.optional_blank_line
   end
 
   def save!(args = nil, body = nil)
     save
     system("open #{_args.first}")
-    _optional_blank_line
+    api.optional_blank_line
   end
 end
 =begin

data/imports/markdown.rb

@@ -9,12 +9,12 @@ module Markdown
   SimpleFormats[:s] = %w[<strike> </strike>]
 
 
-  def h1(args = nil, body = nil); _out "# #{Livetext.interpolate(@_data)}"; _optional_blank_line end       # atx style for now
-  def h2(args = nil, body = nil); _out "## #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-  def h3(args = nil, body = nil); _out "### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-  def h4(args = nil, body = nil); _out "#### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-  def h5(args = nil, body = nil); _out "##### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
-  def h6(args = nil, body = nil); _out "###### #{Livetext.interpolate(@_data)}"; _optional_blank_line end
+  def h1(args = nil, body = nil); api.out "# #{Livetext.interpolate(api.data)}"; api.optional_blank_line end       # atx style for now
+  def h2(args = nil, body = nil); api.out "## #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+  def h3(args = nil, body = nil); api.out "### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+  def h4(args = nil, body = nil); api.out "#### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+  def h5(args = nil, body = nil); api.out "##### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
+  def h6(args = nil, body = nil); api.out "###### #{Livetext.interpolate(api.data)}"; api.optional_blank_line end
 
   def title(args = nil, body = nil)
     h1
@@ -25,18 +25,18 @@ module Markdown
   end
 
   def bq(args = nil, body = nil)   # block quote
-    _body {|line| _out "> #{line}" }
+    api.body {|line| api.out "> #{line}" }
   end
 
   def list(args = nil, body = nil)
-    _body {|line| _out " * #{line}" }
+    api.body {|line| api.out " * #{line}" }
   end
 
   def olist(args = nil, body = nil)   # Doesn't handle paragraphs yet
     n = 0
-    _body do |line|
+    api.body do |line|
       n += 1
-      _out "#{n}. #{_format(line)}"
+      api.out "#{n}. #{_format(line)}"
     end
   end