livetext 0.9.55 → 0.9.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00c147a97637c967777f1a1a8bae52d8e0ca8e65f3e032e9a03f0f3bbc2c5d50
-  data.tar.gz: c931920c669cf05c76176d19bcfb9c06149d3bf6b32167aa2e6da7b50290adef
+  metadata.gz: 03b835ce30fd58d0d0bdca2902661242763e9ea1c9cc71bb49bad16543b9f2f0
+  data.tar.gz: 36e4bf16acf045e4960ba5e5238c33561f640c63ae80be628805b15ccdefc00d
 SHA512:
-  metadata.gz: 59836de9481a1239cf0c0f00f55681da634c7e96e337c67d2c4fb8974ec3dad06fa83bbe7eb7f73596c73d97e9359aab613efbf87d0ddfe70e9a3a50c65e931e
-  data.tar.gz: b0e1a74d2d75e8c47afff0881594d1022dbb63e71ec67b8304622b9885bc62429d6782286482a45520587207fc48e4158d0a857f51bcac5596c51cc779f2cf01
+  metadata.gz: ba6cdce7c715a47048bd48cb66428afcd8510466df09d7c946b1c1aa156aa7216bb3695a5cbdb0b5d0a9954f6d6a3cd17eb79d8c0d05ab6e143eb542e5b66eed
+  data.tar.gz: 20a0995a45aba208d232265dd4f2fcff0f2d28bff1deb5b05b743b5c8fa01f7b3ea2ba32b22c9426eba1421ed665b0c1606561b268f1b109df69addc7e084f97

data/lib/livetext/ast/show_ast_clean.rb

@@ -0,0 +1,10 @@
+require_relative 'lib/livetext/ast'
+
+ast = LivetextAST.new
+lines = File.readlines('examples/example1/README.lt3').map(&:chomp)
+result = ast.parse_directives(lines)
+
+puts "AST RESULT:"
+puts "=" * 50
+puts LivetextAST.inspect_ast(result)
+puts "=" * 50

data/lib/livetext/ast/show_ast_result.rb

@@ -0,0 +1,60 @@
+require_relative 'lib/livetext/ast'
+
+ast = LivetextAST.new
+
+puts "=== Complete AST for README.lt3 ==="
+puts
+
+# Read the file
+lines = File.readlines('examples/example1/README.lt3').map(&:chomp)
+
+# Parse directives
+directive_result = ast.parse_directives(lines)
+
+puts "File has #{lines.length} lines"
+puts "Found #{directive_result.is_a?(Array) ? directive_result.length : 1} directives"
+puts
+
+puts "=== AST Structure (Pretty Printed) ==="
+puts LivetextAST.inspect_ast(directive_result)
+puts
+
+puts "=== Summary by Directive Type ==="
+if directive_result.is_a?(Array)
+  directive_types = directive_result.map { |d| d[1] if d.is_a?(Array) && d[0] == :directive }.compact
+  type_counts = directive_types.group_by(&:itself).transform_values(&:count)
+  type_counts.sort.each do |type, count|
+    puts "#{type}: #{count}"
+  end
+else
+  puts "Single directive: #{directive_result[1] if directive_result.is_a?(Array)}"
+end
+puts
+
+puts "=== Sample Text Lines with Formatting ==="
+text_lines = lines.reject { |line| line.start_with?('.') || line.strip.empty? }
+sample_lines = text_lines.first(10)
+
+sample_lines.each_with_index do |line, i|
+  puts "Line #{i+1}: #{line.inspect}"
+  
+  # Parse variables
+  var_result = ast.parse_variables(line)
+  if var_result != line
+    puts "  Variables: #{LivetextAST.inspect_ast(var_result)}"
+  end
+  
+  # Parse functions
+  func_result = ast.parse_functions(line)
+  if func_result != line
+    puts "  Functions: #{LivetextAST.inspect_ast(func_result)}"
+  end
+  
+  # Parse formatting
+  format_result = ast.parse_inline_formatting(line)
+  if format_result != line
+    puts "  Formatting: #{LivetextAST.inspect_ast(format_result)}"
+  end
+  
+  puts
+end

data/lib/livetext/ast/show_raw_arrays.rb

@@ -0,0 +1,13 @@
+require_relative 'lib/livetext/ast'
+
+ast = LivetextAST.new
+lines = File.readlines('examples/example1/README.lt3').map(&:chomp)
+result = ast.parse_directives(lines)
+
+puts "RAW ARRAYS:"
+puts "=" * 50
+result.each_with_index do |directive, i|
+  puts "Directive #{i+1}: #{directive.inspect}"
+  puts
+end
+puts "=" * 50

data/lib/livetext/ast.rb

@@ -0,0 +1,464 @@
+# Livetext AST Parser for Inline Formatting, Variables, and Functions
+# Parses Livetext syntax into s-expression style Ruby arrays
+#
+# Features:
+# - Inline formatting: *bold, _italic, `code, ~strike, **double, *[bracketed]
+# - Variables: $name, $my_var, $font.title (with validation)
+# - Functions: $$func, $$func:param, $$func[param], $$func (space/eol)
+# - Escaped characters: \*, \_, \`, \~, \$, \$\$
+# - Parameter delimiter tracking for functions (:space, :eol, :colon, :lbrack)
+#
+# Edge cases handled to match Livetext behavior:
+# - $foo. -> parses $foo as variable, . as literal
+# - $a..b -> parses $a as variable, ..b as literal
+# - Invalid names left as literal text
+
+class LivetextAST
+  # AST node type constants
+  TEXT = :text
+  BOLD = :bold
+  ITALIC = :italic
+  CODE = :code
+  STRIKE = :strike
+  VAR = :var
+  FUNC = :func
+  BODY = :body
+  DIRECTIVE = :directive
+  ERROR = :error
+  
+  # Function parameter delimiter constants
+  SPACE = :space
+  EOL = :eol
+  COLON = :colon
+  LBRACK = :lbrack
+  def initialize
+    @escaped_chars = {}
+    @escape_counter = 0
+  end
+
+  def parse_inline_formatting(text)
+    return [] if text.nil? || text.empty?
+    
+    # Step 1: Mark escaped characters
+    text = mark_escaped_characters(text)
+    
+    # Step 2: Parse in order of precedence
+    result = parse_bracketed_markers(text)
+    result = parse_double_markers(result)
+    result = parse_single_markers(result)
+    
+    # Step 3: Restore escaped characters
+    result = restore_escaped_characters(result)
+    
+    # Step 4: Convert to s-expression format
+    convert_to_formatting_sexpr(result)
+  end
+
+  def parse_variables(text)
+    return [] if text.nil? || text.empty?
+    
+    # Step 1: Mark escaped dollar signs
+    text = mark_escaped_dollars(text)
+    
+    # Step 2: Parse variables
+    result = parse_variable_markers(text)
+    
+    # Step 3: Restore escaped characters
+    result = restore_escaped_characters(result)
+    
+    # Step 4: Convert to s-expression format
+    convert_to_variable_sexpr(result)
+  end
+
+  def parse_functions(text)
+    return [] if text.nil? || text.empty?
+    
+    # Step 1: Mark escaped dollar signs
+    text = mark_escaped_dollars(text)
+    
+    # Step 2: Parse functions
+    result = parse_function_markers(text)
+    
+    # Step 3: Restore escaped characters
+    result = restore_escaped_characters(result)
+    
+    # Step 4: Convert to s-expression format
+    convert_to_function_sexpr(result)
+  end
+
+  def parse_directives(lines)
+    return [] if lines.nil? || lines.empty?
+    
+    # Step 2: Parse each directive
+    result = []
+    i = 0
+    while i < lines.length
+      line = lines[i]
+      if line.start_with?('.') && line.strip != ".end"
+        directive_result = parse_single_directive(lines, i)
+        if directive_result.is_a?(Array) && directive_result.first == ERROR
+          # Error occurred, return the error
+          return directive_result
+        else
+          result << directive_result
+          # Skip to the line after the directive (including body if any)
+          if directive_result.is_a?(Array) && directive_result.first == DIRECTIVE && directive_result.length == 4
+            # Multi-line directive with body, find the .end
+            j = i + 1
+            while j < lines.length && lines[j].strip != ".end"
+              j += 1
+            end
+            i = j  # Skip to after .end
+          end
+        end
+      end
+      i += 1
+    end
+    
+    # Step 3: Return single directive or array of directives
+    result.length == 1 ? result.first : result
+  end
+
+  private
+
+  def mark_escaped_characters(str)
+    str.gsub(/\\([*_`~])/) do |match|
+      marker = "ESCAPED_#{@escape_counter}"
+      @escaped_chars[marker] = $1
+      @escape_counter += 1
+      marker
+    end
+  end
+
+  def mark_escaped_dollars(str)
+    str.gsub(/\\(\$+)/) do |match|
+      marker = "ESCAPED_#{@escape_counter}"
+      @escaped_chars[marker] = match  # Store the full escaped sequence
+      @escape_counter += 1
+      marker
+    end
+  end
+
+  def restore_escaped_characters(str)
+    @escaped_chars.each do |marker, char|
+      str = str.gsub(marker, char)
+    end
+    @escaped_chars.clear  # Reset for next use
+    str
+  end
+
+  def parse_bracketed_markers(text)
+    # Handle *[content], _[content], `[content], ~[content]
+    text.gsub(/([*_`~])\[([^\]]*)\]/) do |match|
+      marker, content = $1, $2
+      if content.empty?
+        ""  # empty brackets disappear
+      else
+        format_type = case marker
+                     when "*" then BOLD
+                     when "_" then ITALIC
+                     when "`" then CODE
+                     when "~" then STRIKE
+                     end
+        "FORMAT_#{format_type}_#{content}_END"
+      end
+    end
+  end
+
+  def parse_double_markers(text)
+    # Handle **word, text and **word. text
+    text.gsub(/(?<=\s|^)\*\*([^\s,.]*)/) do |match|
+      if $1.empty?
+        "**"  # standalone ** should be literal
+      else
+        "FORMAT_bold_#{$1}_END"
+      end
+    end
+  end
+
+  def parse_single_markers(text)
+    # Handle *word, _word, `word, ~word
+    text.gsub(/(?<=\s|^)([*_`~])(?!\[)(?!\*)([^\s]*)/) do |match|
+      marker, content = $1, $2
+      if content.empty?
+        marker  # standalone marker should be literal
+      else
+        format_type = case marker
+                     when "*" then BOLD
+                     when "_" then ITALIC
+                     when "`" then CODE
+                     when "~" then STRIKE
+                     end
+        "FORMAT_#{format_type}_#{content}_END"
+      end
+    end
+  end
+
+  def parse_variable_markers(text)
+    # Handle $variable names
+    # Valid names: start with letter, contain letters/numbers/underscores, can have periods as separators
+    # Must be followed by word boundary or end of string
+    text.gsub(/\$([a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)*)(?=\b|$)/) do |match|
+      var_name = $1
+      if valid_variable_name?(var_name)
+        "VAR_#{var_name}_END"
+      else
+        match  # leave as literal if invalid
+      end
+    end
+  end
+
+  def parse_function_markers(text)
+    # Handle $$function names with parameters
+    # Pattern: $$name, $$name:param, $$name[param], $$name (space or eol)
+    text.gsub(/\$\$([a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)*)(?:\s|$|:([^\s]+)|\[([^\]]*)\])?/) do |match|
+      func_name = $1
+      colon_param = $3
+      bracket_param = $4
+      
+      if valid_function_name?(func_name)
+        if colon_param
+          "FUNC_#{func_name}_COLON_#{colon_param}_END"
+        elsif bracket_param
+          "FUNC_#{func_name}_LBRACK_#{bracket_param}_END"
+        elsif match.end_with?(" ")
+          "FUNC_#{func_name}_SPACE_END"
+        else
+          "FUNC_#{func_name}_EOL_END"
+        end
+      else
+        match  # leave as literal if invalid
+      end
+    end
+  end
+
+  def valid_variable_name?(name)
+    # Must start with letter, contain only letters/numbers/underscores/periods
+    # No consecutive periods, no trailing period, no leading period
+    return false unless name =~ /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)*$/
+    return false if name.include?("..") || name.end_with?(".") || name.start_with?(".")
+    true
+  end
+
+  def valid_function_name?(name)
+    # Same rules as variables
+    valid_variable_name?(name)
+  end
+
+  def parse_single_directive(lines, start_line)
+    line = lines[start_line]
+    line_num = start_line + 1
+    
+    # Handle dot-space comments (single line)
+    if line =~ /^\.\s+(.*)$/
+      return [DIRECTIVE, "comment", $1]
+    end
+    
+    # Parse directive name and arguments
+    if line =~ /^\.(\w+)(?:\s+(.*))?$/
+      directive_name = $1
+      args = $2 || ""
+      
+      # Check if directive exists in standard.rb
+      unless directive_exists?(directive_name)
+        return [ERROR, "Unknown directive", line_num, directive_name]
+      end
+      
+      # Check if directive takes a body (3 parameters)
+      if directive_has_body?(directive_name)
+        # Parse body until .end
+        body_lines = []
+        i = start_line + 1
+        
+        while i < lines.length
+          current_line = lines[i]
+          if current_line.strip == ".end"
+            return [DIRECTIVE, directive_name, args, [BODY, body_lines]]
+          elsif current_line.strip.start_with?('.') && current_line.strip != ".end"
+            # Found another directive inside body - for rough approximation, just include it
+            # In real Livetext this would be an error, but we're being permissive
+            body_lines << current_line
+          else
+            body_lines << current_line
+          end
+          i += 1
+        end
+        
+        # Reached end of file without .end
+        return [ERROR, "Missing .end", line_num, directive_name]
+      else
+        # Single line directive
+        return [DIRECTIVE, directive_name, args]
+      end
+    else
+      return [ERROR, "Invalid directive syntax", line_num, line.strip]
+    end
+  end
+
+  def directive_exists?(name)
+    # .end is a special case - it's not a directive but a terminator
+    return false if name == "end"
+    
+    # For now, assume any word after a dot is a valid directive
+    # This is a rough approximation that will catch most cases
+    true
+  end
+
+  def directive_has_body?(name)
+    # Heuristic: if we don't know about a directive, assume it might have a body
+    # and let the parsing logic figure it out by looking for .end
+    
+    # Known single-line directives (definitely no body)
+    single_line_directives = %w[
+      h1 h2 h3 h4 h5 h6 set variables variables! errout ttyout say banner
+      cleanup mono br reflection backtrace passthru nopass para nopara 
+      heading newpage cinclude dot_include inherit mixin import copy r 
+      raw debug seek title section testcase
+    ]
+    
+    # If it's in the single-line list, it definitely doesn't have a body
+    return false if single_line_directives.include?(name)
+    
+    # Otherwise, assume it might have a body and let the parser check for .end
+    true
+  end
+
+  # Custom inspect method for prettier AST output
+  def self.inspect_ast(ast)
+    case ast
+    when Array
+      if ast.empty?
+        "[]"
+      elsif ast.first.is_a?(Symbol)
+        case ast.first
+        when TEXT
+          "[TEXT, #{ast[1..-1].map { |part| inspect_ast(part) }.join(', ')}]"
+        when BOLD
+          "[BOLD, #{ast[1].inspect}]"
+        when ITALIC
+          "[ITALIC, #{ast[1].inspect}]"
+        when CODE
+          "[CODE, #{ast[1].inspect}]"
+        when STRIKE
+          "[STRIKE, #{ast[1].inspect}]"
+        when VAR
+          "[VAR, #{ast[1].inspect}]"
+        when FUNC
+          delimiter = ast[2]
+          param = ast[3]
+          if param
+            "[FUNC, #{ast[1].inspect}, #{delimiter}, #{param.inspect}]"
+          else
+            "[FUNC, #{ast[1].inspect}, #{delimiter}]"
+          end
+        when BODY
+          "[BODY, #{ast[1].inspect}]"
+        when DIRECTIVE
+          if ast.length == 3
+            "[DIRECTIVE, #{ast[1].inspect}, #{ast[2].inspect}]"
+          else
+            "[DIRECTIVE, #{ast[1].inspect}, #{ast[2].inspect}, #{inspect_ast(ast[3])}]"
+          end
+        when ERROR
+          "[ERROR, #{ast[1].inspect}, #{ast[2]}, #{ast[3].inspect}]"
+        else
+          ast.inspect
+        end
+      else
+        ast.inspect
+      end
+    when String
+      ast.inspect
+    else
+      ast.inspect
+    end
+  end
+
+  def convert_to_formatting_sexpr(text)
+    # Split by FORMAT markers and convert to s-expressions
+    parts = text.split(/(FORMAT_\w+_[^_]*_END)/)
+    
+    result = []
+    parts.each do |part|
+      if part.start_with?("FORMAT_")
+        # Parse format marker
+        if part =~ /FORMAT_(\w+)_([^_]*)_END/
+          format_type = $1.to_sym
+          content = $2
+          result << [format_type, content]
+        end
+      else
+        # Plain text
+        result << part unless part.empty?
+      end
+    end
+    
+    # Handle edge cases
+    if result.empty?
+      return []
+    elsif result.length == 1
+      return result.first
+    else
+      return [TEXT, *result]
+    end
+  end
+
+  def convert_to_variable_sexpr(text)
+    # Split by VAR markers and convert to s-expressions
+    parts = text.split(/(VAR_.*?_END)/)
+    
+    result = []
+    parts.each do |part|
+      if part.start_with?("VAR_")
+        # Parse variable marker
+        if part =~ /VAR_(.*?)_END/
+          var_name = $1
+          result << [VAR, var_name]
+        end
+      else
+        # Plain text
+        result << part unless part.empty?
+      end
+    end
+    
+    # Handle edge cases
+    if result.empty?
+      return []
+    elsif result.length == 1
+      return result.first
+    else
+      return [:text, *result]
+    end
+  end
+
+  def convert_to_function_sexpr(text)
+    # Split by FUNC markers and convert to s-expressions
+    parts = text.split(/(FUNC_.*?_(?:SPACE|EOL|COLON|LBRACK)(?:_.*?)?_END)/)
+    
+    result = []
+    parts.each do |part|
+      if part.start_with?("FUNC_")
+        # Parse function marker
+        if part =~ /FUNC_(.*?)_(SPACE|EOL|COLON|LBRACK)(?:_(.*?))?_END/
+          func_name = $1
+          delimiter = $2.downcase.to_sym
+          param = $3
+          param = nil if param.nil? || param.empty? || delimiter == SPACE || delimiter == EOL
+          result << [FUNC, func_name, delimiter, param]
+        end
+      else
+        # Plain text
+        result << part unless part.empty?
+      end
+    end
+    
+    # Handle edge cases
+    if result.empty?
+      return []
+    elsif result.length == 1
+      return result.first
+    else
+      return [TEXT, *result]
+    end
+  end
+end

data/lib/livetext/ast_to_html.rb

@@ -0,0 +1,32 @@
+# AST to HTML Converter
+# Converts LivetextAST output back to HTML
+
+class LivetextASTToHTML
+  def self.convert(ast)
+    case ast
+    when Array
+      if ast.empty?
+        ""  # empty array maps to empty string
+      elsif ast.first == :text
+        # [:text, "Hello ", [:bold, "world"], "!"]
+        ast[1..-1].map { |part| convert(part) }.join
+      elsif ast.length == 2
+        # [:bold, "content"], [:italic, "content"], etc.
+        format_type, content = ast
+        case format_type
+        when :bold then "<b>#{content}</b>"
+        when :italic then "<i>#{content}</i>"
+        when :code then "<tt>#{content}</tt>"
+        when :strike then "<strike>#{content}</strike>"
+        else content  # fallback
+        end
+      else
+        ast.to_s  # fallback
+      end
+    when String
+      ast
+    else
+      ast.to_s
+    end
+  end
+end

data/lib/livetext/core.rb

@@ -78,8 +78,10 @@ class Livetext
     mix.each do |lib| 
       obj.invoke_dotcmd(:mixin, lib.dup)
     end
-    call.each {|cmd| obj.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
 
@@ -87,9 +89,11 @@ class Livetext
     mix  = Array(mix)
     call = Array(call)
     mix.each {|lib| mixin(lib) }
-    call.each {|cmd| 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
 
@@ -154,8 +158,6 @@ class Livetext
     @api = obj
   end
 
-
-
   def process(text: nil, file: nil, vars: {})
     # Set variables first
     @variables.set_multiple(vars) unless vars.empty?

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/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