Add CharacterClassUnit and use it instead of AlternatesUnit

spec/imbecile/regex/parser_spec.rb

@@ -5,7 +5,8 @@ module Imbecile
       it "parses an empty expression" do
         parser = Parser.new("")
         expect(parser.unit).to be_a Parser::AlternatesUnit
-        expect(parser.unit.alternates.size).to eq 0
+        expect(parser.unit.alternates.size).to eq 1
+        expect(parser.unit.alternates[0].size).to eq 0
       end
 
       it "parses a single character unit expression" do
@@ -163,15 +164,15 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.negate).to be_falsey
-        expect(alt_unit.alternates.size).to eq 2
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterRangeUnit
-        expect(alt_unit.alternates[0].min_code_point).to eq "a".ord
-        expect(alt_unit.alternates[0].max_code_point).to eq "z".ord
-        expect(alt_unit.alternates[1]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[1].code_point).to eq "_".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.negate).to be_falsey
+        expect(ccu.size).to eq 2
+        expect(ccu[0]).to be_a Parser::CharacterRangeUnit
+        expect(ccu[0].min_code_point).to eq "a".ord
+        expect(ccu[0].max_code_point).to eq "z".ord
+        expect(ccu[1]).to be_a Parser::CharacterUnit
+        expect(ccu[1].code_point).to eq "_".ord
       end
 
       it "parses a negated character class" do
@@ -181,12 +182,12 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.negate).to be_truthy
-        expect(alt_unit.alternates.size).to eq 3
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq "x".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.negate).to be_truthy
+        expect(ccu.size).to eq 3
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq "x".ord
       end
 
       it "parses - as a plain character at beginning of a character class" do
@@ -196,11 +197,11 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.alternates.size).to eq 2
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq "-".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.size).to eq 2
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq "-".ord
       end
 
       it "parses - as a plain character at end of a character class" do
@@ -210,13 +211,13 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.alternates.size).to eq 2
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq "0".ord
-        expect(alt_unit.alternates[1]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[1].code_point).to eq "-".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.size).to eq 2
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq "0".ord
+        expect(ccu[1]).to be_a Parser::CharacterUnit
+        expect(ccu[1].code_point).to eq "-".ord
       end
 
       it "parses - as a plain character at beginning of a negated character class" do
@@ -226,12 +227,12 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.negate).to be_truthy
-        expect(alt_unit.alternates.size).to eq 2
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq "-".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.negate).to be_truthy
+        expect(ccu.size).to eq 2
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq "-".ord
       end
 
       it "parses . as a plain character in a negated character class" do
@@ -241,12 +242,12 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.negate).to be_falsey
-        expect(alt_unit.alternates.size).to eq 1
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq ".".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.negate).to be_falsey
+        expect(ccu.size).to eq 1
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq ".".ord
       end
 
       it "parses - as a plain character when escaped in middle of character class" do
@@ -256,16 +257,16 @@ module Imbecile
         expect(parser.unit.alternates[0]).to be_a Parser::SequenceUnit
         seq_unit = parser.unit.alternates[0]
         expect(seq_unit.size).to eq 1
-        expect(seq_unit[0]).to be_a Parser::AlternatesUnit
-        alt_unit = seq_unit[0]
-        expect(alt_unit.negate).to be_falsey
-        expect(alt_unit.alternates.size).to eq 3
-        expect(alt_unit.alternates[0]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[0].code_point).to eq "0".ord
-        expect(alt_unit.alternates[1]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[1].code_point).to eq "-".ord
-        expect(alt_unit.alternates[2]).to be_a Parser::CharacterUnit
-        expect(alt_unit.alternates[2].code_point).to eq "9".ord
+        expect(seq_unit[0]).to be_a Parser::CharacterClassUnit
+        ccu = seq_unit[0]
+        expect(ccu.negate).to be_falsey
+        expect(ccu.size).to eq 3
+        expect(ccu[0]).to be_a Parser::CharacterUnit
+        expect(ccu[0].code_point).to eq "0".ord
+        expect(ccu[1]).to be_a Parser::CharacterUnit
+        expect(ccu[1].code_point).to eq "-".ord
+        expect(ccu[2]).to be_a Parser::CharacterUnit
+        expect(ccu[2].code_point).to eq "9".ord
       end
 
       it "parses alternates" do
@@ -296,10 +297,10 @@ module Imbecile
         expect(parser.unit.alternates[0][0].unit.alternates[1].size).to eq 0
         expect(parser.unit.alternates[1]).to be_a Parser::SequenceUnit
         expect(parser.unit.alternates[1].size).to eq 1
-        expect(parser.unit.alternates[1][0]).to be_a Parser::AlternatesUnit
+        expect(parser.unit.alternates[1][0]).to be_a Parser::CharacterClassUnit
         expect(parser.unit.alternates[1][0].negate).to be_truthy
-        expect(parser.unit.alternates[1][0].alternates.size).to eq 1
-        expect(parser.unit.alternates[1][0].alternates[0]).to be_a Parser::CharacterUnit
+        expect(parser.unit.alternates[1][0].size).to eq 1
+        expect(parser.unit.alternates[1][0][0]).to be_a Parser::CharacterUnit
         expect(parser.unit.alternates[2]).to be_a Parser::SequenceUnit
         expect(parser.unit.alternates[2].size).to eq 2
         expect(parser.unit.alternates[2][0]).to be_a Parser::CharacterUnit
@@ -311,11 +312,11 @@ module Imbecile
         expect(parser.unit.alternates[3][0]).to be_a Parser::MultiplicityUnit
         expect(parser.unit.alternates[3][0].min_count).to eq 1
         expect(parser.unit.alternates[3][0].max_count).to be_nil
-        expect(parser.unit.alternates[3][0].unit).to be_a Parser::AlternatesUnit
-        expect(parser.unit.alternates[3][0].unit.alternates.size).to eq 1
-        expect(parser.unit.alternates[3][0].unit.alternates[0]).to be_a Parser::CharacterRangeUnit
-        expect(parser.unit.alternates[3][0].unit.alternates[0].min_code_point).to eq "x".ord
-        expect(parser.unit.alternates[3][0].unit.alternates[0].max_code_point).to eq "y".ord
+        expect(parser.unit.alternates[3][0].unit).to be_a Parser::CharacterClassUnit
+        expect(parser.unit.alternates[3][0].unit.size).to eq 1
+        expect(parser.unit.alternates[3][0].unit[0]).to be_a Parser::CharacterRangeUnit
+        expect(parser.unit.alternates[3][0].unit[0].min_code_point).to eq "x".ord
+        expect(parser.unit.alternates[3][0].unit[0].max_code_point).to eq "y".ord
       end
 
     end