hoozuki 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c496655adac0eea264d8a058af5518711803be3441781a1e59c132b6ce67d4e7
+  data.tar.gz: '0481e2619ba549f46849b5471f60ee77388fdf79c7dd4c9decbb3f3f3a21093f'
+SHA512:
+  metadata.gz: 1e9aae7d5afa4cc9cab9faf374528cbd2e334ec85305b75ac324b4cc6e4ecfe871d10c6a5478fc83e56dbe89605de0e377d4ad67ae9489464f128d661fad5709
+  data.tar.gz: e62195f96cdff93a141e1796a4e6b7322e57f50ab885b9e61c2815832e45b66137536b1d94782974e57d7ba4b174a5099f1c17b794b28041068292905a794171

data/.rspec

@@ -0,0 +1,4 @@
+--require spec_helper
+--color
+--format documentation
+--backtrace

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change log
+
+## Unreleased
+
+## 0.1.0 (2022-07-04)
+
+- Initial release
+
+<!-- Contributors -->
+
+[@ydah]: https://github.com/ydah

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# Hoozuki (鬼灯)
+
+A hobby regex engine written in Ruby. Designed to be simple and efficient for educational purposes.
+
+## Installation
+
+```bash
+gem install hoozuki
+```
+
+## Usage
+
+```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
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/hoozuki/automaton/dfa.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Automaton
+    class DFA
+      attr_reader :start, :accept, :transitions
+
+      def initialize(start, accept)
+        @start = start
+        @accept = accept
+        @transitions = Set.new
+        @cache = {}
+      end
+
+      class << self
+        def from_nfa(nfa, use_cache)
+          dfa_states = {}
+          queue = []
+          nfa_accept_set = nfa.accept.to_set
+
+          start_set = Set.new([nfa.start])
+          start_states = nfa.epsilon_closure(start_set)
+
+          start_id = 0
+          dfa_states[start_states] = start_id
+          queue << start_states
+
+          dfa = new(start_id, Set.new)
+
+          while (current_nfa_states = queue.shift)
+            current_dfa_id = dfa_states[current_nfa_states]
+            dfa.accept.merge([current_dfa_id]) if current_nfa_states.any? { |state| nfa_accept_set.include?(state) }
+
+            transitions_map = Hash.new { |h, k| h[k] = Set.new }
+
+            current_nfa_states.each do |state|
+              nfa.transitions.each do |from, label, to|
+                transitions_map[label].merge(nfa.epsilon_closure(Set[to])) if from == state && !label.nil?
+              end
+            end
+
+            transitions_map.each do |char, next_nfa_states|
+              unless dfa_states.key?(next_nfa_states)
+                next_dfa_id = dfa_states.length
+                dfa_states[next_nfa_states] = next_dfa_id
+                queue.push(next_nfa_states)
+              end
+
+              next_dfa_id = dfa_states[next_nfa_states]
+              dfa.transitions.add([current_dfa_id, char, next_dfa_id])
+
+              dfa.cache[[current_dfa_id, char]] = next_dfa_id if use_cache
+            end
+          end
+
+          dfa
+        end
+      end
+
+      def next_transition(current, input, use_cache)
+        if use_cache && (next_state = @cache[[current, input]])
+          return next_state
+        end
+
+        @transitions.find { |from, label, _| from == current && label == input }&.last
+      end
+
+      def match?(input, use_cache)
+        state = @start
+
+        input.each_char do |char|
+          next_state = next_transition(state, char, use_cache)
+          return false unless next_state
+
+          state = next_state
+        end
+
+        @accept.include?(state)
+      end
+    end
+  end
+end

data/lib/hoozuki/automaton/nfa.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'sorted_set'
+
+class Hoozuki
+  module Automaton
+    class NFA
+      attr_accessor :start, :accept, :transitions
+
+      def initialize(start, accept)
+        @start = start
+        @accept = accept
+        @transitions = Set.new
+      end
+
+      class << self
+        def new_from_node(node, state)
+          raise ArgumentError, 'Node cannot be nil' if node.nil?
+
+          case node
+          when Node::Literal
+            start_state = state.new_state
+            accept_state = state.new_state
+            nfa = new(start_state, [accept_state])
+            nfa.add_transition(start_state, node.value, accept_state)
+            nfa
+          when Node::Epsilon
+            start_state = state.new_state
+            accept_state = state.new_state
+            nfa = new(start_state, [accept_state])
+            nfa.add_epsilon_transition(start_state, accept_state)
+            nfa
+          when Node::Repetition
+            if node.zero_or_more?
+              remain = new_from_node(node.child, state)
+              start_state = state.new_state
+              accepts = remain.accept.dup
+              accepts << start_state
+
+              nfa = new(start_state, accepts)
+              nfa.merge_nfa(remain)
+              nfa.add_epsilon_transition(start_state, remain.start)
+
+              remain.accept.each do |accept_state|
+                nfa.add_epsilon_transition(accept_state, remain.start)
+              end
+
+              nfa
+            elsif node.one_or_more?
+              remain = new_from_node(node.child, state)
+              start_state = state.new_state
+              accept_state = state.new_state
+              nfa = new(start_state, [accept_state])
+
+              nfa.transitions.merge(remain.transitions)
+              nfa.add_epsilon_transition(start_state, remain.start)
+              remain.accept.each do |remain_accept|
+                nfa.add_epsilon_transition(remain_accept, remain.start)
+                nfa.add_epsilon_transition(remain_accept, accept_state)
+              end
+              nfa
+            elsif node.optional?
+              child = new_from_node(node.child, state)
+              start_state = state.new_state
+              accepts = child.accept.dup
+              accepts << start_state
+
+              nfa = new(start_state, accepts)
+              nfa.transitions.merge(child.transitions)
+              nfa.add_epsilon_transition(start_state, child.start)
+              nfa
+            end
+          when Node::Choice
+            remain1 = new_from_node(node.children[0], state)
+            remain2 = new_from_node(node.children[1], state)
+            start_state = state.new_state
+            accepts = remain1.accept if remain1.respond_to?(:accept)
+            accepts |= remain2.accept if remain2.respond_to?(:accept)
+            nfa = new(start_state, accepts)
+            nfa.merge_nfa(remain1)
+            nfa.merge_nfa(remain2)
+            nfa.add_epsilon_transition(start_state, remain1.start)
+            nfa.add_epsilon_transition(start_state, remain2.start)
+            nfa
+          when Node::Concatenation
+            nfas = node.children.map { |child| new_from_node(child, state) }
+            nfa = nfas.first
+            nfas.drop(1).each do |next_nfa|
+              nfa.transitions.merge(next_nfa.transitions)
+              nfa.accept.each do |accept_state|
+                nfa.add_epsilon_transition(accept_state, next_nfa.start)
+              end
+              nfa.accept = next_nfa.accept
+            end
+            nfa
+          else
+            raise ArgumentError, "Unsupported node type: #{node.class}"
+          end
+        end
+      end
+
+      def epsilon_closure_with_bitset(start)
+        visited = Set.new
+        to_visit = []
+
+        start.each do |state|
+          to_visit << state unless visited.include?(state)
+        end
+
+        until to_visit.empty?
+          state = to_visit.shift
+
+          next if visited.include?(state)
+
+          visited << state
+
+          transitions.each do |from, label, to|
+            to_visit << to if from == state && label.nil? && !visited.include?(to)
+          end
+        end
+
+        visited
+      end
+
+      def epsilon_closure(start)
+        bit_result = epsilon_closure_with_bitset(start.to_set)
+        ::SortedSet.new(bit_result)
+      end
+
+      def add_epsilon_transition(from, to)
+        @transitions << [from, nil, to]
+      end
+
+      def add_transition(from, char, to)
+        @transitions << [from, char, to]
+      end
+
+      def merge_nfa(other)
+        @transitions.merge(other.transitions)
+        add_epsilon_transition(@start, other.start)
+        other.accept.each do |accept_state|
+          @accept << accept_state
+        end
+      end
+    end
+  end
+end

data/lib/hoozuki/automaton/state_id.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Automaton
+    class StateID
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      class << self
+        def new_state
+          @id += 1
+          StateID.new(@id)
+        end
+      end
+
+      def new_state
+        @id += 1
+        StateID.new(@id)
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(StateID)
+        @id <=> other.id
+      end
+    end
+  end
+end

data/lib/hoozuki/automaton.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'automaton/nfa'
+require_relative 'automaton/dfa'
+require_relative 'automaton/state_id'

data/lib/hoozuki/node/choice.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Node
+    class Choice
+      attr_reader :children
+
+      def initialize(children)
+        @children = children
+      end
+    end
+  end
+end

data/lib/hoozuki/node/concatenation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Node
+    class Concatenation
+      attr_reader :children
+
+      def initialize(children)
+        @children = children
+      end
+    end
+  end
+end

data/lib/hoozuki/node/epsilon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Node
+    class Epsilon
+    end
+  end
+end

data/lib/hoozuki/node/literal.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Node
+    class Literal
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+  end
+end

data/lib/hoozuki/node/repetition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  module Node
+    class Repetition
+      attr_reader :child
+
+      def initialize(child, quantifier)
+        @child = child
+        @quantifier = quantifier
+      end
+
+      def zero_or_more?
+        @quantifier == :zero_or_more
+      end
+
+      def one_or_more?
+        @quantifier == :one_or_more
+      end
+
+      def optional?
+        @quantifier == :optional
+      end
+    end
+  end
+end

data/lib/hoozuki/node.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'node/choice'
+require_relative 'node/concatenation'
+require_relative 'node/epsilon'
+require_relative 'node/literal'
+require_relative 'node/repetition'

data/lib/hoozuki/parser.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+class Hoozuki
+  class Parser
+    def initialize(pattern)
+      @pattern = pattern
+      @offset = 0
+    end
+
+    class << self
+      def parse(pattern)
+        new(pattern).parse
+      end
+    end
+
+    def parse
+      ast = parse_choice
+
+      raise 'Unexpected end of pattern' unless eol?
+
+      ast
+    end
+
+    private
+
+    def current
+      @pattern[@offset]
+    end
+
+    def eol?
+      @pattern.size <= @offset
+    end
+
+    def next_char
+      @offset += 1
+    end
+
+    def parse_choice
+      children = []
+      children << parse_concatenation
+
+      while current == '|'
+        next_char
+        children << parse_concatenation
+      end
+
+      return children.first if children.size == 1
+      return Hoozuki::Node::Epsilon.new if children.empty?
+
+      Hoozuki::Node::Choice.new(children)
+    end
+
+    def parse_concatenation
+      children = []
+
+      children << parse_repetition until stop_parsing_concatenation?
+
+      return children.first if children.size == 1
+      return Hoozuki::Node::Epsilon.new if children.empty?
+
+      Hoozuki::Node::Concatenation.new(children)
+    end
+
+    def stop_parsing_concatenation?
+      eol? || current == '|' || current == ')'
+    end
+
+    def parse_repetition
+      child = parse_group
+
+      quantifier = nil
+      case current
+      when '*'
+        quantifier = :zero_or_more
+      when '+'
+        quantifier = :one_or_more
+      when '?'
+        quantifier = :optional
+      end
+      return child if quantifier.nil?
+
+      next_char
+
+      Hoozuki::Node::Repetition.new(child, quantifier)
+    end
+
+    def parse_group
+      return parse_literal if current != '('
+
+      next_char
+      child = parse_choice
+      raise 'Expected closing parenthesis' unless current == ')'
+
+      next_char
+      child
+    end
+
+    def parse_literal
+      raise 'Unexpected end of pattern' if eol?
+
+      if current == '\\'
+        next_char
+        raise 'Unexpected end of pattern' if eol?
+
+        value = current
+        case value
+        when '(', ')', '|', '*', '+', '?', '\\'
+          next_char
+        else
+          raise "Invalid escape sequence: \\#{value}"
+        end
+
+        return Hoozuki::Node::Literal.new(value)
+      end
+
+      value = current
+      case value
+      when '(', ')', '|', '*', '+', '?', '\\'
+        raise "Unexpected character: #{value}"
+      else
+        next_char
+      end
+
+      Hoozuki::Node::Literal.new(value)
+    end
+  end
+end

data/lib/hoozuki/version.rb

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

data/lib/hoozuki.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'hoozuki/automaton'
+require_relative 'hoozuki/node'
+require_relative 'hoozuki/parser'
+require_relative 'hoozuki/version'
+
+class Hoozuki
+  def initialize(input, method: :dfa)
+    @input = input
+    @method = method
+
+    ast = Hoozuki::Parser.new(input).parse
+    case method
+    when :dfa
+      nfa = Automaton::NFA.new_from_node(ast, Automaton::StateID.new(0))
+      @dfa = Automaton::DFA.from_nfa(nfa, use_cache?(input))
+    end
+  end
+
+  def match?(input)
+    case @method
+    when :dfa
+      @dfa.match?(input, use_cache?(input))
+    else
+      raise ArgumentError, "Unknown method: #{@method}"
+    end
+  end
+
+  private
+
+  def use_cache?(input)
+    input.length > 1000
+  end
+end

data/spec/hoozuki_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Hoozuki do
+  describe '#match?' do
+    subject { described_class.new(pattern).match?(value) }
+
+    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
+
+    context 'with alternation "|"' do
+      let(:pattern) { 'a|b' }
+
+      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 quantifiers "*", "+", "?"' do
+      context 'with pattern "b*"' do
+        let(:pattern) { 'b*' }
+
+        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
+
+      context 'with pattern "a+"' do
+        let(:pattern) { 'a+' }
+
+        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
+
+      context 'with pattern "c?"' do
+        let(:pattern) { 'c?' }
+
+        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
+    end
+
+    context 'with grouping "()"' do
+      let(:pattern) { 'ab(cd|)' }
+
+      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
+
+    context 'with escape sequences "\\"' do
+      context 'with pattern "a\\|b\\*"' do
+        let(:pattern) { 'a\\|b\\*' }
+
+        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
+
+      context 'with pattern "\\(a\\+\\)"' do
+        let(:pattern) { '\\(a\\+\\)' }
+
+        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
+    end
+
+    context 'with a combination of features' do
+      let(:pattern) { 'a|b*c(de)?' }
+
+      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
+
+    context 'with multi-byte characters' do
+      let(:pattern) { '(こん|おつ)*やっぴー' }
+
+      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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../lib/hoozuki'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: hoozuki
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Hoozuki is a hobby regex engine written in Ruby, designed to be simple
+  and efficient for educational purposes.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codespellignore"
+- ".rspec"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/hoozuki.rb
+- lib/hoozuki/automaton.rb
+- lib/hoozuki/automaton/dfa.rb
+- lib/hoozuki/automaton/nfa.rb
+- lib/hoozuki/automaton/state_id.rb
+- lib/hoozuki/node.rb
+- lib/hoozuki/node/choice.rb
+- lib/hoozuki/node/concatenation.rb
+- lib/hoozuki/node/epsilon.rb
+- lib/hoozuki/node/literal.rb
+- lib/hoozuki/node/repetition.rb
+- lib/hoozuki/parser.rb
+- lib/hoozuki/version.rb
+- spec/hoozuki_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ydah/hoozuki
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/hoozuki
+  source_code_uri: https://github.com/ydah/hoozuki
+  changelog_uri: https://github.com/ydah/hoozuki/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.8.0.dev
+specification_version: 4
+summary: A hobby regex engine written in Ruby.
+test_files: []