spellingfilter.cpp

 
#include <kdebug.h>
#include "spellingfilter.h"
 
//-----------------------------------------------------------------------------
// SpellingFilter implementation
//
 
SpellingFilter::SpellingFilter(const TQString& text, const TQString& quotePrefix,
  UrlFiltering filterUrls, EmailAddressFiltering filterEmailAddresses,
  const TQStringList& filterStrings)
  : mOriginal(text)
{
  TextCensor c(text);
 
  if(!quotePrefix.isEmpty())
    c.censorQuotations(quotePrefix);
 
  if(filterUrls)
    c.censorUrls();
 
  if(filterEmailAddresses)
    c.censorEmailAddresses();
 
  TQStringList::const_iterator iter = filterStrings.begin();
  while(iter != filterStrings.end())
  {
    c.censorString(*iter);
    ++iter;
  }
 
  mFiltered = c.censoredText();
}
 
TQString SpellingFilter::originalText() const
{
  return mOriginal;
}
 
TQString SpellingFilter::filteredText() const
{
  return mFiltered;
}
 
//-----------------------------------------------------------------------------
// SpellingFilter::TextCensor implementation
//
 
SpellingFilter::TextCensor::TextCensor(const TQString& s)
  : LinkLocator(s)
{
 
}
 
void SpellingFilter::TextCensor::censorQuotations(const TQString& quotePrefix)
{
  mPos = 0;
  while(mPos < static_cast<int>(mText.length()))
  {
    // Find start of quotation
    findQuotation(quotePrefix);
    if(mPos < static_cast<int>(mText.length()))
    {
      int start = mPos;
      skipQuotation(quotePrefix);
 
      // Replace quotation with spaces
      int len = mPos - start;
      TQString spaces;
      spaces.fill(' ', len);
      mText.replace(start, len, spaces);
 
      //kdDebug(5006) << "censored quotation ["
      //  << start << ", " << mPos << ")" << endl;
    }
  }
}
 
void SpellingFilter::TextCensor::censorUrls()
{
  mPos = 0;
  while(mPos < static_cast<int>(mText.length()))
  {
    // Find start of url
    TQString url;
    while(mPos < static_cast<int>(mText.length()) && url.isEmpty())
    {
      url = getUrl();
      ++mPos;
    }
 
    if(mPos < static_cast<int>(mText.length()) && !url.isEmpty())
    {
      int start = mPos - url.length();
 
      // Replace url with spaces
      url.fill(' ');
      mText.replace(start, url.length(), url);
 
      //kdDebug(5006) << "censored url ["
      //  << start << ", " << mPos << ")" << endl;
    }
  }
}
 
void SpellingFilter::TextCensor::censorEmailAddresses()
{
  mPos = 0;
  while(mPos < static_cast<int>(mText.length()))
  {
    // Find start of email address
    findEmailAddress();
    if(mPos < static_cast<int>(mText.length()))
    {
      TQString address = getEmailAddress();
      ++mPos;
      if(!address.isEmpty())
      {
        int start = mPos - address.length();
 
        // Replace address with spaces
        address.fill(' ');
        mText.replace(start, address.length(), address);
 
        //kdDebug(5006) << "censored addr ["
        //  << start << ", "<< mPos << ")" << endl;
      }
    }
  }
}
 
void SpellingFilter::TextCensor::censorString(const TQString& s)
{
  mPos = 0;
  while(mPos != -1)
  {
    // Find start of string
    mPos = mText.find(s, mPos);
    if(mPos != -1)
    {
      // Replace string with spaces
      TQString spaces;
      spaces.fill(' ', s.length());
      mText.replace(mPos, s.length(), spaces);
      mPos += s.length();
 
      //kdDebug(5006) << "censored string ["
      //  << mPos << ", "<< mPos+s.length() << ")" << endl;
    }
  }
}
 
TQString SpellingFilter::TextCensor::censoredText() const
{
  return mText;
}
 
//-----------------------------------------------------------------------------
// text censorship helper functions
//
 
bool SpellingFilter::TextCensor::atLineStart() const
{
  return (mPos == 0 && static_cast<int>(mText.length()) > 0) || (mText[mPos - 1] == '\n');
}
 
void SpellingFilter::TextCensor::skipLine()
{
  mPos = mText.find('\n', mPos);
  if(mPos == -1)
    mPos = static_cast<int>(mText.length());
  else
    ++mPos;
}
 
bool SpellingFilter::TextCensor::atQuotation(const TQString& quotePrefix) const
{
  return atLineStart() &&
    mText.mid(mPos, quotePrefix.length()) == quotePrefix;
}
 
void SpellingFilter::TextCensor::skipQuotation(const TQString& quotePrefix)
{
  while(atQuotation(quotePrefix))
    skipLine();
}
 
void SpellingFilter::TextCensor::findQuotation(const TQString& quotePrefix)
{
  while(mPos < static_cast<int>(mText.length()) && !atQuotation(quotePrefix))
    skipLine();
}
 
void SpellingFilter::TextCensor::findEmailAddress()
{
  while(mPos < static_cast<int>(mText.length()) && mText[mPos] != '@')
    ++mPos;
}