From 9734fa2d530b9496b70a388a117ea57fe5730772 Mon Sep 17 00:00:00 2001
From: Matthew Hall <hallmatthew314@gmail.com>
Date: Sun, 19 Mar 2023 23:02:29 +1300
Subject: Remove old files

---
 spec/__OLD_parcom_spec.cr | 765 ----------------------------------------------
 1 file changed, 765 deletions(-)
 delete mode 100644 spec/__OLD_parcom_spec.cr

(limited to 'spec/__OLD_parcom_spec.cr')

diff --git a/spec/__OLD_parcom_spec.cr b/spec/__OLD_parcom_spec.cr
deleted file mode 100644
index bb9e374..0000000
--- a/spec/__OLD_parcom_spec.cr
+++ /dev/null
@@ -1,765 +0,0 @@
-#require "./spec_helper"
-#
-#require "../src/parcom.cr"
-#
-#include Parcom
-#
-#pending Tokens do
-#  pending ".from_string" do
-#    it "constructs a Tokens(Char) from a String" do
-#      tokens = Tokens.from_string("abcd")
-#      tokens.tokens.should eq("abcd".chars)
-#    end
-#  end
-#
-#  pending "#initialize" do
-#    it "wraps an array with the contents of the given iterable" do
-#      set = Set{'a', 'b', 'c', 'd'}
-#      tokens = Tokens.new(set)
-#      tokens.tokens.should eq(set.to_a)
-#
-#      arr = "abcd".chars
-#      tokens = Tokens.new(arr)
-#      tokens.tokens.should eq(arr)
-#    end
-#  end
-#
-#  context do
-#    tokens_empty = Tokens.new([] of Char)
-#    tokens = Tokens.from_string("abcd")
-#
-#    pending "#[]" do
-#      it "returns the token at the given index" do
-#        tokens[2].should eq('c')
-#        expect_raises(IndexError) { tokens_empty[2] }
-#      end
-#
-#      it "returns a new Tokens similar to Array#[](Int, Int)" do
-#        tokens[1, 5].should eq(Tokens.new(['b', 'c', 'd']))
-#        expect_raises(IndexError) { tokens_empty[1, 5] }
-#      end
-#
-#      it "returns a new Tokens similar to Array#[](Range)" do
-#        tokens[1..3].should eq(Tokens.new(['b', 'c', 'd']))
-#        expect_raises(IndexError) { tokens_empty[1..3] }
-#      end
-#    end
-#
-#    pending "#[]?" do
-#      it "analogous to `Array#[]?`" do
-#        # we should only need to check the nil-returning cases
-#        tokens_empty[2]?.should be_nil
-#        tokens_empty[1, 5]?.should be_nil
-#        tokens_empty[1..3]?.should be_nil
-#      end
-#    end
-#
-#    pending "#empty?" do
-#      it "exposes the `#empty?` method of the wrapped array" do
-#        tokens.empty?.should be_false
-#        tokens_empty.empty?.should be_true
-#      end
-#    end
-#  end
-#end
-#
-#pending Result do
-#  pending "#initialize" do
-#    it "sets values for #tokens and #value" do
-#      tokens = Tokens.from_string("esting")
-#      value  = 't'
-#      result = Result(Char, Char).new(tokens, value)
-#
-#      result.tokens.should eq(tokens)
-#      result.value.should eq(value)
-#    end
-#  end
-#end
-#
-#pending Parser do
-#  p = AnyToken(Char).new
-#
-#  pending "#parse?" do
-#    it "returns `nil` if the parser fails" do
-#      result = p.parse?(Tokens.new([] of Char))
-#
-#      result.should be_nil
-#    end
-#
-#    it "returns a `Result(T, V)` if the parser succeeds" do
-#      tokens = Tokens.from_string("testing")
-#      result = p.parse(tokens)
-#
-#      result.should be_a(Result(Char, Char))
-#    end
-#  end
-#end
-#
-#pending Flunk do
-#  pending "#parse" do
-#    it "always fails" do
-#      tokens = Tokens.from_string("testing")
-#
-#      expect_raises(ParserFail) { Flunk(Char, Char).new.parse(tokens) }
-#    end
-#  end
-#end
-#
-#pending AnyToken do
-#  context do
-#    p = AnyToken(Char).new
-#
-#    pending "#parse" do
-#      it "succeeds when input is non-empty" do
-#        tokens = Tokens.from_string("testing")
-#        result = p.parse(tokens)
-#
-#        result.tokens.should eq(tokens[1..])
-#        result.value.should eq('t')
-#      end
-#
-#      it "fails when input is empty" do
-#        expect_raises(ParserFail) { p.parse(Tokens.new([] of Char)) }
-#      end
-#    end
-#  end
-#end
-#
-#pending EOF do
-#  p = EOF(Char).new
-#
-#  pending "#parse" do
-#    it "succeeds when input is empty" do
-#      result = p.parse(Tokens.new([] of Char))
-#
-#      result.tokens.empty?.should be_true
-#      result.value.should be_nil
-#    end
-#
-#    it "fails when input is non-empty" do
-#      tokens = Tokens.from_string("testing")
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#  end
-#end
-#
-#pending Peek do
-#  tokens = Tokens.from_string("testing")
-#  p = AnyToken(Char).new
-#  result_normal = p.parse(tokens)
-#  result_peek = Peek.new(p).parse(tokens)
-#
-#  pending "#parse" do
-#    it "does not modify the result of the wrapped parser" do
-#      result_peek.value.should eq(result_normal.value)
-#    end
-#
-#    it "does not consume any input" do
-#      result_peek.tokens.should eq(tokens)
-#    end
-#  end
-#end
-#
-#pending Assert do
-#  test_f = ->(x : Char) { x == 't' }
-#  p = AnyToken(Char).new.assert { |x| x == 't' }
-#
-#  pending "#parse" do
-#    it "fails if the wrapped parser fails" do
-#      expect_raises(ParserFail) do
-#        p.parse(Tokens.new([] of Char))
-#      end
-#    end
-#
-#    it "fails if the result value fails the test" do
-#      tokens = Tokens.from_string("_testing")
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if the wrapped parser succeeds and the test passes" do
-#      tokens = Tokens.from_string("testing")
-#      expected_char = tokens[0]
-#      result = p.parse(tokens)
-#
-#      result.value.should eq(expected_char)
-#      test_f.call(expected_char).should be_true 
-#    end
-#  end
-#end
-#
-#pending Satisfy do
-#  p = Satisfy(Char).new { |x| x == 't' }
-#
-#  pending "#parse" do
-#    it "fails if the input is empty" do
-#      expect_raises(ParserFail) { p.parse(Tokens.new([] of Char)) }
-#    end
-#
-#    it "fails if the token fails the test" do
-#      tokens = Tokens.from_string("_testing")
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if the token passes the test" do
-#      tokens = Tokens.from_string("testing")
-#      expected_char = tokens[0]
-#      result = p.parse(tokens)
-#
-#      result.value.should eq(expected_char)
-#    end
-#  end
-#end
-#
-#pending Token do
-#  tokens = Tokens.from_string("testing")
-#
-#  pending "#parse" do
-#    it "fails if the input is empty" do
-#      p = Token(Char).new('t')
-#
-#      expect_raises(ParserFail) { p.parse(Tokens.new([] of Char)) }
-#    end
-#
-#    it "fails if the token is not the expected token" do
-#      p = Token(Char).new('#')
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if the token is the expected token" do
-#      expected_char = tokens[0]
-#      p = Token(Char).new(expected_char)
-#      result = p.parse(tokens)
-#
-#      result.value.should eq(expected_char)
-#    end
-#  end
-#end
-#
-#pending Map do
-#  pending "#parse" do
-#    it "fails if the wrapped parser fails" do
-#      p = AnyToken(Char).new.map { |x| x }
-#
-#      expect_raises(ParserFail) { p.parse(Tokens.new([] of Char)) }
-#    end
-#
-#    it "changes the result value via the provided proc" do
-#      p = AnyToken(Char).new.map { |x| x.letter? }
-#
-#      result = p.parse(Tokens.from_string("testing"))
-#      result.value.should be_true
-#
-#      result = p.parse(Tokens.from_string("_testing"))
-#      result.value.should be_false
-#    end
-#  end
-#end
-#
-#pending Plus do
-#  pending "#parse" do
-#    tokens = Tokens.from_string("testing")
-#    p_t = Token(Char).new('t')
-#    p_e = Token(Char).new('e')
-#    p_at = Token(Char).new('@')
-#
-#    it "fails if the first parser fails" do
-#      p = p_at + p_e
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "fails if the second parser fails" do
-#      p = p_t + p_at
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "fails if both parsers fail" do
-#      p = p_at + p_at
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if both parsers succeed" do
-#      p = p_t + p_e
-#      result = p.parse(tokens)
-#
-#      result.tokens.should eq(tokens[2..])
-#      result.value[0].should eq('t')
-#      result.value[1].should eq('e')
-#    end
-#
-#    it "evaluates parsers from left to right (left associative)" do
-#      p_succeeds = p_t + p_e
-#      p_fails = p_e + p_t
-#
-#      p_succeeds.parse(tokens) # should not raise an exception
-#      expect_raises(ParserFail) { p_fails.parse(tokens) }
-#
-#      p_s = Token(Char).new('s')
-#
-#      r = (p_t + p_e + p_s).parse(tokens) # should not raise an exception
-#      r.value.should be_a({ {Char, Char}, Char})
-#
-#      r = (p_t + (p_e + p_s)).parse(tokens) # should not raise an exception
-#      r.value.should be_a({Char, {Char, Char} })
-#    end
-#  end
-#end
-#
-## most behavior shouldn't need to be tested
-## since it is based on tested bbehavior from
-## Plus and Map
-#pending Left do
-#  pending "#parse" do
-#    it "returns the value of the first parser if both succeed" do
-#      tokens = Tokens.from_string("testing")
-#      letter_t = Token.new('t')
-#      letter_e = Token.new('e')
-#      result = (letter_t << letter_e).parse(tokens)
-#
-#      result.value.should eq('t')
-#      result.tokens.should eq(tokens[2..])
-#    end
-#  end
-#end
-#
-## same deal as Left
-#pending Right do
-#  pending "#parse" do
-#    it "returns the value of the second parser if both succeed" do
-#      tokens = Tokens.from_string("testing")
-#      letter_t = Token.new('t')
-#      letter_e = Token.new('e')
-#      result = (letter_t >> letter_e).parse(tokens)
-#
-#      result.value.should eq('e')
-#      result.tokens.should eq(tokens[2..])
-#    end
-#  end
-#end
-#
-#pending Phrase do
-#  p = Phrase.new(Token.new('t'))
-#
-#  pending "#parse" do
-#    it "fails if the wrapped parser fails" do
-#      tokens = Tokens.from_string("_")
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "fails if not all of the input tokens are parsed" do
-#      tokens = Tokens.from_string("tt")
-#
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if the wrapped parser successfully parses all of the input" do
-#      tokens = Tokens.from_string("t")
-#      result = p.parse(tokens)
-#
-#      result.tokens.empty?.should be_true
-#      result.value.should eq('t')
-#    end
-#  end
-#end
-#
-#pending Recover do
-#  p = Token.new('t').recover('@')
-#
-#  pending "#parse" do
-#    it "succeeds and returns the wrapped parser's value if it succeeds" do
-#      tokens = Tokens.from_string("testing")
-#      result = p.parse(tokens)
-#
-#      result.tokens.should eq(tokens[1..])
-#      result.value.should eq('t')
-#    end
-#
-#    it "succeeds and returns the default value without modifying the input if the wrapped parser fails" do
-#      tokens = Tokens.from_string("_____")
-#      result = p.parse(tokens)
-#
-#      result.tokens.should eq(tokens)
-#      result.value.should eq('@')
-#    end
-#  end
-#end
-#
-#pending Optional do
-#  p = Optional.new(Token.new('t'))
-#
-#  pending "#parse" do
-#    it "succeeds and returns the wrapped parser's value if it succeeds" do
-#      tokens = Tokens.from_string("testing")
-#      result = p.parse(tokens)
-#
-#      result.tokens.should eq(tokens[1..])
-#      result.value.should eq('t')
-#    end
-#
-#    it "succeeds and returns a value of `nil` without modifying the input if the wrapped parser fails" do
-#      tokens = Tokens.from_string("_____")
-#      result = p.parse(tokens)
-#
-#      result.tokens.should eq(tokens)
-#      result.value.should be_nil
-#    end
-#  end
-#end
-#
-#pending Sequence do
-#  # HACK: ps has to be declared this way due to contravariance
-#  # https://crystal-lang.org/reference/1.7/syntax_and_semantics/inheritance.html#covariance-and-contravariance
-#  ps = [] of Parser(Char, Char)
-#  ps = ps + "abcd".chars.map { |c| Token.new(c) }
-#  p = Sequence.new(ps)
-#
-#  pending "#parse" do
-#    it "runs each wrapped parser in order, returns each result" do
-#      tokens = Tokens.from_string("abcd")
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("abcd".chars)
-#      result.tokens.empty?.should be_true
-#    end
-#
-#    it "fails if any of the wrapped parsers fail" do
-#      fail_strings = ["", "abed", "bbcd", "abce"]
-#      fail_strings.each do |s|
-#        tokens = Tokens.from_string(s)
-#        expect_raises(ParserFail) { p.parse(tokens) }
-#      end
-#    end
-#
-#    it "succeeds and returns empty array if parser iterable is empty" do
-#      tokens = Tokens.from_string("abcd")
-#      empty_p = Sequence.new([] of Parser(Char, Char))
-#      result = empty_p.parse(tokens)
-#
-#      result.value.empty?.should be_true
-#      result.tokens.should eq(tokens)
-#    end
-#  end
-#end
-#
-#pending TokenSeq do
-#  p = TokenSeq.new("test".chars)
-#
-#  pending "#parse" do
-#    it "fails if the input stream is too short" do
-#      input = Tokens.from_string("")
-#      expect_raises(ParserFail) { p.parse(input) }
-#    end
-#
-#    it "fails if it encounters an unexpected token" do
-#      input = Tokens.from_string("text")
-#      expect_raises(ParserFail) { p.parse(input) }
-#    end
-#
-#    it "succeeds if the input starts with the expected tokens" do
-#      input = Tokens.from_string("testing")
-#      result = p.parse(input)
-#
-#      result.tokens.should eq(input[4..])
-#      result.value.should eq("test".chars)
-#    end
-#  end
-#end
-#
-#pending Many do
-#  p = Many.new(Token.new('a'))
-#
-#  pending "#parse" do
-#    it "returns an empty array if the wrapped parser never succeeds" do
-#      tokens = Tokens.from_string("bb")
-#      result = p.parse(tokens)
-#
-#      result.value.empty?.should be_true
-#      result.tokens.should eq(tokens)
-#    end
-#
-#    it "stops parsing when the wrapped parser fails, returns all successes" do
-#      tokens = Tokens.from_string("aaabcd")
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#
-#      tokens = Tokens.from_string("aaa")
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#    end
-#
-#    it "stops parsing when the wapped parser succeeds without consuming any input" do
-#      a_optional : Parser(Char, Char?)
-#      a_optional = Optional.new(Token.new('a'))
-#      tokens = Tokens.from_string("aaa")
-#      result = Many(Char, Char?).new(a_optional).parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#    end
-#  end
-#end
-#
-#pending Some do
-#  p = Some.new(Token.new('a'))
-#  pending "#parse" do
-#    it "fails if the wrapped parser never succeeds" do
-#      tokens = Tokens.from_string("")
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "stops parsing when the wrapped parser fails, returns all successes" do
-#      tokens = Tokens.from_string("aaabcd")
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#
-#      tokens = Tokens.from_string("aaa")
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#    end
-#  end
-#end
-#
-#pending Exactly do
-#  letter_a = Token.new('a')
-#  tokens = Tokens.from_string("aaabcd")
-#
-#  pending "#parse" do
-#    it "tries to parse exactly n of the wrapper parser" do
-#      p = Exactly.new(3, letter_a)
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(tokens[3..])
-#    end
-#
-#    it "always succeeds with an empty array if n < 1" do
-#      p = Exactly.new(0, letter_a)
-#      result = p.parse(tokens)
-#
-#      result.value.empty?.should be_true
-#      result.tokens.should eq(tokens)
-#
-#      p = Exactly.new(-42, letter_a)
-#      result = p.parse(tokens)
-#
-#      result.value.empty?.should be_true
-#      result.tokens.should eq(tokens)
-#    end
-#
-#    it "does not take extra matching tokens" do
-#      p = Exactly.new(2, letter_a)
-#      result = p.parse(tokens)
-#
-#      result.value.should eq("aa".chars)
-#      result.tokens.should eq(tokens[2..])
-#    end
-#
-#    it "fails if there are not enough matching tokens" do
-#      p = Exactly.new(60, letter_a)
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#  end
-#end
-#
-#pending AtLeast do
-#  letter_a = Token.new('a')
-#  tokens = Tokens.from_string("aaaabcd")
-#
-#  pending "#parse" do
-#    it "fails if there are not enough matching tokens to parse" do
-#      p = AtLeast.new(5, letter_a)
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#      #expect_raises(ParserFail) { raise ParserFail.new("sdgseg") }
-#    end
-#
-#    it "parses n or more times with the given parser" do
-#      p0 = AtLeast.new(0, letter_a)
-#      p2 = AtLeast.new(2, letter_a)
-#      p4 = AtLeast.new(4, letter_a)
-#
-#      result0 = p0.parse(tokens)
-#      result2 = p2.parse(tokens)
-#      result4 = p4.parse(tokens)
-#
-#      result0.value.should eq("aaaa".chars)
-#      result0.tokens.should eq(tokens[4..])
-#
-#      result2.should eq(result0)
-#      result4.should eq(result0)
-#    end
-#  end
-#end
-#
-#pending AtMost do
-#  letter_a = Token.new('a')
-#  tokens = Tokens.from_string("aaaabcd")
-#
-#  pending "#parse" do
-#    it "does not parse more than n times" do
-#      p0 = AtMost.new(0, letter_a)
-#      p2 = AtMost.new(2, letter_a)
-#      p6 = AtMost.new(6, letter_a)
-#
-#      r0 = p0.parse(tokens)
-#      r0.value.empty?.should be_true
-#      r0.tokens.should eq(tokens)
-#
-#      r2 = p2.parse(tokens)
-#      r2.value.should eq("aa".chars)
-#      r2.tokens.should eq(tokens[2..])
-#
-#      r6 = p6.parse(tokens)
-#      r6.value.should eq("aaaa".chars)
-#      r6.tokens.should eq(tokens[4..])
-#    end
-#  end
-#end
-#
-#pending Between do
-#  letter_a = Token.new('a')
-#  tokens = Tokens.from_string("aaaabcd")
-#
-#  pending "#parse" do
-#    it "parses at least i times, up to a limit of j times" do
-#      p0_4 = Between.new(0, 4, letter_a)
-#      r0_4 = p0_4.parse(tokens)
-#
-#      r0_4.value.should eq("aaaa".chars)
-#      r0_4.tokens.should eq(tokens[4..])
-#    end
-#
-#    it "fails if there are not enough parser successes" do
-#      p = Between.new(5, 6, letter_a)
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#  end
-#end
-#
-#pending FirstOf do
-#  tokens = Tokens.from_string("abcd")
-#  letter_a = Token.new('a')
-#  f = Flunk(Char, Char).new
-#
-#  pending "#parse" do
-#    it "cannot be instantiated with an empty Enumerable" do
-#      expect_raises(ArgumentError) { FirstOf.new([] of Parser(Char, Char)) }
-#    end
-#
-#    it "uses the result of the first successful parser" do
-#      a1 = [letter_a, f, f, f] of Parser(Char, Char)
-#      a2 = [f, letter_a, f, f] of Parser(Char, Char)
-#      a3 = [f, f, letter_a, f] of Parser(Char, Char)
-#      a4 = [f, f, f, letter_a] of Parser(Char, Char)
-#
-#      [a1, a2, a3, a4].each do |arr|
-#        p = FirstOf.new(arr)
-#        r = p.parse(tokens)
-#        r.value.should eq('a')
-#        r.tokens.should eq(tokens[1..])
-#      end
-#    end
-#
-#    it "only fails if no parsers are successful" do
-#      x = Token.new('x')
-#      y = Token.new('x')
-#      z = Token.new('x')
-#      p = FirstOf.new([x, y, z] of Parser(Char, Char))
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#  end
-#end
-#
-#pending SepBy do
-#  pending "#parse" do
-#    letter_a = Token.new('a')
-#    comma = Token.new(',')
-#    tokens = Tokens.from_string("a,a,a,a")
-#
-#    it "fails if no elements can be parsed" do
-#      p = SepBy(Char, Char, Char).new(comma, comma)
-#      expect_raises(ParserFail) { p.parse(tokens) }
-#    end
-#
-#    it "succeeds if only one element can be parsed" do
-#      t1 = Tokens.from_string("a")
-#      t2 = Tokens.from_string("a,")
-#      p = SepBy(Char, Char, Char).new(letter_a, comma)
-#
-#      result = p.parse(t1)
-#      result.value.should eq(['a'])
-#      result.tokens.should eq(t1[1..])
-#
-#      result = p.parse(t2)
-#      result.value.should eq(['a'])
-#      result.tokens.should eq(t2[1..])
-#    end
-#
-#    it "parses 1 element, then 0 or more (sep >> element)" do
-#      p = SepBy(Char, Char, Char).new(letter_a, comma)
-#
-#      result = p.parse(tokens)
-#      result.value.should eq("aaaa".chars)
-#      result.tokens.empty?.should be_true
-#
-#      # drop last char in tokens, should parse three elements
-#      result = p.parse(tokens[..5])
-#      result.value.should eq("aaa".chars)
-#      result.tokens.should eq(Tokens.from_string(","))
-#    end
-#  end
-#end
-#
-#pending "Practical use" do
-#  pending "Use case: text surrounded by whitespace" do
-#    space = Satisfy(Char).new { |c| c.whitespace? }
-#    non_space = Satisfy(Char).new { |c| !c.whitespace? }
-#
-#    # TODO: Figure out why mapping on this parser breaks
-#    # initialization of `body`.
-#    word_chars = Some.new(non_space)
-#    ws = Some.new(space)
-#
-#    bookend = Optional.new(ws)
-#    body = SepBy.new(word_chars, ws)
-#    tokenizer = (bookend >> body << bookend).map do |arrs|
-#      arrs.map { |chars| chars.join }
-#    end
-#
-#    good_strings = [
-#      "test with no trailing whitespace",
-#      "  test with whitespace in the front",
-#      "test with whitespace in the back",
-#      "  test surrounded by whitespace     ",
-#    ]
-#
-#    good_strings.each do |s|
-#      tokens = Tokens.from_string(s)
-#      result = tokenizer.parse(tokens)
-#      result.value.should eq(s.strip.split(/\s+/))
-#      result.tokens.empty?.should be_true
-#    end
-#
-#    bad_strings = [
-#      "",
-#      "            ",
-#    ]
-#
-#    bad_strings.each do |s|
-#      tokens = Tokens.from_string(s)
-#      expect_raises(ParserFail) { tokenizer.parse(tokens) }
-#    end
-#  end
-#end
-#
-- 
cgit v1.2.1