livetext 0.9.55 → 0.9.58

data/plugin/mixin_functions_class.rb

@@ -0,0 +1,33 @@
+def some_dot_command(args, data)
+  # This is a dot command, not a function
+  api.out "Dot command called with: #{data}"
+end
+
+class Livetext::Functions
+  def class_func(param)
+    "Class function called with: #{param}"
+  end
+
+  def another_class_func(param)
+    "Another class function called with: #{param}"
+  end
+
+  def simple_class_func
+    "Simple class function with no parameters"
+  end
+
+  def vars_test(param)
+    # New approach: Access variables through the instance variables
+    # @live and @vars are now available in Livetext::Functions
+    
+    # Access variables using the new instance-based approach
+    view_var = @live.vars.View || "no_view"
+    
+    # Alternative approaches:
+    # view_var = @vars.View || "no_view"  # Direct access to vars
+    # view_var = get_var(:View) || "no_view"  # Using helper method
+    # view_var = Livetext::Vars[:View] || "no_view"  # Fallback to global
+    
+    "Vars test: param=#{param}, View=#{view_var}"
+  end
+end

data/test/snapshots/error_missing_end/match-error.txt

@@ -1 +1 @@
-1 /Expected .end, found end of file/
+1 /expected .end but found end of file/

data/test/snapshots/mixin_functions_class/expected-output.txt

@@ -0,0 +1,20 @@
+Testing functions defined in Livetext::Functions class
+<p>
+
+Now calling functions defined in Livetext::Functions class:
+Class function called with: test_parameter
+<p>
+
+And another one with brackets:
+Another class function called with: with brackets
+<p>
+
+And a function with no parameters:
+Simple class function with no parameters
+<p>
+
+Testing that the functions have access to Livetext::Vars:
+Vars test: param=some_value, View=[View is undefined]
+<p>
+
+That's all.

data/test/snapshots/mixin_functions_class/match-error.txt

@@ -0,0 +1 @@
+1 No error expected

data/test/snapshots/mixin_functions_class/mixin_functions_class.rb

@@ -0,0 +1,33 @@
+def some_dot_command(args, data)
+  # This is a dot command, not a function
+  api.out "Dot command called with: #{data}"
+end
+
+class Livetext::Functions
+  def class_func(param)
+    "Class function called with: #{param}"
+  end
+
+  def another_class_func(param)
+    "Another class function called with: #{param}"
+  end
+
+  def simple_class_func
+    "Simple class function with no parameters"
+  end
+
+  def vars_test(param)
+    # New approach: Access variables through the instance variables
+    # @live and @vars are now available in Livetext::Functions
+    
+    # Access variables using the new instance-based approach
+    view_var = @live.vars.View || "no_view"
+    
+    # Alternative approaches:
+    # view_var = @vars.View || "no_view"  # Direct access to vars
+    # view_var = get_var(:View) || "no_view"  # Using helper method
+    # view_var = Livetext::Vars[:View] || "no_view"  # Fallback to global
+    
+    "Vars test: param=#{param}, View=#{view_var}"
+  end
+end

data/test/snapshots/mixin_functions_class/source.lt3

@@ -0,0 +1,17 @@
+Testing functions defined in Livetext::Functions class
+
+.mixin mixin_functions_class
+
+Now calling functions defined in Livetext::Functions class:
+$$class_func:test_parameter
+
+And another one with brackets:
+$$another_class_func[with brackets]
+
+And a function with no parameters:
+$$simple_class_func
+
+Testing that the functions have access to Livetext::Vars:
+$$vars_test:some_value
+
+That's all.

data/test/snapshots/system_info/match-output.txt

@@ -0,0 +1,18 @@
+ 1  System Info Variables:
+ 2  Hostname: HAL9000
+ 3  /Platform: .*x86_64-darwin\d+/
+ 4  /Ruby Version: \d+\.\d+\.\d+/
+ 5  Livetext Version: 0.9.55
+ 6  <p>
+ 7  
+ 8  System Info Functions:
+ 9  Hostname: HAL9000
+10  /Platform: .*x86_64-darwin\d+/
+11  /Ruby Version: \d+\.\d+\.\d+/
+12  Livetext Version: 0.9.55
+13  <p>
+14  
+15  Date Formatting Functions:
+16  /Default: \d{4}-\d{2}-\d{2}/
+17  /Days ago: \d{4}-\d{2}-\d{2}/
+18  /Days from now: \d{4}-\d{2}-\d{2}/

data/test/unit/all.rb

@@ -10,6 +10,9 @@ require_relative 'variables'
 require_relative 'variable_manager'
 require_relative 'functions'
 require_relative 'function_registry'
+require_relative 'mixin_functions_class'
 require_relative 'formatter'
+require_relative 'formatter_component'
 require_relative 'core_methods'
+require_relative 'stringparser'
 

data/test/unit/ast.rb

@@ -0,0 +1,90 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/livetext/ast'
+
+class TestingLivetextAST < Minitest::Test
+  def setup
+    @ast = LivetextAST.new
+  end
+
+  def test_ast_initialization
+    # Test that AST is properly initialized
+    assert(@ast, "AST should be initialized")
+    assert_instance_of(LivetextAST, @ast)
+  end
+
+  def test_basic_formatting
+    # Test basic text formatting
+    assert_equal([:bold, "bold"], @ast.parse_inline_formatting("*bold"))
+    assert_equal([:italic, "italic"], @ast.parse_inline_formatting("_italic"))
+    assert_equal([:code, "code"], @ast.parse_inline_formatting("`code"))
+    assert_equal([:strike, "strike"], @ast.parse_inline_formatting("~strike"))
+  end
+
+  def test_double_markers
+    # Test double markers
+    assert_equal([:bold, "bold"], @ast.parse_inline_formatting("**bold"))
+    assert_equal("**", @ast.parse_inline_formatting("**"))  # standalone
+    assert_equal(" ** ", @ast.parse_inline_formatting(" ** "))  # surrounded by spaces
+  end
+
+  def test_bracketed_markers
+    # Test bracketed markers
+    assert_equal([:bold, "content"], @ast.parse_inline_formatting("*[content]"))
+    assert_equal([:italic, "content"], @ast.parse_inline_formatting("_[content]"))
+    assert_equal([:code, "content"], @ast.parse_inline_formatting("`[content]"))
+    assert_equal([], @ast.parse_inline_formatting("*[]"))  # empty brackets disappear
+  end
+
+  def test_escaped_markers
+    # Test escaped markers
+    assert_equal("*literal", @ast.parse_inline_formatting("\\*literal"))
+    assert_equal("_literal", @ast.parse_inline_formatting("\\_literal"))
+    assert_equal("`literal", @ast.parse_inline_formatting("\\`literal"))
+    assert_equal("~literal", @ast.parse_inline_formatting("\\~literal"))
+  end
+
+  def test_mixed_content
+    # Test mixed content with text and formatting
+    assert_equal([:text, [:bold, "bold"], " text"], @ast.parse_inline_formatting("*bold text"))
+    assert_equal([:text, "Hello ", [:bold, "world!"]], @ast.parse_inline_formatting("Hello *world!"))
+    assert_equal([:text, [:bold, "bold,"], " ", [:italic, "italic,"], " and ", [:code, "code"]], 
+                 @ast.parse_inline_formatting("*bold, _italic, and `code"))
+  end
+
+  def test_double_marker_termination
+    # Test double markers ending at comma and period
+    assert_equal([:text, [:bold, "word"], ", text"], @ast.parse_inline_formatting("**word, text"))
+    assert_equal([:text, [:bold, "word"], ". text"], @ast.parse_inline_formatting("**word. text"))
+  end
+
+  def test_edge_cases
+    # Test edge cases
+    assert_equal([], @ast.parse_inline_formatting(nil))
+    assert_equal([], @ast.parse_inline_formatting(""))
+    assert_equal("plain text", @ast.parse_inline_formatting("plain text"))
+  end
+
+  def test_complex_examples
+    # Test more complex examples
+    input = "Hello *world and **bold, text with _italic and `code"
+    expected = [:text, "Hello ", [:bold, "world"], " and ", [:bold, "bold"], ", text with ", [:italic, "italic"], " and ", [:code, "code"]]
+    assert_equal(expected, @ast.parse_inline_formatting(input))
+  end
+
+  def test_bracketed_with_spaces
+    # Test bracketed markers with spaces
+    assert_equal([:text, [:bold, "This whole thing"], " is bold"], 
+                 @ast.parse_inline_formatting("*[This whole thing] is bold"))
+    assert_equal([:text, [:italic, "Important note"], " here"], 
+                 @ast.parse_inline_formatting("_[Important note] here"))
+  end
+
+  def test_escaped_in_context
+    # Test escaped markers in context
+    assert_equal("Literal *asterisks* here", 
+                 @ast.parse_inline_formatting("Literal \\*asterisks\\* here"))
+    assert_equal([:text, "Mixed ", [:bold, "bold"], " and *literal* text"], 
+                 @ast.parse_inline_formatting("Mixed *bold and \\*literal\\* text"))
+  end
+end

data/test/unit/ast_directives.rb

@@ -0,0 +1,104 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/livetext/ast'
+
+class TestingLivetextASTDirectives < Minitest::Test
+  def setup
+    @ast = LivetextAST.new
+  end
+
+  def test_single_line_directives
+    # Single line directives (2 parameters: args, data)
+    assert_equal([LivetextAST::DIRECTIVE, "h1", "My Title"], 
+                 @ast.parse_directives([".h1 My Title"]))
+    
+    assert_equal([LivetextAST::DIRECTIVE, "set", "name=value"], 
+                 @ast.parse_directives([".set name=value"]))
+    
+    assert_equal([LivetextAST::DIRECTIVE, "comment", "This is a comment"], 
+                 @ast.parse_directives([". This is a comment"]))
+  end
+
+  def test_multi_line_comment_directive
+    # Multi-line .comment directive
+    input = [
+      ".comment",
+      "  This is a multi-line comment",
+      "  It can span multiple lines",
+      ".end"
+    ]
+    expected = [
+      LivetextAST::DIRECTIVE, "comment", "", 
+      [LivetextAST::BODY, ["  This is a multi-line comment", "  It can span multiple lines"]]
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+
+  def test_multi_line_directives
+    # Multi line directives (3 parameters: args, data, body)
+    input = [
+      ".list",
+      "  * item 1", 
+      "  * item 2",
+      "  * item 3",
+      ".end"
+    ]
+    expected = [
+      LivetextAST::DIRECTIVE, "list", "", 
+      [LivetextAST::BODY, ["  * item 1", "  * item 2", "  * item 3"]]
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+
+  def test_directive_with_args_and_body
+    input = [
+      ".func myfunc",
+      "  return 'Hello, World!'",
+      ".end"
+    ]
+    expected = [
+      LivetextAST::DIRECTIVE, "func", "myfunc",
+      [LivetextAST::BODY, ["  return 'Hello, World!'"]]
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+
+  def test_missing_end_error
+    input = [
+      ".list",
+      "  * item 1",
+      "  * item 2"
+      # Missing .end
+    ]
+    expected = [
+      LivetextAST::ERROR, "Missing .end", 1, "list"
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+
+  def test_unknown_directive
+    input = [".unknown_directive some args"]
+    expected = [
+      LivetextAST::ERROR, "Unknown directive", 1, "unknown_directive"
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+
+  def test_empty_input
+    assert_equal([], @ast.parse_directives([]))
+    assert_equal([], @ast.parse_directives(nil))
+  end
+
+  def test_non_directive_lines
+    input = [
+      "Just some text",
+      "More text here",
+      ".h1 A Title",
+      "More text"
+    ]
+    expected = [
+      LivetextAST::DIRECTIVE, "h1", "A Title"
+    ]
+    assert_equal(expected, @ast.parse_directives(input))
+  end
+end

data/test/unit/ast_variables.rb

@@ -0,0 +1,71 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/livetext/ast'
+
+class TestingLivetextASTVariables < Minitest::Test
+  def setup
+    @ast = LivetextAST.new
+  end
+
+  def test_variable_parsing
+    # Basic variables
+    assert_equal([LivetextAST::VAR, "name"], @ast.parse_variables("$name"))
+    assert_equal([LivetextAST::VAR, "my_var"], @ast.parse_variables("$my_var"))
+    assert_equal([LivetextAST::VAR, "font.title"], @ast.parse_variables("$font.title"))
+    
+    # Invalid names should be left as literal text
+    assert_equal("$_invalid", @ast.parse_variables("$_invalid"))
+    assert_equal("$3invalid", @ast.parse_variables("$3invalid"))
+    
+    # Edge cases - Livetext behavior:
+    # $foo. -> parses $foo as variable, . as literal (matches Livetext)
+    assert_equal([LivetextAST::TEXT, [LivetextAST::VAR, "foo"], "."], @ast.parse_variables("$foo."))
+    # $a..b -> parses $a as variable, ..b as literal (matches Livetext)
+    assert_equal([LivetextAST::TEXT, [LivetextAST::VAR, "a"], "..b"], @ast.parse_variables("$a..b"))
+  end
+
+  def test_function_parsing
+    # No parameter
+    assert_equal([LivetextAST::FUNC, "myfunc", LivetextAST::SPACE, nil], @ast.parse_functions("$$myfunc "))
+    assert_equal([LivetextAST::FUNC, "myfunc", LivetextAST::EOL, nil], @ast.parse_functions("$$myfunc"))
+    
+    # Colon parameter
+    assert_equal([LivetextAST::FUNC, "greet", LivetextAST::COLON, "world"], @ast.parse_functions("$$greet:world"))
+    
+    # Bracket parameter
+    assert_equal([LivetextAST::FUNC, "mean", LivetextAST::LBRACK, "1,2,3"], @ast.parse_functions("$$mean[1,2,3]"))
+    assert_equal([LivetextAST::FUNC, "title", LivetextAST::LBRACK, "My Title"], @ast.parse_functions("$$title[My Title]"))
+    
+    # Note: Function parameter delimiters are tracked as requested:
+    # SPACE, EOL, COLON, LBRACK for debugging/future use
+  end
+
+  def test_mixed_content
+    # Variables in text
+    input = "Hello $name, welcome to $nation!"
+    expected = [LivetextAST::TEXT, "Hello ", [LivetextAST::VAR, "name"], ", welcome to ", [LivetextAST::VAR, "nation"], "!"]
+    assert_equal(expected, @ast.parse_variables(input))
+    
+    # Functions in text
+    input = "The result is $$mean[1,2,3] as expected."
+    expected = [LivetextAST::TEXT, "The result is ", [LivetextAST::FUNC, "mean", LivetextAST::LBRACK, "1,2,3"], " as expected."]
+    assert_equal(expected, @ast.parse_functions(input))
+  end
+
+  def test_escaped_dollars
+    # Escaped variables and functions
+    # Note: Backslash escapes the entire $ or $$ sequence
+    assert_equal("\\$literal", @ast.parse_variables("\\$literal"))
+    assert_equal("\\$\\$literal", @ast.parse_functions("\\$\\$literal"))
+  end
+
+  def test_edge_cases
+    # Empty strings
+    assert_equal([], @ast.parse_variables(""))
+    assert_equal([], @ast.parse_functions(""))
+    
+    # No variables/functions
+    assert_equal("plain text", @ast.parse_variables("plain text"))
+    assert_equal("plain text", @ast.parse_functions("plain text"))
+  end
+end

data/test/unit/core_methods.rb

@@ -29,6 +29,186 @@ class TestingLivetextCoreMethods < Minitest::Test
     assert_equal(@live, result) # Should return self
   end
 
+  def test_customize_with_plugin
+    # Test customize with a real plugin
+    obj = Livetext.customize(
+      mix: ['tutorial'],
+      call: [],
+      vars: {}
+    )
+    
+    assert_instance_of(Livetext, obj)
+    # Should have loaded the tutorial plugin
+    assert_includes(obj.methods, :title)
+  end
+
+  def test_customize_with_commands
+    # Test customize with dot commands
+    obj = Livetext.customize(
+      mix: [],
+      call: ['.set VAR="test_value"'],
+      vars: {}
+    )
+    
+    assert_instance_of(Livetext, obj)
+    # Process some text to see if the variable was set
+    body, vars = obj.process(text: "Variable: $VAR")
+    assert_includes(body, "Variable: test_value")
+  end
+
+  def test_customize_with_variables
+    # Test customize with variables
+    obj = Livetext.customize(
+      mix: [],
+      call: [],
+      vars: { 'name' => 'World', 'title' => 'Test' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    # Process some text to see if variables were set
+    body, vars = obj.process(text: "Hello $name\n.h1 $title")
+    assert_includes(body, "Hello World")
+    assert_includes(body, "Test")
+  end
+
+  def test_customize_comprehensive
+    # Test all features together
+    obj = Livetext.customize(
+      mix: ['tutorial'],
+      call: ['.set PLUGIN_VAR="plugin_value"'],
+      vars: { 'custom_var' => 'custom_value' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    
+    # Test that plugin was loaded
+    assert_includes(obj.methods, :title)
+    
+    # Test that variables were set
+    body, vars = obj.process(text: "Plugin: $PLUGIN_VAR\nCustom: $custom_var")
+    assert_includes(body, "Plugin: plugin_value")
+    assert_includes(body, "Custom: custom_value")
+  end
+
+  def test_customize_error_handling
+    # Test customize with invalid plugin
+    assert_raises(FileNotFound) do
+      Livetext.customize(mix: ['nonexistent_plugin'])
+    end
+  end
+
+  def test_customize_empty_parameters
+    # Test customize with empty parameters
+    obj = Livetext.customize()
+    assert_instance_of(Livetext, obj)
+    
+    # Should still work for basic processing
+    body, vars = obj.process(text: "Hello world")
+    assert_includes(body, "Hello world")
+  end
+
+  def test_customize_string_vs_array
+    # Test that string parameters are converted to arrays
+    obj = Livetext.customize(
+      mix: 'tutorial',
+      call: '.nopara',
+      vars: { 'test' => 'value' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    assert_includes(obj.methods, :title)
+  end
+
+  def test_customize_variables_accessible
+    # Test that variables passed to customize are actually accessible afterward
+    obj = Livetext.customize(
+      mix: [],
+      call: [],
+      vars: { 'name' => 'World', 'title' => 'Test Title', 'count' => '42' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    
+    # Test that variables are accessible via vars.to_h
+    vars_hash = obj.vars.to_h
+    assert_equal('World', vars_hash[:name])
+    assert_equal('Test Title', vars_hash[:title])
+    assert_equal('42', vars_hash[:count])
+    
+    # Test that variables are accessible via variables.to_h
+    variables_hash = obj.variables.to_h
+    assert_equal('World', variables_hash[:name])
+    assert_equal('Test Title', variables_hash[:title])
+    assert_equal('42', variables_hash[:count])
+    
+    # Test that variables work in processing
+    body, vars = obj.process(text: "Hello $name\n.h1 $title\nCount: $count")
+    assert_includes(body, "Hello World")
+    assert_includes(body, "Test Title")
+    assert_includes(body, "Count: 42")
+  end
+
+  def test_customize_variables_global_access
+    # Test that variables passed to customize are accessible via Livetext::Vars
+    obj = Livetext.customize(
+      mix: [],
+      call: [],
+      vars: { 'name' => 'World', 'title' => 'Test Title', 'count' => '42' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    
+    # Test that variables are accessible via Livetext::Vars (global access)
+    assert_equal('World', Livetext::Vars[:name])
+    assert_equal('Test Title', Livetext::Vars[:title])
+    assert_equal('42', Livetext::Vars[:count])
+  end
+
+  def test_variable_dot_access
+    # Test that variables can be accessed via live.vars.myvar syntax
+    obj = Livetext.customize(
+      mix: [],
+      call: [],
+      vars: { 'name' => 'World', 'title' => 'Test Title', 'count' => '42' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    
+    # Test dot access syntax
+    assert_equal('World', obj.vars.name)
+    assert_equal('Test Title', obj.vars.title)
+    assert_equal('42', obj.vars.count)
+    
+    # Test that built-in variables also work
+    assert_equal(Livetext::VERSION, obj.vars.Version)
+    assert_equal(`hostname`.chomp, obj.vars.Hostname)
+    
+    # Test that respond_to? works correctly
+    assert(obj.vars.respond_to?(:name))
+    assert(obj.vars.respond_to?(:title))
+    assert(obj.vars.respond_to?(:Version))
+    assert(obj.vars.respond_to?(:nonexistent))  # Now returns true since method_missing always returns a value
+  end
+
+  def test_variable_dot_access_nonexistent
+    # Test what happens when accessing a nonexistent variable with dot syntax
+    obj = Livetext.customize(
+      mix: [],
+      call: [],
+      vars: { 'name' => 'World' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    
+    # Test that all access methods return the same fallback message
+    assert_equal('[nonexistent is undefined]', obj.vars.nonexistent)
+    assert_equal('[nonexistent is undefined]', obj.vars[:nonexistent])
+    assert_equal('[nonexistent is undefined]', obj.vars.get(:nonexistent))
+    
+    # Test global access also returns fallback message
+    assert_equal('[nonexistent is undefined]', Livetext::Vars[:nonexistent])
+  end
+
   def test_process_text
     # Test processing text directly
     text = "Hello world\nThis is a test\n.h1 Title"

data/test/unit/formatter_component.rb

@@ -10,7 +10,7 @@ class TestingLivetextFormatter < Minitest::Test
   def test_formatter_component_initialization
     # Test that FormatterComponent is properly initialized
     assert(@live.formatter, "FormatterComponent should be initialized")
-    assert_instance_of(Livetext::FormatterComponent, @live.formatter)
+    assert_instance_of(Livetext::Formatter, @live.formatter)
   end
 
   def test_basic_formatting