livetext 0.9.52 → 0.9.56

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,8 +78,10 @@ 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.handle_dotcmd(cmd) }  # Use handle_dotcmd for proper command parsing
     obj.api.setvars(vars)
+    # Also set variables in global Livetext::Vars for backward compatibility
+    vars.each {|var, val| Vars[var.to_sym] = val.to_s }
     obj
   end
 
@@ -80,22 +89,19 @@ 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| handle_dotcmd(cmd) }  # Use handle_dotcmd for proper command parsing
     # vars.each_pair {|var, val| @api.set(var, val.to_s) }
     api.setvars(vars)
+    # Also set variables in global Livetext::Vars for backward compatibility
+    vars.each {|var, val| Vars[var.to_sym] = val.to_s }
     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 +110,81 @@ 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 +193,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/errors.rb

@@ -67,6 +67,7 @@ end
 make_exception(:EndWithoutOpening, "Error: found .end with no opening command")
 make_exception(:UnknownMethod,     "Error: name '%1' is unknown")
 make_exception(:NoSuchFile,        "Error: can't find file '%1' (method '%2')")
+make_exception(:ExpectedEnd,       "Error: expected .end but found end of file")
 
 # Move others here?  DisallowedName, etc.
 

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,28 +51,30 @@ class Livetext::Expansion
   end
 
   def funcall(name, param)
-    err = "[Error evaluating $$#{name}(#{param})]"
+    # Use the unified function registry
     name = name.gsub(/\./, "__")
+    result = @live.function_registry.call(name, param)
     
-    # First check Livetext::Functions (for predefined and inline functions)
-    fobj = ::Livetext::Functions.new
-    result = fobj.send(name, param) rescue nil
-    return result.to_s if result
-    
-    # Then check the processor instance (for mixin functions)
-    if @live.main.respond_to?(name)
-      # Check if the method expects parameters
-      method = @live.main.method(name)
-      if method.parameters.empty?
-        result = @live.main.send(name) rescue err
-      else
-        result = @live.main.send(name, param) rescue err
+    # 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
-      return result.to_s
     end
     
-    # If not found anywhere
-    err
+    result
   end
 
   def expand_function_calls(str)
@@ -85,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,35 +1,84 @@
-module Livetext::Formatter
+# Formatter - Centralized text formatting for Livetext
+class Livetext::Formatter
+  def initialize(parent)
+    @parent = parent
+  end
 
-  def self.format(str)
-    str = str.chomp
+  def format(text)
+    return "" if text.nil? || text.empty?
+    
+    text = text.chomp
     # First, mark escaped characters so they won't be processed as formatting
-    str = mark_escaped_characters(str)
+    text = mark_escaped_characters(text)
     
-    # Process all marker types in sequence (like the original formatter)
-    str = handle_double_markers(str)
-    str = handle_bracketed_markers(str)
-    str = handle_single_markers(str)
-    str = handle_underscore_markers(str)
-    str = handle_backtick_markers(str)
-    str = handle_tilde_markers(str)
+    # 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)
     
-    str = unmark_escaped_characters(str)
-    str
+    text = unmark_escaped_characters(text)
+    text
+  end
+
+  def format_line(line)
+    return "" if line.nil?
+    format(line.chomp)
+  end
+
+  def format_multiple(lines)
+    lines.map { |line| format_line(line) }
+  end
+
+  # Convenience methods for common formatting patterns
+  def bold(text)
+    "<b>#{text}</b>"
+  end
+
+  def italic(text)
+    "<i>#{text}</i>"
+  end
+
+  def code(text)
+    "<tt>#{text}</tt>"
+  end
+
+  def strike(text)
+    "<strike>#{text}</strike>"
+  end
+
+  def link(text, url)
+    "<a href='#{url}'>#{text}</a>"
+  end
+
+  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
 
   private
 
-  def self.mark_escaped_characters(str)
+  def mark_escaped_characters(str)
     # Replace escaped characters with a null byte marker (safe for internal use)
     str.gsub(/\\([*_`~])/, "\u0000\\1")
   end
 
-  def self.unmark_escaped_characters(str)
+  def unmark_escaped_characters(str)
     # Restore escaped characters
     str.gsub(/\u0000([*_`~])/, '\1')
   end
 
-  def self.handle_double_markers(str)
+  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|
@@ -41,7 +90,7 @@ module Livetext::Formatter
     end
   end
 
-  def self.handle_bracketed_markers(str)
+  def handle_bracketed_markers(str)
     # Handle all bracketed markers: *[content], _[content], `[content]
     # *[content] -> <b>content</b>
     # _[content] -> <i>content</i>
@@ -85,7 +134,7 @@ module Livetext::Formatter
     str
   end
 
-  def self.handle_single_markers(str)
+  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)
@@ -102,7 +151,7 @@ module Livetext::Formatter
     end
   end
 
-  def self.handle_underscore_markers(str)
+  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|
@@ -114,7 +163,7 @@ module Livetext::Formatter
     end
   end
 
-  def self.handle_backtick_markers(str)
+  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|
@@ -126,7 +175,7 @@ module Livetext::Formatter
     end
   end
 
-  def self.handle_tilde_markers(str)
+  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|
@@ -137,183 +186,4 @@ module Livetext::Formatter
       end
     end
   end
-
 end
-
-# Legacy classes - kept for compatibility but not used
-class Livetext::Formatter::Delimited
-  def initialize(str, marker, tag)
-    @str, @marker, @tag = str.dup, marker, tag
-    @buffer = ""
-    @cdata  = ""
-    @state  = :INITIAL
-  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
-  end
-
-  def front
-    @str[0]
-  end
-
-  def grab(n=1)
-    char = @str.slice!(0..(n-1))
-    char
-  end
-
-  def grab_terminator
-    @state = :LOOPING
-  end
-
-  def eol?
-    @str.empty?
-  end
-
-  def space?
-    front == " "
-  end
-
-  def escape?
-    front == "\\"
-  end
-
-  def terminated?
-    space?
-  end
-
-  def marker?
-    @str.start_with?(@marker)
-  end
-
-  def space_marker?
-    @str.start_with?(" " + @marker)
-  end
-
-  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
-      @buffer << grab
-    when space_marker?
-      @buffer << grab
-      grab(n)
-      @state = :CDATA
-    when marker?
-      grab(n)
-      @state = :CDATA
-    when eol?
-      @state = :FINAL
-    else
-      @state = :BUFFER
-    end
-  end
-
-  def buffer
-    @buffer << grab
-    @state = :LOOPING
-  end
-
-  def cdata
-    case
-    when eol?
-      if @cdata.empty?
-        @buffer << @marker unless @marker[1] == "["
-      else
-        @buffer << wrap(@cdata)
-      end
-      @state = :FINAL
-    when terminated?
-      @buffer << wrap(@cdata)
-      grab_terminator
-      @cdata = ""
-      @state = :LOOPING
-    else
-      @cdata << grab
-      @state = :CDATA
-    end
-  end
-
-  def looping
-    n = @marker.length
-    case
-    when escape?
-      grab
-      @buffer << grab
-    when space_marker?
-      @buffer << grab
-      grab(n)
-      @state = :CDATA
-    when eol?
-      @state = :FINAL
-    else
-      @buffer << grab
-    end
-  end
-
-  def handle
-    loop do
-      break if @state == :FINAL
-      meth = @state.downcase
-      send(meth)
-    end
-    return @buffer
-  end
-
-  def self.process(str)
-    bold = self.new(str, "*", "b")
-    sb   = bold.handle
-    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
-end
-
-class Livetext::Formatter::Double < Livetext::Formatter::Delimited
-  def initialize(str, sigil, tag)
-    super
-    @marker = sigil + sigil
-  end
-
-  def terminated?
-    terms = [" ", ".", ","]
-    terms.include?(front)
-  end
-end
-
-class Livetext::Formatter::Bracketed < Livetext::Formatter::Delimited
-  def initialize(str, sigil, tag)
-    super
-    @marker = sigil + "["
-  end
-
-  def terminated?
-    front == "]" || eol?
-  end
-
-  def grab_terminator
-    @state = :LOOPING
-    grab
-  end
-end
-