re 0.0.3 → 0.0.4

data/MIT-LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2003, 2004 Jim Weirich
+Copyright (c) 2009, Jim Weirich
+
+All Rights Reserved
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -33,12 +33,12 @@ 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"
+  result = date.match("2009-01-23")
+  result.data(:year)   # => "2009"
+  result.data(:month)  # => "01"
+  result.data(:day)    # => "23"
 
-== Version: 0.0.3
+== Version: 0.0.4
 
 == Usage:
 
@@ -91,8 +91,9 @@ 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
+Documentation :: http://re-lib.rubyforge.org
+Source        :: http://github.com/jimweirich/re
+GemCutter     :: http://gemcutter.org/gems/re
+Bug Tracker   :: http://www.pivotaltracker.com/projects/47758
+Author        :: jim.weirich@gmail.com
 

data/lib/re.rb

@@ -34,10 +34,10 @@
 # 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"
+#   result = date.match("2009-01-23")
+#   result.data(:year)   # => "2009"
+#   result.data(:month)  # => "01"
+#   result.data(:day)    # => "23"
 #
 # == Usage:
 #
@@ -90,10 +90,11 @@
 #
 # == 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
+# Documentation :: http://re-lib.rubyforge.org
+# Source        :: http://github.com/jimweirich/re
+# GemCutter     :: http://gemcutter.org/gems/re
+# Bug Tracker   :: http://www.pivotaltracker.com/projects/47758
+# Author        :: jim.weirich@gmail.com
 #
 module Re
   
@@ -101,7 +102,7 @@ module Re
     NUMBERS = [
       MAJOR = 0,
       MINOR = 0,
-      BUILD = 3,
+      BUILD = 4,
       BETA  = nil,
     ].compact
   end
@@ -110,19 +111,19 @@ module Re
   # 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
+    # Create a Re result object with the match data and the original
     # Re::Rexp object.
     def initialize(match_data, rexp)
       @match_data = match_data
       @rexp = rexp
     end
     
-    # Return the full match
+    # Return the text of the full match.
     def full_match
       @match_data[0]
     end
     
-    # Return the named capture data.
+    # Return the text of the named capture data.
     def [](name)
       index = @rexp.capture_keys.index(name)
       index ? @match_data[index+1] : nil
@@ -136,25 +137,28 @@ module Re
   CONCAT  = 2                   # r + r, literal    :nodoc:
   ALT     = 1                   # r | r             :nodoc:
 
+  # Mode Bits
+
+  MULTILINE_MODE = Regexp::MULTILINE
+  IGNORE_CASE_MODE = Regexp::IGNORECASE
 
   # Constructed regular expressions.
   class Rexp
-    attr_reader :string, :level, :options, :capture_keys
+    attr_reader :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, options, keys)
-      @string = string
+    def initialize(string, level, keys, options=0)
+      @raw_string = string
       @level = level
-      @options = options
       @capture_keys = keys
+      @options = options
     end
-
-    # Return a real regular expression from the the constructed
-    # regular expression.
+    
+    # Return a Regexp from the the constructed regular expression.
     def regexp
-      @regexp ||= Regexp.new(string, options)
+      @regexp ||= Regexp.new(encoding)
     end
 
     # Does it match a string? (returns Re::Result if match, nil otherwise)
@@ -164,140 +168,152 @@ module Re
     end
     alias =~ match
     
-    # Concatenate two regular expressions
+    # New regular expresion that matches the concatenation of self and
+    # other.
     def +(other)
-      Rexp.new(parenthesize(CONCAT) + other.parenthesize(CONCAT),
+      Rexp.new(parenthesized_encoding(CONCAT) + other.parenthesized_encoding(CONCAT),
         CONCAT,
-        options | other.options,
         capture_keys + other.capture_keys)
     end
 
-    # Matches either self or other
+    # New regular expresion that matches either self or other.
     def |(other)
-      Rexp.new(parenthesize(ALT) + "|" + other.parenthesize(ALT),
+      Rexp.new(parenthesized_encoding(ALT) + "|" + other.parenthesized_encoding(ALT),
         ALT,
-        options | other.options,
         capture_keys + other.capture_keys)
     end
 
-    # self is optional
+    # New regular expression where self is optional.
     def optional
-      Rexp.new(parenthesize(POSTFIX) + "?", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "?", POSTFIX, capture_keys)
     end
 
-    # self matches many times (zero or more)
+    # New regular expression that matches self many (zero or more)
+    # times.
     def many
-      Rexp.new(parenthesize(POSTFIX) + "*", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "*", POSTFIX, capture_keys)
     end
 
-    # self matches many times (zero or more) (non-greedy version)
+    # New regular expression that matches self many (zero or more)
+    # times (non-greedy version).
     def many!
-      Rexp.new(parenthesize(POSTFIX) + "*?", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "*?", POSTFIX, capture_keys)
     end
 
-    # self matches one or more times
+    # New regular expression that matches self one or more times.
     def one_or_more
-      Rexp.new(parenthesize(POSTFIX) + "+", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "+", POSTFIX, capture_keys)
     end
 
-    # self matches one or more times
+    # New regular expression that matches self one or more times
+    # (non-greedy version).
     def one_or_more!
-      Rexp.new(parenthesize(POSTFIX) + "+?", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "+?", POSTFIX, capture_keys)
     end
 
-    # self is repeated from min to max times.  If max is omitted, then
-    # it is repeated exactly min times.
+    # New regular expression that matches self between +min+ and +max+
+    # times (inclusive).  If +max+ is omitted, then it must match self
+    # exactly exactly +min+ times.
     def repeat(min, max=nil)
       if min && max
-        Rexp.new(parenthesize(POSTFIX) + "{#{min},#{max}}", POSTFIX, options, capture_keys)
+        Rexp.new(parenthesized_encoding(POSTFIX) + "{#{min},#{max}}", POSTFIX, capture_keys)
       else
-        Rexp.new(parenthesize(POSTFIX) + "{#{min}}", POSTFIX, options, capture_keys)
+        Rexp.new(parenthesized_encoding(POSTFIX) + "{#{min}}", POSTFIX, capture_keys)
       end
     end
 
-    # self is repeated at least min times
+    # New regular expression that matches self at least +min+ times.
     def at_least(min)
-      Rexp.new(parenthesize(POSTFIX) + "{#{min},}", POSTFIX, options, capture_keys)
+      Rexp.new(parenthesized_encoding(POSTFIX) + "{#{min},}", POSTFIX, capture_keys)
     end
 
-    # self is repeated at least max times
+    # New regular expression that matches self at most +max+ times.
     def at_most(max)
-      Rexp.new(parenthesize(POSTFIX) + "{0,#{max}}", POSTFIX, options, capture_keys)
-    end
-
-    # None of the given characters will match.
-    def none(chars)
-      Rexp.new("[^" + Rexp.escape_any(chars) + "]", GROUPED, 0, [])
+      Rexp.new(parenthesized_encoding(POSTFIX) + "{0,#{max}}", POSTFIX, capture_keys)
     end
 
-    # self must match all of the string
+    # New regular expression that matches self across the complete
+    # string.
     def all
       self.begin.very_end
     end
 
-    # self must match almost all of the string (trailing new lines are allowed)
+    # New regular expression that matches self across most of the
+    # entire string (trailing new lines are not required to match).
     def almost_all
       self.begin.end
     end
 
-    # self must match at the beginning of a line
+    # New regular expression that matches self at the beginning of a line.
     def bol
-      Rexp.new("^" + parenthesize(CONCAT), CONCAT, options, capture_keys)
+      Rexp.new("^" + parenthesized_encoding(CONCAT), CONCAT, capture_keys)
     end
 
-    # self must match at the end of a line
+    # New regular expression that matches self at the end of the line.
     def eol
-      Rexp.new(parenthesize(CONCAT) + "$", CONCAT, options, capture_keys)
+      Rexp.new(parenthesized_encoding(CONCAT) + "$", CONCAT, capture_keys)
     end
 
-    # self must match at the beginning of the string
+    # New regular expression that matches self at the beginning of a string.
     def begin
-      Rexp.new("\\A" + parenthesize(CONCAT), CONCAT, options, capture_keys)
+      Rexp.new("\\A" + parenthesized_encoding(CONCAT), CONCAT, capture_keys)
     end
 
-    # self must match the end of the string (with an optional new line)
+    # New regular expression that matches self at the end of a string
+    # (trailing new lines are allowed to not match).
     def end
-      Rexp.new(parenthesize(CONCAT) + "\\Z", CONCAT, options, capture_keys)
+      Rexp.new(parenthesized_encoding(CONCAT) + "\\Z", CONCAT, capture_keys)
     end
 
-    # self must match the very end of the string (including any new lines)
+    # New regular expression that matches self at the very end of a string
+    # (trailing new lines are required to match).
     def very_end
-      Rexp.new(parenthesize(CONCAT) + "\\z", CONCAT, options, capture_keys)
+      Rexp.new(parenthesized_encoding(CONCAT) + "\\z", CONCAT, capture_keys)
     end
 
-    # self must match an entire line.
+    # New expression that matches self across an entire line.
     def line
       self.bol.eol
     end
 
-    # self is contained in a non-capturing group
+    # New regular expression that is grouped, but does not cause the
+    # capture of a match.  The Re library normally handles grouping
+    # automatically, so this method shouldn't be needed by client
+    # software for normal operations.
     def group
-      Rexp.new("(?:" + string + ")", GROUPED, options, capture_keys)
+      Rexp.new("(?:" + encoding + ")", GROUPED, capture_keys)
     end
 
-    # self is a capturing group with the given name.
+    # New regular expression that captures text matching self.  The
+    # matching text may be retrieved from the Re::Result object using
+    # the +name+ (a symbol) as the keyword.
     def capture(name)
-      Rexp.new("(" + string + ")", GROUPED, options, [name] + capture_keys)
+      Rexp.new("(" + encoding + ")", GROUPED, [name] + capture_keys)
     end
     
-    # self will work in multiline matches
+    # New regular expression that matches self in multiline mode.
     def multiline
-      Rexp.new(string, GROUPED, options|Regexp::MULTILINE, capture_keys)
+      Rexp.new(@raw_string, GROUPED, capture_keys, options | MULTILINE_MODE)
     end
     
-    # Is this a multiline regular expression?
+    # Is this a multiline regular expression?  The multiline mode of
+    # interior regular expressions are not reflected in value returned
+    # by this method.
     def multiline?
-      (options & Regexp::MULTILINE) != 0
+      (options & MULTILINE_MODE) != 0
     end
 
-    # self will work in multiline matches
+    # New regular expression that matches self while ignoring case.
     def ignore_case
-      Rexp.new(string, GROUPED, options|Regexp::IGNORECASE, capture_keys)
+      Rexp.new(@raw_string, GROUPED, capture_keys, options | IGNORE_CASE_MODE)
     end
 
-    # Does this regular expression ignore case?
+    # Does this regular expression ignore case?  Note that this only
+    # queries the outer most regular expression.  The ignore case mode
+    # of interior regular expressions are not reflected in value
+    # returned by this method.
     def ignore_case?
-      (options & Regexp::IGNORECASE) != 0
+      (options & IGNORE_CASE_MODE) != 0
     end
 
     # String representation of the constructed regular expression.
@@ -310,32 +326,51 @@ module Re
     # String representation with grouping if needed.
     #
     # If the precedence of the current Regexp is less than the new
-    # precedence level, return the string wrapped in a non-capturing
-    # group.  Otherwise just return the string.
-    def parenthesize(new_level)
+    # precedence level, return the encoding wrapped in a non-capturing
+    # group.  Otherwise just return the encoding.
+    def parenthesized_encoding(new_level)
       if level >= new_level
-        string
+        encoding
       else
-        group.string
+        group.encoding
       end
     end
     
-    # Create a literal regular expression (concatenation level
-    # precedence, no capture keywords).
+    # The string encoding of current regular expression.  The encoding
+    # will include option flags if specified.
+    def encoding
+      if options == 0
+        @raw_string
+      else
+        "(?#{encode_options}:" + @raw_string + ")"
+      end
+    end
+    
+    # Encode the options into a string (e.g "", "m", "i", or "mi")
+    def encode_options          # :nodoc:
+      (multiline? ? "m" : "") +
+        (ignore_case? ? "i" : "")
+    end
+    private :encode_options
+
+    # New regular expression that matches the literal characters in
+    # +chars+.  For example, Re.literal("a(b)") will be equivalent to
+    # /a\(b\)/.  Note that characters with special meanings in regular
+    # expressions will be quoted.
     def self.literal(chars)
-      new(Regexp.escape(chars), CONCAT, 0, [])
+      new(Regexp.escape(chars), CONCAT, [])
     end
 
-    # Create a regular expression from a raw string representing a
-    # regular expression.  The raw string should represent a regular
-    # expression with the highest level of precedence (you should use
-    # parenthesis if it is not).
+    # New regular expression constructed from a string representing a
+    # ruby regular expression.  The raw string should represent a
+    # regular expression with the highest level of precedence (you
+    # should use parenthesis if it is not).
     def self.raw(re_string)     # :no-doc:
-      new(re_string, GROUPED, 0, [])
+      new(re_string, GROUPED, [])
     end
 
-    # Escape any special characters.
-    def self.escape_any(chars)
+    # Escape special characters found in character classes.
+    def self.escape_any(chars)  # :nodoc:
       chars.gsub(/([\[\]\^\-])/) { "\\#{$1}" }
     end
   end
@@ -360,10 +395,12 @@ module Re
   # re() without arguments can be used to access the methods.
   module ConstructionMethods
     
+    ANY_CHAR =  Rexp.raw(".")
+    
     # :call-seq:
     #   re.null
     #
-    # Matches the null string
+    # Regular expression that matches the null string
     def null
       self
     end
@@ -374,43 +411,77 @@ module Re
     #   re.any(range)
     #   re.any(chars, range, ...)
     #
-    # Match a character from the character class.
+    # Regular expression that matches a character from a 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.
+    # +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
+    #   re.any                            -- matches any character
+    #   re.any("aieouy")                  -- matches vowels
+    #   re.any("0-9")                     -- matches digits
+    #   re.any("A-Z", "a-z", "0-9")       -- matches alphanumerics
+    #   re.any("A-Z", "a-z", "0-9", "_")  -- matches alphanumerics
+    #                                        plus an underscore
     #
     def any(*chars)
       if chars.empty?
-        @dot ||= Rexp.raw(".")
+        ANY_CHAR
       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, [])
+        Rexp.new("[" + char_class(chars)  + "]", GROUPED, [])
       end
     end
     
+    # :call-seq:
+    #   re.none(chars)
+    #   re.none(range)
+    #   re.none(chars, range, ...)
+    #
+    # Regular expression that matches a character not in a character
+    # class.
+    #
+    # +None+ with one or more arguments will construct a character
+    # class for the given 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.none("aieouy")                 -- matches non-vowels
+    #   re.any("0-9")                     -- matches non-digits
+    #   re.any("A-Z", "a-z", "0-9")       -- matches non-alphanumerics
+    #
+    def none(*chars)
+      Rexp.new("[^" + char_class(chars)  + "]", GROUPED, [])
+    end
+
+    def char_class(chars)
+      any_chars = ''
+      chars.each do |chs|
+        if /^.-.$/ =~ chs
+          any_chars << chs
+        else
+          any_chars << Rexp.escape_any(chs)
+        end
+      end
+      any_chars
+    end
+    private :char_class
+
     # :call-seq:
     #   re.space
     #
-    # Matches any white space
+    # Regular expression that matches any white space character.
+    # (equivalent to /\s/)
     def space
       @space ||= Rexp.raw("\\s")
     end
@@ -418,7 +489,8 @@ module Re
     # :call-seq:
     #   re.spaces
     #
-    # Matches any white space
+    # Regular expression that matches any sequence of white space
+    # characters.  (equivalent to /\s+/)
     def spaces
       @spaces ||= space.one_or_more
     end
@@ -426,7 +498,8 @@ module Re
     # :call-seq:
     #   re.nonspace
     #
-    # Matches any non-white space
+    # Regular expression that matches any non-white space character.
+    # (equivalent to /\S/)
     def nonspace
       @nonspace ||= Rexp.raw("\\S")
     end
@@ -434,7 +507,8 @@ module Re
     # :call-seq:
     #   re.nonspaces
     #
-    # Matches any non-white space
+    # Regular expression that matches any sequence of non-white space
+    # characters.  (equivalent to /\S+/)
     def nonspaces
       @nonspaces ||= Rexp.raw("\\S").one_or_more
     end
@@ -442,7 +516,8 @@ module Re
     # :call-seq:
     #   re.word_char
     #
-    # Matches any sequence of word characters
+    # Regular expression that matches any word character.  (equivalent
+    # to /\w/)
     def word_char
       @word_char ||= Rexp.raw("\\w")
     end
@@ -450,7 +525,8 @@ module Re
     # :call-seq:
     #   re.word
     #
-    # Matches any sequence of word characters
+    # Regular expression that matches any sequence of word characters.
+    # (equivalent to /\w+/)
     def word
       @word ||= word_char.one_or_more
     end
@@ -458,7 +534,8 @@ module Re
     # :call-seq:
     #   re.break
     #
-    # Zero-length matches any break
+    # Regular expression that matches any break between word/non-word
+    # characters.  This is a zero length match.  (equivalent to /\b/)
     def break
       @break ||= Rexp.raw("\\b")
     end
@@ -466,7 +543,8 @@ module Re
     # :call-seq:
     #   re.digit
     #
-    # Matches a digit
+    # Regular expression that matches a single digit.  (equivalent to
+    # /\d/)
     def digit
       @digit ||= any("0-9")
     end
@@ -474,7 +552,8 @@ module Re
     # :call-seq:
     #   re.digits
     #
-    # Matches a sequence of digits
+    # Regular expression that matches a sequence of digits.
+    # (equivalent to /\d+/)
     def digits
       @digits ||= digit.one_or_more
     end
@@ -482,7 +561,8 @@ module Re
     # :call-seq:
     #   re.hex_digit
     #
-    # Matches a hex digit (upper or lower case)
+    # Regular expression that matches a single hex digit.  (equivalent
+    # to /[A-Fa-f0-9]/)
     def hex_digit
       @hex_digit ||= any("0-9", "a-f", "A-F")
     end
@@ -490,7 +570,8 @@ module Re
     # :call-seq:
     #   re.hex_digits
     #
-    # Matches a sequence of hex digits
+    # Regular expression that matches a sequence of hex digits
+    # (equivalent to /[A-Fa-f0-9]+/)
     def hex_digits
       @hex_digits ||= hex_digit.one_or_more
     end

data/test/re_test.rb

@@ -138,23 +138,40 @@ class ReTest < Test::Unit::TestCase
   end
   
   def test_no_options
-    r = re("a")
+    r = re("a") + re.any + re("b")
     assert ! r.ignore_case?
     assert ! r.multiline?
+    assert r =~ "axb"
+    assert r !~ "a\nb"
+    assert r !~ "Axb"
   end
 
   def test_any_with_multiline
-    r = re.any.multiline.all
+    r = re.any.all.multiline
     assert r.multiline?
     assert r =~ "\n"
   end
   
   def test_ignore_case
-    r = re("a").ignore_case.all
-    assert r.ignore_case?
+    r = re("a").all.ignore_case
     assert r =~ "a"
     assert r =~ "A"
   end
+  
+  def test_partial_ignore_case
+    r = (re("a").ignore_case + re("b")).all
+    assert r =~ "ab"
+    assert r =~ "Ab"
+    assert r !~ "aB"
+  end
+  
+  def test_options_no_not_modify_existing_rexps
+    r = re("a")
+    r2 = r.ignore_case
+    
+    assert r !~ "A"
+    assert r2 =~ "A"
+  end
 
   def test_any_with_a_character_list
     r = re.any("xyz").all
@@ -176,17 +193,17 @@ class ReTest < Test::Unit::TestCase
     assert r =~ "]"
   end
   
-  def test_range_of_chars
+  def test_any_with_a_range_of_chars
     r = re.any("a-z").many.all
     assert r =~ "abcdefghijklmnopqrstuvwxyz"
   end
 
-  def test_range_and_mix_of_chars
+  def test_any_with_a_range_and_mix_of_chars
     r = re.any("0-9", ".-").many.all
     assert r =~ "-12.3"
   end
 
-  def test_none
+  def test_none_with_a_character_list
     r = re.none("xyz").all
     assert r =~ "w"
     assert r !~ "x"
@@ -206,6 +223,22 @@ class ReTest < Test::Unit::TestCase
     assert r !~ "]"
   end
   
+  def test_none_with_a_range_of_chars
+    r = re.none("a-z").many.all
+    assert r =~ "0123()$#"
+    assert r !~ "a"
+    assert r !~ "b"
+    assert r !~ "z"
+  end
+
+  def test_none_with_a_range_and_mix_of_chars
+    r = re.none("0-9", ".-").many.all
+    assert r =~ "abc%^&"
+    assert r !~ "-"
+    assert r !~ "."
+    assert r !~ "1"
+  end
+
   def test_all
     r = re("a").all
     assert r =~ "a"
@@ -471,7 +504,7 @@ class ReTest < Test::Unit::TestCase
   class << self
     include Re
     def date_re
-      # (19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])
+      # /\A((?:19|20)[0-9]{2})[\- \/.](0[1-9]|1[012])[\- \/.](0[1-9]|[12][0-9]|3[01])\z/
       @date_re ||=
         begin
           delim_re                = re.any("- /.")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: re
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Jim Weirich
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-28 00:00:00 -05:00
+date: 2009-12-29 00:00:00 -05:00
 default_executable: 
 dependencies: []