rrrex 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Ian Young
+
+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,57 @@
+Really Readable Regular Expressions
+================
+
+rrrex is a new syntax for regular expressions. It trades compactness for readability by real humans, and picks up a couple nice perks
+along the way.
+
+Crash Course
+============
+
+    "The string you'd like to search".rmatch? { "string" }
+
+    "abc".rmatch? { "ab" + "c" }
+
+    "abc".rmatch? { "xyz".or "abc" }
+
+You don't have to worry about escaping special characters in your strings any more:
+    "{symbols} .*&+ [galore]".rmatch? { "{symbols} .*&+ [galore]" }
+
+You can combine operations and get the expected precedence:
+    "abc".rmatch? { "ab" + ( "z".or "c" ) }
+
+Repetition:
+    "aaabc".rmatch? { 1.or_more "a" }
+    "aaabc".rmatch? { 5.or_less "a" }
+    "aaabc".rmatch? { 3.exactly "a" }
+    "aaabc".rmatch? { (1..5).of "a" }
+These are equivalent:
+    "aaabc".rmatch? { 0.or_more "a" }
+    "aaabc".rmatch? { any "a" }
+And these are equivalent:
+    "aaabc".rmatch? { 1.or_more "a" }
+    "aaabc".rmatch? { some "a" }
+
+Special character sets:
+    "abc1234.&*".rmatch? { 10.exactly any_char }
+    "abc1234".rmatch? { 3.exactly letter }
+    "abc1234".rmatch? { 4.exactly digit }
+    "abc_123".rmatch? { 7.exactly word_char }
+    " ".rmatch? { whitespace }
+Or create your own:
+    "abc".rmatch? { 3.exactly "a".."c" }
+
+Two types of negation:
+    "x".rmatch? { word_char.not "x" } # => nil
+    "y".rmatch? { word_char.not "x" }
+    "x".rmatch? { _not "x" } # => nil
+    "y".rmatch? { _not "x" }
+
+Groups:
+    match = "1234567890       Central Processing".rmatch? do
+        group :serial do
+            some digit
+        end + some whitespace + group :source do
+            any any_char
+        end
+    end
+    match

data/Rakefile

@@ -0,0 +1,79 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+
+task :default => ["test"]
+
+spec = Gem::Specification.new do |s|
+
+  s.name = "rrrex"
+  s.version = "0.1.0"
+  s.author = "Ian Young"
+  s.email = "ian.greenleaf+github@gmail.com"
+
+  s.summary = "Really Readable Regexps"
+  s.description = <<-EOF
+    Rrrex is a new syntax for regular expressions.
+    Less compact, but human-readable. By regular humans.
+  EOF
+
+  s.files = Dir[ 'lib/**/*.rb', 'test/**/*', '[A-Z]*' ]
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.md)
+  s.rdoc_options      = %w(--main README.md)
+
+  s.add_development_dependency("mocha")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+task :package => :gemspec
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end
+
+desc 'Tag the repository in git with gem version number'
+task :tag => [:gemspec, :package] do
+  if `git diff --cached`.empty?
+    if `git tag`.split("\n").include?("v#{spec.version}")
+      raise "Version #{spec.version} has already been released"
+    end
+    `git add #{File.expand_path("../#{spec.name}.gemspec", __FILE__)}`
+    `git commit -m "Released version #{spec.version}"`
+    `git tag v#{spec.version}`
+    `git push --tags`
+    `git push`
+  else
+    raise "Unstaged changes still waiting to be committed"
+  end
+end
+
+desc "Tag and publish the gem to rubygems.org"
+task :publish => :tag do
+  `gem push pkg/#{spec.name}-#{spec.version}.gem`
+end

data/lib/method_missing_conversion.rb

@@ -0,0 +1,23 @@
+module MethodMissingConversion
+  def self.included receiver
+    receiver.extend ClassMethods
+  end
+
+  module ClassMethods
+    def sends_methods_to methods, convert_to
+      define_method :method_missing_helper do |name, args, block|
+        if methods.include? name
+          convert_to.new( self ).send name, *args
+        else
+          method_missing_without_regexp name, *args, &block
+        end
+      end
+      alias_method :method_missing_without_regexp, :method_missing
+      alias_method :method_missing, :method_missing_with_regexp
+    end
+  end
+
+  def method_missing_with_regexp( name, *args, &block )
+    method_missing_helper name, args, block
+  end
+end

data/lib/rrrex.rb

@@ -0,0 +1 @@
+require 'rrrex/core_ext'

data/lib/rrrex/composite_match.rb

@@ -0,0 +1,16 @@
+require 'rrrex/composite_match'
+module Rrrex
+  module CompositeMatch
+    def initialize(*args)
+      @atoms = args.collect do |a|
+        input a
+      end
+    end
+
+    def group_names
+      @atoms.inject( [] ) do |memo,a|
+        memo + a.group_names
+      end
+    end
+  end
+end

data/lib/rrrex/concat_match.rb

@@ -0,0 +1,10 @@
+require 'rrrex/match'
+require 'rrrex/composite_match'
+module Rrrex
+  class ConcatMatch < Match
+   include CompositeMatch
+    def to_regexp_string
+      wrap @atoms.map {|p| p.to_regexp_string }.join ""
+    end
+  end
+end

data/lib/rrrex/core_ext.rb

@@ -0,0 +1,3 @@
+require 'rrrex/core_ext/fixnum'
+require 'rrrex/core_ext/range'
+require 'rrrex/core_ext/string'

data/lib/rrrex/core_ext/fixnum.rb

@@ -0,0 +1,13 @@
+class Fixnum
+  def exactly( atom )
+    Rrrex::NumberMatch.new atom, self, self
+  end
+
+  def or_more( atom )
+    Rrrex::NumberMatch.new atom, self, nil
+  end
+
+  def or_less( atom )
+    Rrrex::NumberMatch.new atom, nil, self
+  end
+end

data/lib/rrrex/core_ext/range.rb

@@ -0,0 +1,10 @@
+require 'method_missing_conversion'
+require 'rrrex/range_match'
+class Range
+  include MethodMissingConversion
+  sends_methods_to [ :or, :+ ], Rrrex::RangeMatch
+
+  def of( atom )
+    Rrrex::NumberMatch.new atom, self.begin, self.end
+  end
+end

data/lib/rrrex/core_ext/string.rb

@@ -0,0 +1,23 @@
+require 'method_missing_conversion'
+require 'rrrex/string_match'
+require 'rrrex/match'
+require 'rrrex/dsl_context'
+class String
+  include MethodMissingConversion
+  sends_methods_to [ :or ], Rrrex::StringMatch
+
+  def plus_with_regexp( str2 )
+    if str2.kind_of? Rrrex::Match
+      Rrrex::StringMatch.new( self ) + str2
+    else
+      self.plus_without_regexp str2
+    end
+  end
+  alias_method :plus_without_regexp, :+
+  alias_method :+, :plus_with_regexp
+
+  def rmatch?( &block )
+    pattern = Rrrex::Match.convert Rrrex::DslContext.module_exec &block
+    pattern.match self
+  end
+end

data/lib/rrrex/dsl_context.rb

@@ -0,0 +1,47 @@
+require 'rrrex/unescaped_string_match'
+require 'rrrex/group_match'
+require 'rrrex/number_match'
+module Rrrex
+  module DslContext
+
+    WORD_CHAR = '\w'
+    DIGIT = '\d'
+    WHITESPACE = '\s'
+    LETTER = '[[:alpha:]]'
+    ANY_CHAR = '.'
+
+    constants.each do |const|
+      ( class << self; self; end ).instance_eval do
+        define_method const.downcase.to_sym do
+          UnescapedStringMatch.new const_get( const )
+        end
+      end
+    end
+
+    def self.any r
+      NumberMatch.new r, 0, nil
+    end
+
+    def self.some r
+      NumberMatch.new r, 1, nil
+    end
+
+    def self._not r
+      any_char.not r
+    end
+
+    def self.group( name_or_atom=nil, atom=nil, &block )
+      if name_or_atom.kind_of? Symbol
+        name = name_or_atom
+        atom = atom || DslContext.module_exec( &block )
+      elsif name_or_atom.kind_of? Hash
+        name = name_or_atom.keys.first
+        atom = name_or_atom[ name ]
+      else
+        name = nil
+        atom = name_or_atom
+      end
+      GroupMatch.new atom, name
+    end
+  end
+end

data/lib/rrrex/group_match.rb

@@ -0,0 +1,20 @@
+require 'rrrex/match'
+require 'rrrex/single_atom_match'
+module Rrrex
+  class GroupMatch < Match
+   include SingleAtomMatch
+   def initialize atom, name
+     @name = name
+     super atom
+   end
+
+   def to_regexp_string
+     "(#{atom.to_regexp_string})"
+   end
+
+   def group_names
+     names = @atom.group_names || []
+     names.unshift @name
+   end
+  end
+end

data/lib/rrrex/match.rb

@@ -0,0 +1,52 @@
+module Rrrex
+  class Match
+  end
+end
+require 'rrrex/regexp'
+require 'rrrex/string_match'
+require 'rrrex/range_match'
+require 'rrrex/or_match'
+require 'rrrex/concat_match'
+require 'rrrex/not_match'
+module Rrrex
+  class Match
+    def self.convert( atom )
+      if atom.kind_of? Match
+        atom
+      elsif atom.kind_of? Range
+        RangeMatch.new atom
+      else
+        StringMatch.new atom
+      end
+    end
+
+    def wrap( s )
+      "(?:#{s})"
+    end
+
+    def match(str)
+      Regexp.new( self ).match str
+    end
+
+    def or(atom)
+      OrMatch.new self, atom
+    end
+
+    def +(p)
+      ConcatMatch.new self, p
+    end
+
+    def not(atom)
+      ConcatMatch.new NotMatch.new( atom ), self
+    end
+
+    def group_names
+      []
+    end
+
+    protected
+    def input( atom )
+      self.class.convert atom
+    end
+  end
+end

data/lib/rrrex/match_data.rb

@@ -0,0 +1,36 @@
+module Rrrex
+  class MatchData
+    def initialize( atom, match_data )
+      @atom = atom
+      @match_data = match_data
+    end
+
+    def []( i )
+      if i.is_a? Symbol
+        named_groups[ i ]
+      else
+        @match_data[ i ]
+      end
+    end
+
+    def named_groups
+      @named_groups ||=
+        begin
+          result = {}
+          names = @atom.group_names
+          names.each_index do |i|
+            result[ names[ i ] ] = @match_data[ i + 1 ]
+          end
+          result
+        end
+    end
+
+    def to_a
+      @match_data.to_a
+    end
+
+    def method_missing( name, *args )
+      @match_data.send name, *args
+    end
+  end
+end

data/lib/rrrex/not_match.rb

@@ -0,0 +1,10 @@
+require 'rrrex/match'
+require 'rrrex/single_atom_match'
+module Rrrex
+  class NotMatch < Match
+   include SingleAtomMatch
+   def to_regexp_string
+     "(?!#{atom.to_regexp_string})"
+   end
+  end
+end

data/lib/rrrex/number_match.rb

@@ -0,0 +1,17 @@
+require 'rrrex/match'
+require 'rrrex/single_atom_match'
+module Rrrex
+  class NumberMatch < Match
+    include SingleAtomMatch
+    def initialize( a, min, max )
+      super a
+      @min = min
+      @max = max
+    end
+
+    def to_regexp_string
+      # Subtle: when nil, we want min to convert to 0, but max to convert to ""
+      wrap atom.to_regexp_string + "{#{@min.to_i},#{@max}}"
+    end
+  end
+end

data/lib/rrrex/or_match.rb

@@ -0,0 +1,10 @@
+require 'rrrex/match'
+require 'rrrex/composite_match'
+module Rrrex
+  class OrMatch < Match
+   include CompositeMatch
+    def to_regexp_string
+      wrap @atoms.map {|p| p.to_regexp_string }.join "|"
+    end
+  end
+end

data/lib/rrrex/range_match.rb

@@ -0,0 +1,14 @@
+require 'rrrex/match'
+require 'rrrex/single_atom_match'
+module Rrrex
+  class RangeMatch < Match
+   include SingleAtomMatch
+    def initialize( range )
+      @range = range
+    end
+
+    def to_regexp_string
+      wrap "[#{@range.first}-#{@range.last}]"
+    end
+  end
+end

data/lib/rrrex/regexp.rb

@@ -0,0 +1,14 @@
+require 'rrrex/match_data'
+module Rrrex
+  class Regexp < ::Regexp
+    def initialize( r )
+      super r.to_regexp_string
+      @atom = r
+    end
+
+    def match( str )
+      result = super( str )
+      MatchData.new @atom, result unless result.nil?
+    end
+  end
+end

data/lib/rrrex/single_atom_match.rb

@@ -0,0 +1,26 @@
+module Rrrex
+  module SingleAtomMatch
+
+    attr_reader :atom
+
+    def initialize( a )
+      self.atom = a
+    end
+
+    def atom=( a )
+      @atom = input a
+    end
+
+    def to_regexp_string
+      wrap atom.to_regexp_string
+    end
+
+    def group_names
+      if @atom.respond_to? :group_names
+        @atom.group_names if @atom.respond_to? :group_names
+      else
+        []
+      end
+    end
+  end
+end

data/lib/rrrex/string_match.rb

@@ -0,0 +1,14 @@
+require 'rrrex/match'
+require 'rrrex/single_atom_match'
+module Rrrex
+  class StringMatch < Match
+   include SingleAtomMatch
+    def initialize( a )
+      @atom = a
+    end
+
+    def to_regexp_string
+      wrap Regexp.escape atom
+    end
+  end
+end

data/lib/rrrex/unescaped_string_match.rb

@@ -0,0 +1,8 @@
+require 'rrrex/string_match'
+module Rrrex
+  class UnescapedStringMatch < StringMatch
+    def to_regexp_string
+      wrap atom
+    end
+  end
+end

data/test/match_test.rb

@@ -0,0 +1,230 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+require 'rrrex'
+
+class MatchTest < Test::Unit::TestCase
+
+  def test_match_simple_string
+    [ ["a", "a"], ["bc", "babb bc"], ["úñícode", "i like úñícode"] ].each do |pattern,string|
+      m = Rrrex::StringMatch.new pattern
+      assert m.match string
+    end
+  end
+
+  def test_dont_match_simple_string
+    [ ["a", "b"], ["bc", "bac def"], ["úñícode", "i like unicode"] ].each do |pattern,string|
+      m = Rrrex::StringMatch.new pattern
+      assert_nil m.match string
+    end
+  end
+
+  def test_inline_match_triggers_module
+    rxp_stub = stub "Rrrex::Match", { :match => true }
+    Rrrex::StringMatch.expects(:new).with("oo").returns(rxp_stub)
+    "foobar".rmatch? do "oo" end
+  end
+
+  def test_match_simple_string_inline
+    assert_match "oo", "foobar" do "oo" end
+  end
+
+  def test_dont_match_simple_string_inline
+    assert_no_match "foobar" do "xy" end
+  end
+
+  def test_special_characters_escaped_in_string
+    assert_no_match "foobar" do "o+" end
+    assert_match "o+", "+hello+" do "o+" end
+  end
+
+  def test_match_or
+    assert_match "foo", "foobar" do "xy".or "foo" end
+  end
+
+  def test_match_any
+    assert_match "x", "x" do any "x" end
+    assert_match "aaaaa", "aaaaab" do any "a" end
+    assert_match "abab", "ababaab" do any "ab" end
+    assert_match "", "xxxx" do any "y" end
+  end
+
+  def test_match_some
+    assert_match "x", "x" do some "x" end
+    assert_match "aaaaa", "aaaaab" do some "a" end
+    assert_match "abab", "ababaab" do some "ab" end
+    assert_no_match "xxxx" do some "y" end
+  end
+
+  def test_match_not
+    assert_match "x", "x" do _not "y" end
+    assert_no_match "x" do _not "x" end
+    assert_match "cdef", "abcdefab" do some _not( "a".or "b" ) end
+    assert_match "defa", "abcdefaab" do some _not( "ab".or "b".or "c" ) end
+  end
+
+  def test_match_lookahead_not
+    assert_match "y", "xy" do letter.not "x" end
+    assert_match "1234", "123456789" do some( digit.not "5" ) end
+    assert_match "1234", "1234abc" do some( digit.not "5" ) end
+    assert_match "abb", "abcabb" do ( "ab" + letter ).not "abc" end
+    assert_no_match "abbbc" do "a" + ( (1..6).of "a" ).not( "aaa" ) + "c" end
+    assert_match "21", "123321" do 2.or_more digit.not( "12".or "3" ) end
+  end
+
+  def test_match_concat
+    assert_match "foobar", "foobar" do "foo" + "bar" end
+    assert_match "foobarbaz", "foobarbazbar" do "foo" + "bar" + "baz" end
+  end
+
+  def test_match_num_exactly
+    assert_match "oo", "foobar" do 2.exactly "o" end
+    assert_match "oo", "foooobar" do 2.exactly "o" end
+    assert_no_match "foobar" do 3.exactly "o" end
+    assert_match "foobar", "foobar" do "f" + 2.exactly( "o" ) + "bar" end
+    assert_no_match "foobar" do "f" + 1.exactly( "o" ) + "bar" end
+  end
+
+  def test_match_num_or_more
+    assert_match "oo", "foobar" do 2.or_more "o" end
+    assert_match "foooo", "foooobar" do "f" + 2.or_more( "o" ) end
+    assert_no_match "foobar" do 3.or_more "o" end
+  end
+
+  def test_match_num_or_less
+    assert_match "xx", "xx" do 2.or_less "x" end
+    assert_match "xx", "xxxxxxxx" do 2.or_less "x" end
+    assert_match "xx", "xx" do 100.or_less "x" end
+    assert_match "foobar", "foobar" do "f" + 2.or_less( "o" ) + "bar" end
+    assert_match "fbar", "fbar" do "f" + 2.or_less( "o" ) + "bar" end
+    assert_no_match "foooobar" do "f" + 3.or_less( "o" ) + "bar" end
+    assert_match "", "xxxxx" do 3.or_less "y" end
+  end
+
+  def test_range_of_matches
+    assert_match "xx", "xx" do (2..4).of "x" end
+    assert_match "xxx", "xxx" do (2..100).of "x" end
+    assert_match "xxxx", "xxxxxxxx" do (2..4).of "x" end
+    assert_no_match "foobar" do "f" + (3..4).of( "o" ) + "bar" end
+    assert_no_match "foooooooobar" do "f" + (3..4).of( "o" ) + "bar" end
+    assert_no_match "xxxx" do (1..100).of( "y" ) + "bar" end
+  end
+
+  def test_char_range
+    assert_match "b", "b" do "a".."c" end
+    assert_no_match "b" do "A".."C" end
+    assert_match "abc", "abcdefg" do 1.or_more "a".."c" end
+    assert_match "123", "123456789" do (1..4).of 1..3 end
+    assert_match "x8", "ax87" do 1.or_more( ("q".."z").or(8..9) ) end
+    assert_match "az", "az" do ("a".."c") + ("w".."z") end
+  end
+
+  def test_grouping
+    assert_match "foobar", "foobar" do "foo" + ( "xyz".or "bar" ) end
+    assert_match "bar", "foobar" do ( "xyz" + "foo" ).or "bar" end
+    assert_match "fo", "foobar" do ( "xyz" + "foo" ).or( "xyz".or "fo" ).or( "foo" + "xyz" ) end
+  end
+
+  def test_dont_add_extra_backreferences
+    mdata = "foobar".rmatch? do "foo" + ( "xyz".or "bar" ) end
+    assert_equal 1, mdata.length
+  end
+
+  def test_any_characters
+    assert_match "f", "foobar" do any_char end
+    chars = "#\t?/\<>.,;:\"'!@\#$%^&*()[]{} bar"
+    assert_match chars, chars do some any_char end
+    assert_no_match "\n" do any_char end
+  end
+
+  def test_word_characters
+    assert_match "f", "foobar" do word_char end
+    assert_match "foo_bar2", "### foo_bar2 baz bar" do some word_char end
+    assert_no_match '?/\<>.,;:"\'!@#$%^&*()[]{}' do word_char end
+    assert_no_match 'a,b,c,d' do 2.or_more word_char end
+  end
+
+  def test_digit_characters
+    assert_match "1", "12345" do digit end
+    assert_match "654321", "### abc654321baz123" do some digit end
+    assert_no_match 'abc_DEF *&".' do digit end
+    assert_no_match '1,2,3' do 2.or_more digit end
+  end
+
+  def test_letter_characters
+    assert_match "f", "foobar" do letter end
+    assert_match "foo", "### foo_bar2 baz bar" do some letter end
+    assert_no_match '?/."()123456_' do letter end
+    assert_no_match 'a1b2c3' do 2.or_more letter end
+  end
+
+  def test_whitespace_characters
+    assert_match " ", "    " do whitespace end
+    assert_match " \t ", "### \t baz bar" do some whitespace end
+    assert_no_match 'abc_123-+=().?!' do whitespace end
+    assert_no_match 'a b c d' do 2.or_more whitespace end
+  end
+
+  def test_numeric_group
+    assert_match_backreferences ["a", "a"], "abc" do group "a" end
+    assert_match_backreferences ["ab", "a", "b"], "abc" do group( "a" ) + group( "b" ) end
+    assert_match_backreferences ["ab", "ab", "b"], "abc" do group( "a" + group( "b" ) ) end
+    assert_match_backreferences ["abcde", "abcde"], "abcde" do group( any word_char ) end
+    assert_match_backreferences ["abcde", "e"], "abcde" do any group( word_char ) end
+    assert_match_backreferences ["a", "a", nil], "abc" do group( "a" ).or group( "b" ) end
+  end
+
+  def test_named_groups
+    assert_match_named_groups( { :my_a => "a" }, "abc" ) do group :my_a, "a" end
+    assert_match_named_groups( { :my_b => "b" }, "abc" ) do "a" + group( :my_b, "b" ) + "c" end
+    assert_match_named_groups( { :a => "a", :b => nil }, "abc" ) do group( :a, "a" ).or group( :b, "b" ) end
+    assert_match_named_groups( { :a => "ab", :b => "ab" }, "abc" ) do group( :a, group( :b, "ab" ) ) end
+    assert_match_named_groups( { :a => "ab", :b => "b" }, "abc" ) do group( :a, "a" + group( :b, "b" ) ) end
+    assert_match_named_groups( { :word => "abcde" }, "abcde" ) do group( :word, any( word_char ) ) end
+    assert_match_named_groups( { :letter => "e" }, "abcde" ) do any group( :letter, word_char ) end
+  end
+
+  def test_named_groups_block_syntax
+    assert_match_named_groups( { :my_a => "a" }, "abc" ) do group :my_a do "a" end end
+    assert_match_named_groups( { :my_a => "a" }, "abc" ) do group( :my_a ) { "a" } end
+    assert_match_named_groups( { :full_match => "abc", :last_part => "bc" }, "abc" ) do
+      group :full_match do
+        "a" + group( :last_part ) do
+          "bz".or "bc".or "b"
+        end
+      end
+    end
+  end
+
+  def test_named_groups_cached
+    assert( matches = "a".rmatch? do group :a, "a" end )
+    Rrrex::GroupMatch.any_instance.expects( :group_names ).times( 1 ).returns( [] )
+    matches[ :a ]
+    matches[ :a ]
+    matches.named_groups
+    matches.named_groups
+  end
+
+  def assert_no_match( string, &block )
+    assert_nil( string.rmatch?( &block ) )
+  end
+
+  def assert_match( expected, string, &block )
+    assert( matches = string.rmatch?( &block ) )
+    assert_equal expected, matches[0]
+  end
+
+  def assert_match_backreferences( expected, string, &block )
+    assert( matches = string.rmatch?( &block ) )
+    assert_equal expected, matches.to_a
+  end
+
+  def assert_match_named_groups( expected, string, &block )
+    assert( matches = string.rmatch?( &block ) )
+    assert_equal expected, matches.named_groups
+    expected.each do |k,v|
+      assert_equal v, matches[ k ]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: rrrex
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ian Young
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: "    Rrrex is a new syntax for regular expressions.\n    Less compact, but human-readable. By regular humans.\n"
+email: ian.greenleaf+github@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/rrrex.rb
+- lib/rrrex/match_data.rb
+- lib/rrrex/or_match.rb
+- lib/rrrex/single_atom_match.rb
+- lib/rrrex/regexp.rb
+- lib/rrrex/dsl_context.rb
+- lib/rrrex/match.rb
+- lib/rrrex/not_match.rb
+- lib/rrrex/group_match.rb
+- lib/rrrex/number_match.rb
+- lib/rrrex/core_ext.rb
+- lib/rrrex/range_match.rb
+- lib/rrrex/unescaped_string_match.rb
+- lib/rrrex/string_match.rb
+- lib/rrrex/core_ext/string.rb
+- lib/rrrex/core_ext/fixnum.rb
+- lib/rrrex/core_ext/range.rb
+- lib/rrrex/composite_match.rb
+- lib/rrrex/concat_match.rb
+- lib/method_missing_conversion.rb
+- test/match_test.rb
+- LICENSE
+- Rakefile
+- README.md
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Really Readable Regexps
+test_files: []
+