mailchimp3 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ed47a5c9aa596d1bd8ab0960067fecd28276112
+  data.tar.gz: c4106451d50a559f56e15b552d76e26cfbabfb93
+SHA512:
+  metadata.gz: c58c68f2c6b1fcff8db1f90bf260ecf565ed74384053635353470f9512a6eb1591d186a35b186e72cb968ae98c2b6ff535a1e7de37aa29ba6a88d5e9d7974f81
+  data.tar.gz: 1a4a7c917560dba01b9e71a39f5570dc432af9a0589c0641c4ada87dc726d4fc23e233b802f24d663617df721ac12902856b3ff144653907652ea2f9bd651e39

data/README.md

@@ -0,0 +1,273 @@
+# MailChimp3
+
+[![Circle CI](https://circleci.com/gh/seven1m/mailchimp3/tree/master.svg?style=svg)](https://circleci.com/gh/seven1m/mailchimp3/tree/master)
+
+`mailchimp3` is a Rubygem that provides a very thin, simple wrapper around the MailChimp RESTful JSON API version 3.0
+documented at [kb.mailchimp.com/api](http://kb.mailchimp.com/api/).
+
+## Installation
+
+```
+gem install mailchimp3 (eventually)
+```
+
+## Usage with HTTP Basic Auth
+
+1. Set your HTTP Basic auth key somewhere in your app
+   (probably an initializer if using Rails):
+
+   ```ruby
+   MailChimp3.config.basic_auth_key = 'key-us2'
+   ```
+
+2. Create a new API object and use it:
+
+   ```ruby
+   # HTTP Basic
+   api = MailChimp3.new
+   ```
+
+3. Call a method on the api object to build the endpoint path.
+
+   ```ruby
+   api.lists
+   # /lists
+   ```
+
+4. For IDs, treat the object like a hash (use square brackets).
+
+   ```ruby
+   api.lists['abc123'].members
+   # /lists/abc123/members
+   ```
+
+5. To execute the request, use `get`, `post`, `patch`, or `delete`, optionally passing arguments.
+
+   ```ruby
+   api.lists.get(count: 25)
+   # GET /lists?count=25
+   api.lists['abc123'].members['cde345'].get
+   # GET /lists/abc123/members/cde345
+   ```
+
+### Usage with OAuth 2
+
+1. Set your OAuth client id and secret somewhere in your app
+   (probably an initializer if using Rails):
+
+   ```ruby
+   MailChimp3.config.client_id = 'abc123'
+   MailChimp3.config.client_secret = 'xyz456'
+   ```
+
+2. (First time for each user) Get an OAuth 2 token by calling `MailChimp3.oauth.authorize_url` and redirect your user to it:
+
+   ```ruby
+   url = MailChimp3.oauth.authorize_url(
+     redirect_uri: 'http://example.com/oauth/callback'
+   )
+   redirect_to url
+   ```
+
+3. Upon redirect back to your app (in your `/oauth/callback` action),
+   call `MailChimp3.oauth.complete_auth`, passing in the `code` param
+   and the `redirect_uri` again.
+
+   ```ruby
+   data = MailChimp3.oauth.complete_auth(
+     params[:code],
+     redirect_uri: 'http://example.com/oauth/callback'
+   )
+   ```
+
+   The hash returned looks like this:
+
+   ```ruby
+   {
+     token: <OAuth2::AccessToken>
+     token_string: 'abc123',
+     metadata: {
+       dc: 'us2'
+     }
+   }
+   ```
+
+   Then get the authentication token and data center, and store it on
+   your user record for later use:
+
+   ```ruby
+   user.update_attributes(
+     mailchimp_auth_token: data[:token_string],
+     mailchimp_data_center: data[:metadata][:dc]
+   )
+   ```
+
+4. (Subsequent times for user) Instantiate the api object, passing in the
+   auth token and data center:
+
+   ```ruby
+   api = MailChimp3.new(
+     oauth_auth_token: user.mailchimp_auth_token,
+     dc: user.mailchimp_data_center
+   )
+   ```
+
+5. Use the `api` instance to make API calls!
+
+## Example
+
+```ruby
+require 'mailchimp3'
+
+api = MailChimp3.new(basic_auth_key: 'abc123abc123abc123abc123abc123ab-us2')
+api.lists.post(
+  name: 'Church.IO',
+  email_type_option: false,
+  permission_reminder: 'signed up on https://church.io'
+  contact: {
+    company: 'TJRM',
+    address1: '123 N. Main',
+    city: 'Tulsa',
+    state: 'OK',
+    zip: '74137',
+    country: 'US'
+  },
+  campaign_defaults: {
+    from_name: 'Tim Morgan',
+    from_email: 'tim@timmorgan.org',
+    subject: 'Hello World',
+    language: 'English'
+  },
+)
+```
+
+...which returns something like:
+
+```ruby
+{
+  "id"   => "abc123abc1",
+  "name" => "Church.IO",
+  "contact" => {
+    "company"  => "TJRM",
+    "address1" => "123 N. Main",
+    "address2" => "",
+    "city"     => "Tulsa",
+    "state"    => "OK",
+    "zip"      => "74137",
+    "country"  => "US",
+    "phone"    => ""
+  },
+  "campaign_defaults" => {
+    "from_name"  => "Tim Morgan",
+    "from_email" => "tim@timmorgan.org",
+    "subject"    => "test",
+    "language"   => "English"
+  },
+  # ...
+  "stats" => {
+    "member_count" => 0,
+    # ...
+  },
+  "_links" => [
+    {
+      "rel"          => "self",
+      "href"         => "https://us2.api.mailchimp.com/3.0/lists/abc123abc1",
+      "method"       => "GET",
+      "targetSchema" => "https://us2.api.mailchimp.com/schema/3.0/Lists/Instance.json"
+    },
+    # ...
+  ]
+}
+```
+
+## get()
+
+`get()` works for a collection (index) and a single resource (show).
+
+```ruby
+# collection
+api.lists['abc123'].members.get(count: 25)
+# => { members: array_of_resources }
+
+# single resource
+api.lists['abc123'].members['cde345'].get
+# => resource_hash
+```
+
+## post()
+
+`post()` sends a POST request to create a new resource.
+
+```ruby
+api.lists['abc123'].members.post(...)
+# => resource_hash
+```
+
+## patch()
+
+`patch()` sends a PATCH request to update an existing resource.
+
+```ruby
+api.lists['abc123'].members['cde345'].patch(...)
+# => resource_hash
+```
+
+## delete()
+
+`delete()` sends a DELETE request to delete an existing resource. This method returns `true` if the delete was successful.
+
+```ruby
+api.lists['abc123'].members['cde345'].delete
+# => true
+```
+
+## Errors
+
+The following errors may be raised by the library, depending on the API response status code.
+
+| HTTP Status Codes   | Error Class                                                                   |
+| ------------------- | ----------------------------------------------------------------------------- |
+| 400                 | `MailChimp3::Errors::BadRequest` < `MailChimp3::Errors::ClientError`          |
+| 401                 | `MailChimp3::Errors::Unauthorized` < `MailChimp3::Errors::ClientError`        |
+| 403                 | `MailChimp3::Errors::Forbidden` < `MailChimp3::Errors::ClientError`           |
+| 404                 | `MailChimp3::Errors::NotFound` < `MailChimp3::Errors::ClientError`            |
+| 405                 | `MailChimp3::Errors::MethodNotAllowed` < `MailChimp3::Errors::ClientError`    |
+| 422                 | `MailChimp3::Errors::UnprocessableEntity` < `MailChimp3::Errors::ClientError` |
+| other 4xx errors    | `MailChimp3::Errors::ClientError`                                             |
+| 500                 | `MailChimp3::Errors::InternalServerError` < `MailChimp3::Errors::ServerError` |
+| other 5xx errors    | `MailChimp3::Errors::ServerError`                                             |
+
+The exception object has the following methods:
+
+| Method  | Content                                  |
+| ------- | ---------------------------------------- |
+| status  | HTTP status code returned by the server  |
+| message | the message returned by the API          |
+| details | the full response returned by the server |
+
+The `message` should be a simple string given by the API, e.g. "Resource Not Found".
+
+`details` is a Ruby hash containing all the details given by the server, and looks like this:
+
+```ruby
+{
+  "type"     => "http://kb.mailchimp.com/api/error-docs/400-invalid-resource",
+  "title"    => "Invalid Resource",
+  "status"   => 400,
+  "detail"   => "The resource submitted could not be validated. For field-specific details, see the 'errors' array.",
+  "instance" => "286179fe-f3dc-4c03-8c14-1021cf0191a2",
+  "errors" => [
+    {
+      "field"   => "",
+      "message" => "Required fields were not provided: permission_reminder, campaign_defaults"
+    }
+  ]
+}
+```
+
+Alternatively, you may rescue `MailChimp3::Errors::BaseError` and branch your code based on
+the status code returned by calling `error.status`.
+
+## Copyright & License
+
+Copyright 2015, Tim Morgan. Licensed MIT.

data/lib/mailchimp3.rb

@@ -0,0 +1,19 @@
+require_relative 'mailchimp3/endpoint'
+require_relative 'mailchimp3/oauth'
+require_relative 'mailchimp3/errors'
+
+module MailChimp3
+  module_function
+
+  def new(*args)
+    Endpoint.new(*args)
+  end
+
+  def config
+    @config ||= Struct.new(:client_id, :client_secret).new
+  end
+
+  def oauth
+    @oauth ||= MailChimp3::OAuth.new
+  end
+end

data/lib/mailchimp3/endpoint.rb

@@ -0,0 +1,114 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module MailChimp3
+  class Endpoint
+    attr_reader :url, :last_result
+
+    def initialize(oauth_access_token: nil, basic_auth_key: nil, dc: nil, url: nil)
+      @oauth_access_token = oauth_access_token
+      @basic_auth_key = basic_auth_key
+      @dc = dc
+      @dc ||= @basic_auth_key.split('-').last if @basic_auth_key
+      @url = url || _build_url
+      fail Errors::DataCenterRequiredError, 'You must pass dc.' unless @dc || @url
+      @cache = {}
+    end
+
+    def method_missing(method_name, *_args)
+      _build_endpoint(method_name.to_s)
+    end
+
+    def [](id)
+      _build_endpoint(id.to_s)
+    end
+
+    def get(params = {})
+      @last_result = _connection.get(@url, params)
+      _build_response(@last_result)
+    end
+
+    def post(body = {})
+      @last_result = _connection.post(@url) do |req|
+        req.body = body.to_json
+      end
+      _build_response(@last_result)
+    end
+
+    def patch(body = {})
+      @last_result = _connection.patch(@url) do |req|
+        req.body = body.to_json
+      end
+      _build_response(@last_result)
+    end
+
+    def delete
+      @last_result = _connection.delete(@url)
+      if @last_result.status == 204
+        true
+      else
+        _build_response(@last_result)
+      end
+    end
+
+    private
+
+    def _build_response(result)
+      case result.status
+      when 200..299
+        result.body
+      when 400
+        fail Errors::BadRequest, result
+      when 401
+        fail Errors::Unauthorized, result
+      when 403
+        fail Errors::Forbidden, result
+      when 404
+        fail Errors::NotFound, result
+      when 405
+        fail Errors::MethodNotAllowed, result
+      when 422
+        fail Errors::UnprocessableEntity, result
+      when 400..499
+        fail Errors::ClientError, result
+      when 500
+        fail Errors::InternalServerError, result
+      when 500..599
+        fail Errors::ServerError, result
+      else
+        binding.pry
+        fail "unknown status #{result.status}"
+      end
+    end
+
+    def _build_endpoint(path)
+      @cache[path] ||= begin
+        self.class.new(
+          url: File.join(url, path.to_s),
+          basic_auth_key: @basic_auth_key,
+          oauth_access_token: @oauth_access_token
+        )
+      end
+    end
+
+    def _build_url
+      url = "https://#{@dc}.api.mailchimp.com/3.0"
+      url << '/' if url =~ /3\.0\z/ # workaround for the api requiring a slash on the root urls
+      url
+    end
+
+    def _connection
+      @connection ||= Faraday.new(url: url) do |faraday|
+        faraday.adapter :excon
+        faraday.response :json, content_type: /\bjson$/
+        if @basic_auth_key
+          faraday.basic_auth '', @basic_auth_key
+        elsif @oauth_access_token
+          faraday.headers['Authorization'] = "Bearer #{@oauth_access_token}"
+        else
+          fail Errors::AuthRequiredError, "You must specify either HTTP basic auth credentials or an OAuth2 access token."
+        end
+      end
+    end
+  end
+end

data/lib/mailchimp3/errors.rb

@@ -0,0 +1,39 @@
+module MailChimp3
+  module Errors
+    class AuthRequiredError < StandardError; end
+    class DataCenterRequiredError < StandardError; end
+
+    class BaseError < StandardError
+      attr_reader :status, :details
+
+      def initialize(response)
+        @status = response.status
+        @message = if response.body.is_a?(Hash)
+                     "#{response.body['title']}: #{response.body['detail']}"
+                   else
+                     response.body.to_s
+                   end
+        @details = response.body if response.body.is_a?(Hash)
+      end
+
+      def to_s
+        @message
+      end
+
+      def inspect
+        "<#{self.class.name} status=#{@status} message=#{@message}>"
+      end
+    end
+
+    class ClientError              < BaseError;   end # 400..499
+    class BadRequest               < ClientError; end # 400
+    class Unauthorized             < ClientError; end # 401
+    class Forbidden                < ClientError; end # 403
+    class NotFound                 < ClientError; end # 404
+    class MethodNotAllowed         < ClientError; end # 405
+    class UnprocessableEntity      < ClientError; end # 422
+
+    class ServerError              < BaseError;   end # 500..599
+    class InternalServerError      < ServerError; end # 500
+  end
+end

data/lib/mailchimp3/oauth.rb

@@ -0,0 +1,42 @@
+require 'oauth2'
+require 'json'
+
+module MailChimp3
+  class OAuth
+    def initialize
+      @oauth = OAuth2::Client.new(
+        MailChimp3.config.client_id,
+        MailChimp3.config.client_secret,
+        site: 'https://login.mailchimp.com',
+        authorize_url: '/oauth2/authorize',
+        token_url: '/oauth2/token'
+      )
+    end
+
+    def authorize_url(redirect_uri:)
+      @oauth.auth_code.authorize_url(redirect_uri: redirect_uri)
+    end
+
+    def complete_auth(code, redirect_uri:)
+      token = @oauth.auth_code.get_token(
+        code,
+        redirect_uri: redirect_uri
+      )
+      {
+        token: token,
+        token_string: token.token,
+        metadata: metadata(token)
+      }
+    end
+
+    private
+
+    def metadata(token)
+      JSON.parse(token.get('/oauth2/metadata').body).tap do |hash|
+        hash.keys.each do |key|
+          hash[key.to_sym] = hash.delete(key)
+        end
+      end
+    end
+  end
+end

data/lib/mailchimp3/version.rb

@@ -0,0 +1,3 @@
+module MailChimp3
+  VERSION = '1.0.0'
+end

data/spec/mailchimp3/endpoint_spec.rb

@@ -0,0 +1,194 @@
+require_relative '../spec_helper'
+require 'json'
+
+describe MailChimp3::Endpoint do
+  let(:base) { described_class.new(basic_auth_key: 'key-us2') }
+
+  subject { base }
+
+  describe '#method_missing' do
+    before do
+      @result = subject.lists
+    end
+
+    it 'returns a wrapper object with updated url' do
+      expect(@result).to be_a(described_class)
+      expect(@result.url).to match(%r{/lists$})
+    end
+  end
+
+  describe '#[]' do
+    before do
+      @result = subject.lists[1]
+    end
+
+    it 'returns a wrapper object with updated url' do
+      expect(@result).to be_a(described_class)
+      expect(@result.url).to match(%r{/lists/1$})
+    end
+  end
+
+  describe '#get' do
+    context 'given a good URL' do
+      subject { base.lists }
+
+      let(:result) do
+        {
+          'id'   => 'e8bcf09f6f',
+          'name' => 'My List'
+        }
+      end
+
+      before do
+        stub_request(:get, 'https://us2.api.mailchimp.com/3.0/lists')
+          .to_return(status: 200, body: { lists: result }.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+        @result = subject.get
+      end
+
+      it 'returns the result of making a GET request to the endpoint' do
+        expect(@result).to be_a(Hash)
+        expect(@result['lists']).to eq(result)
+      end
+    end
+
+    context 'given a non-existent URL' do
+      subject { base.non_existent }
+
+      let(:result) do
+        {
+          'status'  => 404,
+          'title'  => 'Resource Not Found',
+          'detail' => 'The requested resource could not be found.'
+        }
+      end
+
+      before do
+        stub_request(:get, 'https://us2.api.mailchimp.com/3.0/non_existent')
+          .to_return(status: 404, body: result.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+      end
+
+      it 'raises a NotFound error' do
+        error = begin
+                  subject.get
+                rescue MailChimp3::Errors::NotFound => e
+                  e
+                end
+        expect(error.status).to eq(404)
+        expect(error.message).to eq('Resource Not Found: The requested resource could not be found.')
+      end
+    end
+
+    context 'given a client error' do
+      subject { base.error }
+
+      let(:result) do
+        {
+          'status'  => 400,
+          'title' => 'Bad request'
+        }
+      end
+
+      before do
+        stub_request(:get, 'https://us2.api.mailchimp.com/3.0/error')
+          .to_return(status: 400, body: result.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+      end
+
+      it 'raises a ClientError error' do
+        expect {
+          subject.get
+        }.to raise_error(MailChimp3::Errors::ClientError)
+      end
+    end
+
+    context 'given a server error' do
+      subject { base.error }
+
+      let(:result) do
+        {
+          'status'  => 500,
+          'title' => 'System error has occurred'
+        }
+      end
+
+      before do
+        stub_request(:get, 'https://us2.api.mailchimp.com/3.0/error')
+          .to_return(status: 500, body: result.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+      end
+
+      it 'raises a ServerError error' do
+        expect {
+          subject.get
+        }.to raise_error(MailChimp3::Errors::ServerError)
+      end
+    end
+  end
+
+  describe '#post' do
+    subject { base.lists }
+
+    let(:resource) do
+      {
+        'name' => 'Foo'
+      }
+    end
+
+    let(:result) do
+      {
+        'id'   => 'd3ed40bd7c',
+        'name' => 'Foo'
+      }
+    end
+
+    before do
+      stub_request(:post, 'https://us2.api.mailchimp.com/3.0/lists')
+        .to_return(status: 201, body: result.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+      @result = subject.post(resource)
+    end
+
+    it 'returns the result of making a POST request to the endpoint' do
+      expect(@result).to eq(result)
+    end
+  end
+
+  describe '#patch' do
+    subject { base.lists['d3ed40bd7c'] }
+
+    let(:resource) do
+      {
+        'id'   => 'd3ed40bd7c',
+        'name' => 'Foo'
+      }
+    end
+
+    let(:result) do
+      {
+        'id'   => 'd3ed40bd7c',
+        'name' => 'Foo'
+      }
+    end
+
+    before do
+      stub_request(:patch, 'https://us2.api.mailchimp.com/3.0/lists/d3ed40bd7c')
+        .to_return(status: 200, body: result.to_json, headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+      @result = subject.patch(resource)
+    end
+
+    it 'returns the result of making a PATCH request to the endpoint' do
+      expect(@result).to eq(result)
+    end
+  end
+
+  describe '#delete' do
+    subject { base.lists['d3ed40bd7c'] }
+
+    before do
+      stub_request(:delete, 'https://us2.api.mailchimp.com/3.0/lists/d3ed40bd7c')
+        .to_return(status: 204, body: '')
+      @result = subject.delete
+    end
+
+    it 'returns true' do
+      expect(@result).to eq(true)
+    end
+  end
+end

data/spec/mailchimp3/oauth_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper'
+
+MailChimp3.config.client_id = 'foo'
+MailChimp3.config.client_secret = 'bar'
+
+describe MailChimp3::OAuth do
+  subject { MailChimp3.oauth }
+
+  describe '#authorize_url' do
+    it 'returns the authorization url' do
+      url = subject.authorize_url(
+        redirect_uri: 'http://example.com/oauth/callback'
+      )
+      expect(url).to eq('https://login.mailchimp.com/oauth2/authorize?client_id=foo&redirect_uri=http%3A%2F%2Fexample.com%2Foauth%2Fcallback&response_type=code')
+    end
+  end
+
+  describe '#complete_auth' do
+    before do
+      stub_request(:post, 'https://login.mailchimp.com/oauth2/token')
+        .with(body: {
+          'client_id'     => 'foo',
+          'client_secret' => 'bar',
+          'code'          => '1234567890',
+          'grant_type'    => 'authorization_code',
+          'redirect_uri'  => 'http://example.com/oauth/callback'
+        })
+        .to_return(
+          status: 200,
+          body: {
+            access_token: '925680f04933b28f128d721fdf8949fa',
+            expires_in: 0,
+            scope: nil
+          }.to_json,
+          headers: {
+            'Content-Type' => 'application/json'
+          }
+        )
+        stub_request(:get, 'https://login.mailchimp.com/oauth2/metadata')
+          .with(headers: {
+            'Authorization' => 'Bearer 925680f04933b28f128d721fdf8949fa'
+          })
+          .to_return(
+            status: 200,
+            body: {
+              dc: 'us2',
+              role: 'owner',
+              accountname: 'timmorgan',
+              user_id: 2472146,
+              login: {
+                email: 'tim@timmorgan.org',
+                avatar: nil,
+                login_id: 2472146,
+                login_name: 'timmorgan',
+                login_email:'tim@timmorgan.org'
+              },
+              login_url: 'https://login.mailchimp.com',
+              api_endpoint: 'https://us2.api.mailchimp.com'
+            }.to_json)
+    end
+
+    it 'stores the auth token and metadata' do
+      url = subject.authorize_url(
+        redirect_uri: 'http://example.com/oauth/callback'
+      )
+      hash = subject.complete_auth(
+        '1234567890',
+        redirect_uri: 'http://example.com/oauth/callback'
+      )
+      expect(hash[:token]).to be_an(OAuth2::AccessToken)
+      expect(hash[:token_string]).to eq('925680f04933b28f128d721fdf8949fa')
+      expect(hash[:metadata]).to be_a(Hash)
+      expect(hash[:metadata][:dc]).to eq('us2')
+    end
+  end
+end

data/spec/mailchimp3_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+
+describe MailChimp3 do
+  describe '#config' do
+    it 'returns configuration object' do
+      subject.config.client_id = 'foo'
+      subject.config.client_secret = 'bar'
+      expect(subject.config.client_id).to eq('foo')
+      expect(subject.config.client_secret).to eq('bar')
+    end
+  end
+
+  describe '#oauth' do
+    it 'returns a MailChimp3::OAuth instance' do
+      expect(subject.oauth).to be_a(MailChimp3::OAuth)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'webmock/rspec'
+require 'pry'
+
+require_relative '../lib/mailchimp3'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.color = true
+  config.order = 'random'
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: mailchimp3
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.3
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: mailchimp3 is a gem for working with MailChimp's RESTful JSON API documented
+  at http://kb.mailchimp.com/api/ using HTTP basic auth or OAuth 2.0. This library
+  can talk to any endpoint the API provides, since it is written to build endpoint
+  URLs dynamically using method_missing.
+email: tim@timmorgan.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mailchimp3.rb
+- lib/mailchimp3/endpoint.rb
+- lib/mailchimp3/errors.rb
+- lib/mailchimp3/oauth.rb
+- lib/mailchimp3/version.rb
+- spec/mailchimp3/endpoint_spec.rb
+- spec/mailchimp3/oauth_spec.rb
+- spec/mailchimp3_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/seven1m/mailchimp3
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: wrapper for MailChimp's 3.0 API
+test_files:
+- spec/mailchimp3/endpoint_spec.rb
+- spec/mailchimp3/oauth_spec.rb
+- spec/mailchimp3_spec.rb
+- spec/spec_helper.rb