Update camille and services to new Chameleon framework

Author: IanKeen

Package.swift

@@ -1,16 +1,11 @@
+// swift-tools-version:3.1
+
 import PackageDescription
 
 let package = Package(
     name: "Camille",
-    targets: [
-        Target(
-            name: "Camille",
-            dependencies: []
-        )
-    ],
     dependencies: [
-        .Package(url: "https://github.com/ChameleonBot/Bot.git", majorVersion: 0, minor: 2),
-        .Package(url: "https://github.com/ChameleonBot/Sugar.git", majorVersion: 0, minor: 2)
+        .Package(url: "https://github.com/ChameleonBot/Chameleon.git", majorVersion: 1),
     ],
     exclude: [
         "XcodeProject"

Sources/Camille/Configs/Configs+KarmaService.swift

@@ -1,16 +1,16 @@
-import Sugar
-
-extension Configs {
-    static let Karma = KarmaService.Config(
-        topUsersLimit: 20,
-        karmaAdjusters: [("++", 1), ("--", -1)],
-        textDistanceThreshold: 4,
-        allowedBufferCharacters: [" ", ":"],
-        positiveMessage: { user, total in
-            return ["\(user.name) you rock!: \(total)"]
-        },
-        negativeMessage: { user, total in
-            return ["Boooo \(user.name)!: \(total)"]
-        }
-    )
-}
+//import Sugar
+//
+//extension Configs {
+//    static let Karma = KarmaService.Config(
+//        topUsersLimit: 20,
+//        karmaAdjusters: [("++", 1), ("--", -1)],
+//        textDistanceThreshold: 4,
+//        allowedBufferCharacters: [" ", ":"],
+//        positiveMessage: { user, total in
+//            return ["\(user.name) you rock!: \(total)"]
+//        },
+//        negativeMessage: { user, total in
+//            return ["Boooo \(user.name)!: \(total)"]
+//        }
+//    )
+//}

Sources/Camille/HelloService.swift

@@ -1,25 +1,38 @@
-import Bot
-import Sugar
+import Chameleon
 
-final class HelloService: SlackMessageService {
-    func messageEvent(slackBot: SlackBot, webApi: WebAPI, message: MessageDecorator, previous: MessageDecorator?) throws {
-        guard let target = message.target, let sender = message.sender else { return }
-        
-        try message.routeText(
-            to: self.sayHello(to: sender, in: target, with: webApi),
-            matching: Greeting(name: "greeting"), slackBot.me
-        )
+final class HelloService: SlackBotMessageService {
+    func configure(slackBot: SlackBot) {
+        configureMessageService(slackBot: slackBot)
+
+        slackBot.registerHelp(item: Patterns.greeting(slackBot))
+    }
+    func onMessage(slackBot: SlackBot, message: MessageDecorator, previous: MessageDecorator?) throws {
+        try slackBot.route(message, matching: Patterns.greeting(slackBot), to: sendGreeting)
+    }
+
+    private func sendGreeting(bot: SlackBot, message: MessageDecorator, match: PatternMatch) throws -> Void {
+        let response = try message
+            .respond()
+            .text(["well", try match.value(key: "greeting"), "back at you", try message.sender()])
+            .makeChatMessage()
+
+        try bot.send(response)
     }
 }
 
-fileprivate extension HelloService {
-    func sayHello(to sender: User, in target: SlackTargetType, with webApi: WebAPI) -> (PatternMatchResult) throws -> Void {
-        return { match in
-            let message = try SlackMessage()
-                .line(match.value(named: "greeting"), " ", sender)
-                .makeChatPostMessage(target: target)
-            
-            try webApi.execute(message)
+private enum Patterns: HelpRepresentable {
+    case greeting(SlackBot)
+
+    var topic: String {
+        return "Greetings"
+    }
+    var description: String {
+        return "Greet the bot"
+    }
+
+    var pattern: [Matcher] {
+        switch self {
+        case .greeting(let bot): return [["hey", "hi", "hello"].any.using(key: "greeting"), bot.me]
         }
     }
 }

Sources/Camille/Karma/KarmaAdjustable.swift

@@ -1,74 +1,71 @@
-import Bot
-import Sugar
+import Chameleon
+import Foundation
+
+private typealias PartialUpdate = (user: ModelPointer<User>, operation: Operation)
+private typealias Update = (ModelPointer<User>, (current: Int, change: Int))
+
+private enum Operation: String {
+    case plus = "++"
+    case minus = "--"
+
+    func update(value: Int) -> Int {
+        switch self {
+        case .plus: return value + 1
+        case .minus: return value - 1
+        }
+    }
+}
 
 extension KarmaService {
-    func adjustKarma(
-        in message: MessageDecorator,
-        from sender: User,
-        in target: SlackTargetType,
-        storage: Storage,
-        webApi: WebAPI) throws -> Void {
-        
-        //find any karma adjustments
-        let adjustments: [(user: User, amount: Int)] = message.mentioned_users.flatMap { link in
-            //user can't adjust their own karma
-            guard link.value != sender else { return nil }
-            
-            //Move past the `>` and get the rest of the message
-            let start = message.text.index(after: link.range.upperBound)
-            let text = message.text.substring(from: start)
-            
-            //iterate forward until we pass the threshold or hit the end of the string
-            for index in (0..<min(self.config.textDistanceThreshold, text.characters.count)) {
-                //check for adjustments
-                for adjuster in self.config.karmaAdjusters {
-                    if text.substring(from: index).hasPrefix(adjuster.adjuster.karmaValue) {
-                        return (link.value, adjuster.amount)
-                    }
-                }
-                
-                //check the allowed chars
-                let nextChar = Character(text.substring(to: 1))
-                guard self.config.allowedBufferCharacters.contains(nextChar) else { break }
-            }
-            
-            return nil
+    func adjust(bot: SlackBot, message: MessageDecorator) throws {
+        guard !message.isIM else { return }
+
+        func partialUpdate(from link: MessageDecorator.Link<ModelPointer<User>>) throws -> PartialUpdate? {
+            guard try link.value.id != message.sender().id else { return nil }
+
+            let possibleOperation = message.text
+                .substring(from: link.range.upperBound)
+                .trimCharacters(in: [" ", ">", ":"])
+                .components(separatedBy: " ")
+                .first ?? ""
+
+            guard let operation = Operation(rawValue: possibleOperation)
+                else { return nil }
+
+            return (link.value, operation)
         }
-        
-        guard !adjustments.isEmpty else { return }
-        
-        //consolidate adjustments
-        let consolidated: [(user: User, change: Int, total: Int)] = adjustments
-            .grouped(by: { $0.user })
-            .flatMap { user, changes in
-                let current: Int = storage.get(.in("Karma"), key: user.id, or: 0)
-                let change = changes.reduce(0) { $0 + $1.amount }
-                guard change != 0 else { return nil }
-                let newTotal = current + change
-                return (user, change, newTotal)
+
+        func consolidatePartialUpdates(for user: ModelPointer<User>, partials: [PartialUpdate]) throws -> Update {
+            let count: Int = try storage.get(key: user.id, from: Keys.namespace, or: 0)
+            let change = partials.reduce(0) { $1.operation.update(value: $0) }
+            return (user, (count, change))
         }
-        
-        //make adjustments
-        for adjustment in consolidated where adjustment.change != 0 {
-            try storage.set(.in("Karma"), key: adjustment.user.id, value: adjustment.total)
+
+        let updates = try message
+            .mentionedUsers
+            .flatMap(partialUpdate)
+            .group(by: { $0.user })
+            .map(consolidatePartialUpdates)
+            .filter { $0.value.change != 0 }
+
+        guard !updates.isEmpty else { return }
+
+        let response = try message.respond()
+
+        for (user, data) in updates {
+            let newTotal = data.current + data.change
+            storage.set(value: newTotal, forKey: user.id, in: Keys.namespace)
+
+            let comment = (data.change > 0
+                ? config.positiveComments.randomElement
+                : config.negativeComments.randomElement
+            ) ?? ""
+
+            response
+                .text([user, comment, newTotal])
+                .newLine()
         }
 
-        //build a message
-        let response = consolidated
-            .flatMap { adjustment in
-                if adjustment.change > 0 {
-                    return self.config.positiveMessage(adjustment.user, adjustment.total).randomElement
-                } else if adjustment.change < 0 {
-                    return self.config.negativeMessage(adjustment.user, adjustment.total).randomElement
-                }
-                return nil
-            }
-            .joined(separator: "\n")
-        
-        guard !response.isEmpty else { return }
-        
-        //respond
-        let request = ChatPostMessage(target: target, text: response)
-        try webApi.execute(request)
+        try bot.send(response.makeChatMessage())
     }
 }

Sources/Camille/Karma/KarmaService+Adjustments.swift

@@ -1,13 +1,22 @@
-import Sugar
-import Models
 
 extension KarmaService {
-    struct Config {
-        let topUsersLimit: Int
-        let karmaAdjusters: [(adjuster: KarmaAdjustable, amount: Int)]
-        let textDistanceThreshold: Int
-        let allowedBufferCharacters: Set<Character>
-        let positiveMessage: (_ user: User, _ total: Int) -> [String]
-        let negativeMessage: (_ user: User, _ total: Int) -> [String]
+    public struct Config {
+        let topUserLimit: Int
+        let positiveComments: [String]
+        let negativeComments: [String]
+
+        public init(topUserLimit: Int, positiveComments: [String], negativeComments: [String]) {
+            self.topUserLimit = topUserLimit
+            self.positiveComments = positiveComments
+            self.negativeComments = negativeComments
+        }
+
+        public static func `default`() -> Config {
+            return Config(
+                topUserLimit: 10,
+                positiveComments: ["you rock!"],
+                negativeComments: ["booooo!"]
+            )
+        }
     }
 }

Sources/Camille/Karma/KarmaService+Config.swift

@@ -0,0 +1,33 @@
+import Chameleon
+
+extension KarmaService {
+    enum Patterns: HelpRepresentable {
+        case topUsers
+        case myCount
+        case userCount
+        case adjustment
+
+        var topic: String {
+            return "Karma"
+        }
+        var description: String {
+            switch self {
+            case .topUsers: return "Find out who's on top!"
+            case .myCount: return "See how much karma you have"
+            case .userCount: return "See how much karma someone else has"
+            case .adjustment: return "Give or take karma from someone"
+            }
+        }
+
+        var pattern: [Matcher] {
+            switch self {
+            case .topUsers: return ["top", Int.any.using(key: Keys.count)]
+            case .myCount: return ["how much karma do I have"]
+            case .userCount: return ["how much karma does", User.any.using(key: Keys.user), "have"]
+            case .adjustment: return [User.any, ["++", "--"].any]
+            }
+        }
+
+        var strict: Bool { return false }
+    }
+}