livetext 0.9.26 → 0.9.27

data/test/unit/new_lineparser.rb

@@ -0,0 +1,359 @@
+require 'minitest/autorun'
+
+require_relative 'lib/livetext'
+
+class TestingLivetext < MiniTest::Test
+
+  LineParser = Livetext::LineParser
+
+  def perform_test(recv, sym, msg, src, exp)
+    actual = recv.send(sym, src)
+    if exp[0] == "/" 
+      exp = Regexp.compile(exp[1..-2])   # skip slashes
+      $testme = false
+      assert_match(exp, actual, msg)
+    else
+      $testme = false
+      assert_equal(exp, actual, msg)
+    end
+  end
+
+  def invoke_test(msg, src, exp)
+    actual = LineParser.parse!(src)
+    if exp[0] == "/" 
+      exp = Regexp.compile(exp[1..-2])   # skip slashes
+      $testme = false
+      assert_match(exp, actual, msg)
+    else
+      $testme = false
+      assert_equal(exp, actual, msg)
+    end
+  end
+
+  # Some (most) methods were generated via the code
+  # seen in the comment at the bottom of this file...
+
+  def test_simple_string
+    parse = LineParser.new("only testing")
+    tokens = parse.parse_variables  # .tokenize
+    assert_equal tokens, [[:str, "only testing"]], "Tokens were: #{tokens.inspect}"
+#   expected = "only testing"
+#   result = parse.evaluate
+#   assert_equal expected, result
+  end
+
+  def test_variable_interpolation
+    $testme = true
+    parse = LineParser.new("File is $File and user is $User")
+    tokens = parse.parse_variables   # tokenize
+    expected_tokens = [[:str, "File is "],
+                       [:var, "File"],
+                       [:str, " and user is "],
+                       [:var, "User"]]
+    assert_equal expected_tokens, tokens
+#   result = parse.evaluate
+#   expected = "File is [File is undefined] and user is Hal"  # FIXME
+#   assert_equal expected, result
+    $testme = false
+  end
+
+  def test_NEW_var_expansion
+    parse = LineParser.new("File is $File and user is $User")
+    expected = "File is [File is undefined] and user is Hal"  # FIXME
+    str = parse.parse_variables
+    assert_equal expected, str
+  end
+
+  def test_func_expansion
+    parse = LineParser.new("myfunc() results in $$myfunc apparently.")
+    tokens = parse.parse_functions  # .tokenize
+    expected_tokens = [[:str, "myfunc() results in "],
+                       [:func, "myfunc", nil, nil],
+                       [:str, " apparently."]]
+    assert_equal expected_tokens, tokens
+#   result = parse.evaluate
+#   expected = "myfunc() results in [Error evaluating $$myfunc()] apparently."
+#   assert_equal expected, result
+  end
+
+# These tests follow this form:
+#
+#  def xtest_func_SUFFIX
+#    str = "WHATEVER"
+#    parse = LineParser.new(str)
+#    tokens_expected = [[], [], ...]
+#    tokens = parse.tokenize
+#    assert_equal tokens_expected, tokens
+#    result = parse.evaluate
+#    regex_expected = /Today is ....-..-../
+#    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+#  end
+
+  def test_func_2
+    str = "Today is $$date"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Today is "], [:func, "date", nil, nil]]
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+    result = parse.evaluate
+    regex_expected = /Today is ....-..-../
+    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_var_before_comma
+    str = "User name is $User, and all is well"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "User name is "], [:var, "User"], [:str, ", and all is well"]]
+    tokens = parse.parse_variables # tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+    result = parse.evaluate
+    regex_expected = /User name is .*, /
+    assert_match regex_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_var_at_EOS
+    str = "File name is $File"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "File name is "], [:var, "File"]]
+    tokens = parse.parse_variables # tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "File name is [File is undefined]"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_var_starts_string
+    str = "$File is my file name"
+    parse = LineParser.new(str)
+    tokens_expected = [[:var, "File"], [:str, " is my file name"]]
+    tokens = parse.parse_variables # tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "[File is undefined] is my file name"
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+# Next one is/will be a problem... 
+# I permit periods *inside* variable names
+
+  def test_var_before_period
+    str = "This is $File\\."      # FIXME escaped for now...
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "This is "], [:var, "File"], [:str, "."]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+    result = parse.evaluate
+    string_expected = "This is [File is undefined]."
+    assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_func_needing_parameter_colon_eos  # colon, param, EOS
+    str = "Square root of 225 is $$isqrt:225"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Square root of 225 is "], [:func, "isqrt", :colon, "225"]]
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens
+#   result = parse.evaluate
+#   string_expected = "Square root of 225 is 15"
+#   assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_func_needing_parameter_colon  # colon, param, more chars
+    str = "Answer is $$isqrt:225 today"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Answer is "], 
+                       [:func, "isqrt", :colon, "225"], 
+                       [:str, " today"]]
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens
+#   result = parse.evaluate
+#   string_expected = "Answer is 15 today"
+#   assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  # isqrt: Not real tests?? 
+
+  def test_isqrt_empty_colon_param
+    str = "Calculate $$isqrt:"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt", :colon, ""]] 
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens
+#   result = parse.evaluate
+#   string_expected = "Calculate [Error evaluating $$isqrt(NO PARAM)]"
+#   assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_isqrt_empty_bracket_param
+    str = "Calculate $$isqrt[]"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt", :brackets, ""]  # , [:colon, ""]
+                      ] 
+    # If param is null, we don't get [:colon, value]!
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens
+#   result = parse.evaluate
+#   string_expected = "Calculate [Error evaluating $$isqrt(NO PARAM)]"
+#   assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+  def test_isqrt_malformed_number
+    str = "Calculate $$isqrt[3a5]"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt", :brackets, "3a5"]
+                      ] 
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens_expected, tokens
+#   result = parse.evaluate
+#   string_expected = "Calculate [Error evaluating $$isqrt(3a5)]"
+#   assert_equal string_expected, result, "Found unexpected: #{result.inspect}"
+  end
+
+# ...end of this group
+
+  def test_func_with_colon
+    parse = LineParser.new("Calling $$myfunc:foo here.")
+    tokens = parse.parse_functions  # tokenize
+    assert_equal tokens, [[:str, "Calling "],
+                          [:func, "myfunc", :colon, "foo"],
+                          [:str, " here."]]
+#   result = parse.evaluate
+#   expected = "Calling [Error evaluating $$myfunc(foo)] here."
+#   assert_equal expected, result
+  end
+
+  def test_func_with_brackets
+    parse = LineParser.new("Calling $$myfunc2[foo bar] here.")
+    tokens = parse.parse_functions  # .tokenize
+    expected_tokens = [[:str, "Calling "],
+                       [:func, "myfunc2", :brackets, "foo bar"],
+                       [:str, " here."]]
+    assert_equal expected_tokens, tokens
+#   result = parse.evaluate
+#   expected = "Calling [Error evaluating $$myfunc2(foo bar)] here."
+#   assert_equal expected, result
+  end
+
+  def test_parse_formatting
+    msg, src, exp = <<~STUFF.split("\n")
+    Check simple formatting
+    This is *bold and _italics ...
+    This is <b>bold</b> and <i>italics</i> ...
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_01   # Check output of $$date
+    msg, src, exp = <<~STUFF.split("\n")
+    Check output of $$date
+    Today is $$date, I guess
+    /Today is \\d\\d\\d\\d-\\d\\d-\\d\\d, I guess/
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_32   # Check "real" dollar signs
+    msg, src, exp = <<~STUFF.split("\n")
+      Check "real" dollar signs
+      You paid $75 for that item.
+      You paid $75 for that item.
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_33   # Check dollar-space
+    msg, src, exp = <<~STUFF.split("\n")
+      Check dollar-space
+      He paid $ 76 for it...
+      He paid $ 76 for it...
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_34   # Check escaped dollar signs
+    msg, src, exp = <<~STUFF.split("\n")
+      Check escaped dollar signs
+      Paid \\$78 yo
+      Paid $78 yo
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_35   # Check ignored function param (bug or feature?)
+    msg, src, exp = <<~STUFF.split("\n")
+      Check ignored function param (bug or feature?)
+      Today is $$date:foobar, apparently.
+      /Today is \\d\\d\\d\\d.\\d\\d.\\d\\d apparently./
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+  def test_formatting_36   # Check ignored function bracket param (bug or feature?)
+    msg, src, exp = <<~STUFF.split("\n")
+      Check ignored function bracket param (bug or feature?)
+      Today is $$date[a useless parameter], apparently.
+      /Today is \\d\\\d\\d\\d.\\d\\d.\\d\\d, apparently./
+    STUFF
+    invoke_test(msg, src, exp)
+  end
+
+end
+
+# Test generation logic:
+
+=begin
+  TestLines = []
+
+  items = []
+  formatting_tests = File.open("test/snapshots/formatting-tests.txt")
+  loop do 
+    4.times { items << formatting_tests.gets.chomp }
+    # Blank line terminates each "stanza"
+    raise "Oops? #{items.inspect}" unless items.last.empty?
+    TestLines << items
+    break if formatting_tests.eof?
+  end
+
+  STDERR.puts <<~RUBY
+    require 'minitest/autorun'
+
+    require_relative '../lib/livetext'
+
+    # Just another testing class. Chill.
+
+    class TestingLivetext < MiniTest::Test
+  RUBY
+
+  TestLines.each.with_index do |item, num|
+    msg, src, exp, blank = *item
+    # generate tests...
+    name = "test_formatting_#{'%02d' % (num + 1)}"
+    method_source = <<~RUBY
+      def #{name}   # #{msg}
+        msg, src, exp = <<~STUFF.split("\\n")
+        #{msg}
+        #{src}
+        #{exp}
+        STUFF
+
+        actual = LineParser.parse!(src)
+        # FIXME could simplify assert logic?
+        if exp[0] == "/" 
+          exp = Regexp.compile(exp[1..-2])   # skip slashes
+          assert_match(exp, actual, msg)
+        else
+          assert_equal(exp, actual, msg)
+        end
+      end
+
+    RUBY
+    STDERR.puts method_source
+  end
+  STDERR.puts "\nend"
+end
+=end

data/test/unit/tokenizer.rb

@@ -91,6 +91,7 @@ class TestingLivetext < MiniTest::Test
 # I permit periods *inside* variable names
 
   def test_tokenizer_var_before_period
+skip
     str = "This is $File\\."      # FIXME escaped for now...
     parse = LineParser.new(str)
     tokens_expected = [[:str, "This is "], [:var, "File"], [:str, "."]]
@@ -503,7 +504,7 @@ class TestingLivetext < MiniTest::Test
     invoke_test(msg, src, exp)
   end
 
-  def test_tokenizer_formatting_34   # Check escaped dollar signs
+  def xtest_tokenizer_formatting_34   # Check escaped dollar signs
     msg, src, exp = <<~STUFF.split("\n")
       Check escaped dollar signs
       Paid \\$78 yo

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: livetext
 version: !ruby/object:Gem::Version
-  version: 0.9.26
+  version: 0.9.27
 platform: ruby
 authors:
 - Hal Fulton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-05 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies: []
 description: A smart text processor extensible in Ruby
 email: rubyhacker@gmail.com
@@ -29,7 +29,6 @@ files:
 - lib/cmdargs.rb
 - lib/livetext.rb
 - lib/livetext/errors.rb
-- lib/livetext/formatline.rb
 - lib/livetext/funcall.rb
 - lib/livetext/functions.rb
 - lib/livetext/global_helpers.rb
@@ -117,6 +116,9 @@ files:
 - test/snapshots/example_alpha2/expected-error.txt
 - test/snapshots/example_alpha2/expected-output.txt
 - test/snapshots/example_alpha2/source.lt3
+- test/snapshots/functions/actual-error.txt
+- test/snapshots/functions/actual-output.txt
+- test/snapshots/functions/err-sdiff.txt
 - test/snapshots/functions/expected-error.txt
 - test/snapshots/functions/expected-output.txt
 - test/snapshots/functions/source.lt3
@@ -139,19 +141,25 @@ files:
 - test/snapshots/mixin_bookish/expected-output.txt
 - test/snapshots/mixin_bookish/source.lt3
 - test/snapshots/mixin_bookish/toc.tmp
+- test/snapshots/more_complex_vars/actual-error.txt
+- test/snapshots/more_complex_vars/actual-output.txt
+- test/snapshots/more_complex_vars/err-sdiff.txt
 - test/snapshots/more_complex_vars/expected-error.txt
 - test/snapshots/more_complex_vars/expected-output.txt
+- test/snapshots/more_complex_vars/out-sdiff.txt
 - test/snapshots/more_complex_vars/source.lt3
 - test/snapshots/more_functions/actual-error.txt
 - test/snapshots/more_functions/actual-output.txt
 - test/snapshots/more_functions/err-sdiff.txt
 - test/snapshots/more_functions/expected-error.txt
 - test/snapshots/more_functions/expected-output.txt
-- test/snapshots/more_functions/out-sdiff.txt
 - test/snapshots/more_functions/source.lt3
 - test/snapshots/predef_vars/expected-error.txt
 - test/snapshots/predef_vars/match-output.txt
 - test/snapshots/predef_vars/source.lt3
+- test/snapshots/raw_lines/actual-error.txt
+- test/snapshots/raw_lines/actual-output.txt
+- test/snapshots/raw_lines/err-sdiff.txt
 - test/snapshots/raw_lines/expected-error.txt
 - test/snapshots/raw_lines/expected-output.txt
 - test/snapshots/raw_lines/source.lt3
@@ -196,11 +204,10 @@ files:
 - test/snapshots/var_into_func/expected-output.txt
 - test/snapshots/var_into_func/out-sdiff.txt
 - test/snapshots/var_into_func/source.lt3
-- test/testlines.rb
 - test/unit/all.rb
-- test/unit/formatline.rb
 - test/unit/html.rb
 - test/unit/lineparser.rb
+- test/unit/new_lineparser.rb
 - test/unit/parser.rb
 - test/unit/parser/all.rb
 - test/unit/parser/general.rb