livetext 0.9.51 → 0.9.55

data/lib/livetext/formatter_component.rb

@@ -0,0 +1,189 @@
+# Formatter - Centralized text formatting for Livetext
+class Livetext::Formatter
+  def initialize(parent)
+    @parent = parent
+  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 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 mark_escaped_characters(str)
+    # Replace escaped characters with a null byte marker (safe for internal use)
+    str.gsub(/\\([*_`~])/, "\u0000\\1")
+  end
+
+  def unmark_escaped_characters(str)
+    # Restore escaped characters
+    str.gsub(/\u0000([*_`~])/, '\1')
+  end
+
+  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
+        "<b>#{$1}</b>"
+      end
+    end
+  end
+
+  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
+    
+    # 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
+  end
+
+  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 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 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

data/lib/livetext/function_registry.rb

@@ -0,0 +1,163 @@
+# Function Registry - Unified function management for Livetext
+class Livetext::FunctionRegistry
+  def initialize
+    @user_functions = {}
+    @builtin_functions = {}
+    @metadata = {}
+    register_builtin_functions
+    puts "DEBUG: Registered #{@builtin_functions.size} builtin functions" if ENV['DEBUG']
+  end
+  
+  def register_user(name, function, source: :inline, filename: nil)
+    name_sym = name.to_sym
+    @user_functions[name_sym] = function
+    @metadata[name_sym] = { source: source, filename: filename }
+  end
+  
+  def register_builtin(name, function)
+    @builtin_functions[name] = function
+    @metadata[name] = { source: :builtin, filename: "builtin" }
+  end
+  
+  def call(name, param)
+    # Convert name to symbol for consistent lookup
+    name_sym = name.to_sym
+    
+    if @user_functions[name_sym]
+      call_function(name, @user_functions[name_sym], param)
+    elsif @builtin_functions[name_sym]
+      call_function(name, @builtin_functions[name_sym], param)
+    else
+      "[Error evaluating $$#{name}(#{param})]"
+    end
+  end
+  
+           def list_functions
+           result = []
+           @user_functions.each { |name, _| result << { name: name.to_s, source: get_source(name) } }
+           @builtin_functions.each { |name, _| result << { name: name.to_s, source: get_source(name) } }
+           result.sort_by { |f| f[:name] }
+         end
+         
+         def get_function_info(name)
+           name_sym = name.to_sym
+           metadata = @metadata[name_sym]
+           return nil unless metadata
+           
+           {
+             name: name.to_s,
+             source: get_source(name),
+             filename: metadata[:filename],
+             type: @user_functions.key?(name_sym) ? :user : :builtin
+           }
+         end
+  
+  def function_exists?(name)
+    name_sym = name.to_sym
+    @user_functions.key?(name_sym) || @builtin_functions.key?(name_sym)
+  end
+  
+  private
+  
+  def call_function(name, function, param)
+    function.call(param)
+  rescue => e
+    "[Error evaluating $$#{name}(#{param})]"
+  end
+  
+  def get_source(name)
+    name_sym = name.to_sym
+    metadata = @metadata[name_sym]
+    case metadata[:source]
+    when :inline then "inline (#{metadata[:filename] || 'unknown'})"
+    when :mixin then "mixin (#{metadata[:filename] || 'unknown'})"
+    when :builtin then "builtin"
+    else "unknown"
+    end
+  end
+  
+  def register_builtin_functions
+    # Move all current Livetext::Functions methods here
+    register_builtin(:date, ->(param) { Time.now.strftime("%F") })
+    register_builtin(:time, ->(param) { Time.now.strftime("%T") })
+    register_builtin(:pwd, ->(param) { Dir.pwd })
+    register_builtin(:rand, ->(param) do
+      if param && !param.empty?
+        n1, n2 = param.split.map(&:to_i)
+        Kernel.rand(n1..n2).to_s
+      else
+        Kernel.rand.to_s
+      end
+    end)
+    register_builtin(:link, ->(param) do
+      if param && param.include?("|")
+        text, url = param.split("|", 2)
+        "<a style='text-decoration: none' href='#{url}'>#{text}</a>"
+      else
+        "[Error in function $$link: expected 'text|url' format]"
+      end
+    end)
+    register_builtin(:br, ->(param) do
+      n = (param || "1").to_i
+      "<br>" * n
+    end)
+    register_builtin(:reverse, ->(param) do
+      if param && !param.empty?
+        param.reverse
+      else
+        "(reverse: No parameter)"
+      end
+    end)
+    register_builtin(:isqrt, ->(param) do
+      arg = num = param
+      if num.nil? || num.empty?
+        arg = "NO PARAM"
+      end
+      num = num.include?(".") ? Float(num) : Integer(num)
+      Math.sqrt(num).to_i.to_s
+    rescue => err
+      "[Error evaluating $$isqrt(#{arg})]"
+    end)
+    
+    # System info functions (return current values)
+    register_builtin(:hostname, ->(param) { `hostname`.chomp })
+    register_builtin(:platform, ->(param) { RUBY_PLATFORM })
+    register_builtin(:ruby_version, ->(param) { RUBY_VERSION })
+    register_builtin(:livetext_version, ->(param) { Livetext::VERSION })
+    
+    # Date/time functions
+    register_builtin(:year, ->(param) { Time.now.year.to_s })
+    register_builtin(:month, ->(param) { Time.now.mon.to_s })
+    register_builtin(:day, ->(param) { Time.now.day.to_s })
+    register_builtin(:hour, ->(param) { Time.now.hour.to_s })
+    register_builtin(:minute, ->(param) { Time.now.min.to_s })
+    register_builtin(:second, ->(param) { Time.now.sec.to_s })
+    register_builtin(:weekday, ->(param) { Time.now.wday.to_s })
+    register_builtin(:week, ->(param) { Time.now.strftime("%U") })
+    
+    # Date formatting functions
+    register_builtin(:format_date, ->(param) do
+      if param && !param.empty?
+        Time.now.strftime(param)
+      else
+        Time.now.strftime("%F") # Default format
+      end
+    end)
+    register_builtin(:days_ago, ->(param) do
+      if param && !param.empty?
+        days = param.to_i
+        (Time.now - (days * 24 * 60 * 60)).strftime("%F")
+      else
+        "[Error evaluating $$days_ago: requires number of days]"
+      end
+    end)
+    register_builtin(:days_from_now, ->(param) do
+      if param && !param.empty?
+        days = param.to_i
+        (Time.now + (days * 24 * 60 * 60)).strftime("%F")
+      else
+        "[Error evaluating $$days_from_now: requires number of days]"
+      end
+    end)
+  end
+end

data/lib/livetext/handler/mixin.rb

@@ -24,6 +24,10 @@ class Livetext::Handler::Mixin
 # STDERR.puts "After eval"
     newmod = Object.const_get("::" + modname)
 # STDERR.puts "After const_get"
+    
+    # Register functions from the mixin with the registry
+    handler.register_mixin_functions(newmod, parent)
+    
     newmod   # return actual module
   end
 
@@ -33,5 +37,26 @@ class Livetext::Handler::Mixin
     [modname, "module ::#{modname}; #{meths}\nend"]
   end
 
+  def register_mixin_functions(module_obj, parent)
+    # Get all instance methods from the module
+    methods = module_obj.instance_methods(false)
+    
+    methods.each do |method_name|
+      # Create a lambda that calls the method on the parent (Livetext instance)
+      function = ->(param) do
+        # Check if the method expects parameters
+        method = parent.method(method_name)
+        if method.parameters.empty?
+          parent.send(method_name)
+        else
+          parent.send(method_name, param)
+        end
+      end
+      
+      # Register with the function registry
+      parent.function_registry.register_user(method_name.to_s, function, source: :mixin, filename: @file)
+    end
+  end
+
 end
 

data/lib/livetext/helpers.rb

@@ -81,15 +81,15 @@ module Livetext::Helpers
     text = File.readlines(fname)
     enum = text.each
     @backtrace = btrace
-    @main.source(enum, fname, 0)
+    source(enum, fname, 0)
     line = nil
     loop do
-      line = @main.nextline
+      line = nextline
       break if line.nil?
       success = process_line(line)
       break unless success
     end
-    val = @main.finalize rescue nil
+    val = finalize rescue nil
     @body    # FIXME?   @body.join("\n")  # array
     return true
   end
@@ -125,7 +125,25 @@ module Livetext::Helpers
     api.data = data0.dup   # should permit _ in function names at least
     args0 = data0.split
     api.args = args0.dup
-    retval = @main.send(name)  # , *args)      # was 125
+    # Get method signature to determine what parameters to pass
+    method = method(name)
+    param_count = method.parameters.length
+    
+    # Pass parameters based on method signature
+    case param_count
+    when 0
+      retval = send(name)
+    when 2
+      retval = send(name, args0, data0)
+    when 3
+      # Check if this is a method that needs raw body content
+      # For now, we'll check if it's dot_def and if it has 'body raw' in args
+      raw_body = (name == :dot_def && args0.length >= 3 && args0[2] == 'raw')
+      body_lines = raw_body ? api.body(true) : api.body(false)
+      retval = send(name, args0, data0, body_lines)
+    else
+      retval = send(name)  # fallback to no parameters
+    end
     retval
   rescue => err
     graceful_error(err)   # , "#{__method__}: name = #{name}")
@@ -139,7 +157,7 @@ module Livetext::Helpers
     case
       when name == :end   # special case
         graceful_error EndWithoutOpening()
-      when @main.respond_to?(name)
+      when respond_to?(name)
         success = invoke_dotcmd(name, data)    # was 141
     else
       graceful_error UnknownMethod(name)
@@ -162,8 +180,8 @@ module Livetext::Helpers
       data0 = ""
     end
     name = "dot_" + name if %w[include def].include?(name)
-    @main.check_disallowed(name)
-    @main.api.data = data0  # FIXME kill this?
+    check_disallowed(name)
+    api.data = data0  # FIXME kill this?
     [name.to_sym, data0]
   end
 

data/lib/livetext/reopen.rb

@@ -1,5 +1,7 @@
 # Reopen for convenience... do differently
 
+
+
 class Object
   def send?(meth, *args)
     if self.respond_to?(meth)

data/lib/livetext/skeleton.rb

@@ -9,9 +9,6 @@ class Livetext
   module Handler
   end
 
-  module Formatter
-  end
-
   class HTML
   end