slack-ruby-client 0.4.0 → 0.5.0

data/lib/slack/real_time/concurrency.rb

@@ -0,0 +1,8 @@
+module Slack
+  module RealTime
+    module Concurrency
+      autoload :Eventmachine, 'slack/real_time/concurrency/eventmachine'
+      autoload :Celluloid, 'slack/real_time/concurrency/celluloid'
+    end
+  end
+end

data/lib/slack/real_time/concurrency/celluloid.rb

@@ -0,0 +1,92 @@
+require 'websocket/driver'
+require 'socket'
+require 'forwardable'
+require 'celluloid/io'
+
+module Slack
+  module RealTime
+    module Concurrency
+      module Celluloid
+        class Socket < Slack::RealTime::Socket
+          include ::Celluloid::IO
+          include ::Celluloid::Logger
+
+          BLOCK_SIZE = 4096
+
+          extend ::Forwardable
+          def_delegator :socket, :write
+          def_delegators :driver, :text, :binary, :close
+
+          attr_reader :socket
+
+          def initialize(*args)
+            super
+            @driver = build_driver
+          end
+
+          # @yieldparam [WebSocket::Driver] driver
+          def connect!
+            super
+
+            driver.start
+            future.run_loop
+          end
+
+          def run_loop
+            loop { read } if socket
+          rescue EOFError
+            # connection closed
+          end
+
+          def read
+            buffer = socket.readpartial(BLOCK_SIZE)
+            driver.parse buffer
+          end
+
+          def start_async
+            future = yield self if block_given?
+
+            Actor.new(future)
+          end
+
+          protected
+
+          class Actor
+            attr_reader :future
+
+            def initialize(future)
+              @future = future
+            end
+
+            def join
+              @future.value
+            end
+          end
+
+          def connected?
+            !@connected.nil?
+          end
+
+          def build_socket
+            socket = TCPSocket.new(addr, port)
+            socket = SSLSocket.new(socket, build_ssl_context) if secure?
+            socket
+          end
+
+          def build_ssl_context
+            OpenSSL::SSL::SSLContext.new(:TLSv1_2_client)
+          end
+
+          def build_driver
+            ::WebSocket::Driver.client(self)
+          end
+
+          def connect
+            @socket = build_socket
+            @connected = @socket.connect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/concurrency/eventmachine.rb

@@ -0,0 +1,39 @@
+require 'faye/websocket'
+require 'eventmachine'
+
+module Slack
+  module RealTime
+    module Concurrency
+      module Eventmachine
+        class Socket < Slack::RealTime::Socket
+          def start_async
+            thread = ensure_reactor_running
+
+            yield self if block_given?
+
+            thread
+          end
+
+          def send_data(message)
+            driver.send(message)
+          end
+
+          protected
+
+          # @return [Thread]
+          def ensure_reactor_running
+            return if EventMachine.reactor_running?
+
+            reactor = Thread.new { EventMachine.run }
+            Thread.pass until EventMachine.reactor_running?
+            reactor
+          end
+
+          def connect
+            @driver = ::Faye::WebSocket::Client.new(url, nil, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/config.rb

@@ -1,12 +1,15 @@
 module Slack
   module RealTime
     module Config
+      class NoConcurrencyError < StandardError; end
+
       extend self
 
       ATTRIBUTES = [
         :token,
         :websocket_ping,
-        :websocket_proxy
+        :websocket_proxy,
+        :concurrency
       ]
 
       attr_accessor(*Config::ATTRIBUTES)
@@ -15,6 +18,25 @@ module Slack
         self.websocket_ping = 30
         self.websocket_proxy = nil
         self.token = nil
+        self.concurrency = method(:detect_concurrency)
+      end
+
+      def concurrency
+        (val = @concurrency).respond_to?(:call) ? val.call : val
+      end
+
+      private
+
+      def detect_concurrency
+        [:Eventmachine, :Celluloid].each do |concurrency|
+          begin
+            return Slack::RealTime::Concurrency.const_get(concurrency)
+          rescue LoadError
+            false # could not be loaded, missing dependencies
+          end
+        end
+
+        fail NoConcurrencyError, 'Missing concurrency. Add faye-websocket or celluloid-io to your Gemfile.'
       end
     end
 

data/lib/slack/real_time/socket.rb

@@ -3,40 +3,78 @@ module Slack
     class Socket
       attr_accessor :url
       attr_accessor :options
+      attr_reader :driver
 
       def initialize(url, options = {})
         @url = url
         @options = options
+        @driver = nil
       end
 
-      def send_data(data)
-        @ws.send(data) if @ws
+      def send_data(message)
+        case message
+        when Numeric then driver.text(message.to_s)
+        when String  then driver.text(message)
+        when Array   then driver.binary(message)
+        else false
+        end
       end
 
-      def connect!(&_block)
+      def connect!
         return if connected?
 
-        @ws = Faye::WebSocket::Client.new(url, nil, options)
-
-        @ws.on :close do |event|
-          close(event)
-        end
+        connect
 
-        yield @ws if block_given?
+        yield driver if block_given?
       end
 
       def disconnect!
-        @ws.close if @ws
+        driver.close
       end
 
       def connected?
-        !@ws.nil?
+        !driver.nil?
+      end
+
+      def start_sync(&block)
+        thread = start_async(&block)
+        thread.join if thread
+      rescue Interrupt
+        thread.exit if thread
+      end
+
+      # @return [#join]
+      def start_async
+        fail NotImplementedError, "Expected #{self.class} to implement #{__method__}."
       end
 
       protected
 
+      def addr
+        URI(url).host
+      end
+
+      def secure?
+        port == URI::HTTPS::DEFAULT_PORT
+      end
+
+      def port
+        case (uri = URI(url)).scheme
+        when 'wss'.freeze, 'https'.freeze
+          URI::HTTPS::DEFAULT_PORT
+        when 'ws', 'http'.freeze
+          URI::HTTP::DEFAULT_PORT
+        else
+          uri.port
+        end
+      end
+
+      def connect
+        fail NotImplementedError, "Expected #{self.class} to implement #{__method__}."
+      end
+
       def close(_event)
-        @ws = nil
+        @driver = nil
       end
     end
   end

data/lib/slack/version.rb

@@ -1,3 +1,3 @@
 module Slack
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/slack/web/api/endpoints.rb

@@ -16,6 +16,7 @@ require 'slack/web/api/endpoints/rtm'
 require 'slack/web/api/endpoints/search'
 require 'slack/web/api/endpoints/stars'
 require 'slack/web/api/endpoints/team'
+require 'slack/web/api/endpoints/usergroups'
 require 'slack/web/api/endpoints/users'
 
 module Slack
@@ -38,6 +39,7 @@ module Slack
         include Search
         include Stars
         include Team
+        include Usergroups
         include Users
       end
     end

data/lib/slack/web/api/endpoints/groups.rb

@@ -21,7 +21,7 @@ module Slack
           # This method closes a private group.
           #
           # @option options [group] :channel
-          #   Group to open.
+          #   Group to close.
           # @see https://api.slack.com/methods/groups.close
           # @see https://github.com/dblock/slack-api-ref/blob/master/methods/groups.close.json
           def groups_close(options = {})

data/lib/slack/web/api/endpoints/team.rb

@@ -31,7 +31,7 @@ module Slack
           # @option options [Object] :app_id
           #   Filter logs to this API application. Defaults to all logs.
           # @option options [user] :user
-          #   Filter logs generated by this user’s actions. Defaults to all logs.
+          #   Filter logs generated by this user's actions. Defaults to all logs.
           # @option options [Object] :change_type
           #   Filter logs with this change type. Defaults to all logs.
           # @see https://api.slack.com/methods/team.integrationLogs

data/lib/slack/web/api/endpoints/usergroups.rb

@@ -0,0 +1,113 @@
+# This file was auto-generated by lib/slack/web/api/tasks/generate.rake
+
+module Slack
+  module Web
+    module Api
+      module Endpoints
+        module Usergroups
+          #
+          # This method is used to create a user group.
+          #
+          # @option options [Object] :name
+          #   A name for the user group. Must be unique among user groups.
+          # @option options [Object] :handle
+          #   A mention handle. Must be unique among channels, users and user groups.
+          # @option options [Object] :description
+          #   A short description of the user group.
+          # @option options [Object] :channels
+          #   A comma separated string of encoded channel IDs for which the user group uses as a default.
+          # @option options [Object] :include_count
+          #   Include the number of users in each user group.
+          # @see https://api.slack.com/methods/usergroups.create
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.create.json
+          def usergroups_create(options = {})
+            throw ArgumentError.new('Required arguments :name missing') if options[:name].nil?
+            post('usergroups.create', options)
+          end
+
+          #
+          # This method disables an existing user group.
+          #
+          # @option options [Object] :usergroup
+          #   The encoded ID of the user group to disable.
+          # @option options [Object] :include_count
+          #   Include the number of users in the user group.
+          # @see https://api.slack.com/methods/usergroups.disable
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.disable.json
+          def usergroups_disable(options = {})
+            throw ArgumentError.new('Required arguments :usergroup missing') if options[:usergroup].nil?
+            post('usergroups.disable', options)
+          end
+
+          #
+          # This method enables a user group which was previously disabled.
+          #
+          # @option options [Object] :usergroup
+          #   The encoded ID of the user group to enable.
+          # @option options [Object] :include_count
+          #   Include the number of users in the user group.
+          # @see https://api.slack.com/methods/usergroups.enable
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.enable.json
+          def usergroups_enable(options = {})
+            throw ArgumentError.new('Required arguments :usergroup missing') if options[:usergroup].nil?
+            post('usergroups.enable', options)
+          end
+
+          #
+          # This method returns a list of all user groups in the team. This can optionally include disabled user groups.
+          #
+          # @option options [Object] :include_disabled
+          #   Include disabled user groups.
+          # @option options [Object] :include_count
+          #   Include the number of users in each user group.
+          # @option options [Object] :include_users
+          #   Include the list of users for each user group.
+          # @see https://api.slack.com/methods/usergroups.list
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.list.json
+          def usergroups_list(options = {})
+            post('usergroups.list', options)
+          end
+
+          #
+          # This method updates the properties of an existing user group.
+          #
+          # @option options [Object] :usergroup
+          #   The encoded ID of the user group to update.
+          # @option options [Object] :name
+          #   A name for the user group. Must be unique among user groups.
+          # @option options [Object] :handle
+          #   A mention handle. Must be unique among channels, users and user groups.
+          # @option options [Object] :description
+          #   A short description of the user group.
+          # @option options [Object] :channels
+          #   A comma separated string of encoded channel IDs for which the user group uses as a default.
+          # @option options [Object] :include_count
+          #   Include the number of users in the user group.
+          # @see https://api.slack.com/methods/usergroups.update
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.update.json
+          def usergroups_update(options = {})
+            throw ArgumentError.new('Required arguments :usergroup missing') if options[:usergroup].nil?
+            post('usergroups.update', options)
+          end
+
+          #
+          # This method updates the list of users that belong to a user group. This method replaces all users in a user group with the list of users provided in the users parameter.
+          #
+          # @option options [Object] :usergroup
+          #   The encoded ID of the user group to update.
+          # @option options [Object] :users
+          #   A comma separated string of encoded user IDs that represent the entire list of users for the user group.
+          # @option options [Object] :include_count
+          #   Include the number of users in the user group.
+          # @see https://api.slack.com/methods/usergroups.users
+          # @see https://github.com/dblock/slack-api-ref/blob/master/methods/usergroups.users.json
+          def usergroups_users(options = {})
+            throw ArgumentError.new('Required arguments :usergroup missing') if options[:usergroup].nil?
+            throw ArgumentError.new('Required arguments :users missing') if options[:users].nil?
+            post('usergroups.users', options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/web/api/error.rb

@@ -2,6 +2,12 @@ module Slack
   module Web
     module Api
       class Error < ::Faraday::Error
+        attr_reader :response
+
+        def initialize(message, response)
+          @response = response
+          super message
+        end
       end
     end
   end

data/lib/slack/web/api/schema/group.json

@@ -0,0 +1,14 @@
+{
+  "type": "object",
+  "required": [
+    "name"
+  ],
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "desc": {
+      "type": "string"
+    }
+  }
+}