mlightner-enhanced_regexp 0.1.0

data/README

@@ -0,0 +1,47 @@
+Enhanced Regular Expressions
+============================
+Author: mlightner@gmail.com
+
+This package extends the functionality of Regexp objects by adding methods to create copies of them
+with modified options.  It also allows for toggling of "inverted" status on a regexp object.
+
+Example:
+
+require 'rubygems'
+require 'enhanced_regexp'
+irb> exp = /test/i
+=> /test/i
+irb> exp.case_sensitive?
+=> true
+irb> exp2 = exp.without_case            
+=> /test/
+irb> exp2.case_sensitive?                
+=> false
+irb> mlx = /test.*multiline/
+=> /test.*multiline/
+irb> "test\n multiline".match(mlx)
+=> nil
+irb> "test\n multiline".match(mlx.with_multiline)
+=> #<MatchData:0xb7c0c004>
+irb> "test\n multiline".match(mlx.with_multiline).inspect
+=> "#<MatchData:0xb7c0725c>"
+irb> invx = /hello/i.invert!                             
+=> /hello/i
+irb> invx.inverted?
+=> true
+irb> "oh hello".match(invx)
+=> false
+irb> "oh hai".match(invx)    
+=> true
+irb> invx.uninvert!
+=> /hello/i
+irb> "oh hello".match(invx)
+=> #<MatchData:0xb7bedac8>
+
+
+
+NOTES:
+ - With inversion, you can toggle it on any given regular expression without creating a new one.
+ - When changing other option values, a new Regexp will ge generated and returned as the value of
+     the call to regex.with_option (or without_option).  This new regular expression will be identical
+     to the original aside from the requested option change.

data/lib/enhanced_regexp/inversion.rb

@@ -0,0 +1,52 @@
+module MattLightner
+
+  module EnhancedRegexp
+
+    #= Inverted Regular Expressions
+    # Gives the ability to invert a regular expression so that running a match against it
+    # will yield a true result when it does NOT match the target string.
+    module Inversion
+
+      def self.included(base)
+        base.send(:include, MattLightner::EnhancedRegexp::Inversion::InstanceMethods)
+        base.class_eval do
+          alias_method :match_without_inversion, :match
+          alias_method :match, :match_with_inversion
+        end
+      end
+
+      module InstanceMethods
+        # Invert this regular expression.
+        def invert!
+          @inverted = true
+          self
+        end
+
+        # Uninvert this regular expression.
+        def uninvert!
+          @inverted = false
+          self
+        end
+
+        def set_inverted(value = true)
+          @inverted = (value) ? true : false
+        end
+
+        # Is this an inverted regular expression?
+        def inverted?
+          @inverted rescue false
+        end
+
+        def match_with_inversion(*args, &block)
+          result = match_without_inversion(*args, &block)
+          if @inverted
+            result.nil? ? true : false
+          else
+            match_without_inversion(*args, &block)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/enhanced_regexp/options_modification.rb

@@ -0,0 +1,69 @@
+module MattLightner
+
+  module EnhancedRegexp
+
+    #= Options Modification
+    # Makes it easy to modify options set on a regular expression.
+    module OptionsModification
+
+      def self.included(base)
+        base.send(:include, MattLightner::EnhancedRegexp::OptionsModification::InstanceMethods)
+      end
+
+      module InstanceMethods
+
+        #== Case sensitivity: the IGNORECASE flag
+        # Return a new regular expression identical to this one except without case sensitivity.
+        def without_case
+          Regexp.new(self.source, (self.options ^ Regexp::IGNORECASE)).set_inverted(self.inverted?)
+        end
+
+        # Return a new regular expression identical to this one except with case sensitivity.
+        def with_case
+          Regexp.new(self.source, (self.options | Regexp::IGNORECASE)).set_inverted(self.inverted?)
+        end
+
+        # Boolean test to see if this regular expression is case sensitive.
+        def case_sensitive?
+          (self.options | Regexp::IGNORECASE) == self.options
+        end
+
+
+        #== Multi-line matching: the MULTILINE flag
+        # Return a new regular expression identical to this one except without case sensitivity.
+        def without_multiline
+          Regexp.new(self.source, (self.options ^ Regexp::MULTILINE)).set_inverted(self.inverted?)
+        end
+
+        # Return a new regular expression identical to this one except with case sensitivity.
+        def with_multiline
+          Regexp.new(self.source, (self.options | Regexp::MULTILINE)).set_inverted(self.inverted?)
+        end
+
+        # Boolean test to see if this regular expression is case sensitive.
+        def multiline?
+          (self.options | Regexp::MULTILINE) == self.options
+        end
+
+
+        #== Multi-line matching: the EXTENDED flag
+        # Return a new regular expression identical to this one except without case sensitivity.
+        def without_extended
+          Regexp.new(self.source, (self.options ^ Regexp::EXTENDED)).set_inverted(self.inverted?)
+        end
+
+        # Return a new regular expression identical to this one except with case sensitivity.
+        def with_extended
+          Regexp.new(self.source, (self.options | Regexp::EXTENDED)).set_inverted(self.inverted?)
+        end
+
+        # Boolean test to see if this regular expression is case sensitive.
+        def extended?
+          (self.options | Regexp::EXTENDED) == self.options
+        end
+
+      end
+
+    end
+  end
+end

data/lib/enhanced_regexp.rb

@@ -0,0 +1,7 @@
+require 'enhanced_regexp/inversion'
+require 'enhanced_regexp/options_modification'
+
+Regexp.class_eval do
+  include MattLightner::EnhancedRegexp::Inversion
+  include MattLightner::EnhancedRegexp::OptionsModification
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: mlightner-enhanced_regexp
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matt Lightner
+autorequire: name
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mlightner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/enhanced_regexp.rb
+- lib/enhanced_regexp/inversion.rb
+- lib/enhanced_regexp/options_modification.rb
+- README
+has_rdoc: true
+homepage: http://mattlightner.com/code/enhanced_regexp
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Enhanced regular expressions allow for a boolean inverted/not inverted association to be attached to any regular expression, as well as easy modification of Regexp options (e, i, m).
+test_files: []
+