hoozuki 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c496655adac0eea264d8a058af5518711803be3441781a1e59c132b6ce67d4e7
-  data.tar.gz: '0481e2619ba549f46849b5471f60ee77388fdf79c7dd4c9decbb3f3f3a21093f'
+  metadata.gz: ff80e01946d63faf2012a01c6f7d2c04f0330b47aa63ba2a0f540c9e6cf290fc
+  data.tar.gz: 515b27f972f50c5f4c35cf6d33422637f93cdedc7db54ffdbd7a3f363a10c18f
 SHA512:
-  metadata.gz: 1e9aae7d5afa4cc9cab9faf374528cbd2e334ec85305b75ac324b4cc6e4ecfe871d10c6a5478fc83e56dbe89605de0e377d4ad67ae9489464f128d661fad5709
-  data.tar.gz: e62195f96cdff93a141e1796a4e6b7322e57f50ab885b9e61c2815832e45b66137536b1d94782974e57d7ba4b174a5099f1c17b794b28041068292905a794171
+  metadata.gz: d26025dabd381db4ec2dc42ee4baa626e5389fd4ce7ade66f6e5a6d42879c929e2529e65413c919b8119e0127027986243a3be8a5bc0c702cbc52c57c276fee3
+  data.tar.gz: edff1a212c89c9f322517649ef6b8daf27bbaa41682e312313b064e97002d3a0c395e2bc3c9a82c657ea8e38670e91f31616923f5d026776a5d81bac0892a3ec

data/CHANGELOG.md

@@ -2,7 +2,11 @@
 
 ## Unreleased
 
-## 0.1.0 (2022-07-04)
+## 0.2.0 (2025-08-25)
+
+- Support VM engine for regex matching. ([@ydah])
+
+## 0.1.0 (2025-08-23)
 
 - Initial release
 

data/README.md

@@ -1,6 +1,9 @@
-# Hoozuki (鬼灯)
+# Hoozuki (鬼灯) [![Gem Version](https://badge.fury.io/rb/hoozuki.svg)](https://badge.fury.io/rb/hoozuki) [![CI](https://github.com/ydah/hoozuki/actions/workflows/ci.yml/badge.svg)](https://github.com/ydah/hoozuki/actions/workflows/ci.yml)
 
 A hobby regex engine written in Ruby. Designed to be simple and efficient for educational purposes.
+Currently supports 2 engines:
+- NFA Based Engine
+- VM Based Engine
 
 ## Installation
 
@@ -12,10 +15,20 @@ gem install hoozuki
 
 ```ruby
 require 'hoozuki'
-regex = Hoozuki::Regex.new('a(bc|de)f')
-puts regex.match?('abcdef') # => true
-puts regex.match?('adef')   # => true
-puts regex.match?('xyz')    # => false
+regex = Hoozuki.new('a(bc|de)*f') # Or Hoozuki.new('a(bc|de)*f', engine: :nfa) for NFA based engine
+regex.match?('abcdef') # => true
+regex.match?('adef')   # => true
+regex.match?('xyz')    # => false
+```
+
+If you want to use the VM based engine:
+
+```ruby
+require 'hoozuki'
+regex = Hoozuki.new('a(bc|de)*f', engine: :vm)
+regex.match?('abcdef') # => true
+regex.match?('adef')   # => true
+regex.match?('xyz')    # => false
 ```
 
 ## License

data/lib/hoozuki/instruction/char.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Instruction
+    class Char
+      attr_accessor :char
+
+      def initialize(char)
+        @char = char
+      end
+    end
+  end
+end

data/lib/hoozuki/instruction/jmp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Instruction
+    class Jmp
+      attr_accessor :target
+
+      def initialize(target)
+        @target = target
+      end
+    end
+  end
+end

data/lib/hoozuki/instruction/match.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Instruction
+    class Match
+    end
+  end
+end

data/lib/hoozuki/instruction/split.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Instruction
+    class Split
+      attr_accessor :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+    end
+  end
+end

data/lib/hoozuki/instruction.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'instruction/char'
+require_relative 'instruction/jmp'
+require_relative 'instruction/match'
+require_relative 'instruction/split'

data/lib/hoozuki/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Hoozuki
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/hoozuki/vm/compiler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module VM
+    class Compiler
+      attr_reader :instructions
+
+      def initialize
+        @pc = 0
+        @instructions = []
+      end
+
+      def compile(ast)
+        _compile(ast)
+        @pc += 1
+        @instructions << Instruction::Match.new
+      end
+
+      private
+
+      def _compile(ast)
+        case ast
+        when Hoozuki::Node::Literal
+          emit(Hoozuki::Instruction::Char.new(ast.value))
+        when Hoozuki::Node::Epsilon
+          # Do nothing for epsilon
+        when Node::Repetition
+          if ast.zero_or_more?
+            split = @pc
+            emit(Hoozuki::Instruction::Split.new(@pc + 1, 0))
+            _compile(ast.child)
+            emit(Hoozuki::Instruction::Jmp.new(split))
+            patch(split, Hoozuki::Instruction::Split.new(split + 1, @pc))
+          elsif ast.one_or_more?
+            start = @pc
+            _compile(ast.child)
+            emit(Hoozuki::Instruction::Split.new(start, @pc + 1))
+          elsif ast.optional?
+            split = @pc
+            emit(Hoozuki::Instruction::Split.new(0, 0))
+            start = @pc
+            _compile(ast.child)
+            last = @pc
+            patch(split, Hoozuki::Instruction::Split.new(start, last))
+          end
+        when Node::Choice
+          split = @pc
+          @pc += 1
+          @instructions << Hoozuki::Instruction::Split.new(@pc, 0)
+          _compile(ast.children.first)
+          jump = @pc
+          emit(Hoozuki::Instruction::Jmp.new(0))
+
+          if @instructions[split].is_a?(Hoozuki::Instruction::Split)
+            @instructions[split].right = @pc
+          else
+            raise "Instruction at pc #{split} is not a Split"
+          end
+
+          _compile(ast.children.last)
+
+          if @instructions[jump].is_a?(Hoozuki::Instruction::Jmp)
+            @instructions[jump].target = @pc
+          else
+            raise "Instruction at pc #{jump} is not a Jmp"
+          end
+        when Node::Concatenation
+          ast.children.each do |child|
+            _compile(child)
+          end
+        end
+      end
+
+      def emit(instruction)
+        @instructions << instruction
+        @pc += 1
+      end
+
+      def patch(pc, instruction)
+        @instructions[pc] = instruction
+      end
+    end
+  end
+end

data/lib/hoozuki/vm/evaluator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module VM
+    class Evaluator
+      class << self
+        def evaluate(instructions, input, input_pos = 0, pc = 0)
+          new._evaluate(instructions, input, input_pos, pc)
+        end
+      end
+
+      def _evaluate(instructions, input, input_pos, pc)
+        loop do
+          return false if pc >= instructions.size
+
+          inst = instructions[pc]
+          case inst
+          when Hoozuki::Instruction::Char
+            return false if input_pos >= input.size || input[input_pos] != inst.char
+            input_pos += 1
+            pc += 1
+          when Hoozuki::Instruction::Jmp
+            pc = inst.target
+          when Hoozuki::Instruction::Split
+            if _evaluate(instructions, input, input_pos, inst.left)
+              return true
+            else
+              pc = inst.right
+            end
+          when Hoozuki::Instruction::Match
+            return input_pos == input.length
+          else
+            raise "Unknown instruction: #{inst.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hoozuki/vm.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'vm/compiler'
+require_relative 'vm/evaluator'

data/lib/hoozuki.rb

@@ -1,29 +1,37 @@
 # frozen_string_literal: true
 
 require_relative 'hoozuki/automaton'
+require_relative 'hoozuki/instruction'
 require_relative 'hoozuki/node'
 require_relative 'hoozuki/parser'
 require_relative 'hoozuki/version'
+require_relative 'hoozuki/vm'
 
 class Hoozuki
-  def initialize(input, method: :dfa)
+  def initialize(input, engine: :dfa)
     @input = input
-    @method = method
+    @engine = engine
 
     ast = Hoozuki::Parser.new(input).parse
-    case method
+    case engine
     when :dfa
       nfa = Automaton::NFA.new_from_node(ast, Automaton::StateID.new(0))
       @dfa = Automaton::DFA.from_nfa(nfa, use_cache?(input))
+    when :vm
+      compiler = VM::Compiler.new
+      compiler.compile(ast)
+      @bytecode = compiler.instructions
     end
   end
 
   def match?(input)
-    case @method
+    case @engine
     when :dfa
       @dfa.match?(input, use_cache?(input))
+    when :vm
+      VM::Evaluator.evaluate(@bytecode, input, 0, 0)
     else
-      raise ArgumentError, "Unknown method: #{@method}"
+      raise ArgumentError, "Unknown engine: #{@engine}"
     end
   end
 

data/spec/hoozuki_spec.rb

@@ -1,8 +1,8 @@
 # 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.new(pattern, engine: mode).match?(value) }
 
     context 'with basic concatenation' do
       let(:pattern) { 'abc' }
@@ -208,4 +208,14 @@ RSpec.describe Hoozuki do
       end
     end
   end
+
+  describe '#match?' do
+    context 'with :vm mode' do
+      include_examples 'regex matching behavior', :vm
+    end
+
+    context 'with :dfa mode' do
+      include_examples 'regex matching behavior', :dfa
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hoozuki
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -28,6 +28,11 @@ files:
 - lib/hoozuki/automaton/dfa.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
@@ -36,6 +41,9 @@ files:
 - lib/hoozuki/node/repetition.rb
 - lib/hoozuki/parser.rb
 - lib/hoozuki/version.rb
+- lib/hoozuki/vm.rb
+- lib/hoozuki/vm/compiler.rb
+- lib/hoozuki/vm/evaluator.rb
 - spec/hoozuki_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ydah/hoozuki