lita-conferenz 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4b5b603523ab6945ca312403138be66d58bb927
+  data.tar.gz: 94583855cb7b7a9a8545ece100e7db0b8202f8bf
+SHA512:
+  metadata.gz: 6e3089bc86479ea11ee2da7a1b1ba80594883bd9b443481ae74d6cb482426f30b6d6741cf4d788b0c19672b4851bb98c1d069858e440666953a0b54e99ba2454
+  data.tar.gz: b54af757417eff2d669d94fe99b6b4e2092375d9c78a3bcb69a801c4ec7d2cf94eac855d5ed1cd6d76356dd63c0b2776968c071e039a814d6d3951f14eb5c355

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita-conferenz.rb

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

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

@@ -0,0 +1,205 @@
+module Lita::Handlers::Conferenz
+  class Chat < Lita::Handler
+    namespace "conferenz"
+
+    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(/^conferenz 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{^conferenz\s+worst},
+        :list_worst,
+        command: true,
+        help: { t("help.list_worst_key") => t("help.list_worst_value") }
+      )
+
+      self.class.route(
+        %r{^conferenz\s+best},
+        :list_best,
+        command: true,
+        help: { t("help.list_best_key") => t("help.list_best_value") }
+      )
+
+      self.class.route(
+        %r{^conferenz\s+modified\s+.+},
+        :modified,
+        command: true,
+        help: { t("help.modified_key") => t("help.modified_value") }
+      )
+
+      self.class.route(
+        %r{^conferenz\s+delete},
+        :delete,
+        command: true,
+        restrict_to: :conferenz_admins,
+        help: { t("help.delete_key") => t("help.delete_value") }
+      )
+
+      self.class.route(%r{^conferenz\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 conferenz
+    # modifications, force conferenz 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::Conferenz::Chat)

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

@@ -0,0 +1,20 @@
+module Lita::Handlers::Conferenz
+  class Config < Lita::Handler
+    namespace "conferenz"
+
+    default_term_normalizer = proc do |term|
+      term.to_s.downcase.strip
+    end
+
+    config :cooldown, types: [Integer, nil], default: 0
+    config :link_conferenz_threshold, types: [Integer, nil], default: 0
+    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::Conferenz::Config)

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

@@ -0,0 +1,153 @@
+ module Lita::Handlers::Conferenz
+  class Term
+    include Lita::Handler::Common
+
+    namespace "conferenz"
+
+    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
+    alias_method :==, :eql?
+
+    def hash
+      term.hash
+    end
+
+    def increment(user)
+      modify(user, 1)
+    end
+
+    def link(other)
+      if config.link_conferenz_threshold
+        threshold = config.link_conferenz_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-conferenz.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-conferenz"
+  spec.version       = "1.0.1"
+  spec.authors       = ["Piotr Limanowski"]
+  spec.email         = ["plimanowski+conferenz@gmail.com"]
+  spec.description   = %q{A Lita handler for tracking conferences attendance.}
+  spec.summary       = %q{A Lita handler for tracking conferences attendance.}
+  spec.homepage      = "https://github.com/peel/conferenz"
+  spec.license       = "MIT"
+  spec.metadata      = { "lita_plugin_type" => "handler" }
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "lita", ">= 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

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/conferenz/chat_spec.rb

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+require "spec_helper"
+
+describe Lita::Handlers::Conferenz::Chat, lita_handler: true do
+  let(:payload) { double("payload") }
+
+  prepend_before { registry.register_handler(Lita::Handlers::Conferenz::Config) }
+
+  before do
+    registry.config.handlers.conferenz.cooldown = nil
+    registry.config.handlers.conferenz.link_karma_threshold = nil
+    described_class.routes.clear
+    subject.define_routes(payload)
+  end
+
+  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("conferenz best").to(:list_best) }
+  it { is_expected.to route_command("conferenz worst").to(:list_worst) }
+  it { is_expected.to route_command("conferenz modified foo").to(:modified) }
+  it do
+    is_expected.to route_command("conferenz delete").with_authorization_for(:karma_admins).to(:delete)
+  end
+  it { is_expected.to route_command("conferenz").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) }
+  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
+      send_message("foo++")
+      expect(replies.last).to eq("foo: 1")
+    end
+
+    it "matches multiple terms in one message" do
+      send_message("foo++ bar++")
+      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
+      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
+      registry.config.handlers.conferenz.cooldown = 10
+      send_message("foo++")
+      send_message("foo++")
+      expect(replies.last).to match(/cannot modify foo/)
+    end
+
+    it "is case insensitive" do
+      send_message("foo++")
+      send_message("FOO++")
+      expect(replies.last).to eq("foo: 2")
+    end
+
+    it "handles Unicode word characters" do
+      send_message("föö++")
+      expect(replies.last).to eq("föö: 1")
+    end
+  end
+
+  describe "#decrement" do
+    it "decreases the term's score by one and says the new score" do
+      send_message("foo--")
+      expect(replies.last).to eq("foo: -1")
+    end
+
+    it "matches multiple terms in one message" do
+      send_message("foo-- bar--")
+      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
+      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
+      registry.config.handlers.conferenz.cooldown = 10
+      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
+      send_message("foo~~")
+      expect(replies.last).to eq("foo: 0")
+    end
+
+    it "matches multiple terms in one message" do
+      send_message("foo~~ bar~~")
+      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
+
+  describe "#list" do
+    it "replies with a warning if there are no terms" do
+      send_command("conferenz")
+      expect(replies.last).to match(/no terms being tracked/)
+    end
+
+    context "with modified terms" do
+      before do
+        send_message(
+          "one++ one++ one++ two++ two++ three++ four++ four-- five--"
+        )
+      end
+
+      it "lists the top 5 terms by default" do
+        send_command("conferenz")
+        expect(replies.last).to eq <<-MSG.chomp
+1. one (3)
+2. two (2)
+3. three (1)
+4. four (0)
+5. five (-1)
+MSG
+      end
+
+      it 'lists the bottom 5 terms when passed "worst"' do
+        send_command("conferenz worst")
+        expect(replies.last).to eq <<-MSG.chomp
+1. five (-1)
+2. four (0)
+3. three (1)
+4. two (2)
+5. one (3)
+MSG
+      end
+
+      it "limits the list to the count passed as the second argument" do
+        send_command("conferenz best 2")
+        expect(replies.last).to eq <<-MSG.chomp
+1. one (3)
+2. two (2)
+MSG
+      end
+    end
+  end
+
+  describe "#link" do
+    it "says that it's linked term 2 to term 1" do
+      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_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_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
+
+    context "when link_karma_threshold is set" do
+      before do
+        registry.config.handlers.conferenz.link_karma_threshold = 1
+      end
+
+      it "doesn't allow a term to be linked if both are below the threshold" do
+        send_command("foo += bar")
+        expect(replies.last).to include("must have less than")
+      end
+
+      it "doesn't allow a term to be linked if it's below the threshold" do
+        send_command("foo++")
+        send_command("foo += bar")
+        expect(replies.last).to include("must have less than")
+      end
+
+      it "doesn't allow a term to be linked to another term below the threshold" do
+        send_command("bar++")
+        send_command("foo += bar")
+        expect(replies.last).to include("must have less than")
+      end
+
+      it "allows links if both terms meet the threshold" do
+        send_command("foo++ bar++")
+        send_command("foo += bar")
+        expect(replies.last).to include("has been linked")
+        send_command("bar += foo")
+        expect(replies.last).to include("has been linked")
+      end
+
+      it "uses the absolute value for terms with negative karma" do
+        send_command("foo-- bar--")
+        send_command("foo += bar")
+        expect(replies.last).to include("has been linked")
+        send_command("bar += foo")
+        expect(replies.last).to include("has been linked")
+      end
+    end
+  end
+
+  describe "#unlink" do
+    it "says that it's unlinked term 2 from term 1" do
+      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
+      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_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 a message if the term hasn't been modified" do
+      send_command("conferenz modified foo")
+      expect(replies.last).to match(/never been modified/)
+    end
+
+    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("conferenz modified foo")
+      expect(replies.last).to eq("#{user.name}, #{other_user.name}")
+    end
+  end
+
+  describe "#delete" do
+    before do
+      robot.auth.add_user_to_group!(user, :karma_admins)
+    end
+
+    it "deletes the term" do
+      send_message("foo++")
+      send_command("conferenz delete foo")
+      expect(replies.last).to eq("foo has been deleted.")
+      send_message("foo~~")
+      expect(replies.last).to eq("foo: 0")
+    end
+
+    it "matches terms exactly, including leading whitespace" do
+      term = "  'foo bar* 'baz''/ :"
+      subject.redis.zincrby("terms", 1, term)
+      send_command("conferenz delete #{term}")
+      expect(replies.last).to include("has been deleted")
+    end
+
+    it "clears the modification list" do
+      send_message("foo++")
+      send_command("conferenz delete foo")
+      send_command("conferenz 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("conferenz 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("conferenz 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
+      registry.config.handlers.conferenz.term_pattern = /[<:]([^>:]+)[>:]/
+      registry.config.handlers.conferenz.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

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter "/spec/" }
+
+require "lita-conferenz"
+require "lita/rspec"
+
+Lita.version_3_compatibility_mode = false

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: lita-conferenz
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Piotr Limanowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Lita handler for tracking conferences attendance.
+email:
+- plimanowski+conferenz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- lib/lita-conferenz.rb
+- lib/lita/handlers/conferenz/chat.rb
+- lib/lita/handlers/conferenz/config.rb
+- lib/lita/handlers/conferenz/term.rb
+- lita-conferenz.gemspec
+- locales/en.yml
+- spec/lita/handlers/conferenz/chat_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/peel/conferenz
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A Lita handler for tracking conferences attendance.
+test_files:
+- spec/lita/handlers/conferenz/chat_spec.rb
+- spec/spec_helper.rb