lita 2.7.2 → 3.0.0

data/spec/lita/response_spec.rb

@@ -1,10 +1,9 @@
 require "spec_helper"
 
 describe Lita::Response do
-  subject { described_class.new(message, pattern) }
+  subject { described_class.new(message, /dummy regexp/) }
 
-  let(:message) { double("Lita::Message").as_null_object }
-  let(:pattern) { double("Regexp").as_null_object }
+  let(:message) { instance_double("Lita::Message").as_null_object }
 
   [:args, :reply, :user, :command?].each do |method|
     it "delegates :#{method} to #message" do
@@ -13,10 +12,20 @@ describe Lita::Response do
     end
   end
 
-  it "supports the deprecated Response.new(message, matches: matches) API" do
-    matches = ["foo"]
-    expect(Lita.logger).to receive(:warn)
-    subject = described_class.new(message, matches: matches)
-    expect(subject.matches).to eq(matches)
+  describe "#matches" do
+    it "matches the pattern against the message" do
+      expect(message).to receive(:match).with(subject.pattern)
+      subject.matches
+    end
+  end
+
+  describe "#match_data" do
+    let(:body) { instance_double("String") }
+
+    it "matches the message body against the pattern" do
+      allow(message).to receive(:body).and_return(body)
+      expect(subject.pattern).to receive(:match).with(message.body)
+      subject.match_data
+    end
   end
 end

data/spec/lita/robot_spec.rb

@@ -15,8 +15,8 @@ describe Lita::Robot do
   end
 
   context "with registered handlers" do
-    let(:handler1) { double("Handler 1").as_null_object }
-    let(:handler2) { double("Handler 2").as_null_object }
+    let(:handler1) { class_double("Lita::Handler", http_routes: [], trigger: nil) }
+    let(:handler2) { class_double("Lita::Handler", http_routes: [], trigger: nil) }
 
     before do
       allow(Lita).to receive(:handlers).and_return([handler1, handler2])
@@ -40,11 +40,12 @@ describe Lita::Robot do
   end
 
   describe "#run" do
-    let(:thread) { double("Thread", :abort_on_exception= => true, join: nil) }
+    let(:thread) { instance_double("Thread", :abort_on_exception= => true, join: nil) }
 
     before do
       allow_any_instance_of(Lita::Adapters::Shell).to receive(:run)
-      allow_any_instance_of(Thin::Server).to receive(:start)
+      allow_any_instance_of(Puma::Server).to receive(:run)
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener)
 
       allow(Thread).to receive(:new) do |&block|
         block.call
@@ -58,13 +59,7 @@ describe Lita::Robot do
     end
 
     it "starts the web server" do
-      expect_any_instance_of(Thin::Server).to receive(:start)
-      subject.run
-    end
-
-    it "doesn't silence thin if config.http.debug is true" do
-      Lita.config.http.debug = true
-      expect_any_instance_of(Thin::Server).not_to receive(:silent=)
+      expect_any_instance_of(Puma::Server).to receive(:run)
       subject.run
     end
 
@@ -77,21 +72,35 @@ describe Lita::Robot do
     end
   end
 
+  describe "#join" do
+    it "delegates to the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:join).with("#lita.io")
+      subject.join("#lita.io")
+    end
+  end
+
+  describe "#part" do
+    it "delegates to the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:part).with("#lita.io")
+      subject.part("#lita.io")
+    end
+  end
+
   describe "#send_message" do
-    let(:source) { double("Source") }
+    let(:source) { instance_double("Lita::Source") }
 
     it "delegates to the adapter" do
       expect_any_instance_of(
         Lita::Adapters::Shell
       ).to receive(:send_messages).with(
-        source, ["foo", "bar"]
+        source, %w(foo bar)
       )
       subject.send_messages(source, "foo", "bar")
     end
   end
 
   describe "#set_topic" do
-    let(:source) { double("Source") }
+    let(:source) { instance_double("Lita::Source") }
 
     it "delegates to the adapter" do
       expect_any_instance_of(Lita::Adapters::Shell).to receive(:set_topic).with(

data/spec/lita/rspec_spec.rb

@@ -55,7 +55,7 @@ describe handler_class, lita_handler: true do
   describe "#blah" do
     it "replies with bongo and wongo" do
       send_command("blah")
-      expect(replies).to eq(["bongo", "wongo"])
+      expect(replies).to eq(%w(bongo wongo))
     end
   end
 

data/spec/lita/source_spec.rb

@@ -25,20 +25,4 @@ describe Lita::Source do
   it "requires either a user or a room" do
     expect { described_class.new }.to raise_error(ArgumentError)
   end
-
-  describe "the deprecated Source.new(user, room) API" do
-    it "can have a user and is marked as private if there is no room" do
-      expect(Lita.logger).to receive(:warn)
-      subject = described_class.new("Carl")
-      expect(subject.user).to eq("Carl")
-      expect(subject).to be_a_private_message
-    end
-
-    it "can have a room and is not marked as private if it does" do
-      expect(Lita.logger).to receive(:warn)
-      subject = described_class.new("Carl", "#litabot")
-      expect(subject.room).to eq("#litabot")
-      expect(subject).not_to be_a_private_message
-    end
-  end
 end

data/spec/lita/timer_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Lita::Timer do
+  let(:queue) { Queue.new }
+
+  before { allow(subject).to receive(:sleep) }
+
+  after { subject.stop }
+
+  it "runs single timers" do
+    subject = described_class.new { queue.push(true) }
+    expect(subject).to receive(:sleep).with(0).once
+    subject.start
+    expect(queue.pop(true)).to be(true)
+    expect { queue.pop(true) }.to raise_error(ThreadError)
+  end
+
+  it "runs recurring timers" do
+    halt = false
+    subject = described_class.new(interval: 1, recurring: true) do |timer|
+      queue.push(true)
+      timer.stop if halt
+      halt = true
+    end
+    expect(subject).to receive(:sleep).with(1).twice
+    subject.start
+    2.times { expect(queue.pop(true)).to be(true) }
+    expect { queue.pop(true) }.to raise_error(ThreadError)
+  end
+end

data/spec/lita/user_spec.rb

@@ -9,12 +9,9 @@ describe Lita::User, lita: true do
       persisted_user = described_class.find(1)
       expect(user).to eq(persisted_user)
     end
-  end
-
-  describe ".find" do
-    before { described_class.create(1, name: "Carl") }
 
     it "returns existing users" do
+      described_class.create(1, name: "Carl")
       expect_any_instance_of(described_class).not_to receive(:save)
       user = described_class.find(1, name: "Carl")
       expect(user.id).to eq("1")
@@ -22,6 +19,26 @@ describe Lita::User, lita: true do
     end
   end
 
+  describe ".find_by_id" do
+    it "finds users with no metadata stored" do
+      described_class.create(1)
+      user = described_class.find_by_id(1)
+      expect(user.id).to eq("1")
+    end
+  end
+
+  describe ".find_by_mention_name" do
+    it "returns nil if no user matches the provided mention name" do
+      expect(described_class.find_by_mention_name("carlthepug")).to be_nil
+    end
+
+    it "returns a user that matches the provided mention name" do
+      described_class.create(1, mention_name: "carlthepug")
+      user = described_class.find_by_mention_name("carlthepug")
+      expect(user.id).to eq("1")
+    end
+  end
+
   describe ".find_by_name" do
     it "returns nil if no user matches the provided name" do
       expect(described_class.find_by_name("Carl")).to be_nil
@@ -34,18 +51,61 @@ describe Lita::User, lita: true do
     end
   end
 
+  describe ".find_by_partial_name" do
+    before { described_class.create(1, name: "José Vicente Cuadra") }
+
+    it "finds users by partial name match" do
+      user = described_class.find_by_partial_name("José")
+      expect(user.id).to eq("1")
+    end
+
+    it "returns nil if no users' names start with the provided string" do
+      expect(described_class.find_by_partial_name("Foo")).to be_nil
+    end
+
+    it "returns nil if more than one match was found" do
+      described_class.create(2, name: "José Contreras")
+      expect(described_class.find_by_partial_name("José")).to be_nil
+    end
+  end
+
+  describe ".fuzzy_find" do
+    let!(:user) { described_class.create(1, name: "Carl the Pug", mention_name: "carlthepug") }
+
+    it "finds by ID" do
+      expect(described_class.fuzzy_find(1)).to eq(user)
+    end
+
+    it "finds by mention name" do
+      expect(described_class.fuzzy_find("carlthepug")).to eq(user)
+    end
+
+    it "finds by name" do
+      expect(described_class.fuzzy_find("Carl the Pug")).to eq(user)
+    end
+
+    it "finds by partial mention name" do
+      expect(described_class.fuzzy_find("Carl")).to eq(user)
+    end
+  end
+
   describe "#save" do
-    subject { described_class.new(1, name: "Carl") }
+    subject { described_class.new(1, name: "Carl", mention_name: "carlthepug") }
 
     it "saves an ID to name mapping for the user in Redis" do
       subject.save
-      expect(described_class.redis.hgetall("id:1")).to eq("name" => "Carl")
+      expect(described_class.redis.hgetall("id:1")).to include("name" => "Carl")
     end
 
     it "saves a name to ID mapping for the user in Redis" do
       subject.save
       expect(described_class.redis.get("name:Carl")).to eq("1")
     end
+
+    it "saves a mention name to ID mapping for the user in Redis" do
+      subject.save
+      expect(described_class.redis.get("mention_name:carlthepug")).to eq("1")
+    end
   end
 
   describe "#==" do

data/spec/lita_spec.rb

@@ -13,6 +13,43 @@ describe Lita do
     end
   end
 
+  describe ".load_locales" do
+    let(:load_path) do
+      load_path = double("Array")
+      allow(load_path).to receive(:concat)
+      load_path
+    end
+
+    let(:new_locales) { %w(foo bar) }
+
+    before do
+      allow(I18n).to receive(:load_path).and_return(load_path)
+      allow(I18n).to receive(:reload!)
+    end
+
+    it "appends the locale files to I18n.load_path" do
+      expect(I18n.load_path).to receive(:concat).with(new_locales)
+      described_class.load_locales(new_locales)
+    end
+
+    it "reloads I18n" do
+      expect(I18n).to receive(:reload!)
+      described_class.load_locales(new_locales)
+    end
+
+    it "wraps single paths in an array" do
+      expect(I18n.load_path).to receive(:concat).with(["foo"])
+      described_class.load_locales("foo")
+    end
+  end
+
+  describe ".locale=" do
+    it "sets I18n.locale to the normalized locale" do
+      expect(I18n).to receive(:locale=).with("es-MX.UTF-8")
+      described_class.locale = "es_MX.UTF-8"
+    end
+  end
+
   describe ".redis" do
     it "memoizes a Redis::Namespace" do
       expect(described_class.redis).to respond_to(:namespace)

data/spec/spec_helper.rb

@@ -8,4 +8,15 @@ SimpleCov.start { add_filter "/spec/" }
 
 require "pry"
 require "lita"
+require "lita/cli"
 require "lita/rspec"
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks_config|
+    mocks_config.verify_doubled_constant_names = true
+    # Enable config option this when a new rspec-mocks beta including this patch is released:
+    # https://github.com/rspec/rspec-mocks/pull/466
+    #
+    # mocks_config.verify_partial_doubles = true
+  end
+end

data/templates/locales/en.yml

@@ -0,0 +1,90 @@
+en:
+  lita:
+    adapters:
+      shell:
+        startup_message: Type "exit" or "quit" to end the session.
+    handlers:
+      authorization:
+        help:
+          add_key: auth add USER GROUP
+          add_value: Add USER to authorization group GROUP. Requires admin privileges.
+          remove_key: auth remove USER GROUP
+          remove_value: Remove USER from authorization group GROUP. Requires admin privileges.
+          list_key: "auth list [GROUP]"
+          list_value: >-
+            List authorization groups and the users in them. If GROUP is supplied,
+            only lists that group.
+        user_added: "%{user} was added to %{group}."
+        user_already_in: "%{user} was already in %{group}."
+        user_removed: "%{user} was removed from %{group}."
+        user_not_in: "%{user} was not in %{group}."
+        empty_state: There are no authorization groups yet.
+        empty_state_group: "There is no authorization group named %{group}."
+        format: "Format"
+        admin_management: Administrators can only be managed via Lita config.
+        no_user_found: 'No user was found with the identifier "%{identifier}".'
+      help:
+        help:
+          help_value: Lists help information for terms and command the robot will respond to.
+          help_command_key: help COMMAND
+          help_command_value: Lists help information for terms or commands that begin with COMMAND.
+      info:
+        help:
+          info_value: Replies with the current version of Lita.
+      room:
+        help:
+          join_key: join ROOM_ID
+          join_value: Makes the robot join the room with room ID ROOM_ID.
+          part_key: part ROOM_ID
+          part_value: Makes the robot part from the room with room ID ROOM_ID.
+    adapter:
+      name_required: Adapters that are anonymous classes must define self.name.
+      method_not_implemented: "This adapter has not implemented #%{method}."
+      missing_configs: "The following keys are required on config.adapter: %{configs}"
+    cli:
+      no_gemfile_warning: >-
+        The default command "start" must be run inside a Lita project. Try running `lita new` to
+        generate a new Lita project or `lita help` to see all commands.
+      travis_question: Do you want to test your plugin on Travis CI?
+      coveralls_question: |-
+        Do you want to generate code coverage information with SimpleCov and Coveralls.io?
+    config:
+      exception: |
+        Lita configuration file could not be processed. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+    daemon:
+      pid_exists: >-
+        PID file exists at %{path}. Lita may already be running. Kill the existing process or
+        remove the PID file and then start Lita.
+      kill_failure: "Failed to kill existing Lita process %{pid}."
+    handler:
+      name_required: Handlers that are anonymous classes must define self.name.
+      dispatch: "Dispatching message to %{handler}#%{method}."
+      exception: |
+        %{handler} crashed. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+    robot:
+      unknown_adapter: "Unknown adapter: :%{adapter}."
+    rspec:
+      full_suite_required: Lita::RSpec requires both RSpec::Mocks and RSpec::Expectations.
+      mocks_expect_syntax_required: RSpec::Mocks 2.14 or greater is required to use Lita::RSpec.
+      route_failure: |-
+        Expected message "%{message}" to route to :%{route}, but didn't.
+      negative_route_failure: |-
+        Expected message "%{message}" not to route to :%{route}, but did.
+      http_route_failure: |-
+        Expected request "%{method} %{path}" to route to :%{route}, but didn't.
+      negative_http_route_failure: |-
+        Expected request "%{method} %{path}" not to route to :%{route}, but did.
+      event_subscription_failure: |-
+        Expected triggering event "%{event}" to invoke :%{route}, but didn't.
+      negative_event_subscription_failure: |-
+        Expected triggering event "%{event}" not to invoke :%{route}, but did.
+    source:
+      user_or_room_required: Either a user or a room is required.
+    user:
+      find_deprecated: Lita::User.find will be removed in Lita 4.0. Use Lita::User.create instead.

data/templates/plugin/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/templates/plugin/lib/lita/plugin_type/plugin.tt

@@ -12,3 +12,7 @@ module Lita
     <%- end -%>
   end
 end
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "..", "..", "locales", "*.yml"), __FILE__
+)]