bows 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f136b3b94c864c9bdfff6829ee3add739e565ec
+  data.tar.gz: 34d7ab35c8d8e417f040faa34d1bf16dcb3f553e
+SHA512:
+  metadata.gz: 759458f070d855822f8597379c8ad392935d1548d039bd85ac281719ac5114054ef18fab3beeed7625fb93c1704ee26ce511796b8f5eac8e8b589e59feb720b8
+  data.tar.gz: 926eb6957418a8564100da028b20b66b132636103dc8f963b74de747a6c0793964c500fad994fc3ae0e6af635ae3ef50b072a2b1529687e94c27ace520920b50

data/lib/ribbon/intercom.rb

@@ -0,0 +1,42 @@
+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(:Package,     'ribbon/intercom/package')
+    autoload(:Packageable, 'ribbon/intercom/packageable')
+    autoload(:Packet,      'ribbon/intercom/packet')
+    autoload(:Utils,       'ribbon/intercom/utils')
+
+    module_function
+
+    def load_tasks
+      Dir[
+        File.expand_path("../../tasks", __FILE__) + '/**.rake'
+      ].each { |rake_file| load rake_file }
+    end
+
+    def method_missing(meth, *args, &block)
+      client.send(meth, *args, &block)
+    end
+
+    def client
+      @_client ||= Client.new
+    end
+
+    def mock_safe
+      orig_client = client
+      @_client = @_client.mock_safe
+      yield
+    ensure
+      @_client = orig_client
+    end
+  end # Intercom
+end # Ribbon
+
+# Create a shortcut to the module
+Intercom = Ribbon::Intercom

data/lib/ribbon/intercom/client.rb

@@ -0,0 +1,61 @@
+require 'ribbon/config'
+
+module Ribbon::Intercom
+  class Client
+    autoload(:SDK, 'ribbon/intercom/client/sdk')
+    autoload(:MockSDK, 'ribbon/intercom/client/mock_sdk')
+
+    def config(&block)
+      (@__config ||= Ribbon::Config.new).tap { |config|
+        if block_given?
+          config.define(&block)
+        end
+      }
+    end
+
+    def [](handle)
+      _load_sdk(handle)
+    end
+
+    ##
+    # Return a mock safe version of this client.
+    def mock_safe
+      dup.tap { |client|
+        client.preload_sdks
+
+        # Make SDK instances mock safe
+        client.sdk_instances = Hash[
+          client.sdk_instances.map { |service, sdk| [service, sdk.mock_safe] }
+        ]
+      }
+    end
+
+    def preload_sdks
+      if config.service?
+        config.service.each { |name, *args|
+          _load_sdk(name)
+        }
+      end
+    end
+
+    protected
+
+    attr_accessor :sdk_instances
+
+    private
+
+    def _load_sdk(handle)
+      raise Errors::ServiceNotDefinedError unless config.service?
+
+      (self.sdk_instances ||= Hash.new { |hash, key|
+        # Get the last service if there are duplicates
+        if (service_def = config.service.select { |r| r.first == key }.last)
+          name, config = service_def
+          hash[key] = SDK.new(config[:url], config[:token], config[:secret])
+        else
+          raise Errors::ServiceNotDefinedError
+        end
+      })[handle.to_sym]
+    end
+  end # Client
+end # Ribbon::Intercom

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

@@ -0,0 +1,13 @@
+module Ribbon::Intercom
+  class Client
+    class MockSDK < SDK
+      def initialize(service)
+        super(Adapters::MockAdapter.new(service))
+      end
+
+      def with_permissions(*perms, &block)
+        adapter.with_permissions(*perms, &block)
+      end
+    end # MockSDK
+  end # Client
+end # Ribbon::Intercom

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

@@ -0,0 +1,99 @@
+require 'base64'
+
+module Ribbon::Intercom
+  class Client
+    class SDK
+      autoload(:Adapters, 'ribbon/intercom/client/sdk/adapters')
+
+      include Utils::Mixins::MockSafe
+
+      attr_reader :adapter
+
+      def initialize(*args)
+        case args.first
+        when Adapters::Adapter
+          self.adapter = args.first
+        else
+          self.adapter = Adapters::HttpAdapter.new(*args)
+        end
+      end
+
+      def begin
+        Utils::MethodChain.begin { |methods|
+          queue = Packet::MethodQueue.new
+          methods.each { |meth, *args| queue.enqueue(meth, *args) }
+          send_packet(method_queue: queue).retval
+        }
+      end
+
+      ##
+      # Returns the headers defined for this SDK. Optionally, you may also define
+      # additional headers you'd like to add/override.
+      def headers(new_headers={})
+        adapter.headers(new_headers)
+      end
+
+      def connect(*args)
+        adapter.connect(*args)
+      end
+
+      def connected?
+        adapter.connected?
+      end
+
+      ##
+      # Calls the method on the adapter returning the response Packet
+      def call(method_name, *args)
+        send_packet(
+          method_queue: Packet::MethodQueue.new.enqueue(method_name, *args)
+        )
+      end
+
+      ##
+      # Sends the packet with the adapter, returning the response Packet.
+      #
+      # Intended to be called by Package.
+      def send_packet(packet)
+        _process_response(adapter.send_packet(packet))
+      end
+
+      def dup
+        super.tap { |sdk|
+          sdk.adapter = adapter.dup
+        }
+      end
+
+      protected
+
+      def adapter=(adapter)
+        @adapter = adapter
+      end
+
+      private
+
+      ##
+      # Simulates calling the remote method as if it were a local method.
+      #
+      # Intended to be called by end-users.
+      def method_missing(meth, *args, &block)
+        call(meth, *args).retval
+      end
+
+      ##
+      # Process a Packet object returned by Adapter#send_packet.
+      def _process_response(packet)
+        _handle_response_error(packet) if packet.error?
+
+        Package.init_packages(packet.retval, self)
+        packet
+      end
+
+      ##
+      # Raises an error depending on what went wrong.
+      def _handle_response_error(packet)
+        raise 'packet contains no error' unless packet.error?
+        raise packet.error
+      end
+    end # SDK
+  end # Client
+end # Ribbon::Intercom

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

@@ -0,0 +1,10 @@
+module Ribbon::Intercom
+  class Client::SDK
+    module Adapters
+      autoload(:Adapter,     'ribbon/intercom/client/sdk/adapters/adapter')
+      autoload(:HttpAdapter, 'ribbon/intercom/client/sdk/adapters/http_adapter')
+      autoload(:LocalAdapter, 'ribbon/intercom/client/sdk/adapters/local_adapter')
+      autoload(:MockAdapter, 'ribbon/intercom/client/sdk/adapters/mock_adapter')
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class Adapter
+      autoload(:Response, 'ribbon/intercom/client/sdk/adapters/adapter/response')
+
+      def initialize(*args)
+        connect(*args)
+      end
+
+      ##
+      # Call the method on the service.
+      #
+      # @deprecated This method is only called by tests. Don't call it elsewhere.
+      def call(method_name, *args)
+        send_packet(
+          method_queue: Packet::MethodQueue.new.enqueue(method_name, *args)
+        )
+      end
+
+      ##
+      # Send a packet to the service and returns the Packet returned by the service.
+      def send_packet(packet)
+        packet = Packet.new(packet) if packet.is_a?(Hash)
+
+        send_packet!(packet.encode).tap { |response|
+          raise TypeError, "send_packet! should return an Adapter::Response" unless response.is_a?(Response)
+        }.packet
+      end
+
+      ##
+      # Returns the headers defined for this Adapter. Optionally, you may also
+      # define additional headers you'd like to add/override.
+      def headers(new_headers={})
+        (@headers ||= {}).merge!(new_headers)
+      end
+
+      def dup
+        super.tap { |adapter|
+          adapter.headers = @headers.dup if @headers
+        }
+      end
+
+      ##
+      # Connect to a service. The specific arguments depend on the Adapter
+      # subclass.
+      def connect(*args)
+        raise NotImplementedError
+      end
+
+      ##
+      # Returns whether or not the Adapter is connected to a service.
+      def connected?
+        raise NotImplementedError
+      end
+
+      ##
+      # Actually send the packet to the service. Should return an Adapter::Response object.
+      def send_packet!(packet)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def headers=(h)
+        @headers = h
+      end
+
+      private
+
+      ##
+      # Encode the arguments for transmission to the service.
+      def _encode_args(*args)
+        Base64.strict_encode64(Marshal.dump(Utils.sanitize(args)))
+      end
+    end # Adapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

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

@@ -0,0 +1,13 @@
+module Ribbon::Intercom
+  class Client::SDK::Adapters::Adapter
+    class Response < Rack::Response
+      def body
+        super.join
+      end
+
+      def packet
+        @__packet ||= Packet.decode(body) unless body.empty?
+      end
+    end # Response
+  end # Client::SDK::Adapters::Adapter
+end # Ribbon::Intercom

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

@@ -0,0 +1,32 @@
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class HttpAdapter < Adapter
+      autoload(:Connection, 'ribbon/intercom/client/sdk/adapters/http_adapter/connection')
+
+      attr_reader :connection
+
+      def connect(*args)
+        @_connection_args = args.dup
+      end
+
+      def connected?
+        !!connection
+      end
+
+      def connection
+        @__connection ||= Connection.new(*@_connection_args)
+      end
+
+      ##
+      # Send the encoded packet up to the service via an HTTP PUT.
+      def send_packet!(encoded_packet)
+        response = connection.put(
+          headers: headers,
+          body:    encoded_packet
+        )
+
+        Adapter::Response.new(response.body, response.code.to_i, response)
+      end
+    end # HttpAdapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

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

@@ -0,0 +1,34 @@
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class HttpAdapter::Connection
+      attr_reader :url
+
+      def initialize(url, token, secret)
+        @url = url.is_a?(String) ? URI(url) : url
+
+        @_client = Net::HTTP.new(@url.hostname, @url.port)
+        @_client.use_ssl = @url.is_a?(URI::HTTPS)
+        @_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        @_client.cert_store = OpenSSL::X509::Store.new.tap { |s| s.set_default_paths }
+
+        @_headers = {
+          'Authorization' => "Basic #{Base64.strict_encode64("#{token}:#{secret}")}"
+        }
+      end
+
+      def put(params={})
+        @_client.put(url.request_uri, params[:body], _prepare_headers(params[:headers]).merge(@_headers))
+      end
+
+      private
+
+      def _prepare_headers(headers)
+        Hash[(headers || {}).map { |k, v| [k.to_s, v.to_s] }]
+      end
+    end # HttpAdapter::Connection
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

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

@@ -0,0 +1,55 @@
+require 'base64'
+
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class LocalAdapter < Adapter
+      attr_reader :service
+      attr_accessor :channel_token
+      attr_accessor :channel_secret
+
+      def connect(service, params={})
+        case service
+        when Service
+          @service = service
+        else
+          raise ArgumentError, "Expected a service, got: #{service.inspect}"
+        end
+
+        @channel_token = params[:channel_token]
+        @channel_secret = params[:channel_secret]
+      end
+
+      def connected?(*args)
+        !!service
+      end
+
+      ##
+      # Mimics an HTTP PUT
+      def send_packet!(encoded_packet)
+        response = service.call(
+          _http_headers.merge(
+            'HTTP_AUTHORIZATION'     => _http_auth,
+            'REQUEST_METHOD'         => 'PUT',
+            'rack.input'             => StringIO.new(encoded_packet)
+          )
+        )
+
+        Adapter::Response.new(response[2], response[0], response[1])
+      end
+
+      private
+
+      def _http_auth
+        "Basic #{Base64.strict_encode64("#{channel_token}:#{channel_secret}")}"
+      end
+
+      def _http_headers
+        Hash[headers.map { |name, value| [_header_to_http(name), value] }]
+      end
+
+      def _header_to_http(name)
+        "HTTP_#{name.to_s.upcase.gsub('-', '_')}"
+      end
+    end # MockAdapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom