livetext 0.9.09 → 0.9.14

data/test/unit/parser/general.rb

@@ -0,0 +1,59 @@
+
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/general'
+
+ParseGeneral = ::Livetext::ParseGeneral
+
+class TestParseGeneral < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_strip_quotes
+    assert_raises(NilValue)         { ParseGeneral.new(nil).strip_quotes }
+    assert_raises(NullString)       { ParseGeneral.new("").strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseGeneral.new(%['test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseGeneral.new(%[test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseGeneral.new(%["test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseGeneral.new(%[test"]).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseGeneral.new(%["test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseGeneral.new(%['test"]).strip_quotes }
+
+    assert ParseGeneral.new(%[24601]).strip_quotes  == "24601", "Failure 1"
+    assert ParseGeneral.new(%[3.14]).strip_quotes   == "3.14",  "Failure 2"
+    assert ParseGeneral.new(%[test]).strip_quotes   == "test",  "Failure 3"
+    assert ParseGeneral.new(%['test']).strip_quotes == "test",  "Failure 4"
+    assert ParseGeneral.new(%["test"]).strip_quotes == "test",  "Failure 5"
+  end
+
+  def test_variables
+    vars = ["foo 234\n", "bar 456\n"]
+    expect = [%w[foo 234], %w[bar 456]]
+    assert_equal ParseGeneral.parse_vars(vars), expect
+
+    vars = ["foo2 234", "bar2 456"]     # newline irrelevant
+    expect = [%w[foo2 234], %w[bar2 456]]
+    assert_equal ParseGeneral.parse_vars(vars), expect
+
+    # quotes are not stripped... hmm
+    vars = ["alpha 'simple string'", 'beta "another string"']
+    expect = [["alpha", "'simple string'"], ["beta", '"another string"']]
+    assert_equal ParseGeneral.parse_vars(vars), expect
+
+    # prefix (namespacing)
+    vars = ["alpha 'simple string'", 'beta "another string"']
+    expect = [["this.alpha", "'simple string'"], ["this.beta", '"another string"']]
+    assert_equal ParseGeneral.parse_vars(vars, prefix: "this"), expect
+
+    # prefix (namespacing)
+    vars = ["alpha 'simple string'", 'beta "another string"']
+    expect = [["this.that.alpha", "'simple string'"], ["this.that.beta", '"another string"']]
+    assert_equal ParseGeneral.parse_vars(vars, prefix: "this.that"), expect
+
+  end
+
+end

data/test/unit/parser/importable.rb

@@ -0,0 +1,19 @@
+
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/set'
+
+ParseSet = Livetext::ParseSet
+
+class TestParseSet < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  # FIXME no tests yet
+  # Bad syntax? File not found? not found searching upward?
+
+end

data/test/unit/parser/mixin.rb

@@ -0,0 +1,19 @@
+
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/set'
+
+ParseSet = Livetext::ParseSet
+
+class TestParseSet < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  # FIXME no tests yet
+  # Bad syntax? File not found? not found searching upward?
+
+end

data/test/unit/parser/set.rb

@@ -0,0 +1,157 @@
+
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/set'
+
+ParseSet = Livetext::ParseSet
+
+class TestParseSet < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_one_unquoted
+    set = ParseSet.new('my_var_123 = 789').parse
+    pair = set.first
+    assert_equal pair, %w[my_var_123 789]
+
+    set = ParseSet.new('var_234 = naked_string').parse
+    pair = set.first
+    assert_equal pair, %w[var_234 naked_string]
+  end
+
+  def test_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
+    set = ParseSet.new('fancy.var2 = "another string"').parse
+    pair = set.first
+    assert_equal pair, ["fancy.var2", "another string"]
+  end
+
+  def test_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
+    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
+    set = ParseSet.new('gamma = "oh, well"').parse
+    pair = set.first
+    assert_equal pair, ["gamma", "oh, well"]
+  end
+
+  def test_get_var
+    @parse = ParseSet.new("foo=345")
+    assert_equal @parse.get_var, "foo"
+    @parse = ParseSet.new("foo = 345")
+    assert_equal @parse.get_var, "foo"
+    @parse = ParseSet.new("foo123 = 345")
+    assert_equal @parse.get_var, "foo123"
+    @parse = ParseSet.new("foo_bar = 345")
+    assert_equal @parse.get_var, "foo_bar"
+    @parse = ParseSet.new("Foobar = 345")
+    assert_equal @parse.get_var, "Foobar"
+    @parse = ParseSet.new("_foobar = 345")
+    assert_equal @parse.get_var, "_foobar"
+
+    # will not notice missing equal sign till later parsing
+    @parse = ParseSet.new("foo bar")
+    assert_equal @parse.get_var, "foo"
+
+    # can detect missing equal sign if iteration ends
+    @parse = ParseSet.new("foo")
+    assert_raises(NoEqualSign) { @parse.get_var }
+    @parse = ParseSet.new("foo-bar = 345")
+    assert_raises(BadVariableName) { @parse.get_var }
+  end
+
+  def test_skip_equal
+    @parse = ParseSet.new("=")
+    assert_nil @parse.skip_equal
+    @parse = ParseSet.new("   = ")
+    assert_nil @parse.skip_equal
+    @parse = ParseSet.new("   =")
+    assert_nil @parse.skip_equal
+    @parse = ParseSet.new("   = 345")
+    assert_equal @parse.skip_equal, "3"
+    @parse = ParseSet.new("   = 'meh'")
+    assert_equal @parse.skip_equal, "'"
+
+    @parse = ParseSet.new("no equal here")
+    assert_raises(NoEqualSign) { @parse.skip_equal }
+    @parse = ParseSet.new("")
+    assert_raises(NoEqualSign) { @parse.skip_equal }
+  end
+
+  def test_quoted_value
+    @parse = ParseSet.new(%['this'])
+    assert_equal @parse.quoted_value, "this"
+    @parse = ParseSet.new(%["that"])
+    assert_equal @parse.quoted_value, "that"
+    @parse = ParseSet.new(%[""])
+    assert_equal @parse.quoted_value, ""
+    @parse = ParseSet.new(%[''])
+    assert_equal @parse.quoted_value, ""
+
+    @parse = ParseSet.new(%['foo"])
+    assert_raises(BadQuotedString) { @parse.quoted_value }
+    @parse = ParseSet.new(%["bar'])
+    assert_raises(BadQuotedString) { @parse.quoted_value }
+    @parse = ParseSet.new(%['baz])
+    assert_raises(BadQuotedString) { @parse.quoted_value }
+    @parse = ParseSet.new(%["bam])
+    assert_raises(BadQuotedString) { @parse.quoted_value }
+    # LATER: 
+    #  - allow (escaped?) comma in quoted string
+  end
+
+  def test_unquoted_value
+    # Note: an unquoted value is still a string!
+    @parse = ParseSet.new(%[342 ])
+    assert_equal @parse.unquoted_value, "342"
+    @parse = ParseSet.new(%[343,])
+    assert_equal @parse.unquoted_value, "343"
+    @parse = ParseSet.new(%[344,678])
+    assert_equal @parse.unquoted_value, "344"
+    @parse = ParseSet.new(%[345.123])
+    assert_equal @parse.unquoted_value, "345.123"
+    @parse = ParseSet.new(%[whatever])
+    assert_equal @parse.unquoted_value, "whatever"
+
+    # LATER: 
+    #  - disallow comma in unquoted string
+    #  - disallow quote trailing unquoted string
+    #  - allow/disallow escaping??
+  end
+
+  # BUG: FormatLine doesn't know variables in this context!
+
+  def xtest_4
+    set = ParseSet.new("file = $File").parse
+    assert_equal set.first, "file"
+    assert set.last !~ /undefined/
+  end
+
+  # BUG: ...or functions.
+  # (Additional bug: Failing silently seems wrong.)
+
+  def xtest_5
+    set = ParseSet.new("date = $$date").parse
+    assert_equal set.first, "date"
+    assert set.last =~ /^\d\d.\d\d.\d\d/
+  end
+
+end

data/test/unit/parser/string.rb

@@ -0,0 +1,130 @@
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/string'
+
+class TestStringParser < MiniTest::Test
+
+  def setup
+    # Lengths: zero, one, arbitrary
+    @str0 = ""
+    @str1 = "x"
+    @strN = "This is a test"
+    @zero = StringParser.new(@str0)
+    @one  = StringParser.new(@str1)
+    @many = StringParser.new(@strN)
+  end
+
+  def teardown
+    # Line and length are invariants
+    assert_equal @zero.len, 0
+    assert_equal @one.len,  1
+    assert_equal @many.len, 14
+  end
+
+  def test_init
+    assert_equal @zero.line, ""
+    assert @zero.eos, "EOS was initially false for #{@zero.inspect}"
+    assert_equal @zero.i, 0
+    
+    assert_equal @one.line, "x"
+    refute @one.eos, "EOS was initially true for #{@one.inspect}"
+    assert_equal @one.i, 0
+
+    assert_equal @many.line, "This is a test"
+    refute @many.eos, "EOS was initially true for #{@many.inspect}"
+    assert_equal @many.i, 0
+  end
+
+  def test_next
+    assert_nil @zero.next
+    assert_equal @zero.i, 0      # nothing happens
+    
+    assert_equal @one.next, "x"
+    assert_equal @one.i, 1
+
+    assert_equal @many.next, "T"
+    refute @many.eos, "EOS was true for #{@many.inspect}"
+    assert_equal @many.i, 1
+  end
+
+  def test_eos
+    assert @zero.eos?
+    refute @one.eos?
+    refute @many.eos?
+  end
+
+  def test_next_eos
+    @zero.next
+    assert @zero.eos?
+    
+    @one.next
+    assert @one.eos?
+    @one.next
+    assert @one.eos?
+
+    @many.next
+    refute @many.eos?
+    count = @many.len    # doesn't make sense??
+    count.times { @many.next }
+    assert @many.eos?
+  end
+
+  def test_peek
+    assert_nil @zero.peek
+    assert_equal @one.peek, @str1[0]
+    assert_equal @many.peek, @strN[0]
+  end
+
+  def test_next_peek
+    char1 = @zero.next
+    char2 = @zero.peek
+    assert_nil char1
+    assert_nil char2
+    assert @zero.i == 0
+    assert @zero.last?
+    assert @zero.eos?
+
+    refute @one.last?    # FIXME??
+    char1 = @one.peek
+    refute @one.last?    # FIXME??
+    char2 = @one.next
+    char3 = @one.peek
+    assert char1
+    assert char2 == char1
+    assert char3 == @str1[1]
+    assert @one.i == 1
+    assert @one.last?
+    assert @one.eos?     # FIXME??
+
+    char1 = @many.peek
+    char2 = @many.next
+    char3 = @many.peek
+    assert char1
+    assert char2 == char1
+    assert char3 == @strN[1]
+    assert @many.i == 1
+    refute @many.last?
+    refute @many.eos?
+  end
+
+  def test_skip_spaces
+    none = StringParser.new("abc")
+    char, index = none.peek, none.i
+    none.skip_spaces
+    refute none.peek == " "
+    assert_equal none.peek, char
+    assert_equal none.i, index
+
+    one = StringParser.new(" def")
+    one.skip_spaces
+    refute one.peek == " "
+    assert_equal one.peek, "d"
+    assert_equal one.i, 1
+
+    some = StringParser.new("   xyz")
+    some.skip_spaces
+    refute some.peek == " "
+    assert_equal some.peek, "x"
+    assert_equal some.i, 3
+  end
+end

data/test/unit/parser.rb

@@ -0,0 +1,6 @@
+
+require_relative 'parser/string'
+require_relative 'parser/set'
+require_relative 'parser/general'
+require_relative 'parser/mixin'       # currently empty
+require_relative 'parser/importable'  # currently empty

data/test/unit/standard.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+
+
+require_relative '../../lib/livetext'
+
+class TestingLivetext < MiniTest::Test
+  include Livetext::Standard
+  include Livetext::UserAPI
+
+  # Only method here "really" belongs elsewhere?  FIXME
+
+  def test_onoff
+    refute onoff('off'), "Expected onoff('off') to be false"
+    assert onoff('on'),  "Expected onoff('on') to be true"
+    refute onoff('oFf'), "Expected onoff('oFf') to be false"
+    assert onoff('oN'),  "Expected onoff('oN') to be true"
+    assert onoff(nil),   "Expected onoff(nil) to be true"
+
+    assert_raises(ExpectedOnOff, "Should raise ExpectedOnOff") { onoff("") }
+    assert_raises(ExpectedOnOff, "Should raise ExpectedOnOff") { onoff(345) }
+  end
+
+end

data/test/unit/stringparser.rb

@@ -0,0 +1,140 @@
+require 'minitest/autorun'
+
+require_relative '../../lib/stringparser'
+
+class TestStringParser < MiniTest::Test
+
+  def setup
+    # Lengths: zero, one, arbitrary
+    @str0 = ""
+    @str1 = "x"
+    @strN = "This is a test"
+    @zero = StringParser.new(@str0)
+    @one  = StringParser.new(@str1)
+    @many = StringParser.new(@strN)
+  end
+
+  def teardown
+    # Line and length are invariants
+    assert_equal @zero.len, 0
+    assert_equal @one.len,  1
+    assert_equal @many.len, 14
+  end
+
+  def test_init
+    assert_equal @zero.line, ""
+    assert @zero.eos, "EOS was initially false for #{@zero.inspect}"
+    assert_equal @zero.i, 0
+
+    assert_equal @one.line, "x"
+    refute @one.eos, "EOS was initially true for #{@one.inspect}"
+    assert_equal @one.i, 0
+
+    assert_equal @many.line, "This is a test"
+    refute @many.eos, "EOS was initially true for #{@many.inspect}"
+    assert_equal @many.i, 0
+  end
+
+  def test_next
+    assert_nil @zero.next
+    assert_equal @zero.i, 0      # nothing happens
+
+    assert_equal @one.next, "x"
+    assert_equal @one.i, 1
+
+    assert_equal @many.next, "T"
+    refute @many.eos, "EOS was true for #{@many.inspect}"
+    assert_equal @many.i, 1
+  end
+
+  def test_eos
+    assert @zero.eos?
+    refute @one.eos?
+    refute @many.eos?
+  end
+
+  def test_next_eos
+    @zero.next
+    assert @zero.eos?
+
+    @one.eos?
+    refute @one.eos?
+    @one.next
+    assert @one.eos?
+    @one.next # One beyond the actual end
+    assert @one.eos? # Still the end
+
+    @many.next
+    refute @many.eos?
+    count = @many.len    # doesn't make sense??
+    count.times { @many.next }
+    assert @many.eos?
+  end
+
+  def test_peek
+    assert_nil @zero.peek
+    assert_equal @one.peek, @str1[0]
+    assert_equal @many.peek, @strN[0]
+  end
+
+  def test_next_peek
+    char1 = @zero.next
+    char2 = @zero.peek
+    assert_nil char1
+    assert_nil char2
+    assert @zero.i == 0
+    assert @zero.last?
+    assert @zero.eos?
+
+    refute @one.last?
+    char1 = @one.peek
+    refute @one.last?
+    char2 = @one.next
+    assert @one.last? # One beyond the last
+    char3 = @one.peek
+    assert char1
+    assert char2 == char1
+    assert char3 == @str1[1]
+    assert @one.i == 1
+    assert @one.last?
+    assert @one.eos?
+
+    char1 = @many.peek
+    char2 = @many.next
+    char3 = @many.peek
+    assert char1
+    assert char2 == char1
+    assert char3 == @strN[1]
+    assert @many.i == 1
+    refute @many.last?
+    refute @many.eos?
+  end
+
+  def test_skip_spaces
+    none = StringParser.new("abc")
+    char, index = none.peek, none.i
+    none.skip_spaces
+    refute none.peek == " "
+    assert_equal none.peek, char
+    assert_equal none.i, index
+
+    one = StringParser.new(" def")
+    one.skip_spaces
+    refute one.peek == " "
+    assert_equal one.peek, "d"
+    assert_equal one.i, 1
+
+    some = StringParser.new("   xyz")
+    some.skip_spaces
+    refute some.peek == " "
+    assert_equal some.peek, "x"
+    assert_equal some.i, 3
+  end
+
+  def test_for_parse_set
+    str = StringParser.new('gamma = "oh, well"')
+    count = str.len    # doesn't make sense??
+    count.times { print str.next; }
+
+  end
+end