boty 0.1.0 → 0.1.1

data/spec/boty/cli_spec.rb

@@ -6,21 +6,21 @@ module Boty
     subject(:cli) { described_class.new }
 
     before(:all) do
-      FileUtils.mkdir_p "tmp" if !Dir.exists? "tmp"
+      FileUtils.mkdir_p "tmp" unless Dir.exist? "tmp"
       FileUtils.chdir "tmp"
     end
 
     before do
-      FileUtils.rm_rf "nice_bot" if Dir.exists? "nice_bot"
+      FileUtils.rm_rf "nice_bot" if Dir.exist? "nice_bot"
 
-      allow(cli).to receive(:ask).
-        and_return ENV["SLACK_COMPANY"], ENV["SLACK_BOT_API_TOKEN"]
+      allow(cli).to receive(:ask)
+        .and_return ENV["SLACK_COMPANY"], ENV["SLACK_BOT_API_TOKEN"]
 
       allow(cli).to receive(:run)
     end
 
     after(:all) do
-      FileUtils.rm_rf "nice_bot" if Dir.exists? "nice_bot"
+      FileUtils.rm_rf "nice_bot" if Dir.exist? "nice_bot"
       FileUtils.chdir "../"
     end
 

data/spec/boty/dsl_spec.rb

@@ -1,6 +1,6 @@
 module Boty
   RSpec.describe DSL do
-    let(:bot) { Bot.new({"id" => "U123", "name" => "jeeba"}) }
+    let(:bot) { Bot.new("id" => "U123", "name" => "jeeba") }
     subject(:dsl) { described_class.new bot }
 
     def message(text, extras = {})
@@ -13,12 +13,11 @@ module Boty
 
     before do
       # used by message class
-      allow(Slack.users).to receive(:info).with("U5678").
-        and_return(Slack::User.new("id" => "U5678", "name" => "julian"))
+      allow(Slack.users).to receive(:info).with("U5678")
+        .and_return Slack::User.new("id" => "U5678", "name" => "julian")
     end
 
-    methods_from_bot = [ :name, :brain, :know_how, :im, :say,
-                         :desc, :respond, :match ]
+    methods_from_bot = %i(name brain know_how im say desc respond match)
     methods_from_bot.each do |bot_method|
       it "responds to :#{bot_method}" do
         expect(dsl.respond_to?(bot_method)).to eq true
@@ -36,8 +35,8 @@ module Boty
         say "Ohay <@#{user.id}>! I'm here, that's for sure."
       end
 
-      expect(dsl).to receive(:say).
-        with "Ohay <@U5678>! I'm here, that's for sure."
+      expect(dsl).to receive(:say)
+        .with "Ohay <@U5678>! I'm here, that's for sure."
 
       message "jeeba, are you there?"
     end
@@ -47,8 +46,8 @@ module Boty
         say "Ohay <@#{user.id}>! It matched."
       end
 
-      expect(bot).to receive(:say).
-        with "Ohay <@U5678>! It matched."
+      expect(bot).to receive(:say)
+        .with "Ohay <@U5678>! It matched."
 
       message "called with match?"
     end
@@ -80,16 +79,16 @@ module Boty
         executed = false
         dsl.match "omg" do executed = true end
 
-        expect { message "bbq omg lol." }.
-          to change { executed }.from(false).to true
+        expect { message "bbq omg lol." }
+          .to change { executed }.from(false).to true
       end
 
       it "binds a string with #respond" do
         executed = false
         dsl.respond "omg" do executed = true end
 
-        expect { message "<@jeeba>: bbq omg lol." }.
-          to change { executed }.from(false).to true
+        expect { message "<@jeeba>: bbq omg lol." }
+          .to change { executed }.from(false).to true
       end
     end
 

data/spec/boty/rspec_spec.rb

@@ -28,7 +28,8 @@ module Boty
 
     context "helpers" do
       it "includes #message_event to fire `data['type'] = 'message' events" do
-        expect(@_bot).to receive(:event).with "type" => "message", "text" => "omg"
+        expect(@_bot).to receive(:event)
+          .with "type" => "message", "text" => "omg"
         message "omg"
       end
     end

data/spec/boty/script_loader_spec.rb

@@ -1,15 +1,17 @@
 module Boty
   RSpec.describe Boty::ScriptLoader, :fakefs, :users do
-    let(:dsl) { Boty::DSL.new Bot.new({ "name" => "jabber", "id" => "123" }) }
-    let(:data) {{
-      "type" => "message",
-      "text" => "hey <@jabber>, pug me"
-    }}
+    let(:dsl) { Boty::DSL.new Bot.new("name" => "jabber", "id" => "123") }
+    let(:data) do
+      {
+        "type" => "message",
+        "text" => "hey <@jabber>, pug me"
+      }
+    end
 
     subject(:loader) { described_class.new Boty::DSL.new(bot) }
 
     before do
-      FileUtils.mkdir "script" unless Dir.exists? "script"
+      FileUtils.mkdir "script" unless Dir.exist? "script"
       File.open "script/omg.rb", "w" do |f|
         f.write <<-RUBY
           respond(/pug me/i) do

data/spec/boty/session_spec.rb

@@ -33,8 +33,8 @@ module Boty
       end
 
       it "intializes the sse client with the session url" do
-        expect(Faye::WebSocket::Client).to receive(:new).
-          with("ws://example.org/slack/sse/url")
+        expect(Faye::WebSocket::Client).to receive(:new)
+          .with("ws://example.org/slack/sse/url")
 
         session.start
       end

data/spec/boty/slack/chat_spec.rb

@@ -8,26 +8,26 @@ module Boty
       }
 
       let(:post_message_url) {
-        "https://slack.com/api/chat.postMessage?"+
-        "token=#{ENV['SLACK_BOT_API_TOKEN']}&#{parameters}"
+        "https://slack.com/api/chat.postMessage?" \
+          "token=#{ENV['SLACK_BOT_API_TOKEN']}&#{parameters}"
       }
 
       describe "#post_message" do
         it "uses api end point to send message with default parameters" do
-          expect(Slack::URL).to receive(:get).
-            with(post_message_url + "&text=omglolbbq")
+          expect(Slack::URL).to receive(:get)
+            .with(post_message_url + "&text=omglolbbq")
           chat.post_message "omglolbbq"
         end
 
         it "uri encodes the message" do
-          expect(Slack::URL).to receive(:get).
-            with(post_message_url + "&text=omg%20lol%20bbq")
+          expect(Slack::URL).to receive(:get)
+            .with(post_message_url + "&text=omg%20lol%20bbq")
           chat.post_message "omg lol bbq"
         end
 
         it "accepts extra api parameters" do
-          expect(Slack::URL).to receive(:get).
-            with(post_message_url + "&text=omg&extra=param")
+          expect(Slack::URL).to receive(:get)
+            .with(post_message_url + "&text=omg&extra=param")
           chat.post_message "omg", extra: "param"
         end
 
@@ -35,8 +35,8 @@ module Boty
           let(:parameters) { "as_user=true&channel=lol" }
 
           it "sends to a specific channel when one is given" do
-            expect(Slack::URL).to receive(:get).
-              with(post_message_url + "&text=omg")
+            expect(Slack::URL).to receive(:get)
+              .with(post_message_url + "&text=omg")
             chat.post_message "omg", channel: "lol"
           end
         end
@@ -44,26 +44,26 @@ module Boty
 
       describe "#post_im" do
         let(:im_open_url) {
-          "https://slack.com/api/im.open?"+
-          "token=#{ENV['SLACK_BOT_API_TOKEN']}&user=U1234"
+          "https://slack.com/api/im.open?" \
+            "token=#{ENV['SLACK_BOT_API_TOKEN']}&user=U1234"
         }
 
         before do
-          allow(Slack::URL).to receive(:get).with(im_open_url).
-            and_return("channel" => { "id" => "C4321" })
+          allow(Slack::URL).to receive(:get).with(im_open_url)
+            .and_return("channel" => { "id" => "C4321" })
           allow(chat).to receive(:post_message)
         end
 
         it "calls `#im.open` to open the channel" do
-          expect(chat.im).to receive(:open).with("U1234").
-            and_return Channel.new(id: "C4321", info: {})
+          expect(chat.im).to receive(:open).with("U1234")
+            .and_return Channel.new(id: "C4321", info: {})
 
           chat.post_im "U1234", "message"
         end
 
         it "sends the message to the im channel returned by `#im.open`" do
-          expect(chat).to receive(:post_message).
-            with "message", channel: "C4321"
+          expect(chat).to receive(:post_message)
+            .with "message", channel: "C4321"
 
           chat.post_im "U1234", "message"
         end

data/spec/boty/slack/im_spec.rb

@@ -8,8 +8,8 @@ module Boty
       let(:action) { :open }
 
       let(:im_url) {
-        "https://slack.com/api/im.#{action}?"+
-        "token=#{ENV['SLACK_BOT_API_TOKEN']}"
+        "https://slack.com/api/im.#{action}?" \
+          "token=#{ENV['SLACK_BOT_API_TOKEN']}"
       }
 
       describe "#open" do
@@ -20,8 +20,8 @@ module Boty
         end
 
         it "returns a channel object with the im channel information" do
-          expect(Slack::URL).to receive(:get).with(im_url + "&user=U1234").
-            and_return(
+          expect(Slack::URL).to receive(:get).with(im_url + "&user=U1234")
+            .and_return(
               "ok" => true,
               "channel" => { "id" => "D024BFF1M" }
             )

data/spec/boty/slack/message_spec.rb

@@ -6,14 +6,16 @@ module Boty
       let(:user_id) { "U7777" }
       let(:user_name) { "julian" }
 
-      let(:message_json) {{
-        "type" => "message",
-        "text" => "omg lol bbq",
-        "user" => "U7777",
-        "channel" => "333",
-        "ts" => "1234",
-        "team" => "3452"
-      }}
+      let(:message_json) do
+        {
+          "type" => "message",
+          "text" => "omg lol bbq",
+          "user" => "U7777",
+          "channel" => "333",
+          "ts" => "1234",
+          "team" => "3452"
+        }
+      end
 
       it "uses Slack.users.info to create a User instance" do
         expect(message.user.id).to eq "U7777"
@@ -25,7 +27,7 @@ module Boty
           expect(message.from? "U7777").to eq true
         end
 
-        it "returns true if the param `respond_to? :id` returning the message author" do
+        it "returns true when param `#respond_to? :id` is the message author" do
           expect(message.from? OpenStruct.new(id: "U7777")).to eq true
         end
       end

data/spec/boty/slack/rtm_spec.rb

@@ -4,9 +4,9 @@ module Boty
       subject(:rtm) { described_class.new }
 
       let(:url_with_default_parameters) {
-        "https://#{ENV["SLACK_COMPANY"]}.slack.com/api/rtm.start?"+
-        "token=#{ENV["SLACK_BOT_API_TOKEN"]}&"+
-        "simple_latest=true&no_unreads=true"
+        "https://#{ENV['SLACK_COMPANY']}.slack.com/api/rtm.start?" \
+          "token=#{ENV['SLACK_BOT_API_TOKEN']}&" \
+          "simple_latest=true&no_unreads=true"
       }
 
       describe "#start" do

data/spec/boty/slack/url_spec.rb

@@ -31,8 +31,8 @@ module Boty
         end
 
         it "parses the json response" do
-          expect(Net::HTTP).to receive(:get).with(URI("http://example.org")).
-            and_return "{\"it\": \"works\"}"
+          expect(Net::HTTP).to receive(:get).with(URI("http://example.org"))
+            .and_return "{\"it\": \"works\"}"
           response = url.get "http://example.org"
           expect(response).to eq "it" => "works"
         end
@@ -48,11 +48,11 @@ module Boty
 
         it "appends the api token" do
           url = client.send :parameterize, {}
-          expect(url).to include "token=#{ENV["SLACK_BOT_API_TOKEN"]}"
+          expect(url).to include "token=#{ENV['SLACK_BOT_API_TOKEN']}"
         end
 
         it "add extra parameters" do
-          url = client.send :parameterize, {really: "omg"}
+          url = client.send :parameterize, really: "omg"
           expect(url).to include "really=omg"
         end
 
@@ -62,7 +62,7 @@ module Boty
         end
 
         it "applies URI.encode to parameter values" do
-          url = client.send :parameterize, {really: "omg lol"}
+          url = client.send :parameterize, really: "omg lol"
           expect(url).to include "really=omg%20lol"
         end
       end

data/spec/boty/slack/users_spec.rb

@@ -2,49 +2,49 @@ module Boty
   module Slack
     RSpec.describe Users do
       def url_for(action)
-        "https://slack.com/api/users.#{action}?"+
+        "https://slack.com/api/users.#{action}?" \
         "token=#{ENV['SLACK_BOT_API_TOKEN']}"
       end
 
       subject(:users) { described_class.new }
 
       before do
-        allow(Slack::URL).to receive(:get).with(url_for(:info) + "&user=U123456").
-          and_return(
+        allow(Slack::URL).to receive(:get)
+          .with(url_for(:info) + "&user=U123456").and_return(
             "ok" => true,
             "user" => {
               "id" => "U123456",
               "name" => "julian"
             }
-        )
+          )
 
-        allow(Slack::URL).to receive(:get).with(url_for(:list)).
-          and_return(
-            {
-              "ok" => true,
-              "members" => [
-                {
-                  "id"   => "U023BECGF",
-                  "name" => "bobby"
-                },
-                {
-                  "id" => "U123456",
-                  "name" => "julian"
-                }
-              ]
-            }
-        )
+        allow(Slack::URL).to receive(:get).with(url_for(:list))
+          .and_return(
+            "ok" => true,
+            "members" => [
+              {
+                "id"   => "U023BECGF",
+                "name" => "bobby"
+              },
+              {
+                "id" => "U123456",
+                "name" => "julian"
+              }
+            ]
+          )
       end
 
       describe "#info" do
         it "calls Slack::URL get with token and user" do
-          expect(Slack::URL).to receive(:get).with(url_for(:info) + "&user=U123456")
+          expect(Slack::URL).to receive(:get)
+            .with(url_for(:info) + "&user=U123456")
 
           users.info "U123456"
         end
 
         it "returns a channel object with the im channel information" do
-          expect(Slack::URL).to receive(:get).with(url_for(:info) + "&user=U123456")
+          expect(Slack::URL).to receive(:get)
+            .with(url_for(:info) + "&user=U123456")
 
           user = users.info("U123456")
 
@@ -56,7 +56,7 @@ module Boty
       describe "#list" do
         it "retrieves the users list" do
           list = Slack.users.list
-          expect(list.map(&:name)).to eq ["bobby", "julian"]
+          expect(list.map(&:name)).to eq %w(bobby julian)
         end
       end
 

data/spec/happy_path_spec.rb

@@ -5,13 +5,13 @@ module Boty
     def start_session(only_knows: nil)
       executable_bot = File.read "bot"
       @session = instance_eval executable_bot, "bot", 1
+      return unless only_knows
 
-      if only_knows
-        extra_to_remove = bot.know_how.keys - only_knows
-        extra_to_remove.each do |command_desc|
-          bot.no command_desc
+      bot.know_how.each { |action|
+        unless only_knows.include? action.desc.command
+          bot.no action.desc.command
         end
-      end
+      }
     end
 
     def message(message)
@@ -37,13 +37,14 @@ module Boty
           allow(cli).to receive(:ask).and_return "omg", "lol"
           cli.new bot_name
         end
-        expect(Dir.exists? bot_name).to eq true
+
+        expect(Dir.exist? bot_name).to eq true
 
         Dir.chdir bot_name
 
-        expect(File.read ".env.local").to eq %{SLACK_COMPANY=omg
+        expect(File.read ".env.local").to eq %(SLACK_COMPANY=omg
 SLACK_BOT_API_TOKEN=lol
-}
+)
       end
     end
 
@@ -61,37 +62,37 @@ SLACK_BOT_API_TOKEN=lol
         expect(Faye::WebSocket::Client).to receive(:new).with(rtm_ws_url)
         start_session
 
-        expect(bot).to receive(:say).
-          with "Ohay <@#{current_user}>! I'm here, that's for sure."
+        expect(bot).to receive(:say)
+          .with "Ohay <@#{current_user}>! I'm here, that's for sure."
         message "hey boty!"
       end
 
       describe "knows" do
         before do
-          start_session only_knows: ['knows']
+          start_session only_knows: ["knows"]
         end
 
         it "responds in particular with the known commands and handlers" do
           # check that a im arrived to the current user with knows result
           message = "```\nknows: List all the commands known by this bot.\n```"
-          expect{ message "<@boty>: knows" }.
-            to send_im(current_user_id, message)
+          expect { message "<@boty>: knows" }
+            .to send_im(current_user_id, message)
         end
       end
 
       it "overrides default locale with the project specific one" do
         File.open("locale/xpto.yml", "w") do |file|
-          file.write(%{xpto:
+          file.write(%(xpto:
   scripts:
-    knows: "Wow! Such commands!"})
+    knows: "Wow! Such commands!"))
         end
-        start_session only_knows: ['knows']
+        start_session only_knows: ["knows"]
         ::Boty.locale = :xpto
 
         message = "```\nknows: List all the commands known by this bot.\n```"
 
-        expect{ message "<@boty>: knows" }.
-          to send_im(current_user_id, message)
+        expect { message "<@boty>: knows" }
+          .to send_im(current_user_id, message)
       end
     end
   end