flexr 1.0.0

data/tools/coverage.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "coverage"
+require "rspec/core"
+
+Coverage.start(lines: true)
+
+status = RSpec::Core::Runner.run(["spec", "--format", "progress", "--no-color"], File::NULL, $stdout)
+result = Coverage.result
+files = Dir[File.expand_path("../lib/flexr/**/*.rb", __dir__)]
+totals = files.map do |file|
+  lines = result.fetch(file, {}).fetch(:lines, [])
+  executable = lines.count { |count| !count.nil? }
+  covered = lines.count { |count| count&.positive? }
+  uncovered = lines.each_index.select { |index| lines[index]&.zero? }
+  [file, covered, executable, uncovered]
+end
+covered = totals.sum { |_, count, _, _| count }
+executable = totals.sum { |_, _, count, _| count }
+percentage = executable.zero? ? 100.0 : covered.to_f / executable * 100
+
+puts format("coverage: %<percentage>.2f%% (%<covered>d/%<executable>d lines)",
+            percentage: percentage, covered: covered, executable: executable)
+puts "coverage target: 95.00% (gate)"
+totals.reject { |_, count, total, _| total.zero? || count == total }.each do |file, count, total, uncovered|
+  puts format("  %<file>s: %<count>d/%<total>d", file: file.delete_prefix("#{Dir.pwd}/"), count: count,
+              total: total)
+  puts "    uncovered lines: #{uncovered.map { |line| line + 1 }.join(', ')}"
+end
+
+exit status unless status.zero?
+exit 1 if percentage < 95.0

data/tools/docs_verify.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "rbconfig"
+require "stringio"
+require "tmpdir"
+require_relative "../lib/flexr"
+
+module FlexrDocumentation
+  ROOT = File.expand_path("..", __dir__)
+  MARKER_START = "<!-- flexr-help:start -->"
+  MARKER_END = "<!-- flexr-help:end -->"
+  MARKDOWN_FILES = [
+    File.join(ROOT, "README.md"),
+    File.join(ROOT, "CONTRIBUTING.md"),
+    *Dir[File.join(ROOT, "docs/**/*.md")],
+    *Dir[File.join(ROOT, "examples/**/README.md")]
+  ].freeze
+  STABLE_DSL_METHODS = Flexr::DSL::DSL_METHODS - %i[compile! dfa]
+
+  module_function
+
+  def verify
+    verify_links
+    verify_english
+    verify_tutorial
+    verify_cli_snapshot
+    verify_dsl_reference
+    puts "docs: links, language, tutorial, CLI snapshot, and DSL coverage passed"
+  end
+
+  def verify_links
+    MARKDOWN_FILES.each do |path|
+      File.read(path).scan(/\[[^\]]+\]\(([^)\s]+)(?:\s+"[^"]*")?\)/).flatten.each do |target|
+        next if target.match?(%r{\A(?:https?://|mailto:)}) || target.start_with?("#")
+
+        local_target = target.split("#", 2).first
+        resolved = File.expand_path(local_target, File.dirname(path))
+        next if File.file?(resolved) || File.directory?(resolved)
+
+        raise "broken documentation link: #{path}: #{target}"
+      end
+    end
+  end
+
+  def verify_english
+    MARKDOWN_FILES.each do |path|
+      raise "documentation contains non-English characters: #{path}" if
+        File.read(path).match?(/[ぁ-んァ-ヶ一-龯]/)
+    end
+  end
+
+  def verify_tutorial
+    spec = File.join(ROOT, "examples/calculator/lexer.flexr.rb")
+    input = "if ifx == = 12 + 3"
+    expected = [["IF", "if"], ["IDENT", "ifx"], ["EQ", "=="], ["ASSIGN", "="],
+                ["INTEGER", 12], ["PLUS", "+"], ["INTEGER", 3]]
+    runtime = ruby_json(<<~RUBY, spec, input)
+      require "json"
+      load ARGV.fetch(0)
+      puts JSON.generate(CalculatorExample::Lexer.new(ARGV.fetch(1)).tokens)
+    RUBY
+    raise "tutorial runtime output mismatch: #{runtime.inspect}" unless JSON.parse(runtime) == expected
+
+    Dir.mktmpdir("flexr-docs") do |directory|
+      output = File.join(directory, "calculator.rb")
+      stdout, stderr, status = command("examples/calculator/lexer.flexr.rb", "-o", output)
+      raise "tutorial generation failed: #{stderr}#{stdout}" unless status.success?
+
+      generated = ruby_json(<<~RUBY, output, input)
+        require "json"
+        load ARGV.fetch(0)
+        puts JSON.generate(CalculatorExample::Lexer.new(ARGV.fetch(1)).tokens)
+      RUBY
+      raise "tutorial runtime/generated mismatch" unless generated == runtime
+    end
+
+    stdout, stderr, status = command("check", spec, "--format", "json")
+    raise "tutorial check failed: #{stderr}#{stdout}" unless status.success? && JSON.parse(stdout) == []
+  end
+
+  def verify_cli_snapshot
+    output = StringIO.new
+    error = StringIO.new
+    status = Flexr::CLI.run(["--help"], out: output, err: error)
+    raise "CLI help failed: #{error.string}" unless status.zero?
+
+    page = File.read(File.join(ROOT, "docs/reference/cli.md"))
+    snapshot = page.split(MARKER_START, 2).last&.split(MARKER_END, 2)&.first
+    raise "CLI help markers are missing" unless snapshot
+    raise "CLI help snapshot is stale" unless output.string == "#{snapshot.strip}\n"
+  end
+
+  def verify_dsl_reference
+    page = File.read(File.join(ROOT, "docs/reference/dsl.md"))
+    STABLE_DSL_METHODS.each do |method_name|
+      next if page.include?("## `#{method_name}(")
+
+      raise "stable DSL method is missing from the reference: #{method_name}"
+    end
+  end
+
+  def command(*arguments)
+    Open3.capture3(RbConfig.ruby, "-Ilib", "exe/flexr", *arguments, chdir: ROOT)
+  end
+
+  def ruby_json(script, path, input)
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-Ilib", "-e", script, path, input, chdir: ROOT)
+    raise "Ruby example failed: #{stderr}" unless status.success?
+
+    stdout.strip
+  end
+end
+
+FlexrDocumentation.verify

data/tools/gen_unicode_tables.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Generate the vendored Unicode snapshot from the Unicode Character Database.
+# This tool intentionally never asks the host Ruby Regexp implementation for
+# a property set: changing the Ruby version must not change generated output.
+
+require "fileutils"
+
+input = ARGV.fetch(0) { abort "usage: gen_unicode_tables.rb UCD_DIRECTORY OUTPUT_DIRECTORY" }
+output = ARGV.fetch(1) { abort "usage: gen_unicode_tables.rb UCD_DIRECTORY OUTPUT_DIRECTORY" }
+FileUtils.mkdir_p(output)
+
+def parse_ranges(path, property: nil)
+  ranges = []
+  File.foreach(path, encoding: "UTF-8") do |line|
+    body, _comment = line.split("#", 2)
+    fields = body.strip.split(";").map(&:strip)
+    next if fields.empty? || fields.first.empty?
+    next if property && fields[1] != property
+
+    first, last = fields.first.split("..", 2).map { |value| Integer(value, 16) }
+    last ||= first
+    ranges << [first, last]
+  end
+  merge_ranges(ranges)
+end
+
+def merge_ranges(ranges)
+  ranges.sort_by(&:first).each_with_object([]) do |range, merged|
+    if merged.empty? || range.first > merged.last.last + 1
+      merged << range.dup
+    else
+      merged.last[1] = [merged.last.last, range.last].max
+    end
+  end
+end
+
+def unicode_version(input)
+  readme = File.join(input, "ReadMe.txt")
+  text = File.file?(readme) ? File.read(readme) : ""
+  text[/Version[- ]([0-9]+\.[0-9]+\.[0-9]+)/, 1] ||
+    text[/Unicode\s+([0-9]+\.[0-9]+\.[0-9]+)/i, 1] || "unknown"
+end
+
+def category_ranges(path, categories)
+  unicode_data_ranges(path, categories: Array(categories))
+end
+
+def unicode_data_ranges(path, categories: nil)
+  selected_categories = categories && Array(categories)
+  ranges = []
+  first = last = nil
+  current_category = nil
+  File.foreach(path, encoding: "UTF-8") do |line|
+    body = line.split("#", 2).first
+    fields = body.strip.split(";")
+    next if fields.length < 3
+
+    codepoint = Integer(fields[0], 16)
+    name = fields[1]
+    category = fields[2]
+    if name.end_with?(", First>")
+      first = codepoint
+      current_category = category
+    elsif name.end_with?(", Last>") && first
+      last = codepoint
+      ranges << [first, last] if selected_categories.nil? || selected_categories.include?(current_category)
+      first = last = current_category = nil
+    elsif selected_categories.nil? || selected_categories.include?(category)
+      ranges << [codepoint, codepoint]
+    end
+  end
+  merge_ranges(ranges)
+end
+
+def property_file_ranges(path, names)
+  names = Array(names)
+  selected = []
+  File.foreach(path, encoding: "UTF-8") do |line|
+    body = line.split("#", 2).first
+    fields = body.strip.split(";").map(&:strip)
+    next if fields.length < 2 || !names.include?(fields[1])
+
+    first, last = fields.first.split("..", 2).map { |value| Integer(value, 16) }
+    last ||= first
+    selected << [first, last]
+  end
+  merge_ranges(selected)
+end
+
+def property_names(path)
+  names = {}
+  File.foreach(path, encoding: "UTF-8") do |line|
+    body = line.split("#", 2).first
+    fields = body.strip.split(";").map(&:strip)
+    names[fields[1]] = true if fields.length >= 2 && !fields[1].empty?
+  end
+  names.keys.sort
+end
+
+def complement_ranges(ranges, maximum: 0x10ffff)
+  result = []
+  cursor = 0
+  ranges.each do |first, last|
+    result << [cursor, first - 1] if cursor < first
+    cursor = [cursor, last + 1].max
+  end
+  result << [cursor, maximum] if cursor <= maximum
+  result
+end
+
+def case_fold_table(path)
+  table = {}
+  File.foreach(path, encoding: "UTF-8") do |line|
+    body = line.split("#", 2).first
+    fields = body.strip.split(";").map(&:strip)
+    next unless fields.length >= 3 && %w[C S].include?(fields[1])
+
+    mapping = fields[2].split.map { |value| Integer(value, 16) }
+    table[Integer(fields[0], 16)] = mapping.first if mapping.length == 1
+  end
+  table
+end
+
+unicode_data = File.join(input, "UnicodeData.txt")
+scripts = File.join(input, "Scripts.txt")
+prop_list = File.join(input, "PropList.txt")
+case_folding = File.join(input, "CaseFolding.txt")
+[unicode_data, scripts, prop_list, case_folding].each do |path|
+  abort "missing UCD file: #{path}" unless File.file?(path)
+end
+
+properties = {
+  "L" => category_ranges(unicode_data, %w[Lu Ll Lt Lm Lo]),
+  "Letter" => category_ranges(unicode_data, %w[Lu Ll Lt Lm Lo]),
+  "N" => category_ranges(unicode_data, %w[Nd Nl No]),
+  "Number" => category_ranges(unicode_data, %w[Nd Nl No]),
+  "Nd" => category_ranges(unicode_data, ["Nd"]),
+  "ASCII" => [[0, 0x7f]],
+  "Alphabetic" => merge_ranges(category_ranges(unicode_data, %w[Lu Ll Lt Lm Lo Nl]) +
+                                 property_file_ranges(prop_list, ["Other_Alphabetic"])),
+  "Other_Alphabetic" => property_file_ranges(prop_list, ["Other_Alphabetic"]),
+  "Alnum" => merge_ranges(category_ranges(unicode_data, %w[Lu Ll Lt Lm Lo Nd Nl No]) +
+                           property_file_ranges(prop_list, ["Other_Alphabetic"])),
+  "Word" => merge_ranges(category_ranges(unicode_data, %w[Lu Ll Lt Lm Lo Nd Nl No]) +
+                          property_file_ranges(prop_list, ["Other_Alphabetic"]) + [[0x5f, 0x5f]]),
+  "Space" => property_file_ranges(prop_list, ["White_Space"]),
+  "XDigit" => [[0x30, 0x39], [0x41, 0x46], [0x61, 0x66]],
+  "Cntrl" => [[0, 0x1f], [0x7f, 0x9f]],
+  "Lowercase" => merge_ranges(category_ranges(unicode_data, ["Ll"]) +
+                               property_file_ranges(prop_list, ["Other_Lowercase"])),
+  "Uppercase" => merge_ranges(category_ranges(unicode_data, ["Lu"]) +
+                               property_file_ranges(prop_list, ["Other_Uppercase"]))
+}
+%w[Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs].each do |category|
+  properties[category] = category_ranges(unicode_data, [category])
+end
+properties["Cn"] = complement_ranges(unicode_data_ranges(unicode_data))
+{
+  "C" => %w[Cc Cf Cn Co Cs], "M" => %w[Mc Me Mn], "P" => %w[Pc Pd Pe Pf Pi Po Ps],
+  "S" => %w[Sc Sk Sm So], "Z" => %w[Zl Zp Zs], "LC" => %w[Lt Lu Ll]
+}.each do |name, categories|
+  properties[name] = category_ranges(unicode_data, categories)
+end
+properties["C"] = merge_ranges(properties.fetch("C") + properties.fetch("Cn"))
+
+property_names(scripts).each do |script|
+  properties[script] = property_file_ranges(scripts, [script])
+end
+properties["Any"] = [[0, 0x10ffff]]
+properties["Assigned"] = complement_ranges(properties.fetch("Cn"))
+
+version = unicode_version(input)
+File.write(File.join(output, "UNICODE_VERSION"), "#{version}\n")
+source = <<~RUBY
+  # frozen_string_literal: true
+
+  module Flexr
+    module Unicode
+      module Data
+        VERSION = #{version.inspect}
+        PROPERTIES = #{properties.inspect}.freeze
+      end
+    end
+  end
+RUBY
+File.write(File.join(output, "properties.rb"), source)
+
+fold_source = <<~RUBY
+  # frozen_string_literal: true
+
+  module Flexr
+    module Unicode
+      module Data
+        CASE_FOLD = #{case_fold_table(case_folding).inspect}.freeze
+      end
+    end
+  end
+RUBY
+File.write(File.join(output, "case_folding.rb"), fold_source)
+puts "Unicode #{version}: generated #{properties.length} property tables"

data/tools/regexp_tokenizer_reference.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module FlexrVerification
+  module RegexpTokenizerReference
+    module_function
+
+    class UnmatchedInputError < StandardError
+      attr_reader :offset, :byte
+
+      def initialize(offset:, byte:)
+        @offset = offset
+        @byte = byte
+        super(format("reference tokenizer could not match byte at offset %<offset>d (0x%<byte>02x)",
+                     offset: offset, byte: byte))
+      end
+    end
+
+    RULES = [
+      [/[ \t\r\n]+/, ->(_text) {}],
+      [/\\p\{[A-Za-z_][A-Za-z0-9_]*\}/, ->(text) { [:PROPERTY, text.byteslice(3...-1)] }],
+      [/\\./, ->(text) { [:ESCAPE, text] }],
+      [/\[[^\]\n]*\]/, ->(text) { [:CHAR_CLASS, text] }],
+      [/[?*+]|\{[0-9]+(?:,[0-9]*)?\}/, ->(text) { [:QUANTIFIER, text] }],
+      [/\|/, ->(text) { [:ALTERNATION, text] }],
+      [/\(/, ->(text) { [:GROUP_OPEN, text] }],
+      [/\)/, ->(text) { [:GROUP_CLOSE, text] }],
+      [/\^|\$/, ->(text) { [:ANCHOR, text] }],
+      [/\./, ->(text) { [:DOT, text] }],
+      [/[^\\\[\]().|?*+{}^$ \t\r\n]/, ->(text) { [:LITERAL, text] }]
+    ].freeze
+    BYTE_RULES = RULES.map do |pattern, action|
+      [Regexp.new(pattern.source, pattern.options | ::Regexp::NOENCODING), action]
+    end.freeze
+
+    def tokens(input)
+      source = input.b
+      position = 0
+      result = []
+      while position < source.bytesize
+        match = match_at(source, position)
+        raise UnmatchedInputError.new(offset: position, byte: source.getbyte(position)) unless match
+
+        matched_text, action = match
+        text = input.byteslice(position, matched_text.bytesize)
+        position += matched_text.bytesize
+        token = action.call(text)
+        result << token if token
+      end
+      result
+    end
+
+    def match_at(source, position)
+      BYTE_RULES.each do |pattern, action|
+        candidate = pattern.match(source, position)
+        return [candidate[0], action] if candidate&.begin(0) == position
+      end
+      nil
+    end
+  end
+end

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification
+name: flexr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby DSL and source generator for deterministic byte-oriented lexers.
+email:
+- t.yudai92@gmail.com
+executables:
+- flexr
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/baselines/json.json
+- benchmark/baselines/json_handwritten.rb
+- benchmark/baselines/json_rexical.rex
+- benchmark/corpora/README.md
+- benchmark/corpora/generate_json.rb
+- benchmark/golden/calculator_lexer.sha256
+- benchmark/golden/json_lexer.sha256
+- benchmark/golden/regexp_tokenizer.sha256
+- benchmark/golden/ruby_subset_lexer.sha256
+- benchmark/golden/toy_lang_lexer.sha256
+- benchmark/golden/with_lrama_lexer.sha256
+- benchmark/golden/with_racc_lexer.sha256
+- benchmark/run.rb
+- docs/README.md
+- docs/RELEASING.md
+- docs/adr/0001-byte-level-dfa.md
+- docs/adr/0003-leftmost-longest.md
+- docs/adr/0006-accel-not-scanner.md
+- docs/adr/0008-what-pure-ruby-means.md
+- docs/adr/0016-spec-is-plain-ruby.md
+- docs/adr/0017-static-analysis-by-default.md
+- docs/adr/0018-prism-for-generator-only.md
+- docs/adr/0019-measured-performance-floor.md
+- docs/adr/0020-vendored-unicode-contract.md
+- docs/explanation/backends.md
+- docs/explanation/matching-semantics.md
+- docs/explanation/runtime-vs-generated.md
+- docs/explanation/security-model.md
+- docs/explanation/unicode-and-encoding.md
+- docs/how-to/deploy-a-standalone-lexer.md
+- docs/how-to/generate-a-lexer.md
+- docs/how-to/handle-errors.md
+- docs/how-to/integrate-with-lrama.md
+- docs/how-to/integrate-with-racc.md
+- docs/how-to/migrate-from-flex.md
+- docs/how-to/migrate-from-rexical.md
+- docs/how-to/run-a-lexer-at-runtime.md
+- docs/how-to/track-token-locations.md
+- docs/how-to/tune-performance.md
+- docs/how-to/use-states.md
+- docs/how-to/use-trailing-context.md
+- docs/internals/README.md
+- docs/perf-log.md
+- docs/reference/README.md
+- docs/reference/actions.md
+- docs/reference/cli.md
+- docs/reference/compatibility.md
+- docs/reference/diagnostics.md
+- docs/reference/dsl.md
+- docs/reference/errors.md
+- docs/reference/generated-artifacts.md
+- docs/reference/public-api.md
+- docs/reference/regexp.md
+- docs/reference/runtime.md
+- docs/reference/tokens-and-locations.md
+- docs/tutorial/build-a-calculator-lexer.md
+- examples/calculator/README.md
+- examples/calculator/lexer.flexr.rb
+- examples/json/README.md
+- examples/json/lexer.flexr.rb
+- examples/ruby_subset/README.md
+- examples/ruby_subset/lexer.flexr.rb
+- examples/toy_lang/README.md
+- examples/toy_lang/lexer.flexr.rb
+- examples/with_lrama/README.md
+- examples/with_lrama/lexer.flexr.rb
+- examples/with_racc/README.md
+- examples/with_racc/lexer.flexr.rb
+- exe/flexr
+- lib/flexr.rb
+- lib/flexr/automaton/accel.rb
+- lib/flexr/automaton/analysis.rb
+- lib/flexr/automaton/byte_class_set.rb
+- lib/flexr/automaton/compiler.rb
+- lib/flexr/automaton/dfa.rb
+- lib/flexr/automaton/minimizer.rb
+- lib/flexr/automaton/nfa.rb
+- lib/flexr/cli.rb
+- lib/flexr/codegen/base.rb
+- lib/flexr/codegen/direct.rb
+- lib/flexr/codegen/firstmatch.rb
+- lib/flexr/codegen/table.rb
+- lib/flexr/codegen/table_packer.rb
+- lib/flexr/diagnostics.rb
+- lib/flexr/dsl.rb
+- lib/flexr/errors.rb
+- lib/flexr/generated.rb
+- lib/flexr/generator.rb
+- lib/flexr/importer.rb
+- lib/flexr/ir.rb
+- lib/flexr/lexer.rb
+- lib/flexr/options.rb
+- lib/flexr/rake_task.rb
+- lib/flexr/regexp/ast.rb
+- lib/flexr/regexp/char_class.rb
+- lib/flexr/regexp/normalizer.rb
+- lib/flexr/regexp/parser.rb
+- lib/flexr/regexp/tokenizer.flexr.rb
+- lib/flexr/regexp/tokenizer.rb
+- lib/flexr/regexp/unsupported.rb
+- lib/flexr/runtime/buffer.rb
+- lib/flexr/runtime/core.rb
+- lib/flexr/runtime/errors.rb
+- lib/flexr/runtime/interpreter.rb
+- lib/flexr/runtime/location.rb
+- lib/flexr/runtime/token.rb
+- lib/flexr/source/passthrough.rb
+- lib/flexr/source/prism_reader.rb
+- lib/flexr/source/static_eval.rb
+- lib/flexr/unicode/case_fold.rb
+- lib/flexr/unicode/data/LICENSE-UNICODE.txt
+- lib/flexr/unicode/data/UNICODE_VERSION
+- lib/flexr/unicode/data/case_folding.rb
+- lib/flexr/unicode/data/properties.rb
+- lib/flexr/unicode/property.rb
+- lib/flexr/unicode/reference_regexp.rb
+- lib/flexr/unicode/utf8_splitter.rb
+- lib/flexr/version.rb
+- site/README.md
+- site/astro.config.mjs
+- site/package.json
+- site/pnpm-lock.yaml
+- site/pnpm-workspace.yaml
+- site/public/playground.js
+- site/scripts/verify-site.mjs
+- site/src/content.config.ts
+- site/src/content/docs/benchmarks.md
+- site/src/content/docs/concepts/matching-semantics.md
+- site/src/content/docs/concepts/regexp-model.md
+- site/src/content/docs/concepts/runtime-vs-generated.md
+- site/src/content/docs/concepts/security-model.md
+- site/src/content/docs/examples.md
+- site/src/content/docs/learn/generation.md
+- site/src/content/docs/learn/getting-started.md
+- site/src/content/docs/learn/parser-integration.md
+- site/src/content/docs/learn/runtime-mode.md
+- site/src/content/docs/reference/action-context.md
+- site/src/content/docs/reference/cli.md
+- site/src/content/docs/reference/diagnostics.md
+- site/src/content/docs/reference/dsl.md
+- site/src/content/docs/reference/public-api.md
+- site/src/content/docs/reference/regexp.md
+- site/src/content/docs/reference/runtime.md
+- site/src/content/docs/reference/tokens-and-locations.md
+- site/src/env.d.ts
+- site/src/layouts/SiteLayout.astro
+- site/src/pages/index.astro
+- site/src/pages/playground.astro
+- site/src/styles/custom.css
+- site/tsconfig.json
+- tools/coverage.rb
+- tools/docs_verify.rb
+- tools/gen_unicode_tables.rb
+- tools/regexp_tokenizer_reference.rb
+homepage: https://github.com/ydah/flexr
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  generator_ruby_version: ">= 3.3 (Prism)"
+  homepage_uri: https://github.com/ydah/flexr
+  source_code_uri: https://github.com/ydah/flexr/tree/main
+  bug_tracker_uri: https://github.com/ydah/flexr/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby-native lexer generator with runtime and generated modes
+test_files: []