re 0.0.1

data/README.rdoc

@@ -0,0 +1,39 @@
+
+= Regular Expression Construction.
+
+Construct regular expressions using the re() method.
+
+Usage:
+
+  include Re
+
+  number = re.any("0-9").all
+  if number =~ string
+    puts "Matches!"
+  else
+    puts "No Match"
+  end
+
+Examples:
+
+  re("a")                -- matches "a"
+  re("a") + re("b")      -- matches "ab"
+  re("a") | re("b")      -- matches "a" or "b"
+  re("a").many           -- matches "", "a", "aaaaaa"
+  re("a").one_or_more    -- matches "a", "aaaaaa", but not ""
+  re("a").optional       -- matches "" or "a"
+  re("a").all            -- matches "a", but not "xab"
+
+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.digit / re.digits  -- matches a digit / sequence of digits
+
+See Re::NULL for a complete list of common constants.
+
+See Re.re,
+Re::Rexp, and Re::NULL for details.

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby"
+
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.warning = true
+  t.verbose = false
+  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"]
+end

data/lib/re.rb

@@ -0,0 +1,373 @@
+#!/usr/bin/ruby -wKU
+#
+# = Regular Expression Construction.
+#
+# Construct regular expressions using the re() method.
+#
+# Usage:
+#
+#   include Re
+#
+#   number = re.any("0-9").all
+#   if number =~ string
+#     puts "Matches!"
+#   else
+#     puts "No Match"
+#   end
+#
+# Examples:
+#
+#   re("a")                -- matches "a"
+#   re("a") + re("b")      -- matches "ab"
+#   re("a") | re("b")      -- matches "a" or "b"
+#   re("a").many           -- matches "", "a", "aaaaaa"
+#   re("a").one_or_more    -- matches "a", "aaaaaa", but not ""
+#   re("a").optional       -- matches "" or "a"
+#   re("a").all            -- matches "a", but not "xab"
+#
+# 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.digit / re.digits  -- matches a digit / sequence of digits
+#
+# See Re::NULL for a complete list of common constants.
+#
+# See Re.re,
+# Re::Rexp, and Re::NULL for details.
+
+module Re
+  class Result
+    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
+    end
+  end
+  
+  # Precedence levels for regular expressions:
+
+  GROUPED = 4                   # (r), [chars]      :nodoc:
+  POSTFIX = 3                   # r*, r+, r?        :nodoc:
+  CONCAT  = 2                   # r + r, literal    :nodoc:
+  ALT     = 1                   # r | r             :nodoc:
+
+
+  # Constructed regular expressions.
+  class Rexp
+    attr_reader :string, :level, :flags, :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)
+      @string = string
+      @level = level
+      @flags = flags
+      @capture_keys = keys
+    end
+
+    # Return a real regular expression from the the constructed
+    # regular expression.
+    def regexp
+      @regexp ||= Regexp.new(string, flags)
+    end
+
+    # Does it match a string? (returns Re::Result if match, nil otherwise)
+    def match(string)
+      md = regexp.match(string)
+      md ? Result.new(md, self) : nil
+    end
+    alias =~ match
+    
+    # Concatenate two regular expressions
+    def +(other)
+      Rexp.new(parenthesize(CONCAT) + other.parenthesize(CONCAT),
+        CONCAT,
+        flags | other.flags,
+        capture_keys + other.capture_keys)
+    end
+
+    # Matches either self or other
+    def |(other)
+      Rexp.new(parenthesize(ALT) + "|" + other.parenthesize(ALT),
+        ALT,
+        flags | other.flags,
+        capture_keys + other.capture_keys)
+    end
+
+    # self is optional
+    def optional
+      Rexp.new(parenthesize(POSTFIX) + "?", POSTFIX, flags, capture_keys)
+    end
+
+    # self matches many times (zero or more)
+    def many
+      Rexp.new(parenthesize(POSTFIX) + "*", POSTFIX, flags, capture_keys)
+    end
+
+    # self matches one or more times
+    def one_or_more
+      Rexp.new(parenthesize(POSTFIX) + "+", POSTFIX, flags, 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)
+      else
+        Rexp.new(parenthesize(POSTFIX) + "{#{min}}", POSTFIX, flags, capture_keys)
+      end
+    end
+
+    # self is repeated at least min times
+    def at_least(min)
+      Rexp.new(parenthesize(POSTFIX) + "{#{min},}", POSTFIX, flags, capture_keys)
+    end
+
+    # self is repeated at least max times
+    def at_most(max)
+      Rexp.new(parenthesize(POSTFIX) + "{0,#{max}}", POSTFIX, flags, capture_keys)
+    end
+
+    # None of the given characters will match.
+    def none(chars)
+      Rexp.new("[^" + Rexp.escape_any(chars) + "]", GROUPED, 0, [])
+    end
+
+    # self must match all of the string
+    def all
+      self.begin.very_end
+    end
+
+    # self must match almost all of the string (trailing new lines are allowed)
+    def almost_all
+      self.begin.end
+    end
+
+    # self must match at the beginning of a line
+    def bol
+      Rexp.new("^" + parenthesize(CONCAT), CONCAT, flags, capture_keys)
+    end
+
+    # self must match at the end of a line
+    def eol
+      Rexp.new(parenthesize(CONCAT) + "$", CONCAT, flags, capture_keys)
+    end
+
+    # self must match at the beginning of the string
+    def begin
+      Rexp.new("\\A" + parenthesize(CONCAT), CONCAT, flags, 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)
+    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)
+    end
+
+    # self must match an entire line.
+    def line
+      self.bol.eol
+    end
+
+    # self is contained in a non-capturing group
+    def group
+      Rexp.new("(?:" + string + ")", GROUPED, flags, capture_keys)
+    end
+
+    # self is a capturing group with the given name.
+    def capture(name)
+      Rexp.new("(" + string + ")", GROUPED, flags, [name] + capture_keys)
+    end
+    
+    # self will work in multiline matches
+    def multiline
+      Rexp.new(string, GROUPED, flags|Regexp::MULTILINE, capture_keys)
+    end
+    
+    # Is this a multiline regular expression?
+    def multiline?
+      (flags & Regexp::MULTILINE) != 0
+    end
+
+    # self will work in multiline matches
+    def ignore_case
+      Rexp.new(string, GROUPED, flags|Regexp::IGNORECASE, capture_keys)
+    end
+
+    # Does this regular expression ignore case?
+    def ignore_case?
+      (flags & Regexp::IGNORECASE) != 0
+    end
+
+    # String representation of the constructed regular expression.
+    def to_s
+      regexp.to_s
+    end
+    
+    protected
+
+    # 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)
+      if level >= new_level
+        string
+      else
+        group.string
+      end
+    end
+    
+    # Create a literal regular expression (concatenation level
+    # precedence, no capture keywords).
+    def self.literal(chars)
+      new(Regexp.escape(chars), CONCAT, 0, [])
+    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).
+    def self.raw(re_string)     # :no-doc:
+      new(re_string, GROUPED, 0, [])
+    end
+
+    # Escape any special characters.
+    def self.escape_any(chars)
+      chars.gsub(/([\[\]\^\-])/) { "\\#{$1}" }
+    end
+  end
+
+  
+  # Construct a regular expression from the literal string.  Special
+  # Regexp characters will be escaped before constructing the regular
+  # expression.  If no literal is given, then the NULL regular
+  # expression is returned.
+  #
+  # See Re for example usage.
+  #
+  def re(exp=nil)
+    exp ? Rexp.literal(exp) : NULL
+  end
+  
+  # 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)
+        end
+      end
+      Rexp.new("[" + any_chars  + "]", GROUPED, 0, [])
+    end
+  end
+  
+  # Matches any white space
+  def NULL.space
+    @space ||= Rexp.raw("\\s")
+  end
+
+    # Matches any white space
+  def NULL.spaces
+    @spaces ||= space.one_or_more
+  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
+end

data/test/re_test.rb

@@ -0,0 +1,440 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 're'
+
+class ReTest < Test::Unit::TestCase
+  include Re
+
+  def test_strings_match
+    assert re("a") =~ "a"
+    assert re("a") !~ "A"
+  end
+  
+  def test_not_match
+    assert re("a") !~ "b"
+  end
+
+  def test_special_characters_match
+    r = re("()").all
+    assert r =~ "()"
+  end
+
+  def test_concatenation
+    r = re("a") + re("b")
+    assert r =~ "ab"
+    assert r !~ "xb"
+  end
+  
+  def test_null
+    r = re("a") + re.null + re("b")
+    assert r =~ "ab"
+  end
+
+  def test_alteration
+    r = re("a") | re("b")
+    assert r =~ "a"
+    assert r =~ "b"
+    assert r !~ "x"
+  end
+  
+  def test_many
+    r =  re("x").many.all
+    assert r !~ "z"
+    assert r =~ ""
+    assert r =~ "x"
+    assert r =~ "xxx"
+  end
+
+  def test_one_or_more
+    r = re("x").one_or_more.all
+    assert r !~ ""
+    assert r =~ "x"
+    assert r =~ "xxx"
+  end
+  
+  def test_repeat_fixed_number
+    r = re("a").repeat(3).all
+    assert r =~ "aaa"
+    assert r !~ "aa"
+    assert r !~ "aaaa"
+  end
+
+  def test_repeat_range
+    r = re("a").repeat(2, 4).all
+    assert r !~ "a"
+    assert r =~ "aa"
+    assert r =~ "aaa"
+    assert r =~ "aaaa"
+    assert r !~ "aaaaa"
+  end
+
+  def test_at_least
+    r = re("a").at_least(2).all
+    assert r !~ "a"
+    assert r =~ "aa"
+    assert r =~ "aaaaaaaaaaaaaaaaaaaa"
+  end
+
+  def test_at_most
+    r = re("a").at_most(4).all
+    assert r =~ ""
+    assert r =~ "a"
+    assert r =~ "aa"
+    assert r =~ "aaa"
+    assert r =~ "aaaa"
+    assert r !~ "aaaaa"
+  end
+  
+  def test_optional
+    r = re("a").optional.all
+    assert r =~ ""
+    assert r =~ "a"
+    assert r !~ "aa"
+  end
+
+  def test_any_with_no_arguments
+    r = re.any.all
+    assert r =~ "a"
+    assert r =~ "1"
+    assert r =~ "#"
+    assert r =~ "."
+    assert r =~ " "
+    assert r !~ "ab"
+    assert r !~ "\n"
+  end
+  
+  def test_no_flags
+    r = re("a")
+    assert ! r.ignore_case?
+    assert ! r.multiline?
+  end
+
+  def test_any_with_multiline
+    r = re.any.multiline.all
+    assert r.multiline?
+    assert r =~ "\n"
+  end
+  
+  def test_ignore_case
+    r = re("a").ignore_case.all
+    assert r.ignore_case?
+    assert r =~ "a"
+    assert r =~ "A"
+  end
+
+  def test_any_with_a_character_list
+    r = re.any("xyz").all
+    assert r !~ "w"
+    assert r =~ "x"
+    assert r =~ "y"
+    assert r =~ "z"
+  end
+
+  def test_any_with_special_chars
+    r = re.any("^.(-)[]").all
+    assert r !~ "x"
+    assert r =~ "."
+    assert r =~ "^"
+    assert r =~ "-"
+    assert r =~ "("
+    assert r =~ ")"
+    assert r =~ "["
+    assert r =~ "]"
+  end
+  
+  def test_range_of_chars
+    r = re.any("a-z").many.all
+    assert r =~ "abcdefghijklmnopqrstuvwxyz"
+  end
+
+  def test_range_and_mix_of_chars
+    r = re.any("0-9", ".-").many.all
+    assert r =~ "-12.3"
+  end
+
+  def test_none
+    r = re.none("xyz").all
+    assert r =~ "w"
+    assert r !~ "x"
+    assert r !~ "y"
+    assert r !~ "z"
+  end
+
+  def test_none_with_special_chars
+    r = re.none("^.()[]-").all
+    assert r =~ "x"
+    assert r !~ "."
+    assert r !~ "^"
+    assert r !~ "-"
+    assert r !~ "("
+    assert r !~ ")"
+    assert r !~ "["
+    assert r !~ "]"
+  end
+  
+  def test_all
+    r = re("a").all
+    assert r =~ "a"
+    assert r !~ "a\n"
+    assert r !~ "xa"
+    assert r !~ "ax"
+  end
+  
+  def test_almost_all
+    r = re("a").almost_all
+    assert r =~ "a"
+    assert r =~ "a\n"
+    assert r !~ "xa"
+    assert r !~ "ax"
+  end
+  
+  def test_all_across_lines
+    r = re("a").many.all
+    assert r =~ "a"
+    assert r !~ "b\na"
+  end
+  
+  def test_line
+    r = re("a").line
+    assert r =~ "a"
+    assert r =~ "b\na"
+    assert r =~ "b\na\n"
+    assert r =~ "b\na\nx"
+  end
+  
+  def test_bol
+    r = re("a").bol
+    assert r =~ "a"
+    assert r =~ "b\na"
+    assert r =~ "b\na"
+    assert r !~ "b\nxa"
+  end
+  
+  def test_eol
+    r = re("a").eol
+    assert r =~ "a"
+    assert r =~ "b\na\nx"
+    assert r !~ "b\nax"
+    assert r !~ "b\nax\n"
+  end
+  
+  def test_begin
+    r = re("a").begin
+    assert r =~ "a"
+    assert r =~ "a\nb"
+    assert r !~ "b\na"
+    assert r !~ "b\na"
+    assert r !~ "b\nxa"
+  end
+  
+  def test_begin2
+    r = re.begin + re("a")
+    assert r =~ "a"
+    assert r =~ "a\nb"
+    assert r !~ "b\na"
+    assert r !~ "b\na"
+    assert r !~ "b\nxa"
+  end
+  
+  def test_end
+    r = re("a").end
+    assert r =~ "a"
+    assert r =~ "b\na"
+    assert r =~ "b\na\n"
+    assert r !~ "b\na\nx"
+    assert r !~ "b\nax"
+    assert r !~ "b\nax\n"
+  end
+  
+  def test_end2
+    r = re("a") + re.end
+    assert r =~ "a"
+    assert r =~ "b\na"
+    assert r =~ "b\na\n"
+    assert r !~ "b\na\nx"
+    assert r !~ "b\nax"
+    assert r !~ "b\nax\n"
+  end
+  
+  def test_very_end
+    r = re("a").very_end
+    assert r =~ "a"
+    assert r =~ "b\na"
+    assert r !~ "b\na\n"
+    assert r !~ "b\na\nx"
+    assert r !~ "b\nax"
+    assert r !~ "b\nax\n"
+  end
+  
+  def test_hex_digit
+    r = re.hex_digit.all
+    assert r =~ "1"
+    assert r =~ "a"
+    assert r =~ "F"
+    assert r !~ "12"
+    assert r !~ "g"
+  end
+
+  def test_hex_digits
+    r = re.hex_digits.all
+    assert r =~ "1234567890abcedfABCDEF"
+    assert r !~ "g"
+  end
+
+  def test_digit
+    r = re.digit.all
+    assert r =~ "0"
+    assert r =~ "9"
+    assert r !~ "12"
+    assert r !~ "x"
+    assert r !~ "a"
+  end
+  
+  def test_digits
+    r = re.digits.all
+    assert r =~ "0123456789"
+    assert r !~ "0123456789x"
+  end
+  
+  def test_break
+    r = re.break + re("a") + re.break
+    assert r =~ "there is a home"
+    assert r !~ "there is an aardvark"
+  end
+  
+  def test_nonspace
+    r = re.nonspace.all
+    assert r =~ "a"
+    assert r =~ "1"
+    assert r =~ "#"
+    assert r !~ "ab"
+    assert r !~ " "
+    assert r !~ "\t"
+    assert r !~ "\n"
+  end
+
+  def test_nonspaces
+    r = re.nonspaces.all
+    assert r =~ "a"
+    assert r =~ "asdfhjkl!@\#$%^&*()_+="
+    assert r !~ ""
+    assert r !~ "a dog"
+  end
+
+  def test_space
+    r = re.space.all
+    assert r =~ " "
+    assert r =~ "\t"
+    assert r =~ "\n"
+    assert r !~ "x"
+    assert r !~ ""
+    assert r !~ "  "
+    assert re.space.many.all =~ " \n\t    "
+  end
+
+  def test_spaces
+    r = re.spaces.all
+    assert r =~ " "
+    assert r =~ "  "
+    assert r =~ " \t  \n  "
+    assert r !~ ""
+    assert r !~ "x"
+  end
+
+  def test_word_char
+    r = re.word_char.all
+    assert r =~ "a"
+    assert r =~ "1"
+    assert r =~ "_"
+    assert r !~ "!"
+    assert r !~ "?"
+  end
+  
+  def test_word
+    r = re.word.all
+    assert r =~ "a"
+    assert r =~ "1"
+    assert re.word.all =~ "this_is_a_test"
+    assert re.word.all !~ "asdf jkl"
+  end
+  
+  def test_single_capture
+    r = re.any("a-z").one_or_more.capture(:word)
+    result = (r =~ "012abc789")
+    assert result
+    assert_equal "abc", result.data(:word)
+  end
+
+  def test_multiple_capture
+    word = re.any("a-z").one_or_more.capture(:word)
+    number = re.any("0-9").one_or_more.capture(:number)
+    r = (word + re.spaces + number).capture(:everything)
+    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
+  end
+  
+  def test_precedence_concatentaion_vs_alteration
+    r = (re("a") | re("b") + re("c")).all
+    assert r =~ "a"
+    assert r =~ "bc"
+    assert r !~ "ac"
+  end
+  
+  def test_precendence_of_eol
+    r = re("a").bol.many
+  end
+  
+  def test_example
+    bracketed_delim = re("[") + re.none("]").one_or_more + re("]")
+    delims = bracketed_delim.one_or_more.capture(:delims)
+    delim_definition = re("//").bol + delims + re("\n")
+
+    result = delim_definition.match("//[a][b][xyz]\n1a2b3xyz4")
+    assert result
+    assert_equal "[a][b][xyz]", result.data(: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")
+    assert date_re.match("2010/01/01")
+    assert date_re.match("2010/12/01")
+    assert date_re.match("2010/03/01")
+    assert date_re.match("2010/03/12")
+    assert date_re.match("2010/03/24")
+    assert date_re.match("2010/03/30")
+    assert date_re.match("2010/03/31")
+
+    assert ! date_re.match("2100/01/01")
+    assert ! date_re.match("2100/01/32")
+    assert ! date_re.match("2010/00/01")
+    assert ! date_re.match("2010/13/01")
+    assert ! date_re.match("2010/01/00")
+    assert ! date_re.match("2010/1/01")
+    assert ! date_re.match("2010/01/1")
+  end
+
+
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: re
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Weirich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-28 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: "     The re library allows the easy construction of regular expressions via an expression language.\n"
+email: jim.weirich@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- lib/re.rb
+- test/re_test.rb
+has_rdoc: true
+homepage: http://re.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- re.rb
+- --title
+- Re -- Ruby Regular Expression Construction
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: re-lib
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Construct Ruby Regular Expressions
+test_files: []
+