livetext 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df24e0cbe9a3f4391eef57d4bd0574711e65e175
-  data.tar.gz: 891f6d330f4e6d2fd0decd0f863ac40deb1f5d77
+  metadata.gz: 51b98abafb62da3270ae601664283dbdeddcbd18
+  data.tar.gz: 579b07876a855105028a3758980784eaa45dedaa
 SHA512:
-  metadata.gz: c36b73c36a7098e92454da35e1a6087a1bd0e50b1c351e5f6a235ca2988df79e211b47a934a68fb8aaf494cdda07e022c3607eca24d0cc9cdfa52e6bea6b7e8f
-  data.tar.gz: 8019031d4822367265d76cfc14218d1ab3c572068091936fff7fca59187f6f82c4c17101bec018ddaa0aee05c03b8cf2fdb6a332f6f1f20c3ec44b5fadfd454b
+  metadata.gz: f64fa18bf90f23c2ff4626dacce8a8ced320f45eb7e0c2d3b0b43d789b9d60ea24aa59177d9eedee4a5d91c280f2a0ddfe003b2cef1716aa4fa60635d70ab15a
+  data.tar.gz: 38ebabd3efb44a08ae48996fc08be4e7307bfd1b6f3f426c2938333658a02768703a7f0cfc181cb4d96b83dd91744a9012579ad6c51259c55ba8670e9a7ee020

data/lib/livetext.rb

@@ -1,5 +1,15 @@
+class Livetext
+  VERSION = "0.7.2"
+end
+
 require 'fileutils'
 
+$: << "/Users/Hal/Desktop/Personal/Dropbox/files/livetext/lib"
+
+require 'functions'
+require 'userapi'
+require 'standard'
+
 Plugins = File.expand_path(File.join(File.dirname(__FILE__), "../dsl"))
 
 TTY = ::File.open("/dev/tty", "w")
@@ -8,9 +18,10 @@ require_relative "#{Plugins}/pyggish"
 
 
 class Livetext
-  VERSION = "0.7.1"
 
-  Space = " "
+  class Processor
+    include Livetext::Standard
+    include Livetext::UserAPI
 
   Disallowed = [:nil?, :===, :=~, :!~, :eql?, :hash, :<=>, 
                 :class, :singleton_class, :clone, :dup, :taint, :tainted?, 
@@ -25,17 +36,64 @@ class Livetext
                 :enum_for, :pretty_inspect, :==, :equal?, :!, :!=, :instance_eval, 
                 :instance_exec, :__send__, :__id__, :__binding__]
 
-  class Functions    # Functions will go here... user-def AND pre-def??
-    def date
-      Time.now.strftime("%F")
+    def initialize(parent, output)
+      @parent = parent
+      @_nopass = false
+      @_nopara = false
+      @output = output
+      @vars = {}
+      @sources = []
     end
 
-    def time
-      Time.now.strftime("%F")
+    def _error!(err, abort=true, trace=false)
+      STDERR.puts "Error: #{err} (at #{@sources.last[1]} line #{@sources.last[2]})"
+#     STDERR.puts err.backtrace if err.respond_to? :backtrace # trace
+      exit if abort
     end
+
+    def _disallowed?(name)
+      Disallowed.include?(name.to_sym)
+    end
+
+    def source(enum, file, line)
+      @sources.push([enum, file, line])
+    end
+
+    def peek_nextline
+      @sources.last[0].peek
+    rescue StopIteration
+      @sources.pop
+      nil
+    end
+
+    def nextline
+      return nil if @sources.empty?
+      line = @sources.last[0].next
+      @sources.last[2] += 1
+      line
+    rescue StopIteration
+      @sources.pop
+      nil
+    end
+
+    def grab_file(fname)
+      File.read(fname)
+    end
+
+  end
+
+####
+
+  Space = " "
+
+  def initialize(output = ::STDOUT)
+    @_mixins = []
+    @_outdir = "."
+    @_file_num = 0
+    @main = Processor.new(self, output)
   end
 
-  def handle_line(line, sigil=".")
+  def process_line(line, sigil=".")
     nomarkup = true
     # FIXME inefficient
     scomment  = rx(sigil, Livetext::Space)  # apply these in order
@@ -45,42 +103,21 @@ class Livetext
     elsif line =~ sname 
       handle_sname(line)
     else
-      _passthru(line)
+      @main._passthru(line)
     end
   end
 
-  def peek_nextline
-    @sources.last[0].peek
-  rescue StopIteration
-    @sources.pop
-    nil
-  end
-
-  def nextline
-    return nil if @sources.empty?
-    line = @sources.last[0].next
-    @sources.last[2] += 1
-    line
-  rescue StopIteration
-    @sources.pop
-    nil
-  end
-
   def process_file(fname)
     enum = File.readlines(fname).each
-    _check_existence(fname, "No such file '#{fname}' to process")
-    @sources.push [enum, fname, 0]
+    raise "No such file '#{fname}' to process" unless File.exist?(fname)
+    @main.source(enum, fname, 0)
     loop do 
-      line = nextline
+      line = @main.nextline
       break if line.nil?
-      handle_line(line)
+      process_line(line)
     end
   end
 
-  def grab_file(fname)
-    File.read(fname)
-  end
-
   def rx(str, space=nil)
     Regexp.compile("^" + Regexp.escape(str) + "#{space}")
   end
@@ -88,465 +125,27 @@ class Livetext
   def handle_scomment(line, sigil=".")
   end
 
-  def _disallowed?(name)
-    Livetext::Disallowed.include?(name.to_sym)
-  end
-
   def _get_name(line, sigil=".")
-    name, @_data = line.split(" ", 2)
+    name, data = line.split(" ", 2)
     name = name[1..-1]  # chop off sigil
-    @_args = @_data.split
-    _error! "Name '#{name}' is not permitted" if _disallowed?(name)
+    @main.data = data
+    @main._error! "Name '#{name}' is not permitted" if @main._disallowed?(name)
     name = "_def" if name == "def"
     name = "_include" if name == "include"
-    _error! "Mismatched 'end'" if name == "end"
+    @main._error! "Mismatched 'end'" if name == "end"
     name
   end
 
   def handle_sname(line, sigil=".")
     name = _get_name(line, sigil=".")
-    unless self.respond_to?(name)
-      _error! "Name '#{name}' is unknown"
+    unless @main.respond_to?(name)
+      @main._error! "Name '#{name}' is unknown"
       return
     end
-    self.send(name)
+    @main.send(name)
   rescue => err
-    _error!(err)
-  end
-
-# include ::Livetext::Helpers
-  def _error!(err, abort=true, trace=false)
-    STDERR.puts "Error: #{err} (at #{@sources.last[1]} line #{@sources.last[2]})"
-    STDERR.puts err.backtrace if trace
-    exit if abort
-  end
-
-  def _check_existence(file, msg)
-    _error! msg unless File.exist?(file)
-  end
-
-  def _source
-    @input
-  end
-
-  def _args
-    if block_given?
-      @_args.each {|arg| yield arg }
-    else
-      @_args
-    end
-  end
-
-  def _optional_blank_line
-    @line = nextline if peek_nextline =~ /^ *$/
-  end
-
-  def _comment?(str, sigil=".")
-    c1 = sigil + Livetext::Space
-    c2 = sigil + sigil + Livetext::Space
-    str.index(c1) == 0 || str.index(c2) == 0
-  end
-
-  def _trailing?(char)
-    return true if ["\n", " ", nil].include?(char)
-    return false
-  end
-
-  def _end?(str, sigil=".")
-    cmd = sigil + "end"
-    return false if str.index(cmd) != 0 
-    return false unless _trailing?(str[5])
-    return true
-  end
-
-  def _raw_body(tag = "__EOF__", sigil = ".")
-    lines = []
-    loop do
-      @line = nextline
-      break if @line.chomp.strip == tag
-      lines << @line
-    end
-    _optional_blank_line
-    if block_given?
-      lines.each {|line| yield @line }
-    else
-      lines
-    end
-  end
-
-  def _body(sigil=".")
-    lines = []
-    loop do
-      @line = nextline
-      break if _end?(@line, sigil)
-      next if _comment?(@line, sigil)
-      lines << @line
-    end
-    _optional_blank_line
-    if block_given?
-      lines.each {|line| yield line }
-    else
-      lines
-    end
-  end
-
-  def _body!(sigil=".")
-    _body(sigil).join("\n")
-  end
-
-  def _basic_format(line, delim, tag)
-    s = line.each_char
-    c = s.next
-    last = nil
-    getch = -> { last = c; c = s.next }
-    buffer = ""
-    loop do
-      case c
-        when " "
-          buffer << " "
-          last = " "
-        when delim
-          if last == " " || last == nil
-            buffer << "<#{tag}>"
-            c = getch.call
-            if c == "("
-              loop { getch.call; break if c == ")"; buffer << c }
-              buffer << "</#{tag}>"
-            else
-              loop { buffer << c; getch.call; break if c == " " || c == nil || c == "\n" }
-              buffer << "</#{tag}>"
-              buffer << " " if c == " "
-            end
-          else
-            buffer << delim
-          end
-      else
-        buffer << c
-      end
-      getch.call
-    end
-    buffer
-  end
-
-  def _handle_escapes(str, set)
-    str = str.dup
-    set.each_char do |ch|
-      str.gsub!("\\#{ch}", ch)
-    end
-    str
-  end
-
-  def _formatting(line)
-    l2 = _basic_format(line, "_", "i")
-    l2 = _basic_format(l2, "*", "b")
-    l2 = _basic_format(l2, "`", "tt")
-    l2 = _handle_escapes(l2, "_*`")
-    line.replace(l2)
-  end
-
-  def _substitution(line)   # FIXME handle functions separately later??
-    fobj = ::Livetext::Functions.new
-    @funcs = ::Livetext::Functions.instance_methods
-    @funcs.each do |func|
-      name = ::Regexp.escape("$$#{func}")
-      rx = /#{name}\b/
-      line.gsub!(rx) do |str| 
-        val = fobj.send(func)
-        str.sub(rx, val)
-      end
-    end
-    @vars.each_pair do |var, val|
-      name = ::Regexp.escape("$#{var}")
-      rx = /#{name}\b/
-      line.gsub!(rx, val)
-    end
-    line
-  end
-
-  def _passthru(line)
-    return if @_nopass
-TTY.puts "nopara = #@_nopara"
-    _puts "<p>" if line == "\n" and ! @_nopara
-    _formatting(line)
-    _substitution(line)
-    _puts line
-  end
-
-  def _puts(*args)
-    @output.puts *args
-  end
-
-  def _print(*args)
-    @output.print *args
-  end
-
-  def _debug=(val)
-    @_debug = val
+    @main._error!(err)
   end
 
-  def _debug(*args)
-    TTY.puts *args if @_debug
-  end
-
-# include ::Livetext::Standard
-
-  def comment
-    junk = _body  # do nothing with contents
-  end
-
-  def shell
-    cmd = @_data
-    _errout("Running: #{cmd}")
-    system(cmd)
-  end
-
-  def func
-    funcname = @_args[0]
-    _error! "Illegal name '#{funcname}'" if _disallowed?(funcname)
-    func_def = <<-EOS
-      def #{funcname}
-        #{_body!}
-      end
-    EOS
-    Livetext::Functions.class_eval func_def
-  end
-
-  def shell!
-    cmd = @_data
-    system(cmd)
-  end
-
-  def errout
-    TTY.puts @_data
-  end
-
-  def say
-    str = _substitution(@_data)
-    TTY.puts str
-    _optional_blank_line
-  end
-
-  def banner
-    str = _substitution(@_data)
-    n = str.length - 1
-    _errout "-"*n
-    _errout str
-    _errout "-"*n
-  end
-
-  def quit
-    @output.close
-    exit
-  end
-
-  def outdir
-    @_outdir = @_args.first
-    _optional_blank_line
-  end
-
-  def outdir!  # FIXME ?
-    @_outdir = @_args.first
-    raise "No output directory specified" if @_outdir.nil?
-    raise "No output directory specified" if @_outdir.empty?
-    system("rm -f #@_outdir/*.html")
-    _optional_blank_line
-  end
-
-  def _output(name)
-    @output.close unless @output == STDOUT
-    @output = File.open(@_outdir + "/" + name, "w")
-    @output.puts "<meta charset='UTF-8'>\n\n"
-  end
-
-  def _append(name)
-    @output.close unless @output == STDOUT
-    @output = File.open(@_outdir + "/" + name, "a")
-    @output.puts "<meta charset='UTF-8'>\n\n"
-  end
-
-  def output
-    name = @_args.first
-    _debug "Redirecting output to: #{name}"
-    _output(name)
-  end
-
-  def append
-    file = @_args[0]
-    _append(file)
-  end
-
-  def next_output
-    tag, num = @_args
-    _next_output(tag, num)
-    _optional_blank_line
-  end
-
-  def cleanup
-    @_args.each do |item| 
-      if ::File.directory?(item)
-        system("rm -f #{item}/*")
-      else
-        ::FileUtils.rm(item)
-      end
-    end
-  end
-
-  def _next_output(tag = "sec", num = nil)
-    @_file_num = num ? num : @_file_num + 1
-    @_file_num = @_file_num.to_i
-    name = "#{'%03d' % @_file_num}-#{tag}.html"
-    _output(name)
-  end
-
-  def _def
-    name = @_args[0]
-    str = "def #{name}\n"
-    raise "Illegal name '#{name}'" if _disallowed?(name)
-    str += _body!
-    str += "end\n"
-    eval str
-  rescue => err
-    _error!(err)
-  end
-
-  def nopass
-    @_nopass = true
-  end
-
-  def set
-    assigns = @_data.chomp.split(/, */)
-    assigns.each do |a| 
-      var, val = a.split("=")
-      val = val[1..-2] if val[0] == ?" and val[-1] == ?"
-      val = val[1..-2] if val[0] == ?' and val[-1] == ?'
-      @vars[var] = val
-    end
-    _optional_blank_line
-  end
-
-  def _include
-    file = @_args.first
-    _check_existence(file, "No such include file '#{file}'")
-    process_file(file)
-    _optional_blank_line
-  end
-
-  def include!    # FIXME huh?
-    file = @_args.first
-    return unless File.exist?(file)
-
-    lines = process_file(file)
-    File.delete(file)
-    _optional_blank_line
-  end
-
-  def mixin
-    name = @_args.first   # Expect a module name
-    file = "#{Plugins}/" + name.downcase + ".rb"
-    return if @_mixins.include?(name)
-    file = "./#{name}.rb" unless File.exist?(file)
-    _check_existence(file, "No such mixin '#{name}'")
-
-    @_mixins << name
-    meths = grab_file(file)
-    modname = name.gsub("/","_").capitalize
-    string = "module ::#{modname}\n#{meths}\nend"
-    eval(string)
-    newmod = Object.const_get("::" + modname)
-    self.extend(newmod)
-    init = "init_#{name}"
-    self.send(init) if self.respond_to? init
-    _optional_blank_line
-  end
-
-  def copy
-    file = @_args.first
-    _check_existence(file, "No such file '#{file}' to copy")
-    @output.puts grab_file(file)
-    _optional_blank_line
-  end
-
-  def r
-    _puts @_data  # No processing at all
-  end
-
-  def raw
-    # No processing at all (terminate with __EOF__)
-    _puts _raw_body  
-  end
-
-  def debug
-    arg = @_args.first
-    self._debug = true
-    self._debug = false if arg == "off"
-  end
-
-  def nopara
-    @_nopara = true
-  end
-
-  def heading
-    _print "<center><font size=+1><b>"
-    _print @_data
-    _print "</b></font></center>"
-  end
-
-  def newpage
-    _puts '<p style="page-break-after:always;"></p>'
-    _puts "<p/>"
-  end
-
-  def invoke(str)
-  end
-
-  def dlist
-    delim = "~~"
-    _puts "<table>"
-    _body do |line|
-      line = _formatting(line)
-      term, defn = line.split(delim)
-      _puts "<tr>"
-      _puts "<td width=3%><td width=10%>#{term}</td><td>#{defn}</td>"
-      _puts "</tr>"
-    end
-    _puts "</table>"
-  end
-
-######  Livetext
-
-  def initialize(input = ::STDIN, output = ::STDOUT)
-    @input = input
-    @output = output
-    @vars = {}
-    @_mixins = []
-    @source_files = []
-    @sources = []
-    @_outdir = "."
-    @_file_num = 0
-    @_nopass = false
-    @_nopara = false
-  end
-
-#   def method_missing(name, *args)
-# ::TTY.puts "MM: #{name}"
-#     name = "_def" if name.to_s == "def"
-#     name = "_include" if name.to_s == "include"
-#     @main.send(name, *args)
-# #     $mods.reverse.each do |mod|
-# #       if mod.respond_to?(name)
-# #         mod.send(name, *args)
-# #         return
-# #       end
-# #     end
-#     _puts "  Error: Method '#{name}' is not defined (from method_missing)"
-#     puts caller.map {|x| "  " + x }
-#     exit
-#   end
-
-end
-
-if $0 == __FILE__
-  x = Livetext.new
-  x.process_file(ARGV[0] || STDIN)
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: livetext
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Hal Fulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-15 00:00:00.000000000 Z
+date: 2017-03-17 00:00:00.000000000 Z
 dependencies: []
 description: A smart text processor extensible in Ruby
 email: rubyhacker@gmail.com