livetext 0.9.52 → 0.9.56

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

@@ -11,6 +11,32 @@ class Livetext::Functions
     attr_accessor :param   # kill this?
   end
 
+  # Instance variables for accessing the Livetext instance and its variables
+  attr_accessor :live, :vars
+
+  def initialize
+    @live = nil
+    @vars = nil
+  end
+
+  # Helper method to access variables with fallback to global Livetext::Vars
+  def get_var(name)
+    return @vars.get(name) if @vars
+    return @live&.vars.get(name) if @live&.vars
+    Livetext::Vars[name]
+  end
+
+  # Helper method to set variables
+  def set_var(name, value)
+    if @vars
+      @vars.set(name, value)
+    elsif @live&.vars
+      @live.vars.set(name, value)
+    else
+      Livetext::Vars[name] = value
+    end
+  end
+
   def code_lines(param = nil)
     $code_lines.to_i  # FIXME pleeease
   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,54 @@ 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
+    
+    # Also look for methods defined in Livetext::Functions class
+    # Get all methods from Livetext::Functions
+    functions_class_methods = Livetext::Functions.instance_methods(false)
+    
+    functions_class_methods.each do |method_name|
+      # Skip methods that are already built-in (defined in the original functions.rb)
+      builtin_methods = [:code_lines, :ns, :isqrt, :reverse, :date, :time, :pwd, :rand, :link, :br, :yt, :simple_format, 
+                        :b, :i, :t, :s, :bi, :bt, :bs, :it, :is, :ts, :bit, :bis, :bts, :its, :bits]
+      next if builtin_methods.include?(method_name)
+      
+      # Create a lambda that calls the method on a new Livetext::Functions instance
+      function = ->(param) do
+        fobj = ::Livetext::Functions.new
+        # Set the Livetext instance and its variables for access in functions
+        fobj.live = parent
+        fobj.vars = parent.vars
+        method = fobj.method(method_name)
+        if method.parameters.empty?
+          fobj.send(method_name)
+        else
+          fobj.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
@@ -122,25 +122,42 @@ module Livetext::Helpers
   end
 
   def invoke_dotcmd(name, data0="")
-    api.data = data0.dup   # should permit _ in function names at least
+    api.data = data0.dup
     args0 = data0.split
     api.args = args0.dup
-    retval = @main.send(name)  # , *args)      # was 125
+    method = method(name)
+    params = method.parameters
+    
+    case params.length
+    when 0
+      retval = send(name)
+    when 2
+      retval = send(name, args0, data0)
+    when 3
+      processed_body = api.body(false)
+      retval = send(name, args0, data0, processed_body)
+    when 4
+      if params[3][1] == :raw 
+        raw_body = api.body(true)
+        retval = send(name, args0, data0, raw_body, true)
+      else
+        raise "4th parameter is not :raw!"
+      end
+    else
+      raise "#{name} has #{params.length} parameters!"
+    end
     retval
-  rescue => err
-    graceful_error(err)   # , "#{__method__}: name = #{name}")
   end
 
   def handle_dotcmd(line, indent = 0)
-    indent = @indentation.last # top of stack
-    line = line.sub(/# .*$/, "")   # FIXME Could be problematic?
+    line = line.sub(/# .*$/, "")
     name, data = get_name_data(line)
-    success = true  # Be optimistic...  :P
+    check_disallowed(name)
     case
-      when name == :end   # special case
-        graceful_error EndWithoutOpening()
-      when @main.respond_to?(name)
-        success = invoke_dotcmd(name, data)    # was 141
+    when name == :end   # special case
+      graceful_error EndWithoutOpening()
+    when respond_to?(name)
+      success = invoke_dotcmd(name, data)    # was 141
     else
       graceful_error UnknownMethod(name)
     end
@@ -162,8 +179,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