livetext 0.9.11 → 0.9.13

data/test/snapshots.rb

@@ -0,0 +1,219 @@
+require 'minitest/autorun'
+
+require_relative '../lib/livetext'
+
+=begin
+Snapshots...
+
+NOTE that the external_files method has been replaced by the Snapshot class.
+
+You can add any ordinary test method above. But so far, most of these tests simply 
+call external_files.
+
+The external_files method works this way: 
+  - If the test (caller) method is test_my_silly_feature, then we will
+    look for a directory called snapshots/my_silly_feature
+  - In here, there must be a source.lt3, expected-output.txt, and expected-error.txt
+  - Technically, any of these can be empty
+  - We run livetext on the source and compare actual vs expected (stdout, stderr)
+  - The "real" output gets checked first
+  - Of course, both must compare correctly for the test to pass
+  - See also: match*
+=end
+
+
+# Just a testing class. Chill.
+
+class TestingLivetext < MiniTest::Test
+
+  class Snapshot
+    SOURCE = "source.lt3"
+    # Will now keep "actual" output in same dir?
+    ACTUAL_OUT, ACTUAL_ERR = "actual-output.txt", "actual-error.txt"
+    EXP_OUT,    EXP_ERR    = "expected-output.txt", "expected-error.txt"
+    MATCH_OUT,  MATCH_ERR  =  "match-output.txt", "match-error.txt"
+
+    def initialize(base, assertion = nil)
+      @assertion = assertion
+      @base = base
+      @errors = false
+      Dir.chdir(base) do
+        @literal_out = File.exist?(EXP_OUT)
+        @literal_err = File.exist?(EXP_ERR)
+        @match_out = File.exist?(MATCH_OUT)
+        @match_err = File.exist?(MATCH_ERR)
+      end
+      bad_files = (@literal_out && @match_out) || (@literal_err && @match_err)
+      raise "Inconsistent structure for #@base" if bad_files
+    end
+
+    def check_matches(actual, control)
+      controls = File.readlines(control).map(&:chomp)
+      lines = File.readlines(actual).map(&:chomp)
+      lines.unshift("DUMMY LINE")   # 1-based index! (for when I'm editing)
+      controls.each do |line|
+        line_num, item = line.split(" ", 2)
+        item = Regexp.new(item[1..-2]) if item[0] == "/"  # Hmm, string can't start with /...
+        line_num = line_num.to_i
+        info = "Expected line #{line_num} of #{actual.inspect} to match #{item.inspect} (was: #{lines[line_num].inspect})"
+        good = item === lines[line_num]
+        @errors = true unless good
+#       assert item === lines[line_num], info   # string or regex
+        @assertion.call item === lines[line_num], info   # string or regex
+      end
+    end
+
+    def sdiff(f1, f2, out)
+      File.open(out, "w") {|file| file.puts "#{'%-60s'% 'EXPECTED'}| #{'%-60s'% 'ACTUAL'}" }
+      system("/usr/bin/sdiff -t -w 121 #{f1} #{f2} >>#{out}")
+    end
+
+    def check_stdout
+      if @literal_out
+        actual, expected = File.read(ACTUAL_OUT), File.read(EXP_OUT)
+        same = actual == expected
+        @errors = true if not same
+        file = "out-sdiff.txt"
+        sdiff(ACTUAL_OUT, EXP_OUT, file)
+#       assert same, "Discrepancy in STDOUT - see #@base/#{file}"
+        @assertion.call same, "Discrepancy in STDOUT - see #@base/#{file}"
+      else
+        check_matches(ACTUAL_OUT, MATCH_OUT)
+      end
+    end
+
+    def check_stderr
+      if @literal_err
+        actual, expected = File.read(ACTUAL_ERR), File.read(EXP_ERR)
+        same = actual == expected
+        @errors = true if not same
+        file = "err-sdiff.txt"
+        sdiff(ACTUAL_ERR, EXP_ERR, file)
+#       assert same, "Discrepancy in STDERR - see #@base/#{file}"
+        @assertion.call same, "Discrepancy in STDERR - see #@base/#{file}"
+      else
+        check_matches(ACTUAL_ERR, MATCH_ERR)
+      end
+    end
+
+    def cleanup
+      return if @errors
+      system("rm -f #{ACTUAL_OUT} #{ACTUAL_ERR} *sdiff.txt")
+    end
+
+    def run
+      @errors = false   # oops, need to reset
+      Dir.chdir(@base) do
+        cmd = "../../../bin/livetext #{SOURCE} >#{ACTUAL_OUT} 2>#{ACTUAL_ERR}"
+        system(cmd)
+        check_stdout
+        check_stderr
+        cleanup
+      end
+    end
+  end
+
+  TTY = File.open("/dev/tty","w")
+
+  cmdline = ARGV.first == "cmdline"
+  if cmdline
+    dir = "../"
+    Dir.chdir `livetext --path`.chomp.chomp
+  else
+    dir = ""
+  end
+
+  Data = "#{dir}test/snapshots"
+  TestLines = []
+  Dir.chdir(Data)
+
+  items = []
+  short_tests = File.open("lines.txt")
+  loop do 
+    4.times { items << short_tests.gets.chomp }
+    # Blank line terminates each "stanza"
+    raise "Oops? #{items.inspect}" unless items.last.empty?
+    TestLines << items
+    break if short_tests.eof?
+  end
+
+  if File.size("subset.txt")  == 0
+    puts "Defining via TestLines"
+    TestLines.each.with_index do |item, num|
+      msg, src, exp, blank = *item
+      define_method("test_formatting_#{num}") do
+        actual = FormatLine.parse!(src)
+        if exp[0] == "/" # regex!
+          exp = Regexp.compile(exp[1..-2])   # skip slashes
+          assert_match(exp, actual, msg)
+        else
+          assert_equal(exp, actual, msg)
+        end
+      end
+    end
+  end
+
+  TestDirs = Dir.entries(".").reject {|fname| ! File.directory?(fname) } - %w[. ..]
+  selected = File.readlines("subset.txt").map(&:chomp)
+  Subset   = selected.empty? ? TestDirs : selected
+
+  Subset.each do |tdir|
+    define_method("test_#{tdir}") do
+      myproc = Proc.new {|bool, info| assert bool, info }
+      this = Snapshot.new(tdir, myproc)
+      this.run
+    end
+  end
+
+  def green(str)
+    "" + str.to_s + ""
+  end
+
+  def red(str)
+    "" + str.to_s + ""
+  end
+
+  def sdiff(which, f1, f2, out, rx)
+    return "\n >>> No match for std#{which}!" if rx
+    File.open(out, "w") {|file| file.puts "#{'%-60s'% 'EXPECTED'}| #{'%-60s'% 'ACTUAL'}" }
+    system("/usr/bin/sdiff -t -w 121 #{f1} #{f2} >>#{out}")
+    return "\n  >>> Unexpected std#{which}! See #{out}"
+  end
+
+  def external_files(base)
+    Dir.chdir(base) do
+      src, out, exp = "source.lt3", "/tmp/#{base}--actual-output.txt", "expected-output.txt"
+      err, erx = "/tmp/#{base}--actual-error.txt", "expected-error.txt"
+     
+      # New features - match out/err by regex
+      expout_regex = "expected-out-line1match.txt"
+      experr_regex = "expected-err-line1match.txt"
+
+      cmd = "livetext #{src} >#{out} 2>#{err}"
+      system(cmd)
+
+      output   = File.read(out)
+      errors   = File.read(err)
+      rx_out = rx_err = nil
+
+      expected = File.exist?(expout_regex) ?  rx_out = /#{Regexp.escape(File.read(expout_regex).chomp)}/ : File.read(exp)
+      errexp   = File.exist?(experr_regex) ?  rx_err = /#{Regexp.escape(File.read(experr_regex).chomp)}/ : File.read(erx)
+
+      out_ok = rx_out ? output =~ rx_out : output == expected
+      err_ok = rx_err ? errors =~ rx_err : errors == errexp
+
+      system("mkdir -p /tmp/#{base}")
+      bad_out = bad_err = nil
+      bad_out = sdiff("out", exp, out, "/tmp/#{base}/exp.out.sdiff", rx_out) unless out_ok
+      bad_err = sdiff("err", erx, err, "/tmp/#{base}/exp.err.sdiff", rx_err) unless err_ok
+
+      assert(err_ok, bad_err)
+      assert(out_ok, bad_out)
+      # only on success
+      system("rm -rf #{out} #{err} /tmp/#{base}") if out_ok && err_ok
+    end
+  end
+
+end
+
+

data/test/testlines.rb

@@ -1,5 +1,5 @@
-require 'livetext'
-require 'formatline'
+require '../lib/livetext'
+require '../lib/formatline'
 
   def red(str)
     "" + str + ""

data/test/unit/all.rb

@@ -0,0 +1,3 @@
+
+require_relative 'standard'
+require_relative 'parser'      # nested

data/test/unit/html.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+
+require '../../lib/livetext'
+
+class TestingLivetext < MiniTest::Test
+  include Livetext::Standard
+  include Livetext::UserAPI
+
+  # Some of these methods being tested "really" belong elsewhere?
+  # Same is probably true of the methods that are testing them.
+
+  def test_wrapped
+    cdata = "nothing much"
+    assert_equal wrapped(cdata, :b),     "<b>#{cdata}</b>"
+    assert_equal wrapped(cdata, :b, :i), "<b><i>#{cdata}</i></b>"
+
+    assert_equal wrapped(cdata, :table, :tr, :td),
+                          "<table><tr><td>#{cdata}</td></tr></table>"
+  end
+
+  def test_wrapped_bang
+    cdata = "nothing much"
+    assert_equal wrapped!(cdata, :td, valign: :top), 
+                     "<td valign='top'>#{cdata}</td>"
+    assert_equal wrapped!(cdata, :img, src: "foo.jpg"),
+                    "<img src='foo.jpg'>#{cdata}</img>"
+    assert_equal wrapped!(cdata, :a, style: 'text-decoration: none', 
+                     href: 'foo.com'),
+                     "<a style='text-decoration: none' href='foo.com'>#{cdata}</a>"
+  end
+
+  def xtest_wrap
+    # bogus!
+    wrap(:ul) { 2.times {|i| _out i } }
+    puts @body
+  end
+
+end

data/test/unit/parse_misc.rb

@@ -0,0 +1,60 @@
+require 'minitest/autorun'
+
+# FIXME delete??
+
+require 'parse_misc'
+
+ParseMisc = ::Livetext::ParseMisc
+
+class TestParseMisc < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_strip_quotes
+    assert_raises(NilValue)         { ParseMisc.new(nil).strip_quotes }
+    assert_raises(NullString)       { ParseMisc.new("").strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%['test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseMisc.new(%[test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%["test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseMisc.new(%[test"]).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%["test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%['test"]).strip_quotes }
+
+    assert ParseMisc.new(%[24601]).strip_quotes  == "24601", "Failure 1"
+    assert ParseMisc.new(%[3.14]).strip_quotes   == "3.14",  "Failure 2"
+    assert ParseMisc.new(%[test]).strip_quotes   == "test",  "Failure 3"
+    assert ParseMisc.new(%['test']).strip_quotes == "test",  "Failure 4"
+    assert ParseMisc.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 ParseMisc.parse_vars(vars), expect
+
+    vars = ["foo2 234", "bar2 456"]     # newline irrelevant
+    expect = [%w[foo2 234], %w[bar2 456]]
+    assert_equal ParseMisc.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 ParseMisc.parse_vars(vars), expect
+
+    # prefix (namespacing)
+    vars = ["alpha 'simple string'", 'beta "another string"']
+    expect = [["this.alpha", "'simple string'"], ["this.beta", '"another string"']]
+    assert_equal ParseMisc.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 ParseMisc.parse_vars(vars, prefix: "this.that"), expect
+
+  end
+
+end

data/test/unit/parse_set.rb

@@ -0,0 +1,157 @@
+
+require 'minitest/autorun'
+
+require_relative '../../lib/parse/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/all.rb

@@ -0,0 +1,3 @@
+
+require_relative '../standard'
+require_relative '../parser'      # nested

data/test/unit/parser/general.rb

@@ -0,0 +1,59 @@
+
+require 'minitest/autorun'
+
+require_relative '../../../lib/parser/general'
+
+ParseMisc = ::Livetext::ParseMisc
+
+class TestParseMisc < MiniTest::Test
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_strip_quotes
+    assert_raises(NilValue)         { ParseMisc.new(nil).strip_quotes }
+    assert_raises(NullString)       { ParseMisc.new("").strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%['test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseMisc.new(%[test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%["test]).strip_quotes }
+#   assert_raises(MismatchedQuotes) { ParseMisc.new(%[test"]).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%["test']).strip_quotes }
+    assert_raises(MismatchedQuotes) { ParseMisc.new(%['test"]).strip_quotes }
+
+    assert ParseMisc.new(%[24601]).strip_quotes  == "24601", "Failure 1"
+    assert ParseMisc.new(%[3.14]).strip_quotes   == "3.14",  "Failure 2"
+    assert ParseMisc.new(%[test]).strip_quotes   == "test",  "Failure 3"
+    assert ParseMisc.new(%['test']).strip_quotes == "test",  "Failure 4"
+    assert ParseMisc.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 ParseMisc.parse_vars(vars), expect
+
+    vars = ["foo2 234", "bar2 456"]     # newline irrelevant
+    expect = [%w[foo2 234], %w[bar2 456]]
+    assert_equal ParseMisc.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 ParseMisc.parse_vars(vars), expect
+
+    # prefix (namespacing)
+    vars = ["alpha 'simple string'", 'beta "another string"']
+    expect = [["this.alpha", "'simple string'"], ["this.beta", '"another string"']]
+    assert_equal ParseMisc.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 ParseMisc.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 '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