scantron 0.0.1.beta

data/README.rdoc

@@ -0,0 +1,78 @@
+= Scantron
+
+http://github.com/stephencelis/scantron
+
+A simple, but powerful, rule-based string scanner and scrubber.
+
+
+== Examples
+
+==== NumberScanner
+
+  require "scantron"
+  require "number_scanner"
+
+  NumberScanner.scan "A one, 2, 3.0, 4 1/2..."
+  # => [1, 2, 3.0, (9/2)]
+
+  number_scanner = NumberScanner.new <<HERE
+    Ninety-nine bottles of beer on the wall.
+    Ninety-nine bottles of beer.
+    Take one down, pass it around,
+    Ninety-eight and a half bottles of beer on the wall.
+  HERE
+
+  number_scanner.scan # => [99, 99, 1, (197/2)]
+
+TODO: Scrubbing
+
+
+==== RangeScanner
+
+  require "scantron"
+  require "range_scanner"
+
+  RangeScanner.scan "100-150 degrees"
+  # => [100..150]
+
+  RangeScanner.scan "Twelve or thirteen rolls for five or six people"
+  # => [12..13, 5..6]
+
+
+=== Build Your Own
+
+TODO
+
+
+== Install
+
+  % [sudo] gem install scantron
+
+
+Or, with {Bundler}[http://gembundler.com/], add <tt>gem "scantron"</tt> to your
+Gemfile and run <tt>bundle install</tt>.
+
+
+== License
+
+(The MIT License)
+
+(c) 2010 Stephen Celis <stephen@stephencelis.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake/testtask'
+require 'rdoctest/task'
+
+Rdoctest::Task.new do |t|
+  t.ruby_opts << '-rscantron -rrange_scanner'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+task :default => [:doctest, :test]

data/lib/scantron.rb

@@ -0,0 +1,7 @@
+relative_path = File.join File.dirname(__FILE__), 'scantron', 'scanners'
+$LOAD_PATH << File.expand_path(relative_path)
+require 'scantron/version'
+require 'scantron/scanner'
+
+module Scantron
+end

data/lib/scantron/result.rb

@@ -0,0 +1,148 @@
+module Scantron
+  # The class Scanner yields to the most. If scrubbing with a block, you're
+  # yielding to one of these.
+  #
+  # ==== Using Results
+  #
+  # Results have a few components that are important to know about during scans
+  # and scrubs.
+  #
+  #   >> number_scanner = NumberScanner.new "One, 2, buckle my shoe"
+  #   => #<NumberScanner...>
+  #   >> number_scanner.scrub do |result|
+  #   >>   p result.name, result.rule, result.scanner, result.value
+  #   >>   "<#{result}>"
+  #   >> end
+  #   :integer
+  #   #<struct Scantron::Rule...>
+  #   #<StringScanner 6/22...>
+  #   2
+  #   :human
+  #   #<struct Scantron::Rule...>
+  #   #<StringScanner 3/22...>
+  #   1
+  #   => "<One>, <2>, buckle my shoe"
+  #
+  # [+name+]     The name of the particular rule matched for this result. Use
+  #              case statements to process different rules in different ways.
+  #
+  # [+rule+]     The Rule itself (if you need access to the regular expression
+  #              or any metadata you store there).
+  #
+  # [+scanner+]  The StringScanner used to capture this match. And used later
+  #              for scrubbing. You can change its position, match something
+  #              else, and the final scrub would be different.
+  #
+  # [+value+]    The value of the rule as processed by the rule's block.
+  #
+  # Also note that calling to_s on the Result will return the matched string.
+  class Result
+    class << self
+      def from name, rule, scanner, scantron
+        result = new name, rule, scanner, scantron
+        scantron.class.before ? scantron.class.before.call(result) : result
+      end
+    end
+
+    # The name of the rule.
+    attr_reader :name
+
+    # The Rule the Result was matched from.
+    attr_reader :rule
+
+    # The StringScanner instance that matched the rule.
+    attr_reader :scanner
+
+    # Overwrite the length to adjust the length of the matched string returned.
+    attr_writer :length
+
+    # Overwrite the offset to adjust the offset of the matched string returned.
+    attr_writer :offset
+
+    # The Scantron::Scanner instance that created this result.
+    attr_reader :scantron
+
+    # Hash of information to write to and read from.
+    attr_reader :data
+
+    def initialize name, rule, scanner, scantron
+      @name     = name
+      @rule     = rule
+      @scanner  = scanner.dup
+      @length   = nil
+      @offset   = nil
+      @value    = nil
+      @data     = {}
+      @scantron = scantron
+    end
+
+    # The value as evaluated by the Rule's block (or Scanner's after_match).
+    def value
+      @value ||= rule.block ? rule.block.call(self) : to_s
+    end
+
+    def [] key
+      data[key]
+    end
+
+    def []= key, value
+      data[key] = value
+    end
+
+    def length
+      @length || scanner.matched_size
+    end
+    alias size length
+
+    def length= length
+      @value = nil
+      @length = length
+    end
+
+    def offset
+      @offset || scanner.pos - scanner.matched_size
+    end
+
+    def offset= offset
+      @value = nil
+      @offset = offset
+    end
+
+    def pos
+      [offset, length]
+    end
+
+    def eql? other
+      pos == other.pos && value == other.value
+    end
+    alias == eql?
+
+    def hash
+      pos.hash ^ value.hash
+    end
+
+    include Comparable
+    def <=> other
+      [offset, -length] <=> [other.offset, -other.length]
+    end
+
+    def pre_match
+      return scanner.pre_match if @offset.nil?
+      scanner.string[0, offset]
+    end
+
+    def post_match
+      return scanner.post_match if @length.nil? && @offset.nil?
+      scanner.string[offset + length, scanner.string.length]
+    end
+
+    def to_s
+      return scanner.matched if @length.nil? && @offset.nil?
+      scanner.string[offset, length]
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_s.inspect}>"
+    end
+  end
+end

data/lib/scantron/rule.rb

@@ -0,0 +1,11 @@
+module Scantron
+  # A simple Struct-derived class to store class rules.
+  #
+  #   Scantron::Rule.new /\btest\b/, {}, lambda {}
+  #   # => #<struct Scantron::Rule ...>
+  class Rule < Struct.new :regexp, :data, :block
+    def to_s
+      regexp.to_s
+    end
+  end
+end

data/lib/scantron/scanner.rb

@@ -0,0 +1,211 @@
+require 'strscan'
+require 'scantron/result'
+require 'scantron/rule'
+
+module Scantron
+  # Scantron::Scanner is meant to be inherited from. It provides functionality
+  # above and beyond StringScanner.
+  #
+  # Define a few rules, scan, sort, and process the results all at once.
+  #
+  #   class HTMLScanner < Scantron::Scanner
+  #     rule :tag, %r{<(\w+)[^>]*>([^<]+)</[^>]+>} do |r|
+  #       { :tag => r.scanner[1].downcase, :innerHTML => r.scanner[2] }
+  #     end
+  #
+  #     rule :comment, /<!--(.+?)-->/ do |r|
+  #       { :comment => r.scanner[1].strip }
+  #     end
+  #   end
+  #
+  #   html = HTMLScanner.new "<A HREF='/'>Root!</A><!-- Important link! -->"
+  #   html.scan
+  #   # => [{:tag=>"a", :innerHTML=>"Root!"}, {:comment=>"Important link!"}]
+  #
+  #   html.scrub { |r| r.to_s.swapcase unless r.name == :comment }
+  #   # => "<a href='/'>rOOT!</a>"
+  class Scanner
+    @before = nil
+    @after = nil
+    @rules = {}
+
+    class << self
+      attr_reader :before
+      attr_reader :after
+      attr_reader :rules
+
+      # Scans a string against the rules defined in the class, returning an
+      # array of matches processed by those rules.
+      #
+      # ==== Example
+      #
+      # The NumberScanner class scans for numbers and returns an array of
+      # numbers.
+      #
+      #   NumberScanner.scan 'One, two, skip a few, 99, 100'
+      #   # => [1, 2, 99, 100]
+      def scan string
+        new(string).scan
+      end
+
+      # Scans a string against the rules defined in the class, returning the
+      # first match if it coincides with the beginning of the string.
+      #
+      # For flexibility, whitespace counts, so if you're matching against
+      # non-whitespace, make sure to strip your strings before sending them
+      # through.
+      #
+      # ==== Example
+      #
+      #   NumberScanner.parse 'One, two, three, four...'
+      #   # => 1
+      #
+      #   NumberScanner.parse 'And a five, six, seven eight.'
+      #   # => nil
+      #
+      #   number_scanner = NumberScanner.new '  One with whitespace...'
+      #   number_scanner.parse
+      #   # => nil
+      #
+      #   number_scanner.string.lstrip!
+      #   number_scanner.parse
+      #   # => 1
+      def parse string
+        new(string).parse
+      end
+
+      # Scans and processes a string against the rules defined in the class.
+      # Accepts a block that yields to each Result, otherwise scrubbing each
+      # match from the string.
+      #
+      # ==== Example
+      #
+      # Using the NumberScanner class:
+      #
+      #   NumberScanner.scrub '99 bottles of beer / take one down'
+      #   # => " bottles of beer / take  down"
+      #
+      #   NumberScanner.scrub 'And one more thing...' do |r|
+      #     "<span data-value='#{r.value}'>#{r}</span>"
+      #   end
+      #   # => "And <span data-value='1'>one</span> more thing..."
+      def scrub string, &block
+        new(string).scrub &block
+      end
+
+      protected
+
+      attr_writer :before
+      attr_writer :after
+      attr_writer :rules
+
+      def inherited subclass
+        subclass.before = before
+        subclass.after = after
+        subclass.rules = rules.dup
+      end
+
+      private
+
+      # A DSL provided to create scanner rules in scanner classes. Provided
+      # blocks yield to Scantron::Result instances, evaluated during matches.
+      #
+      # ==== Example
+      #
+      #   class TestScanner < Scantron::Scanner
+      #     rule :test, /\btest\b/
+      #   end
+      #   TestScanner.scan "The test went well, didn't it?"
+      #   # => ["test"]
+      #
+      #   >> class PluralScanner < Scantron::Scanner
+      #   >>   rule :plural, /\b[\w]+s\b/ do |r|
+      #   >>     puts r
+      #   >>     r.to_s.capitalize
+      #   >>   end
+      #   >> end
+      #   => ...
+      #   >> PluralScanner.scan "No ifs, ands, or buts about it."
+      #   ifs
+      #   ands
+      #   buts
+      #   => ["Ifs", "Ands", "Buts"]
+      def rule name, regexp, data = {}, &block
+        rules[name] = Rule.new regexp, data, block || after
+      end
+
+      def before_match &block
+        self.before = block
+      end
+
+      def after_match &block
+        self.after = block
+      end
+    end
+
+    attr_reader :string
+
+    def initialize string
+      super
+      @string = string
+    end
+
+    # See Scantron::Scanner.scan. The instance method analog.
+    def scan
+      perform.uniq.map { |result| result.value }
+    end
+
+    # See Scantron::Scanner.parse. The instance method analog.
+    def parse
+      result = perform.find { |result| result.offset == 0 }
+      result.value if result
+    end
+
+    # See Scantron::Scanner.scrub. The instance method analog.
+    def scrub
+      str = string.dup
+
+      perform.reverse.each do |result|
+        pos = result.pos
+        sub = yield result if block_given?
+        str[*pos] = sub.to_s if str[*pos] == string[*pos]
+      end
+
+      str
+    end
+
+    # The heart of the scanner. Returns Result instances to scan, scrub, and
+    # parse. Not a class method to discourage direct use outside of a scanner's
+    # implementation.
+    def perform return_overlapping = false
+      scanner = StringScanner.new string
+      results = []
+
+      self.class.rules.each_pair do |name, rule|
+        while scanner.skip_until rule.regexp
+          results << Result.from(name, rule, scanner, self)
+        end
+
+        scanner.pos = 0
+      end
+
+      results.sort!
+      remove_overlapping results unless return_overlapping
+      results.compact.reject { |r| r.value == false }
+    end
+
+    private
+
+    def remove_overlapping results
+      prev = nil
+
+      results.each.with_index do |r, i|
+        if prev && r.offset < prev.offset + prev.length
+          results[i] = nil if prev.length >= r.length
+        end
+
+        prev = r
+      end
+    end
+  end
+end

data/lib/scantron/scanners/amount_scanner.rb

@@ -0,0 +1,18 @@
+require 'range_scanner'
+
+# Scans for both numbers and ranges.
+class AmountScanner < Scantron::Scanner
+  # AmountScanner completely overrides Scantron::Scanner's perform in order to
+  # use both NumberScanner's and RangeScanner's perform methods, discarding
+  # numbers that occur in ranges.
+  def perform return_overlapping = false
+    numbers = NumberScanner.new(string).perform
+    ranges  = RangeScanner.new(string).perform
+    return numbers if ranges.empty?
+    numbers.delete_if { |n| ranges.any? { |r| r.offset == n.offset } }
+    results = numbers + ranges
+    results.sort!
+    remove_overlapping results unless return_overlapping
+    results.compact
+  end
+end

data/lib/scantron/scanners/number_scanner.rb

@@ -0,0 +1,155 @@
+class NumberScanner < Scantron::Scanner
+  WORD_MAP = {
+    'trillion'  => 1_000_000_000_000,
+    'trillions' => 1_000_000_000_000,
+    'billion'   => 1_000_000_000,
+    'billions'  => 1_000_000_000,
+    'million'   => 1_000_000,
+    'millions'  => 1_000_000,
+    'thousand'  => 1_000,
+    'thousands' => 1_000,
+    'hundred'   => 100,
+    'ninety'    => 90,
+    'eighty'    => 80,
+    'seventy'   => 70,
+    'sixty'     => 60,
+    'fifty'     => 50,
+    'forty'     => 40,
+    'thirty'    => 30,
+    'twenty'    => 20,
+    'nineteen'  => 19,
+    'eighteen'  => 18,
+    'seventeen' => 17,
+    'sixteen'   => 16,
+    'fifteen'   => 15,
+    'fourteen'  => 14,
+    'thirteen'  => 13,
+    'twelve'    => 12,
+    'eleven'    => 11,
+    'ten'       => 10,
+    'nine'      => 9,
+    'eight'     => 8,
+    'seven'     => 7,
+    'six'       => 6,
+    'five'      => 5,
+    'four'      => 4,
+    'three'     => 3,
+    'two'       => 2,
+    'one'       => 1,
+    'half'      => Rational(1, 2),
+    'halves'    => Rational(1, 2),
+    'third'     => Rational(1, 3),
+    'thirds'    => Rational(1, 3),
+    'fourth'    => Rational(1, 4),
+    'fourths'   => Rational(1, 4),
+    'fifth'     => Rational(1, 5),
+    'fifths'    => Rational(1, 5),
+    'sixth'     => Rational(1, 6),
+    'sixths'    => Rational(1, 6),
+    'seventh'   => Rational(1, 7),
+    'sevenths'  => Rational(1, 7),
+    'eighth'    => Rational(1, 8),
+    'eighths'   => Rational(1, 8),
+    'zero'      => 0
+  }
+
+  words = WORD_MAP.keys.map { |v| v.sub /y$/, 'y-?' } * '|'
+  human = %r{(?:\b(?:#{words}))(?: ?\b(?:#{words}|an?d?)\b ?)*}i
+  rule :human, human do |r|
+    human_to_number r.to_s
+  end
+
+  #-
+  # This catches, perhaps, too many edge cases. Simplify.
+  #+
+  def self.human_to_number words
+    numbers = words.split(/\W+/).map { |w| WORD_MAP[w.downcase] || w }
+
+    case numbers.count { |n| n.is_a? Numeric }
+      when 0 then false
+      when 1 then numbers[0]
+    else
+      array = []
+      total = 0
+      limit = 1
+      words = []
+      reset = true
+
+      numbers.each.with_index do |n, i|
+        words << n and next if n.is_a?(String)
+
+        if n == 1 && limit == 1
+          reset = false
+          next
+        end
+
+        if n >= 1_000
+          total += n * limit
+          limit = 1
+          reset = true
+        else
+          if n < 1
+            if words.join(' ') =~ /\band\b/
+              if total > 0 && total % 1_000
+                if total % (factor = 10 ** (total.to_i.to_s.size - 1)) == 0
+                  limit = n * factor
+                else
+                  limit = n
+                end
+              else
+                limit += n
+              end
+            else
+              limit *= n
+            end
+          elsif words.join(' ') =~ /\band\b/ && numbers[i + 1].to_i < 1
+            total += limit
+            limit = n
+          elsif !reset && limit >= 1 &&
+            m1 = (n > (m2 = numbers[i + 1].to_i) ? n + m2 : n) and
+            m = [limit, m1].sort and
+            !m[1].to_s[-(m0 = m[0].to_i.to_s.size), m0].to_i.zero?
+
+            array << total + limit
+            total = 0
+            limit = n
+          elsif !reset && limit == 1 && n > numbers[i + 1].to_i &&
+            m = [limit, n + numbers[i + 1].to_i].sort and
+              !m[1].to_s[-(m[0].to_i.to_s.size), m[0].to_i.to_s.size].to_i.zero?
+
+            array << total + limit
+            total = 0
+            limit = n
+          else
+            n > limit ? limit *= n : limit += n
+          end
+
+          total += limit if numbers[i + 1].nil?
+          reset = false
+        end
+
+        words.clear
+      end
+
+      array.empty? ? total : array << total
+    end
+  end
+
+  rule :rational, %r{([-+])?(\d+ )?(\d*\.?\d+/\d*\.?\d+)} do |r|
+    if r.length != r.scanner.matched_size
+      parse r.to_s
+    else
+      "#{r.scanner[1]}#{r.scanner[3]}".to_r + r.scanner[2].to_i
+    end
+  end
+
+  int = /\d+(?:,?\d+)*/ # Could be stricter with delimiter matching...
+  pre = %r{(?<![,.]|\d|\d/|/\d)[-+]?}
+  rule :float, %r{#{pre}#{int}?\.\d+(?![,./]\d)} do |r|
+    r.to_s.gsub(/,/, '').to_f
+  end
+
+  rule :integer, %r{#{pre}#{int}(?!#{int}?[,./]\d| ?\d+/\d+)} do |r|
+    r.to_s.gsub(/,/, '').to_i
+  end
+end

data/lib/scantron/scanners/range_scanner.rb

@@ -0,0 +1,18 @@
+require 'number_scanner'
+
+class RangeScanner < Scantron::Scanner
+  values = NumberScanner.rules.values_at :human, :rational, :integer, :float
+  valued = /#{values.map { |r| r.regexp }.join '|'} ?/
+  regexp = /#{NumberScanner.rules[:human].regexp} ?(and|or|to) ?#{valued}/
+  rule :range_with_human, regexp do |r|
+    n = NumberScanner.scan r.to_s.sub(/-/, ' ')
+    n.size == 2 && n.first < n.last ? Range.new(*n) : false
+  end
+
+  values.delete_at 0
+  valued = /(#{values.map { |r| r.regexp }.join '|'} ?)/
+  rule :range_without_human, /#{valued} ?(-|and|or|to) ?#{valued}/ do |r|
+    n = NumberScanner.scan r.to_s.sub(/-/, ' ')
+    n.size == 2 && n.first < n.last ? Range.new(*n) : false
+  end
+end

data/lib/scantron/version.rb

@@ -0,0 +1,10 @@
+module Scantron
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+    BETA  = 'beta'
+
+    VERSION = [MAJOR, MINOR, PATCH, BETA].compact.join('.').freeze
+  end
+end

data/test/test_number_scanner.rb

@@ -0,0 +1,71 @@
+require 'scantron'
+require 'number_scanner'
+require 'test/unit'
+
+class TestNumberScanner < Test::Unit::TestCase
+  def test_converts_words_to_numbers
+    { <<STR                      => 234_567_890_123_456,
+Two hundred and thirty-four trillion five hundred sixty seven billion eight \
+hundred ninety million one hundred twenty three thousand four hundred fifty \
+six.
+STR
+      'one and a half'                => Rational(3, 2),
+      'three and a half'              => Rational(7, 2),
+      'one half'                      => Rational(1, 2),
+      'three halves'                  => Rational(3, 2),
+      'one half million'              => 500_000,
+      'three half millions'           => 1_500_000,
+      'one and a half million'        => 1_500_000,
+      'three and a half million'      => 3_500_000,
+      'one million and a half'        => 1_500_000,
+      'three million and a half'      => 3_500_000,
+      'thirty-seven and five eighths' => 37 + Rational(5, 8),
+      'thirty-seven fifty-eight'      => [37, 58],
+      'one two'                       => [1, 2],
+      'twelve three'                  => [12, 3],
+      'one twenty-three'              => [1, 23]
+    }.each do |string, expectation|
+      assert_equal expectation, NumberScanner.human_to_number(string)
+    end
+  end
+
+  def test_scans_human_numbers
+    { 'thirty-two' => [32],
+      'thirty two' => [32]
+    }.each do |string, expectation|
+      assert_equal expectation, NumberScanner.scan(string)
+    end
+  end
+
+  def test_scans_rationals
+    { '1 1/2'  => [Rational(3, 2)],
+      '-3/2'   => [Rational(-3, 2)],
+      '1 -1/2' => [1, Rational(-1, 2)]
+    }.each do |string, expectation|
+      assert_equal expectation, NumberScanner.scan(string)
+    end
+  end
+
+  def test_scans_floats
+    { '-.2' => [-0.2],
+      '3.2' => [ 3.2]
+    }.each do |string, expectation|
+      assert_equal expectation, NumberScanner.scan(string)
+    end
+  end
+
+  def test_scans_integers
+    { '-2' => [-2],
+      '32' => [32]
+    }.each do |string, expectation|
+      assert_equal expectation, NumberScanner.scan(string)
+    end
+  end
+
+  def test_mixed_company
+    str, arr = <<STR, [1, 2, 3, 4.5, 6.7, 8.9, 1, 2, 99, 100]
+1, 2, 3. 4.5, 6.7, 8.9. one, two, skip a few, ninety-nine-a-hundred
+STR
+    assert_equal arr, NumberScanner.scan(str)
+  end
+end

data/test/test_range_scanner.rb

@@ -0,0 +1,29 @@
+require 'scantron'
+require 'range_scanner'
+require 'test/unit'
+
+class TestRangeScanner < Test::Unit::TestCase
+  def test_scans_shared_company
+    { 'one and a half to two' => [Rational(3, 2)..2],
+      '1-2'                   => [1..2],
+      '1.5-2.0'               => [1.5..2.0],
+      '1 1/2-2 1/2'           => [Rational(3, 2)..Rational(5, 2)]
+    }.each do |string, expectation|
+      assert_equal expectation, RangeScanner.scan(string)
+    end
+  end
+
+  def test_scans_mixed_company
+    { 'from one to 100'       => [1..100],
+      '1 - 1.5'               => [1..1.5],
+      '2 1/2 or 3'            => [Rational(5, 2)..3],
+      'between seven and 10'  => [7..10]
+    }.each do |string, expectation|
+      assert_equal expectation, RangeScanner.scan(string)
+    end
+  end
+
+  def test_scans_min_to_max
+    assert_equal [], RangeScanner.scan("4 or 3 people")
+  end
+end

data/test/test_scanner.rb

@@ -0,0 +1,29 @@
+require 'scantron'
+
+class TestScanner < Test::Unit::TestCase
+  class BogusScanner < Scantron::Scanner
+    after_match { |r| :default }
+    rule(:test, /\btest\b/) { 1 }
+    rule(:tests, /\btests\b/) { |r| "#{r}" }
+    rule :testing, /,.+$/
+    rule(:false, /and/) { |r| false }
+  end
+
+  def setup
+    @scanner = BogusScanner.new 'and test the tests, k?'
+  end
+
+  def test_should_scan
+    assert_equal [1, 'tests', :default], @scanner.scan
+  end
+
+  def test_should_scrub
+    assert_equal "and  the ", @scanner.scrub
+
+    assert_equal %(and <i id="1">test</i> the <i id="tests">tests</i>),
+      @scanner.scrub { |r|
+        %(<i id="#{r.value}">#{r}</i>) unless r.value == :default
+      }
+    assert_equal 'and', BogusScanner.scrub('and')
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: scantron
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1
+  - beta
+  version: 0.0.1.beta
+platform: ruby
+authors: 
+- Stephen Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-28 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdoctest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Rule-based string scanning and scrubbing
+email: stephen@stephencelis.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/scantron/result.rb
+- lib/scantron/rule.rb
+- lib/scantron/scanner.rb
+- lib/scantron/scanners/amount_scanner.rb
+- lib/scantron/scanners/number_scanner.rb
+- lib/scantron/scanners/range_scanner.rb
+- lib/scantron/version.rb
+- lib/scantron.rb
+- test/test_number_scanner.rb
+- test/test_range_scanner.rb
+- test/test_scanner.rb
+has_rdoc: true
+homepage: http://github.com/stephencelis/scantron
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rule-based string scanning and scrubbing
+test_files: 
+- test/test_number_scanner.rb
+- test/test_range_scanner.rb
+- test/test_scanner.rb