mode-sdk 0.0.1

data/lib/mode/sdk/table_import.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+#
+module Mode
+  module Sdk
+    # Represents the status of a Mode table import job
+    #
+    class TableImport
+      # Construct a new TableImport instance
+      #
+      # @param resource_path [String] Mode API resource path
+      #
+      # @return [Mode::Sdk::TableImport] the instance
+      #
+      def initialize(resource_path)
+        @resource_path = resource_path
+      end
+
+      # Poll the API representation of the table import until the job is no
+      # longer running
+      #
+      # @param interval [optional, Integer, Float] polling interval in seconds
+      #
+      # @yield [Hash] the API representation of the table import job
+      #
+      def poll(interval = 0.5)
+        loop do
+          repr = fetch_repr
+
+          yield repr
+
+          if %w(new enqueued running).include?(repr.fetch('state'))
+            sleep interval
+          else
+            break
+          end
+        end
+      end
+
+      private
+
+      attr_reader :resource_path
+
+      # Get the API representation of the resource from the Mode API
+      #
+      # @return [Hash] the API representation
+      #
+      def fetch_repr
+        Mode::Sdk::Client.get("#{resource_path}?embed[table]=1").body
+      end
+    end
+  end
+end

data/lib/mode/sdk/upload.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+#
+module Mode
+  module Sdk
+    # Represents a Mode Upload containing raw CSV with no header
+    #
+    class Upload
+      attr_reader :content, :options
+
+      # Construct a new Upload instance
+      #
+      # @param content [String, #read] the content
+      # @param options [optional, Hash] hash of options
+      #
+      # @option options [Integer] :content_size the size of the provided
+      #   content
+      #
+      # @return [Mode::Sdk::Upload] the instance
+      #
+      def initialize(content, options = {})
+        @content = content
+        @options = options
+      end
+
+      # Create the Upload through the Mode API
+      #
+      # @return [Mode::Sdk::Client::Response] the response
+      #
+      def create
+        @create ||= Mode::Sdk::Client.post(
+          collection_path,
+          content,
+          content_type: 'application/csv',
+          content_length: content_length,
+          expect: [201])
+      end
+
+      # The unique token assigned to the upload
+      #
+      # @return [String] the token
+      #
+      def token
+        create.body.fetch('token')
+      end
+
+      private
+
+      def content_length
+        options.fetch(:content_length, nil) || content.size
+      end
+
+      def collection_path
+        '/api/uploads'
+      end
+    end
+  end
+end

data/lib/mode/sdk/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+#
+module Mode
+  # Official [Mode Analytics](https://modeanalytics.com) Ruby SDK
+  #
+  module Sdk
+    VERSION = '0.0.1'
+  end
+end

data/lib/mode/sdk/warehouse_util.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+#
+module Mode
+  module Sdk
+    # Provides simple utility methods for use with the Mode public data
+    # warehouse
+    #
+    module WarehouseUtil
+      # Normalize and truncate a string for use as a Mode warehouse table or
+      # column name
+      #
+      # @param name [String] the original name
+      #
+      # @return [String] the normalized name
+      #
+      def normalize_name(name)
+        normalize_string(name)[0..63]
+      end
+
+      protected
+
+      def normalize_string(name)
+        name
+          .downcase              # no uppercase characters
+          .strip                 # no leading or trailing whitespace
+          .gsub(/\s+/, ' ')      # no multiple consecutive spaces
+          .gsub(/-/, '_')        # no hyphens
+          .gsub(/[^\w\s_]/, '')  # no unexpected characters
+          .gsub(/\s/, '_')       # no spaces
+          .gsub(/_+/, '_')       # no multiple consecutive underscores
+          .gsub(/(^_)|(_$)/, '') # no leading or trailing underscores
+      end
+    end
+  end
+end

data/mode-sdk.gemspec

@@ -0,0 +1,27 @@
+# encoding: utf-8
+#
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'mode/sdk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mode-sdk'
+  spec.version       = Mode::Sdk::VERSION
+  spec.authors       = ['Heather Rivers']
+  spec.email         = ['heather@modeanalytics.com']
+  spec.description   = 'Mode Ruby SDK'
+  spec.summary       = 'Ruby SDK for interacting with the Mode Analytics API'
+  spec.homepage      = 'https://github.com/mode/mode-ruby-sdk'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)/)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+end

data/spec/lib/mode/sdk/client/request_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Client::Request do
+  describe '#response' do
+    let :request do
+      Mode::Sdk::Client::Request.new(Net::HTTP::Head.new('some/path'))
+    end
+
+    it 'performs http request' do
+      expect(Mode::Sdk::Client::Request.http).to receive(:request)
+
+      expect(request.response).to(
+        be_an_instance_of(Mode::Sdk::Client::Response))
+    end
+  end
+
+  describe '#build_http_request' do
+    let :head do
+      Net::HTTP::Head.new('some/path')
+    end
+
+    it 'sets default headers' do
+      request = Mode::Sdk::Client::Request.new(head)
+
+      http_request = request.send(:build_http_request)
+
+      expect(http_request['accept']).to match(/application\/json\Z/)
+      expect(http_request['user-agent']).to match(/mode\-sdk/)
+      expect(http_request['authorization']).to match(/Basic/)
+    end
+
+    describe 'content' do
+      it 'does not assign nil body' do
+        request = Mode::Sdk::Client::Request.new(head)
+
+        expect(head).to receive(:body=).never
+        expect(head).to receive(:body_stream=).never
+
+        request.send(:build_http_request)
+      end
+
+      it 'handles string body' do
+        request = Mode::Sdk::Client::Request.new(head, 'content')
+
+        expect(head).to receive(:body=).once
+        expect(head).to receive(:body_stream=).never
+
+        request.send(:build_http_request)
+      end
+
+      it 'handles io body' do
+        request = Mode::Sdk::Client::Request.new(head, StringIO.new)
+
+        expect(head).to receive(:body=).never
+        expect(head).to receive(:body_stream=).once
+
+        request.send(:build_http_request)
+      end
+    end
+
+    describe 'content_type' do
+      it 'has default value' do
+        request = Mode::Sdk::Client::Request.new(head)
+
+        http_request = request.send(:build_http_request)
+
+        expect(http_request.content_type).to eq('application/json')
+      end
+
+      it 'allows override' do
+        request = Mode::Sdk::Client::Request.new(
+          head,
+          nil,
+          content_type: 'application/lol')
+
+        http_request = request.send(:build_http_request)
+
+        expect(http_request.content_type).to eq('application/lol')
+      end
+    end
+
+    describe 'content_length' do
+      it 'is not set by default' do
+        request = Mode::Sdk::Client::Request.new(head)
+
+        http_request = request.send(:build_http_request)
+
+        expect(http_request.content_length).to be_nil
+      end
+
+      it 'is set if provided' do
+        request = Mode::Sdk::Client::Request.new(
+          head,
+          nil,
+          content_length: 42)
+
+        http_request = request.send(:build_http_request)
+
+        expect(http_request.content_length).to eq(42)
+      end
+    end
+  end
+end

data/spec/lib/mode/sdk/client/response_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Client::Response do
+  describe '#code' do
+    it 'returns http response code as an integer' do
+      http_response = double(:http_response, code: '200')
+
+      response = Mode::Sdk::Client::Response.new(http_response)
+
+      expect(response.code).to eq(200)
+    end
+  end
+
+  describe '#body' do
+    it 'parses response body' do
+      http_response = double(:http_response, body: '{"foo":"bar"}')
+
+      response = Mode::Sdk::Client::Response.new(http_response)
+
+      expect(response.body).to eq('foo' => 'bar')
+    end
+  end
+
+  describe '#validate!' do
+    it 'raises exception if response is 401' do
+      http_response = double(:http_response, code: '401')
+
+      response = Mode::Sdk::Client::Response.new(http_response, [200])
+
+      expect {
+        response.validate!
+      }.to raise_error(Mode::Sdk::Client::AuthenticationError)
+    end
+
+    it 'raises exception if response is 403' do
+      http_response = double(:http_response, code: '403')
+
+      response = Mode::Sdk::Client::Response.new(http_response, [200])
+
+      expect {
+        response.validate!
+      }.to raise_error(Mode::Sdk::Client::AuthorizationError)
+    end
+
+    it 'raises exception if response is unexpected' do
+      http_response = double(:http_response, code: '200')
+
+      response = Mode::Sdk::Client::Response.new(http_response, [201])
+
+      expect {
+        response.validate!
+      }.to raise_error(Mode::Sdk::Client::ResponseError)
+    end
+
+    it 'returns true if response is expected' do
+      http_response = double(:http_response, code: '201')
+
+      response = Mode::Sdk::Client::Response.new(http_response, [201])
+
+      expect(response.validate!).to eq(true)
+    end
+  end
+end

data/spec/lib/mode/sdk/client_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Client do
+  describe '.head' do
+    it 'performs a head request' do
+      expect(Mode::Sdk::Client).to receive(:request) do |request|
+        expect(request).to be_an_instance_of(Net::HTTP::Head)
+      end
+
+      Mode::Sdk::Client.head('some/path')
+    end
+  end
+
+  describe '.get' do
+    it 'performs a get request' do
+      expect(Mode::Sdk::Client).to receive(:request) do |request|
+        expect(request).to be_an_instance_of(Net::HTTP::Get)
+      end
+
+      Mode::Sdk::Client.get('some/path')
+    end
+  end
+
+  describe '.post' do
+    it 'performs a post request' do
+      expect(Mode::Sdk::Client).to receive(:request) do |request|
+        expect(request).to be_an_instance_of(Net::HTTP::Post)
+      end
+
+      Mode::Sdk::Client.post('some/path', nil)
+    end
+  end
+
+  describe '.put' do
+    it 'performs a put request' do
+      expect(Mode::Sdk::Client).to receive(:request) do |request|
+        expect(request).to be_an_instance_of(Net::HTTP::Put)
+      end
+
+      Mode::Sdk::Client.put('some/path', nil)
+    end
+  end
+
+  describe '.request' do
+    it 'returns response' do
+      mock_response = Mode::Sdk::Client::Response.new(nil)
+
+      expect_any_instance_of(Mode::Sdk::Client::Request).to(
+        receive(:response).and_return(mock_response))
+
+      response = Mode::Sdk::Client.send(:request, nil, nil)
+
+      expect(response).to be_an_instance_of(Mode::Sdk::Client::Response)
+    end
+  end
+
+  describe '.account' do
+    it 'returns account representation' do
+      mock_response = double(:response, body: { 'username' => 'someone' })
+
+      expect_any_instance_of(Mode::Sdk::Client::Request).to(
+        receive(:response).and_return(mock_response))
+
+      response = Mode::Sdk::Client.account
+
+      expect(response).to eq('username' => 'someone')
+    end
+  end
+end

data/spec/lib/mode/sdk/column_set_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::ColumnSet do
+  describe '#columns' do
+    it 'builds an array of columns from hashes' do
+      set = Mode::Sdk::ColumnSet.new([{}, {}])
+
+      expect(set.columns.map(&:class)).to eq([
+        Mode::Sdk::Column, Mode::Sdk::Column])
+    end
+  end
+
+  describe '#validate!' do
+    it 'raises error if no columns are provided' do
+      set = Mode::Sdk::ColumnSet.new(nil)
+
+      expect {
+        set.validate!
+      }.to raise_error(Mode::Sdk::ColumnSet::InvalidError) do |exception|
+        expect(exception.message).to match(/no columns provided/i)
+      end
+    end
+
+    it 'raises error if column is invalid' do
+      expect_any_instance_of(Mode::Sdk::Column).to receive(
+        :validate!).and_raise(Mode::Sdk::Column::InvalidError)
+
+      set = Mode::Sdk::ColumnSet.new([{}])
+
+      expect {
+        set.validate!
+      }.to raise_error(Mode::Sdk::Column::InvalidError)
+    end
+
+    it 'returns true if columns are valid' do
+      expect_any_instance_of(Mode::Sdk::Column).to receive(:validate!)
+
+      set = Mode::Sdk::ColumnSet.new([{}])
+
+      expect(set.validate!).to eq(true)
+    end
+  end
+
+  describe '#to_array' do
+    it 'converts columns to attributes' do
+      set = Mode::Sdk::ColumnSet.new([{ foo: 'bar' }])
+
+      expect(set.to_array).to eq([{ 'foo' => 'bar' }])
+    end
+  end
+end