lita-karma 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c32b6338811ce3ca6a1a5c9abf1dbb591bfe90a3
-  data.tar.gz: f83476d892d5f67a37510a60c1a33e53d6d5c3a1
+  metadata.gz: 970fdc7b7a7dd713d5aaa779ee54a03f4b7b11f9
+  data.tar.gz: 1cf49139dc0e119127dcc8625dbff430bc5c93b0
 SHA512:
-  metadata.gz: 110bbb250b54efc45e554bf135b05c19d50a4a3eaedb2b0b2dcd4339a750ae83c49dfe80f44f9d104c6cea49757a7720c900c632774bc1df8720c8ed67977b2d
-  data.tar.gz: 0990210987a83902b7f661fe77591d2a3b9bb814b33b49f62865128030e67c75709f08c03a3f658cc656235a77172e09572e203f29921b8b51e020b3f9e23b41
+  metadata.gz: 1af6f6ad8bb1afebb17ec8d591cb56ecbcce7411d6160faa678c524d654ff0a0f263727a01e93331a67936be40a371e21f5b3b58503c47d7180edc1b764a44b1
+  data.tar.gz: e1b5d78d0a2e76213dba98c55c8002822e3f10932a53606ae685f3d6b5862dc5defcbfe97d15771eafcc5df9961e3bb24fc8182b7521491ce0c596f1dbaf844d

data/.travis.yml

@@ -4,3 +4,7 @@ rvm:
 script: bundle exec rspec
 before_install:
   - gem update --system
+notifications:
+  webhooks:
+    urls:
+      - https://lita-freenode.herokuapp.com/travis

data/README.md

@@ -1,6 +1,6 @@
 # lita-karma
 
-[![Build Status](https://travis-ci.org/jimmycuadra/lita-karma.png)](https://travis-ci.org/jimmycuadra/lita-karma)
+[![Build Status](https://travis-ci.org/jimmycuadra/lita-karma.png?branch=master)](https://travis-ci.org/jimmycuadra/lita-karma)
 [![Code Climate](https://codeclimate.com/github/jimmycuadra/lita-karma.png)](https://codeclimate.com/github/jimmycuadra/lita-karma)
 [![Coverage Status](https://coveralls.io/repos/jimmycuadra/lita-karma/badge.png)](https://coveralls.io/r/jimmycuadra/lita-karma)
 
@@ -16,11 +16,24 @@ gem "lita-karma"
 
 ## Configuration
 
-lita-karma has one option, the cooldown, which 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. The default is 300 (5 minutes). Set it to `nil` to disable rate limiting.
+### 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.
+* `term_pattern` (Regexp) - Determines what Lita will recognize as a valid term for tracking karma. Default: `//[\[\]\w\._|\{\}]{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.
+
+
+### Example
+
+This example configuration sets the cooldown to 10 minutes and changes the term pattern and normalization to allow multi-word terms bounded by `<>` or `:`, as previous versions of lita-karma did by default.
+
+``` ruby
 Lita.configure do |config|
   config.handlers.karma.cooldown = 600
+  config.handlers.karma.term_pattern = /[<:][^>:]+[>:]/
+  config.handlers.karma.term_normalizer = lambda do |term|
+    term.to_s.downcase.strip.sub(/[<:]([^>:]+)[>:]/, '\1')
+  end
 end
 ```
 
@@ -32,14 +45,6 @@ Lita will add a karma point whenever it hears a term upvoted:
 term++
 ```
 
-You can also give karma to multi-worded terms or terms with symbols by bounding them with `<>` or `::`:
-
-```
-:Linus Torvalds:++
-
-<C++>++
-```
-
 It will subtract a karma point whenever it hears a term downvoted:
 
 ```
@@ -97,6 +102,14 @@ 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.
 
+To permanently delete a term and all its links:
+
+```
+Lita: karma delete TERM
+```
+
+Note that when deleting a term, the term will be matched exactly as typed, including leading whitespace (the single space after the word "delete" is not counted) and other patterns which would not normally match as a valid term. This can be useful if you decide to change the term pattern or normalization and want to clean up previous data that is no longer valid. Deleting a term requires the user to be a member of the `:karma_admins` authorization group.
+
 ## License
 
 [MIT](http://opensource.org/licenses/MIT)

data/lib/lita/handlers/karma.rb

@@ -2,61 +2,40 @@ require "lita"
 
 module Lita
   module Handlers
+    # Tracks karma points for arbitrary terms.
     class Karma < Handler
-      TERM_REGEX = /[<:][^>:]+[>:]|[\[\]\w\._\-|\{\}]{2,}/
-
-      route %r{(#{TERM_REGEX.source})\+\+}, :increment, help: {
-        "TERM++" => "Increments TERM by one."
-      }
-      route %r{(#{TERM_REGEX.source})\-\-}, :decrement, help: {
-        "TERM--" => "Decrements TERM by one."
-      }
-      route %r{(#{TERM_REGEX.source})~~}, :check, help: {
-        "TERM~~" => "Shows the current karma of TERM."
-      }
-      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
-      }
-      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
-      }
-      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
-      }
-      route %r{^karma\s*$}, :list_best, command: true
-      route(
-        %r{^(#{TERM_REGEX.source})\s*\+=\s*(#{TERM_REGEX.source})},
-        :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
-        }
-      )
-      route(
-        %r{^(#{TERM_REGEX.source})\s*-=\s*(#{TERM_REGEX.source})},
-        :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
-        }
-      )
+      TERM_PATTERN = /[\[\]\w\._|\{\}]{2,}/
+
+      class << self
+        attr_accessor :term_pattern
+      end
+
+      on :loaded, :upgrade_data
+      on :loaded, :define_routes
 
       def self.default_config(config)
         config.cooldown = 300
       end
 
+      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)
+        self.class.term_pattern =
+          Lita.config.handlers.karma.term_pattern || TERM_PATTERN
+
+        define_static_routes
+        define_dynamic_routes(term_pattern.source)
+      end
+
       def increment(response)
         modify(response, 1)
       end
@@ -70,18 +49,11 @@ HELP
 
         response.matches.each do |match|
           term = normalize_term(match[0])
-          own_score = 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}"
-            score += link_score
-          end
+          total_score, own_score, links = scores_for(term)
 
-          string = "#{term}: #{score}"
+          string = "#{term}: #{total_score}"
           unless links.empty?
-            string << " (#{own_score}), linked to: "
-            string << links.join(", ")
+            string << " (#{own_score}), linked to: #{links.join(", ")}"
           end
           output << string
         end
@@ -102,6 +74,7 @@ HELP
           term1, term2 = normalize_term(match[0]), normalize_term(match[1])
 
           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}."
@@ -114,6 +87,7 @@ HELP
           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}."
@@ -141,38 +115,156 @@ HELP
         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
 
-          ttl = redis.ttl("cooldown:#{response.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
-          else
-            redis.zincrby("terms", delta, term)
-            redis.sadd("modified:#{term}", response.user.id)
-            cooldown = Lita.config.handlers.karma.cooldown
-            if cooldown
-              redis.setex(
-                "cooldown:#{response.user.id}:#{term}",
-                cooldown.to_i,
-                1
-              )
-            end
-          end
+          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)
-        term.to_s.downcase.strip.sub(/[<:]([^>:]+)[>:]/, '\1')
+        term_normalizer = Lita.config.handlers.karma.term_normalizer
+
+        if term_normalizer.respond_to?(:call)
+          term_normalizer.call(term)
+        else
+          term.to_s.downcase.strip
+        end
       end
 
       def list(response, redis_command)
@@ -192,6 +284,35 @@ HELP
           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)
+        cooldown = Lita.config.handlers.karma.cooldown
+
+        if cooldown
+          redis.setex(
+            "cooldown:#{user_id}:#{term}",
+            cooldown.to_i,
+            1
+          )
+        end
+      end
+
+      def term_pattern
+        self.class.term_pattern
+      end
     end
 
     Lita.register_handler(Karma)

data/lita-karma.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-karma"
-  spec.version       = "1.2.0"
+  spec.version       = "2.0.0"
   spec.authors       = ["Jimmy Cuadra"]
   spec.email         = ["jimmy@jimmycuadra.com"]
   spec.description   = %q{A Lita handler for tracking karma points for arbitrary terms.}
@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "lita", "~> 2.0"
+  spec.add_runtime_dependency "lita", "~> 2.6"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/lita/handlers/karma_spec.rb

@@ -1,7 +1,13 @@
 require "spec_helper"
 
 describe Lita::Handlers::Karma, lita_handler: true do
-  before { Lita.config.handlers.karma.cooldown = nil }
+  let(:payload) { double("payload") }
+
+  before do
+    Lita.config.handlers.karma.cooldown = nil
+    described_class.routes.clear
+    subject.define_routes(payload)
+  end
 
   it { routes("foo++").to(:increment) }
   it { routes("foo--").to(:decrement) }
@@ -9,10 +15,29 @@ describe Lita::Handlers::Karma, lita_handler: true do
   it { routes_command("karma best").to(:list_best) }
   it { routes_command("karma worst").to(:list_worst) }
   it { routes_command("karma modified").to(:modified) }
+  it { routes_command("karma delete").to(:delete) }
   it { routes_command("karma").to(:list_best) }
   it { routes_command("foo += bar").to(:link) }
   it { routes_command("foo -= bar").to(:unlink) }
   it { doesnt_route("+++++").to(:increment) }
+  it { doesnt_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
 
   describe "#increment" do
     it "increases the term's score by one and says the new score" do
@@ -43,16 +68,6 @@ describe Lita::Handlers::Karma, lita_handler: true do
       send_message("FOO++")
       expect(replies.last).to eq("foo: 2")
     end
-
-    it "matches multi-word terms bounded by delimeters" do
-      send_message(":Some Thing:++")
-      expect(replies.last).to eq("some thing: 1")
-    end
-
-    it "matches terms with symbols that are bounded by delimeters" do
-      send_message("<C++>++")
-      expect(replies.last).to eq("c++: 1")
-    end
   end
 
   describe "#decrement" do
@@ -78,11 +93,6 @@ describe Lita::Handlers::Karma, lita_handler: true do
       send_message("foo--")
       expect(replies.last).to match(/cannot modify foo/)
     end
-
-    it "matches multi-word terms bounded by delimeters" do
-      send_message(":Some Thing:--")
-      expect(replies.last).to eq("some thing: -1")
-    end
   end
 
   describe "#check" do
@@ -95,11 +105,6 @@ describe Lita::Handlers::Karma, lita_handler: true do
       send_message("foo~~ bar~~")
       expect(replies).to eq(["foo: 0", "bar: 0"])
     end
-
-    it "matches multi-word terms bounded by delimeters" do
-      send_message(":Some Thing:~~")
-      expect(replies.last).to eq("some thing: 0")
-    end
   end
 
   describe "#list" do
@@ -214,4 +219,86 @@ MSG
       expect(replies.last).to eq(user.name)
     end
   end
+
+  describe "#delete" do
+    before do
+      allow(Lita::Authorization).to receive(:user_in_group?).and_return(true)
+    end
+
+    it "deletes the term" do
+      send_message("foo++")
+      send_command("karma delete foo")
+      expect(replies.last).to eq("foo has been deleted.")
+      send_message("foo~~")
+      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)
+      send_command("karma delete #{term}")
+      expect(replies.last).to include("has been deleted")
+    end
+
+    it "clears the modification list" do
+      send_message("foo++")
+      send_command("karma delete foo")
+      send_command("karma modified foo")
+      expect(replies.last).to eq("foo has never been modified.")
+    end
+
+    it "clears the deleted term's links" do
+      send_command("foo += bar")
+      send_command("foo += baz")
+      send_command("karma delete foo")
+      send_message("foo++")
+      expect(replies.last).to eq("foo: 1")
+    end
+
+    it "clears links from other terms connected to the deleted term" do
+      send_command("bar += foo")
+      send_command("baz += foo")
+      send_command("karma delete foo")
+      send_message("bar++")
+      expect(replies.last).to eq("bar: 1")
+      send_message("baz++")
+      expect(replies.last).to eq("baz: 1")
+    end
+  end
+
+  describe "custom term patterns and normalization" do
+    before do
+      Lita.config.handlers.karma.term_pattern = /[<:]([^>:]+)[>:]/
+      Lita.config.handlers.karma.term_normalizer = lambda do |term|
+        term.to_s.downcase.strip.sub(/[<:]([^>:]+)[>:]/, '\1')
+      end
+      described_class.routes.clear
+      subject.define_routes(payload)
+    end
+
+    it "increments multi-word terms bounded by delimeters" do
+      send_message(":Some Thing:++")
+      expect(replies.last).to eq("some thing: 1")
+    end
+
+    it "increments terms with symbols that are bounded by delimeters" do
+      send_message("<C++>++")
+      expect(replies.last).to eq("c++: 1")
+    end
+
+    it "decrements multi-word terms bounded by delimeters" do
+      send_message(":Some Thing:--")
+      expect(replies.last).to eq("some thing: -1")
+    end
+
+    it "checks multi-word terms bounded by delimeters" do
+      send_message(":Some Thing:~~")
+      expect(replies.last).to eq("some thing: 0")
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-karma
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-20 00:00:00.000000000 Z
+date: 2013-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -132,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.3
 signing_key: 
 specification_version: 4
 summary: A Lita handler for tracking karma points for arbitrary terms.