livetext 0.9.52 → 0.9.56

data/lib/livetext/standard.rb

@@ -41,55 +41,88 @@ module Livetext::Standard
 #    end
 #  end
 
-  def backtrace(args = nil, body = nil)
+  def backtrace(args, data)
     @backtrace = onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def comment(args = nil, body = nil)
-    api.body
+  def comment(args, data, body)
+    # body parameter contains the processed lines
     api.optional_blank_line
   end
 
-  def shell(args = nil, body = nil)
+  def shell(args, data)
     cmd = api.data
     system(cmd)
     api.optional_blank_line
   end
 
-  def func(args = nil, body = nil)
+  def func(args, data, body)
     funcname = api.args[0]
     # check_disallowed(funcname)  # should any be invalid?
     funcname = funcname.gsub(/\./, "__")
+    function_body = body.join("\n")
     func_def = <<~EOS
       def #{funcname}(param)
-        #{api.body(true).to_a.join("\n")}
+        #{function_body}
       end
     EOS
     api.optional_blank_line
+    
+    # Register in old system (this works perfectly)
     Livetext::Functions.class_eval func_def
+    
+    # Also register in new registry with proper delegation
+    function = ->(param) do
+      fobj = ::Livetext::Functions.new
+      fobj.send(funcname, param)
+    end
+    
+                 function_registry.register_user(funcname, function, source: :inline, filename: @current_file)
+    return true
+  end
+
+  def functions(args, data)
+    # List all available functions with their sources
+    registry = function_registry
+    functions = registry.list_functions
+    
+    if functions.empty?
+      api.out "No functions available."
+      return true
+    end
+    
+    api.out "<h3>Available Functions</h3>"
+    api.out "<ul>"
+    
+    functions.each do |func|
+      api.out "<li><strong>$$#{func[:name]}</strong> - #{func[:source]}</li>"
+    end
+    
+    api.out "</ul>"
+    api.optional_blank_line
     return true
   end
 
   # FIXME - move these to a single universal place in code
 
-  def h1(args = nil, body = nil); api.out html.tag(:h1, cdata: api.data); return true; end
-  def h2(args = nil, body = nil); api.out html.tag(:h2, cdata: api.data); return true; end
-  def h3(args = nil, body = nil); api.out html.tag(:h3, cdata: api.data); return true; end
-  def h4(args = nil, body = nil); api.out html.tag(:h4, cdata: api.data); return true; end
-  def h5(args = nil, body = nil); api.out html.tag(:h5, cdata: api.data); return true; end
-  def h6(args = nil, body = nil); api.out html.tag(:h6, cdata: api.data); return true; end
+  def h1(args, data); api.out html.tag(:h1, cdata: api.format(api.data)); return true; end
+  def h2(args, data); api.out html.tag(:h2, cdata: api.data); return true; end
+  def h3(args, data); api.out html.tag(:h3, cdata: api.data); return true; end
+  def h4(args, data); api.out html.tag(:h4, cdata: api.data); return true; end
+  def h5(args, data); api.out html.tag(:h5, cdata: api.data); return true; end
+  def h6(args, data); api.out html.tag(:h6, cdata: api.data); return true; end
 
-  def list(args = nil, body = nil)
+  def list(args, data, body)
     html.wrap :ul do
-      api.body {|line| api.out html.tag(:li, cdata: line) }
+      body.each {|line| api.out html.tag(:li, cdata: line) }
     end
     api.optional_blank_line
   end
 
-  def list!(args = nil, body = nil)
+  def list!(args, data, body)
     html.wrap(:ul) do
-      lines = api.body.each   # enumerator
+      lines = body.each   # enumerator
       loop do
         line = lines.next
         line = api.format(line)
@@ -100,30 +133,30 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def shell!(args = nil, body = nil)
+  def shell!(args, data)
     cmd = api.data
     system(cmd)
     api.optional_blank_line
   end
 
-  def errout(args = nil, body = nil)
+  def errout(args, data)
     ::STDERR.puts api.data
     api.optional_blank_line
   end
 
-  def ttyout(args = nil, body = nil)
+  def ttyout(args, data)
     TTY.puts api.data
     api.optional_blank_line
   end
 
-  def say(args = nil, body = nil)
+  def say(args, data)
     data = args || api.args.join(" ")
     str = api.format(data)
     TTY.puts str
     api.optional_blank_line
   end
 
-  def banner(args = nil, body = nil)
+  def banner(args, data)
     str = api.format(api.data)
     num = str.length
     decor = "-"*num + "\n"
@@ -131,11 +164,11 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def quit(args = nil, body = nil)
+  def quit
     @output.close
   end
 
-  def cleanup(args = nil, body = nil)
+  def cleanup(args, data)
     api.args.each do |item|
       cmd = ::File.directory?(item) ? "rm -f #{item}/*" : "rm #{item}"
       system(cmd)
@@ -143,18 +176,33 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def dot_def(args = nil, body = nil)
+  def dot_def(args, data, body)
     name = api.args[0]
     check_disallowed(name)
-    # Difficult to avoid eval here
-    str = "def #{name}\n"
-    str << api.body(true).join("\n")
+    
+    # Check for parameter type specification
+    param_type = api.args[1]&.downcase
+    raw_body = api.args[2]&.downcase == 'raw'
+    
+    # Build method signature based on param_type
+    case param_type
+    when nil
+      str = "def #{name}\n"
+    when 'args'
+      str = "def #{name}(args, data)\n"
+    when 'body'
+      str = "def #{name}(args, data, body)\n"
+    else
+      raise "Invalid parameter type: #{param_type}. Use 'args' or 'body' or omit."
+    end
+    
+    str << body.join("\n")
     str << "\nend\n"
     eval str
     api.optional_blank_line
   end
 
-  def set(args = nil, body = nil)
+  def set(args, data)
     line = api.args.join(" ")  # data.chomp
     pairs = Livetext::ParseSet.new(line).parse
     api.setvars(pairs)
@@ -163,7 +211,7 @@ module Livetext::Standard
 
   # FIXME really these should be one method...
 
-  def variables!(args = nil, body = nil)  # cwd, not FileDir - weird, fix later
+  def variables!(args, data, body)  # cwd, not FileDir - weird, fix later
     prefix = api.args[0]
     file = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
@@ -171,14 +219,14 @@ module Livetext::Standard
       here = ""  # different for ! version
       lines = File.readlines(here + file)
     else
-      lines = api.body
+      lines = body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
     api.setvars(pairs)
     api.optional_blank_line
   end
 
-  def variables(args = nil, body = nil)
+  def variables(args, data, body)
     prefix = api.args[0]
     fname = api.args[1]
     prefix = nil if prefix == "-"  # FIXME dumb hack
@@ -195,7 +243,7 @@ module Livetext::Standard
       raise "No such file #{path.inspect} (file #{path})" unless fok
       lines = File.readlines(path)
     else
-      lines = api.body
+      lines = body
     end
     pairs = Livetext::ParseGeneral.parse_vars(lines, prefix: nil)
     api.setvars(pairs)
@@ -204,9 +252,9 @@ module Livetext::Standard
     fatal(err)
   end
 
-  def heredoc(args = nil, body = nil)
+  def heredoc(args, data, body)
     var = api.args[0]
-    text = api.body.join("\n")
+    text = body.join("\n")
     rhs = ""
     text.each_line do |line|
       str = api.format(line.chomp)
@@ -218,9 +266,9 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def heredoc!(args = nil, body = nil)     # no <br>
+  def heredoc!(args, data, body)     # no <br>
     var = api.args[0]
-    text = api.body.join("\n")
+    text = body.join("\n")
     rhs = ""
     text.each_line do |line|
       str = api.format(line.chomp)
@@ -232,7 +280,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def seek(args = nil, body = nil)    # like include, but search upward as needed
+  def seek(args, data)    # like include, but search upward as needed
     file = api.args.first
 		file = search_upward(file)
     check_file_exists(file)
@@ -240,7 +288,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def cinclude(args = nil, body = nil)   # dot command
+  def cinclude(args, data)   # dot command
     file = api.expand_variables(api.args.first)    # allows for variables
     if api.args.size > 1  # there is an HTML file
       processed = api.expand_variables(api.args[1]) 
@@ -250,127 +298,127 @@ module Livetext::Standard
       end
     end
     check_file_exists(file)
-    @parent.process_file(file)
+    process_file(file)
     api.optional_blank_line
   end
 
-  def dot_include(args = nil, body = nil)   # dot command
+  def dot_include(args, data)   # dot command
     file = api.expand_variables(api.args.first)  # allows for variables
     check_file_exists(file)
-    @parent.process_file(file)
+    process_file(file)
     api.optional_blank_line
   end
 
-  def inherit(args = nil, body = nil)
+  def inherit(args, data)
     file = api.args.first
     upper = "../#{file}"
     got_upper, got_file = File.exist?(upper), File.exist?(file)
     good = got_upper || got_file
     STDERR.puts "File #{file} not found (local or parent)" unless good
 
-    @parent.process_file(upper) if got_upper
-    @parent.process_file(file)  if got_file
+    process_file(upper) if got_upper
+    process_file(file)  if got_file
     api.optional_blank_line
   end
 
-  def mixin(args = nil, body = nil)
-    name = api.args.first   # Expect a module name
+  def mixin(args, data)
+    name = args.first   # Expect a module name
     @mixins ||= []
     return if @mixins.include?(name)
     @mixins << name
-    mod = Livetext::Handler::Mixin.get_module(name, @parent)
+    mod = Livetext::Handler::Mixin.get_module(name, self)
     self.extend(mod)
     init = "init_#{name}"
     self.send(init) rescue nil  # if self.respond_to? init
     api.optional_blank_line
   end
 
-  def import(args = nil, body = nil)
-    name = api.args.first   # Expect a module name
+  def import(args, data)
+    name = args.first   # Expect a module name
     @imports ||= []
     return if @imports.include?(name)
     @imports << name
-    mod = Livetext::Handler::Import.get_module(name, @parent)
+    mod = Livetext::Handler::Import.get_module(name, self)
     self.extend(mod)
     init = "init_#{name}"
     self.send(init) rescue nil  # if self.respond_to? init
     api.optional_blank_line
   end
 
-  def copy(args = nil, body = nil)
+  def copy(args, data)
     file = api.args.first
     ok = file_exists?(file)
 
-    self.parent.graceful_error FileNotFound(file) unless ok   # FIXME seems weird?
+    graceful_error FileNotFound(file) unless ok   # FIXME seems weird?
       api.out grab_file(file)
     api.optional_blank_line
     [ok, file]
   end
 
-  def r(args = nil, body = nil)
+  def r(args, data)
     # FIXME api.data is broken
     # api.out api.data  # No processing at all
     api.out api.args.join(" ")
     api.optional_blank_line
   end
 
-  def raw(args = nil, body = nil)
+  def raw(args, data)
     # No processing at all (terminate with __EOF__)
     api.raw_body {|line| api.out line }  # no formatting
     api.optional_blank_line
   end
 
-  def debug(args = nil, body = nil)
+  def debug(args, data)
     @debug = onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def passthru(args = nil, body = nil)
+  def passthru(args, data)
     # FIXME - add check for args size? (helpers)
     @nopass = ! onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def nopass(args = nil, body = nil)
+  def nopass
     @nopass = true
     api.optional_blank_line
   end
 
-  def para(args = nil, body = nil)
+  def para(args, data)
     # FIXME - add check for args size? (helpers)
     @nopara = ! onoff(api.args.first)
     api.optional_blank_line
   end
 
-  def nopara(args = nil, body = nil)
+  def nopara
     @nopara = true
     api.optional_blank_line
   end
 
-  def heading(args = nil, body = nil)
+  def heading(args, data)
     api.print "<center><font size=+1><b>"
     api.print api.data
     api.print "</b></font></center>"
     api.optional_blank_line
   end
 
-  def newpage(args = nil, body = nil)
+  def newpage
     api.out '<p style="page-break-after:always;"></p>'
     api.out "<p/>"
     api.optional_blank_line
   end
 
-  def mono(args = nil, body = nil)
+  def mono(args, data, body)
     html.wrap ":pre" do
       api.body(true) {|line| api.out line }
     end
     api.optional_blank_line
   end
 
-  def dlist(args = nil, body = nil)
+  def dlist(args, data, body)
     delim = api.args.first
     html.wrap(:dl) do
-      api.body do |line|
+      body.each do |line|
         line = api.format(line)
         term, defn = line.split(delim)
         api.out html.tag(:dt, cdata: term)
@@ -381,18 +429,18 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def link(args = nil, body = nil)
+  def link(args, data)
     url = api.args.first
     text = api.args[2..-1].join(" ")
     api.out "<a style='text-decoration: none' href='#{url}'>#{text}</a>"
     api.optional_blank_line
   end
 
-  def xtable(args = nil, body = nil)   # Borrowed from bookish - FIXME
+  def xtable(args, data, body)   # Borrowed from bookish - FIXME
     title = api.data
     delim = " :: "
     api.out "<br>\n\n<center><table width=90% cellpadding=5>"
-    lines = api.body(true)
+    lines = body
     maxw = nil
     processed = []
     lines.each do |line|
@@ -418,11 +466,11 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def table(args = nil, body = nil)   # Same as xtable
+  def table(args, data, body)   # Same as xtable
     title = api.data
     delim = " :: "
     api.out "<br>\n\n<center><table width=90% cellpadding=5>"
-    lines = api.body(true)
+    lines = body
     maxw = nil
     processed = []
     lines.each do |line|
@@ -448,7 +496,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def image(args = nil, body = nil)
+  def image(args, data)
     name, wide, high = api.args
     geom = ""
     geom = "width=#{wide} height=#{high}" if wide || high
@@ -456,7 +504,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def br(args = nil, body = nil)
+  def br(args, data)
     num = api.args.first || "1"
     str = ""
     num.to_i.times { str << "<br>" }
@@ -464,7 +512,7 @@ module Livetext::Standard
     api.optional_blank_line
   end
 
-  def reflection(args = nil, body = nil)   # strictly experimental!
+  def reflection(args, data)   # strictly experimental!
     list = self.methods
     obj  = Object.instance_methods
     diff = (list - obj).sort

data/lib/livetext/userapi.rb

@@ -138,12 +138,31 @@ class Livetext::UserAPI
       @line = format(@line) unless raw
       lines << @line
     end
-    raise "Expected .end, found end of file" unless end?(@line)  # use custom exception
+    graceful_error ExpectedEnd() unless end?(@line)  # use custom exception
     optional_blank_line   # FIXME Delete this??
     return lines unless block_given?
     lines.each {|line| yield line }   # FIXME what about $. ?
   end
 
+  def body_with_raw
+    processed_lines = []
+    raw_lines = []
+    end_found = false
+    loop do
+      @line = @live.nextline
+      break if @line.nil?
+      @line.chomp!
+      break if end?(@line)
+      next if comment?(@line)
+      raw_lines << @line
+      @line = format(@line)
+      processed_lines << @line
+    end
+    graceful_error ExpectedEnd() unless end?(@line)  # use custom exception
+    optional_blank_line   # FIXME Delete this??
+    [processed_lines, raw_lines]
+  end
+
   def body_text(raw=false)
     raw_body.join("\n")
   end

data/lib/livetext/variable_manager.rb

@@ -0,0 +1,78 @@
+# Variable Manager - Centralized variable handling for Livetext
+class Livetext::VariableManager
+  def initialize(parent)
+    @parent = parent
+    @variables = Livetext::Variables.new
+    initialize_default_variables
+  end
+
+  def set(name, value)
+    @variables.set(name, value)
+  end
+
+  def get(name)
+    @variables.get(name)
+  end
+
+  def [](name)
+    @variables[name]
+  end
+
+  def set_multiple(pairs)
+    pairs.each do |name, value|
+      set(name, value)
+    end
+  end
+
+  def exists?(name)
+    @variables.exists?(name)
+  end
+
+  def list
+    @variables.inspect
+  end
+
+  def to_h
+    @variables.to_h
+  end
+
+  def replace(vars)
+    @variables = Livetext::Variables.new(vars)
+  end
+
+  # Enable live.vars.myvar syntax
+  def method_missing(name, *args)
+    if args.empty?
+      @variables[name.to_sym] || "[#{name} is undefined]"
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    true  # Since method_missing always returns a value, respond_to? should always return true
+  end
+
+  private
+
+  def initialize_default_variables
+    # System info variables
+    set(:User, `whoami`.chomp)
+    set(:Version, Livetext::VERSION)
+    set(:Hostname, `hostname`.chomp)
+    set(:Platform, RUBY_PLATFORM)
+    set(:RubyVersion, RUBY_VERSION)
+    set(:LivetextVersion, Livetext::VERSION)
+    
+    # Date/time variables
+    now = Time.now
+    set(:Year, now.year.to_s)
+    set(:Month, now.mon.to_s)
+    set(:Day, now.day.to_s)
+    set(:Hour, now.hour.to_s)
+    set(:Minute, now.min.to_s)
+    set(:Second, now.sec.to_s)
+    set(:Weekday, now.wday.to_s)
+    set(:Week, now.strftime("%U"))
+  end
+end

data/lib/livetext/variables.rb

@@ -21,7 +21,7 @@
     end
   
     def [](var)
-      @vars[var.to_sym]
+      @vars[var.to_sym] || "[#{var} is undefined]"
     end
 
     def []=(var, value)
@@ -46,5 +46,13 @@
     def to_a
       @vars.to_a
     end
+
+    def to_h
+      @vars.select { |k, v| k.is_a?(Symbol) }
+    end
+
+    def exists?(var)
+      @vars[var.to_sym] != nil
+    end
   end
 

data/lib/livetext/version.rb

@@ -2,5 +2,5 @@
 # Defining VERSION
 
 class Livetext
-  VERSION = "0.9.52"
+  VERSION = "0.9.56"
 end

data/lib/livetext.rb

@@ -5,7 +5,6 @@ if !defined?(Livetext)
   require_relative 'livetext/helpers'
   require_relative 'livetext/variables'
   require_relative 'livetext/core'
-  require_relative 'livetext/formatter'
   require_relative 'livetext/paths'
 
   require_relative 'livetext/reopen'
@@ -13,9 +12,16 @@ if !defined?(Livetext)
   require_relative 'livetext/errors'
   require_relative 'livetext/standard'
   require_relative 'livetext/functions'
+  require_relative 'livetext/function_registry'
+  require_relative 'livetext/variable_manager'
+  require_relative 'livetext/formatter'
   require_relative 'livetext/userapi'
-  # require_relative 'livetext/formatter'
-  require_relative 'livetext/processor'
+
 
   require_relative 'livetext/handler'
+  
+  # Include Standard after it's loaded
+  class Livetext
+    include Livetext::Standard
+  end
 end