ribbon-intercom 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3dd1e6bc419cb94651ef42356db8b7b8c6c48a6
+  data.tar.gz: 8c97e000d932acf6012513ab7339e506b0c6852a
+SHA512:
+  metadata.gz: 7642b346c15bf955093543ebee843814cace7994bb3565b95db3e833ac13816d7b1f945abea4f8c4adcbe9e284349b7dab6f171271911e5ccf3990ccf8a2856e
+  data.tar.gz: 1bde67801438c049bf1877b2c78e8cfb44f25ca82f372370afd48ab0fbc67f7c6e87876e18d9bf1c7c810cacef2b7bb6220b021931d60392b0d74e77f56ef589

data/lib/ribbon/intercom.rb

@@ -0,0 +1,25 @@
+require 'ribbon/intercom/version'
+require 'rack'
+
+module Ribbon
+  module Intercom
+    require 'ribbon/intercom/railtie' if defined?(Rails)
+    autoload(:Service, 'ribbon/intercom/service')
+    autoload(:Errors, 'ribbon/intercom/errors')
+    autoload(:Client, 'ribbon/intercom/client')
+    autoload(:Utils, 'ribbon/intercom/utils')
+
+    module_function
+
+    def method_missing(meth, *args, &block)
+      client.send(meth, *args, &block)
+    end
+
+    def client
+      @__client ||= Client.new
+    end
+  end # Intercom
+end # Ribbon
+
+# Create a shortcut to the module
+Intercom = Ribbon::Intercom

data/lib/ribbon/intercom/client.rb

@@ -0,0 +1,31 @@
+require 'ribbon/config'
+
+module Ribbon::Intercom
+  class Client
+    autoload(:SDK, 'ribbon/intercom/client/sdk')
+
+    def config(&block)
+      (@__config ||= Ribbon::Config.new).tap { |config|
+        if block_given?
+          config.define(&block)
+        end
+      }
+    end
+
+    def [](handle)
+      _load_sdk(handle)
+    end
+
+    def _load_sdk(handle, url=nil, token=nil, secret=nil)
+      (@_sdk_instances ||= Hash.new { |hash, key|
+        if (remote = config.remote.select { |r| r.first == key }.last)
+          # Get the last remote if there are duplicates
+          config = remote.last
+          SDK.new(config[:url], config[:token], config[:secret])
+        else
+          raise Errors::RemoteNotFoundError
+        end
+      })[handle.to_sym]
+    end
+  end # Client
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk.rb

@@ -0,0 +1,49 @@
+module Ribbon::Intercom
+  class Client
+    class SDK
+      autoload(:Connection, 'ribbon/intercom/client/sdk/connection')
+      autoload(:Response, 'ribbon/intercom/client/sdk/response')
+
+      attr_reader :connection
+
+      def initialize(*args)
+        connect(*args)
+      end
+
+      def connect(*args)
+        @connection = Connection.new(*args)
+      end
+
+      def connected?
+        !!connection
+      end
+
+      def method_missing(meth, *args, &block)
+        _send_request(meth, *args)
+      end
+
+      private
+
+      def _send_request(method_name, *args)
+        response = connection.put("", method_name, args)
+
+        if response.success?
+          response.body
+        else
+          case response.code
+          when 401
+            raise Errors::AuthenticationError, request.body
+          when 403
+            raise Errors::MissingPermissionsError, response.missing_permissions.to_a.join(', ')
+          when 404
+            raise Errors::InvalidMethodError, "#{method_name} is not a valid method"
+          when 500
+            raise Errors::ServerError, response.body
+          else
+            raise Errors::RequestFailureError, response.body
+          end
+        end
+      end
+    end # Client
+  end # SDK
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/connection.rb

@@ -0,0 +1,35 @@
+require 'rest-client'
+
+module Ribbon::Intercom
+  class Client
+    class SDK
+      class Connection
+        def initialize(url, token, secret)
+          @client = RestClient::Resource.new(
+            url,
+            user: token,
+            password: secret,
+          ) { |response, request, result| response }
+        end
+
+        def put(path, method_name, args)
+          path = _build_path(path)
+          headers = { "X-Intercom-Method" => method_name }
+          payload = _encode_args(args)
+
+          Response.new(@client[path].put(payload, headers))
+        end
+
+        private
+
+        def _build_path(path)
+          path[0] == '/' ? path : '/' + path
+        end
+
+        def _encode_args(args)
+          Base64.strict_encode64(Marshal.dump(Utils.sanitize(args)))
+        end
+      end # Connection
+    end # SDK
+  end # Client
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/response.rb

@@ -0,0 +1,59 @@
+require 'base64'
+require 'set'
+
+module Ribbon::Intercom
+  class Client
+    class SDK
+      class Response
+        attr_reader :headers
+        attr_reader :body
+        attr_reader :code
+
+        def initialize(rest_client_response)
+          response = rest_client_response
+          @code = response.code
+          @headers = rest_client_response.headers
+          @body = _process_body(response.body)
+          _deep_freeze(@body)
+        end
+
+        def success?
+          code >= 200 && code < 300
+        end
+
+        def error?
+          !success?
+        end
+
+        def missing_permissions
+          @__missing_permissions ||= headers[:x_intercom_permissions_missing] &&
+            headers[:x_intercom_permissions_missing].split(',').to_set
+        end
+
+        def method_missing(meth, *args, &block)
+          if body.key?(meth.to_s)
+            body[meth.to_s]
+          else
+            super
+          end
+        end
+
+        private
+
+        def _process_body(body)
+          Marshal.load(Base64.strict_decode64(body)) unless body.empty?
+        end
+
+        def _deep_freeze(obj)
+          if obj.respond_to?(:each)
+            obj.each do |elem|
+              _deep_freeze(elem)
+            end
+          end
+
+          obj.freeze
+        end
+      end # Response
+    end # SDK
+  end # Client
+end # Ribbon::Intercom

data/lib/ribbon/intercom/errors.rb

@@ -0,0 +1,32 @@
+module Ribbon::Intercom
+  module Errors
+    class Error < StandardError; end
+
+    # General Errors
+    class MissingPermissionsError < Error; end
+    class ServerError < Error; end
+    class UnsafeValueError < Error; end
+
+    # Intercom Errors
+    class RemoteNotFoundError < Error; end
+
+    # Service Errors
+    class NoPermissionsError < Error; end
+    class MissingStoreError < Error; end
+
+    # Channel Store Errors
+    class ChannelStoreError < Error; end
+    class InvalidStoreParamsError < ChannelStoreError; end
+    class InvalidChannelError < ChannelStoreError; end
+
+    # SDK Errors
+    class RequestFailureError < Error; end
+    class InvalidMethodError < Error; end
+    class AuthenticationError < Error; end
+
+    # Channel Errors
+    class ChannelNameMissingError < Error; end
+    class ChannelTokenMissingError < Error; end
+    class ChannelSecretMissingError < Error; end
+  end # Errors
+end # Ribbon::Intercom

data/lib/ribbon/intercom/railtie.rb

@@ -0,0 +1,16 @@
+require 'ribbon/intercom'
+require 'rails'
+
+module Ribbon
+  module Intercom
+    class Railtie < Rails::Railtie
+      railtie_name :intercom
+
+      rake_tasks do
+        Dir[
+          File.expand_path("../../../tasks", __FILE__) + '/**/*.rake'
+        ].each { |rake_file| load rake_file }
+      end
+    end
+  end
+end

data/lib/ribbon/intercom/service.rb

@@ -0,0 +1,185 @@
+require 'base64'
+require 'yaml'
+require 'set'
+
+module Ribbon::Intercom
+  class Service
+    autoload(:Channel, 'ribbon/intercom/service/channel')
+
+    module ChannelStores
+      autoload(:Base, 'ribbon/intercom/service/channel_stores/base')
+      autoload(:RedisStore, 'ribbon/intercom/service/channel_stores/redis_store')
+    end
+
+    class << self
+      def instance
+        @instance ||= new(store: _load_store)
+      end
+
+      def default_store(store_name, params={})
+        @_store_name = store_name
+        @_store_params = params
+      end
+
+      def permissions(*perms)
+        @_next_permissions = perms.map(&:to_sym).to_set
+      end
+
+      def method_permissions
+        if (ancestor = ancestors.find { |a| a <= Service && a != self })
+          ancestor.method_permissions
+        else
+          {}
+        end.merge(@_method_permissions).dup
+      end
+
+      def method_missing(meth, *args, &block)
+        instance.send(meth, *args, &block)
+      end
+
+      def _load_store
+        raise "Store name missing"   unless (store_name = @_store_name.to_s)
+
+        store = store_name.split("_").map(&:capitalize).join + "Store"
+        Intercom::Service::ChannelStores.const_get(store).new(@_store_params)
+      end
+    end # Class methods
+
+    attr_reader :request
+    attr_reader :channel
+    attr_reader :env
+
+    def initialize(opts={})
+      @_opts = opts.dup
+    end
+
+    def store
+      @store ||= @_opts[:store] or raise Errors::MissingStoreError
+    end
+
+    def open_channel(params={})
+      # Accept either an array of permissions or a string
+      store.open_channel(params)
+    end
+
+    def lookup_channel(token)
+      store.lookup_channel(token)
+    end
+
+    def method_permissions(method_name)
+      self.class.method_permissions[method_name.to_sym]
+    end
+
+    def method_permissions!(method_name)
+      method_permissions(method_name) or raise Errors::InvalidMethodError
+    end
+
+    def sufficient_permissions?(intercom_method)
+      permissions = method_permissions!(intercom_method)
+      channel.may?(*permissions)
+    end
+
+    def sufficient_permissions!(intercom_method)
+      sufficient_permissions?(intercom_method) or raise Errors::MissingPermissionsError
+    end
+
+    def process_request
+      @request = Rack::Request.new(env)
+      return _respond!(405) unless request.put?
+      return _respond!(401) unless _perform_basic_auth(request.env)
+
+      # Check permissions
+      intercom_method = env['HTTP_X_INTERCOM_METHOD'].to_sym
+      sufficient_permissions!(intercom_method)
+
+      # Execute the requested method
+      args = _decode_args(request.body.read)
+
+      [intercom_method, args]
+    rescue Errors::UnsafeValueError
+      _respond!(400, {}, "Arg types are invalid")
+    rescue Errors::MissingPermissionsError
+      _respond!(403, {"X-Intercom-Permissions-Missing" => _missing_permissions(intercom_method).to_a.join(',')}, "Permissions missing.")
+    rescue Errors::InvalidMethodError
+      _respond!(404, {}, "Method requested not found.")
+    end
+
+    def call_method(intercom_method, *args)
+      body = Utils.sanitize(send(intercom_method, *args))
+      _respond!(200, {}, body)
+    rescue Errors::UnsafeValueError
+      _respond!(500, {}, "Return value type is invalid")
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      @env = env
+
+      response = catch(:response) {
+        intercom_method, args = process_request
+        call_method(intercom_method, *args)
+      }
+
+      response.finish
+    rescue Exception => e
+      _response(500, {}, e.message).finish
+    end
+
+    private
+
+    def _perform_basic_auth(env)
+      auth = Rack::Auth::Basic::Request.new(env)
+
+      if auth.provided? && auth.basic?
+        token  = auth.credentials[0]
+        secret = auth.credentials[1]
+
+        # Check if the request is authenticated
+        @channel = lookup_channel(token)
+        channel && channel.valid_secret?(secret)
+      end
+    end
+
+    def _missing_permissions(intercom_method)
+      method_permissions(intercom_method) - channel.permissions
+    end
+
+    def _response(status, headers={}, body="")
+      body = [_encode_body(body)]
+      headers = headers.merge("Content-Type" => "text/plain", "Transfer-Encoding" => "gzip")
+      Rack::Response.new(body, status, headers)
+    end
+
+    def _respond!(status, headers={}, body="")
+      throw :response, _response(status, headers, body)
+    end
+
+    def _encode_body(body)
+      Base64.strict_encode64(Marshal.dump(body))
+    end
+
+    def _decode_args(args)
+      Utils.sanitize(Marshal.load(Base64.strict_decode64(args))).tap { |args|
+        raise Errors::UnsafeValueError unless args.is_a?(Array)
+      }
+    end
+  end # Service
+
+  # Re-opening the class so the above instance methods don't get added to the
+  # permissions hash
+  class Service
+    class << self
+      def method_added(method_name)
+        (@_method_permissions ||= {})[method_name] = (@_next_permissions || [method_name].to_set).dup.freeze
+        @_next_permissions = nil
+      end
+    end # Class Methods
+
+    def rotate_secret
+      channel.rotate_secret!
+    end
+  end # Service
+end # Ribbon::Intercom

data/lib/ribbon/intercom/service/channel.rb

@@ -0,0 +1,101 @@
+require 'securerandom'
+require 'bcrypt'
+
+module Ribbon::Intercom
+  class Service
+    class Channel
+      include BCrypt
+
+      attr_reader :name
+      attr_reader :store
+      attr_reader :token
+      attr_reader :secret_hash_crt
+      attr_reader :secret_hash_prv
+
+      def initialize(store, params={})
+        @store = store
+        @name = params[:name] or raise Errors::ChannelNameMissingError
+        @token = params[:token]
+        @secret_hash_crt = params[:secret_hash_crt]
+        @secret_hash_prv = params[:secret_hash_prv]
+
+        may(*((params[:may] || []) | [:rotate_secret]))
+      end
+
+      def rotate_secret
+        SecureRandom.hex(16).tap { |secret|
+          @secret_hash_prv = secret_hash_crt
+          @secret_hash_crt = Password.create(secret)
+        }
+      end
+
+      def rotate_secret!
+        rotate_secret.tap { save }
+      end
+
+      def may(*args)
+        (@_allowed_to ||= Hash.new(false)).merge!(
+          Hash[
+            args.map { |perm| [perm.to_sym, true] }
+          ]
+        ).keys.to_set
+      end
+
+      def may!(*args)
+        may(*args).tap { save }
+      end
+
+      def may?(*args)
+        args.all? { |perm| @_allowed_to[perm.to_sym] }
+      end
+
+      def permissions
+        @_allowed_to.keys.to_set
+      end
+
+      def valid_secret?(secret)
+        !!secret && (secret_crt == secret || secret_prv == secret)
+      end
+
+      def secret_crt
+        @__secret_crt ||= _to_bcrypt_pw(secret_hash_crt)
+      end
+
+      def secret_prv
+        @__secret_prv ||= _to_bcrypt_pw(secret_hash_prv)
+      end
+
+      def save
+        # Loop until unique
+        unless token
+          loop { break unless store.token_exists?(@token = SecureRandom.hex(4)) }
+        end
+
+        _run_validations
+        store.persist(self)
+      end
+
+      def ==(other)
+        other.is_a?(Channel) &&
+          name == other.name &&
+          store == other.store &&
+          token == other.token &&
+          secret_crt.to_s == other.secret_crt.to_s &&
+          secret_prv.to_s == other.secret_prv.to_s &&
+          permissions == other.permissions
+      end
+
+      private
+
+      def _to_bcrypt_pw(pw)
+        Password.new(pw) if pw && !pw.empty?
+      end
+
+      def _run_validations
+        raise Errors::ChannelNameMissingError unless name
+        raise Errors::ChannelTokenMissingError unless token
+        raise Errors::ChannelSecretMissingError unless secret_hash_crt
+      end
+    end # Service
+  end # Channel
+end # Ribbon::Intercom

data/lib/ribbon/intercom/service/channel_stores/base.rb

@@ -0,0 +1,23 @@
+module Ribbon::Intercom
+  class Service
+    module ChannelStores
+      class Base
+        def open_channel(params={})
+          raise NotImplementedError
+        end
+
+        def token_exists?(token)
+          raise NotImplementedError
+        end
+
+        def lookup_channel(token)
+          raise NotImplementedError
+        end
+
+        def persist(channel)
+          raise NotImplementedError
+        end
+      end # Base
+    end # ChannelStores
+  end # Service
+end # Ribbon::Intercom

data/lib/ribbon/intercom/service/channel_stores/redis_store.rb

@@ -0,0 +1,60 @@
+require 'redis'
+
+module Ribbon::Intercom
+  class Service
+    module ChannelStores
+      class RedisStore < Base
+        def initialize(params={})
+          if params[:url]
+            @_redis = Redis.new(url: params[:url])
+          elsif params[:redis]
+            @_redis = params[:redis]
+          else
+            raise Errors::InvalidStoreParamsError
+          end
+        end
+
+        def open_channel(params={})
+          Channel.new(self, params)
+        end
+
+        def token_exists?(token)
+          @_redis.exists("channel:#{token}")
+        end
+
+        def lookup_channel(token)
+          if token_exists?(token) && (channel_data = @_redis.hgetall("channel:#{token}"))
+            permissions = @_redis.smembers("channel:#{token}:permissions")
+
+            Channel.new(self,
+              Utils.symbolize_keys(
+                channel_data.merge(may: permissions)
+              )
+            )
+          end
+        end
+
+        def persist(channel)
+          raise Errors::InvalidChannelError, channel.inspect unless channel.is_a?(Channel)
+
+          data_hash = {}
+          [:name, :token, :secret_hash_crt, :secret_hash_prv].each { |key|
+            value = channel.send(key)
+            data_hash[key] = value if value
+          }
+
+          # Save channel data as hash
+          @_redis.mapped_hmset("channel:#{channel.token}", data_hash)
+
+          # Associate permissions set to its channel
+          channel_key = "channel:#{channel.token}:permissions"
+          channel.tap { |c|
+            c.permissions.each { |p|
+              @_redis.sadd(channel_key, p)
+            }
+          }
+        end
+      end # RedisStore
+    end # ChannelStores
+  end # Service
+end # Ribbon::Intercom

data/lib/ribbon/intercom/utils.rb

@@ -0,0 +1,30 @@
+module Ribbon::Intercom
+  class Utils
+    class << self
+      def sanitize(object)
+        case object
+        when String, Symbol, TrueClass, FalseClass, Integer, Float, NilClass
+          object
+        when Hash
+          sanitize_hash(object)
+        when Array
+          sanitize_array(object)
+        else
+          raise Errors::UnsafeValueError, object.inspect
+        end
+      end
+
+      def sanitize_array(array)
+        array.map { |obj| sanitize(obj) }
+      end
+
+      def sanitize_hash(hash)
+        Hash[hash.map { |key, val| [sanitize(key), sanitize(val)] }]
+      end
+
+      def symbolize_keys(hash)
+        hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      end
+    end # Class methods
+  end # Utils
+end # Ribbon::Intercom

data/lib/ribbon/intercom/version.rb

@@ -0,0 +1,5 @@
+module Ribbon
+  module Intercom
+    VERSION = '0.1.0'
+  end
+end

data/lib/tasks/intercom.rake

@@ -0,0 +1,22 @@
+require 'optparse'
+require 'ribbon/intercom'
+require 'json'
+
+namespace :intercom do
+  namespace :client do
+    task :rotate_secret, [:remote] => :environment do |t, args|
+      remote = args[:remote]
+      puts "New #{remote} secret: #{Intercom[remote].rotate_secret}"
+    end
+  end
+
+  namespace :service do
+    task :open_channel, [:service_name, :channel_name] => :environment do |t, args|
+      service = args[:service_name].split("_").map(&:capitalize).join
+      channel_name = args[:channel_name]
+
+      Intercom::const_get(service).open_channel(name: channel_name)
+      puts "New channel: #{channel_name}"
+    end
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: ribbon-intercom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Honer
+- Kayvon Ghaffari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: ribbon-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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-rails
+  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: sqlite3
+  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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  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'
+description: A standard for authenticating requests among services
+email:
+- robert@ribbonpayments.com
+- kayvon@ribbon.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ribbon/intercom.rb
+- lib/ribbon/intercom/client.rb
+- lib/ribbon/intercom/client/sdk.rb
+- lib/ribbon/intercom/client/sdk/connection.rb
+- lib/ribbon/intercom/client/sdk/response.rb
+- lib/ribbon/intercom/errors.rb
+- lib/ribbon/intercom/railtie.rb
+- lib/ribbon/intercom/service.rb
+- lib/ribbon/intercom/service/channel.rb
+- lib/ribbon/intercom/service/channel_stores/base.rb
+- lib/ribbon/intercom/service/channel_stores/redis_store.rb
+- lib/ribbon/intercom/utils.rb
+- lib/ribbon/intercom/version.rb
+- lib/tasks/intercom.rake
+homepage: http://github.com/ribbon/intercom
+licenses:
+- BSD
+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.3
+signing_key: 
+specification_version: 4
+summary: A standard for authenticating requests among services
+test_files: []