rita 0.1.0 → 5.0.0.alpha.1

data/spec/lita_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita do
+  let(:registry) { Lita::Registry.new }
+  before { described_class.register_adapter(:shell, Lita::Adapters::Shell) }
+
+  it "memoizes a Configuration" do
+    expect(described_class.config).to eql(described_class.config)
+  end
+
+  it "keeps track of registered hooks" do
+    hook = double("hook")
+    described_class.register_hook("Foo ", hook)
+    described_class.register_hook(:foO, hook)
+    expect(described_class.hooks[:foo]).to eq(Set.new([hook]))
+  end
+
+  describe ".configure" do
+    it "yields the Configuration object" do
+      described_class.configure { |c| c.robot.name = "Not Lita" }
+      expect(described_class.config.robot.name).to eq("Not Lita")
+    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 ".default_locale=" do
+    it "sets I18n.default_locale to the normalized locale" do
+      expect(I18n).to receive(:default_locale=).with("zh-TW")
+      described_class.default_locale = "zh_TW"
+    end
+  end
+
+  describe ".redis" do
+    let(:redis_namespace) { instance_double("Redis") }
+
+    before do
+      if described_class.instance_variable_defined?(:@redis)
+        described_class.remove_instance_variable(:@redis)
+      end
+
+      allow(redis_namespace).to receive(:ping).and_return("PONG")
+      allow(Redis::Namespace).to receive(:new).and_return(redis_namespace)
+    end
+
+    it "memoizes a Redis::Namespace" do
+      expect(described_class.redis).to equal(redis_namespace)
+      expect(described_class.redis).to eql(described_class.redis)
+    end
+
+    it "raises a RedisError if it can't connect to Redis" do
+      allow(redis_namespace).to receive(:ping).and_raise(Redis::CannotConnectError)
+      expect { Lita.redis }.to raise_error(Lita::RedisError, /could not connect to Redis/)
+    end
+
+    context "with test mode off" do
+      around do |example|
+        test_mode = Lita.test_mode?
+        Lita.test_mode = false
+        example.run
+        Lita.test_mode = test_mode
+      end
+
+      it "logs a fatal warning and raises an exception if it can't connect to Redis" do
+        allow(redis_namespace).to receive(:ping).and_raise(Redis::CannotConnectError)
+
+        expect(Lita.logger).to receive(:fatal)
+        expect { Lita.redis }.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe ".register_adapter" do
+    let(:robot) { Lita::Robot.new(registry) }
+
+    it "builds an adapter out of a provided block" do
+      # rubocop:disable Lint/EmptyBlock
+      described_class.register_adapter(:foo) {}
+      # rubocop:enable Lint/EmptyBlock
+
+      expect(Lita.logger).to receive(:warn).with(/not implemented/)
+
+      Lita.adapters[:foo].new(robot).run
+    end
+
+    it "raises if a non-class object is passed as the adapter" do
+      expect do
+        described_class.register_adapter(:foo, :bar)
+      end.to raise_error(ArgumentError, /requires a class/)
+    end
+  end
+
+  describe ".register_handler" do
+    it "builds a handler out of a provided block" do
+      # rubocop:disable Lint/EmptyBlock
+      described_class.register_handler(:foo) {}
+      # rubocop:enable Lint/EmptyBlock
+      #
+      expect(described_class.handlers.to_a.last.namespace).to eq("foo")
+    end
+
+    it "raises if a non-class object is the only argument" do
+      expect do
+        described_class.register_handler(:foo)
+      end.to raise_error(ArgumentError, /requires a class/)
+    end
+  end
+
+  describe ".reset" do
+    it "clears the config" do
+      described_class.config.robot.name = "Foo"
+      described_class.reset
+      expect(described_class.config.robot.name).to eq("Lita")
+    end
+
+    it "clears adapters" do
+      described_class.register_adapter(:foo, Class.new)
+      described_class.reset
+      expect(described_class.adapters).to be_empty
+    end
+
+    it "clears handlers" do
+      described_class.register_handler(Class.new)
+      described_class.reset
+      expect(described_class.handlers).to be_empty
+    end
+
+    it "clears hooks" do
+      described_class.register_hook(:foo, double)
+      described_class.reset
+      expect(described_class.hooks).to be_empty
+    end
+  end
+
+  describe ".load_config" do
+    let(:hook) { double("Hook") }
+    let(:validator) { instance_double("Lita::ConfigurationValidator", call: nil) }
+
+    before do
+      allow(
+        Lita::ConfigurationValidator
+      ).to receive(:new).with(described_class).and_return(validator)
+    end
+
+    after { described_class.reset }
+
+    it "calls before_run hooks" do
+      described_class.register_hook(:before_run, hook)
+      expect(hook).to receive(:call).with(config_path: "path/to/config")
+      described_class.load_config("path/to/config")
+    end
+
+    it "calls config_finalized hooks" do
+      described_class.register_hook(:config_finalized, hook)
+      expect(hook).to receive(:call).with(config_path: "path/to/config")
+      described_class.load_config("path/to/config")
+    end
+
+    it "raises if the configuration is not valid" do
+      allow(validator).to receive(:call).and_raise(SystemExit)
+
+      expect { described_class.load_config }.to raise_error(SystemExit)
+    end
+  end
+
+  describe ".run" do
+    let(:validator) { instance_double("Lita::ConfigurationValidator", call: nil) }
+    let(:robot) { double("Lita::Robot", run: nil) }
+
+    before do
+      allow(Lita::Robot).to receive(:new).and_return(robot)
+      allow(Lita::ConfigurationBuilder).to receive(:load_user_config)
+      allow(
+        Lita::ConfigurationValidator
+      ).to receive(:new).with(described_class).and_return(validator)
+    end
+
+    after { described_class.reset }
+
+    it "runs a new Robot" do
+      expect(robot).to receive(:run)
+      described_class.run
+    end
+
+    it "loads configuration from a config file" do
+      expect(described_class).to receive(:load_config).with("path/to/config")
+      described_class.run("path/to/config")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Generate code coverage metrics outside CI.
+unless ENV["CI"]
+  require "simplecov"
+  SimpleCov.start { add_filter "/spec/" }
+end
+
+require "pry"
+require "lita/rspec"
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks_config|
+    mocks_config.verify_doubled_constant_names = true
+    mocks_config.verify_partial_doubles = true
+  end
+
+  # Lita calls `exit(false)` in a few places. If an RSpec example hits one of these calls and it
+  # wasn't explicitly stubbed, the example will stop at exactly that point, but will be reported by
+  # RSpec as having passed, and will also change RSpec's exit code to 1. This situation indicates
+  # either a missing stub or a real bug, so we catch it here and fail loudly.
+  #
+  # https://github.com/rspec/rspec-core/issues/2246
+  config.around do |example|
+    example.run
+  rescue SystemExit => e
+    raise <<~ERROR
+      Unhandled SystemExit! This will cause RSpec to exit 1 but show the example as passing!"
+
+      Full backtrace:
+
+      #{e.backtrace.join("\n")}
+    ERROR
+  end
+end

data/spec/templates/basic.erb

@@ -0,0 +1 @@
+Template rendered from a file!

data/spec/templates/basic.irc.erb

@@ -0,0 +1 @@
+IRC template rendered from a file!

data/spec/templates/helpers.erb

@@ -0,0 +1 @@
+<%= reverse_name(@first, @last) %>

data/spec/templates/interpolated.erb

@@ -0,0 +1 @@
+I love <%= @first %> <%= @last %>!

data/templates/locales/en.yml

@@ -0,0 +1,137 @@
+en:
+  lita:
+    adapters:
+      shell:
+        startup_message: Type "exit" or "quit" to end the session.
+    core:
+      register_adapter:
+        block_or_class_required: Lita.register_adapter requires a class in its two argument form.
+      register_handler:
+        block_or_class_required: Lita.register_handler requires a class in its single argument form.
+    adapter:
+      method_not_implemented: "This adapter has not implemented #%{method}."
+    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.
+      license_notice: >-
+        If you plan to release this plugin as open source software, consider adding a LICENSE file
+        to the root of the repository.
+
+        Common open source software licenses can be found at https://choosealicense.com/.
+      github_user_question: What is your GitHub username?
+    config:
+      exception: |
+        Lita configuration file could not be processed. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+      locale_deprecated: >-
+        `config.robot.locale` and `config.robot.default_locale` are deprecated and will be removed
+        in Lita 6.0. Use the environment variable LC_ALL, LC_MESSAGES, or LANG to set the program's
+        locale instead.
+      missing_required_adapter_attribute: >-
+        Configuration attribute "%{attribute}" is required for "%{adapter}" adapter.
+      missing_required_handler_attribute: >-
+        Configuration attribute "%{attribute}" is required for "%{handler}" handler.
+      type_error: >-
+        Configuration type error: "%{attribute}" must be one of: %{types}.
+      validation_error: >-
+        Validation error on attribute "%{attribute}": %{message}
+    handler:
+      dispatch: "Dispatching message to %{handler}#%{method}."
+      exception: |
+        %{handler} crashed. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+    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:
+        handler_contains: Handler "%{handler}" defines the following commands
+        help:
+          help_value: Lists help information for terms and command the robot will respond to.
+          help_query_key: "help QUERY"
+          help_query_value: Lists help information for commands matching QUERY.
+        info: >-
+          Send the message "%{address}help QUERY" to see matching help messages. QUERY may be the
+          name of a handler, text matching a message pattern a handler responds to, or text
+          matching the description of a message pattern a handler responds to. The following
+          handlers are installed:
+        no_help_found: "No matching handlers, message patterns, or descriptions found."
+        pattern_or_description_contains: Message patterns or descriptions that match "%{query}"
+        unauthorized: " [Unauthorized]"
+      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.
+      users:
+        find_empty_state: No matching users found.
+        help:
+          find_key: users find SEARCH_TERM
+          find_value: Find a Lita user by ID, name, or mention name.
+    http:
+      exception: |
+        Lita's built-in web server could not be started. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+    plugin:
+      name_required: Plugins that are anonymous classes must set a namespace or define self.name.
+    redis:
+      exception: |
+        Lita could not connect to Redis. The exception was:
+        %{message}
+        Full backtrace:
+        %{backtrace}
+      test_mode_exception: |
+        Lita could not connect to Redis. The exception was:
+        %{message}
+    robot:
+      unknown_adapter: "Unknown adapter: :%{adapter}."
+    rspec:
+      full_suite_required: Lita::RSpec requires both RSpec::Mocks and RSpec::Expectations.
+      version_3_required: RSpec::Core 3 or greater is required to use Lita::RSpec.
+      rack_test_required: Rack::Test is required to use the `http` method of Lita::RSpec.
+      lita_3_compatibility_mode: >-
+        WARNING: Lita 3 compatibility mode is deprecated in Lita 5 and will be removed in Lita 6.
+        It no longer has any effect. Please remove any calls to `Lita.version_3_compatibility_mode`.
+      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.
+    template:
+      missing_template: Missing template file at %{path}.

data/templates/plugin/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/templates/plugin/README.tt

@@ -0,0 +1,29 @@
+# <%= config[:gem_name] %>
+
+TODO: Add a description of the plugin.
+
+## Installation
+
+<%- if config[:plugin_type] == "extension" -%>
+Add <%= config[:gem_name] %> to your Lita plugin's gemspec:
+
+``` ruby
+spec.add_runtime_dependency "<%= config[:gem_name] %>"
+```
+<%- else -%>
+Add <%= config[:gem_name] %> to your Lita instance's Gemfile:
+
+``` ruby
+gem "<%= config[:gem_name] %>"
+```
+<%- end -%>
+
+<%- unless config[:plugin_type] == "extension" -%>
+## Configuration
+
+TODO: Describe any configuration attributes the plugin exposes.
+
+<%- end -%>
+## Usage
+
+TODO: Describe the plugin's features and how to use them.

data/templates/plugin/Rakefile

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

data/templates/plugin/gemspec.tt

@@ -0,0 +1,27 @@
+Gem::Specification.new do |spec|
+  spec.name          = "<%= config[:gem_name] %>"
+  spec.version       = "0.1.0"
+  spec.authors       = ["<%= config[:author] %>"]
+  spec.email         = ["<%= config[:email] %>"]
+  spec.description   = "TODO: Add a description"
+  spec.summary       = "TODO: Add a summary"
+  spec.homepage      = "TODO: Add a homepage"
+  spec.license       = "TODO: Add a license"
+  spec.metadata      = { "lita_plugin_type" => "<%= config[:plugin_type] %>" }
+
+  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", ">= <%= config[:required_lita_version] %>"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  if RUBY_PLATFORM != 'java'
+    spec.add_development_dependency "pry-byebug"
+  end
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+end

data/templates/plugin/gitignore

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lita
+  module <%= config[:constant_namespace] %>
+    class <%= config[:constant_name] %><% unless config[:plugin_type] == "extension" %> < <%= config[:plugin_type].capitalize %><% end %>
+      # insert <%= config[:plugin_type] %> code here
+
+      <%- if config[:plugin_type] == "adapter" -%>
+      Lita.register_adapter(:<%= config[:name] %>, self)
+      <%- elsif config[:plugin_type] == "handler" -%>
+      Lita.register_handler(self)
+      <%- else -%>
+      # If your extension needs to register with a Lita hook, uncomment the
+      # following line and change the hook name to the appropriate value:
+      # Lita.register_hook(:hook_name, self)
+      <%- end -%>
+    end
+  end
+end

data/templates/plugin/lib/plugin.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/<%= config[:namespace] %>/<%= config[:name] %>"
+<%- if config[:plugin_type] == "handler" -%>
+
+Lita::<%= config[:constant_namespace] %>::<%= config[:constant_name] %>.template_root File.expand_path(
+  File.join("..", "..", "templates"),
+ __FILE__
+)
+<%- end -%>

data/templates/plugin/locales/en.yml.tt

@@ -0,0 +1,4 @@
+en:
+  lita:
+    <%= config[:namespace] %>:
+      <%= config[:name] %>:

data/templates/plugin/spec/lita/plugin_type/plugin_spec.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::<%= config[:constant_namespace] %>::<%= config[:constant_name] %>, <%= config[:spec_type] %>: true do
+end

data/templates/plugin/spec/spec_helper.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "simplecov"
+require "coveralls"
+SimpleCov.start { add_filter "/spec/" }
+
+require "<%= config[:gem_name] %>"
+require "lita/rspec"

data/templates/robot/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "lita"

data/templates/robot/lita_config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Lita.configure do |config|
+  # The name your robot will use.
+  config.robot.name = "Lita"
+
+  ## An array identifiers for users who are considered administrators. These
+  ## users have the ability to add and remove other users from authorization
+  ## groups. What is considered a user ID will change depending on which adapter
+  ## you use.
+  # config.robot.admins = ["1", "2"]
+
+  # The adapter you want to connect with. Make sure you've added the
+  # appropriate gem to the Gemfile.
+  config.robot.adapter = :shell
+
+  ## Example: Set options for the chosen adapter.
+  # config.adapter.username = "myname"
+  # config.adapter.password = "secret"
+
+  ## Example: Set options for the Redis connection.
+  # config.redis[:host] = "127.0.0.1"
+  # config.redis[:port] = 1234
+
+  ## Example: Set configuration for any loaded handlers. See the handler's
+  ## documentation for options.
+  # config.handlers.example_handler.example_attribute = "example value"
+end