hoozuki 0.1.0 → 1.0.0

data/spec/hoozuki/vm/compiler_spec.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki::VM::Compiler do
+  describe '#compile' do
+    let(:compiler) { described_class.new }
+
+    context 'with Literal node' do
+      it 'compiles to Char and Match instructions' do
+        node = Hoozuki::Node::Literal.new('a')
+        compiler.compile(node)
+
+        expect(compiler.instructions.size).to eq(2)
+        expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Char)
+        expect(compiler.instructions[0].char).to eq('a')
+        expect(compiler.instructions[1]).to be_a(Hoozuki::Instruction::Match)
+      end
+
+      it 'handles multibyte characters' do
+        node = Hoozuki::Node::Literal.new('あ')
+        compiler.compile(node)
+
+        expect(compiler.instructions[0].char).to eq('あ')
+      end
+    end
+
+    context 'with Epsilon node' do
+      it 'compiles to only Match instruction' do
+        node = Hoozuki::Node::Epsilon.new
+        compiler.compile(node)
+
+        expect(compiler.instructions.size).to eq(1)
+        expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Match)
+      end
+    end
+
+    context 'with Concatenation node' do
+      it 'compiles to sequential Char instructions' do
+        node = Hoozuki::Node::Concatenation.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        compiler.compile(node)
+
+        expect(compiler.instructions.size).to eq(3)
+        expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Char)
+        expect(compiler.instructions[0].char).to eq('a')
+        expect(compiler.instructions[1]).to be_a(Hoozuki::Instruction::Char)
+        expect(compiler.instructions[1].char).to eq('b')
+        expect(compiler.instructions[2]).to be_a(Hoozuki::Instruction::Match)
+      end
+
+      it 'handles longer concatenations' do
+        node = Hoozuki::Node::Concatenation.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b'),
+          Hoozuki::Node::Literal.new('c')
+        ])
+        compiler.compile(node)
+
+        expect(compiler.instructions.size).to eq(4)
+        expect(compiler.instructions.map { |i| i.is_a?(Hoozuki::Instruction::Char) ? i.char : nil }.compact).to eq(['a', 'b', 'c'])
+      end
+    end
+
+    context 'with Choice node' do
+      it 'compiles with Split and Jmp instructions' do
+        node = Hoozuki::Node::Choice.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        compiler.compile(node)
+
+        expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Split)
+        expect(compiler.instructions).to include(an_instance_of(Hoozuki::Instruction::Jmp))
+        expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+      end
+
+      it 'sets correct Split targets' do
+        node = Hoozuki::Node::Choice.new([
+          Hoozuki::Node::Literal.new('a'),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        compiler.compile(node)
+
+        split = compiler.instructions[0]
+        expect(split.left).to eq(1)
+        expect(split.right).to be > split.left
+      end
+    end
+
+    context 'with Repetition node' do
+      context 'with zero_or_more' do
+        it 'compiles with Split and Jmp for looping' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :zero_or_more
+          )
+          compiler.compile(node)
+
+          expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Split)
+          expect(compiler.instructions).to include(an_instance_of(Hoozuki::Instruction::Jmp))
+          expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+        end
+
+        it 'creates correct loop structure' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :zero_or_more
+          )
+          compiler.compile(node)
+
+          split = compiler.instructions[0]
+          expect(split).to be_a(Hoozuki::Instruction::Split)
+          jmp = compiler.instructions.find { |i| i.is_a?(Hoozuki::Instruction::Jmp) }
+          expect(jmp.target).to eq(0)
+        end
+      end
+
+      context 'with one_or_more' do
+        it 'compiles with Char followed by Split' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :one_or_more
+          )
+          compiler.compile(node)
+
+          expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Char)
+          expect(compiler.instructions[1]).to be_a(Hoozuki::Instruction::Split)
+          expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+        end
+
+        it 'creates correct loop structure' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :one_or_more
+          )
+          compiler.compile(node)
+
+          split = compiler.instructions[1]
+          expect(split.left).to eq(0)
+          expect(split.right).to eq(2)
+        end
+      end
+
+      context 'with optional' do
+        it 'compiles with Split around the node' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :optional
+          )
+          compiler.compile(node)
+
+          expect(compiler.instructions[0]).to be_a(Hoozuki::Instruction::Split)
+          expect(compiler.instructions[1]).to be_a(Hoozuki::Instruction::Char)
+          expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+        end
+
+        it 'sets Split to allow skipping' do
+          node = Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :optional
+          )
+          compiler.compile(node)
+
+          split = compiler.instructions[0]
+          expect(split.left).to eq(1)
+          expect(split.right).to eq(2)
+        end
+      end
+    end
+
+    context 'with complex nested structures' do
+      it 'compiles choice within concatenation' do
+        node = Hoozuki::Node::Concatenation.new([
+          Hoozuki::Node::Literal.new('x'),
+          Hoozuki::Node::Choice.new([
+            Hoozuki::Node::Literal.new('a'),
+            Hoozuki::Node::Literal.new('b')
+          ]),
+          Hoozuki::Node::Literal.new('y')
+        ])
+        compiler.compile(node)
+
+        expect(compiler.instructions).to include(an_instance_of(Hoozuki::Instruction::Split))
+        expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+      end
+
+      it 'compiles repetition within choice' do
+        node = Hoozuki::Node::Choice.new([
+          Hoozuki::Node::Repetition.new(
+            Hoozuki::Node::Literal.new('a'),
+            :zero_or_more
+          ),
+          Hoozuki::Node::Literal.new('b')
+        ])
+        compiler.compile(node)
+
+        expect(compiler.instructions).to include(an_instance_of(Hoozuki::Instruction::Split))
+        expect(compiler.instructions).to include(an_instance_of(Hoozuki::Instruction::Jmp))
+        expect(compiler.instructions.last).to be_a(Hoozuki::Instruction::Match)
+      end
+    end
+  end
+
+  describe '#instructions' do
+    it 'returns empty array initially' do
+      compiler = described_class.new
+      expect(compiler.instructions).to eq([])
+    end
+
+    it 'accumulates instructions after compile' do
+      compiler = described_class.new
+      node = Hoozuki::Node::Literal.new('a')
+      compiler.compile(node)
+
+      expect(compiler.instructions).not_to be_empty
+    end
+  end
+end

data/spec/hoozuki/vm/evaluator_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki::VM::Evaluator do
+  describe '.evaluate' do
+    context 'with single Char instruction' do
+      it 'matches exact character' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be true
+      end
+
+      it 'does not match different character' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'b')).to be false
+      end
+
+      it 'does not match empty string' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be false
+      end
+
+      it 'handles multibyte characters' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('あ'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'あ')).to be true
+        expect(described_class.evaluate(instructions, 'い')).to be false
+      end
+    end
+
+    context 'with multiple Char instructions' do
+      it 'matches sequential characters' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Char.new('c'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'abc')).to be true
+      end
+
+      it 'does not match partial sequence' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be false
+        expect(described_class.evaluate(instructions, 'abc')).to be false
+      end
+    end
+
+    context 'with Jmp instruction' do
+      it 'jumps to target address' do
+        instructions = [
+          Hoozuki::Instruction::Jmp.new(2),
+          Hoozuki::Instruction::Char.new('x'),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'x')).to be false
+      end
+
+      it 'handles backward jumps for loops' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Jmp.new(0),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be true
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'aaa')).to be true
+      end
+    end
+
+    context 'with Split instruction' do
+      it 'tries left branch first' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new,
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be true
+      end
+
+      it 'tries right branch if left fails' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new,
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'b')).to be true
+      end
+
+      it 'returns false if both branches fail' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new,
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'c')).to be false
+      end
+    end
+
+    context 'with Match instruction' do
+      it 'returns true only if entire input is consumed' do
+        instructions = [
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be true
+        expect(described_class.evaluate(instructions, 'a')).to be false
+      end
+
+      it 'returns false if input remains unconsumed' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'ab')).to be false
+      end
+    end
+
+    context 'with complex patterns' do
+      it 'handles choice pattern (a|b)' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Jmp.new(4),
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'b')).to be true
+        expect(described_class.evaluate(instructions, 'c')).to be false
+      end
+
+      it 'handles zero-or-more pattern (a*)' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Jmp.new(0),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be true
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'aa')).to be true
+        expect(described_class.evaluate(instructions, 'aaa')).to be true
+        expect(described_class.evaluate(instructions, 'b')).to be false
+      end
+
+      it 'handles one-or-more pattern (a+)' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Split.new(0, 2),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'aa')).to be true
+        expect(described_class.evaluate(instructions, 'aaa')).to be true
+        expect(described_class.evaluate(instructions, '')).to be false
+      end
+
+      it 'handles optional pattern (a?)' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 2),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be true
+        expect(described_class.evaluate(instructions, 'a')).to be true
+        expect(described_class.evaluate(instructions, 'aa')).to be false
+      end
+    end
+
+    context 'with edge cases' do
+      it 'handles empty instruction list' do
+        instructions = []
+
+        expect(described_class.evaluate(instructions, '')).to be false
+        expect(described_class.evaluate(instructions, 'a')).to be false
+      end
+
+      it 'handles invalid pc (out of bounds)' do
+        instructions = [
+          Hoozuki::Instruction::Jmp.new(10),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, '')).to be false
+      end
+
+      it 'handles long input strings' do
+        instructions = [
+          Hoozuki::Instruction::Split.new(1, 3),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Jmp.new(0),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        long_input = 'a' * 1000
+        expect(described_class.evaluate(instructions, long_input)).to be true
+      end
+    end
+
+    context 'with initial positions' do
+      it 'can start from non-zero input position' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('b'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'ab', 1, 0)).to be true
+      end
+
+      it 'can start from non-zero pc' do
+        instructions = [
+          Hoozuki::Instruction::Char.new('x'),
+          Hoozuki::Instruction::Char.new('a'),
+          Hoozuki::Instruction::Match.new
+        ]
+
+        expect(described_class.evaluate(instructions, 'a', 0, 1)).to be true
+      end
+    end
+  end
+end