BeHaveDo

src/main/scala/nu/glen/followbackbot/Responder.scala

@@ -1,7 +1,6 @@
 package nu.glen.followbackbot
 
 import twitter4j.{Status, StatusUpdate}
-import util.matching.Regex
 
 object Responder {
   /**
@@ -13,10 +12,12 @@ object Responder {
   def simple(responder: SimpleResponder): Responder = { status =>
     // get the untruncated retweet text if status is a retweet
     val text =
-      if (status.isRetweet)
-        status.getRetweetedStatus.getText
-      else
-        status.getText
+      Option(
+        if (status.isRetweet)
+          status.getRetweetedStatus.getText
+        else
+          status.getText
+      ).getOrElse("").trim
 
     responder(text) map { response =>
       // add @reply prefix
@@ -51,68 +52,3 @@ object Responder {
   def merged(responders: Responder*): Responder =
     (status) => responders.foldLeft[Option[StatusUpdate]](None)(_ orElse _(status))
 }
-
-/**
- * Base class for SimpleResponders which extract a keyword which, when processed,
- * serves as the prefix for the rest of the extracted text. keywords are filtered against
- * a Set[String] of stop words.
- */
-abstract class KeywordPrefixResponder(stopWords: Set[String])
-  extends SimpleResponder
-  with SimpleLogger
-{
-  /**
-   * extract the keyword and remaining text from a status text
-   *
-   * @param statusText the text from which to extract
-   */
-  def extract(statusText: String): Option[(String, String)]
-
-  /**
-   * combine the keyword (now vetted against stopwords) with the rest of the
-   * string to form the tweet.
-   *
-   * @param filteredKeyword the keyword, filtered against stop words
-   * @param rest the rest of the sentence to be combined with the keyword
-   */
-  def combine(filteredKeyword: String, rest: String): String
-
-  def apply(statusText: String): Option[String] = {
-    extract(statusText) flatMap { case (keyword, rest) =>
-      if (stopWords.contains(keyword)) {
-        log.info("  Skipping tweet with stop word: %s", keyword)
-        None
-      } else {
-        Some(combine(keyword, rest))
-      }
-    }
-  }
-}
-
-/**
- * A KeywordPrefixResponder that uses a regex for extraction
- */
-abstract class RegexKeywordPrefixResponder(stopWords: Set[String], regex: Regex)
-  extends KeywordPrefixResponder(stopWords)
-{
-  override def extract(statusText: String): Option[(String, String)] = statusText match {
-     case regex(keyword, rest) => Some((keyword.toLowerCase, rest))
-     case _ => None
-  }
-}
-
-/**
- * A RegexKeywordPrefixResponder which (poorly) matches gerrunds as keywords
- */
-abstract class GerrundKeywordPrefixResponder
-  extends RegexKeywordPrefixResponder(
-    Ing.stopWords,
-    """.*?\b([a-z\-A-Z]+[iI][nN][gG])\b\"?(.*?)\"?""".r)
-
-/**
- * A RegexKeywordPrefixResponder which (poorly) matches past-tense verbs as keywords
- */
-abstract class PastTenseKeywordPrefixResponder
-  extends RegexKeywordPrefixResponder(
-    Ed.stopWords,
-     """.*?\b([a-z\-A-Z]+[eE][dD])\b\"?(.*?)\"?""".r)

src/main/scala/nu/glen/yourmombot/YourMomBot.scala

@@ -6,8 +6,9 @@ object YourMomBot
   extends FollowBackBot(
     Responder.rateLimited(
       Responder.merged(
-        Responder.simple(YourMomPastTenseResponder),
-        Responder.simple(YourMomGerrundResponder)
+        Responder.logOnly(Responder.simple(new YourMomBeHaveResponder)),
+        Responder.simple(new YourMomPastTenseResponder),
+        Responder.simple(new YourMomGerrundResponder)
       ),
       RateLimiter.merged(
         RateLimiter.perHour(2),

src/main/scala/nu/glen/yourmombot/YourMomResponder.scala

@@ -1,13 +1,19 @@
 package nu.glen.yourmombot
 
-import nu.glen.followbackbot.{GerrundKeywordPrefixResponder, PastTenseKeywordPrefixResponder}
+import nu.glen.followbackbot.{
+  BeHaveKeywordPrefixResponder,
+  GerrundKeywordPrefixResponder,
+  PastTenseKeywordPrefixResponder
+}
 
-object YourMomGerrundResponder extends GerrundKeywordPrefixResponder {
-  override def name = "YourMomGerrundResponder"
+class YourMomGerrundResponder extends GerrundKeywordPrefixResponder {
   override def combine(gerrund: String, rest: String) = "Your mom's %s%s".format(gerrund, rest)
 }
 
-object YourMomPastTenseResponder extends PastTenseKeywordPrefixResponder {
-  override def name = "YourMomPastTenseResponder"
+class YourMomPastTenseResponder extends PastTenseKeywordPrefixResponder {
+  override def combine(verb: String, rest: String) = "Your mom %s%s".format(verb, rest)
+}
+
+class YourMomBeHaveDoResponder extends BeHaveDoKeywordPrefixResponder {
   override def combine(verb: String, rest: String) = "Your mom %s%s".format(verb, rest)
 }

src/test/scala/nu/glen/yourmombot/YourMomResponderSpec.scala

@@ -6,27 +6,46 @@ class YourMomResponderSpec extends FunSpec {
   // most of the unit tests for this are in ResponderSpec, since the only
   // thing this class does is prefix "Your Mom's"
   describe("YourMomGerrundResponder") {
+    val responder = new YourMomGerrundResponder
+
     it("should extract a simple sentance") {
-      val result = YourMomGerrundResponder("I'm hoping this works")
+      val result = responder("I'm hoping this works")
       assert(result == Some("Your mom's hoping this works"))
     }
 
     it("should return None for no ing") {
-      val result = YourMomGerrundResponder("foobar")
+      val result = responder("foobar")
       assert(result == None)
     }
   }
 
   // most of the unit tests for this are in ResponderSpec, since the only
   // thing this class does is prefix "Your Mom's"
   describe("YourMomPastTenseResponder") {
+    val responder = new YourMomPastTenseResponder
+
     it("should extract a simple sentance") {
-      val result = YourMomPastTenseResponder("I hoped this worked")
+      val result = responder("I hoped this worked")
       assert(result == Some("Your mom hoped this worked"))
     }
 
     it("should return None for no ed") {
-      val result = YourMomPastTenseResponder("foobar")
+      val result = responder("foobar")
+      assert(result == None)
+    }
+  }
+
+  describe("YourMomBeHaveResponder") {
+    val responder = new YourMomBeHaveDoResponder
+
+    it("should extract") {
+      val result = responder("I didn't much care for that")
+      println(result)
+      assert(result == Some("Your mom didn't much care for that"))
+    }
+
+    it("should return None") {
+      val result = responder("foobar")
       assert(result == None)
     }
   }