livetext 0.9.52 → 0.9.56

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

@@ -0,0 +1,317 @@
+require 'minitest/autorun'
+require_relative '../../lib/livetext'
+
+class TestingLivetextCoreMethods < Minitest::Test
+  def setup
+    @live = Livetext.new
+  end
+
+  def test_customize_class_method
+    # Test the class-level customize method
+    obj = Livetext.customize(
+      mix: [], 
+      call: ['.nopara'], 
+      vars: { 'test_var' => 'test_value' }
+    )
+    
+    assert_instance_of(Livetext, obj)
+    # The customize method should set up the instance with mixins, commands, and vars
+  end
+
+  def test_customize_instance_method
+    # Test the instance-level customize method
+    result = @live.customize(
+      mix: [],
+      call: ['.nopara'],
+      vars: { 'test_var' => 'test_value' }
+    )
+    
+    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"
+    body, vars = @live.process(text: text)
+    
+    assert_includes(body, "Hello world")
+    assert_includes(body, "This is a test")
+    # Should process the .h1 command
+    assert_instance_of(Hash, vars)
+  end
+
+  def test_process_file
+    # Test processing a file
+    # Create a temporary test file
+    require 'tempfile'
+    temp_file = Tempfile.new(['test', '.lt3'])
+    temp_file.write("Hello from file\n.h1 File Title")
+    temp_file.close
+    
+    body, vars = @live.process(file: temp_file.path)
+    
+    assert_includes(body, "Hello from file")
+    # Should process the .h1 command
+    assert_instance_of(Hash, vars)
+    
+    temp_file.unlink
+  end
+
+  def test_process_with_file
+    # Test process method with file parameter
+    require 'tempfile'
+    temp_file = Tempfile.new(['test', '.lt3'])
+    temp_file.write("Hello from process file\n.h1 Process Title")
+    temp_file.close
+    
+    body, vars = @live.process(file: temp_file.path)
+    
+    assert_includes(body, "Hello from process file")
+    # Should process the .h1 command
+    assert_instance_of(Hash, vars)
+    
+    temp_file.unlink
+  end
+
+  def test_process_with_text
+    # Test process method with text parameter
+    text = "Hello from process text\n.h1 Process Text Title"
+    body, vars = @live.process(text: text)
+    
+    assert_includes(body, "Hello from process text")
+    # Should process the .h1 command
+    assert_instance_of(Hash, vars)
+  end
+
+  def test_process_with_vars
+    # Test process method with variables
+    text = "Hello $name\n.h1 $title"
+    body, vars = @live.process(text: text, vars: { 'name' => 'World', 'title' => 'Test Title' })
+    
+    assert_includes(body, "Hello World")
+    assert_includes(body, "Test Title")
+    assert_equal('World', vars[:name])
+    assert_equal('Test Title', vars[:title])
+  end
+
+  def test_process_error_handling
+    # Test process method error cases
+    assert_raises(RuntimeError) { @live.process } # No file or text
+    assert_raises(RuntimeError) { @live.process(file: 'nonexistent.lt3', text: 'some text') } # Both file and text
+  end
+
+  def test_backward_compatibility
+    # Test that old methods still work
+    text = "Hello from old method\n.h1 Old Title"
+    
+    # Test transform
+    result1 = @live.transform(text)
+    assert_includes(result1, "Hello from old method")
+    
+    # Test xform with text
+    result2 = @live.xform(text: text)
+    assert_includes(result2, "Hello from old method")
+    
+    # Test xform_file
+    require 'tempfile'
+    temp_file = Tempfile.new(['test', '.lt3'])
+    temp_file.write("Hello from old file method\n.h1 Old File Title")
+    temp_file.close
+    
+    result3 = @live.xform_file(temp_file.path)
+    assert_includes(result3, "Hello from old file method")
+    
+    temp_file.unlink
+  end
+
+  def test_process_returns_array
+    # Test that process returns [body, vars] array
+    text = "Hello $name\n.set title=\"Test Title\"\n.h1 $title"
+    body, vars = @live.process(text: text, vars: { 'name' => 'World' })
+    
+    assert_includes(body, "Hello World")
+    assert_includes(body, "Test Title")
+    assert_equal('World', vars[:name])
+    assert_equal('Test Title', vars[:title])
+  end
+end

data/test/unit/formatter.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/livetext'
+
+class TestingLivetextFormatter < Minitest::Test
+  def setup
+    @live = Livetext.new
+  end
+
+  def test_formatter_component_initialization
+    # Test that Formatter is properly initialized
+    assert(@live.formatter, "Formatter should be initialized")
+    assert_instance_of(Livetext::Formatter, @live.formatter)
+  end
+
+  def test_basic_formatting
+    # Test basic text formatting
+    assert_equal("<b>bold</b>", @live.formatter.format("*bold"))
+    assert_equal("<i>italic</i>", @live.formatter.format("_italic"))
+    assert_equal("<tt>code</tt>", @live.formatter.format("`code"))
+    assert_equal("<strike>strike</strike>", @live.formatter.format("~strike"))
+  end
+
+  def test_double_markers
+    # Test double markers
+    assert_equal("<b>bold</b>", @live.formatter.format("**bold"))
+    assert_equal("**", @live.formatter.format("**"))  # standalone
+    assert_equal(" ** ", @live.formatter.format(" ** "))  # surrounded by spaces
+  end
+
+  def test_bracketed_markers
+    # Test bracketed markers
+    assert_equal("<b>content</b>", @live.formatter.format("*[content]"))
+    assert_equal("<i>content</i>", @live.formatter.format("_[content]"))
+    assert_equal("<tt>content</tt>", @live.formatter.format("`[content]"))
+    assert_equal("", @live.formatter.format("*[]"))  # empty brackets disappear
+  end
+
+  def test_escaped_markers
+    # Test escaped markers
+    assert_equal("*literal", @live.formatter.format("\\*literal"))
+    assert_equal("_literal", @live.formatter.format("\\_literal"))
+    assert_equal("`literal", @live.formatter.format("\\`literal"))
+    assert_equal("~literal", @live.formatter.format("\\~literal"))
+  end
+
+  def test_format_line
+    # Test format_line method
+    assert_equal("<b>bold</b>", @live.formatter.format_line("*bold\n"))
+    assert_equal("", @live.formatter.format_line(nil))
+    assert_equal("", @live.formatter.format_line(""))
+  end
+
+  def test_format_multiple
+    # Test format_multiple method
+    lines = ["*bold\n", "_italic\n", "`code\n"]
+    expected = ["<b>bold</b>", "<i>italic</i>", "<tt>code</tt>"]
+    assert_equal(expected, @live.formatter.format_multiple(lines))
+  end
+
+  def test_convenience_methods
+    # Test convenience methods
+    assert_equal("<b>text</b>", @live.formatter.bold("text"))
+    assert_equal("<i>text</i>", @live.formatter.italic("text"))
+    assert_equal("<tt>text</tt>", @live.formatter.code("text"))
+    assert_equal("<strike>text</strike>", @live.formatter.strike("text"))
+    assert_equal("<a href='url'>text</a>", @live.formatter.link("text", "url"))
+  end
+
+  def test_escape_html
+    # Test HTML escaping
+    assert_equal("&lt;tag&gt;", @live.formatter.escape_html("<tag>"))
+    assert_equal("&amp;", @live.formatter.escape_html("&"))
+    assert_equal("&quot;text&quot;", @live.formatter.escape_html('"text"'))
+    assert_equal("&#39;text&#39;", @live.formatter.escape_html("'text'"))
+  end
+
+  def test_edge_cases
+    # Test edge cases
+    assert_equal("", @live.formatter.format(nil))
+    assert_equal("", @live.formatter.format(""))
+    assert_equal("plain text", @live.formatter.format("plain text"))
+  end
+end

data/test/unit/formatter_component.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/livetext'
+
+class TestingLivetextFormatter < Minitest::Test
+  def setup
+    @live = Livetext.new
+  end
+
+  def test_formatter_component_initialization
+    # Test that FormatterComponent is properly initialized
+    assert(@live.formatter, "FormatterComponent should be initialized")
+    assert_instance_of(Livetext::Formatter, @live.formatter)
+  end
+
+  def test_basic_formatting
+    # Test basic text formatting
+    assert_equal("<b>bold</b>", @live.formatter.format("*bold"))
+    assert_equal("<i>italic</i>", @live.formatter.format("_italic"))
+    assert_equal("<tt>code</tt>", @live.formatter.format("`code"))
+    assert_equal("<strike>strike</strike>", @live.formatter.format("~strike"))
+  end
+
+  def test_double_markers
+    # Test double markers
+    assert_equal("<b>bold</b>", @live.formatter.format("**bold"))
+    assert_equal("**", @live.formatter.format("**"))  # standalone
+    assert_equal(" ** ", @live.formatter.format(" ** "))  # surrounded by spaces
+  end
+
+  def test_bracketed_markers
+    # Test bracketed markers
+    assert_equal("<b>content</b>", @live.formatter.format("*[content]"))
+    assert_equal("<i>content</i>", @live.formatter.format("_[content]"))
+    assert_equal("<tt>content</tt>", @live.formatter.format("`[content]"))
+    assert_equal("", @live.formatter.format("*[]"))  # empty brackets disappear
+  end
+
+  def test_escaped_markers
+    # Test escaped markers
+    assert_equal("*literal", @live.formatter.format("\\*literal"))
+    assert_equal("_literal", @live.formatter.format("\\_literal"))
+    assert_equal("`literal", @live.formatter.format("\\`literal"))
+    assert_equal("~literal", @live.formatter.format("\\~literal"))
+  end
+
+  def test_format_line
+    # Test format_line method
+    assert_equal("<b>bold</b>", @live.formatter.format_line("*bold\n"))
+    assert_equal("", @live.formatter.format_line(nil))
+    assert_equal("", @live.formatter.format_line(""))
+  end
+
+  def test_format_multiple
+    # Test format_multiple method
+    lines = ["*bold\n", "_italic\n", "`code\n"]
+    expected = ["<b>bold</b>", "<i>italic</i>", "<tt>code</tt>"]
+    assert_equal(expected, @live.formatter.format_multiple(lines))
+  end
+
+  def test_convenience_methods
+    # Test convenience methods
+    assert_equal("<b>text</b>", @live.formatter.bold("text"))
+    assert_equal("<i>text</i>", @live.formatter.italic("text"))
+    assert_equal("<tt>text</tt>", @live.formatter.code("text"))
+    assert_equal("<strike>text</strike>", @live.formatter.strike("text"))
+    assert_equal("<a href='url'>text</a>", @live.formatter.link("text", "url"))
+  end
+
+  def test_escape_html
+    # Test HTML escaping
+    assert_equal("&lt;tag&gt;", @live.formatter.escape_html("<tag>"))
+    assert_equal("&amp;", @live.formatter.escape_html("&"))
+    assert_equal("&quot;text&quot;", @live.formatter.escape_html('"text"'))
+    assert_equal("&#39;text&#39;", @live.formatter.escape_html("'text'"))
+  end
+
+  def test_edge_cases
+    # Test edge cases
+    assert_equal("", @live.formatter.format(nil))
+    assert_equal("", @live.formatter.format(""))
+    assert_equal("plain text", @live.formatter.format("plain text"))
+  end
+end