porter2stemmer 1.0.0

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Neil Smith
+
+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/README.md

@@ -0,0 +1,58 @@
+The Porter 2 stemmer
+====================
+This is the Porter 2 stemming algorithm, as described at 
+http://snowball.tartarus.org/algorithms/english/stemmer.html
+The original paper is:
+
+Porter, 1980, "An algorithm for suffix stripping", _Program_, Vol. 14,
+no. 3, pp 130-137
+
+Features of this implementation
+===============================
+This stemmer is written in pure Ruby, making it easy to modify for language variants. 
+For instance, the original Porter stemmer only works for American English and does
+not recognise British English's '-ise' as an alternate spelling of '-ize'. This 
+implementation has been extended to handle correctly British English.
+
+This stemmer also features a comprehensive test set of over 29,000 words, taken from the 
+[Porter 2 stemmer website](http://snowball.tartarus.org/algorithms/english/stemmer.html).
+
+Files
+=====
+Constants for the stemmer are in the Porter2 module.
+
+Procedures that implement the stemmer are added to the String class.
+
+The stemmer algorithm is implemented in the String#porter2_stem procedure.
+
+Internationalisation
+====================
+There isn't much, as this is a stemmer that only works for English.
+
+The `gb_english` flag to the various procedures allows the stemmer to treat the British 
+English '-ise' the same as the American English '-ize'.
+
+Longest suffixes
+================
+Several places in the algorithm require matching the longest suffix of a word. The 
+regexp engine in Ruby 1.9 seems to handle alterntives in regexps by finding the 
+alternative that matches at the first position in the string. As we're only talking 
+about suffixes, that first match is also the longest suffix. If the regexp engine changes,
+this behaviour may change and break the stemmer.
+
+Usage
+=====
+Call the String#porter2_stem or String#stem methods on a string to return its stem
+    "consistency".stem       # => "consist"
+    "knitting".stem          # => "knit"
+    "articulated".stem       # => "articul"
+    "nationalize".stem       # => "nation"
+    "nationalise".stem       # => "nationalis"
+    "nationalise".stem(true) # => "nation"
+
+Author
+======
+The Porter 2 stemming algorithm was developed by 
+[Martin Porter](http://snowball.tartarus.org/algorithms/english/stemmer.html). 
+This implementation is by [Neil Smith](http://www.njae.me.uk).
+

data/README.rdoc

@@ -0,0 +1,67 @@
+= porter2stemmer
+
+==The Porter 2 stemmer
+This is the Porter 2 stemming algorithm, as described at 
+http://snowball.tartarus.org/algorithms/english/stemmer.html
+The original paper is:
+
+Porter, 1980, "An algorithm for suffix stripping", _Program_, Vol. 14, no. 3, pp 130-137
+
+==Features of this implementation
+This stemmer is written in pure Ruby, making it easy to modify for language variants. 
+For instance, the original Porter stemmer only works for American English and does
+not recognise British English's '-ise' as an alternate spelling of '-ize'. This 
+implementation has been extended to handle correctly British English.
+
+This stemmer also features a comprehensive test set of over 29,000 words, taken from the 
+{Porter 2 stemmer website}[http://snowball.tartarus.org/algorithms/english/stemmer.html].
+
+==Files
+Constants for the stemmer are in the Porter2 module.
+
+Procedures that implement the stemmer are added to the String class.
+
+The stemmer algorithm is implemented in the String#porter2_stem procedure.
+
+==Internationalisation
+There isn't much, as this is a stemmer that only works for English.
+
+The +gb_english+ flag to the various procedures allows the stemmer to treat the British 
+English '-ise' the same as the American English '-ize'.
+
+==Longest suffixes
+Several places in the algorithm require matching the longest suffix of a word. The 
+regexp engine in Ruby 1.9 seems to handle alterntives in regexps by finding the 
+alternative that matches at the first position in the string. As we're only talking 
+about suffixes, that first match is also the longest suffix. If the regexp engine changes,
+this behaviour may change and break the stemmer.
+
+==Usage
+Call the String#porter2_stem or String#stem methods on a string to return its stem
+  "consistency".stem       # => "consist"
+  "knitting".stem          # => "knit"
+  "articulated".stem       # => "articul"
+  "nationalize".stem       # => "nation"
+  "nationalise".stem       # => "nationalis"
+  "nationalise".stem(true) # => "nation"
+
+==Author
+The Porter 2 stemming algorithm was developed by 
+{Martin Porter}[http://snowball.tartarus.org/algorithms/english/stemmer.html]. 
+This implementation is by {Neil Smith}[http://www.njae.me.uk].
+
+== Contributing to porter2stemmer
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Neil Smith. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "porter2stemmer"
+  gem.homepage = "http://github.com/NeilNjae/porter2stemmer"
+  gem.license = "MIT"
+  gem.summary = %Q{A pure Ruby implementation of the Porter 2 stemmer}
+  gem.description = %Q{This is the Porter 2 stemming algorithm, as described at 
+http://snowball.tartarus.org/algorithms/english/stemmer.html It removes suffixes from English words, revealing something closer to the stem of the word. For instance "acknowledgments".stem => "acknowledg".}
+  gem.email = "neil.github@njae.me.uk"
+  gem.authors = ["Neil Smith"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "porter2stemmer #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/porter2stemmer/constants.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+# Constants for the Porter 2 stemmer
+module Porter2
+
+  # A non-vowel
+  C = "[^aeiouy]"
+
+  # A vowel: a e i o u y
+  V = "[aeiouy]"
+
+  # A non-vowel other than w, x, or Y
+  CW = "[^aeiouywxY]"
+
+  # Doubles created when adding a suffix: these are undoubled when stemmed
+  Double = "(bb|dd|ff|gg|mm|nn|pp|rr|tt)"
+
+  # A valid letter that can come before 'li' (or 'ly')
+  Valid_LI = "[cdeghkmnrt]"
+
+  # A specification for a short syllable.
+  #
+  # A short syllable in a word is either: 
+  # 1. a vowel followed by a non-vowel other than w, x or Y and preceded by a non-vowel, or 
+  # 2. a vowel at the beginning of the word followed by a non-vowel.
+  #
+  # (The original document is silent on whether sequences of two or more non-vowels make a
+  # syllable long. But as this specification is only used to find sequences of non-vowel -
+  # vowel - non-vowel - end-of-word, this ambiguity does not have an effect.)
+  SHORT_SYLLABLE = "((#{C}#{V}#{CW})|(^#{V}#{C}))"
+
+  # Suffix transformations used in porter2_step2.
+  # (ogi, li endings dealt with in procedure)
+  STEP_2_MAPS = {"tional" => "tion",
+		 "enci" => "ence",
+                 "anci" => "ance",
+                 "abli" => "able",
+                 "entli" => "ent",
+                 "ization" => "ize",
+                 "izer" => "ize",
+                 "ational" => "ate",
+                 "ation" => "ate",
+                 "ator" => "ate",
+                 "alism" => "al",
+                 "aliti" => "al",
+                 "alli" => "al",
+                 "fulness" => "ful",
+                 "ousli" => "ous",
+                 "ousness" => "ous",
+                 "iveness" => "ive",
+                 "iviti" => "ive",
+                 "biliti" => "ble",
+                 "bli" => "ble",
+                 "fulli" => "ful",
+                 "lessli" => "less" }
+
+  # Suffix transformations used in porter2_step3.
+  # (ative ending dealt with in procedure)  
+  STEP_3_MAPS = {"tional" => "tion",
+                 "ational" => "ate",
+                 "alize" => "al",
+                 "icate" => "ic",
+                 "iciti" => "ic",
+                 "ical" => "ic",
+                 "ful" => "",
+                 "ness" => "" }
+  
+  # Suffix transformations used in porter2_step4.
+  # (ion ending dealt with in procedure)
+  STEP_4_MAPS = {"al" => "",
+                 "ance" => "",
+                 "ence" => "",
+                 "er" => "",
+                 "ic" => "",
+                 "able" => "",
+                 "ible" => "",
+                 "ant" => "",
+                 "ement" => "",
+                 "ment" => "",
+                 "ent" => "",
+                 "ism" => "",
+                 "ate" => "",
+                 "iti" => "",
+                 "ous" => "",
+                 "ive" => "",
+                 "ize" => "" }
+  
+  # Special-case stemmings 
+  SPECIAL_CASES = {"skis" => "ski",
+                   "skies" => "sky",
+                    
+                   "dying" => "die",
+                   "lying" => "lie",
+                   "tying" => "tie",
+                   "idly" =>  "idl",
+                   "gently" => "gentl",
+                   "ugly" => "ugli",
+                   "early" => "earli",
+                   "only" => "onli",
+                   "singly" =>"singl",
+                    
+                   "sky" => "sky",
+                   "news" => "news",
+                   "howe" => "howe",
+                   "atlas" => "atlas",
+                   "cosmos" => "cosmos",
+                   "bias" => "bias",
+                   "andes" => "andes" }
+   
+  # Special case words to stop processing after step 1a.
+  STEP_1A_SPECIAL_CASES = %w[ inning outing canning herring earring proceed exceed succeed ]
+
+end
+

data/lib/porter2stemmer/implementation.rb

@@ -0,0 +1,326 @@
+# coding: utf-8
+
+# Implementation of the Porter 2 stemmer. String#porter2_stem is the main stemming procedure.
+
+class String
+  # Tidy up the word before we get down to the algorithm
+  def porter2_tidy
+    preword = self.to_s.strip.downcase
+    
+    # map apostrophe-like characters to apostrophes
+    preword.gsub!(/‘/, "'")
+    preword.gsub!(/’/, "'")
+
+    preword
+  end
+     
+
+  # Preprocess the word. 
+  # Remove any initial ', if present. Then, set initial y, or y after a vowel, to Y
+  #
+  # (The comment to 'establish the regions R1 and R2' in the original description 
+  # is an implementation optimisation that identifies where the regions start. As
+  # no modifications are made to the word that affect those positions, you may want
+  # to cache them now. This implementation doesn't do that.)
+  def porter2_preprocess    
+    w = self.dup
+
+    # remove any initial apostrophe
+    w.gsub!(/^'*(.)/, '\1')
+    
+    # set initial y, or y after a vowel, to Y
+    w.gsub!(/^y/, "Y")
+    w.gsub!(/(#{Porter2::V})y/, '\1Y')
+    
+    w
+  end
+    
+
+  # R1 is the portion of the word after the first non-vowel after the first vowel
+  # (with words beginning 'gener-', 'commun-', and 'arsen-' treated as special cases
+  def porter2_r1
+    if self =~ /^(gener|commun|arsen)(?<r1>.*)/
+      Regexp.last_match(:r1)
+    else
+      self =~ /#{Porter2::V}#{Porter2::C}(?<r1>.*)$/
+      Regexp.last_match(:r1) || ""
+    end
+  end
+
+
+  # R2 is the portion of R1 (porter2_r1) after the first non-vowel after the first vowel
+  def porter2_r2
+    self.porter2_r1 =~ /#{Porter2::V}#{Porter2::C}(?<r2>.*)$/
+    Regexp.last_match(:r2) || ""
+  end
+  
+
+  # Returns true if the word ends with a short syllable
+  def porter2_ends_with_short_syllable?
+    self =~ /#{Porter2::SHORT_SYLLABLE}$/ ? true : false
+  end
+
+
+  # A word is short if it ends in a short syllable, and R1 is null
+  def porter2_is_short_word?
+    self.porter2_ends_with_short_syllable? and self.porter2_r1.empty?
+  end
+  
+
+  # Search for the longest among the suffixes, 
+  # * '
+  # * 's
+  # * 's'
+  # and remove if found.
+  def porter2_step0
+    self.sub!(/(.)('s'|'s|')$/, '\1') || self
+  end
+  
+
+  # Search for the longest among the following suffixes, and perform the action indicated. 
+  # sses:: replace by ss 
+  # ied, ies:: replace by i if preceded by more than one letter, otherwise by ie
+  # s:: delete if the preceding word part contains a vowel not immediately before the s
+  # us, ss:: do nothing
+  def porter2_step1a
+    if self =~ /sses$/
+      self.sub(/sses$/, 'ss')
+    elsif self =~ /..(ied|ies)$/
+      self.sub(/(ied|ies)$/, 'i')
+    elsif self =~ /(ied|ies)$/
+      self.sub(/(ied|ies)$/, 'ie')
+    elsif self =~ /(us|ss)$/
+      self
+    elsif self =~ /s$/
+      if self =~ /(#{Porter2::V}.+)s$/
+        self.sub(/s$/, '') 
+      else
+        self
+      end
+    else
+      self
+    end
+  end
+  
+
+  # Search for the longest among the following suffixes, and perform the action indicated. 
+  # eed, eedly:: replace by ee if the suffix is also in R1 
+  # ed, edly, ing, ingly:: delete if the preceding word part contains a vowel and, 
+  #                        after the deletion:
+  #                        * if the word ends at, bl or iz: add e, or
+  #                        * if the word ends with a double: remove the last letter, or
+  #                        * if the word is short: add e
+  # 
+  # (If gb_english is +true+, treat the 'is' suffix as 'iz' above.)
+  def porter2_step1b(gb_english = false)
+    if self =~ /(eed|eedly)$/
+      if self.porter2_r1 =~ /(eed|eedly)$/
+        self.sub(/(eed|eedly)$/, 'ee')
+      else
+        self
+      end
+    else
+      w = self.dup
+      if w =~ /#{Porter2::V}.*(ed|edly|ing|ingly)$/
+        w.sub!(/(ed|edly|ing|ingly)$/, '')
+        if w =~ /(at|lb|iz)$/
+          w += 'e' 
+        elsif w =~ /is$/ and gb_english
+          w += 'e' 
+        elsif w =~ /#{Porter2::Double}$/
+	  w.chop!
+        elsif w.porter2_is_short_word?
+          w += 'e'
+        end
+      end
+      w
+    end
+  end
+
+
+  # Replace a suffix of y or Y by i if it is preceded by a non-vowel which is 
+  # not the first letter of the word.
+  def porter2_step1c
+    if self =~ /.+#{Porter2::C}(y|Y)$/
+      self.sub(/(y|Y)$/, 'i')
+    else
+      self
+    end
+  end
+  
+
+  # Search for the longest among the suffixes listed in the keys of Porter2::STEP_2_MAPS. 
+  # If one is found and that suffix occurs in R1, replace it with the value 
+  # found in STEP_2_MAPS.
+  #
+  # (Suffixes 'ogi' and 'li' are treated as special cases in the procedure.)
+  # 
+  # (If gb_english is +true+, replace the 'iser' and 'isation' suffixes with
+  # 'ise', similarly to how 'izer' and 'ization' are treated.)
+  def porter2_step2(gb_english = false)
+    r1 = self.porter2_r1
+    s2m = Porter2::STEP_2_MAPS.dup
+    if gb_english
+      s2m["iser"] = "ise"
+      s2m["isation"] = "ise"
+    end
+    step_2_re = Regexp.union(s2m.keys.map {|r| Regexp.new(r + "$")})
+    if self =~ step_2_re
+      if r1 =~ /#{$&}$/
+        self.sub(/#{$&}$/, s2m[$&])
+      else
+        self
+      end
+    elsif r1 =~ /li$/ and self =~ /(#{Porter2::Valid_LI})li$/
+      self.sub(/li$/, '')
+    elsif r1 =~ /ogi$/ and self =~ /logi$/
+      self.sub(/ogi$/, 'og')
+    else
+      self
+    end
+  end
+     
+
+  # Search for the longest among the suffixes listed in the keys of Porter2::STEP_3_MAPS. 
+  # If one is found and that suffix occurs in R1, replace it with the value 
+  # found in STEP_3_MAPS.
+  #
+  # (Suffix 'ative' is treated as a special case in the procedure.)
+  # 
+  # (If gb_english is +true+, replace the 'alise' suffix with
+  # 'al', similarly to how 'alize' is treated.)
+  def porter2_step3(gb_english = false)
+    if self =~ /ative$/ and self.porter2_r2 =~ /ative$/
+      self.sub(/ative$/, '')
+    else
+      s3m = Porter2::STEP_3_MAPS.dup
+      if gb_english
+	s3m["alise"] = "al"
+      end
+      step_3_re = Regexp.union(s3m.keys.map {|r| Regexp.new(r + "$")})
+      r1 = self.porter2_r1
+      if self =~ step_3_re and r1 =~ /#{$&}$/ 
+	self.sub(/#{$&}$/, s3m[$&])
+      else
+	self
+      end
+    end
+  end
+  
+
+  # Search for the longest among the suffixes listed in the keys of Porter2::STEP_4_MAPS. 
+  # If one is found and that suffix occurs in R2, replace it with the value 
+  # found in STEP_4_MAPS.
+  #
+  # (Suffix 'ion' is treated as a special case in the procedure.)
+  # 
+  # (If gb_english is +true+, delete the 'ise' suffix if found.)
+  def porter2_step4(gb_english = false)
+    if self.porter2_r2 =~ /ion$/ and self =~ /(s|t)ion$/
+      self.sub(/ion$/, '')
+    else
+      s4m = Porter2::STEP_4_MAPS.dup
+      if gb_english
+        s4m["ise"] = ""
+      end
+      step_4_re = Regexp.union(s4m.keys.map {|r| Regexp.new(r + "$")})
+      r2 = self.porter2_r2
+      if self =~ step_4_re
+        if r2 =~ /#{$&}/
+          self.sub(/#{$&}$/, s4m[$&])
+        else
+          self
+        end
+      else
+        self
+      end
+    end
+  end
+
+
+  # Search for the the following suffixes, and, if found, perform the action indicated. 
+  # e:: delete if in R2, or in R1 and not preceded by a short syllable
+  # l:: delete if in R2 and preceded by l
+  def porter2_step5
+    if self =~ /ll$/ and self.porter2_r2 =~ /l$/
+      self.sub(/ll$/, 'l') 
+    elsif self =~ /e$/ and self.porter2_r2 =~ /e$/ 
+      self.sub(/e$/, '') 
+    else
+      r1 = self.porter2_r1
+      if self =~ /e$/ and r1 =~ /e$/ and not self =~ /#{Porter2::SHORT_SYLLABLE}e$/
+        self.sub(/e$/, '')
+      else
+        self
+      end
+    end
+  end
+  
+
+  # Turn all Y letters into y
+  def porter2_postprocess
+    self.gsub(/Y/, 'y')
+  end
+
+  public
+  
+  # Perform the stemming procedure. If +gb_english+ is true, treat '-ise' and similar suffixes
+  # as '-ize' in American English.
+  def porter2_stem(gb_english = false)
+    preword = self.porter2_tidy
+    return preword if preword.length <= 2
+
+    word = preword.porter2_preprocess
+    
+    if Porter2::SPECIAL_CASES.has_key? word
+      Porter2::SPECIAL_CASES[word]
+    else
+      w1a = word.porter2_step0.porter2_step1a
+      if Porter2::STEP_1A_SPECIAL_CASES.include? w1a 
+	w1a
+      else
+        w1a.porter2_step1b(gb_english).porter2_step1c.porter2_step2(gb_english).porter2_step3(gb_english).porter2_step4(gb_english).porter2_step5.porter2_postprocess
+      end
+    end
+  end  
+  
+  # A verbose version of porter2_stem that prints the output of each stage to STDOUT
+  def porter2_stem_verbose(gb_english = false)
+    preword = self.porter2_tidy
+    puts "Preword: #{preword}"
+    return preword if preword.length <= 2
+
+    word = preword.porter2_preprocess
+    puts "Preprocessed: #{word}"
+    
+    if Porter2::SPECIAL_CASES.has_key? word
+      puts "Returning #{word} as special case #{Porter2::SPECIAL_CASES[word]}"
+      Porter2::SPECIAL_CASES[word]
+    else
+      r1 = word.porter2_r1
+      r2 = word.porter2_r2
+      puts "R1 = #{r1}, R2 = #{r2}"
+    
+      w0 = word.porter2_step0 ; puts "After step 0:  #{w0} (R1 = #{w0.porter2_r1}, R2 = #{w0.porter2_r2})"
+      w1a = w0.porter2_step1a ; puts "After step 1a: #{w1a} (R1 = #{w1a.porter2_r1}, R2 = #{w1a.porter2_r2})"
+      
+      if Porter2::STEP_1A_SPECIAL_CASES.include? w1a
+        puts "Returning #{w1a} as 1a special case"
+	w1a
+      else
+        w1b = w1a.porter2_step1b(gb_english) ; puts "After step 1b: #{w1b} (R1 = #{w1b.porter2_r1}, R2 = #{w1b.porter2_r2})"
+        w1c = w1b.porter2_step1c ; puts "After step 1c: #{w1c} (R1 = #{w1c.porter2_r1}, R2 = #{w1c.porter2_r2})"
+        w2 = w1c.porter2_step2(gb_english) ; puts "After step 2:  #{w2} (R1 = #{w2.porter2_r1}, R2 = #{w2.porter2_r2})"
+        w3 = w2.porter2_step3(gb_english) ; puts "After step 3:  #{w3} (R1 = #{w3.porter2_r1}, R2 = #{w3.porter2_r2})"
+        w4 = w3.porter2_step4(gb_english) ; puts "After step 4:  #{w4} (R1 = #{w4.porter2_r1}, R2 = #{w4.porter2_r2})"
+        w5 = w4.porter2_step5 ; puts "After step 5:  #{w5}"
+        wpost = w5.porter2_postprocess ; puts "After postprocess: #{wpost}"
+        wpost
+      end
+    end
+  end  
+  
+  alias stem porter2_stem
+
+end
+

data/lib/porter2stemmer.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+# ==The Porter 2 stemmer
+
+require 'porter2stemmer/constants'
+require 'porter2stemmer/implementation'
+