livetext 0.9.51 → 0.9.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1d0ef585b57b9cf3ffc439ab8dc44d67ba5b287219920121694d06a78558872
-  data.tar.gz: a73d887e9f053977c1c96b0b7ac8b1eb4bd8976180e5fee18ecb5ef5b5ca1e65
+  metadata.gz: 00c147a97637c967777f1a1a8bae52d8e0ca8e65f3e032e9a03f0f3bbc2c5d50
+  data.tar.gz: c931920c669cf05c76176d19bcfb9c06149d3bf6b32167aa2e6da7b50290adef
 SHA512:
-  metadata.gz: 4ceda09db8d0819b550c485af5fb3d5f6da2be17ce879a07c1199c31554f76550bebaf8bcc77e834ff20466eb859d3712996fd23d0c6812aba799809f6a66ada
-  data.tar.gz: 97c76c0a601541d78afa39da976fb966ee3a7917c065eb5589c70b755e8120f89916edbc7eacc72f02c4f76edcbadd839ed545e482b097e970e87602b59b4ecf
+  metadata.gz: 59836de9481a1239cf0c0f00f55681da634c7e96e337c67d2c4fb8974ec3dad06fa83bbe7eb7f73596c73d97e9359aab613efbf87d0ddfe70e9a3a50c65e931e
+  data.tar.gz: b0e1a74d2d75e8c47afff0881594d1022dbb63e71ec67b8304622b9885bc62429d6782286482a45520587207fc48e4158d0a857f51bcac5596c51cc779f2cf01

data/imports/bookish.rb

@@ -205,7 +205,7 @@ api.tty "## sec: cp 4"
     title = api.data
     delim = " :: "
     api.out "<br><center><table width=90% cellpadding=5>"
-    lines = api.body(true)
+    lines = body
     maxw = nil
     lines.each do |line|
       api.format(line)
@@ -238,8 +238,8 @@ api.tty "## sec: cp 4"
     _debug "Closing TOC"
     @toc.close
   rescue => err
-     puts @parent.body
-     @parent.body = ""
+     puts self.body
+     self.body = ""
     _errout "Exception: #{err.inspect}"
   end
 

data/lib/livetext/core.rb

@@ -8,7 +8,23 @@ class Livetext
 
   TTY = ::File.open("/dev/tty", "w")
 
-  attr_reader :main, :sources
+  Disallowed = 
+     %i[ __binding__        __id__            __send__          class
+         clone              display           dup               enum_for
+         eql?               equal?            extend            freeze
+         frozen?            hash              inspect           instance_eval   
+         instance_exec      instance_of?      is_a?             kind_of?
+         method             methods           nil?              object_id          
+         pretty_inspect     private_methods   protected_methods public_method
+         public_methods     public_send       respond_to?       send
+         singleton_class    singleton_method  singleton_methods taint
+         tainted?           tap               to_enum           to_s
+         trust              untaint           untrust           untrusted?
+         define_singleton_method              instance_variable_defined?
+         instance_variable_get                instance_variable_set
+         remove_instance_variable             instance_variables ]
+
+  attr_reader :sources, :function_registry, :variables, :formatter
   attr_accessor :nopass, :nopara
   attr_accessor :body, :indentation
 
@@ -17,7 +33,7 @@ class Livetext
   end
 
   def vars
-    @_vars
+    @variables
   end
 
   def self.interpolate(str)
@@ -27,16 +43,10 @@ class Livetext
     str3
   end
 
-  def peek_nextline
-    @main.peek_nextline  # delegate
-  end
 
-  def nextline
-    @main.nextline       # delegate
-  end
 
   def sources
-    @main.sources        # delegate
+    @sources        # delegate
   end
 
   def save_location
@@ -48,18 +58,15 @@ class Livetext
   end
 
   def initialize(output = ::STDOUT)  # Livetext
-    @source = nil
-    @_mixins = []
-    @_imports = []
-    @_outdir = "."
-    @no_puts = output.nil?
     @body = ""
-    @main = Processor.new(self, output)  # nil = make @main its own parent??
-    @parent = @main
     @indentation = [0]
-    @_vars = Livetext::Vars
     @api = UserAPI.new(self)
-    initial_vars
+    @output = ::Livetext.output = output
+    @html = Livetext::HTML.new(@api)
+    @sources = []
+    @function_registry = Livetext::FunctionRegistry.new
+    @variables = Livetext::VariableManager.new(self)
+    @formatter = Livetext::Formatter.new(self)
 # puts "------ init: self = "
 # p self
   end
@@ -71,7 +78,7 @@ class Livetext
     mix.each do |lib| 
       obj.invoke_dotcmd(:mixin, lib.dup)
     end
-    call.each {|cmd| obj.main.send(cmd[1..-1]) }  # ignores leading dot, no param
+    call.each {|cmd| obj.send(cmd[1..-1]) }  # ignores leading dot, no param
     obj.api.setvars(vars)
     obj
   end
@@ -80,22 +87,17 @@ class Livetext
     mix  = Array(mix)
     call = Array(call)
     mix.each {|lib| mixin(lib) }
-    call.each {|cmd| @main.send(cmd[1..-1]) }  # ignores leading dot, no param
+    call.each {|cmd| send(cmd[1..-1]) }  # ignores leading dot, no param
     # vars.each_pair {|var, val| @api.set(var, val.to_s) }
     api.setvars(vars)
     self
   end
 
-  def inspect
+    def inspect
    api_abbr  = @api ? "(non-nil)" : "(not shown)"
-   main_abbr = @main ? "(non-nil)" : "(not shown)"
     "Livetext:\n" + 
-    "  source = #{@source.inspect}\n" +
-    "  mixins = #{@_mixins.inspect}\n" + 
-    "  import = #{@_mixins.inspect}\n" + 
-    "  main   = #{main_abbr}\n" + 
     "  indent = #{@indentation.inspect}\n" + 
-    "  vars   = #{@_vars.inspect}\n" + 
+    "  vars   = #{@variables.inspect}\n" + 
     "  api    = #{api_abbr}\n" +
     "  body   = (#{@body.size} bytes)"
   end
@@ -104,23 +106,83 @@ class Livetext
     @api
   end
 
+  def error(*args)
+    ::STDERR.puts *args
+  end
+
+  def disallowed?(name)
+    flag = Disallowed.include?(name.to_sym)
+    flag
+  end
+
+  def output=(io)
+    @output = io
+  end
+
+  def html
+    @html
+  end
+
+  def source(enum, file, line)
+    @sources.push([enum, file, line])
+  end
+
+  def peek_nextline
+    return nil if @sources.empty?
+    source = @sources.last
+    line = source[0].peek
+    line
+  rescue StopIteration
+    @sources.pop
+    nil
+  rescue => err
+    TTY.puts "#{__method__}: RESCUE err = #{err.inspect}"
+    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 api=(obj)
     @api = obj
   end
 
-  def initial_vars
-    # Other predefined variables (see also setfile)
-    @api.setvar(:User, `whoami`.chomp)
-    @api.setvar(:Version, Livetext::VERSION)
+
+
+  def process(text: nil, file: nil, vars: {})
+    # Set variables first
+    @variables.set_multiple(vars) unless vars.empty?
+    
+    # Process based on input type
+    case
+    when file && text.nil?
+      process_file(file)
+    when file.nil? && text
+      transform_text(text)
+    when file.nil? && text.nil?
+      raise "Must specify file or text"
+    when file && text
+      raise "Cannot specify file and text"
+    end
+    
+    [self.body, @variables.to_h]
   end
 
-  def transform(text)
+  # Keep transform for backward compatibility, but make it private
+  private def transform_text(text)
     setfile!("(string)")
     enum = text.each_line
     front = text.match(/.*?\n/).to_a.first.chomp rescue ""
-    @main.source(enum, "STDIN: '#{front}...'", 0)
+    source(enum, "STDIN: '#{front}...'", 0)
     loop do 
-      line = @main.nextline
+      line = nextline
       break if line.nil?
       process_line(line)
     end
@@ -129,29 +191,22 @@ class Livetext
     result
   end
 
-  # EXPERIMENTAL and incomplete
+  # Keep for backward compatibility
+  def transform(text)
+    transform_text(text)
+  end
+
+  # Keep for backward compatibility
   def xform(*args, file: nil, text: nil, vars: {})
-    case
-      when file && text.nil?
-        xform_file(file)
-      when file.nil? && text
-        transform(text)
-      when file.nil? && text.nil?
-        raise "Must specify file or text"
-      when file && text
-        raise "Cannot specify file and text"
-    end
-    self.process_file(file)
-    self.body
+    body, _vars = process(file: file, text: text, vars: vars)
+    body
   end
 
+  # Keep for backward compatibility
   def xform_file(file, vars: nil)
-    Livetext::Vars.replace(vars) unless vars.nil?
-    @_vars.replace(vars) unless vars.nil?
-# checkpoint! "Calling process_file..."
-    self.process_file(file)
-# checkpoint! "...returned"
-    self.body
+    vars_hash = vars.nil? ? {} : vars
+    body, _vars = process(file: file, vars: vars_hash)
+    body
   end
 
 end

data/lib/livetext/expansion.rb

@@ -8,8 +8,6 @@ class Livetext::Expansion
   Lbrack = "\\["
   Colon  = ":"
 
-  Formatter = ::Livetext::Formatter
-
   def initialize(instance)   # Livetext::Expansion
     @live = instance
   end
@@ -18,7 +16,7 @@ class Livetext::Expansion
     return "" if line == "\n" || line.nil?
     with_vars = expand_variables(line)
     with_func = expand_function_calls(with_vars)
-    formatted = Formatter.format(with_func)
+    formatted = @live.formatter.format(with_func)
   end
 
   def expand_variables(str)
@@ -53,12 +51,30 @@ class Livetext::Expansion
   end
 
   def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
+    # Use the unified function registry
     name = name.gsub(/\./, "__")
-    return if self.send?(name, param)
-    fobj = ::Livetext::Functions.new
-    result = fobj.send(name, param) rescue err
-    result.to_s
+    result = @live.function_registry.call(name, param)
+    
+    # If not found in registry, fall back to old system for backward compatibility
+    if result.start_with?("[Error evaluating $$#{name}(")
+      # Try old Livetext::Functions system
+      fobj = ::Livetext::Functions.new
+      old_result = fobj.send(name, param) rescue nil
+      return old_result.to_s if old_result
+      
+              # Try Livetext instance (for mixin functions)
+      if @live.respond_to?(name)
+        method = @live.method(name)
+        if method.parameters.empty?
+          old_result = @live.send(name) rescue nil
+        else
+          old_result = @live.send(name, param) rescue nil
+        end
+        return old_result.to_s if old_result
+      end
+    end
+    
+    result
   end
 
   def expand_function_calls(str)
@@ -69,7 +85,7 @@ class Livetext::Expansion
     rbrack = "\\]"
     space_eol = "( |$)"
     prx1 = "(?<param>[^ ]+)"
-    prx2 = "(?<param>.+)"
+    prx2 = "(?<param>.*)"
     pat2 = "(?<full_param>#{colon}#{prx1})"
     pat3 = "(?<full_param>#{lbrack}#{prx2}#{rbrack})"
     rx = Regexp.compile("#{pat1}(#{pat2}|#{pat3})?")

data/lib/livetext/formatter.rb

@@ -1,202 +1,189 @@
-module Livetext::Formatter
-
-  def self.format(str)    # FIXME - unneeded?
-    str = str.chomp
-    s2 = Double.process(str.chomp)
-    s3 = Bracketed.process(s2)
-    s4 = Single.process(s3)
-    s4
-  end
-  
-  ## Hmmm...
-  # 
-  #  Double:  b, i, t, s
-  #  Single:  bits
-  #  Brackt:  bits
-  # 
-
-end
-
-class Livetext::Formatter::Delimited
-  def initialize(str, marker, tag)    # Delimited
-    @str, @marker, @tag = str.dup, marker, tag
-    @buffer = ""
-    @cdata  = ""
-    @state  = :INITIAL
+# Formatter - Centralized text formatting for Livetext
+class Livetext::Formatter
+  def initialize(parent)
+    @parent = parent
   end
 
-  def status(where)
-    if $debug
-      STDERR.printf "%-11s %-7s #{@marker.inspect} \n #{' '*11} state = %-8s  str = %-20s  buffer = %-20s  cdata = %-20s\n", 
-        where, self.class, @state, @str.inspect, @buffer.inspect, @cdata.inspect
-    end
+  def format(text)
+    return "" if text.nil? || text.empty?
+    
+    text = text.chomp
+    # First, mark escaped characters so they won't be processed as formatting
+    text = mark_escaped_characters(text)
+    
+    # Process all marker types in sequence
+    text = handle_double_markers(text)
+    text = handle_bracketed_markers(text)
+    text = handle_single_markers(text)
+    text = handle_underscore_markers(text)
+    text = handle_backtick_markers(text)
+    text = handle_tilde_markers(text)
+    
+    text = unmark_escaped_characters(text)
+    text
   end
 
-  def front
-    @str[0]
+  def format_line(line)
+    return "" if line.nil?
+    format(line.chomp)
   end
 
-  def grab(n=1)
-    char = @str.slice!(0..(n-1))   # grab n chars
-    char
+  def format_multiple(lines)
+    lines.map { |line| format_line(line) }
   end
 
-  def grab_terminator
-    @state = :LOOPING
-    # goes onto buffer by default
-    # Don't? what if searching for space_marker?
-    # @buffer << grab  
+  # Convenience methods for common formatting patterns
+  def bold(text)
+    "<b>#{text}</b>"
   end
 
-  def eol?
-    @str.empty?
+  def italic(text)
+    "<i>#{text}</i>"
   end
 
-  def space?
-    front == " "
+  def code(text)
+    "<tt>#{text}</tt>"
   end
 
-  def escape?
-    front == "\\"
+  def strike(text)
+    "<strike>#{text}</strike>"
   end
 
-  def terminated?
-    space?   # Will be overridden except in Single
+  def link(text, url)
+    "<a href='#{url}'>#{text}</a>"
   end
 
-  def marker?
-    @str.start_with?(@marker)
+  def escape_html(text)
+    text.gsub(/[&<>"']/) do |char|
+      case char
+      when '&' then '&amp;'
+      when '<' then '&lt;'
+      when '>' then '&gt;'
+      when '"' then '&quot;'
+      when "'" then '&#39;'
+      else char
+      end
+    end
   end
 
-  def space_marker?
-    @str.start_with?(" " + @marker)
-  end
+  private
 
-  def wrap(text)
-    if text.empty?
-      result = @marker
-      result = "" if @marker[1] == "["
-      return result
-    end
-    "<#{@tag}>#{text}</#{@tag}>"
-  end
-  
-  def initial
-    n = @marker.length
-    case
-    when escape?
-      grab               # backslash
-      @buffer << grab    # char
-    when space_marker?
-      @buffer << grab   # append the space
-      grab(n)           # eat the marker
-      @state = :CDATA
-    when marker?
-      grab(n)  # Eat the marker
-      @state = :CDATA
-    when eol?
-      @state = :FINAL
-    else
-      @state = :BUFFER
-    end
+  def mark_escaped_characters(str)
+    # Replace escaped characters with a null byte marker (safe for internal use)
+    str.gsub(/\\([*_`~])/, "\u0000\\1")
   end
 
-  def buffer
-    @buffer << grab
-    @state = :LOOPING
+  def unmark_escaped_characters(str)
+    # Restore escaped characters
+    str.gsub(/\u0000([*_`~])/, '\1')
   end
 
-  def cdata
-    case
-    when eol?
-      if @cdata.empty?
-        @buffer << @marker unless @marker[1] == "["
+  def handle_double_markers(str)
+    # **word -> <b>word</b> (terminated by space, comma, period)
+    # But ignore standalone ** or ** surrounded by spaces
+    str.gsub(/(?<=\s|^)\*\*([^\s,.]*)/) do |match|
+      if $1.empty?
+        "**"  # standalone ** should be literal
       else
-        @buffer << wrap(@cdata)
+        "<b>#{$1}</b>"
       end
-      @state = :FINAL
-    when terminated?
-      @buffer << wrap(@cdata)
-      grab_terminator    # "*a *b"  case???
-      @cdata = ""
-      @state = :LOOPING
-    else
-      @cdata << grab
-      @state = :CDATA
     end
   end
 
-  def looping
-    n = @marker.length
-    case
-    when escape?
-      grab               # backslash
-      @buffer << grab    # char
-    when space_marker?
-      @buffer << grab   # append the space
-      grab(n)           # eat the marker
-      @state = :CDATA
-    when eol?
-      @state = :FINAL
-    else   # includes marker not preceded by space!
-      @buffer << grab
+  def handle_bracketed_markers(str)
+    # Handle all bracketed markers: *[content], _[content], `[content]
+    # *[content] -> <b>content</b>
+    # _[content] -> <i>content</i>
+    # `[content] -> <tt>content</tt>
+    # And handle unclosed brackets with end-of-line termination
+    # Empty brackets disappear
+    # But ignore if the marker was originally escaped
+    # And ignore embedded markers (like abc*[)
+    
+    # First handle complete brackets for all marker types
+    str = str.gsub(/(?<!\u0000)([*_`])\[([^\]]*)\]/) do |match|
+      marker, content = $1, $2
+      if content.empty?
+        ""  # empty brackets disappear
+      else
+        case marker
+        when "*" then "<b>#{content}</b>"
+        when "_" then "<i>#{content}</i>"
+        when "`" then "<tt>#{content}</tt>"
+        else match  # fallback
+        end
+      end
     end
-  end
-
-  def handle
-    loop do
-      break if @state == :FINAL
-      meth = @state.downcase
-      send(meth)
+    
+    # Then handle unclosed brackets (end of line replaces closing bracket)
+    # But only if it's at start of line or preceded by whitespace
+    str = str.gsub(/(?<!\u0000)(?<=\s|^)([*_`])\[([^\]]*)$/) do |match|
+      marker, content = $1, $2
+      if content.empty?
+        ""  # standalone marker[ disappears
+      else
+        case marker
+        when "*" then "<b>#{content}</b>"
+        when "_" then "<i>#{content}</i>"
+        when "`" then "<tt>#{content}</tt>"
+        else match  # fallback
+        end
+      end
+    end
+    
+    str
+  end
+
+  def handle_single_markers(str)
+    # *word -> <b>word</b> (only at start of word or after space)
+    # But ignore standalone * or * surrounded by spaces
+    # Also ignore * that are part of ** patterns (already processed)
+    # And ignore * that are part of *[ patterns (already processed)
+    str.gsub(/(?<=\s|^)\*(?!\[)([^\s]*)/) do |match|
+      if $1.empty?
+        "*"  # standalone * should be literal
+      elsif $1.start_with?('*')
+        # This is part of a ** pattern, leave it as literal
+        match
+      else
+        "<b>#{$1}</b>"
+      end
     end
-    return @buffer
-  end
-
-  def self.process(str)
-    bold = self.new(str, "*", "b")
-    sb   = bold.handle
-# return sb
-    ital = self.new(sb, "_", "i")
-    si   = ital.handle
-    code = self.new(si, "`", "tt")
-    sc   = code.handle
-    stri = self.new(sc, "~", "strike")
-    si   = stri.handle
-    si
-  end
-end
-
-class Livetext::Formatter::Single < Livetext::Formatter::Delimited
-  # Yeah, this one is that simple
-end
-
-class Livetext::Formatter::Double < Livetext::Formatter::Delimited
-  def initialize(str, sigil, tag)    # Double
-    super
-    # Convention: marker is "**", sigil is "*"
-    @marker = sigil + sigil
-  end
-
-  def terminated?
-    terms = [" ", ".", ","]
-    terms.include?(front)
   end
-end
 
-class Livetext::Formatter::Bracketed < Livetext::Formatter::Delimited
-  def initialize(str, sigil, tag)   # Bracketed
-    super
-    # Convention: marker is "*[", sigil is "*"
-    @marker = sigil + "["
+  def handle_underscore_markers(str)
+    # _word -> <i>word</i> (only at start of word or after space)
+    # But ignore standalone _ or _ surrounded by spaces
+    str.gsub(/(?<=\s|^)_([^\s]*)/) do |match|
+      if $1.empty?
+        "_"  # standalone _ should be literal
+      else
+        "<i>#{$1}</i>"
+      end
+    end
   end
 
-  def terminated?
-    front == "]" || eol?
+  def handle_backtick_markers(str)
+    # `word -> <tt>word</tt> (only at start of word or after space)
+    # But ignore standalone ` or ` surrounded by spaces
+    str.gsub(/(?<=\s|^)`([^\s]*)/) do |match|
+      if $1.empty?
+        "`"  # standalone ` should be literal
+      else
+        "<tt>#{$1}</tt>"
+      end
+    end
   end
 
-  def grab_terminator
-    @state = :LOOPING
-    grab
+  def handle_tilde_markers(str)
+    # ~word -> <strike>word</strike> (only at start of word or after space)
+    # But ignore standalone ~ or ~ surrounded by spaces
+    str.gsub(/(?<=\s|^)~([^\s]*)/) do |match|
+      if $1.empty?
+        "~"  # standalone ~ should be literal
+      else
+        "<strike>#{$1}</strike>"
+      end
+    end
   end
 end
-