hoozuki 0.1.0 → 1.0.0

data/spec/hoozuki_spec.rb

@@ -1,24 +1,27 @@
 # frozen_string_literal: true
 
 RSpec.describe Hoozuki do
-  describe '#match?' do
-    subject { described_class.new(pattern).match?(value) }
+  shared_examples 'regex matching behavior' do |mode|
+    subject { described_class.match?(pattern, value, engine: mode) }
 
     context 'with basic concatenation' do
       let(:pattern) { 'abc' }
 
       context 'when text is "abc"' do
         let(:value) { 'abc' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "ab"' do
         let(:value) { 'ab' }
+
         it { is_expected.to be false }
       end
 
       context 'when text is "abcd"' do
         let(:value) { 'abcd' }
+
         it { is_expected.to be false }
       end
     end
@@ -28,16 +31,53 @@ RSpec.describe Hoozuki do
 
       context 'when text is "a"' do
         let(:value) { 'a' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "b"' do
         let(:value) { 'b' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "ab"' do
         let(:value) { 'ab' }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context 'with multiple alternations' do
+      let(:pattern) { 'a|b|c|d' }
+
+      context 'when text is "a"' do
+        let(:value) { 'a' }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when text is "b"' do
+        let(:value) { 'b' }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when text is "c"' do
+        let(:value) { 'c' }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when text is "d"' do
+        let(:value) { 'd' }
+
+        it { is_expected.to be true }
+      end
+
+      context 'when text is "e"' do
+        let(:value) { 'e' }
+
         it { is_expected.to be false }
       end
     end
@@ -48,21 +88,25 @@ RSpec.describe Hoozuki do
 
         context 'when text is "" (empty)' do
           let(:value) { '' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "b"' do
           let(:value) { 'b' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "bbb"' do
           let(:value) { 'bbb' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "c"' do
           let(:value) { 'c' }
+
           it { is_expected.to be false }
         end
       end
@@ -72,16 +116,19 @@ RSpec.describe Hoozuki do
 
         context 'when text is "a"' do
           let(:value) { 'a' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "aaa"' do
           let(:value) { 'aaa' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "" (empty)' do
           let(:value) { '' }
+
           it { is_expected.to be false }
         end
       end
@@ -91,16 +138,19 @@ RSpec.describe Hoozuki do
 
         context 'when text is "" (empty)' do
           let(:value) { '' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "c"' do
           let(:value) { 'c' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "cc"' do
           let(:value) { 'cc' }
+
           it { is_expected.to be false }
         end
       end
@@ -111,16 +161,19 @@ RSpec.describe Hoozuki do
 
       context 'when text is "abcd"' do
         let(:value) { 'abcd' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "ab"' do
         let(:value) { 'ab' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "abc"' do
         let(:value) { 'abc' }
+
         it { is_expected.to be false }
       end
     end
@@ -131,11 +184,13 @@ RSpec.describe Hoozuki do
 
         context 'when text is "a|b*"' do
           let(:value) { 'a|b*' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "ab"' do
           let(:value) { 'ab' }
+
           it { is_expected.to be false }
         end
       end
@@ -145,11 +200,13 @@ RSpec.describe Hoozuki do
 
         context 'when text is "(a+)"' do
           let(:value) { '(a+)' }
+
           it { is_expected.to be true }
         end
 
         context 'when text is "a"' do
           let(:value) { 'a' }
+
           it { is_expected.to be false }
         end
       end
@@ -160,26 +217,31 @@ RSpec.describe Hoozuki do
 
       context 'when text is "a"' do
         let(:value) { 'a' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "bc"' do
         let(:value) { 'bc' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "cde"' do
         let(:value) { 'cde' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "bbbcde"' do
         let(:value) { 'bbbcde' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "bd"' do
         let(:value) { 'bd' }
+
         it { is_expected.to be false }
       end
     end
@@ -189,23 +251,145 @@ RSpec.describe Hoozuki do
 
       context 'when text is "こんやっぴー"' do
         let(:value) { 'こんやっぴー' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "おつやっぴー"' do
         let(:value) { 'おつやっぴー' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "こんおつやっぴー"' do
         let(:value) { 'こんおつやっぴー' }
+
         it { is_expected.to be true }
       end
 
       context 'when text is "こんこんきーつね"' do
         let(:value) { 'こんこんきーつね' }
+
         it { is_expected.to be false }
       end
     end
   end
+
+  describe '#match?' do
+    context 'with :vm mode' do
+      it_behaves_like 'regex matching behavior', :vm
+
+      context 'with VM-specific edge cases' do
+        it 'handles deeply nested structures' do
+          pattern = '((((a))))'
+          expect(described_class.match?(pattern, 'a', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'b', engine: :vm)).to be false
+        end
+
+        it 'handles multiple quantifiers in sequence' do
+          pattern = 'a*b+c?'
+          expect(described_class.match?(pattern, 'bc', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'abc', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'aaabbbbc', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'c', engine: :vm)).to be false
+        end
+
+        it 'handles empty alternations' do
+          pattern = 'a|'
+          expect(described_class.match?(pattern, 'a', engine: :vm)).to be true
+          expect(described_class.match?(pattern, '', engine: :vm)).to be true
+        end
+
+        it 'handles nested groups with quantifiers' do
+          pattern = '(ab)*'
+          expect(described_class.match?(pattern, '', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'ab', engine: :vm)).to be true
+          expect(described_class.match?(pattern, 'abab', engine: :vm)).to be true
+        end
+      end
+    end
+
+    context 'with :dfa mode' do
+      it_behaves_like 'regex matching behavior', :dfa
+
+      context 'with DFA-specific edge cases' do
+        it 'handles deeply nested structures' do
+          pattern = '((((a))))'
+          expect(described_class.match?(pattern, 'a', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'b', engine: :dfa)).to be false
+        end
+
+        it 'handles multiple quantifiers in sequence' do
+          pattern = 'a*b+c?'
+          expect(described_class.match?(pattern, 'bc', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'abc', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'aaabbbbc', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'c', engine: :dfa)).to be false
+        end
+
+        it 'handles empty alternations' do
+          pattern = 'a|'
+          expect(described_class.match?(pattern, 'a', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, '', engine: :dfa)).to be true
+        end
+
+        it 'handles nested groups with quantifiers' do
+          pattern = '(ab)*'
+          expect(described_class.match?(pattern, '', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'ab', engine: :dfa)).to be true
+          expect(described_class.match?(pattern, 'abab', engine: :dfa)).to be true
+        end
+      end
+    end
+
+    context 'with common edge cases' do
+      it 'handles single character patterns for both engines' do
+        [:vm, :dfa].each do |engine|
+          expect(described_class.match?('x', 'x', engine: engine)).to be true
+          expect(described_class.match?('x', 'y', engine: engine)).to be false
+        end
+      end
+
+      it 'handles very long patterns for both engines' do
+        pattern = 'a' * 100
+        input = 'a' * 100
+
+        [:vm, :dfa].each do |engine|
+          expect(described_class.match?(pattern, input, engine: engine)).to be true
+        end
+      end
+
+      it 'handles patterns with all quantifier types for both engines' do
+        pattern = 'a*b+c?d'
+
+        [:vm, :dfa].each do |engine|
+          expect(described_class.match?(pattern, 'bd', engine: engine)).to be true
+          expect(described_class.match?(pattern, 'bcd', engine: engine)).to be true
+          expect(described_class.match?(pattern, 'abcd', engine: engine)).to be true
+          expect(described_class.match?(pattern, 'aaabbbbcd', engine: engine)).to be true
+        end
+      end
+    end
+  end
+
+  describe '#compile' do
+    context 'with :vm engine' do
+      it 'returns instruction array' do
+        result = described_class.compile('a', engine: :vm)
+        expect(result).to be_an(Array)
+        expect(result).to all(be_a(Hoozuki::Instruction::Char).or(be_a(Hoozuki::Instruction::Match)))
+      end
+
+      it 'raises error for unknown engine' do
+        expect { described_class.compile('a', engine: :unknown) }.to raise_error(ArgumentError, 'Unknown engine: unknown')
+      end
+    end
+
+    context 'with :dfa engine' do
+      it 'returns DFA object' do
+        result = described_class.compile('a', engine: :dfa)
+        expect(result).to be_a(Hoozuki::Automaton::DFA)
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hoozuki
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -26,8 +26,14 @@ files:
 - lib/hoozuki.rb
 - lib/hoozuki/automaton.rb
 - lib/hoozuki/automaton/dfa.rb
+- lib/hoozuki/automaton/dfa/builder.rb
 - lib/hoozuki/automaton/nfa.rb
 - lib/hoozuki/automaton/state_id.rb
+- lib/hoozuki/instruction.rb
+- lib/hoozuki/instruction/char.rb
+- lib/hoozuki/instruction/jmp.rb
+- lib/hoozuki/instruction/match.rb
+- lib/hoozuki/instruction/split.rb
 - lib/hoozuki/node.rb
 - lib/hoozuki/node/choice.rb
 - lib/hoozuki/node/concatenation.rb
@@ -35,7 +41,19 @@ files:
 - lib/hoozuki/node/literal.rb
 - lib/hoozuki/node/repetition.rb
 - lib/hoozuki/parser.rb
+- lib/hoozuki/parser.y
 - lib/hoozuki/version.rb
+- lib/hoozuki/vm.rb
+- lib/hoozuki/vm/compiler.rb
+- lib/hoozuki/vm/evaluator.rb
+- spec/hoozuki/automaton/dfa/builder_spec.rb
+- spec/hoozuki/automaton/dfa_spec.rb
+- spec/hoozuki/automaton/nfa_spec.rb
+- spec/hoozuki/instruction_spec.rb
+- spec/hoozuki/node_spec.rb
+- spec/hoozuki/parser_spec.rb
+- spec/hoozuki/vm/compiler_spec.rb
+- spec/hoozuki/vm/evaluator_spec.rb
 - spec/hoozuki_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ydah/hoozuki
@@ -60,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.8.0.dev
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A hobby regex engine written in Ruby.
 test_files: []