slack-api-wrapper 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c18b521343ae2907134d7af29d23616e0990ec2
+  data.tar.gz: a8fc73773601ce072195cf08bde1bf0247b7e3db
+SHA512:
+  metadata.gz: 1b4e7a04162651cbf861fd47928ce96735666cb5f942b2d51d3f103f6d948c8e2871606e37e0f758c4bba02617a100aaa4766c26922514262bcbeb5ec402fd57
+  data.tar.gz: d667a8f1236fa4cf4bb5c337c1a8a0ae460e11741b48fa1020bdc9f9f03b6bcf796e16a37bf513080469a5e60b7e54ef166a22e37f77cdf2c4d128a7004337fc

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slack.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Gustavo Bazan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+Slack API Wrapper [![Build Status](https://travis-ci.org/gssbzn/slack-api-wrapper.svg)](https://travis-ci.org/gssbzn/slack-api-wrapper)
+=========================
+
+A library that provides a plain function-call interface to the Slack API web endpoints.
+
+This a work in progress, many API endpoint implementations are still missing,
+I expect to add them as soon as possible or you can help by making a pull request.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'slack-api-wrapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install slack-api-wrapper
+
+## Usage
+
+TODO: Write usage instructions here
+
+You can see a demo here [slack-web-test](https://github.com/gssbzn/slack-web-test)
+
+## Contributing
+
+1. Fork it ( https://github.com/gssbzn/slack-api-wrapper/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+## License
+
+MIT License. Copyright 2015 Gustavo Bazan. http://gustavobazan.com
+
+This software is not created by, affiliated with, or supported by Slack Technologies, Inc.

data/Rakefile

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

data/lib/slack-api-wrapper.rb

@@ -0,0 +1,87 @@
+require 'net/https'
+require 'cgi'
+require 'json'
+
+require_relative "slack/version"
+require_relative "slack/error"
+require_relative "slack/session"
+require_relative "slack/oauth2"
+require_relative "slack/client"
+
+module Slack # :nodoc:
+  WEB_SERVER = 'slack.com'
+  API_SERVER = "#{WEB_SERVER}/api"
+
+  #
+  def self.clean_params(params)
+    r = {}
+    params.each do |k,v|
+      r[k] = v.to_s unless v.nil?
+    end
+    r
+  end
+
+  #
+  def self.make_query_string(params)
+    clean_params(params).collect {|k,v|
+      CGI.escape(k) + "=" + CGI.escape(v)
+    }.join("&")
+  end
+
+  #
+  def self.do_http(uri, request) # :nodoc:
+
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    http.use_ssl = true
+
+    # Let then know about us
+    request['User-Agent'] =  "SlackRubyAPIWrapper"
+
+    begin
+      http.request(request)
+    rescue OpenSSL::SSL::SSLError => e
+      raise SlackError.new("SSL error connecting to Slack.")
+    end
+  end
+
+  # Parse response. You probably shouldn't be calling this directly.  This takes responses from the server
+  # and parses them.  It also checks for errors and raises exceptions with the appropriate messages.
+  def self.parse_response(response, raw=false) # :nodoc:
+    if response.kind_of?(Net::HTTPServerError)
+      raise Slack.new("Slack Server Error: #{response} - #{response.body}", response)
+    elsif response.kind_of?(Net::HTTPUnauthorized)
+      raise SlackAuthError.new("User is not authenticated.", response)
+    elsif !response.kind_of?(Net::HTTPSuccess)
+      begin
+        d = JSON.parse(response.body)
+      rescue
+        raise SlackError.new("Slack Server Error: body=#{response.body}", response)
+      end
+      if d['error']
+        raise SlackError.new(d['error'], response)
+      else
+        raise SlackError.new(response.body, response)
+      end
+    end
+
+    return response.body if raw
+
+    begin
+      return JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise SlackError.new("Unable to parse JSON response: #{response.body}", response)
+    end
+  end
+
+  # A string comparison function that is resistant to timing attacks.  If you're comparing a
+  # string you got from the outside world with a string that is supposed to be a secret, use
+  # this function to check equality.
+  def self.safe_string_equals(a, b)
+    if a.length != b.length
+      false
+    else
+      a.chars.zip(b.chars).map {|ac,bc| ac == bc}.all?
+    end
+  end
+end

data/lib/slack/client.rb

@@ -0,0 +1,20 @@
+require_relative 'session'
+require_relative 'web'
+
+module Slack
+  # Use this class to make Slack API calls.  You'll need to obtain an OAuth 2 access token
+  # first; you can get one using either SlackOAuth2Flow.
+  class Client
+    include Web
+
+    # Args:
+    # * +oauth2_access_token+: Obtained via Slack::OAuth2::Flow or Slack::OAuth2::FlowNoRedirect.
+    def initialize(oauth2_access_token)
+      if oauth2_access_token.is_a?(String)
+        @session = OAuth2Session.new(oauth2_access_token)
+      else
+        raise ArgumentError.new("oauth2_access_token doesn't have a valid type")
+      end
+    end
+  end
+end

data/lib/slack/error.rb

@@ -0,0 +1,21 @@
+# This is the usual error raised on any Slack related Errors
+module Slack
+  class Error < RuntimeError
+    attr_accessor :http_response, :error
+    def initialize(error, http_response=nil)
+      @error = error
+      @http_response = http_response
+    end
+
+    def to_s
+      "#{error}"
+    end
+  end
+
+  # This is the error raised on Authentication failures.  Usually this means
+  # one of three things
+  # * Your user failed to go to the authorize url and approve your application
+  # * You set an invalid or expired token and secret on your Session
+  # * Your user deauthorized the application after you stored a valid token and secret
+  class AuthError < Error; end
+end

data/lib/slack/oauth2.rb

@@ -0,0 +1,6 @@
+require_relative 'oauth2/flow_base'
+require_relative 'oauth2/flow'
+module Slack
+  module Oauth2
+  end
+end

data/lib/slack/oauth2/flow.rb

@@ -0,0 +1,155 @@
+require 'securerandom'
+
+require_relative 'flow_base'
+
+module Slack
+  module OAuth2
+    # The standard OAuth 2 authorization helper.  Use this if you're writing a web app.
+    class Flow < FlowBase
+
+      # * consumer_key: Your Slack API app's "app key"
+      # * consumer_secret: Your Slack API app's "app secret"
+      # * redirect_uri: The URI that the Slack server will redirect the user to after the user
+      #   finishes authorizing your app.  This URI  must be HTTPs-based and pre-registered with
+      #   the Slack servers.
+      # * session: A hash that represents the current web app session (will be used to save the CSRF
+      #   token)
+      # * csrf_token_key: The key to use when storing the CSRF token in the session (for example,
+      #   :slack_auth_csrf_token)
+      def initialize(consumer_key, consumer_secret, redirect_uri, scope, team, session, csrf_token_session_key)
+        super(consumer_key, consumer_secret, scope, team)
+        unless redirect_uri.is_a?(String)
+          raise ArgumentError, "redirect_uri must be a String, got #{consumer_secret.inspect}"
+        end
+        @redirect_uri = redirect_uri
+        @session = session
+        @csrf_token_session_key = csrf_token_session_key
+      end
+
+      # Starts the OAuth 2 authorizaton process, which involves redirecting the user to
+      # the returned "authorization URL" (a URL on the Slack website).  When the user then
+      # either approves or denies your app access, Slack will redirect them to the
+      # redirect_uri you provided to the constructor, at which point you should call finish()
+      # to complete the process.
+      #
+      # This function will also save a CSRF token to the session and csrf_token_session_key
+      # you provided to the constructor.  This CSRF token will be checked on finish() to prevent
+      # request forgery.
+      #
+      # * url_state: Any data you would like to keep in the URL through the authorization
+      #   process.  This exact value will be returned to you by finish().
+      #
+      # Returns the URL to redirect the user to.
+      def start(url_state=nil)
+        unless url_state.nil? or url_state.is_a?(String)
+          raise ArgumentError, "url_state must be a String"
+        end
+
+        csrf_token = SecureRandom.base64(16)
+        state = csrf_token
+        unless url_state.nil?
+            state += "|" + url_state
+        end
+        @session[@csrf_token_session_key] = csrf_token
+        _get_authorize_url(@redirect_uri, state)
+      end
+
+      # Call this after the user has visited the authorize URL (see: start()), approved your app,
+      # and was redirected to your redirect URI.
+      #
+      # * query_params: The query params on the GET request to your redirect URI.
+      #
+      # Returns a tuple of (access_token, scope, url_state).  access_token can be used to
+      # construct a SlackClient.  scpe is the Slack scope the user that jsut approved
+      # your app.  url_state is the value you originally passed in to start().
+      #
+      # Can throw BadRequestError, BadStateError, CsrfError, NotApprovedError,
+      # ProviderError.
+      def finish(query_params)
+        csrf_token_from_session = @session[@csrf_token_session_key]
+
+        # Check well-formedness of request.
+
+        # Check well-formedness of request.
+
+        state = query_params['state']
+        if state.nil?
+          raise BadRequestError.new("Missing query parameter 'state'.")
+        end
+        code = query_params['code']
+
+        error = query_params['error']
+
+        unless (error.nil? || code.nil?)
+          raise BadRequestError.new("Query parameters 'code' and 'error' are both set;" +
+          " only one must be set.")
+        end
+        if error.nil? and code.nil?
+          raise BadRequestError.new("Neither query parameter 'code' or 'error' is set.")
+        end
+
+        # Check CSRF token
+
+        if csrf_token_from_session.nil?
+          raise BadStateError.new("Missing CSRF token in session.");
+        end
+        unless csrf_token_from_session.length > 20
+          raise RuntimeError.new("CSRF token unexpectedly short: #{csrf_token_from_session.inspect}")
+        end
+
+        split_pos = state.index('|')
+        if split_pos.nil?
+          given_csrf_token = state
+          url_state = nil
+        else
+          given_csrf_token, url_state = state.split('|', 2)
+        end
+        unless Slack::safe_string_equals(csrf_token_from_session, given_csrf_token)
+          raise CsrfError.new("Expected #{csrf_token_from_session.inspect}, " +
+                              "got #{given_csrf_token.inspect}.")
+        end
+        @session.delete(@csrf_token_session_key)
+
+        # Check for error identifier
+
+        unless error.nil?
+          if error == 'access_denied'
+            # The user clicked "Deny"
+            raise NotApprovedError.new("No additional description from Slack.")
+          else
+            raise ProviderError.new(error)
+          end
+        end
+
+        # If everything went ok, make the network call to get an access token.
+
+        access_token, scope = _finish(code, @redirect_uri)
+        return access_token, scope, url_state
+      end
+
+      # Thrown if the redirect URL was missing parameters or if the given parameters were not valid.
+      #
+      # The recommended action is to show an HTTP 400 error page.
+      class BadRequestError < Exception; end
+
+      # Thrown if all the parameters are correct, but there's no CSRF token in the session.  This
+      # probably means that the session expired.
+      #
+      # The recommended action is to redirect the user's browser to try the approval process again.
+      class BadStateError < Exception; end
+
+      # The user chose not to approve your app.
+      class NotApprovedError < Exception; end
+
+      # Thrown if the given 'state' parameter doesn't contain the CSRF token from the user's session.
+      # This is blocked to prevent CSRF attacks.
+      #
+      # The recommended action is to respond with an HTTP 403 error page.
+      class CsrfError < Exception; end
+
+      # Slack redirected to your redirect URI with some unexpected error identifier and error
+      # message.
+      class ProviderError < Exception; end
+    end
+  end
+end

data/lib/slack/oauth2/flow_base.rb

@@ -0,0 +1,78 @@
+require 'uri'
+
+module Slack
+  module OAuth2
+    # Base class for the OAuth 2 authorization helpers.
+    class FlowBase  # :nodoc:
+      def initialize(consumer_key, consumer_secret, scope, team)
+        unless consumer_key.is_a?(String)
+          raise ArgumentError, "consumer_key must be a String, got #{consumer_key.inspect}"
+        end
+        unless consumer_secret.is_a?(String)
+          raise ArgumentError, "consumer_secret must be a String, got #{consumer_secret.inspect}"
+        end
+        unless scope.is_a?(String)
+          raise ArgumentError, "scope must be a String, got #{scope.inspect}"
+        end
+
+        @consumer_key = consumer_key
+        @consumer_secret = consumer_secret
+        @scope = scope
+        @team = team
+      end
+
+      protected
+
+      def _get_authorize_url(redirect_uri, state)
+        params = {
+          "client_id" => @consumer_key,
+          "redirect_uri" => redirect_uri,
+          "scope" => @scope,
+          "state" => state,
+          "team" => @team
+        }
+
+        host = Slack::WEB_SERVER
+        path = "/oauth/authorize"
+
+        target = URI::Generic.new("https", nil, host, nil, nil, path, nil, nil, nil)
+        target.query = Slack::make_query_string(params)
+
+        target.to_s
+      end
+
+      # Finish the OAuth 2 authorization process.  If you used a redirect_uri, pass that in.
+      # Will return an access token string that you can use with SlackClient.
+      def _finish(code, original_redirect_uri)
+
+        raise ArgumentError, "code must be a String" unless code.is_a?(String)
+
+        uri = URI.parse("https://#{Slack::API_SERVER}/oauth.access")
+        request = Net::HTTP::Post.new(uri.request_uri)
+
+        params = {
+          "client_id" => @consumer_key,
+          "client_secret" => @consumer_secret,
+          "code" => code,
+          "redirect_uri" => original_redirect_uri
+        }
+
+        request.set_form_data(Slack::clean_params(params))
+
+        response = Slack::do_http(uri, request)
+
+        j = Slack::parse_response(response)
+        ["access_token", "scope"].each do |k|
+          unless j.has_key?(k)
+            raise Slack::Error.new("Bad response from /token: missing \"#{k}\".")
+          end
+          unless j[k].is_a?(String)
+            raise Slack::Error.new("Bad response from /token: field \"#{k}\" is not a string.")
+          end
+        end
+
+        return j['access_token'], j['scope']
+      end
+    end
+  end
+end

data/lib/slack/session.rb

@@ -0,0 +1,77 @@
+module Slack
+
+  class OAuth2Session # :nodoc:
+
+    def initialize(oauth2_access_token)
+      unless oauth2_access_token.is_a?(String)
+        raise "bad type for oauth2_access_token (expecting String)"
+      end
+      @access_token = oauth2_access_token
+    end
+
+    private
+
+    def build_url(path)
+      host = Slack::WEB_SERVER
+      full_path = "/api/#{path}"
+      URI::HTTPS.build({host: host, path: full_path})
+    end
+
+    def build_url_with_params(path, params) # :nodoc:
+      target = build_url(path)
+      target.query = Slack::make_query_string(params)
+      target
+    end
+
+    protected
+
+    def do_http(uri, request) # :nodoc:
+      Slack::do_http(uri, request)
+    end
+
+    public
+
+    def do_get(path, params=nil, headers=nil)  # :nodoc:
+      params ||= {}
+      params["token"] = @access_token
+      uri = build_url_with_params(path, params)
+      do_http(uri, Net::HTTP::Get.new(uri.request_uri))
+    end
+
+    def do_http_with_body(uri, request, body)
+      if body != nil
+        if body.is_a?(Hash)
+          request.set_form_data(Slack::clean_params(body))
+        elsif body.respond_to?(:read)
+          if body.respond_to?(:length)
+            request["Content-Length"] = body.length.to_s
+          elsif body.respond_to?(:stat) && body.stat.respond_to?(:size)
+            request["Content-Length"] = body.stat.size.to_s
+          else
+            raise ArgumentError, "Don't know how to handle 'body' (responds to 'read' but not to 'length' or 'stat.size')."
+          end
+          request.body_stream = body
+        else
+          s = body.to_s
+          request["Content-Length"] = s.length
+          request.body = s
+        end
+      end
+      do_http(uri, request)
+    end
+
+    def do_post(path, params=nil, headers=nil)  # :nodoc:
+      params ||= {}
+      params["token"] = @access_token
+      uri = build_url(path)
+      do_http_with_body(uri, Net::HTTP::Post.new(uri.request_uri, headers), params)
+    end
+
+    def do_put(path, params=nil, headers=nil, body=nil)  # :nodoc:
+      params ||= {}
+      params["token"] = @access_token
+      uri = build_url_with_params(path, params)
+      do_http_with_body(uri, Net::HTTP::Put.new(uri.request_uri, headers), body)
+    end
+  end
+end

data/lib/slack/version.rb

@@ -0,0 +1,3 @@
+module Slack
+  VERSION = "0.0.2"
+end

data/lib/slack/web.rb

@@ -0,0 +1,28 @@
+require_relative 'web/auth'
+require_relative 'web/channels'
+require_relative 'web/chat'
+require_relative 'web/emoji'
+require_relative 'web/files'
+require_relative 'web/groups'
+require_relative 'web/im'
+require_relative 'web/search'
+require_relative 'web/stars'
+require_relative 'web/users'
+require_relative 'error'
+
+module Slack
+  module Web
+    include Auth
+    include Channels
+    include Chat
+    include Emoji
+    include Files
+    include Groups
+    include Im
+    include Stars
+    include Search
+    include Users
+
+    class NotImplementedError < Exception; end
+  end
+end

data/lib/slack/web/auth.rb

@@ -0,0 +1,10 @@
+module Slack
+  module Web
+    module Auth
+      def auth_test
+        response = @session.do_get "auth.test"
+        Slack::parse_response(response)
+      end
+    end
+  end
+end

data/lib/slack/web/channels.rb

@@ -0,0 +1,82 @@
+module Slack
+  module Web
+    module Channels
+      SCOPE = "channels"
+
+      # Archives a channel.
+      def channels_archive(channel)
+        response = @session.do_get "#{SCOPE}.archive", "channel" => channel
+        Slack::parse_response(response)
+      end
+
+      # Creates a channel.
+      def channels_create(name)
+        response = @session.do_get "#{SCOPE}.create", "name" => name
+        Slack::parse_response(response)
+      end
+
+      # Fetches history of messages and events from a channel.
+      def channels_history(channel, latest, oldest, inclusive, count)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Gets information about a channel.
+      def channels_info(channel)
+        response = @session.do_get "#{SCOPE}.info", "channel" => channel
+        Slack::parse_response(response)
+      end
+
+      # Invites a user to a channel.
+      def channels_invite(channel, user)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Joins a channel, creating it if needed.
+      def channels_join(name)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Removes a user from a channel.
+      def channels_kick(channel, user)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Leaves a channel.
+      def channels_leave(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Lists all channels in a Slack team.
+      def channels_list(exclude_archived=0)
+        response = @session.do_get "#{SCOPE}.list", "exclude_archived" => exclude_archived
+        Slack::parse_response(response)
+      end
+
+      # Sets the read cursor in a channel.
+      def channels_mark(channel, ts)
+        raise Slack::Error("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Renames a channel.
+      def channels_rename(channel, name)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Sets the purpose for a channel.
+      def channels_set_purpose(channel, purpose)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Sets the topic for a channel.
+      def channels_set_topic(channel, topic)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Unarchives a channel.
+      def channels_unarchive(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+    end
+  end
+end

data/lib/slack/web/chat.rb

@@ -0,0 +1,44 @@
+module Slack
+  module Web
+    module Chat
+      SCOPE = "chat"
+
+      # Deletes a message.
+      def chat_delete(ts, channel)
+        param = {
+          "ts" => ts,
+          "channel" => channel
+        }
+        response = @session.do_get "#{SCOPE}.delete", param
+        Slack::parse_response(response)
+      end
+
+      # Sends a message to a channel.
+      def chat_post_message(channel, text, username, as_user= false, parse, link_names, attachments)
+        param = {
+          "channel" => channel,
+          "text" => text,
+          "username" => username,
+          "as_user" => as_user,
+          "parse" => parse,
+          "link_names" => link_names,
+          "attachments" => attachments
+        }
+        response = @session.do_get "#{SCOPE}.postMessage", param
+        Slack::parse_response(response)
+      end
+
+      # Updates a message.
+      def chat_update(ts, channel, text)
+        param = {
+          "ts" => ts,
+          "channel" => channel,
+          "text" => text
+        }
+        response = @session.do_get "#{SCOPE}.update", param
+        Slack::parse_response(response)
+      end
+
+    end
+  end
+end

data/lib/slack/web/emoji.rb

@@ -0,0 +1,13 @@
+module Slack
+  module Web
+    module Emoji
+      SCOPE = "emoji"
+
+      # Lists custom emoji for a team.
+      def emoji_list
+        response = @session.do_get "#{SCOPE}.list"
+        Slack::parse_response(response)
+      end
+    end
+  end
+end

data/lib/slack/web/files.rb

@@ -0,0 +1,53 @@
+module Slack
+  module Web
+    module Files
+      SCOPE = "files"
+
+      #Deletes a file.
+      def files_delete(file)
+        response = @session.do_get "#{SCOPE}.delete", "file" => file
+        Slack::parse_response(response)
+      end
+
+      # Gets information about a team file.
+      def files_info(file, count=100, page=1)
+        param = {
+          "file" => file,
+          "count" => count,
+          "page" => page
+        }
+        response = @session.do_get "#{SCOPE}.info", param
+        Slack::parse_response(response)
+      end
+
+      # Lists & filters team files.
+      def files_list(user, ts_from=0, ts_to=Time.now, types="all", count=100, page=1)
+        param = {
+          "user" => user,
+          "ts_from" => ts_from,
+          "ts_to" => ts_to,
+          "types" => types,
+          "count" => count,
+          "page" => page
+        }
+        response = @session.do_get "#{SCOPE}.list", param
+        Slack::parse_response(response)
+      end
+
+      # Uploads or creates a file.
+      def files_upload(file, content, filetype, filename, title, initial_comment, channels)
+        param = {
+          "file" => file,
+          "content" => content,
+          "filetype" => filetype,
+          "filename" => filename,
+          "title" => title,
+          "initial_comment" => initial_comment,
+          "channels" => channels
+        }
+        response = @session.do_get "#{SCOPE}.upload", param
+        Slack::parse_response(response)
+      end
+    end
+  end
+end

data/lib/slack/web/groups.rb

@@ -0,0 +1,88 @@
+module Slack
+  module Web
+    module Groups
+      SCOPE = "groups"
+
+      # Archives a private group.
+      def groups_archive(channel)
+        response = @session.do_get "#{SCOPE}.archive", "channel" => channel
+        Slack::parse_response(response)
+      end
+
+      # Closes a private group.
+      def groups_close(channel)
+        response = @session.do_get "#{SCOPE}.close", "channel" => channel
+        Slack::parse_response(response)
+      end
+
+      # Creates a private group.
+      def groups_create(name)
+        response = @session.do_get "#{SCOPE}.create", "name" => name
+        Slack::parse_response(response)
+      end
+
+      # Clones and archives a private group.
+      def groups_create_child(channel)
+        response = @session.do_get "#{SCOPE}.createChild", "channel" => channel
+        Slack::parse_response(response)
+      end
+
+      # Fetches history of messages and events from a private group.
+      def groups_history(channel, latest, oldest, inclusive, count)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Invites a user to a private group.
+      def groups_invite(channel, user)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Removes a user from a private group.
+      def groups_kick(channel, user)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Leaves a private group.
+      def groups_leave(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Lists private groups that the calling user has access to..
+      def groups_list(exclude_archived=0)
+        response = @session.do_get "#{SCOPE}.list", "exclude_archived" => exclude_archived
+        Slack::parse_response(response)
+      end
+
+      # Sets the read cursor in a private group.
+      def groups_mark(channel, ts)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Opens a private group.
+      def groups_open(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Renames a private group.
+      def groups_rename(channel, name)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Sets the purpose for a private group.
+      def groups_set_purpose(channel, purpose)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Sets the topic for a private group.
+      def groups_set_topic(channel, topic)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Unarchives a private group.
+      def groups_unarchive(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+    end
+  end
+end

data/lib/slack/web/im.rb

@@ -0,0 +1,34 @@
+module Slack
+  module Web
+    module Im
+      SCOPE = "im"
+
+      # Close a direct message channel.
+      def im_close(channel)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Fetches history of messages and events from direct message channel.
+      def im_history(channel, latest, oldest, inclusive, count)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Lists direct message channels for the calling user.
+      def im_list
+        response = @session.do_get "#{SCOPE}.list"
+        Slack::parse_response(response)
+      end
+
+      # Sets the read cursor in a direct message channel.
+      def im_mark(channel, ts)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Opens a direct message channel.
+      def im_open(user)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+    end
+  end
+end

data/lib/slack/web/search.rb

@@ -0,0 +1,23 @@
+module Slack
+  module Web
+    module Search
+      SCOPE = "search"
+
+      # Searches for messages and files matching a query.
+      def search_all(query, sort, sort_dir, highlight, count, page)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Searches for files matching a query.
+      def search_files(query, sort, sort_dir, highlight, count, page)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+      # Searches for messages matching a query.
+      def search_messages(query, sort, sort_dir, highlight, count, page)
+        raise NotImplementedError.new("Not yet implemented, feel free to make a pull request")
+      end
+
+    end
+  end
+end

data/lib/slack/web/stars.rb

@@ -0,0 +1,13 @@
+module Slack
+  module Web
+    module Stars
+      SCOPE = "users"
+
+      # Lists stars for a user.
+      def stars_list(user, count, page)
+        raise Slack::Error("Not yet implemented, feel free to make a pull request")
+      end
+
+    end
+  end
+end

data/lib/slack/web/users.rb

@@ -0,0 +1,38 @@
+module Slack
+  module Web
+    module Users
+      SCOPE = "users"
+
+      # Gets user presence information.
+      def users_get_presence(user)
+        response = @session.do_get "#{SCOPE}.getPresence", "user" => user
+        Slack::parse_response(response)
+      end
+
+      # Gets information about a user.
+      def users_info(user)
+        response = @session.do_get "#{SCOPE}.info", "user" => user
+        Slack::parse_response(response)
+      end
+
+      # Lists all users in a Slack team.
+      def users_list
+        response = @session.do_get "#{SCOPE}.list"
+        Slack::parse_response(response)
+      end
+
+      # Marks a user as active.
+      def users_set_active
+        response = @session.do_get "#{SCOPE}.setActive"
+        Slack::parse_response(response)
+      end
+
+      # Manually sets user presence.
+      def users_set_presence(presence)
+        response = @session.do_get "#{SCOPE}.setPresence", "presence" => presence
+        Slack::parse_response(response)
+      end
+
+    end
+  end
+end

data/slack-api-wrapper.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'slack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "slack-api-wrapper"
+  spec.version       = Slack::VERSION
+  spec.authors       = ["Gustavo Bazan"]
+  spec.email         = ["contacto@gustavobazan.com"]
+  spec.summary       = "Slack API Wrapper"
+  spec.description   = <<-EOF
+        A library that provides a plain function-call interface to the
+        Slack API web endpoints.
+    EOF
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", '~> 0'
+  spec.add_development_dependency "rspec", '~> 3.2', '>= 3.2.0'
+end

data/spec/slack/client_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Slack::Client do
+  it 'Initialize' do
+    client = Slack::Client.new("")
+    expect(client).not_to be nil
+  end
+  it 'Validates token is string' do
+    expect{Slack::Client.new(1)}.to raise_error(ArgumentError)
+  end
+  it 'Validates unimplemented methods' do
+    client = Slack::Client.new("")
+    expect{client.groups_open("")}.to raise_error(Slack::Web::NotImplementedError)
+  end
+end

data/spec/slack/oauth2_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Slack::Oauth2 do
+  it 'do something' do
+    skip
+  end
+end

data/spec/slack_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Slack do
+  it 'has a version number' do
+    expect(Slack::VERSION).not_to be nil
+  end
+
+  it 'has web server domain' do
+    expect(Slack::WEB_SERVER).to eq('slack.com')
+  end
+
+  it 'has api uri' do
+    expect(Slack::API_SERVER).to eq('slack.com/api')
+  end
+
+  describe '::clean_params' do
+    let(:params){ {"test_1"=>"test", "test_2" => nil} }
+    it 'removes nil params' do
+      expect(Slack::clean_params(params)).to eq({"test_1"=>"test"})
+    end
+  end
+  
+  describe '::make_query_string' do
+    let(:params){ {"test_1"=>"test", "test_2" => "test"} }
+    it 'transform params to query string' do
+      expect(Slack::make_query_string(params)).to eq("test_1=test&test_2=test")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'slack-api-wrapper'

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: slack-api-wrapper
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Gustavo Bazan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: |2
+          A library that provides a plain function-call interface to the
+          Slack API web endpoints.
+email:
+- contacto@gustavobazan.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/slack-api-wrapper.rb
+- lib/slack/client.rb
+- lib/slack/error.rb
+- lib/slack/oauth2.rb
+- lib/slack/oauth2/flow.rb
+- lib/slack/oauth2/flow_base.rb
+- lib/slack/session.rb
+- lib/slack/version.rb
+- lib/slack/web.rb
+- lib/slack/web/auth.rb
+- lib/slack/web/channels.rb
+- lib/slack/web/chat.rb
+- lib/slack/web/emoji.rb
+- lib/slack/web/files.rb
+- lib/slack/web/groups.rb
+- lib/slack/web/im.rb
+- lib/slack/web/search.rb
+- lib/slack/web/stars.rb
+- lib/slack/web/users.rb
+- slack-api-wrapper.gemspec
+- spec/slack/client_spec.rb
+- spec/slack/oauth2/flow_base_spec.rb
+- spec/slack/oauth2/flow_spec.rb
+- spec/slack/oauth2_spec.rb
+- spec/slack_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+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.4
+signing_key: 
+specification_version: 4
+summary: Slack API Wrapper
+test_files:
+- spec/slack/client_spec.rb
+- spec/slack/oauth2/flow_base_spec.rb
+- spec/slack/oauth2/flow_spec.rb
+- spec/slack/oauth2_spec.rb
+- spec/slack_spec.rb
+- spec/spec_helper.rb