regex 1.0.0 → 1.1.0

data/lib/regex/package.yml

@@ -0,0 +1,7 @@
+name    : regex
+date    : 2010-10-10
+version : 1.1.0
+
+requires:
+  - syckle (build)
+  - qed (test)

data/lib/regex/replacer.rb

@@ -0,0 +1,221 @@
+require 'stringio'
+
+module Regex
+
+  #
+  class Replacer
+
+    # Array of [search, replace] rules.
+    attr_reader :rules
+
+    # Make all patterns exact string matchers.
+    attr_accessor :escape
+
+    # Make all patterns global matchers.
+    attr_accessor :global
+
+    # Make all patterns case-insenstive matchers.
+    attr_accessor :insensitive
+
+    # Make all patterns multi-line matchers.
+    attr_accessor :multiline
+
+    # Make backups of files when they change.
+    attr_accessor :backup
+
+    #
+    def initialize(options={})
+      @rules = []
+      options.each do |k,v|
+        __send__("#{k}=", v)
+      end
+    end
+
+    #
+    def rule(pattern, replacement)
+      @rules << [re(pattern), replacement]
+    end
+
+    #
+    def apply(*ios)
+      ios.each do |io|
+        original = (IO === io || StringIO === io ? io.read : io.to_s)
+        generate = original
+        rules.each do |(pattern, replacement)|
+          if pattern.global
+            generate = generate.gsub(pattern.to_re, replacement)
+          else
+            generate = generate.sub(pattern.to_re, replacement)
+          end
+        end
+        if original != generate
+          write(io, generate)
+        end
+      end
+    end
+
+    private
+
+    # Parse pattern matcher.
+    def re(pattern)
+      Matcher.new(
+        pattern,
+        :global=>global,
+        :escape=>escape,
+        :multiline=>multiline,
+        :insensitive=>insensitive
+      )
+    end
+
+    #
+    def write(io, text)
+      case io
+      when File
+        if backup
+          backup_file = io.path + '.bak'
+          File.open(backup_file, 'w'){ |f| f << File.read(io.path) }
+        end
+        File.open(io.path, 'w'){ |w| w << text }
+      when StringIO
+        io.string = text
+      when IO
+        # TODO: How to handle general IO object?
+        io.write(text)
+      else
+        io.replace(text)
+      end
+    end
+
+    #
+    def self.cli(argv=ARGV)
+      searches = []
+      replaces = []
+      options = {}
+      parser = OptionParser.new do |opt|
+        opt.on('--subtitute', '-s PATTERN', 'search portion of substitution') do |search|
+          searches << search
+        end
+        opt.on('--template', '-t NAME', 'search for built-in regular expression') do |name|
+          searches << "$#{name}"
+        end
+        opt.on('--replace', '-r STRING', 'replacement string of substitution') do |replace|
+          replaces << replace
+        end
+        opt.on('--escape', '-e', 'make all patterns exact string matchers') do
+          options[:escape] = true
+        end
+        opt.on('--insensitive', '-i', 'make all patterns case-insensitive matchers') do
+          options[:insensitive] = true
+        end
+        #opt.on('--unxml', '-x', 'ignore XML/HTML tags') do
+        #  options[:unxml] = true
+        #end
+        opt.on('--global', '-g', 'make all patterns global matchers') do
+          options[:global] = true
+        end
+        opt.on('--multiline', '-m', 'make all patterns multi-line matchers') do
+          options[:multiline] = true
+        end
+        opt.on('-b', '--backup', 'backup any files that are changed') do
+          options[:backup] = true
+        end
+        opt.on_tail('--debug', 'run in debug mode') do
+          $DEBUG = true
+        end
+        opt.on_tail('--help', '-h', 'display this lovely help message') do
+          puts opt
+          exit 0
+        end
+      end
+      parser.parse!(argv)
+
+      files = argv
+      files.each do |file|
+        raise "file does not exist -- #{file}" unless File.exist?(file)
+      end
+      targets = files.empty? ? [ARGF] : files.map{ |f| File.new(f) }
+
+      unless searches.size == replaces.size
+        raise "search replace mismatch -- #{searches.size} to #{replaces.size}"
+      end
+      rules = searches.zip(replaces)
+
+      replacer = new(options)
+      rules.each do |search, replace|
+        replacer.rule(search, replace)
+      end
+      replacer.apply(*targets)
+    end
+
+    # Basically a Regex but handles a couple extra options.
+    class Matcher
+
+      #
+      attr_accessor :global
+
+      #
+      attr_accessor :escape
+
+      #
+      attr_accessor :multiline
+
+      #
+      attr_accessor :insensitive
+
+      #
+      def initialize(pattern, options={})
+        options.each do |k,v|
+          __send__("#{k}=", v) if respond_to?("#{k}=")
+        end
+        @regexp = parse(pattern)
+      end
+
+      #
+      def =~(string)
+        @regexp =~ string
+      end
+
+      #
+      def match(string)
+        @regexp.match(string)
+      end
+
+      #
+      def to_re
+        @regexp
+      end
+
+      # Parse pattern matcher.
+      def parse(pattern)
+        case pattern
+        when Regexp
+          pattern
+        when /^\$/
+          Templates.const_get($'.upcase)
+        when /^\/(.*?)\/(\w+)$/
+          flags = []
+          @global = true if $2.index('g')
+          flags << Regexp::MULTILINE  if $2.index('m') or multiline
+          flags << Regexp::IGNORECASE if $2.index('i') or insensitive
+          if $2.index('e') or escape
+            Regexp.new(Regexp.escape($1), *flags)
+          else
+            Regexp.new($1, *flags)
+          end
+        else
+          flags = []
+          flags << Regexp::MULTILINE  if multiline
+          flags << Regexp::IGNORECASE if insensitive
+          if escape
+            Regexp.new(Regexp.escape(pattern), *flags)
+          else
+            Regexp.new(pattern, *flags)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/regex/string.rb

@@ -1,4 +1,4 @@
-class Regex
+module Regex
 
   # Extensions for String class.
   # These methods are taken directly from Ruby Facets.

data/lib/regex/templates.rb

@@ -0,0 +1,85 @@
+module Regex
+
+  # = Templates
+  #
+  # TODO: What about regular expressions with variable content?
+  # Should these be methods rather than constants? But then how
+  # would we handle named substituions?
+  module Templates
+
+    # Empty line.
+    EMPTY = /^$/
+
+    # Blank line.
+    BLANK = /^\s*$/
+
+    NUMBER = /[-+]?[0-9]*\.?[0-9]+/
+
+    # Markup language tag, e.g \<a>stuff</a>.
+    MLTAG = /<([A-Z][A-Z0-9]*)\b[^>]*>(.*?)<\/\1>/i
+
+    # IPv4 Address
+    IPV4 = /\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/
+
+    # Username
+    USERNAME = /^[a-zA-Z0-9_]{3,16}$/
+
+    # Email Address
+    EMAIL = /([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)/i
+
+    # United States phone number.
+    USPHONE = /(\d\d\d[-]|\(\d\d\d\))?(\d\d\d)[-](\d\d\d\d)/
+
+    # United States zip code.
+    USZIP = /^[0-9]{5}(-[0-9]{4})?$/
+
+    # United States social secuirty number.
+    SSN = /[0-9]\{3\}-[0-9]\{2\}-[0-9]\{4\}/
+
+    # United States dollar amount.
+    DOLLARS = /\$[0-9]*.[0-9][0-9]/
+
+    # Bank Ientification Code
+    BIC = /([a-zA-Z]{4}[a-zA-Z]{2}[a-zA-Z0-9]{2}([a-zA-Z0-9]{3})?)/
+
+    #
+    IBAN = /[a-zA-Z]{2}[0-9]{2}[a-zA-Z0-9]{4}[0-9]{7}([a-zA-Z0-9]?){0,16}/
+
+    # Hexidecimal value.
+    HEX = /(#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\b)/
+
+    # HTTP URL Address
+    HTTP = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \?=.-]*)*\/?$/
+
+    # Ruby comment block.
+    RUBYBLOCK = /^=begin\s*(.*?)\n(.*?)\n=end/m
+
+    # Ruby method definition.
+    # TODO: Not quite right.
+    RUBYMETHOD_WITH_COMMENT = /(^\ *\#.*?)^\s*def\s*(.*?)$/m
+
+    #
+    RUBYMETHOD = /^\ *def\s*(.*?)$/
+
+    # By the legendary abigail. Fails to match if and only if it is matched against
+    # a prime number of 1's. That is, '11' fails, but '1111' does not.
+    # I once heard him talk why this works, but I forgot most of it.
+    PRIMEONES = /^1?$|^(11+?)\1+$/
+
+    # Name of all constants.
+    def self.list
+      constants.map{ |c| c.downcase }
+    end
+
+    # Lookup a template by name.
+    def self.[](name)
+      Templates.const_get(name.upcase)
+    end
+
+  end
+
+  # Add templates to Regex module.
+  include Templates
+
+end
+

data/{test/demos → qed}/regex.rdoc

@@ -19,26 +19,26 @@ We will also suppoly a matching pattern, as none of
 the matching functions will work without providing
 a pattern or the name of built-in pattern template.
 
-  regex = Regex.new(text, :pattern=>'\w+')
+  rx = Regex.new(text, :pattern=>'\w+')
 
 We can see that the Regex object has converted the pattern
 into the expected regular expression via the #regex method.
 
-  regex.regex.assert == /\w+/m
+  rx.regex.assert == /\w+/
 
 Under the hood, Regex has split the process of matching,
 organizing and formating the results into separate methods.
 We can use the #structure method to see thematch results
 organized into uniform arrays.
 
-  regex.structure.assert == %w{We}
+  rx.structure.assert == %w{We}
 
 Whereas the last use only returns a single metch, if we turn
 on repeat mode we can see every word.
 
-  regex.repeat = true
+  rx.repeat = true
 
-  regex.structure.assert == %w{We will match against this string}.map{ |e| [e] }
+  rx.structure.assert == %w{We will match against this string}.map{ |e| [e] }
 
 Notice that repeat mode creates an array in an array.
 

data/qed/replacer.rdoc

@@ -0,0 +1,57 @@
+= Search and Replace
+
+Regex can also be used to do search and replace across multiple
+strings or IO objects, includeing files.
+
+  require 'regex'
+
+To perform search and replace procedure we create a Regex::Replacer object.
+The constructor method takes a Hash of options which set universal parameters
+to apply to all search and replace rules. Usually, each individual rule
+will specify it's own options, so for this example we provide none.
+
+  replacer = Regex::Replacer.new
+
+Rules are added via the #rule method.
+
+  replacer.rule('World', 'Planet Earth')
+  replacer.rule('!', '!!!')
+
+Rules are applied in the order they were defined. If there rules overlap
+in their effects this can be signifficant.
+
+Now, lets say we have that famous String,
+
+  string = "Hello, World!"
+
+We use the #apply method to actually perform the substitutions.
+
+  replacer.apply(string)
+
+The replacements occur in place. Since in this case we are performing
+the serach and replace on a String object, we can see the change 
+has taken place.
+
+  string.assert == "Hello, Planet Earth!!!"
+
+As we mentioned at the beginning, substitutions can be applied to IO
+objects in general, so long as they they can be reopended for writing.
+
+  require 'stringio'
+
+  io = StringIO.new("Hello, World!")
+
+  replacer.apply(io)
+
+  io.read.assert == "Hello, Planet Earth!!!"
+
+If +io+ were a File object, rather than a StringIO, the file would
+be changed on disk. As a precaution a backup file can be written 
+with then name of file plus a '.bak' extension in the same directory as
+the file. To turn on the backup option, either supply it as an option
+to the constructor, or set it via the writer method.
+
+  replacer.backup = true
+
+(TODO: Example of a file search and replace.)
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: regex
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -15,12 +16,39 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-12 00:00:00 -05:00
+date: 2010-10-12 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
-description: Regex is simple commmandline Regular Expression tool.
-email: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: syckle
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: qed
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Regex is a simple commmandline Regular Expression tool, that makes easy to search documents for content matches.
+email: ""
 executables: 
 - regex
 extensions: []
@@ -28,32 +56,25 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
-- HISTORY
-- LICENSE
-- MANIFEST
-- README
 - bin/regex
-- lib/regex.rb
 - lib/regex/command.rb
 - lib/regex/extractor.rb
+- lib/regex/package.yml
+- lib/regex/replacer.rb
 - lib/regex/string.rb
-- lib/regex/templates/common.rb
-- meta/authors
-- meta/created
-- meta/description
-- meta/download
-- meta/homepage
-- meta/mailinglist
-- meta/name
-- meta/repository
-- meta/summary
-- meta/title
-- meta/version
-- test/demos/regex.rdoc
+- lib/regex/templates.rb
+- lib/regex.rb
+- qed/regex.rdoc
+- qed/replacer.rdoc
+- PROFILE
+- PACKAGE
+- LICENSE
+- README
+- HISTORY
 has_rdoc: true
 homepage: http://proutils.github.com/regex
-licenses: []
-
+licenses: 
+- ""
 post_install_message: 
 rdoc_options: 
 - --title
@@ -63,25 +84,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: regex
-rubygems_version: 1.3.6.pre.3
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Regex is simple commmandline Regular Expression tool.
+summary: Regex is a simple commmandline Regular Expression tool.
 test_files: []