Module: Lingo::Attendee::Stemmer::Porter

Extended by:

Porter

Included in:

Porter

Defined in:

lib/lingo/attendee/stemmer/porter.rb

Constant Summary

RULES =

{
  # Step 1a

  S100: [
    'SSES -> SS',  # caresses -> caress

    'IES  -> I',   # ponies   -> poni, ties -> ti

    'SS   -> SS',  # caress   -> caress

    'S    -> '     # cats     -> cat

  ],

  # Step 1b

  S110: [
    '(m>0) EED -> EE goto(S120)',  # agreed    ->  agree,   feed -> feed

    '(*v*) ED  ->    goto(S111)',  # plastered ->  plaster, bled -> bled

    '(*v*) ING ->    goto(S111)',  # motoring  ->  motor,   sing -> sing

    'goto(S120)'
  ],

  # If the second or third of the rules in Step 1b is successful,

  # the following is done:

  S111: [
    'AT -> ATE',                            # conflat(ed) -> conflate

    'BL -> BLE',                            # troubl(ed)  -> trouble

    'IZ -> IZE',                            # siz(ed)     -> size

    '(*d and not (*L or *S or *Z)) -> -1',  # hopp(ing)   -> hop

                                            # tann(ed)    -> tan

                                            # fall(ing)   -> fall

                                            # hiss(ing)   -> hiss

                                            # fizz(ed)    -> fizz

    '(m=1 and *o) -> E'                     # fail(ing)   -> fail

                                            # fil(ing)    -> file

  ],

  # The rule to map to a single letter causes the removal of one of

  # the double letter pair. The -E is put back on -AT, -BL and -IZ,

  # so that the suffixes -ATE, -BLE and -IZE can be recognised later.

  # This E may be removed in step 4.


  # Step 1c

  S120: [
    '(*v*) Y -> I'  # happy -> happi, sky -> sky

  ],

  # Step 1 deals with plurals and past participles. The subsequent

  # steps are much more straightforward.


  # Step 2

  S200: [
    '(m>0) ATIONAL -> ATE',   # relational     -> relate

    '(m>0) TIONAL  -> TION',  # conditional    -> condition, rational -> rational

    '(m>0) ENCI    -> ENCE',  # valenci        -> valence

    '(m>0) ANCI    -> ANCE',  # hesitanci      -> hesitance

    '(m>0) IZER    -> IZE',   # digitizer      -> digitize

    '(m>0) ABLI    -> ABLE',  # conformabli    -> conformable

    '(m>0) ALLI    -> AL',    # radicalli      -> radical

    '(m>0) ENTLI   -> ENT',   # differentli    -> different

    '(m>0) ELI     -> E',     # vileli         -> vile

    '(m>0) OUSLI   -> OUS',   # analogousli    -> analogous

    '(m>0) IZATION -> IZE',   # vietnamization -> vietnamize

    '(m>0) ATION   -> ATE',   # predication    -> predicate

    '(m>0) ATOR    -> ATE',   # operator       -> operate

    '(m>0) ALISM   -> AL',    # feudalism      -> feudal

    '(m>0) IVENESS -> IVE',   # decisiveness   -> decisive

    '(m>0) FULNESS -> FUL',   # hopefulness    -> hopeful

    '(m>0) OUSNESS -> OUS',   # callousness    -> callous

    '(m>0) ALITI   -> AL',    # formaliti      -> formal

    '(m>0) IVITI   -> IVE',   # sensitiviti    -> sensitive

    '(m>0) BILITI  -> BLE'    # sensibiliti    -> sensible

  ],

  # The test for the string S1 can be made fast by doing a program

  # switch on the penultimate letter of the word being tested. This

  # gives a fairly even breakdown of the possible values of the

  # string S1. It will be seen in fact that the S1-strings in step 2

  # are presented here in the alphabetical order of their penultimate

  # letter. Similar techniques may be applied in the other steps.


  # Step 3

  S300: [
    '(m>0) ICATE -> IC',  # triplicate  -> triplic

    '(m>0) ATIVE -> ',    # formative   -> form

    '(m>0) ALIZE -> AL',  # formalize   -> formal

    '(m>0) ICITI -> IC',  # electriciti -> electric

    '(m>0) ICAL  -> IC',  # electrical  -> electric

    '(m>0) FUL   -> ',    # hopeful     -> hope

    '(m>0) NESS  -> '     # goodness    -> good

  ],

  # Step 4

  S400: [
    '(m>1) AL    -> ',               # revival     -> reviv

    '(m>1) ANCE  -> ',               # allowance   -> allow

    '(m>1) ENCE  -> ',               # inference   -> infer

    '(m>1) ER    -> ',               # airliner    -> airlin

    '(m>1) IC    -> ',               # gyroscopic  -> gyroscop

    '(m>1) ABLE  -> ',               # adjustable  -> adjust

    '(m>1) IBLE  -> ',               # defensible  -> defens

    '(m>1) ANT   -> ',               # irritant    -> irrit

    '(m>1) EMENT -> ',               # replacement -> replac

    '(m>1) MENT  -> ',               # adjustment  -> adjust

    '(m>1) ENT   -> ',               # dependent   -> depend

    '(m>1 and (*S or *T)) ION -> ',  # adoption    -> adopt

    '(m>1) OU    -> ',               # homologou   -> homolog

    '(m>1) ISM   -> ',               # communism   -> commun

    '(m>1) ATE   -> ',               # activate    -> activ

    '(m>1) ITI   -> ',               # angulariti  -> angular

    '(m>1) OUS   -> ',               # homologous  -> homolog

    '(m>1) IVE   -> ',               # effective   -> effect

    '(m>1) IZE   -> '                # bowdlerize  -> bowdler

  ],

  # The suffixes are now removed. All that remains is a little

  # tidying up.


  # Step 5a

  S500: [
    '(m>1) E -> ',            # probate -> probat, rate -> rate

    '(m=1 and not *o) E -> '  # cease   -> ceas

  ],

  # Step 5b

  S510: [
    '(m > 1 and *d and *L) -> -1'  # controll -> control, roll -> roll

  ]
}

GOTO_RE =

%r{^#{goto_re = %r{\s*goto\((\S+)\)}}$}

RULE_RE =

%r{^(\(.+\))?\s*(\S*)\s*->\s*(\S*?)(?:#{goto_re})?\s*$}

Instance Method Summary

• #stem(word, found = false) ⇒ Object

Instance Method Details

#stem(word, found = false) ⇒ Object

# File 'lib/lingo/attendee/stemmer/porter.rb', line 283

def stem(word, found = false)
  goto, conv = nil, lambda { |s, h| h.each { |q, r| s.gsub!(q, r.to_s) } }

  RULES.each { |key, rules|
    next if goto && goto != key.to_s

    rules.each { |rule|
      case rule
        when RULE_RE
          cond, repl, goto = $1, $3, $4
          stem = word[/(.+)#{Unicode.downcase($2)}$/, 1] or next
        when GOTO_RE
          goto = $1
          break
      end

      conv[shad = stem.dup,
        /[^aeiouy]/ => 'c',
        /[aeiou]/   => 'v',
        /cy/        => 'cv',
        /y/         => 'c'
      ]

      if cond
        conv[cond,
          'm'   => shad.scan(/vc/).size,
          '*v*' => shad.include?('v'),
          '*d'  => shad.end_with?('c') && (last = stem[-1]) == stem[-2],
          '*o'  => shad.end_with?('cvc') && !'wxy'.include?(last),
          'and' => '&&',
          'or'  => '||',
          'not' => '!',
          '='   => '=='
        ]

        last.upcase! if last
        cond.gsub!(/\*(\w)/) { last == $1 }

        next unless eval(cond)
      end

      found, word = true, begin
        stem[0...Integer(repl)]
      rescue ArgumentError
        stem << Unicode.downcase(repl)
      end

      break
    }
  }

  word if found
end