livetext 0.9.11 → 0.9.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f49173986fc8a17fc77f35032e823f4818d404007d5aacd2d3d5a4a74f19e02
-  data.tar.gz: 61c0eab54d60c23abe0c27a6b8adc16f621e35c347253b557f07ffc80b31f80e
+  metadata.gz: d027612469e45b953a3e8589ebbedf1f746f87f50c4a90b502f4daac56d28605
+  data.tar.gz: b811285f434d3b2760e201eb403f864ba31cb12e31f21105fc8c4fe5e3b743a2
 SHA512:
-  metadata.gz: '07389bbd1154d200f6f56b0373c0459bf140baeefa370d789224f2dedd53fe5120f0f7116e2c9d1381ff07a48f945786bb8e5f3478ac9002aea0f9443f61f579'
-  data.tar.gz: 12829e57528407a55f842f8ad8de77b47396cb6fffb22d76feaf8d98d644ebf00fc50d447a24f453026980a7cb7631443e11f9f7d67121ce9529d583ef85e513
+  metadata.gz: 1e1b08d7d900ae551d7777576a7284d776422d2039813a764c3d9d9b0495ac14eec4e53225e1e0f3b97a1a548377f14b861e72d4b24d2a52055cd0f75404d2bf
+  data.tar.gz: 025055edd14e392750b482f4b0a9a973f213b24a5991bb9c7e9939c225a21bfe77398cc118983599a0fd1ccf1c1aa4c8bbf62874745a2cf5257410b747db72ee

data/README.lt3

@@ -1,5 +1,5 @@
-.mixin tutorial
-.mixin markdown
+.icanhaz tutorial
+.icanhaz markdown
 
 . copy basic.css
 

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

@@ -0,0 +1,15 @@
+
+# More later?
+
+def make_exception(sym, str, target_class = Object)
+  return if target_class.constants.include?(sym)
+  klass = sym   # :"#{sym}_Class"
+  target_class.const_set(klass, StandardError.dup)
+  define_method(sym) do |*args|
+    args = [] unless args.first
+    msg = str.dup
+    args.each.with_index {|arg, i| msg.sub!("%#{i+1}", arg) }
+    target_class.class_eval(klass.to_s).new(msg)
+  end
+end
+

data/lib/formatline.rb

@@ -1,4 +1,7 @@
-class FormatLine
+# 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>]
@@ -21,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
@@ -42,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
@@ -69,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)
@@ -127,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 = ""
@@ -184,7 +167,7 @@ class FormatLine
       end
     end
 
-    add curr
+    add peek
     grab
     param = nil if param.empty?
     param
@@ -204,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
@@ -216,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
@@ -226,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
@@ -234,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
@@ -255,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
 
@@ -272,7 +255,7 @@ class FormatLine
     end
 
     grab
-    case curr
+    case peek
       when Space
         add char + " "
         add_token :str
@@ -283,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
@@ -316,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
@@ -341,8 +322,8 @@ class FormatLine
   end
 
   def escaped
-    ch = grab
     grab
+    ch = grab
     ch
   end
 
@@ -353,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
@@ -373,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
@@ -393,13 +371,6 @@ class FormatLine
     result
   end
 
-  #####
-
-  def showme(tag)
-    char = @line[@cc]
-    puts "--- #{tag}: ch=#{@ch.inspect} next=#{@next.inspect} (cc=#@cc:#{char.inspect})   out=#{@out.inspect}"
-  end
-
   def embedded?
     ! (['"', "'", " ", nil].include? prev)
   end

data/lib/functions.rb

@@ -1,6 +1,10 @@
-require 'standard'  # FIXME
 
-class Livetext::Functions    # Functions will go here... user-def AND pre-def??
+require_relative 'standard'  # FIXME  umm, why is this necessary??
+
+# Class Functions is where '$$func' functions are stored dynamically... 
+# user-def AND pre-def??
+
+class Livetext::Functions
   Formats = ::Livetext::Standard::SimpleFormats
 
   @param = nil

data/lib/handler/icanhaz.rb

@@ -0,0 +1,35 @@
+
+class Livetext::Handler::ICanHaz
+  include Helpers
+
+  attr_reader :file
+
+  def initialize(name)
+    @name = name
+    @file = find_file(name)
+  end
+
+  def self.get_module(name)
+    handler = self.new(name)
+    const1 = Object.constants
+    @file = handler.file.sub(/.rb$/, "")
+    require @file   # + ".rb"
+    const2 = Object.constants
+    names = (const2 - const1)
+    abort "Expected ONE new constant: #{names.inspect}" if names.size != 1
+    modname = names.first.to_s
+    newmod = Object.const_get("::" + modname)
+    newmod   # return actual module
+  end
+
+  private
+
+  def cwd_root?
+    File.dirname(File.expand_path(".")) == "/"
+  end
+
+  def fname2module(name)
+  end
+
+end
+

data/lib/handler.rb

@@ -0,0 +1 @@
+require_relative 'handler/icanhaz'

data/lib/helpers.rb

@@ -0,0 +1,194 @@
+
+module Helpers
+
+  Space = " "
+  Sigil = "." # Can't change yet
+
+  def escape_html(string)
+    enc = string.encoding
+    unless enc.ascii_compatible?
+      if enc.dummy?
+        origenc = enc
+        enc = Encoding::Converter.asciicompat_encoding(enc)
+        string = enc ? string.encode(enc) : string.b
+      end
+      table = Hash[TABLE_FOR_ESCAPE_HTML__.map {|pair|pair.map {|s|s.encode(enc)}}]
+      string = string.gsub(/#{"['&\"<>]".encode(enc)}/, table)
+      string.encode!(origenc) if origenc
+      return string
+    end
+    string.gsub(/['&\"<>]/, TABLE_FOR_ESCAPE_HTML__)
+  end
+
+  def find_file(name, ext=".rb")
+    paths = [Livetext::Path.sub(/lib/, "imports/"), "./"]
+    base  = "#{name}#{ext}"
+    paths.each do |path|
+      file = path + base
+      return file if File.exist?(file)
+    end
+
+    raise "No such mixin '#{name}'"
+
+    # # Really want to search upward??
+    # raise "No such mixin '#{name}'" if cwd_root?
+    # Dir.chdir("..") { find_file(name) }
+  end
+
+  def self.rx(str, space=nil)
+    Regexp.compile("^" + Regexp.escape(str) + "#{space}")
+  end
+
+  Comment  = rx(Sigil, Space)
+  Dotcmd   = rx(Sigil)
+  Ddotcmd  = /^ *\$\.[A-Za-z]/
+
+## FIXME process_file[!] should call process[_text]
+
+  def process_file(fname, btrace=false)
+    setfile(fname)
+    text = File.readlines(fname)
+    enum = text.each
+    @backtrace = btrace
+    @main.source(enum, fname, 0)
+    line = nil
+    loop do 
+      line = @main.nextline
+      break if line.nil?
+      process_line(line)
+    end
+    val = @main.finalize if @main.respond_to? :finalize
+    @body
+  end
+
+  def process_line(line)  # FIXME inefficient?
+    nomarkup = true
+    case line  # must apply these in order
+      when Comment
+        handle_scomment(line)
+      when Dotcmd
+        handle_dotcmd(line)
+      when Ddotcmd
+        indent = line.index("$") + 1
+        @indentation.push(indent)
+        line.sub!(/^ *\$/, "")
+        handle_dotcmd(line)
+        indentation.pop
+    else
+      @main._passthru(line)
+    end
+  end
+
+  def handle_dotcmd(line, indent = 0)
+    indent = @indentation.last # top of stack
+    line = line.sub(/# .*$/, "")
+    name = get_name(line).to_sym
+    result = nil
+    case
+      when name == :end   # special case
+        puts @body
+        raise EndWithoutOpening()
+      when @main.respond_to?(name)
+        result = @main.send(name)
+    else
+      puts @body  # earlier correct output, not flushed yet
+      raise "Name '#{name}' is unknown"
+      return
+    end
+    result
+  end
+
+  def handle_scomment(line)
+  end
+
+  def get_name(line)
+    name, data = line.split(" ", 2)
+    name = name[1..-1]  # chop off sigil
+    name = "dot_" + name if %w[include def].include?(name)
+    @main.data = data
+    @main.check_disallowed(name)
+    name
+  end
+
+  def check_disallowed(name)
+    raise DisallowedName(name) if disallowed?(name)
+  end
+
+  def check_file_exists(file)
+    raise FileNotFound(file) unless File.exist?(file)
+  end
+
+  def set_variables(pairs)
+    pairs.each do |pair|
+      var, value = *pair
+      @parent.setvar(var, value)
+    end
+  end
+
+  def grab_file(fname)
+    File.read(fname)
+  end
+
+  def search_upward(file)
+    value = nil
+    return file if File.exist?(file)
+
+    count = 1
+    loop do
+      front = "../" * count
+      count += 1
+      here = Pathname.new(front).expand_path.dirname.to_s
+      break if here == "/"
+      path = front + file
+      value = path if File.exist?(path)
+      break if value
+    end
+    STDERR.puts "Cannot find #{file.inspect} from #{Dir.pwd}" unless value
+	  return value
+  rescue
+    STDERR.puts "Can't find #{file.inspect} from #{Dir.pwd}"
+	  return nil
+  end
+
+  def include_file(file)
+    @_args = [file]
+    dot_include
+  end
+
+  def onoff(arg)   # helper
+    arg ||= "on"
+    raise ExpectedOnOff unless String === arg
+    case arg.downcase
+      when "on"
+        return true
+      when "off"
+        return false
+    else
+      raise ExpectedOnOff
+    end
+  end
+
+  def setvar(var, val)
+    str, sym = var.to_s, var.to_sym
+    Livetext::Vars[str] = val
+    Livetext::Vars[sym] = val
+    @_vars[str] = val
+    @_vars[sym] = val
+  end
+
+  def setfile(file)
+    if file
+      setvar(:File, file)
+      dir = File.dirname(File.expand_path(file))
+      setvar(:FileDir, dir)
+    else
+      setvar(:File,    "[no file]")
+      setvar(:FileDir, "[no dir]")
+    end
+  end
+
+  def setfile!(file)  # FIXME why does this variant exist?
+    setvar(:File, file)
+  end
+
+end