cnuregexp 1.0.0

data/README.txt

@@ -0,0 +1,43 @@
+cnuregexp
+====================
+
+-What is cnuregexp?
+	cnuregexp allows tags to be placed inside a regex which function as labels 
+	for the matches. The matches within the MatchData object can 
+	then be accessed like a hash with the tag name  as the key. cnuregexp also 
+	provides a greedy match which will return an array of all matches rather than
+  just the first match.
+	
+	cnuregexp can also extract various data from an xml tag with the Regexp.xml_tag 
+	method. It uses Regexps to get the tag name, the attributes and their values,
+	the tag content, and any other relevant data from an xml string. 
+
+	Lastly, cnuregexp allows commonly used regular expressions to be stored in a 
+	config file(lib/cnuregexp_config.yml) and accessed with 
+	Regexp.regular_expression_name notation eg. Regexp.ssn, Regexp.email_address. 
+	cnuregexp comes preloaded with a few common regular expressions which are 
+	located in lib/cnuregexp_config.yml.
+
+-Installation
+	sudo gem install cnuregexp
+
+-Examples
+	  re=/((?# areacode)[0-9]{3})-((?# number)[0-9]{3}-[0-9]{4})/.tag!
+    m=re.match("my phone number is 312-243-0979")
+    m["areacode"]		# => "312"
+    m["number"]			# => ["243-0979"]
+
+		r = Regexp.xml_tag :a, {:href=>true, :attr2=>true, :attr_not_exist=>false}
+    m = r.match('<a href="#test" attr2="_test">test</a>')
+		m[:href_value]	# => "#test"
+		m[:attr2_value] # => "_test"
+		m[:content]			# => "test"
+
+		Regexp.email_address # => / \b ((?# user) (?!\.+)(?!-+)[\w\d._%\-+]+ ) @ ((?# subdomain) ((?!-+)[\w\d\-]+\.)* ((?!-+)[\w\d\-]+  ) ) \. ((?# tld) \w{2,6} ) \b /x
+
+-License
+	cnuregexp is distributed under the Ruby license
+
+-Contact
+	website: www.opensource.cashnetusa.com, www.usergenic.com
+	email: OpenSource@cashnetusa.com, brendan@usergenic.com

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'cnuregexp', 'version')
+
+AUTHOR = ['CashnetUSA', 'Brendan Baldwin']
+DESCRIPTION =  
+	'cnuregexp allows tags to be placed inside a regex which function as labels
+  for the matches. The matches within the MatchData object can
+  then be accessed like a hash with the tag name  as the key. cnuregexp also
+  provides a greedy match which will return an array of all matches rather than
+  just the first match.
+
+  cnuregexp can also extract various data from an xml tag with the Regexp.xml_tag
+  method. It uses Regexps to get the tag name, the attributes and their values,
+  the tag content, and any other relevant data from an xml string.
+
+  Lastly, cnuregexp allows commonly used regular expressions to be stored in a
+  config file(lib/cnuregexp_config.yml) and accessed with
+  Regexp.regular_expression_name notation eg. Regexp.ssn, Regexp.email_address.
+  cnuregexp comes preloaded with a few common regular expressions which are
+  located in lib/cnuregexp_config.yml.'
+
+GEM_NAME = 'cnuregexp'
+RUBYFORGE_PROJECT = 'cnuregexp'
+HOMEPATH = "http://opensource.cashnetusa.com"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "cnuregexp"
+REV = nil 
+VERS = Cnuregexp::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+
+# Generate all the Rake tasks
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT 
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs = CLEAN 
+end
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+

data/lib/cnuregexp.rb

@@ -0,0 +1,345 @@
+class Regexp
+
+	require 'yaml'
+  
+  # The following regexp defines any character sequence which is *not*
+  # a backreference-generating open-parentheses.  This is used to strip
+  # out non-backreference-generating open-parentheses, prior to counting
+  # open parentheses to determine number of backreferences generated up
+  # to a point in an expression.
+  NO_BACKREF_REGEXP = /
+    \\{2}+ | # slashes in multiples of 2
+    \\\(   | # slash escaped open paren
+    \(\?   | # open paren followed by question is ruby regexp extension
+    [^\(]    # any character that is not an open paren
+  /x
+
+  # Defines a backreference inside a Regexp, like \1 or \52.  This
+  # successfully ignores escaped backreference like \\1 or \\\\\\1 etc.
+  BACKREF_REGEXP = /
+    ((?:                     # ruby needs lookbehind but doesnt have, so...
+        (?:[^\\]|\A)\\{2}+ | # slashes in multiples of two
+        [^\\]              | # not a slash
+        \A                   # beginning of string
+      ) \\ )                 # slash to start backreference
+    (\d+)                    # the backreference number
+  /x
+
+  # Define what a 'Tag/Comment' is in regexp-ease: (?# tag name)
+  # Note: Ruby regexps ignore escaping of close-parentheses inside
+  # comments.  For example /(?#\)/ is a complete comment and the 
+  # following fails to compile: /(?# test(ing))/ since ruby only
+  # cares about the first close paren.  The following *will* "work":
+  # /(?# test(ing)/ <= Though we're *techinically* missing a close ')'
+  # This is *not* a hack.
+  TAG_REGEXP = /
+    ( \\{2}+ | [^\\] | \A ) # make sure the comment start is not escaped
+    \(\?\# ([^)]*) \)       # the actual ruby regexp extension coment
+  /x
+
+  # This internal module contains the methods to extend the Regexp
+  # instance of, when the tag! method is called.
+  module Tagged
+    
+    # A tagged Regexp's match method is overwritten with this version
+    # that stows a copy of the Regexp inside the MatchData object,
+    # which is necessary in order for the MatchData to use the Regexp's
+    # tag_index.
+    def match(string)
+      match_data = @original_match_method.call(string)
+      match_data.regexp = self unless match_data.nil?
+      match_data
+    end
+
+    # Returns a hash of the capture/backreference indexes with the
+    # comment strings as the hash keys and the indexes as the values.
+    def tag_index
+      return @tag_index unless @tag_index.nil?
+      @tag_index = {}
+      search_space = self.to_s
+      backref_count = 0
+      while match = TAG_REGEXP.match(search_space) do
+        tag_text = match.captures.last.strip
+        backref_count = backref_count + (
+          match.pre_match + match.captures.first
+        ).gsub(NO_BACKREF_REGEXP,'').length
+        search_space = match.post_match
+        @tag_index.merge!({tag_text => backref_count})
+      end
+      @tag_index
+    end
+    
+		# Regexp has already been tagged so just returns a copy of self
+    def tag
+      self.clone
+    end
+    
+		# Regexp has already been tagged so just returns self
+    def tag!
+      self
+    end
+
+		# Returns that the Regexp has indeed been tagged
+    def tagged?
+      true
+    end
+
+  end
+
+  # Concatenate this Regexp with another Regexp or String.  Why use
+  # this function?  It preserves any internal backreferences in the
+  # second Regexp.  For example: /(a)\1/ + /(b)\1/ will return
+  # /(?-mix:(a)\1)(?-mix:(a)\2)/ # <= notice the \2 in the second.
+  def + arg
+    raise 'String or Regexp required' unless arg.respond_to? :to_s
+    self_s, arg_s = self.to_s, arg.to_s
+    backref_count = self_s.gsub(NO_BACKREF_REGEXP,'').size
+    s = self_s + arg_s.gsub(BACKREF_REGEXP) do |s| 
+        "#{$1}#{$2.to_i + backref_count}"
+      end
+    result = /#{s}/
+    result.tag! if self.tagged? || (arg.is_a?(Regexp) && arg.tagged?)
+    result
+  end
+
+  # Matches returns a MatchDataCollection representing ALL successive
+  # matches of the regexp to the provided string.  Kind of like doing
+  # String#scan(regexp) except that the MatchDataCollection will
+  # consume less resources as it only stores a single MatchData object
+  # in memory at any given time, vs. returning an array of ALL matches.
+  def matches(string)
+    first = match(string)
+    if first && !respond_to?(:tag_index) then # am i a tagged regexp?
+      first.regexp = self
+    end
+    MatchDataCollection.new first
+  end
+
+  # Return a tagged copy of self
+  def tag
+    self.clone.tag!
+  end
+
+  # Convert self into a 'tagged' Regexp.  This extends self with the
+  # methods in the Regexp#Tagged module.
+  #
+  # The MatchData object produced by way of the /regexp/.tag!.match
+  # method provides a new method for identifying/accessing elements
+  # in the MatchData#captures array: Using the ruby Regexp 'comment'
+  # extension in your Regexps, you create a symbolic reference to the
+  # group/backreference containing the comment.  For example:
+  # 
+  #  re=/((?# areacode)[0-9]{3})-((?# number)[0-9]{3}-[0-9]{4})/.tag!
+  #  m=re.match("my phone number is 312-243-0979")
+  #  m["areacode"]# => "312"
+  #  m["number"]  # => "243-0979"
+  #
+  # You can alternately use symbols to retrieve captured values:
+  # 
+  #  m[:areacode] # => "312"
+  #  m[:number]   # => "243-0979"
+  #
+  # And of course the [] method also still functions as originally
+  # designed to allow access via Fixnums, Ranges, and Fixnum Pairs:
+  # 
+  #  m[1]    # => "312"
+  #  m[1..2] # => ["312","243-0979"]
+  #  m[1,2]  # => ["312","243-0979"]
+  #  m[0,3]  # => ["312-243-0979","312","243-0979"]
+  #
+  # Note, due to an implementation issue, you advised to place your
+  # comments at the head of the group you're trying to index.  For
+  # example:
+  # 
+  #  r = /((?# here) string to (match))/x
+  #  r.match("string to match")[:here] # <= "string to match"
+  #  r = /(string to (match)(?# not here))/x
+  #  r.match("string to match")[:not_here] # <= "match"
+  #   
+  # The problem here is that we'd think [:not_here] should return
+  # "string to match", but since the comment appears after another
+  # set of backreference-generating open-parentheses, the index
+  # counter is bumped up and we get something other than we may
+  # actually want.
+  def tag!
+    @original_match_method = method(:match)
+    self.extend Tagged
+    tag_index # ensure memoization on reuse
+    self
+  end
+
+  # Is this Regexp tagged? (see tag! method)
+  def tagged?
+    false
+  end
+
+class << self
+
+		# Reads Regexps from a config file and returns their tagged version 
+		def method_missing(sym)
+			regexp = YAML::load_file(File.dirname(__FILE__)+'/cnuregexp_config.yml')[sym.to_s]
+			return regexp.tag! if regexp
+			super
+		end
+
+    # Creates a Regexp to capture an XML tag matching the
+    # specified tag_name.  Optional attributes hash provided,
+    # allows filtering of the tag based on tag attribute values.
+    # Attributes hash keys are the attribute names and values
+    # may be objects of any of the following classes:
+    # * Array => attribute value must match at least one value
+    #   in the Array.  Elements in array may be any of the
+    #   following classes in this list.
+    # * FalseClass => attribute must not appear in tag.
+    # * Regexp => attribute value must match the Regexp.
+    # * String => attribute value must match the string.
+    # * Symbol => attribute value must match the symbol.to_s.
+    # * TrueClass => any value is okay, but must exist.
+    # 
+    # When you get a match out via .match etc, you'll have the
+    # following comment captures to access via [] on the matchdata
+    # object:
+    # * :tag_name => the name of the tag
+    # * :attributes => all tag attributes as a single string
+    # * :content => if the tag has a closing tag, the inner content
+    # And for each attribute name in the attributes hash argument
+    # you get a corresponding :name_value.  For example:
+    # 
+    #   r=Regexp.xml_tag :a, :href=>true
+    #   r.match('<a href="#test">test</a>')[:href_value] # <= #test
+    def xml_tag(tag_name,attributes={})
+      regexp = "<((?#tag_name)#{tag_name.to_s})((?#attributes)" +
+        attributes.inject("") do |attributes,attribute|
+          name, value = attribute
+          has_false = case
+            when value.is_a?(Array): value.select{|v|v.class==FalseClass}.length>0
+            when value.is_a?(FalseClass): true
+            else false
+            end
+          has_nonfalse = case
+            when value.is_a?(Array): value.select{|v|v.class!=FalseClass}.length>0
+            when value.is_a?(FalseClass): false
+            else true
+            end
+     
+          # Create a separate non-backreference-generating group
+          # to wrap the positive and negative lookahead assertions
+          # where we're searching for 'either' a 'false' (where
+          # the attribute is not present) in addition to a 'nonfalse'
+          # (where we're capturing the attribute value and possibly
+          # trying to match that specific value.)
+          attributes += "(?:" if has_false && has_nonfalse
+         
+          # Include negative assertion for attributes
+          # with 'false' value.
+          if has_false
+            attributes += "(?!(?:\\s+(?:[^>]*\\s+)?)" +
+              Regexp.escape(name.to_s) + "(?:\\s|=|>))"
+          end
+
+          # Pop a pipe into the mix to OR the 'false' and 'nonfalse'
+          # lookahead expressions.
+          attributes += "|" if has_false && has_nonfalse
+
+          # Include positive assertion with value capture
+          # for attributes with 'nonfalse' value.
+          if has_nonfalse
+            value=[value] unless value.class==Array
+            attributes += "(?=(?:\\s+(?:[^>]*\\s+)?)" +
+              Regexp.escape(name.to_s) + "\\s*=\\s*\"((?##{name.to_s}_value)" +
+              value.select {|v|v.class!=FalseClass}.collect do |value|
+                case
+                when value.is_a?(Regexp): value.to_s # TODO: FIX INTERNAL BACKREFS BEFORE CONCAT!
+                when value.is_a?(String): Regexp.escape(value)
+                when value.is_a?(Symbol): Regexp.escape(value.to_s)
+                else "[^\"]*"
+                end
+              end.join("|") +
+            ")\")"
+          end
+
+          # Close the group if we're checking for 'false' *and* 'nonfalse.'
+          attributes += ")" if has_false && has_nonfalse
+
+          attributes
+        end +
+        "(?:(?!/>)[^>])*" +
+        ")" + # end of attributes
+        "(?:/>|>((?#content)(?:(?!</#{tag_name}>).)*)</#{tag_name}>)"
+      /#{regexp}/m.tag!
+    end
+		
+  end
+
+end
+
+# MatchData updated to allow additional use of the [] method to
+# retrieve a captured subexpression containing a ruby regexp
+# comment that matches the [] argument.  For usage examples see
+# the comments for Regexp#tag!
+class MatchData
+  alias_method :original_brackets, :[] if !method_defined?(:original_brackets)
+  attr_accessor :regexp
+
+	# tag_match_brackets allows additional use of the [] method to
+	# retrieve a captured subexpression containing a ruby regexp
+	# comment that matches the [] argument.
+  def tag_match_brackets(*args)
+    if args.first.is_a?(String) || args.first.is_a?(Symbol)
+      if self.regexp.nil? || !self.regexp.respond_to?(:tag_index)
+        return nil 
+      end
+      backrefs = args.collect do |comment|
+        index = self.regexp.tag_index[comment.to_s.strip]
+        if index.nil? then nil else self.to_a[index] end
+      end
+      return backrefs.first if args.size == 1
+      backrefs
+    else
+      case args.size
+      when 1: return self.original_brackets(args.first)
+      when 2: return self.original_brackets(args.first,args.last)
+      end
+    end
+    nil
+  end
+
+  alias_method '[]', :tag_match_brackets
+end
+
+# MatchDataCollection is a NEW class that is returned via the
+# Regexp.matches method, which includes Enumerable to allow
+# iterating over ALL regexp matches in a string.
+class MatchDataCollection
+  include Enumerable
+  attr_reader :first
+
+  def initialize(first)
+    @first = first
+  end
+
+  # Iterates over all *successive* matches in a string:
+  # /\d{2}/.matches("123456").collect {|m| m[0]} # <= ["12","34","56"]
+  # Even though there are technically 5 occurrences of the pattern
+  # /\d{2}/ in the string "123456", the iteration follows only the
+  # *remainder* of the string following each match.
+  def each
+    match = first
+    while match do
+      yield match
+      if match[0].size > 0
+        match = first.regexp.match(match.post_match)
+      else
+        match = first.regexp.match(match.post_match[1..-1])
+      end
+    end
+    self
+  end
+
+	# Returns the size of the MatchDataCollection
+  def size
+    @size ||= first && to_a.size || 0
+  end
+
+end
+

data/lib/cnuregexp/version.rb

@@ -0,0 +1,9 @@
+module Cnuregexp #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/cnuregexp_config.yml

@@ -0,0 +1,33 @@
+proper_name: !ruby/regexp /^[a-z .'\d\-]+$/i
+
+email_address:
+  !ruby/regexp  '/ \b
+        ((?# user) (?!\.+)(?!-+)[\w\d._%\-+]+ )
+        @
+        ((?# subdomain)
+          ((?!-+)[\w\d\-]+\.)*
+          ((?!-+)[\w\d\-]+  )
+        )
+        \.
+        ((?# tld) \w{2,6} )
+        \b
+      /x'
+    
+zipcode_us:
+     !ruby/regexp '/^\d{5}(-?\d{4})?$/'
+
+phone_number_us:
+     !ruby/regexp '/ (?:\(\s*)?\b
+          ((?# area_code)[2-9][0-9][0-9])
+          (?:\)\s*|[\s\-\.\/])?
+          ((?# prefix)[2-9][0-9][0-9])
+          [\s\-\.\/]?
+          ((?# suffix)\d{4})
+          \b
+      /x'
+
+ssn: !ruby/regexp '/\b((?# area_number)(?!000)(?:[0-6]\d{2}|7(?:[0-6]\d|7[012])))([-]?)((?# group_number)(?!00)\d{2})\2((?# serial_number)(?!0000)\d{4})\b/'
+
+social_security_number: !ruby/regexp '/\b((?# area_number)(?!000)(?:[0-6]\d{2}|7(?:[0-6]\d|7[012])))([-]?)((?# group_number)(?!00)\d{2})\2((?# serial_number)(?!0000)\d{4})\b/'
+
+social_security_number_us: !ruby/regexp '/\b((?# area_number)(?!000)(?:[0-6]\d{2}|7(?:[0-6]\d|7[012])))([-]?)((?# group_number)(?!00)\d{2})\2((?# serial_number)(?!0000)\d{4})\b/'

data/test/test_cnuregexp.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestCnuregexp < Test::Unit::TestCase
+
+  def setup
+  end
+  
+	def test_basics
+		r = /((?# areacode)[0-9]{3})-((?# number)[0-9]{3}-[0-9]{4})/.tag!
+
+		assert r.methods.include?('tag_index'), 'Regexp class was not extended'
+		assert r.tagged?, 'tagged? failed'
+		assert_equal 1,r.tag_index['areacode'], 'tag_index failed'
+
+		m = r.match('312-555-1212')
+		assert_equal '312', m['areacode'], 'access by tag name(tag_match_brackets) failed from MatchData'
+		assert_equal '555-1212', m['number'], 'access by tag name(tag_match_brackets) failed from MatchData'
+
+		assert_equal(/(?-mix:(a)\1)(?-mix:(b)\2)/,/(a)\1/ + /(b)\1/, '+ operator failed')
+	
+		#test MatchDataCollection
+		m = r.matches('312-555-1212 and 123-666-9898')
+		a = []
+		assert_nothing_thrown do m.each{|match| a.push match['areacode']; a.push match['number']} end 
+		assert_equal'312', a[0],'MatchDataCollection failed'
+		assert_equal'555-1212', a[1],'MatchDataCollection failed'
+		assert_equal'123', a[2],'MatchDataCollection failed'
+		assert_equal'666-9898', a[3],'MatchDataCollection failed'
+		assert_equal 2, m.size
+
+	end
+ 
+	def test_xml
+
+	  r = Regexp.xml_tag :a, {:href=>true, :attr2=>true, :attr_not_exist=>false}
+
+		m = r.match('<a href="#test" attr2="_test">test</a>')
+    assert_equal '#test', m[:href_value], 'xml_tag failed'
+    assert_equal '_test', m[:attr2_value], 'xml_tag failed'
+		assert_equal 'test', m[:content], 'xml_tag failed'
+
+	end
+
+	def test_config_file
+	
+		assert_nothing_thrown do  Regexp.proper_name end
+		assert_nothing_thrown do  Regexp.ssn end
+
+	end
+	
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/cnuregexp'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: cnuregexp
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-05-22
+summary: The author was too lazy to write a summary
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: http://opensource.cashnetusa.com
+rubyforge_project: cnuregexp
+description: cnuregexp allows tags to be placed inside a regex which function as labels for the matches. The matches within the MatchData object can then be accessed like a hash with the tag name  as the key. cnuregexp also provides a greedy match which will return an array of all matches rather than just the first match.  cnuregexp can also extract various data from an xml tag with the Regexp.xml_tag method. It uses Regexps to get the tag name, the attributes and their values, the tag content, and any other relevant data from an xml string.  Lastly, cnuregexp allows commonly used regular expressions to be stored in a config file(lib/cnuregexp_config.yml) and accessed with Regexp.regular_expression_name notation eg. Regexp.ssn, Regexp.email_address. cnuregexp comes preloaded with a few common regular expressions which are located in lib/cnuregexp_config.yml.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+- CashnetUSA
+- Brendan Baldwin
+files: 
+- Rakefile
+- README.txt
+- lib/cnuregexp.rb
+- lib/cnuregexp_config.yml
+- lib/cnuregexp/version.rb
+- test/test_cnuregexp.rb
+- test/test_helper.rb
+test_files: 
+- test/test_helper.rb
+- test/test_cnuregexp.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: