lita-karma 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f7807772d594056ec3c21dae05d056be2394e3a
-  data.tar.gz: d28351489ce8234e359a15657bccb4cc87f4e0a7
+  metadata.gz: e1e03d87e444b488534df84e8c3d16a8f02f6c82
+  data.tar.gz: 45ad68d97c0bb3b3e172a1334c8d4ad5e29af53f
 SHA512:
-  metadata.gz: ae64368983385ac07aa53548fdb5f91276b4d15c323cf47845208b46f4b1e7d1bf1fdc8ef041daee27bcf5eadb33821d0a7132eda98a2739bd8fdbec626248f3
-  data.tar.gz: f5b8da41d0caa619038e2518a400312d54afd9a005e807c04d39f83a71f798f68b07e4a7df8abd14de9470ec8266990decea488038e037605a941f1a6d118e22
+  metadata.gz: 457f520bc9e527737878628b873e85dc86f2449b45d77c3ac3506a8e81276017311e4db61a312d8e01981652ab733d316be3cb936e8da8a14a115ee5e7f663b0
+  data.tar.gz: 8625c91141b4f995f4be50fe63c72e06ff89643f7f423330d79b43a00c367454059defc608841b795fd31e775973a6375965effbf9c67050dc6e628488a466df

data/README.md

@@ -18,11 +18,10 @@ gem "lita-karma"
 
 ### Optional attributes
 
-* `cooldown` (Integer, nil) - Controls how long a user must wait after modifying a term before they can modify it again. The value should be an integer number of seconds. Set it to `nil` to disable rate limiting. Default: `300` (5 minutes).
-* `link_karma_threshold` (Integer, nil) - Controls how many points a term must have before it can be linked to other terms or before terms can be linked to it. Treated as an absolute value, so it applies to both positive and negative karma. Set it to `nil` to allow all terms to be linked regardless of karma. Default: `10`.
-* `term_pattern` (Regexp) - Determines what Lita will recognize as a valid term for tracking karma. Default: `/[\[\]\p{Word}\._|\{\}]{2,}/`.
-* `term_normalizer` (Proc) - A custom callable that determines how each term will be normalized before being stored in Redis. The proc should take one argument, the term as matched via regular expression, and return one value, the normalized version of the term.
-
+* **cooldown** (`Integer`, `nil`) - Controls how long a user must wait after modifying a term before they can modify it again. The value should be an integer number of seconds. Set it to `nil` to disable rate limiting. Default: `300` (5 minutes).
+* **link_karma_threshold** (`Integer`, `nil`) - Controls how many points a term must have before it can be linked to other terms or before terms can be linked to it. Treated as an absolute value, so it applies to both positive and negative karma. Set it to `nil` to allow all terms to be linked regardless of karma. Default: `10`.
+* **term_pattern** (`Regexp`) - Determines what Lita will recognize as a valid term for tracking karma. Default: `/[\[\]\p{Word}\._|\{\}]{2,}/`.
+* **term_normalizer** (`#call`) - A custom callable that determines how each term will be normalized before being stored in Redis. The proc should take one argument, the term as matched via regular expression, and return one value, the normalized version of the term. Default: turns the term into a string, downcases it, and strips whitespace off both ends.
 
 ### Example
 
@@ -40,6 +39,8 @@ end
 
 ## Usage
 
+### Giving Karma
+
 Lita will add a karma point whenever it hears a term upvoted:
 
 ```
@@ -58,6 +59,8 @@ To check the current karma for a term without modifying it:
 term~~
 ```
 
+### Listing Karma
+
 To list the top scoring terms:
 
 ```
@@ -76,12 +79,14 @@ To list the worst scoring terms:
 Lita: karma worst
 ```
 
-These commands will list 5 terms by default. To specify a number (no greater than 25), pass a second argument to the karma command:
+The list commands will list 5 terms by default. To specify a number (no greater than 25), pass a second argument to the karma command:
 
 ```
 Lita: karma best 10
 ```
 
+### Linking Terms
+
 You can also link terms together. This adds one term's karma to another's whenever it is displayed. A link is uni-directional and non-destructive. You can unlink terms at any time.
 
 ```
@@ -103,6 +108,17 @@ foo~~
 
 When a term is linked, the total karma score is displayed first, followed by the score of the term without its linked terms in parentheses.
 
+### Modification lists
+
+To get a list of the users who have upvoted or downvoted a term:
+
+```
+Lita: karma modified foo
+> Joe, Amy
+```
+
+### Deleting Terms
+
 To permanently delete a term and all its links:
 
 ```

data/lib/lita-karma.rb

@@ -1 +1,11 @@
-require "lita/handlers/karma"
+require "set"
+
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/handlers/karma/chat"
+require 'lita/handlers/karma/config'
+require 'lita/handlers/karma/term'

data/lib/lita/handlers/karma/chat.rb

@@ -0,0 +1,206 @@
+module Lita::Handlers::Karma
+  # Tracks karma points for arbitrary terms.
+  class Chat < Lita::Handler
+    namespace "karma"
+
+    on :loaded, :define_routes
+
+    def define_routes(payload)
+      define_static_routes
+      define_dynamic_routes(config.term_pattern.source)
+    end
+
+    def increment(response)
+      modify(response, :increment)
+    end
+
+    def decrement(response)
+      modify(response, :decrement)
+    end
+
+    def check(response)
+      seen = Set.new
+
+      output = response.matches.map do |match|
+        term = get_term(match[0])
+        next if seen.include?(term)
+        seen << term
+        term.check
+      end.compact
+
+      response.reply output.join("; ")
+    end
+
+    def list_best(response)
+      list(response, :list_best)
+    end
+
+    def list_worst(response)
+      list(response, :list_worst)
+    end
+
+    def link(response)
+      response.matches.each do |match|
+        term1 = get_term(match[0])
+        term2 = get_term(match[1])
+
+        result = term1.link(term2)
+
+        case result
+        when Integer
+          response.reply t("threshold_not_satisfied", threshold: result)
+        when true
+          response.reply t("link_success", source: term2, target: term1)
+        else
+          response.reply t("already_linked", source: term2, target: term1)
+        end
+      end
+    end
+
+    def unlink(response)
+      response.matches.each do |match|
+        term1 = get_term(match[0])
+        term2 = get_term(match[1])
+
+        if term1.unlink(term2)
+          response.reply t("unlink_success", source: term2, target: term1)
+        else
+          response.reply t("already_unlinked", source: term2, target: term1)
+        end
+      end
+    end
+
+    def modified(response)
+      term = get_term(response.args[1])
+
+      users = term.modified
+
+      if users.empty?
+        response.reply t("never_modified", term: term)
+      else
+        response.reply users.map(&:name).join(", ")
+      end
+    end
+
+    def delete(response)
+      term = Term.new(robot, response.message.body.sub(/^karma delete /, ""), normalize: false)
+
+      if term.delete
+        response.reply t("delete_success", term: term)
+      end
+    end
+
+    private
+
+    def define_dynamic_routes(pattern)
+      self.class.route(
+        %r{(#{pattern})\+\+#{token_terminator.source}},
+        :increment,
+        help: { t("help.increment_key") => t("help.increment_value") }
+      )
+
+      self.class.route(
+        %r{(#{pattern})--#{token_terminator.source}},
+        :decrement,
+        help: { t("help.decrement_key") => t("help.decrement_value") }
+      )
+
+      self.class.route(
+        %r{(#{pattern})~~#{token_terminator.source}},
+        :check,
+        help: { t("help.check_key") => t("help.check_value") }
+      )
+
+      self.class.route(
+        %r{^(#{pattern})\s*\+=\s*(#{pattern})(?:\+\+|--|~~)?#{token_terminator.source}},
+        :link,
+        command: true,
+        help: { t("help.link_key") => t("help.link_value") }
+      )
+
+      self.class.route(
+        %r{^(#{pattern})\s*-=\s*(#{pattern})(?:\+\+|--|~~)?#{token_terminator.source}},
+        :unlink,
+        command: true,
+        help: { t("help.unlink_key") => t("help.unlink_value") }
+      )
+    end
+
+    def define_static_routes
+      self.class.route(
+        %r{^karma\s+worst},
+        :list_worst,
+        command: true,
+        help: { t("help.list_worst_key") => t("help.list_worst_value") }
+      )
+
+      self.class.route(
+        %r{^karma\s+best},
+        :list_best,
+        command: true,
+        help: { t("help.list_best_key") => t("help.list_best_value") }
+      )
+
+      self.class.route(
+        %r{^karma\s+modified\s+.+},
+        :modified,
+        command: true,
+        help: { t("help.modified_key") => t("help.modified_value") }
+      )
+
+      self.class.route(
+        %r{^karma\s+delete},
+        :delete,
+        command: true,
+        restrict_to: :karma_admins,
+        help: { t("help.delete_key") => t("help.delete_value") }
+      )
+
+      self.class.route(%r{^karma\s*$}, :list_best, command: true)
+    end
+
+    def determine_list_count(response)
+      n = (response.args[1] || 5).to_i - 1
+      n = 25 if n > 25
+      n
+    end
+
+    def get_term(term)
+      Term.new(robot, term)
+    end
+
+    def list(response, method_name)
+      terms_and_scores = Term.public_send(method_name, robot, determine_list_count(response))
+
+      output = terms_and_scores.each_with_index.map do |term_and_score, index|
+        "#{index + 1}. #{term_and_score[0]} (#{term_and_score[1].to_i})"
+      end.join("\n")
+
+      if output.empty?
+        response.reply t("no_terms")
+      else
+        response.reply output
+      end
+    end
+
+    def modify(response, method_name)
+      user = response.user
+
+      output = response.matches.map do |match|
+        get_term(match[0]).public_send(method_name, user)
+      end
+
+      response.reply output.join("; ")
+    end
+
+    # To ensure that constructs like foo++bar or foo--bar (the latter is
+    # common in some URL generation schemes) do not cause errant karma
+    # modifications, force karma tokens be followed by whitespace (in a zero-
+    # width, look-ahead operator) or the end of the string.
+    def token_terminator
+      %r{(?:(?=\s)|$)}
+    end
+  end
+end
+
+Lita.register_handler(Lita::Handlers::Karma::Chat)

data/lib/lita/handlers/karma/config.rb

@@ -0,0 +1,20 @@
+module Lita::Handlers::Karma
+  class Config < Lita::Handler
+    namespace "karma"
+
+    default_term_normalizer = proc do |term|
+      term.to_s.downcase.strip
+    end
+
+    config :cooldown, types: [Integer, nil], default: 300
+    config :link_karma_threshold, types: [Integer, nil], default: 10
+    config :term_pattern, type: Regexp, default: /[\[\]\p{Word}\._|\{\}]{2,}/
+    config :term_normalizer, default: default_term_normalizer do
+      validate do |value|
+        t("callable_required") unless value.respond_to?(:call)
+      end
+    end
+  end
+end
+
+Lita.register_handler(Lita::Handlers::Karma::Config)

data/lib/lita/handlers/karma/term.rb

@@ -0,0 +1,152 @@
+ module Lita::Handlers::Karma
+  class Term
+    include Lita::Handler::Common
+
+    namespace "karma"
+
+    attr_reader :term
+
+    class << self
+      def list_best(robot, n = 5)
+        list(:zrevrange, robot, n)
+      end
+
+      def list_worst(robot, n = 5)
+        list(:zrange, robot, n)
+      end
+
+      private
+
+      def list(redis_command, robot, n)
+        n = 24 if n > 24
+
+        handler = new(robot, '', normalize: false)
+        handler.redis.public_send(redis_command, "terms", 0, n, with_scores: true)
+      end
+    end
+
+    def initialize(robot, term, normalize: true)
+      super(robot)
+      @term = normalize ? normalize_term(term) : term
+      @link_cache = {}
+    end
+
+    def check
+      string = "#{self}: #{total_score}"
+
+      unless links_with_scores.empty?
+        link_text = links_with_scores.map { |term, score| "#{term}: #{score}" }.join(", ")
+        string << " (#{own_score}), #{t("linked_to")}: #{link_text}"
+      end
+
+      string
+    end
+
+    def decrement(user)
+      modify(user, -1)
+    end
+
+    def delete
+      redis.zrem("terms", to_s)
+      redis.del("modified:#{self}")
+      redis.del("links:#{self}")
+      redis.smembers("linked_to:#{self}").each do |key|
+        redis.srem("links:#{key}", to_s)
+      end
+      redis.del("linked_to:#{self}")
+    end
+
+    def eql?(other)
+      term.eql?(other.term)
+    end
+
+    def hash
+      term.hash
+    end
+
+    def increment(user)
+      modify(user, 1)
+    end
+
+    def link(other)
+      if config.link_karma_threshold
+        threshold = config.link_karma_threshold.abs
+
+        if own_score.abs < threshold || other.own_score.abs < threshold
+          return threshold
+        end
+      end
+
+      redis.sadd("links:#{self}", other.to_s) && redis.sadd("linked_to:#{other}", to_s)
+    end
+
+    def links
+      @links ||= begin
+        redis.smembers("links:#{self}").each do |term|
+          linked_term = self.class.new(robot, term)
+          @link_cache[linked_term.term] = linked_term
+        end
+      end
+    end
+
+    def links_with_scores
+      @links_with_scores ||= begin
+        {}.tap do |h|
+          links.each do |link|
+            h[link] = @link_cache[link].own_score
+          end
+        end
+      end
+    end
+
+    def modified
+      redis.smembers("modified:#{term}").map do |user_id|
+        Lita::User.find_by_id(user_id)
+      end
+    end
+
+    def own_score
+      @own_score ||= redis.zscore("terms", term).to_i
+    end
+
+    def to_s
+      term
+    end
+
+    def total_score
+      @total_score ||= begin
+        links.inject(own_score) do |memo, linked_term|
+          memo + @link_cache[linked_term].own_score
+        end
+      end
+    end
+
+    def unlink(other)
+      redis.srem("links:#{self}", other.to_s) && redis.srem("linked_to:#{other}", to_s)
+    end
+
+    private
+
+    def modify(user, delta)
+      ttl = redis.ttl("cooldown:#{user.id}:#{term}")
+
+      if ttl > 0
+        t("cooling_down", term: self, ttl: ttl, count: ttl)
+      else
+        modify!(user, delta)
+      end
+    end
+
+    def modify!(user, delta)
+      user_id = user.id
+      redis.zincrby("terms", delta, term)
+      redis.sadd("modified:#{self}", user_id)
+      redis.setex("cooldown:#{user_id}:#{self}", config.cooldown, 1) if config.cooldown
+      check
+    end
+
+    def normalize_term(term)
+      config.term_normalizer.call(term)
+    end
+  end
+end

data/lita-karma.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-karma"
-  spec.version       = "3.0.0"
+  spec.version       = "3.0.1"
   spec.authors       = ["Jimmy Cuadra"]
   spec.email         = ["jimmy@jimmycuadra.com"]
   spec.description   = %q{A Lita handler for tracking karma points for arbitrary terms.}

data/locales/en.yml

@@ -0,0 +1,40 @@
+en:
+  lita:
+    handlers:
+      karma:
+        already_linked: "%{source} is already linked to %{target}."
+        already_unlinked: "%{source} is not linked to %{target}."
+        callable_required: must be a callable object
+        cooling_down:
+          one: "You cannot modify %{term} for another %{ttl} second."
+          other: "You cannot modify %{term} for another %{ttl} seconds."
+        delete_success: "%{term} has been deleted."
+        help:
+          increment_key: TERM++
+          increment_value: Increments TERM by one.
+          decrement_key: TERM--
+          decrement_value: Decrements TERM by one.
+          check_key: TERM~~
+          check_value: Shows the current karma of TERM.
+          link_key: TERM1 += TERM2
+          link_value: Links TERM2 to TERM1.
+          unlink_key: TERM1 -= TERM2
+          unlink_value: Unlinks TERM2 from TERM1.
+          list_worst_key: "karma worst [N]"
+          list_worst_value: Lists the bottom N terms by karma. N defaults to 5.
+          list_best_key: "karma best [N]"
+          list_best_value: Lists the top N terms by karma. N defaults to 5.
+          modified_key: karma modified TERM
+          modified_value: Lists the names of users who have upvoted or downvoted TERM.
+          delete_key: karma delete TERM
+          delete_value: >-
+            Permanently removes TERM and all its link information. TERM is matched
+            exactly as typed and does not adhere to the usual pattern for terms.
+        link_success: "%{source} has been linked to %{target}."
+        linked_to: linked to
+        never_modified: "%{term} has never been modified."
+        no_terms: There are no terms being tracked yet.
+        threshold_not_satisfied: >-
+          Terms must have less than or equal to -%{threshold} or greater than or equal to
+          %{threshold} karma to be linked or linked to.
+        unlink_success: "%{source} has been unlinked from %{target}."

data/spec/lita/handlers/{karma_spec.rb → karma/chat_spec.rb}

@@ -1,8 +1,10 @@
 require "spec_helper"
 
-describe Lita::Handlers::Karma, lita_handler: true do
+describe Lita::Handlers::Karma::Chat, lita_handler: true do
   let(:payload) { double("payload") }
 
+  prepend_before { registry.register_handler(Lita::Handlers::Karma::Config) }
+
   before do
     registry.config.handlers.karma.cooldown = nil
     registry.config.handlers.karma.link_karma_threshold = nil
@@ -12,35 +14,28 @@ describe Lita::Handlers::Karma, lita_handler: true do
 
   it { is_expected.to route("foo++").to(:increment) }
   it { is_expected.to route("foo--").to(:decrement) }
+  it { is_expected.to route("foo++ bar").to(:increment) }
+  it { is_expected.to route("foo-- bar").to(:decrement) }
   it { is_expected.to route("foo~~").to(:check) }
   it { is_expected.to route_command("karma best").to(:list_best) }
   it { is_expected.to route_command("karma worst").to(:list_worst) }
-  it { is_expected.to route_command("karma modified").to(:modified) }
+  it { is_expected.to route_command("karma modified foo").to(:modified) }
   it do
     is_expected.to route_command("karma delete").with_authorization_for(:karma_admins).to(:delete)
   end
   it { is_expected.to route_command("karma").to(:list_best) }
   it { is_expected.to route_command("foo += bar").to(:link) }
+  it { is_expected.to route_command("foo += bar++").to(:link) }
+  it { is_expected.to route_command("foo += bar--").to(:link) }
+  it { is_expected.to route_command("foo += bar~~").to(:link) }
   it { is_expected.to route_command("foo -= bar").to(:unlink) }
+  it { is_expected.to route_command("foo -= bar++").to(:unlink) }
+  it { is_expected.to route_command("foo -= bar--").to(:unlink) }
+  it { is_expected.to route_command("foo -= bar~~").to(:unlink) }
   it { is_expected.not_to route("+++++").to(:increment) }
   it { is_expected.not_to route("-----").to(:decrement) }
-
-  describe "#update_data" do
-    before { subject.redis.flushdb }
-
-    it "adds reverse link data for all linked terms" do
-      subject.redis.sadd("links:foo", ["bar", "baz"])
-      subject.upgrade_data(payload)
-      expect(subject.redis.sismember("linked_to:bar", "foo")).to be(true)
-      expect(subject.redis.sismember("linked_to:baz", "foo")).to be(true)
-    end
-
-    it "skips the update if it's already been done" do
-      expect(subject.redis).to receive(:keys).once.and_return([])
-      subject.upgrade_data(payload)
-      subject.upgrade_data(payload)
-    end
-  end
+  it { is_expected.not_to route("foo++bar").to(:increment) }
+  it { is_expected.not_to route("foo--bar").to(:decrement) }
 
   describe "#increment" do
     it "increases the term's score by one and says the new score" do
@@ -50,7 +45,7 @@ describe Lita::Handlers::Karma, lita_handler: true do
 
     it "matches multiple terms in one message" do
       send_message("foo++ bar++")
-      expect(replies).to eq(["foo: 1", "bar: 1"])
+      expect(replies.last).to eq("foo: 1; bar: 1")
     end
 
     it "doesn't start from zero if the term already has a positive score" do
@@ -86,7 +81,7 @@ describe Lita::Handlers::Karma, lita_handler: true do
 
     it "matches multiple terms in one message" do
       send_message("foo-- bar--")
-      expect(replies).to eq(["foo: -1", "bar: -1"])
+      expect(replies.last).to eq("foo: -1; bar: -1")
     end
 
     it "doesn't start from zero if the term already has a positive score" do
@@ -111,7 +106,12 @@ describe Lita::Handlers::Karma, lita_handler: true do
 
     it "matches multiple terms in one message" do
       send_message("foo~~ bar~~")
-      expect(replies).to eq(["foo: 0", "bar: 0"])
+      expect(replies.last).to eq("foo: 0; bar: 0")
+    end
+
+    it "doesn't match the same term multiple times in one message" do
+      send_message("foo~~ foo~~")
+      expect(replies.size).to eq(1)
     end
   end
 
@@ -244,26 +244,18 @@ MSG
   end
 
   describe "#modified" do
-    it "replies with the required format if a term is not provided" do
-      send_command("karma modified")
-      expect(replies.last).to match(/^Format:/)
-    end
-
-    it "replies with the required format if the term is an empty string" do
-      send_command("karma modified '   '")
-      expect(replies.last).to match(/^Format:/)
-    end
-
     it "replies with a message if the term hasn't been modified" do
       send_command("karma modified foo")
       expect(replies.last).to match(/never been modified/)
     end
 
-    it "lists users who have modified the given term" do
-      allow(Lita::User).to receive(:find_by_id).and_return(user)
-      send_message("foo++")
+    it "lists users who have modified the given term in count order" do
+      other_user = Lita::User.create("2", name: "Other User")
+      send_message("foo++", as: user)
+      send_message("foo++", as: user)
+      send_message("foo++", as: other_user)
       send_command("karma modified foo")
-      expect(replies.last).to eq(user.name)
+      expect(replies.last).to eq("#{user.name}, #{other_user.name}")
     end
   end
 
@@ -280,11 +272,6 @@ MSG
       expect(replies.last).to eq("foo: 0")
     end
 
-    it "replies with a warning if the term doesn't exist" do
-      send_command("karma delete foo")
-      expect(replies.last).to eq("foo does not exist.")
-    end
-
     it "matches terms exactly, including leading whitespace" do
       term = "  'foo bar* 'baz''/ :"
       subject.redis.zincrby("terms", 1, term)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-karma
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-23 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -108,9 +108,12 @@ files:
 - README.md
 - Rakefile
 - lib/lita-karma.rb
-- lib/lita/handlers/karma.rb
+- lib/lita/handlers/karma/chat.rb
+- lib/lita/handlers/karma/config.rb
+- lib/lita/handlers/karma/term.rb
 - lita-karma.gemspec
-- spec/lita/handlers/karma_spec.rb
+- locales/en.yml
+- spec/lita/handlers/karma/chat_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jimmycuadra/lita-karma
 licenses:
@@ -133,10 +136,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Lita handler for tracking karma points for arbitrary terms.
 test_files:
-- spec/lita/handlers/karma_spec.rb
+- spec/lita/handlers/karma/chat_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/lita/handlers/karma.rb

@@ -1,315 +0,0 @@
-require "lita"
-
-module Lita
-  module Handlers
-    # Tracks karma points for arbitrary terms.
-    class Karma < Handler
-      config :cooldown, types: [Integer, nil], default: 300
-      config :link_karma_threshold, types: [Integer, nil], default: 10
-      config :term_pattern, type: Regexp, default: /[\[\]\p{Word}\._|\{\}]{2,}/
-      config :term_normalizer do
-        validate do |value|
-          "must be a callable object" unless value.respond_to?(:call)
-        end
-      end
-
-      on :loaded, :upgrade_data
-      on :loaded, :define_routes
-
-      def upgrade_data(payload)
-        return if redis.exists("support:reverse_links")
-        redis.keys("links:*").each do |key|
-          term = key.sub(/^links:/, "")
-          redis.smembers(key).each do |link|
-            redis.sadd("linked_to:#{link}", term)
-          end
-        end
-        redis.incr("support:reverse_links")
-      end
-
-      def define_routes(payload)
-        define_static_routes
-        define_dynamic_routes(config.term_pattern.source)
-      end
-
-      def increment(response)
-        modify(response, 1)
-      end
-
-      def decrement(response)
-        modify(response, -1)
-      end
-
-      def check(response)
-        output = []
-
-        response.matches.each do |match|
-          term = normalize_term(match[0])
-          total_score, own_score, links = scores_for(term)
-
-          string = "#{term}: #{total_score}"
-          unless links.empty?
-            string << " (#{own_score}), linked to: #{links.join(", ")}"
-          end
-          output << string
-        end
-
-        response.reply *output
-      end
-
-      def list_best(response)
-        list(response, :zrevrange)
-      end
-
-      def list_worst(response)
-        list(response, :zrange)
-      end
-
-      def link(response)
-        response.matches.each do |match|
-          term1, term2 = normalize_term(match[0]), normalize_term(match[1])
-
-          if config.link_karma_threshold
-            threshold = config.link_karma_threshold.abs
-
-            _total_score, term2_score, _links = scores_for(term2)
-            _total_score, term1_score, _links = scores_for(term1)
-
-            if term1_score.abs < threshold || term2_score.abs < threshold
-              response.reply "Terms must have less than -#{threshold} or more than #{threshold} karma to be linked or linked to."
-              return
-            end
-          end
-
-          if redis.sadd("links:#{term1}", term2)
-            redis.sadd("linked_to:#{term2}", term1)
-            response.reply "#{term2} has been linked to #{term1}."
-          else
-            response.reply "#{term2} is already linked to #{term1}."
-          end
-        end
-      end
-
-      def unlink(response)
-        response.matches.each do |match|
-          term1, term2 = normalize_term(match[0]), normalize_term(match[1])
-
-          if redis.srem("links:#{term1}", term2)
-            redis.srem("linked_to:#{term2}", term1)
-            response.reply "#{term2} has been unlinked from #{term1}."
-          else
-            response.reply "#{term2} is not linked to #{term1}."
-          end
-        end
-      end
-
-      def modified(response)
-        term = normalize_term(response.args[1])
-
-        if term.empty?
-          response.reply "Format: #{robot.name}: karma modified TERM"
-          return
-        end
-
-        user_ids = redis.smembers("modified:#{term}")
-
-        if user_ids.empty?
-          response.reply "#{term} has never been modified."
-        else
-          output = user_ids.map do |id|
-            User.find_by_id(id).name
-          end.join(", ")
-          response.reply output
-        end
-      end
-
-      def delete(response)
-        term = response.message.body.sub(/^karma delete /, "")
-
-        redis.del("modified:#{term}")
-        redis.del("links:#{term}")
-        redis.smembers("linked_to:#{term}").each do |key|
-          redis.srem("links:#{key}", term)
-        end
-        redis.del("linked_to:#{term}")
-
-        if redis.zrem("terms", term)
-          response.reply("#{term} has been deleted.")
-        else
-          response.reply("#{term} does not exist.")
-        end
-      end
-
-      private
-
-      def cooling_down?(term, user_id, response)
-        ttl = redis.ttl("cooldown:#{user_id}:#{term}")
-
-        if ttl >= 0
-          cooldown_message =
-            "You cannot modify #{term} for another #{ttl} second"
-          cooldown_message << (ttl == 1 ? "." : "s.")
-          response.reply cooldown_message
-          return true
-        else
-          return false
-        end
-      end
-
-      def define_dynamic_routes(pattern)
-        self.class.route(
-          %r{(#{pattern})\+\+},
-          :increment,
-          help: { "TERM++" => "Increments TERM by one." }
-        )
-
-        self.class.route(
-          %r{(#{pattern})\-\-},
-          :decrement,
-          help: { "TERM--" => "Decrements TERM by one." }
-        )
-
-        self.class.route(
-          %r{(#{pattern})~~},
-          :check,
-          help: { "TERM~~" => "Shows the current karma of TERM." }
-        )
-
-        self.class.route(
-          %r{^(#{pattern})\s*\+=\s*(#{pattern})},
-          :link,
-          command: true,
-          help: {
-            "TERM1 += TERM2" => <<-HELP.chomp
-Links TERM2 to TERM1. TERM1's karma will then be displayed as the sum of its \
-own and TERM2's karma.
-HELP
-          }
-        )
-
-        self.class.route(
-          %r{^(#{pattern})\s*-=\s*(#{pattern})},
-          :unlink,
-          command: true,
-          help: {
-            "TERM1 -= TERM2" => <<-HELP.chomp
-Unlinks TERM2 from TERM1. TERM1's karma will no longer be displayed as the sum \
-of its own and TERM2's karma.
-HELP
-          }
-        )
-      end
-
-      def define_static_routes
-        self.class.route(
-          %r{^karma\s+worst},
-          :list_worst,
-          command: true,
-          help: {
-            "karma worst [N]" => <<-HELP.chomp
-Lists the bottom N terms by karma. N defaults to 5.
-HELP
-          }
-        )
-
-        self.class.route(
-          %r{^karma\s+best},
-          :list_best,
-          command: true,
-          help: {
-            "karma best [N]" => <<-HELP.chomp
-Lists the top N terms by karma. N defaults to 5.
-HELP
-          }
-        )
-
-        self.class.route(
-          %r{^karma\s+modified},
-          :modified,
-          command: true,
-          help: {
-            "karma modified TERM" => <<-HELP.chomp
-Lists the names of users who have upvoted or downvoted TERM.
-HELP
-          }
-        )
-
-        self.class.route(
-          %r{^karma\s+delete},
-          :delete,
-          command: true,
-          restrict_to: :karma_admins,
-          help: {
-            "karma delete TERM" => <<-HELP.chomp
-Permanently removes TERM and all its links. TERM is matched exactly as typed \
-and does not adhere to the usual pattern for terms.
-HELP
-          }
-        )
-
-        self.class.route(%r{^karma\s*$}, :list_best, command: true)
-      end
-
-      def modify(response, delta)
-        response.matches.each do |match|
-          term = normalize_term(match[0])
-          user_id = response.user.id
-
-          return if cooling_down?(term, user_id, response)
-
-          redis.zincrby("terms", delta, term)
-          redis.sadd("modified:#{term}", user_id)
-          set_cooldown(term, response.user.id)
-        end
-
-        check(response)
-      end
-
-      def normalize_term(term)
-        if config.term_normalizer
-          config.term_normalizer.call(term)
-        else
-          term.to_s.downcase.strip
-        end
-      end
-
-      def list(response, redis_command)
-        n = (response.args[1] || 5).to_i - 1
-        n = 25 if n > 25
-
-        terms_scores = redis.public_send(
-          redis_command, "terms", 0, n, with_scores: true
-        )
-
-        output = terms_scores.each_with_index.map do |term_score, index|
-          "#{index + 1}. #{term_score[0]} (#{term_score[1].to_i})"
-        end.join("\n")
-
-        if output.length == 0
-          response.reply "There are no terms being tracked yet."
-        else
-          response.reply output
-        end
-      end
-
-      def scores_for(term)
-        own_score = total_score = redis.zscore("terms", term).to_i
-        links = []
-
-        redis.smembers("links:#{term}").each do |link|
-          link_score = redis.zscore("terms", link).to_i
-          links << "#{link}: #{link_score}"
-          total_score += link_score
-        end
-
-        [total_score, own_score, links]
-      end
-
-      def set_cooldown(term, user_id)
-        redis.setex("cooldown:#{user_id}:#{term}", config.cooldown.to_i, 1) if config.cooldown
-      end
-    end
-
-    Lita.register_handler(Karma)
-  end
-end