regexgen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46f71792a530cbee9556f1d401be2095c27b89d177c8cfbb0a5a2bacbdbb4c43
+  data.tar.gz: 749f8d8e47d1539239e47d7c19ad688fd7056d75278a94a7dd555248a3649f9b
+SHA512:
+  metadata.gz: 03f4f12753dee716dadde7e6b3e244356327506ec598a5ffec93427cfb42dd20ff2732005a8907915d7155300fbe4511aaf857b19eb123d35a8463598e29d3e8
+  data.tar.gz: 89490be6ae578fde9e753221afdaa1d83767af9e77f638b6d788d3b632f22d81ac608740d7e22c15edd9145d706aee3f333343e013e1bc5b9cf4ab529e568f5e

data/.github/workflows/main.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup Ruby, JRuby and TruffleRuby
+      uses: ruby/setup-ruby@v1.40.0
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rake test
+    - name: Lint
+      run: bundle exec rubocop

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history

data/.rubocop.yml

@@ -0,0 +1,84 @@
+inherit_from: .rubocop_todo.yml
+
+Style/AsciiComments:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Exclude:
+    - 'lib/regexgen/regex.rb'
+    - 'lib/regexgen/ast.rb'
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: true
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+Lint/DuplicateElsifCondition:
+  Enabled: true
+Lint/DuplicateRescueException:
+  Enabled: true
+Lint/EmptyConditionalBody:
+  Enabled: true
+Lint/FloatComparison:
+  Enabled: true
+Lint/MissingSuper:
+  Enabled: true
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+Lint/OutOfRangeRegexpRef:
+  Enabled: true
+Lint/RaiseException:
+  Enabled: true
+Lint/SelfAssignment:
+  Enabled: true
+Lint/StructNewOverride:
+  Enabled: true
+Lint/TopLevelReturnWithArgument:
+  Enabled: true
+Lint/UnreachableLoop:
+  Enabled: true
+Style/AccessorGrouping:
+  Enabled: true
+Style/ArrayCoercion:
+  Enabled: true
+Style/BisectedAttrAccessor:
+  Enabled: true
+Style/CaseLikeIf:
+  Enabled: true
+Style/ExplicitBlockArgument:
+  Enabled: true
+Style/ExponentialNotation:
+  Enabled: true
+Style/GlobalStdStream:
+  Enabled: true
+Style/HashAsLastArrayItem:
+  Enabled: true
+Style/HashEachMethods:
+  Enabled: true
+Style/HashLikeCase:
+  Enabled: true
+Style/HashTransformKeys:
+  Enabled: true
+Style/HashTransformValues:
+  Enabled: true
+Style/OptionalBooleanParameter:
+  Enabled: true
+Style/RedundantAssignment:
+  Enabled: true
+Style/RedundantFetchBlock:
+  Enabled: true
+Style/RedundantFileExtensionInRequire:
+  Enabled: true
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+Style/RedundantRegexpEscape:
+  Enabled: true
+Style/SingleArgumentDig:
+  Enabled: true
+Style/SlicingWithRange:
+  Enabled: true
+Style/StringConcatenation:
+  Enabled: true

data/.rubocop_todo.yml

@@ -0,0 +1,43 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2020-08-10 13:40:30 UTC using RuboCop version 0.89.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 5
+# Configuration parameters: IgnoredMethods.
+Metrics/AbcSize:
+  Max: 66
+
+# Offense count: 7
+# Configuration parameters: IgnoredMethods.
+Metrics/CyclomaticComplexity:
+  Max: 22
+
+# Offense count: 6
+# Configuration parameters: CountComments, CountAsOne, ExcludedMethods.
+Metrics/MethodLength:
+  Max: 39
+
+# Offense count: 1
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ModuleLength:
+  Max: 103
+
+# Offense count: 6
+# Configuration parameters: IgnoredMethods.
+Metrics/PerceivedComplexity:
+  Max: 24
+
+# Offense count: 5
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/regexgen/minimize.rb'
+    - 'lib/regexgen/regex.rb'
+    - 'lib/regexgen/set.rb'
+    - 'lib/regexgen/state.rb'
+    - 'lib/regexgen/trie.rb'

data/.ruby-version

@@ -0,0 +1 @@
+2.6.5

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in regexgen.gemspec
+gemspec
+
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 12.0'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    regexgen (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.1)
+    byebug (11.1.3)
+    minitest (5.14.1)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    regexp_parser (1.7.1)
+    rexml (3.2.4)
+    rubocop (0.89.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.1.0, < 1.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    ruby-progressbar (1.10.1)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug (~> 11)
+  minitest (~> 5.0)
+  rake (~> 12.0)
+  regexgen!
+  rubocop (~> 0.89)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Aaron Madlon-Kay
+
+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,85 @@
+# regexgen
+
+Generate regular expressions that match a set of strings.
+
+This is a Ruby port of [@devongovett](https://github.com/devongovett/regexgen)'s
+JavaScript [regexgen](https://github.com/devongovett/regexgen) package.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'regexgen'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install regexgen
+
+## Usage
+
+```ruby
+require 'regexgen'
+
+Regexgen.generate(['foobar', 'foobaz', 'foozap', 'fooza']) #=> /foo(?:zap?|ba[rz])/
+```
+
+## Unicode handling
+
+Unlike the JavaScript version, this package does not do any special Unicode
+handling because Ruby does it all for you. You are recommended to use a Unicode
+encoding for your strings.
+
+## How does it work?
+
+Just like the JavaScript version:
+
+1. Generate a [Trie](https://en.wikipedia.org/wiki/Trie) containing all of the
+   input strings. This is a tree structure where each edge represents a single
+   character. This removes redundancies at the start of the strings, but common
+   branches further down are not merged.
+
+2. A trie can be seen as a tree-shaped deterministic finite automaton (DFA), so
+   DFA algorithms can be applied. In this case, we apply [Hopcroft's DFA
+   minimization
+   algorithm](https://en.wikipedia.org/wiki/DFA_minimization#Hopcroft.27s_algorithm)
+   to merge the nondistinguishable states.
+
+3. Convert the resulting minimized DFA to a regular expression. This is done
+   using [Brzozowski's algebraic
+   method](http://cs.stackexchange.com/questions/2016/how-to-convert-finite-automata-to-regular-expressions#2392),
+   which is quite elegant. It expresses the DFA as a system of equations which
+   can be solved for a resulting regex. Along the way, some additional
+   optimizations are made, such as hoisting common substrings out of an
+   alternation, and using character class ranges. This produces an an [Abstract
+   Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST) for
+   the regex, which is then converted to a string and compiled to a Ruby
+   `Regexp` object.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/amake/regexgen.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'regexgen'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/regexgen.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'regexgen/version'
+require 'regexgen/trie'
+
+# Generate regular expressions that match a set of strings
+module Regexgen
+  class <<self
+    def generate(strings, flags = nil)
+      Trie.new.tap { |t| strings.each(&t.method(:add)) }
+          .to_regex(flags)
+    end
+  end
+end

data/lib/regexgen/ast.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Regexgen
+  # Classes in the abstract syntax tree representation
+  module Ast
+    # Represents an alternation (e.g. `foo|bar`)
+    class Alternation
+      attr_reader :precedence, :options
+
+      def initialize(*options)
+        @precedence = 1
+        @options = flatten(options).sort { |a, b| b.length - a.length }
+      end
+
+      def length
+        @options[0].length
+      end
+
+      def to_s
+        @options.map { |o| Ast.parens(o, self) }.join('|')
+      end
+
+      private
+
+      def flatten(options)
+        options.map { |option| option.is_a?(Alternation) ? flatten(option.options) : option }
+               .flatten
+      end
+    end
+
+    # Represents a character class (e.g. [0-9a-z])
+    class CharClass
+      attr_reader :precedence
+
+      def initialize(a, b)
+        @precedence = 1
+        @set = [a, b].flatten
+      end
+
+      def length
+        1
+      end
+
+      def single_character?
+        @set.none? { |c| c.ord > 0xffff }
+      end
+
+      def single_codepoint?
+        true
+      end
+
+      def to_s
+        "[#{to_ranges_string}]"
+      end
+
+      def char_class
+        @set
+      end
+
+      private
+
+      def to_ranges_string
+        to_ranges.map do |first, last|
+          if first == last
+            first
+          elsif first.ord.next == last.ord
+            "#{first}#{last}"
+          else
+            "#{first}-#{last}"
+          end
+        end.join
+      end
+
+      def to_ranges
+        set = @set.sort
+        ranges = [[set.first, set.first]]
+        set.drop(1).each_with_object(ranges) do |c, acc|
+          if acc.last.last.ord.next == c.ord
+            acc.last[-1] = c
+          else
+            acc << [c, c]
+          end
+        end
+      end
+    end
+
+    # Represents a concatenation (e.g. `foo`)
+    class Concatenation
+      attr_reader :precedence, :a, :b
+
+      def initialize(a, b)
+        @precedence = 2
+        @a = a
+        @b = b
+      end
+
+      def length
+        @a.length + @b.length
+      end
+
+      def to_s
+        Ast.parens(@a, self) + Ast.parens(@b, self)
+      end
+
+      def literal(side)
+        return @a.literal(side) if side == :start && @a.respond_to?(:literal)
+
+        @b.literal(side) if side == :end && @b.respond_to?(:literal)
+      end
+
+      def remove_substring(side, len)
+        a = @a
+        b = @b
+        a = @a.remove_substring(side, len) if side == :start && @a.respond_to?(:remove_substring)
+        b = @b.remove_substring(side, len) if side == :end && @b.respond_to?(:remove_substring)
+
+        return b if a.respond_to?(:empty?) && a.empty?
+        return a if b.respond_to?(:empty?) && b.empty?
+
+        Concatenation.new(a, b)
+      end
+    end
+
+    # Represents a repetition (e.g. `a*` or `a?`)
+    class Repetition
+      attr_reader :precedence, :expr, :type
+
+      def initialize(expr, type)
+        @precedence = 3
+        @expr = expr
+        @type = type
+      end
+
+      def length
+        @expr.length
+      end
+
+      def to_s
+        Ast.parens(@expr, self) + @type
+      end
+    end
+
+    # Represents a literal (e.g. a string)
+    class Literal
+      attr_reader :precedence, :value
+
+      def initialize(value)
+        @precedence = 2
+        @value = value
+      end
+
+      def empty?
+        @value.empty?
+      end
+
+      def single_character?
+        length == 1
+      end
+
+      def single_codepoint?
+        @value.codepoints.length == 1
+      end
+
+      def length
+        @value.length
+      end
+
+      def to_s
+        Regexp.escape(@value)
+      end
+
+      def char_class
+        @value if single_codepoint?
+      end
+
+      def literal(_side = nil)
+        @value
+      end
+
+      def remove_substring(side, len)
+        return Literal.new(@value[len..]) if side == :start
+        return Literal.new(@value[0...(@value.length - len)]) if side == :end
+      end
+    end
+
+    class<<self
+      def parens(exp, parent)
+        str = exp.to_s
+        if exp.precedence < parent.precedence
+          unless exp.respond_to?(:single_character?) && exp.single_character?
+            return "(?:#{str})" unless exp.respond_to?(:single_codepoint?) && exp.single_codepoint?
+          end
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/regexgen/minimize.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'regexgen/set'
+
+module Regexgen
+  using SetUtil
+
+  class<<self
+    # Hopcroft's DSA minimization algorithm
+    # https://en.wikipedia.org/wiki/DFA_minimization#Hopcroft's_algorithm
+    #
+    # Largely ported from
+    # https://github.com/devongovett/regexgen/blob/7ef10aef3a414b10554822cdf6e90389582b1890/src/minimize.js
+    #
+    #   P := {F, Q \ F};
+    #   W := {F, Q \ F};
+    #   while (W is not empty) do
+    #        choose and remove a set A from W
+    #        for each c in Σ do
+    #             let X be the set of states for which a transition on c leads to a state in A
+    #             for each set Y in P for which X ∩ Y is nonempty and Y \ X is nonempty do
+    #                  replace Y in P by the two sets X ∩ Y and Y \ X
+    #                  if Y is in W
+    #                       replace Y in W by the same two sets
+    #                  else
+    #                       if |X ∩ Y| <= |Y \ X|
+    #                            add X ∩ Y to W
+    #                       else
+    #                            add Y \ X to W
+    #             end;
+    #        end;
+    #   end;
+    #
+    # Key:
+    #
+    # {...} is a Set (yes we have sets of sets here)
+    # A \ B is complement (A - B)
+    # Q is all states
+    # F is final states
+    # Σ is the DFA's alphabet
+    # c is a letter of the alphabet
+    # A ∩ B is intersection (A & B)
+    # |A| is the cardinality of A (A.size)
+    def minimize(root, alphabet)
+      states = root.visit
+      final_states = states.select(&:accepting).to_set
+
+      p = Set[states, final_states]
+      w = Set.new(p)
+      until w.empty?
+        a = w.shift
+        alphabet.each do |c|
+          x = states.each_with_object(Set.new) do |s, acc|
+            next unless s.transitions.key?(c)
+
+            acc.add(s) if a.include?(s.transitions[c])
+          end
+          p.to_a.each do |y|
+            intersection = x & y
+            next if intersection.empty?
+
+            complement = y - x
+            next if complement.empty?
+
+            p.replace(y, intersection, complement)
+            if w.include?(y)
+              w.replace(y, intersection, complement)
+            elsif intersection.size <= complement.size
+              w.add(intersection)
+            else
+              w.add(complement)
+            end
+          end
+        end
+      end
+
+      new_states = Hash.new { |hash, key| hash[key] = State.new }
+      initial = nil
+
+      p.each do |s|
+        first = s.first
+        s_ = new_states[s]
+        first.transitions.each do |c, old|
+          s_.transitions[c] = new_states[p.find { |v| v.include?(old) }]
+        end
+
+        s_.accepting = first.accepting
+
+        initial = s_ if s.include?(root)
+      end
+
+      initial
+    end
+  end
+end

data/lib/regexgen/regex.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'regexgen/ast'
+
+module Regexgen
+  class<<self
+    def to_regex(root)
+      states = root.visit.to_a
+
+      a = []
+      b = []
+
+      states.each_with_index do |a_, i|
+        b[i] = Ast::Literal.new('') if a_.accepting
+
+        a[i] = []
+        a_.transitions.each do |t, s|
+          j = states.index(s)
+          a[i][j] = a[i][j] ? union(a[i][j], Ast::Literal.new(t)) : Ast::Literal.new(t)
+        end
+      end
+
+      (states.length - 1).downto(0) do |n|
+        if a[n][n]
+          b[n] = concat(star(a[n][n], b[n]))
+          (0...n).each do |j|
+            a[n][j] = concat(start(a[n][n]), a[n][j])
+          end
+        end
+
+        (0...n).each do |i|
+          next unless a[i][n]
+
+          b[i] = union(b[i], concat(a[i][n], b[n]))
+          (0...n).each do |j|
+            a[i][j] = union(a[i][j], concat(a[i][n], a[n][j]))
+          end
+        end
+      end
+
+      b[0].to_s
+    end
+
+    def star(exp)
+      Ast::Repetition.new(exp, '*') if exp
+    end
+
+    def union(a, b)
+      if a && b && a != b
+        res = nil
+        a, b, start = remove_common_substring(a, b, :start)
+        a, b, end_ = remove_common_substring(a, b, :end)
+
+        if (a.respond_to?(:empty?) && a.empty?) || (b.respond_to?(:empty?) && b.empty?)
+          res = Ast::Repetition.new(a.empty? ? b : a, '?')
+        elsif a.is_a?(Ast::Repetition) && a.type == '?'
+          res = Ast::Repetition.new(Ast::Alternation.new(a.expr, b), '?')
+        elsif b.is_a?(Ast::Repetition) && b.type == '?'
+          res = Ast::Repetition.new(Ast::Alternation.new(a, b.expr), '?')
+        else
+          ac = a.char_class if a.respond_to?(:char_class)
+          bc = b.char_class if b.respond_to?(:char_class)
+          res = if ac && bc
+                  Ast::CharClass.new(ac, bc)
+                else
+                  Ast::Alternation.new(a, b)
+                end
+        end
+
+        res = Ast::Concatenation.new(Ast::Literal.new(start), res) unless start.nil? || start.empty?
+
+        res = Ast::Concatenation.new(res, Ast::Literal.new(end_)) unless end_.nil? || end_.empty?
+
+        return res
+      end
+
+      a || b
+    end
+
+    def remove_common_substring(a, b, side)
+      al = a.literal(side) if a.respond_to?(:literal)
+      bl = b.literal(side) if b.respond_to?(:literal)
+      return [a, b, nil] if al.nil? || bl.nil? || al.empty? || bl.empty?
+
+      s = common_substring(al, bl, side)
+      return [a, b, ''] if s.empty?
+
+      a = a.remove_substring(side, s.length)
+      b = b.remove_substring(side, s.length)
+
+      [a, b, s]
+    end
+
+    def common_substring(a, b, side)
+      dir = side == :start ? 1 : -1
+      a = a.chars
+      b = b.chars
+      ai = dir == 1 ? 0 : a.length - 1
+      ae = dir == 1 ? a.length : -1
+      bi = dir == 1 ? 0 : b.length - 1
+      be = dir == 1 ? b.length : -1
+      res = ''
+
+      while ai != ae && bi != be && a[ai] == b[bi]
+        if dir == 1
+          res += a[ai]
+        else
+          res = a[ai] + res
+        end
+        ai += dir
+        bi += dir
+      end
+
+      res
+    end
+
+    def concat(a, b)
+      return unless a && b
+
+      return b if a.respond_to?(:empty?) && a.empty?
+      return a if b.respond_to?(:empty?) && b.empty?
+
+      return Ast::Literal.new(a.value + b.value) if a.is_a?(Ast::Literal) && b.is_a?(Ast::Literal)
+
+      if a.is_a?(Ast::Literal) && b.is_a?(Ast::Concatenation) && b.a.is_a?(Ast::Literal)
+        return Ast::Concatenation.new(Ast::Literal.new(a.value + b.a.value), b.b)
+      end
+
+      if b.is_a?(Ast::Literal) && a.is_a?(Ast::Concatenation) && a.b.is_a?(Ast::Literal)
+        return Ast::Concatenation.new(a.a, Ast::Literal.new(a.b.value + b.value))
+      end
+
+      Ast::Concatenation.new(a, b)
+    end
+  end
+end

data/lib/regexgen/set.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Regexgen
+  module SetUtil
+    refine Set do
+      def shift
+        item = first
+        delete(first)
+        item
+      end
+
+      def replace(search, *replacements)
+        raise unless delete?(search)
+
+        merge(replacements)
+      end
+    end
+  end
+end

data/lib/regexgen/state.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Regexgen
+  class State
+    attr_accessor :accepting
+    attr_reader :transitions
+
+    def initialize
+      @accepting = false
+      @transitions = Hash.new { |hash, key| hash[key] = State.new }
+    end
+
+    def visit(visited = Set.new)
+      return visited if visited.include?(self)
+
+      visited.add(self)
+      @transitions.each_value { |state| state.visit(visited) }
+      visited
+    end
+
+    def to_h
+      @transitions.transform_values(&:to_h).tap do |h|
+        h[''] = nil if @accepting
+      end
+    end
+
+    def to_s
+      sigil = @accepting ? '*' : ''
+      "#{sigil}#{to_h}"
+    end
+
+    alias inspect to_s
+  end
+end

data/lib/regexgen/trie.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'regexgen/state'
+require 'regexgen/minimize'
+require 'regexgen/regex'
+
+module Regexgen
+  class Trie
+    attr_reader :root, :alphabet
+
+    def initialize
+      @alphabet = Set.new
+      @root = State.new
+    end
+
+    def add(str)
+      node = @root
+      str.each_char do |char|
+        @alphabet.add(char)
+        node = node.transitions[char]
+      end
+      node.accepting = true
+    end
+
+    def add_all(strs)
+      strs.each(&method(:add))
+    end
+
+    def minimize
+      Regexgen.minimize(@root, @alphabet)
+    end
+
+    def to_s
+      Regexgen.to_regex(minimize)
+    end
+
+    def to_regex(flags = nil)
+      flags_i = 0
+      flags_i |= Regexp::EXTENDED if flags&.include?('x')
+      flags_i |= Regexp::IGNORECASE if flags&.include?('i')
+      flags_i |= Regexp::MULTILINE if flags&.include?('m')
+      Regexp.new(to_s, flags_i)
+    end
+  end
+end

data/lib/regexgen/version.rb

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

data/regexgen.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/regexgen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'regexgen'
+  spec.version       = Regexgen::VERSION
+  spec.authors       = ['Aaron Madlon-Kay']
+  spec.email         = ['aaron@madlon-kay.com']
+
+  spec.summary       = 'Generate a minimal regex matching a set of strings'
+  spec.homepage      = 'https://github.com/aaron/regexgen-ruby'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/aaron/regexgen-ruby.git'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'byebug', '~> 11'
+  spec.add_development_dependency 'rubocop', '~> 0.89'
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: regexgen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aaron Madlon-Kay
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.89'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.89'
+description: 
+email:
+- aaron@madlon-kay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/regexgen.rb
+- lib/regexgen/ast.rb
+- lib/regexgen/minimize.rb
+- lib/regexgen/regex.rb
+- lib/regexgen/set.rb
+- lib/regexgen/state.rb
+- lib/regexgen/trie.rb
+- lib/regexgen/version.rb
+- regexgen.gemspec
+homepage: https://github.com/aaron/regexgen-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aaron/regexgen-ruby
+  source_code_uri: https://github.com/aaron/regexgen-ruby.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Generate a minimal regex matching a set of strings
+test_files: []