+ boost::filesystem::path result(getHomeDir() / profile);

+ try {

+ boost::filesystem::create_directory(result);

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+ return result;

+ std::vector<boost::filesystem::path> resourcePaths = getResourceDirs();

+ foreach(const boost::filesystem::path& resourcePath, resourcePaths) {

+ boost::filesystem::path r(resourcePath / resource);

+ if (boost::filesystem::exists(r)) {

+ return r;

+ }

+ }

+ return boost::filesystem::path();

+ return Paths::getExecutablePath();

+ class ApplicationPathProvider {

+ public:

+ ApplicationPathProvider(const std::string& applicationName);

+ virtual ~ApplicationPathProvider();

+ virtual boost::filesystem::path getHomeDir() const = 0;

+ virtual boost::filesystem::path getDataDir() const = 0;

+ boost::filesystem::path getExecutableDir() const;

+ boost::filesystem::path getProfileDir(const std::string& profile) const;

+ boost::filesystem::path getResourcePath(const std::string& resource) const;

+ protected:

+ virtual std::vector<boost::filesystem::path> getResourceDirs() const = 0;

+ const std::string& getApplicationName() const {

+ return applicationName;

+ }

+ private:

+ std::string applicationName;

+ };

+ class CocoaApplication {

+ public:

+ CocoaApplication();

+ ~CocoaApplication();

+ private:

+ class Private;

+ Private* d;

+ };

+ public:

+ NSAutoreleasePool* autoReleasePool_;

+ d = new CocoaApplication::Private();

+ NSApplicationLoad();

+ d->autoReleasePool_ = [[NSAutoreleasePool alloc] init];

+ [d->autoReleasePool_ release];

+ delete d;

+ resourceDirs.push_back(getExecutableDir() / "../Resources");

+ resourceDirs.push_back(getExecutableDir() / "../resources"); // Development

+ boost::filesystem::path result(getHomeDir() / "Library/Application Support" / getApplicationName());

+ try {

+ boost::filesystem::create_directory(result);

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+ return result;

+ return boost::filesystem::path(getenv("HOME"));

+ class MacOSXApplicationPathProvider : public ApplicationPathProvider {

+ public:

+ MacOSXApplicationPathProvider(const std::string& name);

+ virtual boost::filesystem::path getHomeDir() const;

+ boost::filesystem::path getDataDir() const;

+ virtual std::vector<boost::filesystem::path> getResourceDirs() const {

+ return resourceDirs;

+ }

+ private:

+ std::vector<boost::filesystem::path> resourceDirs;

+ };

+ typedef MacOSXApplicationPathProvider PlatformApplicationPathProvider;

+ typedef WindowsApplicationPathProvider PlatformApplicationPathProvider;

+ typedef UnixApplicationPathProvider PlatformApplicationPathProvider;

+ CPPUNIT_TEST_SUITE(ApplicationPathProviderTest);

+ CPPUNIT_TEST(testGetDataDir);

+ CPPUNIT_TEST(testGetExecutableDir);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ testling_ = new PlatformApplicationPathProvider("SwiftTest");

+ }

+

+ void tearDown() {

+ delete testling_;

+ }

+

+ void testGetDataDir() {

+ boost::filesystem::path dir = testling_->getDataDir();

+

+ CPPUNIT_ASSERT(boost::filesystem::exists(dir));

+ CPPUNIT_ASSERT(boost::filesystem::is_directory(dir));

+

+ boost::filesystem::remove(dir);

+ }

+

+ void testGetExecutableDir() {

+ boost::filesystem::path dir = testling_->getExecutableDir();

+ CPPUNIT_ASSERT(boost::filesystem::is_directory(dir));

+ CPPUNIT_ASSERT(boost::ends_with(pathToString(dir), "UnitTest"));

+ }

+

+ private:

+ ApplicationPathProvider* testling_;

+ resourceDirs.push_back(getExecutableDir() / "../resources"); // Development

+ resourceDirs.push_back(getExecutableDir() / ".." / "share" / boost::to_lower_copy(getApplicationName())); // Local install

+ char* xdgDataDirs = getenv("XDG_DATA_DIRS");

+ if (xdgDataDirs) {

+ std::vector<std::string> dataDirs = String::split(xdgDataDirs, ':');

+ if (!dataDirs.empty()) {

+ foreach(const std::string& dir, dataDirs) {

+ resourceDirs.push_back(boost::filesystem::path(dir) / "swift");

+ }

+ return;

+ }

+ }

+ resourceDirs.push_back("/usr/local/share/" + boost::to_lower_copy(getApplicationName()));

+ resourceDirs.push_back("/usr/share/" + boost::to_lower_copy(getApplicationName()));

+ char* home = getenv("HOME");

+ return home ? boost::filesystem::path(home) : boost::filesystem::path();

+ char* xdgDataHome = getenv("XDG_DATA_HOME");

+ std::string dataDir;

+ if (xdgDataHome) {

+ dataDir = std::string(xdgDataHome);

+ }

+ boost::filesystem::path dataPath = (dataDir.empty() ?

+ getHomeDir() / ".local" / "share"

+ : boost::filesystem::path(dataDir)) / boost::to_lower_copy(getApplicationName());

+ try {

+ boost::filesystem::create_directories(dataPath);

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+ return dataPath;

+ class UnixApplicationPathProvider : public ApplicationPathProvider {

+ public:

+ UnixApplicationPathProvider(const std::string& name);

+ virtual boost::filesystem::path getHomeDir() const;

+ boost::filesystem::path getDataDir() const;

+ virtual std::vector<boost::filesystem::path> getResourceDirs() const {

+ return resourceDirs;

+ }

+ private:

+ std::vector<boost::filesystem::path> resourceDirs;

+ };

+ resourceDirs.push_back(getExecutableDir());

+ resourceDirs.push_back(getExecutableDir() / "../resources"); // Development

+ wchar_t* appDirRaw = _wgetenv(L"APPDATA");

+ assert(appDirRaw);

+ boost::filesystem::path result(

+ boost::filesystem::path(appDirRaw) / getApplicationName());

+ boost::filesystem::create_directory(result);

+ return result;

+ //FIXME: This should be My Documents

+ wchar_t* homeDirRaw = _wgetenv(L"USERPROFILE");

+ assert(homeDirRaw);

+ return boost::filesystem::path(homeDirRaw);

+ class WindowsApplicationPathProvider : public ApplicationPathProvider {

+ public:

+ WindowsApplicationPathProvider(const std::string& name);

+ boost::filesystem::path getDataDir() const;

+ boost::filesystem::path getHomeDir() const;

+ virtual std::vector<boost::filesystem::path> getResourceDirs() const {

+ return resourceDirs;

+ }

+ private:

+ std::vector<boost::filesystem::path> resourceDirs;

+ };

+ class AutoUpdater {

+ public:

+ virtual ~AutoUpdater();

+ virtual void checkForUpdates() = 0;

+ };

+ return true;

+ return false;

+ return new SparkleAutoUpdater(appcastURL);

+ (void) appcastURL;

+ return NULL;

+ class AutoUpdater;

+ class PlatformAutoUpdaterFactory {

+ public:

+ bool isSupported() const;

+ AutoUpdater* createAutoUpdater(const std::string& appcastURL);

+ };

+ class SparkleAutoUpdater : public AutoUpdater {

+ public:

+ SparkleAutoUpdater(const std::string& url);

+ ~SparkleAutoUpdater();

+ void checkForUpdates();

+

+ private:

+ class Private;

+ Private* d;

+ };

+ public:

+ SUUpdater* updater;

+ d = new Private;

+ d->updater = [SUUpdater sharedUpdater];

+ [d->updater retain];

+ [d->updater setAutomaticallyChecksForUpdates: true];

+ NSURL* nsurl = [NSURL URLWithString:

+ [NSString stringWithUTF8String: url.c_str()]];

+ [d->updater setFeedURL: nsurl];

+ [d->updater release];

+ delete d;

+ [d->updater checkForUpdatesInBackground];

+ boost::function<void ()>* function;

+ if ((self = [super init])) {

+ function = f;

+ }

+ return self;

+ delete function;

+ [super dealloc];

+ (void) sender;

+ (*function)();

+ std::string stdString;

+ if (nsString != nil) {

+ stdString = std::string([nsString cStringUsingEncoding:NSUTF8StringEncoding]);

+ }

+ return stdString;

+ NSString* _Nullable nsString = [NSString stringWithUTF8String:stdString.c_str()];

+ if (nsString == nil) {

+ nsString = @"";

+ }

+ // At this point nsString is guaranteed to be not null/nil.

+ return static_cast<NSString* _Nonnull>(nsString);

+namespace boost {

+ inline void intrusive_ptr_add_ref(NSObject* _Nonnull object) {

+ [object retain];

+ }

+

+ inline void intrusive_ptr_release(NSObject* _Nonnull object) {

+ [object release];

+ }

+// Including intrusive_ptr after ref/release methods to avoid compilation

+ return false;

+ return false;

+ boost::shared_ptr<google_breakpad::ExceptionHandler> handler;

+ // Create the path that will contain the crash dumps

+ if (!boost::filesystem::exists(path)) {

+ try {

+ boost::filesystem::create_directories(path);

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ SWIFT_LOG(error) << "ERROR: " << e.what() << std::endl;

+ }

+ }

+ p = boost::make_shared<Private>();

+ // FIXME: Need UTF8 conversion from string to wstring

+ std::string pathString = pathToString(path);

+ p->handler = boost::shared_ptr<google_breakpad::ExceptionHandler>(

+ // Not using make_shared, because 'handleDump' seems to have problems with VC2010

+ new google_breakpad::ExceptionHandler(

+ std::wstring(pathString.begin(), pathString.end()),

+ (google_breakpad::ExceptionHandler::FilterCallback) 0,

+ handleDump,

+ (void*) 0,

+ google_breakpad::ExceptionHandler::HANDLER_ALL));

+// p->handler = boost::make_shared<google_breakpad::ExceptionHandler>(pathToString(path), (google_breakpad::ExceptionHandler::FilterCallback) 0, handleDump, (void*) 0, true, (const char*) 0);

+ CrashReporter::CrashReporter(const boost::filesystem::path&) {}

+ class CrashReporter {

+ public:

+ CrashReporter(const boost::filesystem::path& path);

+ private:

+ struct Private;

+ boost::shared_ptr<Private> p;

+ };

+ class Dock {

+ public:

+ virtual ~Dock();

+

+ virtual void setNumberOfPendingMessages(int i) = 0;

+ };

+ class CocoaApplication;

+ class MacOSXDock : public Dock {

+ public:

+ MacOSXDock(CocoaApplication* application);

+

+ virtual void setNumberOfPendingMessages(int i);

+ };

+ std::string label(i > 0 ? boost::lexical_cast<std::string>(i) : "");

+ NSString *labelString = [[NSString alloc] initWithUTF8String: label.c_str()];

+ [[NSApp dockTile] setBadgeLabel: labelString];

+ [labelString release];

+ [NSApp requestUserAttention: NSInformationalRequest];

+ class NullDock : public Dock {

+ public:

+ NullDock() {}

+ virtual void setNumberOfPendingMessages(int) {

+ }

+ };

+ class WindowsDock : public Dock {

+ public:

+ WindowsDock(QSystemTrayIcon* tray, Notifier* notifier) : tray(tray), notifier(notifier) {}

+

+ virtual void setNumberOfPendingMessages(int i) {

+ if (notifier->isAvailable()) {

+ return;

+ }

+

+ if (i > 0) {

+ std::string message = boost::lexical_cast<std::string>(i) + " new message";

+ if (i > 1) {

+ message += "s";

+ }

+ message += " received.";

+ tray->showMessage("New messages", message.c_str(), QSystemTrayIcon::NoIcon);

+ }

+ else {

+ tray->showMessage("", "", QSystemTrayIcon::NoIcon, 0);

+ }

+ }

+

+ private:

+ QSystemTrayIcon* tray;

+ Notifier* notifier;

+ };

+ speller_ = new Hunspell(affix_path, dictionary_path);

+ delete speller_;

+ return speller_->spell(word.c_str());

+ char **suggestList = NULL;

+ int words_returned = 0;

+ if (!word.empty()) {

+ words_returned = speller_->suggest(&suggestList, word.c_str());

+ if (suggestList != NULL) {

+ for (int i = 0; i < words_returned; ++i) {

+ list.push_back(suggestList[i]);

+ free(suggestList[i]);

+ }

+ free(suggestList);

+ }

+ }

+ if (!fragment.empty()) {

+ parser_->check(fragment, misspelledPositions);

+ for (PositionPairList::iterator it = misspelledPositions.begin(); it != misspelledPositions.end();) {

+ if (isCorrect(fragment.substr(boost::get<0>(*it), boost::get<1>(*it) - boost::get<0>(*it)))) {

+ it = misspelledPositions.erase(it);

+ }

+ else {

+ ++it;

+ }

+ }

+ }

+ class HunspellChecker : public SpellChecker {

+ public:

+ HunspellChecker(const char* affix_path, const char* dict_path);

+ virtual ~HunspellChecker();

+ virtual bool isCorrect(const std::string& word);

+ virtual void getSuggestions(const std::string& word, std::vector<std::string>& list);

+ virtual void checkFragment(const std::string& fragment, PositionPairList& misspelledPositions);

+ private:

+ Hunspell* speller_;

+ };

+ timer = timerFactory->createTimer(refreshRateMilliseconds);

+ timer->onTick.connect(boost::bind(&ActualIdleDetector::handleTimerTick, this));

+ timer->start();

+ timer->onTick.disconnect(boost::bind(&ActualIdleDetector::handleTimerTick, this));

+ timer->stop();

+ timer->stop();

+ setIdle(querier->getIdleTimeSeconds() >= getIdleTimeSeconds());

+ timer->start();

+ class IdleQuerier;

+ class TimerFactory;

+ class Timer;

+ class ActualIdleDetector : public IdleDetector, public boost::bsignals::trackable {

+ public:

+ ActualIdleDetector(IdleQuerier*, TimerFactory*, int refreshRateMilliseconds);

+ ~ActualIdleDetector();

+ private:

+ void handleTimerTick();

+ private:

+ IdleQuerier* querier;

+ boost::shared_ptr<Timer> timer;

+ };

+ class DummyIdleQuerier : public IdleQuerier {

+ public:

+ DummyIdleQuerier() {}

+ virtual int getIdleTimeSeconds() {

+ return 0;

+ }

+ };

+ class IdleDetector {

+ public:

+ IdleDetector() : idle(false), idleTimeSeconds(300) {}

+ virtual ~IdleDetector();

+

+ void setIdleTimeSeconds(int time) {

+ idleTimeSeconds = time;

+ }

+

+ int getIdleTimeSeconds() const {

+ return idleTimeSeconds;

+ }

+

+ virtual bool isIdle() const {

+ return idle;

+ }

+

+ boost::signal<void (bool /* isIdle */)> onIdleChanged;

+

+ void setIdle(bool b) {

+ if (b != idle) {

+ idle = b;

+ onIdleChanged(b);

+ }

+ }

+

+ private:

+ bool idle;

+ int idleTimeSeconds;

+ };

+ class IdleQuerier {

+ public:

+ virtual ~IdleQuerier();

+ virtual int getIdleTimeSeconds() = 0;

+ };

+ PlatformIdleQuerier querier;

+ while (true) {

+ std::cout << "Idle time: " << querier.getIdleTimeSeconds() << std::endl;

+ Swift::sleep(1000);

+ }

+ assert(false);

+ return 0;

+ mach_port_t masterPort;

+ IOMasterPort(MACH_PORT_NULL, &masterPort);

+ ioService = IOServiceGetMatchingService(masterPort, IOServiceMatching("IOHIDSystem"));

+ assert(ioService);

+ CFTypeRef property = IORegistryEntryCreateCFProperty(ioService, CFSTR("HIDIdleTime"), kCFAllocatorDefault, 0);

+ uint64_t idle = 0;

+ bool result = CFNumberGetValue((CFNumberRef)property, kCFNumberSInt64Type, &idle);

+ assert(result);

+ (void) result;

+ CFRelease(property);

+ return boost::numeric_cast<int>(idle / 1000000000);

+ class MacOSXIdleQuerier : public IdleQuerier {

+ public:

+ MacOSXIdleQuerier();

+ virtual int getIdleTimeSeconds();

+ private:

+ io_service_t ioService;

+ };

+ querier = new MacOSXIdleQuerier();

+ querier = new DummyIdleQuerier();

+ querier = new WindowsIdleQuerier();

+ querier = new XSSIdleQuerier();

+ querier = new DummyIdleQuerier();

+ delete querier;

+ class PlatformIdleQuerier : public IdleQuerier {

+ public:

+ PlatformIdleQuerier();

+ ~PlatformIdleQuerier();

+ virtual int getIdleTimeSeconds() {

+ return querier->getIdleTimeSeconds();

+ }

+ private:

+ IdleQuerier* querier;

+ };

+ CPPUNIT_TEST_SUITE(ActualIdleDetectorTest);

+ CPPUNIT_TEST(testDestructor);

+ CPPUNIT_TEST(testHandleTick_Idle);

+ CPPUNIT_TEST(testHandleTick_Idle_AlreadyIdle);

+ CPPUNIT_TEST(testHandleTick_NotIdle);

+ CPPUNIT_TEST(testHandleTick_NotIdle_AlreadyNotIdle);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ querier = new MockIdleQuerier();

+ timerFactory = new MockTimerFactory();

+ idleEvents.clear();

+ }

+

+ void tearDown() {

+ delete timerFactory;

+ delete querier;

+ }

+

+ void testDestructor() {

+ ActualIdleDetector* testling = createDetector();

+ testling->setIdleTimeSeconds(15);

+ delete testling;

+

+ querier->idleTime = 15;

+ timerFactory->updateTime(15000);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(idleEvents.size()));

+ }

+

+ void testHandleTick_Idle() {

+ std::auto_ptr<ActualIdleDetector> testling(createDetector());

+ testling->setIdleTimeSeconds(15);

+ querier->idleTime = 15;

+

+ timerFactory->updateTime(15000);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(idleEvents.size()));

+ CPPUNIT_ASSERT(idleEvents[0]);

+ }

+

+ void testHandleTick_Idle_AlreadyIdle() {

+ std::auto_ptr<ActualIdleDetector> testling(createDetector());

+ testling->setIdleTimeSeconds(15);

+ querier->idleTime = 15;

+ timerFactory->updateTime(15000);

+

+ querier->idleTime = 30;

+ timerFactory->updateTime(30000);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(idleEvents.size()));

+ CPPUNIT_ASSERT(idleEvents[0]);

+ }

+

+ void testHandleTick_NotIdle() {

+ std::auto_ptr<ActualIdleDetector> testling(createDetector());

+ testling->setIdleTimeSeconds(15);

+ querier->idleTime = 15;

+ timerFactory->updateTime(15000);

+

+ querier->idleTime = 5;

+ timerFactory->updateTime(30000);

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(idleEvents.size()));

+ CPPUNIT_ASSERT(idleEvents[0]);

+ CPPUNIT_ASSERT(!idleEvents[1]);

+ }

+

+ void testHandleTick_NotIdle_AlreadyNotIdle() {

+ std::auto_ptr<ActualIdleDetector> testling(createDetector());

+ testling->setIdleTimeSeconds(15);

+ querier->idleTime = 5;

+

+ timerFactory->updateTime(15000);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(idleEvents.size()));

+ }

+

+ private:

+ ActualIdleDetector* createDetector() {

+ ActualIdleDetector* detector = new ActualIdleDetector(querier, timerFactory, 10);

+ detector->onIdleChanged.connect(boost::bind(&ActualIdleDetectorTest::handleIdle, this, _1));

+ return detector;

+ }

+

+ void handleIdle(bool b) {

+ idleEvents.push_back(b);

+ }

+

+ private:

+ struct MockIdleQuerier : public IdleQuerier {

+ MockIdleQuerier() : idleTime(0) {}

+ virtual int getIdleTimeSeconds() { return idleTime; }

+ int idleTime;

+ };

+

+ struct MockTimer : public Timer {

+ MockTimer(int interval) : interval(interval), running(false), lastTime(0) {}

+

+ virtual void start() {

+ running = true;

+ }

+

+ virtual void stop() {

+ running = false;

+ }

+

+ virtual void updateTime(int currentTime) {

+ if (lastTime == currentTime) {

+ return;

+ }

+ if (running) {

+ int time = lastTime;

+ while (time <= currentTime) {

+ onTick();

+ time += interval;

+ }

+ }

+ lastTime = currentTime;

+ }

+

+ int interval;

+ bool running;

+ int lastTime;

+ };

+

+ struct MockTimerFactory : public TimerFactory {

+ MockTimerFactory() {}

+

+ void updateTime(int milliseconds) {

+ foreach(boost::shared_ptr<MockTimer> timer, timers) {

+ timer->updateTime(milliseconds);

+ }

+ }

+

+ boost::shared_ptr<Timer> createTimer(int milliseconds) {

+ boost::shared_ptr<MockTimer> timer(new MockTimer(milliseconds));

+ timers.push_back(timer);

+ return timer;

+ }

+

+ std::vector<boost::shared_ptr<MockTimer> > timers;

+ };

+

+ MockIdleQuerier* querier;

+ MockTimerFactory* timerFactory;

+ std::vector<bool> idleEvents;

+ LASTINPUTINFO info;

+ info.cbSize = sizeof(info);

+ if (GetLastInputInfo(&info)) {

+ return (GetTickCount() - info.dwTime) / 1000;

+ }

+ else {

+ return 0;

+ }

+ class WindowsIdleQuerier : public IdleQuerier {

+ public:

+ WindowsIdleQuerier();

+ virtual int getIdleTimeSeconds();

+ };

+ display = XOpenDisplay(NULL);

+ assert(display);

+ rootWindow = DefaultRootWindow(display);

+ int event, error;

+ available = XScreenSaverQueryExtension(display, &event, &error);

+ if (available) {

+ info = XScreenSaverAllocInfo();

+ }

+ else {

+ std::cerr << "Warning: XScreenSaver extension not found. Idle time detection will not work." << std::endl;

+ }

+ XFree(info);

+ if (available) {

+ XScreenSaverQueryInfo(display, rootWindow, info);

+ return info->idle / 1000;

+ }

+ else {

+ return 0;

+ }

+ class XSSIdleQuerier : public IdleQuerier {

+ public:

+ XSSIdleQuerier();

+ ~XSSIdleQuerier();

+ virtual int getIdleTimeSeconds();

+ private:

+ Display* display;

+ Window rootWindow;

+ bool available;

+ XScreenSaverInfo* info;

+ };

+ lastFocus = true;

+ shouldMove = false;

+ if (!focus && lastFocus) {

+ shouldMove = true;

+ lastFocus = focus;

+ return;

+ }

+ shouldMove = false;

+ lastFocus = focus;

+ bool ret = shouldMove;

+ shouldMove = false;

+ return ret;

+ class LastLineTracker {

+ public:

+ LastLineTracker();

+ void setHasFocus(bool focus);

+ bool getShouldMoveLastLine();

+ private:

+ bool lastFocus;

+ bool shouldMove;

+ };

+ std::ostringstream result;

+ std::vector<char> currentURL;

+ bool inURL = false;

+ for (size_t i = 0; i < input.size(); ++i) {

+ char c = input[i];

+ if (inURL) {

+ if (c != ' ' && c != '\t' && c != '\n' && !(c == '*' && i == input.size() - 1 && input[0] == '*')) {

+ currentURL.push_back(c);

+ }

+ else {

+ std::string url(&currentURL[0], currentURL.size());

+ result << "<a href=\"" << url << "\">" << url << "</a>";

+ currentURL.clear();

+ inURL = false;

+ result << c;

+ }

+ }

+ else {

+ if (boost::regex_match(input.substr(i, 8), linkifyRegexp)) {

+ currentURL.push_back(c);

+ inURL = true;

+ }

+ else {

+ result << c;

+ }

+ }

+ }

+ if (!currentURL.empty()) {

+ std::string url(&currentURL[0], currentURL.size());

+ result << "<a href=\"" << url << "\">" << url << "</a>";

+ }

+ return std::string(result.str());

+ std::vector<std::string> result;

+ std::pair<std::vector<std::string>, size_t> pair;

+ std::vector<char> currentURL;

+ bool inURL = false;

+ size_t urlStartsAt = 0;

+ for (size_t i = 0; i < input.size(); ++i) {

+ char c = input[i];

+ if (inURL) {

+ if (c != ' ' && c != '\t' && c != '\n' && !(c == '*' && i == input.size() - 1 && input[0] == '*')) {

+ // Keep parsing

+ }

+ else {

+ std::string url(input.substr(urlStartsAt, i - urlStartsAt));

+ result.push_back(url);

+ inURL = false;

+ size_t remaining = input.size() - i;

+ if (remaining > 0) {

+ result.push_back(input.substr(i, remaining));

+ }

+ pair.first = result;

+ pair.second = urlStartsAt == 0 ? 0 : 1;

+ return pair;

+ }

+ }

+ else {

+ if (boost::regex_match(input.substr(i, 8), linkifyRegexp)) {

+ urlStartsAt = i;

+ inURL = true;

+ if (i > 0) {

+ result.push_back(input.substr(0, i));

+ }

+ }

+ else {

+ // Just keep swimming

+ }

+ }

+ }

+ if (urlStartsAt > 0 || inURL) {

+ std::string url(input.substr(urlStartsAt, input.size() - urlStartsAt));

+ result.push_back(url);

+ pair.first = result;

+ pair.second = urlStartsAt == 0 ? 0 : 1;

+ }

+ else {

+ pair.first.push_back(input);

+ pair.second = 1;

+ }

+ return pair;

+ namespace Linkify {

+ std::string linkify(const std::string&);

+ /**

+ * Parse the string for a URI. The string will be split by the URI, and the segments plus index of the URI returned.

+ * If no URI is found the index will be result.size() (i.e. an invalid index)

+ *

+ * Examples:

+ * "not a URI" -> <<"not a URI">, -1>

+ * "http://swift.im" -> <<"http://swift.im">, 0

+ * " See http://swift.im" -> <<" See ", "http://swift.im">, 1>

+ * "Right, http://swift.im it is" -> <<"Right, ", "http://swift.im", " it is">, 1>

+ */

+ std::pair<std::vector<std::string>, size_t> splitLink(const std::string& text);

+ }

+ class MacOSXChecker : public SpellChecker {

+ public:

+ MacOSXChecker();

+ virtual ~MacOSXChecker();

+ virtual bool isCorrect(const std::string& word);

+ virtual void getSuggestions(const std::string& word, std::vector<std::string>& list);

+ virtual void checkFragment(const std::string& fragment, PositionPairList& misspelledPositions);

+ };

+ NSSpellChecker* spellChecker = [NSSpellChecker sharedSpellChecker];

+ [spellChecker setAutomaticallyIdentifiesLanguages:YES];

+ // No content since it doesn't seem to be used anywhere.

+ return false;

+ NSSpellChecker* spellChecker = [NSSpellChecker sharedSpellChecker];

+ NSString* wordString = [[NSString alloc] initWithUTF8String: word.c_str()];

+ NSArray* suggestions = [spellChecker guessesForWordRange:NSMakeRange(0, [wordString length]) inString:wordString language:nil inSpellDocumentWithTag:0];

+ for(unsigned int i = 0; i < [suggestions count]; ++i) {

+ list.push_back(std::string([[suggestions objectAtIndex:i] UTF8String]));

+ }

+ [wordString release];

+ NSSpellChecker* spellChecker = [NSSpellChecker sharedSpellChecker];

+ size_t nextLocation = 0;

+ NSRange range;

+ NSString *fragmentString = [[NSString alloc] initWithUTF8String: fragment.c_str()];

+ do {

+ range = [spellChecker checkSpellingOfString:fragmentString startingAt:static_cast<long>(nextLocation)];

+ if (range.location != NSNotFound) {

+ if (range.location < nextLocation)

+ break;

+ misspelledPositions.push_back(PositionPair(static_cast<int>(range.location), static_cast<int>(range.location + range.length)));

+ nextLocation = range.location + range.length + 1;

+ }

+ } while (range.location != NSNotFound);

+ [fragmentString release];

+ // Registration message

+ std::ostringstream message;

+ message << "GNTP/1.0 REGISTER NONE\r\n";

+ message << "Application-Name: " << name << "\r\n";

+ message << "Application-Icon: file://" << pathToString(icon) << "\r\n";

+ message << "Notifications-Count: " << getAllTypes().size() << "\r\n";

+ std::vector<Notifier::Type> defaultTypes = getDefaultTypes();

+ std::vector<Notifier::Type> allTypes = getAllTypes();

+ foreach(Notifier::Type type, allTypes) {

+ message << "\r\n";

+ message << "Notification-Name: " << typeToString(type) << "\r\n";

+ message << "Notification-Enabled: " << (std::find(defaultTypes.begin(), defaultTypes.end(), type) == defaultTypes.end() ? "false" : "true") << "\r\n";

+ }

+ message << "\r\n";

+ send(message.str());

+ if (currentConnection) {

+ return;

+ }

+ currentMessage = message;

+ currentConnection = connectionFactory->createConnection();

+ currentConnection->onConnectFinished.connect(boost::bind(&GNTPNotifier::handleConnectFinished, this, _1));

+ currentConnection->onDataRead.connect(boost::bind(&GNTPNotifier::handleDataRead, this, _1));

+ currentConnection->connect(HostAddressPort(HostAddress("127.0.0.1"), 23053));

+ if (registered) {

+ std::ostringstream message;

+ message << "GNTP/1.0 NOTIFY NONE\r\n";

+ message << "Application-Name: " << name << "\r\n";

+ message << "Notification-Name: " << typeToString(type) << "\r\n";

+ message << "Notification-Title: " << subject << "\r\n";

+ message << "Notification-Text: " << description << "\r\n";

+ message << "Notification-Icon: " << pathToString(picture) << "\r\n";

+ message << "\r\n";

+ send(message.str());

+ }

+ if (!initialized) {

+ initialized = true;

+ registered = !error;

+ }

+ if (!error) {

+ currentConnection->write(currentMessage.c_str());

+ }

+ currentConnection->onDataRead.disconnect(boost::bind(&GNTPNotifier::handleDataRead, this, _1));

+ currentConnection->onConnectFinished.disconnect(boost::bind(&GNTPNotifier::handleConnectFinished, this, _1));

+ currentConnection.reset();

+ class ConnectionFactory;

+

+ class GNTPNotifier : public Notifier {

+ public:

+ GNTPNotifier(const std::string& name, const boost::filesystem::path& icon, ConnectionFactory* connectionFactory);

+ ~GNTPNotifier();

+

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

+

+ private:

+ void handleConnectFinished(bool error);

+ void handleDataRead(const ByteArray& data);

+ void send(const std::string& message);

+

+ private:

+ std::string name;

+ boost::filesystem::path icon;

+ ConnectionFactory* connectionFactory;

+ bool initialized;

+ bool registered;

+ std::string currentMessage;

+ Connection::ref currentConnection;

+ };

+ /**

+ * Preconditions for using growlnotifier:

+ * - Must be part a bundle.

+ * - The Carbon/Cocoa application loop must be running (e.g. through QApplication)

+ * such that notifications are coming through.

+ */

+ class GrowlNotifier : public Notifier {

+ public:

+ GrowlNotifier(const std::string& name);

+ ~GrowlNotifier();

+

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

+ virtual bool isExternallyConfigured() const;

+

+ // Called by the delegate. Don't call.

+ void handleNotificationClicked(void* data);

+ void handleNotificationTimedOut(void* data);

+

+ virtual void purgeCallbacks();

+

+ private:

+ void clearPendingNotifications();

+

+ private:

+ class Private;

+ boost::shared_ptr<Private> p;

+ };

+ struct Context {

+ Context(const boost::function<void()>& callback) : callback(new boost::function<void()>(callback)) {}

+ boost::function<void()>* callback;

+ };

+ public:

+ std::set<Context*> pendingNotifications;

+ boost::intrusive_ptr<GrowlNotifierDelegate> delegate;

+ p = boost::make_shared<Private>();

+ p->delegate = boost::intrusive_ptr<GrowlNotifierDelegate>([[GrowlNotifierDelegate alloc] init], false);

+ p->delegate.get().notifier = this;

+ p->delegate.get().name = std2NSString(name);

+

+ NSMutableArray* allNotifications = [[NSMutableArray alloc] init];

+ foreach(Type type, getAllTypes()) {

+ [allNotifications addObject: std2NSString(typeToString(type))];

+ }

+

+ NSMutableArray* defaultNotifications = [[NSMutableArray alloc] init];

+ foreach(Type type, getDefaultTypes()) {

+ [defaultNotifications addObject: std2NSString(typeToString(type))];

+ }

+

+ p->delegate.get().registrationDictionary = [[[NSDictionary alloc]

+ initWithObjects: [NSArray arrayWithObjects: allNotifications, defaultNotifications, nil]

+ forKeys: [NSArray arrayWithObjects: GROWL_NOTIFICATIONS_ALL, GROWL_NOTIFICATIONS_DEFAULT, nil]] autorelease];

+

+ [allNotifications release];

+ [defaultNotifications release];

+

+ [GrowlApplicationBridge setGrowlDelegate: p->delegate.get()];

+ [GrowlApplicationBridge setGrowlDelegate: nil];

+ clearPendingNotifications();

+ ByteArray picture;

+ readByteArrayFromFile(picture, picturePath);

+

+ Context* context = new Context(callback);

+ // Growl sometimes sends timeout notifications twice for the same message. We therefore need

+ // to keep track of which ones have already been processed.

+ p->pendingNotifications.insert(context);

+

+ [GrowlApplicationBridge

+ notifyWithTitle: std2NSString(subject)

+ description: std2NSString(description)

+ notificationName: std2NSString(typeToString(type))

+ iconData: [NSData dataWithBytes: vecptr(picture) length: picture.size()]

+ priority: 0

+ isSticky: NO

+ clickContext: [NSData dataWithBytes: &context length: sizeof(context)]];

+ Context* context = *(Context**) [((NSData*) rawData) bytes];

+ if (p->pendingNotifications.erase(context) > 0) {

+ if (!context->callback->empty()) {

+ (*context->callback)();

+ }

+ delete context;

+ }

+ Context* context = *(Context**) [((NSData*) rawData) bytes];

+ if (p->pendingNotifications.erase(context) > 0) {

+ delete context;

+ }

+ return ![GrowlApplicationBridge isMistEnabled];

+ clearPendingNotifications();

+ foreach (Context* context, p->pendingNotifications) {

+ delete context;

+ }

+ p->pendingNotifications.clear();

+ class GrowlNotifier;

+ Swift::GrowlNotifier* notifier;

+ NSString* name;

+ NSDictionary* registrationDictionary;

+ return name;

+ return registrationDictionary;

+ notifier->handleNotificationClicked(clickContext);

+ notifier->handleNotificationTimedOut(clickContext);

+ class LoggingNotifier : public Notifier {

+ public:

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback) {

+ notifications.push_back(Notification(type, subject, description, picture, callback));

+ }

+ struct Notification {

+ Notification(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback) : type(type), subject(subject), description(description), picture(picture), callback(callback) {}

+ Type type;

+ std::string subject;

+ std::string description;

+ boost::filesystem::path picture;

+ boost::function<void()> callback;

+ };

+ virtual void purgeCallbacks() {}

+ std::vector<Notification> notifications;

+ };

+ NotificationCenterNotifier();

+ virtual ~NotificationCenterNotifier();

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void ()> callback);

+ virtual void purgeCallbacks();

+ /**

+ * @brief The handleUserNotificationActivated is called by the delegate, when a user activates/clicks on a notification.

+ * @param identifier The std::string UUID identifiying the notification.

+ */

+ void handleUserNotificationActivated(const std::string& identifier);

+ class Private;

+ boost::shared_ptr<Private> p;

+ struct Context {

+ Context(const boost::function<void()>& callback) : callback(new boost::function<void()>(callback)) {

+ }

+ ~Context() {

+ delete callback;

+ }

+ boost::function<void()>* callback;

+ };

+ public:

+ std::map<std::string, boost::shared_ptr<Context> > callbacksForNotifications;

+ boost::intrusive_ptr<NotificationCenterNotifierDelegate> delegate;

+ p = boost::make_shared<Private>();

+ p->delegate = boost::intrusive_ptr<NotificationCenterNotifierDelegate>([[NotificationCenterNotifierDelegate alloc] init], false);

+ [p->delegate.get() setNotifier: this];

+ [[NSUserNotificationCenter defaultUserNotificationCenter] setDelegate: p->delegate.get()];

+ [[NSUserNotificationCenter defaultUserNotificationCenter] setDelegate: nil];

+ p->callbacksForNotifications.clear();

+ std::vector<Notifier::Type> defaultTypes = getDefaultTypes();

+ if (std::find(defaultTypes.begin(), defaultTypes.end(), type) == defaultTypes.end()) {

+ return;

+ }

+ NSImage* image = [[NSImage alloc] initWithContentsOfFile: std2NSString(picture.string())];

+ NSUserNotification* notification = [[NSUserNotification alloc] init];

+ [notification setTitle:std2NSString(typeToString(type))];

+ [notification setSubtitle:std2NSString(subject)];

+ [notification setInformativeText:std2NSString(description)];

+ [notification setContentImage: image];

+ [image release];

+

+ // The OS X Notification Center API does not allow to attach custom data, like a pointer to a callback function,

+ // to the NSUserNotification object. Therefore we maintain a mapping from a NSUserNotification instance's identification

+ // to their respective callbacks.

+ [notification setIdentifier:[[NSUUID UUID] UUIDString]];

+

+ /// \todo Currently the elements are only removed on application exit. Ideally the notifications not required anymore

+ /// are removed from the map; e.g. when visiting a chat view, all notifications from that view can be removed from

+ /// the map and the NSUserNotificationCenter.

+ p->callbacksForNotifications[ns2StdString(notification.identifier)] = boost::make_shared<Context>(callback);

+ [[NSUserNotificationCenter defaultUserNotificationCenter] deliverNotification:notification];

+ [notification release];

+ p->callbacksForNotifications.clear();

+ if (p->callbacksForNotifications.find(identifier) != p->callbacksForNotifications.end()) {

+ if (!(*p->callbacksForNotifications[identifier]->callback).empty()) {

+ (*p->callbacksForNotifications[identifier]->callback)();

+ }

+ }

+ else {

+ SWIFT_LOG(warning) << "Missing callback entry for activated notification. The activate notification may come from another instance." << std::endl;

+ }

+ class NotificationCenterNotifier;

+ (void)center;

+ std::string identifier = ns2StdString(notification.identifier);

+ notifier->handleUserNotificationActivated(identifier);

+ switch (type) {

+ case ContactAvailable: return "Contact Becomes Available";

+ case ContactUnavailable: return "Contact Becomes Unavailable";

+ case ContactStatusChange: return "Contact Changes Status";

+ case IncomingMessage: return "Incoming Message";

+ case SystemMessage: return "System Message";

+ }

+ assert(false);

+ return "";

+ std::vector<Type> result;

+ result.push_back(ContactAvailable);

+ result.push_back(ContactUnavailable);

+ result.push_back(ContactStatusChange);

+ result.push_back(IncomingMessage);

+ result.push_back(SystemMessage);

+ return result;

+ std::vector<Type> result;

+ result.push_back(IncomingMessage);

+ result.push_back(SystemMessage);

+ return result;

+ class Notifier {

+ public:

+ virtual ~Notifier();

+

+ enum Type { ContactAvailable, ContactUnavailable, ContactStatusChange, IncomingMessage, SystemMessage };

+

+ /**

+ * Picture is a PNG image.

+ */

+ virtual void showMessage(

+ Type type,

+ const std::string& subject,

+ const std::string& description,

+ const boost::filesystem::path& picture,

+ boost::function<void()> callback) = 0;

+

+ virtual bool isAvailable() const {

+ return true;

+ }

+

+ virtual bool isExternallyConfigured() const {

+ return false;

+ }

+

+ /** Remove any pending callbacks. */

+ virtual void purgeCallbacks() = 0;

+

+ protected:

+ std::string typeToString(Type type);

+ static std::vector<Type> getAllTypes();

+ static std::vector<Type> getDefaultTypes();

+

+ static const int DEFAULT_STATUS_NOTIFICATION_TIMEOUT_SECONDS;

+ static const int DEFAULT_MESSAGE_NOTIFICATION_TIMEOUT_SECONDS;

+ };

+ class NullNotifier : public Notifier {

+ public:

+ virtual void showMessage(Type, const std::string&, const std::string&, const boost::filesystem::path&, boost::function<void()>) {

+ }

+ virtual void purgeCallbacks() {

+ }

+ };

+ window->onMessageReceived.connect(boost::bind(&SnarlNotifier::handleMessageReceived, this, _1));

+ available = snarl.RegisterApp(name.c_str(), name.c_str(), icon.string().c_str(), window->getID(), SWIFT_SNARLNOTIFIER_MESSAGE_ID);

+ foreach(Notifier::Type type, getAllTypes()) {

+ snarl.AddClass(typeToString(type).c_str(), typeToString(type).c_str());

+ }

+ snarl.UnregisterApp();

+ window->onMessageReceived.disconnect(boost::bind(&SnarlNotifier::handleMessageReceived, this, _1));

+ if (!notifications.empty()) {

+ std::cerr << "Warning: " << notifications.size() << " Snarl notifications pending" << std::endl;

+ }

+ return available;

+ int timeout = (type == IncomingMessage || type == SystemMessage) ? DEFAULT_MESSAGE_NOTIFICATION_TIMEOUT_SECONDS : DEFAULT_STATUS_NOTIFICATION_TIMEOUT_SECONDS;

+ int notificationID = snarl.EZNotify(

+ typeToString(type).c_str(),

+ subject.c_str(),

+ description.c_str(),

+ timeout,

+ picture.string().c_str());

+ if (notificationID > 0) {

+ notifications.insert(std::make_pair(notificationID, callback));

+ }

+ if (message->message == SWIFT_SNARLNOTIFIER_MESSAGE_ID) {

+ int action = message->wParam;

+ if (action == Snarl::V41::SnarlEnums::NotificationTimedOut || action == Snarl::V41::SnarlEnums::NotificationAck || action == Snarl::V41::SnarlEnums::NotificationClosed) {

+ int notificationID = message->lParam;

+ NotificationsMap::iterator i = notifications.find(notificationID);

+ if (i != notifications.end()) {

+ if (action == Snarl::V41::SnarlEnums::NotificationAck && !i->second.empty()) {

+ i->second();

+ }

+ notifications.erase(i);

+ }

+ else {

+ std::cerr << "Warning: Orphaned Snarl notification received";

+ }

+ }

+ }

+ class Win32NotifierWindow;

+

+ class SnarlNotifier : public Notifier {

+ public:

+ SnarlNotifier(const std::string& name, Win32NotifierWindow* window, const boost::filesystem::path& icon);

+ ~SnarlNotifier();

+

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

+ virtual bool isAvailable() const;

+

+ virtual void purgeCallbacks() {

+ notifications.clear();

+ }

+

+ private:

+ void handleMessageReceived(MSG* message);

+

+ private:

+ Snarl::V41::SnarlInterface snarl;

+ Win32NotifierWindow* window;

+ bool available;

+ typedef std::map<int, boost::function<void()> > NotificationsMap;

+ NotificationsMap notifications;

+ };

+ class TogglableNotifier : public Notifier {

+ public:

+ TogglableNotifier(Notifier* notifier) : notifier(notifier), persistentEnabled(true), temporarilyDisabled(false) {

+ }

+

+ /**

+ * Set a long-term (usually user-set) enabled.

+ * This may be temporarily overriden by the application, e.g. if the

+ * user is marked DND.

+ */

+ void setPersistentEnabled(bool b) {

+ persistentEnabled = b;

+ }

+

+ /**

+ * Set a temporary override to stop notifications without changing the

+ * long-term state. e.g. if the user goes DND, but the persistent

+ * enabled shouldn't be lost when they become available again.

+ */

+ void setTemporarilyDisabled(bool b) {

+ temporarilyDisabled = b;

+ }

+

+ /**

+ * Get the result of applying the temporary override to the persistent

+ * enabledness.

+ */

+ bool getCurrentlyEnabled() const {

+ return persistentEnabled && !temporarilyDisabled;

+ }

+

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback) {

+ if (getCurrentlyEnabled() || notifier->isExternallyConfigured()) {

+ notifier->showMessage(type, subject, description, picture, callback);

+ }

+ }

+

+ virtual bool isExternallyConfigured() const {

+ return notifier->isExternallyConfigured();

+ }

+

+ virtual void purgeCallbacks() {

+ notifier->purgeCallbacks();

+ }

+

+ private:

+ Notifier* notifier;

+ bool persistentEnabled;

+ bool temporarilyDisabled;

+ };

+ class Win32NotifierWindow {

+ public:

+ virtual ~Win32NotifierWindow() {}

+ virtual HWND getID() const = 0;

+ boost::signal<void (MSG*)> onMessageReceived;

+ };

+ class SpellChecker {

+ public:

+ SpellChecker() {

+ parser_ = new SpellParser();

+ }

+ virtual ~SpellChecker() {

+ delete parser_;

+ }

+ virtual bool isCorrect(const std::string& word) = 0;

+ virtual void getSuggestions(const std::string& word, std::vector<std::string>& list) = 0;

+ virtual void checkFragment(const std::string& fragment, PositionPairList& misspelledPositions) = 0;

+ protected:

+ SpellParser *parser_;

+ };

+ std::string affixFile(dictFile);

+ boost::replace_all(affixFile, ".dic", ".aff");

+ if ((boost::filesystem::exists(dictFile)) && (boost::filesystem::exists(affixFile))) {

+ return new HunspellChecker(affixFile.c_str(), dictFile.c_str());

+ }

+ // If dictionaries don't exist disable the checker

+ return NULL;

+ return new MacOSXChecker();

+ class SpellChecker;

+ class SpellCheckerFactory {

+ public:

+ SpellCheckerFactory();

+ SpellChecker* createSpellChecker(const std::string& dictFile);

+ };

+ word_count_tokens()

+ {

+ // define tokens (regular expresions) to match strings

+ // order is important

+ this->self.add

+ ("w{3}.[^ ]+", ID_WWW)

+ ("http:\\/\\/[^ ]+", ID_HTTP)

+ ("\\w{1,}['?|\\-?]?\\w{1,}", ID_WORD)

+ (".", ID_CHAR);

+ }

+ typedef bool result_type;

+ // the function operator gets called for each of the matched tokens

+ template <typename Token>

+ bool operator()(Token const& t, PositionPairList& wordPositions, std::size_t& position) const

+ {

+ switch (t.id()) {

+ case ID_WWW:

+ position += boost::numeric_cast<size_t>(t.value().size());

+ break;

+ case ID_HTTP:

+ position += boost::numeric_cast<size_t>(t.value().size());

+ break;

+ case ID_WORD: // matched a word

+ wordPositions.push_back(boost::tuples::make_tuple(position, position + boost::numeric_cast<size_t>(t.value().size())));

+ position += boost::numeric_cast<size_t>(t.value().size());

+ break;

+ case ID_CHAR: // match a simple char

+ ++position;

+ break;

+ }

+ return true; // always continue to tokenize

+ }

+ std::size_t position = 0;

+ // create the token definition instance needed to invoke the lexical analyzer

+ word_count_tokens<lex::lexertl::lexer<> > word_count_functor;

+ char const* first = fragment.c_str();

+ char const* last = &first[fragment.size()];

+ lex::tokenize(first, last, word_count_functor, boost::bind(counter(), _1, boost::ref(wordPositions), boost::ref(position)));

+ enum token_ids

+ {

+ ID_WWW = 1,

+ ID_HTTP = 2,

+ ID_WORD = 3,

+ ID_CHAR = 4

+ };

+ typedef boost::tuple<int, int> PositionPair;

+ typedef std::vector<PositionPair > PositionPairList;

+ class SpellParser{

+ public:

+ void check(const std::string& fragment, PositionPairList& wordPositions);

+ };

+ words_.erase(std::remove(words_.begin(), words_.end(), word), words_.end());

+ words_.insert(words_.begin(), word);

+ if (boost::starts_with(boost::to_lower_copy(word), lastShort_)) {

+ lastCompletionCandidates_.insert(lastCompletionCandidates_.begin(), word);

+ }

+ words_.erase(std::remove(words_.begin(), words_.end(), word), words_.end());

+ lastCompletionCandidates_.erase(std::remove(lastCompletionCandidates_.begin(), lastCompletionCandidates_.end(), word), lastCompletionCandidates_.end());

+ if (word == lastCompletion_) {

+ if (!lastCompletionCandidates_.empty()) {

+ size_t match = 0;

+ for (match = 0; match < lastCompletionCandidates_.size(); match++) {

+ if (lastCompletionCandidates_[match] == lastCompletion_) {

+ break;

+ }

+ }

+ size_t nextIndex = match + 1;

+ nextIndex = nextIndex >= lastCompletionCandidates_.size() ? 0 : nextIndex;

+ lastCompletion_ = lastCompletionCandidates_[nextIndex];

+ }

+ } else {

+ lastShort_ = boost::to_lower_copy(word);

+ lastCompletionCandidates_.clear();

+ foreach (std::string candidate, words_) {

+ if (boost::starts_with(boost::to_lower_copy(candidate), boost::to_lower_copy(word))) {

+ lastCompletionCandidates_.push_back(candidate);

+ }

+ }

+ lastCompletion_ = !lastCompletionCandidates_.empty() ? lastCompletionCandidates_[0] : word;

+ }

+ return lastCompletion_;

+ class TabComplete {

+ public:

+ void addWord(const std::string& word);

+ void removeWord(const std::string& word);

+ std::string completeWord(const std::string& word);

+ private:

+ std::vector<std::string> words_;

+ std::string lastCompletion_;

+ std::string lastShort_;

+ std::vector<std::string> lastCompletionCandidates_;

+ };

+ class MacOSXURIHandler : public URIHandler {

+ public:

+ MacOSXURIHandler();

+ virtual ~MacOSXURIHandler();

+ virtual void start();

+ virtual void stop();

+ private:

+ class Private;

+ Private* p;

+ };

+ {

+ URIHandler* handler;

+ }

+

+ - (id) initWithHandler: (URIHandler*) h {

+ if ((self = [super init])) {

+ handler = h;

+ }

+ return self;

+ }

+

+ - (void) getUrl: (NSAppleEventDescriptor*) event withReplyEvent: (NSAppleEventDescriptor*) replyEvent {

+ (void) replyEvent;

+ NSString* url = [[event paramDescriptorForKeyword:keyDirectObject] stringValue];

+ handler->onURI(std::string([url UTF8String]));

+ }

+ public:

+ MacOSXURIEventHandler* eventHandler;

+ p = new Private();

+ p->eventHandler = [[MacOSXURIEventHandler alloc] initWithHandler: this];

+ [p->eventHandler release];

+ delete p;

+ [[NSAppleEventManager sharedAppleEventManager] setEventHandler:p->eventHandler andSelector:@selector(getUrl:withReplyEvent:) forEventClass:kInternetEventClass andEventID:kAEGetURL];

+ // Register ourselves as default URI handler

+ //NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];

+ //LSSetDefaultHandlerForURLScheme((CFStringRef)@"xmpp", (CFStringRef)bundleID);

+ [[NSAppleEventManager sharedAppleEventManager] removeEventHandlerForEventClass:kInternetEventClass andEventID:kAEGetURL];

+ class NullURIHandler : public URIHandler {

+ public:

+ virtual void start() {

+ }

+ virtual void stop() {

+ }

+ };

+ class URIHandler {

+ public:

+ URIHandler();

+ virtual ~URIHandler();

+ boost::signal<void (const std::string&)> onURI;

+ };

+ CPPUNIT_TEST_SUITE(XMPPURITest);

+ CPPUNIT_TEST(testFromString_Authority);

+ CPPUNIT_TEST(testFromString_AuthorityWithPath);

+ CPPUNIT_TEST(testFromString_AuthorityWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithPathAndFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithIntlChars);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_Path);

+ CPPUNIT_TEST(testFromString_PathWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithIntlChars);

+ CPPUNIT_TEST(testFromString_PathWithInvalidEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar2);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_NoPrefix);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testFromString_Authority() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithPath() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_AuthorityWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithPathAndFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://nasty!%23$%25()*+,-.;=%3F%5B%5C%5D%5E_%60%7B%7C%7D~node@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+

+ void testFromString_AuthorityWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_Path() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_PathWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_PathWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:nasty!%23$%25()*+,-.;=%3F%5B%5C%5D%5E_%60%7B%7C%7D~node@example.com");

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getPath());

+ }

+ void testFromString_PathWithInvalidEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test%%@example.com");

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+ void testFromString_PathWithIncompleteEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%");

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+ void testFromString_PathWithIncompleteEscapedChar2() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%1");

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+ void testFromString_PathWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message");

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+ void testFromString_PathWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+ void testFromString_PathWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message#myfragment");

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+ void testFromString_PathWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+ void testFromString_NoPrefix() {

+ XMPPURI testling = XMPPURI::fromString("baz@example.com");

+ CPPUNIT_ASSERT(testling.isNull());

+ }

+ private:

+ std::string get(const std::map<std::string, std::string>& m, const std::string& k) {

+ std::map<std::string, std::string>::const_iterator i = m.find(k);

+ return i == m.end() ? "" : i->second;

+ }

+ XMPPURI result;

+ if (boost::starts_with(s, "xmpp:")) {

+ std::string uri = s.substr(5, s.npos);

+ bool parsePath = true;

+ bool parseQuery = true;

+ bool parseFragment = true;

+ // Parse authority

+ if (boost::starts_with(uri, "//")) {

+ size_t i = uri.find_first_of("/#?", 2);

+ result.setAuthority(JID(URL::unescape(uri.substr(2, i - 2))));

+ if (i == uri.npos) {

+ uri = "";

+ parsePath = parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '?') {

+ parsePath = false;

+ }

+ else if (uri[i] == '#') {

+ parseQuery = parsePath = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+ // Parse path

+ if (parsePath) {

+ size_t i = uri.find_first_of("#?");

+ result.setPath(JID(URL::unescape(uri.substr(0, i))));

+ if (i == uri.npos) {

+ uri = "";

+ parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '#') {

+ parseQuery = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+ // Parse query

+ if (parseQuery) {

+ size_t end = uri.find_first_of("#");

+ std::string query = uri.substr(0, end);

+ bool haveType = false;

+ typedef boost::split_iterator<std::string::iterator> split_iterator;

+ for (split_iterator it = boost::make_split_iterator(query, boost::first_finder(";")); it != split_iterator(); ++it) {

+ if (haveType) {

+ std::vector<std::string> keyValue;

+ boost::split(keyValue, *it, boost::is_any_of("="));

+ if (keyValue.size() == 1) {

+ result.addQueryParameter(URL::unescape(keyValue[0]), "");

+ }

+ else if (keyValue.size() >= 2) {

+ result.addQueryParameter(URL::unescape(keyValue[0]), URL::unescape(keyValue[1]));

+ }

+ }

+ else {

+ result.setQueryType(URL::unescape(boost::copy_range<std::string>(*it)));

+ haveType = true;

+ }

+ }

+ uri = (end == uri.npos ? "" : uri.substr(end + 1, uri.npos));

+ }

+ // Parse fragment

+ if (parseFragment) {

+ result.setFragment(URL::unescape(uri));

+ }

+ }

+ return result;

+ // TODO: Implement using Base/URI

+ class XMPPURI {

+ public:

+ XMPPURI();

+

+ const JID& getAuthority() const {

+ return authority;

+ }

+

+ void setAuthority(const JID& j) {

+ authority = j;

+ }

+

+ const JID& getPath() const {

+ return path;

+ }

+

+ void setPath(const JID& j) {

+ path = j;

+ }

+

+ const std::string& getQueryType() const {

+ return queryType;

+ }

+

+ void setQueryType(const std::string& q) {

+ queryType = q;

+ }

+

+ const std::map<std::string, std::string>& getQueryParameters() const {

+ return queryParameters;

+ }

+

+ void addQueryParameter(const std::string& key, const std::string& path) {

+ queryParameters[key] = path;

+ }

+

+ const std::string& getFragment() const {

+ return fragment;

+ }

+

+ void setFragment(const std::string& f) {

+ fragment = f;

+ }

+

+ bool isNull() const {

+ return !authority.isValid() && !path.isValid();

+ }

+

+ static XMPPURI fromString(const std::string&);

+

+ private:

+ JID authority;

+ JID path;

+ std::string fragment;

+ std::string queryType;

+ std::map<std::string, std::string> queryParameters;

+ };

+ CPPUNIT_TEST_SUITE(LastLineTrackerTest);

+ CPPUNIT_TEST(testFocusNormal);

+ CPPUNIT_TEST(testFocusOut);

+ CPPUNIT_TEST(testFocusOtherTab);

+ CPPUNIT_TEST(testRepeatedFocusOut);

+ CPPUNIT_TEST(testRepeatedFocusIn);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ LastLineTrackerTest () {

+ }

+ void testFocusNormal() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testFocusOut() {

+ LastLineTracker testling;

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testFocusOtherTab() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testRepeatedFocusOut() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testRepeatedFocusIn() {

+ LastLineTracker testling;

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ testling.setHasFocus(true);

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ }

+ CPPUNIT_TEST_SUITE(LinkifyTest);

+ CPPUNIT_TEST(testLinkify_URLWithResource);

+ CPPUNIT_TEST(testLinkify_HTTPSURLWithResource);

+ CPPUNIT_TEST(testLinkify_URLWithEmptyResource);

+ CPPUNIT_TEST(testLinkify_BareURL);

+ CPPUNIT_TEST(testLinkify_URLSurroundedByWhitespace);

+ CPPUNIT_TEST(testLinkify_MultipleURLs);

+ CPPUNIT_TEST(testLinkify_CamelCase);

+ CPPUNIT_TEST(testLinkify_HierarchicalResource);

+ CPPUNIT_TEST(testLinkify_Anchor);

+ CPPUNIT_TEST(testLinkify_Plus);

+ CPPUNIT_TEST(testLinkify_Tilde);

+ CPPUNIT_TEST(testLinkify_Equal);

+ CPPUNIT_TEST(testLinkify_Authentication);

+ CPPUNIT_TEST(testLinkify_At);

+ CPPUNIT_TEST(testLinkify_Amps);

+ CPPUNIT_TEST(testLinkify_UnicodeCharacter);

+ CPPUNIT_TEST(testLinkify_NewLine);

+ CPPUNIT_TEST(testLinkify_Tab);

+ CPPUNIT_TEST(testLinkify_Action);

+

+ CPPUNIT_TEST(testLinkify_SplitNone);

+ CPPUNIT_TEST(testLinkify_SplitAll);

+ CPPUNIT_TEST(testLinkify_SplitFirst);

+ CPPUNIT_TEST(testLinkify_SplitSecond);

+ CPPUNIT_TEST(testLinkify_SplitMiddle);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testLinkify_URLWithResource() {

+ std::string result = Linkify::linkify("http://swift.im/blog");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im/blog\">http://swift.im/blog</a>"),

+ result);

+ }

+

+ void testLinkify_HTTPSURLWithResource() {

+ std::string result = Linkify::linkify("https://swift.im/blog");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"https://swift.im/blog\">https://swift.im/blog</a>"),

+ result);

+ }

+

+ void testLinkify_URLWithEmptyResource() {

+ std::string result = Linkify::linkify("http://swift.im/");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im/\">http://swift.im/</a>"),

+ result);

+ }

+

+

+ void testLinkify_BareURL() {

+ std::string result = Linkify::linkify("http://swift.im");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im\">http://swift.im</a>"),

+ result);

+ }

+

+ void testLinkify_URLSurroundedByWhitespace() {

+ std::string result = Linkify::linkify("Foo http://swift.im/blog Bar");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("Foo <a href=\"http://swift.im/blog\">http://swift.im/blog</a> Bar"),

+ result);

+ }

+

+ void testLinkify_MultipleURLs() {

+ std::string result = Linkify::linkify("Foo http://swift.im/blog Bar http://el-tramo.be/about Baz");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("Foo <a href=\"http://swift.im/blog\">http://swift.im/blog</a> Bar <a href=\"http://el-tramo.be/about\">http://el-tramo.be/about</a> Baz"),

+ result);

+ }

+

+ void testLinkify_CamelCase() {

+ std::string result = Linkify::linkify("http://fOo.cOm/bAz");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://fOo.cOm/bAz\">http://fOo.cOm/bAz</a>"),

+ result);

+ }

+

+ void testLinkify_HierarchicalResource() {

+ std::string result = Linkify::linkify("http://foo.com/bar/baz/");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://foo.com/bar/baz/\">http://foo.com/bar/baz/</a>"),

+ result);

+ }

+

+ void testLinkify_Anchor() {

+ std::string result = Linkify::linkify("http://foo.com/bar#baz");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://foo.com/bar#baz\">http://foo.com/bar#baz</a>"),

+ result);

+ }

+

+ void testLinkify_Plus() {

+ std::string result = Linkify::linkify("http://foo.com/bar+baz");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://foo.com/bar+baz\">http://foo.com/bar+baz</a>"),

+ result);

+ }

+

+ void testLinkify_Tilde() {

+ std::string result = Linkify::linkify("http://foo.com/~kev/");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://foo.com/~kev/\">http://foo.com/~kev/</a>"),

+ result);

+ }

+

+ void testLinkify_Equal() {

+ std::string result = Linkify::linkify("http://www.amazon.co.uk/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=xmpp+definitive+guide&x=0&y=0");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://www.amazon.co.uk/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=xmpp+definitive+guide&x=0&y=0\">http://www.amazon.co.uk/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=xmpp+definitive+guide&x=0&y=0</a>"),

+ result);

+ }

+

+ void testLinkify_Authentication() {

+ std::string result = Linkify::linkify("http://bob:bla@swift.im/foo/bar");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://bob:bla@swift.im/foo/bar\">http://bob:bla@swift.im/foo/bar</a>"),

+ result);

+ }

+

+ void testLinkify_At() {

+ std::string result = Linkify::linkify("http://swift.im/foo@bar");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im/foo@bar\">http://swift.im/foo@bar</a>"),

+ result);

+ }

+

+ void testLinkify_Amps() {

+ std::string result = Linkify::linkify("http://swift.im/foo&bar&baz");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im/foo&bar&baz\">http://swift.im/foo&bar&baz</a>"),

+ result);

+ }

+

+ void testLinkify_UnicodeCharacter() {

+ std::string result = Linkify::linkify("http://\xe2\x98\x83.net");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://\xe2\x98\x83.net\">http://\xe2\x98\x83.net</a>"),

+ result);

+ }

+

+ void testLinkify_NewLine() {

+ std::string result = Linkify::linkify("http://swift.im\nfoo");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im\">http://swift.im</a>\nfoo"),

+ result);

+ }

+

+ void testLinkify_Tab() {

+ std::string result = Linkify::linkify("http://swift.im\tfoo");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("<a href=\"http://swift.im\">http://swift.im</a>\tfoo"),

+ result);

+ }

+

+ void testLinkify_Action() {

+ std::string result = Linkify::linkify("*http://swift.im*");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("*<a href=\"http://swift.im\">http://swift.im</a>*"),

+ result);

+ }

+

+ void checkResult(const std::string& testling, size_t expectedIndex, std::string expectedSplit[]) {

+ std::pair<std::vector<std::string>, size_t> result = Linkify::splitLink(testling);

+ CPPUNIT_ASSERT_EQUAL(expectedIndex, result.second);

+ for (size_t i = 0; i < result.first.size(); i++) {

+ CPPUNIT_ASSERT_EQUAL(expectedSplit[i], result.first[i]);

+ }

+ }

+

+ void testLinkify_SplitNone() {

+ std::string testling = "http this ain't";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"http this ain't"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitAll() {

+ std::string testling = "http://swift.im";

+ size_t expectedIndex = 0;

+ std::string expectedSplit[] = {"http://swift.im"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitFirst() {

+ std::string testling = "http://swift.im is a link";

+ size_t expectedIndex = 0;

+ std::string expectedSplit[] = {"http://swift.im", " is a link"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitSecond() {

+ std::string testling = "this is a link: http://swift.im";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"this is a link: ", "http://swift.im"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitMiddle() {

+ std::string testling = "Shove a link like http://swift.im in the middle";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"Shove a link like ","http://swift.im", " in the middle"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+ CPPUNIT_TEST_SUITE(SpellParserTest);

+ CPPUNIT_TEST(testSimpleCheckFragment);

+ CPPUNIT_TEST(testWWWCheckFragment);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ SpellParserTest() {

+ parser_ = new SpellParser();

+ };

+ void tearDown() {

+ position_.clear();

+ }

+ void testSimpleCheckFragment() {

+ parser_->check("fragment test", position_);

+ int size = position_.size();

+ CPPUNIT_ASSERT_EQUAL(2, size);

+ CPPUNIT_ASSERT_EQUAL(0, boost::get<0>(position_.front()));

+ CPPUNIT_ASSERT_EQUAL(8, boost::get<1>(position_.front()));

+ CPPUNIT_ASSERT_EQUAL(9, boost::get<0>(position_.back()));

+ CPPUNIT_ASSERT_EQUAL(13, boost::get<1>(position_.back()));

+ }

+ void testWWWCheckFragment() {

+ parser_->check("www.link.com fragment test", position_);

+ int size = position_.size();

+ CPPUNIT_ASSERT_EQUAL(2, size);

+ CPPUNIT_ASSERT_EQUAL(13, boost::get<0>(position_.front()));

+ CPPUNIT_ASSERT_EQUAL(21, boost::get<1>(position_.front()));

+ CPPUNIT_ASSERT_EQUAL(22, boost::get<0>(position_.back()));

+ CPPUNIT_ASSERT_EQUAL(26, boost::get<1>(position_.back()));

+ }

+ private:

+ SpellParser *parser_;

+ PositionPairList position_;

+ CPPUNIT_TEST_SUITE(TabCompleteTest);

+ CPPUNIT_TEST(testEmpty);

+ CPPUNIT_TEST(testNoMatch);

+ CPPUNIT_TEST(testOneMatch);

+ CPPUNIT_TEST(testTwoMatch);

+ CPPUNIT_TEST(testChangeMatch);

+ CPPUNIT_TEST(testRemoveDuringComplete);

+ CPPUNIT_TEST(testAddDuringComplete);

+ CPPUNIT_TEST(testSwiftRoomSample);

+ CPPUNIT_TEST_SUITE_END();

+

+ TabCompleteTest() {}

+

+ void setUp() {

+ completer_ = TabComplete();

+ }

+

+ void testEmpty() {

+ std::string blah("Blah");

+ CPPUNIT_ASSERT_EQUAL(

+ blah,

+ completer_.completeWord(blah));

+ CPPUNIT_ASSERT_EQUAL(

+ blah,

+ completer_.completeWord(blah));

+ }

+

+ void testNoMatch() {

+ completer_.addWord("Bleh");

+ std::string blah("Blah");

+ CPPUNIT_ASSERT_EQUAL(

+ blah,

+ completer_.completeWord(blah));

+ CPPUNIT_ASSERT_EQUAL(

+ blah,

+ completer_.completeWord(blah));

+ }

+

+ void testOneMatch() {

+ std::string short1("Bl");

+ std::string long1("Blehling");

+ completer_.addWord(long1);

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(short1));

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(long1));

+ }

+

+ void testTwoMatch() {

+ std::string short1("Hur");

+ std::string long1("Hurgle");

+ std::string long2("Hurdler");

+ completer_.addWord(long1);

+ completer_.addWord("Blah");

+ completer_.addWord(long2);

+ completer_.addWord("Bleh");

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(short1));

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(long2));

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(long1));

+ }

+

+ void testChangeMatch() {

+ std::string short1("Hur");

+ std::string short2("Rub");

+ std::string long1("Hurgle");

+ std::string long2("Rubbish");

+ completer_.addWord(long2);

+ completer_.addWord("Blah");

+ completer_.addWord(long1);

+ completer_.addWord("Bleh");

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(short1));

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(short2));

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(long2));

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(short1));

+ }

+

+ void testRemoveDuringComplete() {

+ std::string short1("Kev");

+ std::string long1("Kevin");

+ std::string long2("Kevlar");

+ completer_.addWord(long1);

+ completer_.addWord("Blah");

+ completer_.addWord(long2);

+ completer_.addWord("Bleh");

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(short1));

+ completer_.removeWord(long2);

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(long2));

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(long1));

+ }

+

+ void testAddDuringComplete() {

+ std::string short1("Rem");

+ std::string long1("Remko");

+ std::string long2("Remove");

+ std::string long3("Remedial");

+ completer_.addWord(long1);

+ completer_.addWord("Blah");

+ completer_.addWord(long2);

+ completer_.addWord("Bleh");

+ CPPUNIT_ASSERT_EQUAL(

+ long2,

+ completer_.completeWord(short1));

+ completer_.addWord(long3);

+ CPPUNIT_ASSERT_EQUAL(

+ long1,

+ completer_.completeWord(long2));

+ CPPUNIT_ASSERT_EQUAL(

+ long3,

+ completer_.completeWord(long1));

+ }

+

+ void testSwiftRoomSample() {

+ std::string t("t");

+ std::string Anpan("Anpan");

+ std::string cdubouloz("cdubouloz");

+ std::string Tobias("Tobias");

+ std::string Zash("Zash");

+ std::string lastsky("lastsky");

+ std::string Steve("Steve Kille");

+ std::string Flo("Flo");

+ std::string Test("Test");

+ std::string test("test");

+ completer_.addWord(Anpan);

+ completer_.addWord(cdubouloz);

+ completer_.addWord(Tobias);

+ completer_.addWord(lastsky);

+ completer_.addWord(Steve);

+ completer_.addWord(Flo);

+ completer_.addWord(Zash);

+

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Tobias));

+

+ completer_.addWord(Test);

+

+ CPPUNIT_ASSERT_EQUAL(

+ Test,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Test));

+ CPPUNIT_ASSERT_EQUAL(

+ Test,

+ completer_.completeWord(Tobias));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Test));

+

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+

+ completer_.removeWord(Test);

+

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Tobias));

+

+ completer_.addWord(test);

+

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+ completer_.addWord(Zash);

+

+

+ CPPUNIT_ASSERT_EQUAL(

+ test,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(test));

+ CPPUNIT_ASSERT_EQUAL(

+ test,

+ completer_.completeWord(Tobias));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(test));

+

+ completer_.removeWord(test);

+

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Tobias));

+

+ completer_.removeWord(Tobias);

+ CPPUNIT_ASSERT_EQUAL(

+ t,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ t,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ t,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ t,

+ completer_.completeWord(t));

+

+ completer_.addWord(Tobias);

+

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(t));

+ CPPUNIT_ASSERT_EQUAL(

+ Tobias,

+ completer_.completeWord(Tobias));

+

+ }

+ TabComplete completer_;