livetext 0.9.23 → 0.9.26

data/test/unit/parser/set.rb

@@ -13,7 +13,7 @@ class TestParseSet < MiniTest::Test
   def teardown
   end
 
-  def test_one_unquoted
+  def xtest_one_unquoted
     set = ParseSet.new('my_var_123 = 789').parse
     pair = set.first
     assert_equal pair, %w[my_var_123 789]
@@ -23,37 +23,37 @@ class TestParseSet < MiniTest::Test
     assert_equal pair, %w[var_234 naked_string]
   end
 
-  def test_one_single_quoted
+  def xtest_one_single_quoted
     set = ParseSet.new("fancy.var.name = 'simple string'").parse
     pair = set.first
     assert_equal pair, ["fancy.var.name", "simple string"]
   end
 
-  def test_one_double_quoted
+  def xtest_one_double_quoted
     set = ParseSet.new('fancy.var2 = "another string"').parse
     pair = set.first
     assert_equal pair, ["fancy.var2", "another string"]
   end
 
-  def test_multiple_unquoted
+  def xtest_multiple_unquoted
     pair1, pair2 = ParseSet.new("this=345, that=678").parse
     assert_equal pair1, %w[this 345]
     assert_equal pair2, %w[that 678]
   end
 
-  def test_multiple_unquoted_quoted
+  def xtest_multiple_unquoted_quoted
     pair1, pair2 = ParseSet.new('alpha = 567, beta = "oh well"').parse
     assert_equal pair1, %w[alpha 567]
     assert_equal pair2, ["beta", "oh well"]
   end
 
-  def test_quote_embedded_comma
+  def xtest_quote_embedded_comma
     set = ParseSet.new('gamma = "oh, well"').parse
     pair = set.first
     assert_equal pair, ["gamma", "oh, well"]
   end
 
-  def test_get_var
+  def xtest_get_var
     @parse = ParseSet.new("foo=345")
     assert_equal @parse.get_var, "foo"
     @parse = ParseSet.new("foo = 345")
@@ -78,7 +78,7 @@ class TestParseSet < MiniTest::Test
     assert_raises(BadVariableName) { @parse.get_var }
   end
 
-  def test_skip_equal
+  def xtest_skip_equal
     @parse = ParseSet.new("=")
     assert_nil @parse.skip_equal
     @parse = ParseSet.new("   = ")
@@ -96,7 +96,7 @@ class TestParseSet < MiniTest::Test
     assert_raises(NoEqualSign) { @parse.skip_equal }
   end
 
-  def test_quoted_value
+  def xtest_quoted_value
     @parse = ParseSet.new(%['this'])
     assert_equal @parse.quoted_value, "this"
     @parse = ParseSet.new(%["that"])
@@ -118,7 +118,7 @@ class TestParseSet < MiniTest::Test
     #  - allow (escaped?) comma in quoted string
   end
 
-  def test_unquoted_value
+  def xtest_unquoted_value
     # Note: an unquoted value is still a string!
     @parse = ParseSet.new(%[342 ])
     assert_equal @parse.unquoted_value, "342"
@@ -137,7 +137,7 @@ class TestParseSet < MiniTest::Test
     #  - allow/disallow escaping??
   end
 
-  def test_var_eq_var
+  def xtest_var_eq_var
     set = ParseSet.new("file = $File").parse
     set = set.first  # [["var", "value"]]
     assert_equal set.first, "file"
@@ -149,11 +149,12 @@ class TestParseSet < MiniTest::Test
     set = ParseSet.new("date = $$date").parse
     set = set.first  # [["var", "value"]]
     assert_equal set.first, "date"
+p set.last
     assert set.last =~ /undefined/, "Found 'undefined' for variable value"
     # ^ ParseSet isn't smart enough to know about variables/functions
   end
 
-  def test_two_strings
+  def xtest_two_strings
     line = %[bday="May 31", date='5/31']
     set = ParseSet.new(line).parse
     assert set == [["bday", "May 31"], ["date", "5/31"]]

data/test/unit/standard.rb

@@ -4,7 +4,6 @@ require_relative '../../lib/livetext'
 
 class TestingLivetext < MiniTest::Test
   include Livetext::Standard
-  include Livetext::UserAPI
 
   # Only method here "really" belongs elsewhere?  FIXME
 

data/test/unit/tokenizer.rb

@@ -0,0 +1,534 @@
+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
+
+  def test_tokenizer_simple_string
+    parse = LineParser.new("only testing")
+    tokens = parse.tokenize
+    assert_equal tokens, [[:str, "only testing"]], "Tokens were: #{tokens.inspect}"
+  end
+
+  def test_tokenizer_variable_interpolation
+    parse = LineParser.new("File is $File and user is $User")
+    tokens = parse.tokenize
+    expected_tokens = [[:str, "File is "],
+                       [:var, "File"],
+                       [:str, " and user is "],
+                       [:var, "User"]]
+    assert_equal expected_tokens, tokens
+  end
+
+  def test_tokenizer_func_expansion
+    parse = LineParser.new("myfunc() results in $$myfunc apparently.")
+    tokens = parse.tokenize
+    expected_tokens = [[:str, "myfunc() results in "],
+                       [:func, "myfunc"],
+                       [:str, " apparently."]]
+    assert_equal expected_tokens, tokens
+  end
+
+  def test_tokenizer_func_2
+    str = "Today is $$date"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Today is "], [:func, "date"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+  end
+
+  def test_tokenizer_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.tokenize
+    assert_equal tokens_expected, tokens, "Tokens were: #{tokens.inspect}"
+  end
+
+  def test_tokenizer_var_at_EOS
+    str = "File name is $File"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "File name is "], [:var, "File"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+  def test_tokenizer_var_starts_string
+    str = "$File is my file name"
+    parse = LineParser.new(str)
+    tokens_expected = [[:var, "File"], [:str, " is my file name"]]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+# Next one is/will be a problem... 
+# I permit periods *inside* variable names
+
+  def test_tokenizer_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
+  end
+
+  def test_tokenizer_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.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+  def test_tokenizer_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.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+  # isqrt: Not real tests?? 
+
+  def test_tokenizer_isqrt_empty_colon_param
+    str = "Calculate $$isqrt:"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt"]  # , [:colon, ""]
+                      ] 
+    # If param is null, we don't get [:colon, value]!
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+  def test_tokenizer_isqrt_empty_bracket_param
+    str = "Calculate $$isqrt[]"
+    parse = LineParser.new(str)
+    tokens_expected = [[:str, "Calculate "], 
+                       [:func, "isqrt"]  # , [:colon, ""]
+                      ] 
+    # If param is null, we don't get [:colon, value]!
+    # ^ FIXME function should be more like:  [:func, name, param]
+    tokens = parse.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+  def test_tokenizer_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.tokenize
+    assert_equal tokens_expected, tokens
+  end
+
+# ...end of this group
+
+  def test_tokenizer_func_with_colon
+    parse = LineParser.new("Calling $$myfunc:foo here.")
+    tokens = parse.tokenize
+    assert_equal tokens, [[:str, "Calling "],
+                          [:func, "myfunc"],
+                          [:colon, "foo"],
+                          [:str, " here."]
+                        ]
+  end
+
+  def test_tokenizer_func_with_brackets
+    parse = LineParser.new("Calling $$myfunc2[foo bar] here.")
+    tokens = parse.tokenize
+    assert_kind_of Array, tokens
+    assert_equal 4, tokens.size
+    expected_tokens = [[:str, "Calling "],
+                       [:func, "myfunc2"],
+                       [:brackets, "foo bar"],
+                       [:str, " here."]]
+    assert_equal expected_tokens, tokens
+  end
+
+  def test_tokenizer_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_tokenizer_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_tokenizer_formatting_02   # 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_tokenizer_formatting_03   # 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_tokenizer_formatting_04   # 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_tokenizer_formatting_05   # 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_tokenizer_formatting_06   # 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)
+
+    actual = LineParser.parse!(src)
+    if exp[0] == "/" 
+      exp = Regexp.compile(exp[1..-2])   # skip slashes
+      assert_match(exp, actual, msg)
+    else
+      assert_equal(exp, actual, msg)
+    end
+  end
+
+  def test_tokenizer_formatting_07   # 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)
+
+    actual = LineParser.parse!(src)
+    if exp[0] == "/" 
+      exp = Regexp.compile(exp[1..-2])   # skip slashes
+      assert_match(exp, actual, msg)
+    else
+      assert_equal(exp, actual, msg)
+    end
+  end
+
+  def test_tokenizer_formatting_08   # 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_tokenizer_formatting_09   # 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_tokenizer_formatting_10   # 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_tokenizer_formatting_11   # 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_tokenizer_formatting_12   # 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_tokenizer_formatting_13   # 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_tokenizer_formatting_14   # 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_tokenizer_formatting_15   # 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_tokenizer_formatting_16   # 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_tokenizer_formatting_17   # 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_tokenizer_formatting_18   # 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_tokenizer_formatting_19   # 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_tokenizer_formatting_20   # Check output of $$date
+    $testme = true
+    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)
+    $testme = false
+  end
+
+  def test_tokenizer_formatting_21   # 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_tokenizer_formatting_22   # 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_tokenizer_formatting_23   # 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_tokenizer_formatting_24   # 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_tokenizer_formatting_25   # 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_tokenizer_formatting_26   # 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_tokenizer_formatting_27   # 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_tokenizer_formatting_28   # 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_tokenizer_formatting_29   # 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_tokenizer_formatting_30   # 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_tokenizer_formatting_31   # 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_tokenizer_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_tokenizer_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_tokenizer_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_tokenizer_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_tokenizer_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
+