hoozuki 0.1.0 → 1.0.0

data/spec/hoozuki/automaton/nfa_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki::Automaton::NFA do
+  describe '.from_node' do
+    let(:state) { Hoozuki::Automaton::StateID.new(0) }
+
+    context 'with nil node' do
+      it 'raises ArgumentError' do
+        expect { described_class.from_node(nil, state) }.to raise_error(ArgumentError, 'Node cannot be nil')
+      end
+    end
+
+    context 'with Literal node' do
+      it 'creates NFA from literal node' do
+        node = Hoozuki::Node::Literal.new('a')
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.start).to be_a(Hoozuki::Automaton::StateID)
+        expect(nfa.accept).to be_an(Array)
+        expect(nfa.accept.length).to eq(1)
+        expect(nfa.transitions.size).to eq(1)
+      end
+    end
+
+    context 'with Epsilon node' do
+      it 'creates NFA from epsilon node' do
+        node = Hoozuki::Node::Epsilon.new
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(1)
+        expect(nfa.transitions.size).to eq(1)
+        expect(nfa.transitions.first[1]).to be_nil
+      end
+    end
+
+    context 'with Concatenation node' do
+      it 'creates NFA from concatenation node' do
+        node = Hoozuki::Node::Concatenation.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(1)
+      end
+    end
+
+    context 'with Choice node' do
+      it 'creates NFA from choice node' do
+        node = Hoozuki::Node::Choice.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(2)
+      end
+    end
+
+    context 'with Repetition node' do
+      it 'creates NFA from zero-or-more repetition' do
+        node = Hoozuki::Node::Repetition.new(
+          Hoozuki::Node::Literal.new('a'),
+          :zero_or_more
+        )
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(2)
+      end
+
+      it 'creates NFA from one-or-more repetition' do
+        node = Hoozuki::Node::Repetition.new(
+          Hoozuki::Node::Literal.new('a'),
+          :one_or_more
+        )
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(1)
+      end
+
+      it 'creates NFA from optional repetition' do
+        node = Hoozuki::Node::Repetition.new(
+          Hoozuki::Node::Literal.new('a'),
+          :optional
+        )
+        nfa = described_class.from_node(node, state)
+
+        expect(nfa).to be_a(described_class)
+        expect(nfa.accept.length).to eq(2)
+      end
+    end
+
+    context 'with complex node' do
+      it 'delegates to node.to_nfa' do
+        node = Hoozuki::Node::Literal.new('x')
+        expect(node).to receive(:to_nfa).with(state).and_call_original
+
+        described_class.from_node(node, state)
+      end
+    end
+  end
+
+  describe '#epsilon_closure' do
+    it 'returns set containing start state with no epsilon transitions' do
+      nfa = described_class.new(0, [1])
+      nfa.add_transition(0, 'a', 1)
+
+      closure = nfa.epsilon_closure(Set.new([0]))
+      expect(closure).to include(0)
+    end
+
+    it 'follows epsilon transitions' do
+      nfa = described_class.new(0, [2])
+      nfa.add_epsilon_transition(0, 1)
+      nfa.add_epsilon_transition(1, 2)
+
+      closure = nfa.epsilon_closure(Set.new([0]))
+      expect(closure).to include(0, 1, 2)
+    end
+
+    it 'handles multiple starting states' do
+      nfa = described_class.new(0, [2])
+      nfa.add_epsilon_transition(0, 1)
+      nfa.add_epsilon_transition(2, 3)
+
+      closure = nfa.epsilon_closure(Set.new([0, 2]))
+      expect(closure).to include(0, 1, 2, 3)
+    end
+  end
+
+  describe '#add_transition' do
+    it 'adds a labeled transition' do
+      nfa = described_class.new(0, [1])
+      nfa.add_transition(0, 'a', 1)
+
+      expect(nfa.transitions).to include([0, 'a', 1])
+    end
+  end
+
+  describe '#add_epsilon_transition' do
+    it 'adds an epsilon transition' do
+      nfa = described_class.new(0, [1])
+      nfa.add_epsilon_transition(0, 1)
+
+      expect(nfa.transitions).to include([0, nil, 1])
+    end
+  end
+
+  describe '#merge_transitions' do
+    it 'merges transitions from another NFA' do
+      nfa1 = described_class.new(0, [1])
+      nfa1.add_transition(0, 'a', 1)
+
+      nfa2 = described_class.new(2, [3])
+      nfa2.add_transition(2, 'b', 3)
+
+      nfa1.merge_transitions(nfa2)
+
+      expect(nfa1.transitions).to include([0, 'a', 1], [2, 'b', 3])
+    end
+  end
+end

data/spec/hoozuki/instruction_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki::Instruction do
+  describe Hoozuki::Instruction::Char do
+    describe '#initialize' do
+      it 'sets the character' do
+        instruction = described_class.new('a')
+        expect(instruction.char).to eq('a')
+      end
+
+      it 'handles multibyte characters' do
+        instruction = described_class.new('あ')
+        expect(instruction.char).to eq('あ')
+      end
+    end
+
+    describe '#char=' do
+      it 'allows updating the character' do
+        instruction = described_class.new('a')
+        instruction.char = 'b'
+        expect(instruction.char).to eq('b')
+      end
+    end
+  end
+
+  describe Hoozuki::Instruction::Jmp do
+    describe '#initialize' do
+      it 'sets the target' do
+        instruction = described_class.new(5)
+        expect(instruction.target).to eq(5)
+      end
+
+      it 'handles zero target' do
+        instruction = described_class.new(0)
+        expect(instruction.target).to eq(0)
+      end
+    end
+
+    describe '#target=' do
+      it 'allows updating the target' do
+        instruction = described_class.new(5)
+        instruction.target = 10
+        expect(instruction.target).to eq(10)
+      end
+    end
+  end
+
+  describe Hoozuki::Instruction::Match do
+    describe '#initialize' do
+      it 'creates a Match instruction' do
+        instruction = described_class.new
+        expect(instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe Hoozuki::Instruction::Split do
+    describe '#initialize' do
+      it 'sets left and right targets' do
+        instruction = described_class.new(3, 7)
+        expect(instruction.left).to eq(3)
+        expect(instruction.right).to eq(7)
+      end
+
+      it 'handles zero targets' do
+        instruction = described_class.new(0, 0)
+        expect(instruction.left).to eq(0)
+        expect(instruction.right).to eq(0)
+      end
+    end
+
+    describe '#left=' do
+      it 'allows updating the left target' do
+        instruction = described_class.new(3, 7)
+        instruction.left = 5
+        expect(instruction.left).to eq(5)
+      end
+    end
+
+    describe '#right=' do
+      it 'allows updating the right target' do
+        instruction = described_class.new(3, 7)
+        instruction.right = 10
+        expect(instruction.right).to eq(10)
+      end
+    end
+  end
+end

data/spec/hoozuki/node_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Hoozuki::Node' do
+  let(:state) { Hoozuki::Automaton::StateID.new(0) }
+
+  describe Hoozuki::Node::Literal do
+    describe '#to_nfa' do
+      it 'creates an NFA with a single transition' do
+        node = described_class.new('a')
+        nfa = node.to_nfa(state)
+
+        expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+        expect(nfa.start).to be_a(Hoozuki::Automaton::StateID)
+        expect(nfa.accept).to be_an(Array)
+        expect(nfa.accept.length).to eq(1)
+        expect(nfa.transitions.size).to eq(1)
+      end
+
+      it 'creates correct transition' do
+        node = described_class.new('b')
+        nfa = node.to_nfa(state)
+
+        transition = nfa.transitions.first
+        expect(transition[1]).to eq('b')
+      end
+    end
+  end
+
+  describe Hoozuki::Node::Epsilon do
+    describe '#to_nfa' do
+      it 'creates an NFA with epsilon transition' do
+        node = described_class.new
+        nfa = node.to_nfa(state)
+
+        expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+        expect(nfa.transitions.size).to eq(1)
+        transition = nfa.transitions.first
+        expect(transition[1]).to be_nil
+      end
+    end
+  end
+
+  describe Hoozuki::Node::Repetition do
+    describe '#to_nfa' do
+      context 'with zero_or_more' do
+        it 'creates correct NFA structure' do
+          child = Hoozuki::Node::Literal.new('a')
+          node = described_class.new(child, :zero_or_more)
+          nfa = node.to_nfa(state)
+
+          expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+          expect(nfa.accept.length).to eq(2)
+        end
+      end
+
+      context 'with one_or_more' do
+        it 'creates correct NFA structure' do
+          child = Hoozuki::Node::Literal.new('a')
+          node = described_class.new(child, :one_or_more)
+          nfa = node.to_nfa(state)
+
+          expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+          expect(nfa.accept.length).to eq(1)
+        end
+      end
+
+      context 'with optional' do
+        it 'creates correct NFA structure' do
+          child = Hoozuki::Node::Literal.new('a')
+          node = described_class.new(child, :optional)
+          nfa = node.to_nfa(state)
+
+          expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+          expect(nfa.accept.length).to eq(2)
+        end
+      end
+    end
+  end
+
+  describe Hoozuki::Node::Choice do
+    describe '#to_nfa' do
+      it 'creates NFA with branches' do
+        left = Hoozuki::Node::Literal.new('a')
+        right = Hoozuki::Node::Literal.new('b')
+        node = described_class.new([left, right])
+        nfa = node.to_nfa(state)
+
+        expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+        expect(nfa.accept.length).to eq(2)
+      end
+    end
+  end
+
+  describe Hoozuki::Node::Concatenation do
+    describe '#to_nfa' do
+      it 'creates NFA with sequential states' do
+        children = [
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b'),
+          Hoozuki::Node::Literal.new('c')
+        ]
+        node = described_class.new(children)
+        nfa = node.to_nfa(state)
+
+        expect(nfa).to be_a(Hoozuki::Automaton::NFA)
+        expect(nfa.accept.length).to eq(1)
+      end
+    end
+  end
+end

data/spec/hoozuki/parser_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki::Parser do
+  describe '#parse' do
+    context 'with a single literal' do
+      it 'returns a Literal node' do
+        result = described_class.new.parse('a')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('a')
+      end
+    end
+
+    context 'with concatenation' do
+      it 'returns a Concatenation node' do
+        result = described_class.new.parse('abc')
+        expect(result).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.children.length).to eq(3)
+        expect(result.children.map(&:value)).to eq(%w[a b c])
+      end
+
+      it 'handles multibyte characters' do
+        result = described_class.new.parse('あいう')
+        expect(result).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.children.map(&:value)).to eq(%w[あ い う])
+      end
+    end
+
+    context 'with alternation' do
+      it 'returns a Choice node' do
+        result = described_class.new.parse('a|b')
+        expect(result).to be_a(Hoozuki::Node::Choice)
+        expect(result.children.length).to eq(2)
+      end
+
+      it 'parses choice with concatenation' do
+        result = described_class.new.parse('cat|dog')
+        expect(result).to be_a(Hoozuki::Node::Choice)
+        expect(result.children[0]).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.children[1]).to be_a(Hoozuki::Node::Concatenation)
+      end
+
+      it 'parses multiple choices' do
+        result = described_class.new.parse('a|b|c')
+        expect(result).to be_a(Hoozuki::Node::Choice)
+        expect(result.children.length).to eq(3)
+      end
+    end
+
+    context 'with zero or more quantifier' do
+      it 'returns a Repetition node with zero_or_more' do
+        result = described_class.new.parse('a*')
+        expect(result).to be_a(Hoozuki::Node::Repetition)
+        expect(result.zero_or_more?).to be true
+      end
+    end
+
+    context 'with one or more quantifier' do
+      it 'returns a Repetition node with one_or_more' do
+        result = described_class.new.parse('a+')
+        expect(result).to be_a(Hoozuki::Node::Repetition)
+        expect(result.one_or_more?).to be true
+      end
+    end
+
+    context 'with optional quantifier' do
+      it 'returns a Repetition node with optional' do
+        result = described_class.new.parse('a?')
+        expect(result).to be_a(Hoozuki::Node::Repetition)
+        expect(result.optional?).to be true
+      end
+    end
+
+    context 'with grouping' do
+      it 'returns correct structure' do
+        result = described_class.new.parse('(ab)')
+        expect(result).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.children.length).to eq(2)
+      end
+
+      it 'parses nested groups' do
+        result = described_class.new.parse('((a))')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('a')
+      end
+
+      it 'parses group with empty alternative' do
+        result = described_class.new.parse('(a|)')
+        expect(result).to be_a(Hoozuki::Node::Choice)
+        expect(result.children.last).to be_a(Hoozuki::Node::Epsilon)
+      end
+
+      it 'parses group repetition' do
+        result = described_class.new.parse('(ab)*')
+        expect(result).to be_a(Hoozuki::Node::Repetition)
+        expect(result.child).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.zero_or_more?).to be true
+      end
+    end
+
+    context 'with escaped characters' do
+      it 'treats escaped special characters as literals' do
+        result = described_class.new.parse('\\*')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('*')
+      end
+
+      it 'escapes opening parenthesis' do
+        result = described_class.new.parse('\\(')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('(')
+      end
+
+      it 'escapes closing parenthesis' do
+        result = described_class.new.parse('\\)')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq(')')
+      end
+
+      it 'escapes pipe character' do
+        result = described_class.new.parse('\\|')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('|')
+      end
+
+      it 'escapes backslash' do
+        result = described_class.new.parse('\\\\')
+        expect(result).to be_a(Hoozuki::Node::Literal)
+        expect(result.value).to eq('\\')
+      end
+
+      it 'raises error for incomplete escape' do
+        expect { described_class.new.parse('\\') }.to raise_error
+      end
+    end
+
+    context 'with error cases' do
+      it 'raises error for unmatched opening parenthesis' do
+        expect { described_class.new.parse('(abc') }.to raise_error
+      end
+
+      it 'raises error for unmatched closing parenthesis' do
+        expect { described_class.new.parse('abc)') }.to raise_error
+      end
+
+      it 'raises error for nested unmatched parentheses' do
+        expect { described_class.new.parse('((a)') }.to raise_error
+      end
+    end
+
+    context 'with empty alternation' do
+      it 'returns a Choice with Epsilon' do
+        result = described_class.new.parse('a|')
+        expect(result).to be_a(Hoozuki::Node::Choice)
+        expect(result.children.length).to eq(2)
+        expect(result.children.last).to be_a(Hoozuki::Node::Epsilon)
+      end
+    end
+
+    context 'with complex pattern' do
+      it 'parses correctly' do
+        result = described_class.new.parse('a(b|c)*d')
+        expect(result).to be_a(Hoozuki::Node::Concatenation)
+        expect(result.children.length).to eq(3)
+        expect(result.children[1]).to be_a(Hoozuki::Node::Repetition)
+      end
+    end
+  end
+end