lita-karma 0.0.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4bde948c2cf3b2c372b3cad86e784ba89fd8bf7b
-  data.tar.gz: f52907190d12603f369272c9c4ca113188a2270d
+  metadata.gz: 666d042af696f1eb6b735cd531c3ea31a8485987
+  data.tar.gz: c445dfd3e021e96dda584674ba75953fdf28335f
 SHA512:
-  metadata.gz: 1d81fd849e16e9f627ad271e253ac473e40094caf44b3ed535d1c245ba3ae6213424947bc8375b678e8967a844b109b3639ea7f7d05a5a2150ff6c26a719e4af
-  data.tar.gz: 093d8d92a400eed65a35ffaa84f0f3ef3515da74aedfeae3b6129243d92c00b18b4bb83a25ee632ae71bd37cc3df21b9fad08e9b5041e14fab7826d4d0fd9c5d
+  metadata.gz: 0863e9bd71df183c70fa99ef8f6070839016f5b174496913c41406ea38ccf3ff6219bf63b79746748e294020accd09e553c2475b74890cb58b32a4845d039e39
+  data.tar.gz: 0c39702837bd97f9cabca8fb076e97a9db599d940007fff164690d8fe1c2f5d3993e79004f35f7355ab329fb8d92b5172a48d27903572cd576c95ddb22462cbf

data/lib/lita/handlers/karma.rb

@@ -3,43 +3,42 @@ require "lita"
 module Lita
   module Handlers
     class Karma < Handler
-      def self.help
-        name = Lita.config.robot.mention_name || Lita.config.robot.name
-
-        {
-          "TERM++" => "Increments TERM by one.",
-          "TERM--" => "Decrements TERM by one.",
-          "TERM~~" => "Shows the current karma of TERM.",
-          "#{name}: karma best [N]" => "Lists the top N terms by karma. N defaults to 5.",
-          "#{name}: karma worst [N]" => "Lists the bottom N terms by karma. N defaults to 5.",
-          "#{name}: karma modified TERM" => "Lists the names of users who have upvoted or downvoted TERM.",
-          "#{name}: TERM1 += TERM2" => "Links TERM2 to TERM1. TERM1's karma will then be displayed as the sum of its own and TERM2's karma.",
-          "#{name}: TERM1 -= TERM2" => "Unlinks TERM2 from TERM1. TERM1's karma will no longer be displayed as the sum of its own and TERM2's karma.",
-        }
+      route %r{([^\s]{2,})\+\+}, :increment, help: { "TERM++" => "Increments TERM by one." }
+      route %r{([^\s]{2,})\-\-}, :decrement, help: { "TERM--" => "Decrements TERM by one." }
+      route %r{([^\s]{2,})~~}, :check, help: { "TERM~~" => "Shows the current karma of TERM." }
+      route %r{^karma\s+worst}, :list_worst, command: true, help: {
+        "karma worst [N]" => "Lists the bottom N terms by karma. N defaults to 5."
+      }
+      route %r{^karma\s+best}, :list_best, command: true, help: {
+        "karma best [N]" => "Lists the top N terms by karma. N defaults to 5."
+      }
+      route %r{^karma\s+modified}, :modified, command: true, help: {
+        "karma modified TERM" => "Lists the names of users who have upvoted or downvoted TERM."
+      }
+      route %r{^karma\s*$}, :list_best, command: true
+      route %r{^([^\s]{2,})\s*\+=\s*([^\s]{2,})}, :link, command: true, help: {
+        "TERM1 += TERM2" => "Links TERM2 to TERM1. TERM1's karma will then be displayed as the sum of its own and TERM2's karma."
+      }
+      route %r{^([^\s]{2,})\s*-=\s*([^\s]{2,})}, :unlink, command: true, help: {
+        "TERM1 -= TERM2" => "Unlinks TERM2 from TERM1. TERM1's karma will no longer be displayed as the sum of its own and TERM2's karma."
+      }
+
+      def self.default_config(config)
+        config.cooldown = 300
       end
 
-      route %r{([^\s]{2,})\+\+}, to: :increment
-      route %r{([^\s]{2,})\-\-}, to: :decrement
-      route %r{([^\s]{2,})~~}, to: :check
-      route %r{^karma\s+worst}, to: :list_worst, command: true
-      route %r{^karma\s+best}, to: :list_best, command: true
-      route %r{^karma\s+modified}, to: :modified, command: true
-      route %r{^karma\s*$}, to: :list_best, command: true
-      route %r{^([^\s]{2,})\s*\+=\s*([^\s]{2,})}, to: :link, command: true
-      route %r{^([^\s]{2,})\s*-=\s*([^\s]{2,})}, to: :unlink, command: true
-
-      def increment(matches)
-        modify(matches, 1)
+      def increment(response)
+        modify(response, 1)
       end
 
-      def decrement(matches)
-        modify(matches, -1)
+      def decrement(response)
+        modify(response, -1)
       end
 
-      def check(matches)
+      def check(response)
         output = []
 
-        matches.each do |match|
+        response.matches.each do |match|
           term = match[0]
           own_score = score = redis.zscore("terms", term).to_i
           links = []
@@ -57,86 +56,93 @@ module Lita
           output << string
         end
 
-        reply *output
+        response.reply *output
       end
 
-      def list_best(matches)
-        list(:zrevrange)
+      def list_best(response)
+        list(response, :zrevrange)
       end
 
-      def list_worst(matches)
-        list(:zrange)
+      def list_worst(response)
+        list(response, :zrange)
       end
 
-      def link(matches)
-        matches.each do |match|
+      def link(response)
+        response.matches.each do |match|
           term1, term2 = match
 
           if redis.sadd("links:#{term1}", term2)
-            reply "#{term2} has been linked to #{term1}."
+            response.reply "#{term2} has been linked to #{term1}."
           else
-            reply "#{term2} is already linked to #{term1}."
+            response.reply "#{term2} is already linked to #{term1}."
           end
         end
       end
 
-      def unlink(matches)
-        matches.each do |match|
+      def unlink(response)
+        response.matches.each do |match|
           term1, term2 = match
 
           if redis.srem("links:#{term1}", term2)
-            reply "#{term2} has been unlinked from #{term1}."
+            response.reply "#{term2} has been unlinked from #{term1}."
           else
-            reply "#{term2} is not linked to #{term1}."
+            response.reply "#{term2} is not linked to #{term1}."
           end
         end
       end
 
-      def modified(matches)
-        term = args[1]
+      def modified(response)
+        term = response.args[1]
 
         if term.nil? || term.strip.empty?
-          reply "Format: #{robot.name}: karma modified TERM"
+          response.reply "Format: #{robot.name}: karma modified TERM"
           return
         end
 
         user_ids = redis.smembers("modified:#{term}")
 
         if user_ids.empty?
-          reply "#{term} has never been modified."
+          response.reply "#{term} has never been modified."
         else
-          reply user_ids.map { |id| User.find_by_id(id).name }.join(", ")
+          output = user_ids.map do |id|
+            User.find_by_id(id).name
+          end.join(", ")
+          response.reply output
         end
       end
 
       private
 
-      def modify(matches, delta)
-        matches.each do |match|
+      def modify(response, delta)
+        response.matches.each do |match|
           term = match[0]
 
-          ttl = redis.ttl("cooldown:#{user.id}:#{term}")
+          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.")
-            reply cooldown_message
+            response.reply cooldown_message
             return
           else
             redis.zincrby("terms", delta, term)
-            redis.sadd("modified:#{term}", user.id)
+            redis.sadd("modified:#{term}", response.user.id)
             cooldown = Lita.config.handlers.karma.cooldown
             if cooldown
-              redis.setex("cooldown:#{user.id}:#{term}", cooldown.to_i, 1)
+              redis.setex(
+                "cooldown:#{response.user.id}:#{term}",
+                cooldown.to_i,
+                1
+              )
             end
           end
         end
 
-        check(matches)
+        check(response)
       end
 
-      def list(redis_command)
-        n = (args[1] || 5).to_i - 1
+      def list(response, redis_command)
+        n = (response.args[1] || 5).to_i - 1
 
         terms_scores = redis.public_send(
           redis_command, "terms", 0, n, with_scores: true
@@ -147,15 +153,13 @@ module Lita
         end.join("\n")
 
         if output.length == 0
-          reply "There are no terms being tracked yet."
+          response.reply "There are no terms being tracked yet."
         else
-          reply output
+          response.reply output
         end
       end
     end
 
-    Lita.config.handlers.karma = Config.new
-    Lita.config.handlers.karma.cooldown = 300
     Lita.register_handler(Karma)
   end
 end

data/lita-karma.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-karma"
-  spec.version       = "0.0.3"
+  spec.version       = "1.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", "~> 1.0"
+  spec.add_runtime_dependency "lita", "~> 2.0"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/lita/handlers/karma_spec.rb

@@ -1,196 +1,190 @@
 require "spec_helper"
 
-describe Lita::Handlers::Karma, lita: true do
+describe Lita::Handlers::Karma, lita_handler: true do
   before { Lita.config.handlers.karma.cooldown = nil }
 
   it { routes("foo++").to(:increment) }
   it { routes("foo--").to(:decrement) }
   it { routes("foo~~").to(:check) }
-  it { routes("#{robot.name}: karma best").to(:list_best) }
-  it { routes("#{robot.name}: karma worst").to(:list_worst) }
-  it { routes("#{robot.name}: karma modified").to(:modified) }
-  it { routes("#{robot.name}: karma").to(:list_best) }
-  it { routes("#{robot.name}: foo += bar").to(:link) }
-  it { routes("#{robot.name}: foo -= bar").to(:unlink) }
-
-  describe ".help" do
-    it "returns a hash of command help" do
-      expect(described_class.help).to be_a(Hash)
-    end
-  end
+  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").to(:list_best) }
+  it { routes_command("foo += bar").to(:link) }
+  it { routes_command("foo -= bar").to(:unlink) }
 
   describe "#increment" do
     it "increases the term's score by one and says the new score" do
-      expect_reply("foo: 1")
-      send_test_message("foo++")
+      send_message("foo++")
+      expect(replies.last).to eq("foo: 1")
     end
 
     it "matches multiple terms in one message" do
-      expect_replies("foo: 1", "bar: 1")
-      send_test_message("foo++ bar++")
+      send_message("foo++ bar++")
+      expect(replies).to eq(["foo: 1", "bar: 1"])
     end
 
     it "doesn't start from zero if the term already has a positive score" do
-      send_test_message("foo++")
-      expect_reply("foo: 2")
-      send_test_message("foo++")
+      send_message("foo++")
+      send_message("foo++")
+      expect(replies.last).to eq("foo: 2")
     end
 
     it "replies with a warning if term increment is on cooldown" do
       Lita.config.handlers.karma.cooldown = 10
-      send_test_message("foo++")
-      expect_reply(/cannot modify foo/)
-      expect_no_reply(/foo:/)
-      send_test_message("foo++")
+      send_message("foo++")
+      send_message("foo++")
+      expect(replies.last).to match(/cannot modify foo/)
     end
   end
 
   describe "#decrement" do
     it "decreases the term's score by one and says the new score" do
-      expect_reply("foo: -1")
-      send_test_message("foo--")
+      send_message("foo--")
+      expect(replies.last).to eq("foo: -1")
     end
 
     it "matches multiple terms in one message" do
-      expect_replies("foo: -1", "bar: -1")
-      send_test_message("foo-- bar--")
+      send_message("foo-- bar--")
+      expect(replies).to eq(["foo: -1", "bar: -1"])
     end
 
     it "doesn't start from zero if the term already has a positive score" do
-      send_test_message("foo++")
-      expect_reply("foo: 0")
-      send_test_message("foo--")
+      send_message("foo++")
+      send_message("foo--")
+      expect(replies.last).to eq("foo: 0")
     end
 
     it "replies with a warning if term increment is on cooldown" do
       Lita.config.handlers.karma.cooldown = 10
-      send_test_message("foo--")
-      expect_reply(/cannot modify foo/)
-      expect_no_reply(/foo:/)
-      send_test_message("foo--")
+      send_message("foo--")
+      send_message("foo--")
+      expect(replies.last).to match(/cannot modify foo/)
     end
   end
 
   describe "#check" do
     it "says the term's current score" do
-      expect_reply("foo: 0")
-      send_test_message("foo~~")
+      send_message("foo~~")
+      expect(replies.last).to eq("foo: 0")
     end
 
     it "matches multiple terms in one message" do
-      expect_replies("foo: 0", "bar: 0")
-      send_test_message("foo~~ bar~~")
+      send_message("foo~~ bar~~")
+      expect(replies).to eq(["foo: 0", "bar: 0"])
     end
   end
 
   describe "#list" do
     it "replies with a warning if there are no terms" do
-      expect_reply(/no terms being tracked/)
-      send_test_message("#{robot.name}: karma")
+      send_command("karma")
+      expect(replies.last).to match(/no terms being tracked/)
     end
 
     context "with modified terms" do
       before do
-        send_test_message(
+        send_message(
           "one++ one++ one++ two++ two++ three++ four++ four-- five--"
         )
       end
 
       it "lists the top 5 terms by default" do
-        expect_reply <<-MSG.chomp
+        send_command("karma")
+        expect(replies.last).to eq <<-MSG.chomp
 1. one (3)
 2. two (2)
 3. three (1)
 4. four (0)
 5. five (-1)
 MSG
-        send_test_message("#{robot.name}: karma")
       end
 
       it 'lists the bottom 5 terms when passed "worst"' do
-        expect_reply <<-MSG.chomp
+        send_command("karma worst")
+        expect(replies.last).to eq <<-MSG.chomp
 1. five (-1)
 2. four (0)
 3. three (1)
 4. two (2)
 5. one (3)
 MSG
-        send_test_message("#{robot.name}: karma worst")
       end
 
       it "limits the list to the count passed as the second argument" do
-        expect_reply <<-MSG.chomp
+        send_command("karma best 2")
+        expect(replies.last).to eq <<-MSG.chomp
 1. one (3)
 2. two (2)
 MSG
-        send_test_message("#{robot.name}: karma best 2")
       end
     end
   end
 
   describe "#link" do
     it "says that it's linked term 2 to term 1" do
-      expect_reply("bar has been linked to foo.")
-      send_test_message("#{robot.name}: foo += bar")
+      send_command("foo += bar")
+      expect(replies.last).to eq("bar has been linked to foo.")
     end
 
     it "says that term 2 was already linked to term 1 if it was" do
-      send_test_message("#{robot.name}: foo += bar")
-      expect_reply("bar is already linked to foo.")
-      send_test_message("#{robot.name}: foo += bar")
+      send_command("foo += bar")
+      send_command("foo += bar")
+      expect(replies.last).to eq("bar is already linked to foo.")
     end
 
     it "causes term 1's score to be modified by term 2's" do
-      send_test_message("foo++ bar++ baz++")
-      send_test_message("#{robot.name}: foo += bar")
-      send_test_message("#{robot.name}: foo += baz")
-      expect_reply(/foo: 3 \(1\), linked to: ba[rz]: 1, ba[rz]: 1/)
-      send_test_message("foo~~")
+      send_message("foo++ bar++ baz++")
+      send_command("foo += bar")
+      send_command("foo += baz")
+      send_message("foo~~")
+      expect(replies.last).to match(
+        /foo: 3 \(1\), linked to: ba[rz]: 1, ba[rz]: 1/
+      )
     end
   end
 
   describe "#unlink" do
     it "says that it's unlinked term 2 from term 1" do
-      send_test_message("#{robot.name}: foo += bar")
-      expect_reply("bar has been unlinked from foo.")
-      send_test_message("#{robot.name}: foo -= bar")
+      send_command("foo += bar")
+      send_command("foo -= bar")
+      expect(replies.last).to eq("bar has been unlinked from foo.")
     end
 
     it "says that term 2 was not linked to term 1 if it wasn't" do
-      expect_reply("bar is not linked to foo.")
-      send_test_message("#{robot.name}: foo -= bar")
+      send_command("foo -= bar")
+      expect(replies.last).to eq("bar is not linked to foo.")
     end
 
     it "causes term 1's score to stop being modified by term 2's" do
-      send_test_message("foo++ bar++")
-      send_test_message("#{robot.name}: foo += bar")
-      send_test_message("#{robot.name}: foo -= bar")
-      expect_reply("foo: 1")
-      send_test_message("foo~~")
+      send_message("foo++ bar++")
+      send_command("foo += bar")
+      send_command("foo -= bar")
+      send_message("foo~~")
+      expect(replies.last).to eq("foo: 1")
     end
   end
 
   describe "#modified" do
     it "replies with the required format if a term is not provided" do
-      expect_reply(/^Format:/)
-      send_test_message("#{robot.name}: karma modified")
+      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
-      expect_reply(/^Format:/)
-      send_test_message("#{robot.name}: karma modified '   '")
+      send_command("karma modified '   '")
+      expect(replies.last).to match(/^Format:/)
     end
 
     it "replies with a message if the term hasn't been modified" do
-      expect_reply(/never been modified/)
-      send_test_message("#{robot.name}: karma modified foo")
+      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_test_message("foo++")
-      expect_reply(user.name)
-      send_test_message("#{robot.name}: karma modified foo")
+      send_message("foo++")
+      send_command("karma modified foo")
+      expect(replies.last).to eq(user.name)
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,7 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]
-SimpleCov.start
+SimpleCov.start { add_filter "/spec/" }
 
 require "lita-karma"
 require "lita/rspec"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-karma
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-24 00:00:00.000000000 Z
+date: 2013-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -103,7 +103,6 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
-- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile

data/CHANGELOG.md

@@ -1,16 +0,0 @@
-# Changelog
-
-## 0.0.3 (June 23, 2013)
-
-* Added command help.
-* When a user attempts to modify a term and is rate limited, Lita no longer also displays the term's current karma.
-
-## 0.0.2 (June 22, 2013)
-
-* Added term linking.
-* Added `karma modified` command.
-* Added rate limiting via `config.handlers.karma.cooldown`.
-
-## 0.0.1 (June 15, 2003)
-
-Initial release.