re 0.0.1 → 0.0.3

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2003, 2004 Jim Weirich
+
+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.rdoc

@@ -1,9 +1,46 @@
 
 = Regular Expression Construction.
 
-Construct regular expressions using the re() method.
+Complex regular expressions are hard to construct and even harder to
+read.  The Re library allows users to construct complex regular
+expressions from simpler expressions.  For example, consider the
+following regular expression that will parse dates:
 
-Usage:
+   /\A((?:19|20)[0-9]{2})[\- \/.](0[1-9]|1[012])[\- \/.](0[1-9]|[12][0-9]|3[01])\z/
+
+Using the Re library, That regular expression can be built
+incrementaly from smaller, easier to understand expressions.
+Perhaps something like this:
+
+  require 're'
+
+  include Re
+
+  delim                = re.any("- /.")
+  century_prefix       = re("19") | re("20")
+  under_ten            = re("0") + re.any("1-9")
+  ten_to_twelve        = re("1") + re.any("012")
+  ten_and_under_thirty = re.any("12") + re.any("0-9")
+  thirties             = re("3") + re.any("01")
+         
+  year = (century_prefix + re.digit.repeat(2)).capture(:year)
+  month = (under_ten | ten_to_twelve).capture(:month)
+  day = (under_ten | ten_and_under_thirty | thirties).capture(:day)
+         
+  date = (year + delim + month + delim + day).all
+
+Although it is more code, the individual pieces are smaller and
+easier to independently verify.  As an additional bonus, the capture
+groups can be retrieved by name:
+
+      result = date.match("2009-01-23")
+      result.data(:year)   # => "2009"
+      result.data(:month)  # => "01"
+      result.data(:day)    # => "23"
+
+== Version: 0.0.3
+
+== Usage:
 
   include Re
 
@@ -14,7 +51,7 @@ Usage:
     puts "No Match"
   end
 
-Examples:
+== Examples:
 
   re("a")                -- matches "a"
   re("a") + re("b")      -- matches "ab"
@@ -29,11 +66,33 @@ See Re::Rexp for a complete list of expressions.
 Using re without an argument allows access to a number of common
 regular expression constants.  For example:
 
-  re.space              -- matches " ", "\n" or "\t"
-  re.spaces             -- matches any number of spaces (but at least one)
+  re.space / re.spaces  -- matches " ", "\n" or "\t"
   re.digit / re.digits  -- matches a digit / sequence of digits
 
-See Re::NULL for a complete list of common constants.
+Also, re without arguments can also be used to construct character
+classes:
+
+  re.any                -- Matches any charactor
+  re.any("abc")         -- Matches "a", "b", or "c"
+  re.any("0-9")         -- Matches the digits 0 through 9
+  re.any("A-Z", "a-z", "0-9", "_")
+                        -- Matches alphanumeric or an underscore
+
+See Re::ConstructionMethods for a complete list of common constants
+and character class functions.
+
+See Re.re, Re::Rexp, and Re::ConstructionMethods for details.
+
+== License and Copyright:
+
+Copyright 2009 by Jim Weirich (jim.weirich@gmail.com)
+
+Re is provided under the MIT open source license (see MIT-LICENSE)
+
+== Links:
+
+* Documentation :: http://re-lib.rubyforge.org
+* Source        :: http://github.com/jimweirich/re
+* Bug Tracker   :: http://www.pivotaltracker.com/projects/47758
+* Author        :: jim.weirich@gmail.com
 
-See Re.re,
-Re::Rexp, and Re::NULL for details.

data/Rakefile

@@ -4,6 +4,8 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
+require 'lib/re'
+
 task :default => :test
 
 Rake::TestTask.new(:test) do |t|
@@ -12,7 +14,8 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/*_test.rb']
 end
 
-Rake::RDocTask.new do |rd|
-  rd.main = "lib/re.rb"
-  rd.rdoc_files = FileList["lib/re.rb"]
+task :release => [:check_non_beta, :readme, :gem, "publish:rdoc"]
+
+task :check_non_beta do
+  fail "Must not be a beta version! Version is #{Re::VERSION}" if Re::Version::BETA
 end

data/lib/re.rb

@@ -2,9 +2,44 @@
 #
 # = Regular Expression Construction.
 #
-# Construct regular expressions using the re() method.
+# Complex regular expressions are hard to construct and even harder to
+# read.  The Re library allows users to construct complex regular
+# expressions from simpler expressions.  For example, consider the
+# following regular expression that will parse dates:
 #
-# Usage:
+#    /\A((?:19|20)[0-9]{2})[\- \/.](0[1-9]|1[012])[\- \/.](0[1-9]|[12][0-9]|3[01])\z/
+#
+# Using the Re library, That regular expression can be built
+# incrementaly from smaller, easier to understand expressions.
+# Perhaps something like this:
+#
+#   require 're'
+#
+#   include Re
+#
+#   delim                = re.any("- /.")
+#   century_prefix       = re("19") | re("20")
+#   under_ten            = re("0") + re.any("1-9")
+#   ten_to_twelve        = re("1") + re.any("012")
+#   ten_and_under_thirty = re.any("12") + re.any("0-9")
+#   thirties             = re("3") + re.any("01")
+#          
+#   year = (century_prefix + re.digit.repeat(2)).capture(:year)
+#   month = (under_ten | ten_to_twelve).capture(:month)
+#   day = (under_ten | ten_and_under_thirty | thirties).capture(:day)
+#          
+#   date = (year + delim + month + delim + day).all
+#
+# Although it is more code, the individual pieces are smaller and
+# easier to independently verify.  As an additional bonus, the capture
+# groups can be retrieved by name:
+#
+#       result = date.match("2009-01-23")
+#       result.data(:year)   # => "2009"
+#       result.data(:month)  # => "01"
+#       result.data(:day)    # => "23"
+#
+# == Usage:
 #
 #   include Re
 #
@@ -15,7 +50,7 @@
 #     puts "No Match"
 #   end
 #
-# Examples:
+# == Examples:
 #
 #   re("a")                -- matches "a"
 #   re("a") + re("b")      -- matches "ab"
@@ -30,31 +65,70 @@
 # Using re without an argument allows access to a number of common
 # regular expression constants.  For example:
 #
-#   re.space              -- matches " ", "\n" or "\t"
-#   re.spaces             -- matches any number of spaces (but at least one)
+#   re.space / re.spaces  -- matches " ", "\n" or "\t"
 #   re.digit / re.digits  -- matches a digit / sequence of digits
 #
-# See Re::NULL for a complete list of common constants.
+# Also, re without arguments can also be used to construct character
+# classes:
+#
+#   re.any                -- Matches any charactor
+#   re.any("abc")         -- Matches "a", "b", or "c"
+#   re.any("0-9")         -- Matches the digits 0 through 9
+#   re.any("A-Z", "a-z", "0-9", "_")
+#                         -- Matches alphanumeric or an underscore
+#
+# See Re::ConstructionMethods for a complete list of common constants
+# and character class functions.
+#
+# See Re.re, Re::Rexp, and Re::ConstructionMethods for details.
+#
+# == License and Copyright:
+#
+# Copyright 2009 by Jim Weirich (jim.weirich@gmail.com)
+#
+# Re is provided under the MIT open source license (see MIT-LICENSE)
+#
+# == Links:
+#
+# * Documentation :: http://re-lib.rubyforge.org
+# * Source        :: http://github.com/jimweirich/re
+# * Bug Tracker   :: http://www.pivotaltracker.com/projects/47758
+# * Author        :: jim.weirich@gmail.com
 #
-# See Re.re,
-# Re::Rexp, and Re::NULL for details.
-
 module Re
+  
+  module Version
+    NUMBERS = [
+      MAJOR = 0,
+      MINOR = 0,
+      BUILD = 3,
+      BETA  = nil,
+    ].compact
+  end
+  VERSION = Version::NUMBERS.join('.')
+  
+  # Re::Result captures the result of a match and allows lookup of the
+  # captured groups by name.
   class Result
+    # Create a Re result object with the match data and the origina
+    # Re::Rexp object.
     def initialize(match_data, rexp)
       @match_data = match_data
       @rexp = rexp
     end
-    def data(name=nil)
-      if name
-        index = @rexp.capture_keys.index(name)
-        index ? @match_data[index+1] : nil
-      else
-        @match_data[0]
-      end
+    
+    # Return the full match
+    def full_match
+      @match_data[0]
+    end
+    
+    # Return the named capture data.
+    def [](name)
+      index = @rexp.capture_keys.index(name)
+      index ? @match_data[index+1] : nil
     end
   end
-  
+
   # Precedence levels for regular expressions:
 
   GROUPED = 4                   # (r), [chars]      :nodoc:
@@ -65,22 +139,22 @@ module Re
 
   # Constructed regular expressions.
   class Rexp
-    attr_reader :string, :level, :flags, :capture_keys
+    attr_reader :string, :level, :options, :capture_keys
 
     # Create a regular expression from the string.  The regular
     # expression will have a precedence of +level+ and will recognized
     # +keys+ as a list of capture keys.
-    def initialize(string, level, flags, keys)
+    def initialize(string, level, options, keys)
       @string = string
       @level = level
-      @flags = flags
+      @options = options
       @capture_keys = keys
     end
 
     # Return a real regular expression from the the constructed
     # regular expression.
     def regexp
-      @regexp ||= Regexp.new(string, flags)
+      @regexp ||= Regexp.new(string, options)
     end
 
     # Does it match a string? (returns Re::Result if match, nil otherwise)
@@ -94,7 +168,7 @@ module Re
     def +(other)
       Rexp.new(parenthesize(CONCAT) + other.parenthesize(CONCAT),
         CONCAT,
-        flags | other.flags,
+        options | other.options,
         capture_keys + other.capture_keys)
     end
 
@@ -102,43 +176,53 @@ module Re
     def |(other)
       Rexp.new(parenthesize(ALT) + "|" + other.parenthesize(ALT),
         ALT,
-        flags | other.flags,
+        options | other.options,
         capture_keys + other.capture_keys)
     end
 
     # self is optional
     def optional
-      Rexp.new(parenthesize(POSTFIX) + "?", POSTFIX, flags, capture_keys)
+      Rexp.new(parenthesize(POSTFIX) + "?", POSTFIX, options, capture_keys)
     end
 
     # self matches many times (zero or more)
     def many
-      Rexp.new(parenthesize(POSTFIX) + "*", POSTFIX, flags, capture_keys)
+      Rexp.new(parenthesize(POSTFIX) + "*", POSTFIX, options, capture_keys)
+    end
+
+    # self matches many times (zero or more) (non-greedy version)
+    def many!
+      Rexp.new(parenthesize(POSTFIX) + "*?", POSTFIX, options, capture_keys)
     end
 
     # self matches one or more times
     def one_or_more
-      Rexp.new(parenthesize(POSTFIX) + "+", POSTFIX, flags, capture_keys)
+      Rexp.new(parenthesize(POSTFIX) + "+", POSTFIX, options, capture_keys)
+    end
+
+    # self matches one or more times
+    def one_or_more!
+      Rexp.new(parenthesize(POSTFIX) + "+?", POSTFIX, options, capture_keys)
     end
 
     # self is repeated from min to max times.  If max is omitted, then
     # it is repeated exactly min times.
     def repeat(min, max=nil)
       if min && max
-        Rexp.new(parenthesize(POSTFIX) + "{#{min},#{max}}", POSTFIX, flags, capture_keys)
+        Rexp.new(parenthesize(POSTFIX) + "{#{min},#{max}}", POSTFIX, options, capture_keys)
       else
-        Rexp.new(parenthesize(POSTFIX) + "{#{min}}", POSTFIX, flags, capture_keys)
+        Rexp.new(parenthesize(POSTFIX) + "{#{min}}", POSTFIX, options, capture_keys)
       end
     end
 
     # self is repeated at least min times
     def at_least(min)
-      Rexp.new(parenthesize(POSTFIX) + "{#{min},}", POSTFIX, flags, capture_keys)
+      Rexp.new(parenthesize(POSTFIX) + "{#{min},}", POSTFIX, options, capture_keys)
     end
 
     # self is repeated at least max times
     def at_most(max)
-      Rexp.new(parenthesize(POSTFIX) + "{0,#{max}}", POSTFIX, flags, capture_keys)
+      Rexp.new(parenthesize(POSTFIX) + "{0,#{max}}", POSTFIX, options, capture_keys)
     end
 
     # None of the given characters will match.
@@ -158,27 +242,27 @@ module Re
 
     # self must match at the beginning of a line
     def bol
-      Rexp.new("^" + parenthesize(CONCAT), CONCAT, flags, capture_keys)
+      Rexp.new("^" + parenthesize(CONCAT), CONCAT, options, capture_keys)
     end
 
     # self must match at the end of a line
     def eol
-      Rexp.new(parenthesize(CONCAT) + "$", CONCAT, flags, capture_keys)
+      Rexp.new(parenthesize(CONCAT) + "$", CONCAT, options, capture_keys)
     end
 
     # self must match at the beginning of the string
     def begin
-      Rexp.new("\\A" + parenthesize(CONCAT), CONCAT, flags, capture_keys)
+      Rexp.new("\\A" + parenthesize(CONCAT), CONCAT, options, capture_keys)
     end
 
     # self must match the end of the string (with an optional new line)
     def end
-      Rexp.new(parenthesize(CONCAT) + "\\Z", CONCAT, flags, capture_keys)
+      Rexp.new(parenthesize(CONCAT) + "\\Z", CONCAT, options, capture_keys)
     end
 
     # self must match the very end of the string (including any new lines)
     def very_end
-      Rexp.new(parenthesize(CONCAT) + "\\z", CONCAT, flags, capture_keys)
+      Rexp.new(parenthesize(CONCAT) + "\\z", CONCAT, options, capture_keys)
     end
 
     # self must match an entire line.
@@ -188,32 +272,32 @@ module Re
 
     # self is contained in a non-capturing group
     def group
-      Rexp.new("(?:" + string + ")", GROUPED, flags, capture_keys)
+      Rexp.new("(?:" + string + ")", GROUPED, options, capture_keys)
     end
 
     # self is a capturing group with the given name.
     def capture(name)
-      Rexp.new("(" + string + ")", GROUPED, flags, [name] + capture_keys)
+      Rexp.new("(" + string + ")", GROUPED, options, [name] + capture_keys)
     end
     
     # self will work in multiline matches
     def multiline
-      Rexp.new(string, GROUPED, flags|Regexp::MULTILINE, capture_keys)
+      Rexp.new(string, GROUPED, options|Regexp::MULTILINE, capture_keys)
     end
     
     # Is this a multiline regular expression?
     def multiline?
-      (flags & Regexp::MULTILINE) != 0
+      (options & Regexp::MULTILINE) != 0
     end
 
     # self will work in multiline matches
     def ignore_case
-      Rexp.new(string, GROUPED, flags|Regexp::IGNORECASE, capture_keys)
+      Rexp.new(string, GROUPED, options|Regexp::IGNORECASE, capture_keys)
     end
 
     # Does this regular expression ignore case?
     def ignore_case?
-      (flags & Regexp::IGNORECASE) != 0
+      (options & Regexp::IGNORECASE) != 0
     end
 
     # String representation of the constructed regular expression.
@@ -267,107 +351,155 @@ module Re
   def re(exp=nil)
     exp ? Rexp.literal(exp) : NULL
   end
+  extend self
   
-  # Matches an empty string.  Additional common regular expression
-  # constants are defined as methods on the NULL Rexp.  See Re::NULL.
-  NULL = Rexp.literal("")
-
-  # Matches the null string
-  def NULL.null
-    self
-  end
-
-  # :call-seq:
-  #   re.any
-  #   re.any(chars)
-  #   re.any(range)
-  #   re.any(chars, range, ...)
-  #
-  # Match a character from the character class.
-  #
-  # Any without any arguments will match any single character.  Any
-  # with one or more arguments will construct a character class for
-  # the arguments.  If the argument is a three character string where
-  # the middle character is "-", then the argument represents a range
-  # of characters.  Otherwise the arguments are treated as a list of
-  # characters to be added to the character class.
-  #
-  # Examples:
-  #
-  #   re.any                            -- match any character
-  #   re.any("aieouy")                  -- match vowels
-  #   re.any("0-9")                     -- match digits
-  #   re.any("A-Z", "a-z", "0-9")       -- match alphanumerics
-  #   re.any("A-Z", "a-z", "0-9", "_")  -- match alphanumerics
-  #
-  def NULL.any(*chars)
-    if chars.empty?
-      @dot ||= Rexp.raw(".")
-    else
-      any_chars = ''
-      chars.each do |chs|
-        if /^.-.$/ =~ chs
-          any_chars << chs
-        else
-          any_chars << Rexp.escape_any(chs)
+  # This module defines a number of methods returning common
+  # pre-packaged regular expressions along with methods to create
+  # regular expressions from character classes and other objects.
+  # ConstructionMethods is mixed into the NULL Rexp object so that
+  # re() without arguments can be used to access the methods.
+  module ConstructionMethods
+    
+    # :call-seq:
+    #   re.null
+    #
+    # Matches the null string
+    def null
+      self
+    end
+    
+    # :call-seq:
+    #   re.any
+    #   re.any(chars)
+    #   re.any(range)
+    #   re.any(chars, range, ...)
+    #
+    # Match a character from the character class.
+    #
+    # Any without any arguments will match any single character.  Any
+    # with one or more arguments will construct a character class for
+    # the arguments.  If the argument is a three character string where
+    # the middle character is "-", then the argument represents a range
+    # of characters.  Otherwise the arguments are treated as a list of
+    # characters to be added to the character class.
+    #
+    # Examples:
+    #
+    #   re.any                            -- match any character
+    #   re.any("aieouy")                  -- match vowels
+    #   re.any("0-9")                     -- match digits
+    #   re.any("A-Z", "a-z", "0-9")       -- match alphanumerics
+    #   re.any("A-Z", "a-z", "0-9", "_")  -- match alphanumerics
+    #
+    def any(*chars)
+      if chars.empty?
+        @dot ||= Rexp.raw(".")
+      else
+        any_chars = ''
+        chars.each do |chs|
+          if /^.-.$/ =~ chs
+            any_chars << chs
+          else
+            any_chars << Rexp.escape_any(chs)
+          end
         end
+        Rexp.new("[" + any_chars  + "]", GROUPED, 0, [])
       end
-      Rexp.new("[" + any_chars  + "]", GROUPED, 0, [])
     end
-  end
-  
-  # Matches any white space
-  def NULL.space
-    @space ||= Rexp.raw("\\s")
-  end
-
+    
+    # :call-seq:
+    #   re.space
+    #
+    # Matches any white space
+    def space
+      @space ||= Rexp.raw("\\s")
+    end
+    
+    # :call-seq:
+    #   re.spaces
+    #
     # Matches any white space
-  def NULL.spaces
-    @spaces ||= space.one_or_more
+    def spaces
+      @spaces ||= space.one_or_more
+    end
+    
+    # :call-seq:
+    #   re.nonspace
+    #
+    # Matches any non-white space
+    def nonspace
+      @nonspace ||= Rexp.raw("\\S")
+    end
+    
+    # :call-seq:
+    #   re.nonspaces
+    #
+    # Matches any non-white space
+    def nonspaces
+      @nonspaces ||= Rexp.raw("\\S").one_or_more
+    end
+    
+    # :call-seq:
+    #   re.word_char
+    #
+    # Matches any sequence of word characters
+    def word_char
+      @word_char ||= Rexp.raw("\\w")
+    end
+    
+    # :call-seq:
+    #   re.word
+    #
+    # Matches any sequence of word characters
+    def word
+      @word ||= word_char.one_or_more
+    end
+    
+    # :call-seq:
+    #   re.break
+    #
+    # Zero-length matches any break
+    def break
+      @break ||= Rexp.raw("\\b")
+    end
+    
+    # :call-seq:
+    #   re.digit
+    #
+    # Matches a digit
+    def digit
+      @digit ||= any("0-9")
+    end
+    
+    # :call-seq:
+    #   re.digits
+    #
+    # Matches a sequence of digits
+    def digits
+      @digits ||= digit.one_or_more
+    end
+    
+    # :call-seq:
+    #   re.hex_digit
+    #
+    # Matches a hex digit (upper or lower case)
+    def hex_digit
+      @hex_digit ||= any("0-9", "a-f", "A-F")
+    end
+    
+    # :call-seq:
+    #   re.hex_digits
+    #
+    # Matches a sequence of hex digits
+    def hex_digits
+      @hex_digits ||= hex_digit.one_or_more
+    end
   end
 
-  # Matches any non-white space
-  def NULL.nonspace
-    @nonspace ||= Rexp.raw("\\S")
-  end
-  
-  # Matches any non-white space
-  def NULL.nonspaces
-    @nonspaces ||= Rexp.raw("\\S").one_or_more
-  end
-  
-  # Matches any sequence of word characters
-  def NULL.word_char
-    @word_char ||= Rexp.raw("\\w")
-  end
-  
-  # Matches any sequence of word characters
-  def NULL.word
-    @word ||= word_char.one_or_more
-  end
-  
-  # Zero-length matches any break
-  def NULL.break
-    @break ||= Rexp.raw("\\b")
-  end
-  
-  # Matches a digit
-  def NULL.digit
-    @digit ||= any("0-9")
-  end
-  
-  # Matches a sequence of digits
-  def NULL.digits
-    @digits ||= digit.one_or_more
-  end
-  
-  # Matches a hex digit (upper or lower case)
-  def NULL.hex_digit
-    @hex_digit ||= any("0-9", "a-f", "A-F")
-  end
-  
-  # Matches a sequence of hex digits
-  def NULL.hex_digits
-    @hex_digits ||= hex_digit.one_or_more
-  end
+  # Matches an empty string.  Additional common regular expression
+  # construction methods are defined on NULL. See
+  # Re::ConstructionMethods for details.
+  NULL = Rexp.literal("")
+  NULL.extend(ConstructionMethods)
+
 end

data/test/re_test.rb

@@ -6,6 +6,11 @@ require 're'
 class ReTest < Test::Unit::TestCase
   include Re
 
+  def test_module_access_to_re_function
+    r = Re.re("a").all
+    assert r =~ "a"
+  end
+
   def test_strings_match
     assert re("a") =~ "a"
     assert re("a") !~ "A"
@@ -46,6 +51,20 @@ class ReTest < Test::Unit::TestCase
     assert r =~ "xxx"
   end
 
+  def test_greedy_many
+    r =  re.any.many.capture(:x) + re("b")
+    result = r.match("xbxb")
+    assert result
+    assert_equal "xbx", result[:x]
+  end
+
+  def test_non_greedy_many
+    r =  re.any.many!.capture(:x) + re("b")
+    result = r.match("xbxb")
+    assert result
+    assert_equal "x", result[:x]
+  end
+
   def test_one_or_more
     r = re("x").one_or_more.all
     assert r !~ ""
@@ -53,6 +72,20 @@ class ReTest < Test::Unit::TestCase
     assert r =~ "xxx"
   end
   
+  def test_greedy_one_or_more
+    r = re.any.one_or_more.capture(:any) + re("b")
+    result = r.match("xbxb")
+    assert result
+    assert_equal "xbx", result[:any]
+  end
+  
+  def test_non_greedy_one_or_more
+    r = re.any.one_or_more!.capture(:any) + re("b")
+    result = r.match("xbxb")
+    assert result
+    assert_equal "x", result[:any]
+  end
+  
   def test_repeat_fixed_number
     r = re("a").repeat(3).all
     assert r =~ "aaa"
@@ -104,7 +137,7 @@ class ReTest < Test::Unit::TestCase
     assert r !~ "\n"
   end
   
-  def test_no_flags
+  def test_no_options
     r = re("a")
     assert ! r.ignore_case?
     assert ! r.multiline?
@@ -363,7 +396,7 @@ class ReTest < Test::Unit::TestCase
     r = re.any("a-z").one_or_more.capture(:word)
     result = (r =~ "012abc789")
     assert result
-    assert_equal "abc", result.data(:word)
+    assert_equal "abc", result[:word]
   end
 
   def test_multiple_capture
@@ -373,10 +406,10 @@ class ReTest < Test::Unit::TestCase
     result = (r =~ "   now   123\n")
     assert result
     assert_equal [:everything, :word, :number], r.capture_keys
-    assert_equal "now", result.data(:word)
-    assert_equal "123", result.data(:number)
-    assert_equal "now   123", result.data(:everything)
-    assert_equal "now   123", result.data
+    assert_equal "now", result[:word]
+    assert_equal "123", result[:number]
+    assert_equal "now   123", result[:everything]
+    assert_equal "now   123", result.full_match
   end
   
   def test_precedence_concatentaion_vs_alteration
@@ -397,25 +430,10 @@ class ReTest < Test::Unit::TestCase
 
     result = delim_definition.match("//[a][b][xyz]\n1a2b3xyz4")
     assert result
-    assert_equal "[a][b][xyz]", result.data(:delims)
+    assert_equal "[a][b][xyz]", result[:delims]
   end
   
   def test_date_parser
-    # (19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])
-
-    delim      = re.any("- /.")
-    n_19_or_20 = re("19") | re("20")
-    n_1_to_9   = re("0") + re.any("1-9")
-    n_10_to_12 = re("1") + re.any("012")
-    n_10_to_29 = re.any("12") + re.any("0-9")
-    n_30_or_31 = re("3") + re.any("01")
-    
-    year = n_19_or_20 + re.digit.repeat(2)
-    month = n_1_to_9 | n_10_to_12
-    day = n_1_to_9 | n_10_to_29 | n_30_or_31
-
-    date_re = (year.capture(:year) + delim + month.capture(:month) + delim + day.capture(:day)).all
-    
     assert date_re.match("1900/01/01")
     assert date_re.match("1956/01/01")
     assert date_re.match("2000/01/01")
@@ -435,6 +453,40 @@ class ReTest < Test::Unit::TestCase
     assert ! date_re.match("2010/1/01")
     assert ! date_re.match("2010/01/1")
   end
+  
+  def test_date_capture
+    result = date_re.match("2010/02/14")
+    assert result
+    assert_equal "2010", result[:year]
+    assert_equal "02", result[:month]
+    assert_equal "14", result[:day]
+  end
 
+  private
 
+  def date_re
+    self.class.date_re
+  end
+  
+  class << self
+    include Re
+    def date_re
+      # (19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])
+      @date_re ||=
+        begin
+          delim_re                = re.any("- /.")
+          century_prefix_re       = re("19") | re("20")
+          under_ten_re            = re("0") + re.any("1-9")
+          ten_to_twelve_re        = re("1") + re.any("012")
+          ten_and_under_thirty_re = re.any("12") + re.any("0-9")
+          thirties_re             = re("3") + re.any("01")
+          
+          year = century_prefix_re + re.digit.repeat(2)
+          month = under_ten_re | ten_to_twelve_re
+          day = under_ten_re | ten_and_under_thirty_re | thirties_re
+          
+          (year.capture(:year) + delim_re + month.capture(:month) + delim_re + day.capture(:day)).all
+        end
+    end
+  end  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: re
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jim Weirich
@@ -22,12 +22,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- MIT-LICENSE
 - Rakefile
 - README.rdoc
 - lib/re.rb
 - test/re_test.rb
 has_rdoc: true
-homepage: http://re.rubyforge.org
+homepage: http://re-lib.rubyforge.org
 licenses: []
 
 post_install_message: