super-expressive-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e5ab82376e3effc765d550ed042ba0b52b1921ace4913bc773b6cdf355b3a5f
+  data.tar.gz: 62c2947b14cd2c745e84efdacb8acb8e521526d202b08f55b3b9c4377c5d550b
+SHA512:
+  metadata.gz: 754878b3b36cb750ab0b679ce76d65e70ae60c8939e12a754ea08d4b3690bb032705a506dbc3b9d9e85f7bf286fa010d151d827f7aa9c43d341ea92884d90b1f
+  data.tar.gz: 4ff3df8c2f886a6c35e431b15e5a441c9fb5ee93f7a27c4f0d693cac15a38c9bc3ba2933c1a8f835b208547078a96027e788b7fe43ad7304427d05eef2bc055e

data/.circleci/config.yml

@@ -0,0 +1,18 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3-stretch-node
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: Run rspec
+          command: bundle exec rspec

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at hiroshi_yamasaki@eastback.jp. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in super-expressive-ruby.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Hiroshi Yamasaki
+
+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,141 @@
+# SuperExpressiveRuby
+
+This gem is a port of https://github.com/francisrstokes/super-expressive
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'super-expressive-ruby'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install super-expressive-ruby
+
+## Usage
+
+### Example
+
+<pre>
+require 'super-expressive-ruby'
+
+myRegex = SuperExpressive.create
+  .startOfInput
+  .optional.string('0x')
+  .capture
+    .exactly(4).anyOf
+      .range('A', 'F')
+      .range('a', 'f')
+      .range('0', '9')
+    .end
+  .end
+  .endOfInput
+  .toRegex;
+
+// Produces the following regular expression:
+/^(?:0x)?((?:[A-Fa-f0-9]){4})$/
+</pre>
+
+
+### Snake cases are supported as well.
+
+<pre>
+require 'super-expressive-ruby'
+
+my_regex = SuperExpressive.create
+  .start_of_input
+  .optional.string('0x')
+  .capture
+    .exactly(4).any_of
+      .range('A', 'F')
+      .range('a', 'f')
+      .range('0', '9')
+    .end
+  .end
+  .end_of_input
+  .to_regex;
+
+// Produces the following regular expression:
+/^(?:0x)?((?:[A-Fa-f0-9]){4})$/
+</pre>
+
+### API Compatibility
+
+Unsupported methods can be called but ignored.
+
+- [ ] .allowMultipleMatches (use String#gsub or String#scan' as an alternative)
+- [ ] .lineByLine (use \A or \z as an alternative)
+- [x] .caseInsensitive
+- [ ] .sticky (Ruby does not have JavaScript regular expression y option)
+- [ ] .unicode
+- [x] .singleLine
+- [x] .anyChar
+- [x] .whitespaceChar
+- [x] .nonWhitespaceChar
+- [x] .digit
+- [x] .nonDigit
+- [x] .word
+- [x] .nonWord
+- [x] .wordBoundary
+- [x] .nonWordBoundary
+- [x] .newline
+- [x] .carriageReturn
+- [x] .tab
+- [x] .nullByte
+- [x] .anyOf
+- [x] .capture
+- [x] .namedCapture(name)
+- [x] .namedBackreference(name)
+- [x] .backreference(index)
+- [x] .group
+- [x] .end()
+- [x] .assertAhead
+- [x] .assertNotAhead
+- [x] .optional
+- [x] .zeroOrMore
+- [x] .zeroOrMoreLazy
+- [x] .oneOrMore
+- [x] .oneOrMoreLazy
+- [x] .exactly(n)
+- [x] .atLeast(n)
+- [x] .between(x, y)
+- [x] .betweenLazy(x, y)
+- [x] .startOfInput
+- [x] .endOfInput
+- [x] .anyOfChars(chars)
+- [x] .anythingButChars(chars)
+- [x] .anythingButString(str)
+- [x] .anythingButRange(a, b)
+- [x] .string(s)
+- [x] .char(c)
+- [x] .range(a, b)
+- [x] .subexpression(expr, opts?)
+- [x] .toRegexString()
+- [x] .toRegex()
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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/hiy/super-expressive-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/hiy/super-expressive-ruby/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the SuperExpressiveRuby project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/hiy/super-expressive-ruby/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "super-expressive-ruby"
+
+# 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/super-expressive-ruby.rb

@@ -0,0 +1,10 @@
+require "super-expressive-ruby/version"
+
+module SuperExpressive
+  require 'super-expressive-ruby/super-expressive-ruby'
+  class Error < StandardError; end
+
+  def self.create
+    SuperExpressiveRuby.new
+  end
+end

data/lib/super-expressive-ruby/super-expressive-ruby.rb

@@ -0,0 +1,811 @@
+# frozen_string_literal: true
+
+class SuperExpressiveRuby
+  require 'active_support'
+  require "active_support/core_ext/object/deep_dup"
+
+  attr_accessor :state
+
+  NamedGroupRegex = /^[a-z]+\w*$/i.freeze
+  QuantifierTable = {
+    oneOrMore: '+',
+    oneOrMoreLazy: '+?',
+    zeroOrMore: '*',
+    zeroOrMoreLazy: '*?',
+    optional: '?',
+    exactly: proc { |times| "{#{times}}" },
+    atLeast: proc { |times| "{#{times},}" },
+    between: proc { |times| "{#{times[0]},#{times[1]}}" },
+    betweenLazy: proc { |times| "{#{times[0]},#{times[1]}}?" }
+  }.freeze
+
+  class << self
+    def evaluate(el)
+      case el[:type]
+      when 'noop'
+        ''
+      when 'anyChar'
+        '.'
+      when 'whitespaceChar'
+        '\\s'
+      when 'nonWhitespaceChar'
+        '\\S'
+      when 'digit'
+        '\\d'
+      when 'nonDigit'
+        '\\D'
+      when 'word'
+        '\\w'
+      when 'nonWord'
+        '\\W'
+      when 'wordBoundary'
+        '\\b'
+      when 'nonWordBoundary'
+        '\\B'
+      when 'startOfInput'
+        '^'
+      when 'endOfInput'
+        '$'
+      when 'newline'
+        '\\n'
+      when 'carriageReturn'
+        '\\r'
+      when 'tab'
+        '\\t'
+      when 'nullByte'
+        '\\0'
+      when 'string'
+        el[:value]
+      when 'char'
+        el[:value]
+      when 'range'
+        "[#{el[:value][0]}-#{el[:value][1]}]"
+      when 'anythingButRange'
+        "[^#{el[:value][0]}-#{el[:value][1]}]"
+      when 'anyOfChars'
+        "[#{el[:value]}]"
+      when 'anythingButChars'
+        "[^#{el[:value]}]"
+      when 'namedBackreference'
+        "\\k<#{el[:name]}>"
+      when 'backreference'
+        "\\#{el[:index]}"
+      when 'subexpression'
+        el[:value].map { |value| evaluate(value) }.join('')
+      when 'optional',
+           'zeroOrMore',
+           'zeroOrMoreLazy',
+           'oneOrMore',
+           'oneOrMoreLazy'
+        inner = evaluate(el[:value])
+        with_group =
+          if el[:value][:quantifierRequiresGroup]
+            "(?:#{inner})"
+          else
+            inner
+          end
+        symbol = QuantifierTable[el[:type].to_sym]
+        "#{with_group}#{symbol}"
+      when 'betweenLazy',
+      'between',
+      'atLeast',
+      'exactly'
+        inner = evaluate(el[:value])
+        withGroup =
+          if el[:value][:quantifierRequiresGroup]
+            "(?:#{inner})"
+          else
+            inner
+          end
+        "#{withGroup}#{QuantifierTable[el[:type].to_sym].call(el[:times])}"
+      when 'anythingButString'
+        chars = el[:value].split('').map { |c| "[^#{c}]" }.join('')
+        "(?:#{chars})"
+      when 'assertAhead'
+        evaluated = el[:value].map { |v| evaluate(v) }.join('')
+        "(?=#{evaluated})"
+      when 'assertNotAhead'
+        evaluated = el[:value].map { |v| evaluate(v) }.join('')
+        "(?!#{evaluated})"
+      when 'anyOf'
+        fused, rest = fuse_elements(el[:value])
+        return "[#{fused}]" unless rest.length
+
+        evaluatedRest = rest.map { |v| evaluate(v) }
+        separator = evaluatedRest.length > 0 && fused.length > 0 ? '|' : ''
+        "(?:#{evaluatedRest.join('|')}#{separator}#{fused ? "[#{fused}]" : ''})"
+      when 'capture'
+        evaluated = el[:value].map { |v| evaluate(v) }
+        "(#{evaluated.join('')})"
+      when 'namedCapture'
+        evaluated = el[:value].map { |v| evaluate(v) }
+        "(?<#{el[:name]}>#{evaluated.join('')})"
+      when 'group'
+        evaluated = el[:value].map { |v| evaluate(v) }
+        "(?:#{evaluated.join('')})"
+      else
+        raise "Can't process unsupported element type: #{el[:type]}"
+      end
+    end
+
+    def as_type(type, opts={})
+      proc { |value| { type: type, value: value }.merge(opts) }
+    end
+
+    def deferred_type(type, opts={})
+      type_fn = as_type(type, opts)
+      type_fn.call(type_fn)
+    end
+
+    def assert(condition, message)
+      raise StandardError, message unless condition
+    end
+
+    def partition(a)
+      r = a.each_with_object([[], []]) do |cur, acc|
+        if is_fusable(cur)
+          acc[0].push(cur)
+        else
+          acc[1].push(cur)
+        end
+        acc
+      end
+      [r[0], r[1]]
+    end
+
+    def is_fusable(element)
+      element[:type] == 'range' ||
+        element[:type] == 'char' ||
+        element[:type] == 'anyOfChars'
+    end
+
+    def fuse_elements(elements)
+      fusables, rest = partition(elements)
+      fused = fusables.map do |el|
+        if %w[char anyOfChars].include?(el[:type])
+          el[:value]
+        else
+          "#{el[:value][0]}-#{el[:value][1]}"
+        end
+      end.join('')
+      [fused, rest]
+    end
+
+    def camelize(snake_case_str)
+      snake_case_str.split('_').each_with_object([]).with_index do |(s, acc), idx|
+        acc << if idx.zero?
+                 s
+               else
+                 s.capitalize
+               end
+      end.join
+    end
+  end
+
+  @@t = {
+    root: as_type('root').call,
+    noop: as_type('noop').call,
+    startOfInput: as_type('startOfInput').call,
+    endOfInput: as_type('endOfInput').call,
+    anyChar: as_type('anyChar').call,
+    whitespaceChar: as_type('whitespaceChar').call,
+    nonWhitespaceChar: as_type('nonWhitespaceChar').call,
+    digit: as_type('digit').call,
+    nonDigit: as_type('nonDigit').call,
+    word: as_type('word').call,
+    nonWord: as_type('nonWord').call,
+    wordBoundary: as_type('wordBoundary').call,
+    nonWordBoundary: as_type('nonWordBoundary').call,
+    newline: as_type('newline').call,
+    carriageReturn: as_type('carriageReturn').call,
+    tab: as_type('tab').call,
+    nullByte: as_type('nullByte').call,
+    anyOfChars: as_type('anyOfChars'),
+    anythingButString: as_type('anythingButString'),
+    anythingButChars: as_type('anythingButChars'),
+    anythingButRange: as_type('anythingButRange'),
+    char: as_type('char'),
+    range: as_type('range'),
+    string: as_type('string', { quantifierRequiresGroup: true }),
+    namedBackreference: proc { |name| deferred_type('namedBackreference', { name: name }) },
+    backreference: proc { |index| deferred_type('backreference', { index: index }) },
+    capture: deferred_type('capture', { containsChildren: true }),
+    subexpression: as_type('subexpression', { containsChildren: true, quantifierRequiresGroup: true }),
+    namedCapture: proc { |name| deferred_type('namedCapture', { name: name, containsChildren: true }) },
+    group: deferred_type('group', { containsChildren: true }),
+    anyOf: deferred_type('anyOf', { containsChildren: true }),
+    assertAhead: deferred_type('assertAhead', { containsChildren: true }),
+    assertNotAhead: deferred_type('assertNotAhead', { containsChildren: true }),
+    exactly: proc { |times| deferred_type('exactly', { times: times, containsChild: true }) },
+    atLeast: proc { |times| deferred_type('atLeast', { times: times, containsChild: true }) },
+    between: proc { |x, y| deferred_type('between', { times: [x, y], containsChild: true }) },
+    betweenLazy: proc { |x, y| deferred_type('betweenLazy', { times: [x, y], containsChild: true }) },
+    zeroOrMore: deferred_type('zeroOrMore', { containsChild: true }),
+    zeroOrMoreLazy: deferred_type('zeroOrMoreLazy', { containsChild: true }),
+    oneOrMore: deferred_type('oneOrMore', { containsChild: true }),
+    oneOrMoreLazy: deferred_type('oneOrMoreLazy', { containsChild: true }),
+    optional: deferred_type('optional', { containsChild: true })
+  }.freeze
+
+  def initialize
+    self.state = {
+      hasDefinedStart: false,
+      hasDefinedEnd: false,
+      flags: {
+        g: false,
+        y: false,
+        m: false,
+        i: false,
+        u: false,
+        s: false
+      },
+      stack: [create_stack_frame(t[:root])],
+      namedGroups: [],
+      totalCaptureGroups: 0
+    }
+  end
+
+  def t
+    @@t
+  end
+
+  def escape_special(s)
+    Regexp.escape(s)
+  end
+
+  def create_stack_frame(type)
+    { type: type, quantifier: nil, elements: [] }
+  end
+
+  def allow_multiple_matches
+    # warn("Warning: Ruby does not have a allow multiple matches option. use String#gsub or String#scan")
+    n = clone
+    n.state[:flags][:g] = true
+    n
+  end
+
+  def line_by_line
+    # warn("Warning: Ruby does not have a line by line option. use \A or \z as an alternative")
+    n = clone
+    n.state[:flags][:m] = true
+    n
+  end
+
+  def case_insensitive
+    n = clone
+    n.state[:flags][:i] = true
+    n
+  end
+
+  def sticky
+    # warn("Warning: Ruby does not have a sticky option")
+    n = clone
+    n.state[:flags][:y] = true
+    n
+  end
+
+  def unicode
+    n = clone
+    n.state[:flags][:u] = true
+    n
+  end
+
+  def single_line
+    n = clone
+    n.state[:flags][:s] = true
+    n
+  end
+
+  def match_element(type_fn)
+    n = clone
+    n.get_current_element_array.push(n.apply_quantifier(type_fn))
+    n
+  end
+
+  def any_char
+    match_element(t[:anyChar])
+  end
+
+  def whitespace_char
+    match_element(t[:whitespaceChar])
+  end
+
+  def non_whitespace_char
+    match_element(t[:nonWhitespaceChar])
+  end
+
+  def digit
+    match_element(t[:digit])
+  end
+
+  def non_digit
+    match_element(t[:nonDigit])
+  end
+
+  def word
+    match_element(t[:word])
+  end
+
+  def non_word
+    match_element(t[:nonWord])
+  end
+
+  def word_boundary
+    match_element(t[:wordBoundary])
+  end
+
+  def non_word_boundary
+    match_element(t[:nonWordBoundary])
+  end
+
+  def newline
+    match_element(t[:newline])
+  end
+
+  def carriage_return
+    match_element(t[:carriageReturn])
+  end
+
+  def tab
+    match_element(t[:tab])
+  end
+
+  def null_byte
+    match_element(t[:nullByte])
+  end
+
+  def named_backreference(name)
+    assert(state[:namedGroups].include?(name), "no capture group called '#{name}' exists (create one with .namedCapture())")
+    match_element(t[:namedBackreference].call(name))
+  end
+
+  def backreference(index)
+    assert(index.is_a?(Integer), 'index must be a number')
+    assert(index > 0 && index <= state[:totalCaptureGroups],
+           "invalid index #{index}. There are #{state[:totalCaptureGroups]} capture groups on this SuperExpression")
+    match_element(t[:backreference].call(index))
+  end
+
+  def frame_creating_element(type_fn)
+    n = clone
+    new_frame = create_stack_frame(type_fn)
+    n.state[:stack].push(new_frame)
+    n
+  end
+
+  def any_of
+    frame_creating_element(t[:anyOf])
+  end
+
+  def group
+    frame_creating_element(t[:group])
+  end
+
+  def assert_ahead
+    frame_creating_element(t[:assertAhead])
+  end
+
+  def assert_not_ahead
+    frame_creating_element(t[:assertNotAhead])
+  end
+
+  def capture
+    n = clone
+    new_frame = create_stack_frame(t[:capture])
+    n.state[:stack].push(new_frame)
+    n.state[:totalCaptureGroups] += 1
+    n
+  end
+
+  def track_named_group(name)
+    assert(name.is_a?(String), "name must be a string (got #{name})")
+    assert(name.length > 0, 'name must be at least one character')
+    assert(!state[:namedGroups].include?(name), "cannot use #{name} again for a capture group")
+    assert(name.scan(NamedGroupRegex).any?, "name '#{name}' is not valid (only letters, numbers, and underscores)")
+
+    state[:namedGroups].push name
+  end
+
+  def named_capture(name)
+    n = clone
+    new_frame = create_stack_frame(t[:namedCapture].call(name))
+
+    n.track_named_group(name)
+    n.state[:stack].push(new_frame)
+    n.state[:totalCaptureGroups] += 1
+    n
+  end
+
+  def quantifier_element(type_fn_name)
+    n = clone
+    current_frame = n.get_current_frame
+    if current_frame[:quantifier]
+      raise StandardError, "cannot quantify regular expression with '#{type_fn_name}' because it's already being quantified with '#{current_frame[:quantifier][:type]}'"
+    end
+
+    current_frame[:quantifier] = t[type_fn_name.to_sym]
+    n
+  end
+
+  def optional
+    quantifier_element('optional')
+  end
+
+  def zero_or_more
+    quantifier_element('zeroOrMore')
+  end
+
+  def zero_or_more_lazy
+    quantifier_element('zeroOrMoreLazy')
+  end
+
+  def one_or_more
+    quantifier_element('oneOrMore')
+  end
+
+  def one_or_more_lazy
+    quantifier_element('oneOrMoreLazy')
+  end
+
+  def exactly(n)
+    assert(n.is_a?(Integer) && n > 0, "n must be a positive integer (got #{n})")
+
+    nxt = clone
+    current_frame = nxt.get_current_frame
+    if current_frame[:quantifier]
+      raise StandardError, "cannot quantify regular expression with 'exactly' because it's already being quantified with '#{current_frame[:quantifier][:type]}'"
+    end
+
+    current_frame[:quantifier] = t[:exactly].call(n)
+    nxt
+  end
+
+  def at_least(n)
+    assert(n.is_a?(Integer) && n > 0, "n must be a positive integer (got #{n})")
+    nxt = clone
+    current_frame = nxt.get_current_frame
+    if current_frame[:quantifier]
+      raise StandardError, "cannot quantify regular expression with 'atLeast' because it's already being quantified with '#{currentFrame.quantifier.type}'"
+    end
+
+    current_frame[:quantifier] = t[:atLeast].call(n)
+    nxt
+  end
+
+  def between(x, y)
+    assert(x.is_a?(Integer) && x >= 0, "x must be an integer (got #{x})")
+    assert(y.is_a?(Integer) && y > 0, "y must be an integer greater than 0 (got #{y})")
+    assert(x < y, "x must be less than y (x = #{x}, y = #{y})")
+
+    nxt = clone
+    current_frame = nxt.get_current_frame
+    if current_frame[:quantifier]
+      raise StandardError, "cannot quantify regular expression with 'between' because it's already being quantified with '#{currentFrame.quantifier.type}'"
+    end
+
+    current_frame[:quantifier] = t[:between].call(x, y)
+    nxt
+  end
+
+  def between_lazy(x, y)
+    assert(x.is_a?(Integer) && x >= 0, "x must be an integer (got #{x})")
+    assert(y.is_a?(Integer) && y > 0, "y must be an integer greater than 0 (got #{y})")
+    assert(x < y, "x must be less than y (x = #{x}, y = #{y})")
+
+    n = clone
+    current_frame = n.get_current_frame
+    if current_frame[:quantifier]
+      raise StandardError, "cannot quantify regular expression with 'betweenLazy' because it's already being quantified with '#{current_frame[:quantifier][:type]}'"
+    end
+
+    current_frame[:quantifier] = t[:betweenLazy].call(x, y)
+    n
+  end
+
+  def start_of_input
+    assert(!state[:hasDefinedStart], 'This regex already has a defined start of input')
+    assert(!state[:hasDefinedEnd], 'Cannot define the start of input after the end of input')
+
+    n = clone
+    n.state[:hasDefinedStart] = true
+    n.get_current_element_array.push(t[:startOfInput])
+    n
+  end
+
+  def end_of_input
+    assert(!state[:hasDefinedEnd], 'This regex already has a defined end of input')
+
+    n = clone
+    n.state[:hasDefinedEnd] = true
+    n.get_current_element_array.push(t[:endOfInput])
+    n
+  end
+
+  def any_of_chars(s)
+    n = clone
+    element_value = t[:anyOfChars].call(escape_special(s))
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+    n
+  end
+
+  def end
+    assert(state[:stack].length > 1, 'Cannot call end while building the root expression.')
+
+    n = clone
+    old_frame = n.state[:stack].pop
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(old_frame[:type][:value].call(old_frame[:elements])))
+    n
+  end
+
+  def anything_but_string(str)
+    assert(str.is_a?(String), "str must be a string (got #{str})")
+    assert(str.length > 0, 'str must have least one character')
+
+    n = clone
+    element_value - t[:anythingButString].call(escape_special(str))
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+    n
+  end
+
+  def anything_but_chars(chars)
+    assert(chars.is_a?(String), "chars must be a string (got #{chars})")
+    assert(chars.length > 0, 'chars must have at least one character')
+
+    n = clone
+    element_value = t[:anythingButChars].call(escape_special(chars))
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+    n
+  end
+
+  def anything_but_range(a, b)
+    str_a = a.to_s
+    str_b = b.to_s
+
+    assert(str_a.length === 1, "a must be a single character or number (got #{str_a})")
+    assert(str_b.length === 1, "b must be a single character or number (got #{str_b})")
+    assert(str_a[0].ord < str_b[0].ord, "a must have a smaller character value than b (a = #{str_a[0].ord}, b = #{str_b[0].ord})")
+
+    n = clone
+    element_value = t[:anythingButRange].call([a, b])
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+    n
+  end
+
+  def string(str)
+    assert('' != str, 'str cannot be an empty string')
+    n = clone
+
+    element_value =
+      if str.length > 1
+        t[:string].call(escape_special(str))
+      else
+        t[:char].call(str)
+      end
+
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+
+    n
+  end
+
+  def char(c)
+    assert(c.is_a?(String), "c must be a string (got #{c})")
+    assert(c.length == 1, "char() can only be called with a single character (got #{c})")
+
+    n = clone
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(t[:char].call(escape_special(c))))
+    n
+  end
+
+  def range(a, b)
+    str_a = a.to_s
+    str_b = b.to_s
+
+    assert(str_a.length == 1, "a must be a single character or number (got #{str_a})")
+    assert(str_b.length == 1, "b must be a single character or number (got #{str_b})")
+    assert(str_a[0].ord < str_b[0].ord, "a must have a smaller character value than b (a = #{str_a[0].ord}, b = #{str_b[0].ord})")
+
+    n = clone
+    element_value = t[:range].call([str_a, str_b])
+    current_frame = n.get_current_frame
+
+    current_frame[:elements].push(n.apply_quantifier(element_value))
+    n
+  end
+
+  def merge_subexpression(el, options, parent, increment_capture_groups)
+    next_el = el.clone
+    next_el[:index] += parent.state[:totalCaptureGroups] if next_el[:type] == 'backreference'
+
+    increment_capture_groups.call if next_el[:type] == 'capture'
+
+    if next_el[:type] === 'namedCapture'
+      group_name =
+        if options[:namespace]
+          "#{options[:namespace]}#{next_el[:name]}"
+        else
+          next_el[:name]
+        end
+
+      parent.track_named_group(group_name)
+      next_el[:name] = group_name
+    end
+
+    if next_el[:type] == 'namedBackreference'
+      next_el[:name] =
+        if options[:namespace]
+          "#{options[:namespace]}#{next_el[:name]}"
+        else
+          next_el[:name]
+        end
+    end
+
+    if next_el[:containsChild]
+      next_el[:value] = merge_subexpression(
+        next_el[:value],
+        options,
+        parent,
+        increment_capture_groups
+      )
+    elsif next_el[:containsChildren]
+      next_el[:value] = next_el[:value].map do |e|
+        merge_subexpression(
+          e,
+          options,
+          parent,
+          increment_capture_groups
+        )
+      end
+    end
+
+    if next_el[:type] == 'startOfInput'
+
+      return @@t[:noop] if options[:ignoreStartAndEnd]
+
+      assert(
+        !parent.state[:hasDefinedStart],
+        'The parent regex already has a defined start of input. ' +
+        'You can ignore a subexpressions startOfInput/endOfInput markers with the ignoreStartAndEnd option'
+      )
+
+      assert(
+        !parent.state[:hasDefinedEnd],
+        'The parent regex already has a defined end of input. ' +
+          'You can ignore a subexpressions startOfInput/endOfInput markers with the ignoreStartAndEnd option'
+      )
+
+      parent.state[:hasDefinedStart] = true
+    end
+
+    if next_el[:type] == 'endOfInput'
+      return @@t[:noop] if options[:ignoreStartAndEnd]
+
+      assert(
+        !parent.state[:hasDefinedEnd],
+        'The parent regex already has a defined start of input. ' +
+        'You can ignore a subexpressions startOfInput/endOfInput markers with the ignoreStartAndEnd option'
+      )
+
+      parent.state[:hasDefinedEnd] = true
+    end
+    next_el
+  end
+
+  def apply_subexpression_defaults(expr)
+    out = {}.merge(expr)
+
+    out[:namespace] = out.has_key?(:namespace) ? out[:namespace] : ''
+    out[:ignoreFlags] = out.has_key?(:ignoreFlags) ? out[:ignoreFlags] : true
+    out[:ignoreStartAndEnd] = out.has_key?(:ignoreStartAndEnd) ? out[:ignoreStartAndEnd] : true
+    assert(out[:namespace].is_a?(String), 'namespace must be a string')
+    assert(out[:ignoreFlags].is_a?(TrueClass) || out[:ignoreFlags].is_a?(FalseClass), 'ignoreFlags must be a boolean')
+    assert(out[:ignoreStartAndEnd].is_a?(TrueClass) || out[:ignoreStartAndEnd].is_a?(FalseClass), 'ignoreStartAndEnd must be a boolean')
+
+    out
+  end
+
+  def subexpression(expr, opts = {})
+    assert(expr.is_a?(SuperExpressiveRuby), 'expr must be a SuperExpressive instance')
+    assert(
+      expr.state[:stack].length === 1,
+      'Cannot call subexpression with a not yet fully specified regex object.' +
+      "\n(Try adding a .end() call to match the '#{expr.get_current_frame[:type][:type]}' on the subexpression)\n"
+    )
+
+    options = apply_subexpression_defaults(opts)
+
+    expr_n = expr.clone
+    expr_n.state = expr.state.deep_dup
+    n = clone
+    additional_capture_groups = 0
+
+    expr_frame = expr_n.get_current_frame
+    closure = proc { additional_capture_groups += 1 }
+
+    expr_frame[:elements] = expr_frame[:elements].map do |e|
+      merge_subexpression(e, options, n, closure)
+    end
+
+    n.state[:totalCaptureGroups] += additional_capture_groups
+
+    unless options[:ignoreFlags]
+      expr_n.state[:flags].to_a.each do |e|
+        flag_name = e[0]
+        enabled = e[1]
+        n.state[:flags][flag_name] = enabled || n.state[:flags][flag_name]
+      end
+    end
+
+    current_frame = n.get_current_frame
+    current_frame[:elements].push(n.apply_quantifier(t[:subexpression].call(expr_frame[:elements])))
+    n
+  end
+
+  def to_regex_string
+    pattern, flags = get_regex_pattern_and_flags
+    Regexp.new(pattern, flags).to_s
+  end
+
+  def to_regex
+    pattern, flags = get_regex_pattern_and_flags
+    Regexp.new(pattern, flags)
+  end
+
+  def get_regex_pattern_and_flags
+    assert state[:stack].length === 1,
+           "Cannot compute the value of a not yet fully specified regex object.
+             \n(Try adding a .end() call to match the '#{get_current_frame[:type][:type]}')\n"
+    pattern = get_current_element_array.map { |el| self.class.evaluate(el) }.join('')
+    flag = nil
+    state[:flags].map do |name, is_on|
+      if is_on
+        flag = 0 if !flag
+        case name
+        when :s
+          flag = flag | Regexp::MULTILINE
+        when :i
+          flag = flag | Regexp::IGNORECASE
+        when :x
+          flag = flag | Regexp::EXTENDED
+        end
+      end
+    end
+    pat = (pattern == '' ? '(?:)' : pattern)
+    [pat, flag]
+  end
+
+  def apply_quantifier(element)
+    current_frame = get_current_frame
+    if current_frame[:quantifier]
+      wrapped = current_frame[:quantifier][:value].call(element)
+      current_frame[:quantifier] = nil
+      return wrapped
+    end
+    element
+  end
+
+  def get_current_frame
+    state[:stack][state[:stack].length - 1]
+  end
+
+  def get_current_element_array
+    get_current_frame[:elements]
+  end
+
+  def assert(condition, message)
+    self.class.assert(condition, message)
+    raise StandardError, message unless condition
+  end
+
+  # generate camel case methods
+  public_instance_methods(false).each do |method_name|
+    camelized_method_name = camelize(method_name.to_s)
+    alias_method camelized_method_name, method_name
+  end
+end

data/lib/super-expressive-ruby/version.rb

@@ -0,0 +1,5 @@
+module SuperExpressive
+  module Ruby
+    VERSION = "0.1.0"
+  end
+end

data/super-expressive-ruby.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/super-expressive-ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "super-expressive-ruby"
+  spec.version       = SuperExpressive::Ruby::VERSION
+  spec.authors       = ["Hiroshi Yamasaki"]
+  spec.email         = ["ymskhrs@gmail.com"]
+
+  spec.summary       = "Build regular expressions in almost natural language"
+  spec.description   = "This gem is a port of https://github.com/francisrstokes/super-expressive"
+  spec.homepage      = "https://github.com/hiy/super-expressive-ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/hiy/super-expressive-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/hiy/super-expressive-ruby"
+
+  # 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('..', __FILE__)) 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_dependency "activesupport", '6.0'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: super-expressive-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiroshi Yamasaki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: This gem is a port of https://github.com/francisrstokes/super-expressive
+email:
+- ymskhrs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/super-expressive-ruby.rb
+- lib/super-expressive-ruby/super-expressive-ruby.rb
+- lib/super-expressive-ruby/version.rb
+- super-expressive-ruby.gemspec
+homepage: https://github.com/hiy/super-expressive-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/hiy/super-expressive-ruby
+  source_code_uri: https://github.com/hiy/super-expressive-ruby
+  changelog_uri: https://github.com/hiy/super-expressive-ruby
+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.1.2
+signing_key: 
+specification_version: 4
+summary: Build regular expressions in almost natural language
+test_files: []