milkman 0.0.1

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.rspec
+.config
+.bundle
+*.gem
+Gemfile.lock
+doc/
+pkg/*
+coverage

data/.ruby-gemset

@@ -0,0 +1 @@
+milkman

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p392

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+script: rspec
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kevin Tuhumury
+
+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,97 @@
+# Milkman
+
+[![Build Status](https://travis-ci.org/kevintuhumury/milkman.png?branch=master)](https://travis-ci.org/kevintuhumury/milkman)
+[![Dependency Status](https://gemnasium.com/kevintuhumury/milkman.png)](https://gemnasium.com/kevintuhumury/milkman)
+[![Code Climate](https://codeclimate.com/github/kevintuhumury/milkman.png)](https://codeclimate.com/github/kevintuhumury/milkman)
+[![Coverage Status](https://coveralls.io/repos/kevintuhumury/milkman/badge.png?branch=master)](https://coveralls.io/r/kevintuhumury/milkman)
+
+This gem provides a Ruby wrapper around the [Remember The Milk](https://www.rememberthemilk.com) (RTM) API, using HTTParty. Milkman is a library to access the RTM API in an easy way. It maps all of the methods, which are described in the [official documentation](https://www.rememberthemilk.com/services/api/methods/). Whenever new methods are added to the RTM API, you'll be able to use them immediately through Milkman.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'milkman'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install milkman
+
+## Authorize Milkman
+
+To use Milkman you'll need to authorize the gem with Remember The Milk. In order to do that, you'll need to apply for an API key and shared secret. When that's done, you'll need to run the `milkman` executable.
+
+### Apply for an API key and shared secret
+
+You can retrieve an API key and shared secret from the official Remember The Milk [site](https://www.rememberthemilk.com/services/api/keys.rtm). Just follow the instructions and once you've received the API key and shared secret, move on to the next step.
+
+### Run the `milkman` executable
+
+    milkman authorize API_KEY SHARED_SECRET
+    
+Something like the following will be shown to you:
+
+    Copy the URL below and follow the steps on Remember The Milk (RTM) to authorize Milkman:
+
+    http://www.rememberthemilk.com/services/auth/?api_key=API_KEY&shared_secret=SHARED_SECRET&perms=read&format=json&api_sig=08da0d11ef239318027364133ac1a644
+
+    Once you've authorized Milkman, you'll receive a hash called 'frob' from Remember The Milk. The page from Remember The Milk will list something like the following: 'No callback URL specified for this API key. Your frob value is YOUR_FROB'. Copy and paste that YOUR_FROB value below and press <enter>:
+
+Copy the URL (as requested) and paste it in your browser. Next copy the frob from the Remember The Milk website, paste it in your shell and press enter. Once you've done that, you'll receive the authentication token (auth token) from Remember The Milk:
+
+    USERNAME, you've successfully authorized Milkman with Remember The Milk. As you can see we've received your username and an authorization token. Both this auth token, your API key and shared secret should be saved for later use. You can either save them in a YAML file and load them in your application, include them in the Ruby script where you're using this gem or set them as environment variables. That's completely up to you.
+
+    Both the auth token, API key and shared secret are listed below. Save them using one of the methods above (or perhaps another solution) as you'll need all of them to use Milkman in your own project. Oh, and Remember... The Milk!
+
+        api_key:       API_KEY
+	    shared_secret: SHARED_SECRET
+	    auth_token:    AUTH_TOKEN
+
+Take note of the variables and save them, since you'll need them to use Milkman.
+
+## Using Milkman
+
+Using Milkman is easy. All you need to know is that all calls go through the `Milkman::Client` class. Specifically it's `get` method. Let's say you want to retrieve all your tasks from RTM. Well, there's a method for that and it's called: `rtm.tasks.getList`. More information about that method can be found [here](https://www.rememberthemilk.com/services/api/methods/rtm.tasks.getList.rtm).
+
+### Create an instance of the Milkman client
+
+In order to retrieve the above information, we'll need an instance of the Milkman client. So let's create it:
+
+	client = Milkman::Client.new api_key: API_KEY, shared_secret: SHARED_SECRET, auth_token: AUTH_TOKEN
+	
+That's it.
+
+### Milking the cow, err... Calling our method
+
+Now, let's call our `rtm.tasks.getList` method:
+
+	client.get "rtm.tasks.getList"
+	
+The above call will return every task you have. As can be seen on the [API page](https://www.rememberthemilk.com/services/api/methods/rtm.tasks.getList.rtm) of the above method, there are a couple of optional parameters, like `list_id`, `filter` and `last_sync`. These can be used as follows:
+
+	client.get "rtm.tasks.getList", { list_id: 1, filter: "some filter" }
+
+### Response format
+
+Eventhough the API documentation shows the responses as XML, Milkman will return JSON as it's default response format.
+
+## Contributing
+
+You're very welcome to contribute to this gem. To do so, please follow these steps:
+
+1. Fork this project
+2. Clone your fork on your local machine
+3. Install the development dependencies with `bundle install`
+4. Create your feature branch with `git checkout -b my-new-feature`
+5. Run the specs with `rspec` and make sure everything is covered with RSpec
+6. Commit your changes `git commit -am 'Added new feature'`
+7. Push to your branch `git push origin my-new-feature`
+8. Create a new Pull Request
+
+## Copyright
+
+Copyright 2013 Kevin Tuhumury. Released under the MIT License.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/milkman

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "milkman"
+
+Milkman::CLI.start ARGV

data/lib/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  milkman:
+    authorization:
+      frob_message: "\nCopy the URL below and follow the steps on Remember The Milk (RTM) to authorize Milkman:\n\n%{url}\n\nOnce you've authorized Milkman, you'll receive a hash called 'frob' from Remember The Milk. The page from Remember The Milk will list something like the following: 'No callback URL specified for this API key. Your frob value is YOUR_FROB'. Copy and paste that YOUR_FROB value below and press <enter>:\n\n"
+      auth_token_message: "\n%{username}, you've successfully authorized Milkman with Remember The Milk. As you can see we've received your username and an authorization token. Both this auth token, your API key and shared secret should be saved for later use. You can either save them in a YAML file and load them in your application, include them in the Ruby script where you're using this gem or set them as environment variables. That's completely up to you.\n\nBoth the auth token, API key and shared secret are listed below. Save them using one of the methods above (or perhaps another solution) as you'll need all of them to use Milkman in your own project. Oh, and Remember... The Milk!\n\n\tapi_key:       %{api_key}\n\tshared_secret: %{shared_secret}\n\tauth_token:    %{auth_token}\n\n"

data/lib/milkman.rb

@@ -0,0 +1,20 @@
+require "i18n"
+
+module Milkman
+
+  AUTH_URL = "http://www.rememberthemilk.com/services/auth/"
+  BASE_URL = "http://api.rememberthemilk.com/services/rest/"
+
+  I18n.load_path += Dir.glob(File.join(File.dirname(__FILE__), "locales/*.yml"))
+
+  class NoMilkError < StandardError; end
+  class InvalidResponseError < StandardError; end
+
+end
+
+require "milkman/cli"
+require "milkman/utility"
+require "milkman/request"
+require "milkman/client"
+require "milkman/authorizer"
+require "milkman/version"

data/lib/milkman/authorizer.rb

@@ -0,0 +1,44 @@
+module Milkman
+  class Authorizer
+
+    include Utility
+
+    attr_accessor :options
+
+    def initialize(attributes)
+      @options = attributes.merge! default_options
+    end
+
+    def self.authorize(options)
+      new(options).authorize
+    end
+
+    def authorize
+      puts I18n.t("milkman.authorization.frob_message", url: frob_message_url)
+      puts I18n.t("milkman.authorization.auth_token_message", username: response["rsp"]["auth"]["user"]["username"], api_key: options[:api_key], shared_secret: options[:shared_secret], auth_token: response["rsp"]["auth"]["token"])
+    end
+
+    private
+
+    def response
+      @response ||= Milkman::Request.call request_url(signed_options)
+    end
+
+    def signed_options
+      sign options[:shared_secret], options.merge!(method: "rtm.auth.getToken", frob: frob)
+    end
+
+    def frob
+      STDIN.gets.strip
+    end
+
+    def frob_message_url
+      authorization_url sign(options[:shared_secret], options)
+    end
+
+    def authorization_url(parameters)
+      [ AUTH_URL, encode(parameters) ].join "?"
+    end
+
+  end
+end

data/lib/milkman/cli.rb

@@ -0,0 +1,12 @@
+require "thor"
+
+module Milkman
+  class CLI < Thor
+
+    desc "authorize API_KEY SHARED_SECRET", "Authorize Milkman with Remember The Milk (RTM) by entering an API key and shared secret."
+    def authorize(api_key, shared_secret)
+      Authorizer.authorize api_key: api_key, shared_secret: shared_secret
+    end
+
+  end
+end

data/lib/milkman/client.rb

@@ -0,0 +1,28 @@
+module Milkman
+  class Client
+
+    include Utility
+
+    attr_accessor :options
+
+    def initialize(attributes)
+      @options = attributes.merge default_options
+
+      if !has_required_options?
+        raise NoMilkError, "The API key and shared secret are required."
+      end
+    end
+
+    def get(method, request_options = {})
+      signed_options = sign options[:shared_secret], options.merge!(method: method).merge!(request_options)
+      Milkman::Request.call request_url(signed_options)
+    end
+
+    private
+
+    def has_required_options?
+      options[:api_key] && options[:shared_secret]
+    end
+
+  end
+end

data/lib/milkman/request.rb

@@ -0,0 +1,43 @@
+require "httparty"
+
+module Milkman
+  class Request
+
+    include HTTParty
+
+    def self.call(url)
+      new(url).parsed_response
+    end
+
+    def initialize(url)
+      @url = url
+    end
+
+    def parsed_response
+      if code == 200
+        @response.parsed_response
+      else
+        raise InvalidResponseError, message
+      end
+    end
+
+    private
+
+    def request
+      @response ||= self.class.get @url
+    end
+
+    def response
+      request.response
+    end
+
+    def code
+      response.code.to_i
+    end
+
+    def message
+      "#{@response.message} (#{@response.code}): #{@response.body} #{@response.inspect}"
+    end
+
+  end
+end

data/lib/milkman/utility.rb

@@ -0,0 +1,27 @@
+module Milkman
+  module Utility
+
+    def sign(shared_secret, parameters)
+      parameters.delete(:api_sig)
+      parameters[:api_sig] = Digest::MD5.hexdigest format(shared_secret, parameters)
+      parameters
+    end
+
+    def format(shared_secret, parameters)
+      [ shared_secret, parameters.sort.flatten.join ].join
+    end
+
+    def encode(options)
+      URI::encode_www_form options
+    end
+
+    def request_url(options)
+      [ BASE_URL, encode(options) ].join "?"
+    end
+
+    def default_options
+      { perms: "delete", format: "json" }
+    end
+
+  end
+end

data/lib/milkman/version.rb

@@ -0,0 +1,3 @@
+module Milkman
+  VERSION = "0.0.1"
+end

data/milkman.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'milkman/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "milkman"
+  gem.version       = Milkman::VERSION
+  gem.authors       = ["Kevin Tuhumury"]
+  gem.email         = ["kevin.tuhumury@gmail.com"]
+  gem.homepage      = "http://github.com/kevintuhumury/milkman"
+  gem.summary       = %q{Milkman is a Ruby wrapper for the Remember The Milk (RTM) API.}
+  gem.description   = %q{This gem provides a Ruby wrapper around the Remember The Milk (RTM) API for use in your own project.}
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.executables   = ["milkman"]
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "thor"
+  gem.add_runtime_dependency "i18n"
+  gem.add_runtime_dependency "httparty"
+
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "capture_stdout"
+  gem.add_development_dependency "coveralls"
+end

data/spec/milkman/authorizer_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+module Milkman
+  describe Authorizer do
+
+    let(:options) do
+      { api_key: "<api_key>", shared_secret: "<shared_secret>" }
+    end
+
+    context "#initialize" do
+
+      it "saves a references to the specified options" do
+        hash = { api_key: "<api_key>", shared_secret: "<shared_secret>", format: "json", perms: "delete" }
+
+        client = described_class.new(options)
+        client.options.should eq hash
+      end
+
+    end
+
+    context ".authorize" do
+
+      it "authorizes" do
+        described_class.any_instance.should_receive(:authorize)
+        described_class.authorize options
+      end
+
+    end
+
+    context "#authorize" do
+
+      let(:output) do
+        capture_stdout { described_class.authorize options }
+      end
+
+      let(:response) do
+        {"rsp" => {"auth" => {"user" => {"username" => "<username>"}, "token" => "<token>"}}}
+      end
+
+      before { STDIN.stub(:gets).and_return "<frob>" }
+
+      it "makes a call to the RTM API" do
+        Milkman::Request.should_receive(:call).with(any_args).and_return response
+        capture_stdout { described_class.authorize options }
+      end
+
+      context "output" do
+
+        before do
+          Milkman::Request.stub(:call).with(any_args).and_return response
+        end
+
+        it "notifies the user of entering the frob value" do
+          described_class.any_instance.stub(:frob_message_url).and_return "<url>"
+          output.should include "\nCopy the URL below and follow the steps on Remember The Milk (RTM) to authorize Milkman:\n\n<url>\n\nOnce you've authorized Milkman, you'll receive a hash called 'frob' from Remember The Milk. The page from Remember The Milk will list something like the following: 'No callback URL specified for this API key. Your frob value is YOUR_FROB'. Copy and paste that YOUR_FROB value below and press <enter>:"
+        end
+
+        it "notifies the user of the received auth token, API key and shared secret" do
+          output.should include "<username>, you've successfully authorized Milkman with Remember The Milk. As you can see we've received your username and an authorization token. Both this auth token, your API key and shared secret should be saved for later use. You can either save them in a YAML file and load them in your application, include them in the Ruby script where you're using this gem or set them as environment variables. That's completely up to you.\n\nBoth the auth token, API key and shared secret are listed below. Save them using one of the methods above (or perhaps another solution) as you'll need all of them to use Milkman in your own project. Oh, and Remember... The Milk!\n\n\tapi_key:       <api_key>\n\tshared_secret: <shared_secret>\n\tauth_token:    <token>"
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/milkman/cli_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+module Milkman
+  describe CLI do
+
+    it "authorizes" do
+      Authorizer.should_receive(:authorize).with(api_key: "foo", shared_secret: "bar")
+      subject.authorize("foo", "bar")
+    end
+
+  end
+end

data/spec/milkman/client_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+module Milkman
+  describe Client do
+
+    let(:options) do
+      { api_key: "foo", shared_secret: "bar" }
+    end
+
+    context "#initialize" do
+
+      it "saves a references to the specified options" do
+        hash = { api_key: "foo", shared_secret: "bar", format: "json", perms: "delete" }
+
+        client = described_class.new(options)
+        client.options.should eq hash
+      end
+
+      context "when the required API key and shared secret aren't specified" do
+
+        before do
+          options[:api_key]       = nil
+          options[:shared_secret] = nil
+        end
+
+        it "raises a NoMilkError" do
+          expect { described_class.new(options) }.to raise_error NoMilkError, "The API key and shared secret are required."
+        end
+
+      end
+
+      context "when the API key is specified, but the shared secret isn't" do
+
+        before { options[:shared_secret] = nil }
+
+        it "raises a NoMilkError" do
+          expect { described_class.new(options) }.to raise_error NoMilkError, "The API key and shared secret are required."
+        end
+
+      end
+
+      context "when the API key isn't specified, but the shared secret is" do
+
+        before { options[:api_key] = nil }
+
+        it "raises a NoMilkError" do
+          expect { described_class.new(options) }.to raise_error NoMilkError, "The API key and shared secret are required."
+        end
+
+      end
+
+      context "when both the API key and shared secret are specified" do
+
+        it "doesn't raise a NoMilkError" do
+          expect { described_classClient.new(options) }.to_not raise_error NoMilkError
+        end
+
+      end
+
+    end
+
+    context "#get" do
+
+      it "requests a call to the RTM API with the specified method" do
+        Milkman::Request.should_receive(:call).with "http://api.rememberthemilk.com/services/rest/?api_key=foo&shared_secret=bar&perms=delete&format=json&method=method&api_sig=57c35d820267ab89717e291d619860d2"
+
+        client = described_class.new(options)
+        client.get "method"
+      end
+    end
+
+  end
+end

data/spec/milkman/request_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module Milkman
+  describe Request do
+
+    let(:url) { "#{BASE_URL}?foo=bar" }
+
+    let(:response) do
+      stub(code: 500, message: "Message", body: "Response Body", parsed_response: stub).as_null_object
+    end
+
+    before do
+      described_class.stub(:get).and_return response
+    end
+
+    context ".call" do
+
+      before { response.stub(:code).and_return 200 }
+
+      it "calls parsed_response" do
+        described_class.any_instance.should_receive(:parsed_response)
+        described_class.call url
+      end
+
+      it "makes a call to the RTM API" do
+        described_class.should_receive(:get).with url
+        described_class.call url
+      end
+
+    end
+
+    context "#parsed_response" do
+
+      context "when the response is OK (code: 200)" do
+
+        before { response.stub(:code).and_return 200 }
+
+        it "parses the HTTParty response" do
+          response.should_receive(:parsed_response)
+          described_class.call url
+        end
+
+      end
+
+      context "when the response isn't OK" do
+
+        before { described_class.stub!(:code).and_return 500 }
+
+        it "raises an InvalidResponseError" do
+          expect { described_class.call(url) }.to raise_error InvalidResponseError
+        end
+
+        it "notifies the user with a formatted message" do
+          expect { described_class.call(url) }.to raise_error InvalidResponseError, "Message (500): Response Body #{response.inspect}"
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/milkman/utility_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+class Klass
+  # Dummy Class
+end
+
+module Milkman
+  describe Utility do
+
+    let(:klass) { Klass.new.extend Utility }
+
+    let(:parameters) do
+      { foo: "bar", baz: "qux"}
+    end
+
+    context "#sign" do
+
+      subject { klass.sign "SECRET", parameters }
+
+      it "adds an api_sig to the specified parameters" do
+        parameters.should_not include(:api_sig)
+        expect { subject }.to change { parameters.size }.from(2).to(3)
+        parameters.should include(:api_sig)
+      end
+
+      it "calculates a MD5 hash of the formatted shared secret and specified parameters" do
+        subject[:api_sig].should eq "e307a0ab45b29409338e21e33dd2cfca"
+      end
+
+    end
+
+    context "#format" do
+
+      it "sorts the specified parameters by key name, concatenates key value pairs and attaches it to the shared secret" do
+        klass.format("SECRET", parameters).should eq "SECRETbazquxfoobar"
+      end
+
+    end
+
+    context "#encode" do
+
+      it "encodes the specified options to an url encoded string" do
+        klass.encode(foo: "bar", baz: "qux").should eq "foo=bar&baz=qux"
+      end
+
+    end
+
+    context "#request_url" do
+
+      it "creates a request url with url encoded query parameters" do
+        klass.request_url(foo: "bar", baz: "qux").should eq "http://api.rememberthemilk.com/services/rest/?foo=bar&baz=qux"
+      end
+
+    end
+
+    context "#default_options" do
+
+      it "knows its default API permissions" do
+        klass.default_options[:perms].should eq "delete"
+      end
+
+      it "knows its default API response format" do
+        klass.default_options[:format].should eq "json"
+      end
+
+    end
+
+  end
+end

data/spec/milkman_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Milkman do
+
+  it "knows its AUTH_URL" do
+    Milkman::AUTH_URL.should eq "http://www.rememberthemilk.com/services/auth/"
+  end
+
+  it "knows its BASE_URL" do
+    Milkman::BASE_URL.should eq "http://api.rememberthemilk.com/services/rest/"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter "spec"
+end
+
+require "milkman"
+require "capture_stdout"

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: milkman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kevin Tuhumury
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capture_stdout
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides a Ruby wrapper around the Remember The Milk (RTM) API
+  for use in your own project.
+email:
+- kevin.tuhumury@gmail.com
+executables:
+- milkman
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/milkman
+- lib/locales/en.yml
+- lib/milkman.rb
+- lib/milkman/authorizer.rb
+- lib/milkman/cli.rb
+- lib/milkman/client.rb
+- lib/milkman/request.rb
+- lib/milkman/utility.rb
+- lib/milkman/version.rb
+- milkman.gemspec
+- spec/milkman/authorizer_spec.rb
+- spec/milkman/cli_spec.rb
+- spec/milkman/client_spec.rb
+- spec/milkman/request_spec.rb
+- spec/milkman/utility_spec.rb
+- spec/milkman_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/kevintuhumury/milkman
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1332773264260098832
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1332773264260098832
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Milkman is a Ruby wrapper for the Remember The Milk (RTM) API.
+test_files:
+- spec/milkman/authorizer_spec.rb
+- spec/milkman/cli_spec.rb
+- spec/milkman/client_spec.rb
+- spec/milkman/request_spec.rb
+- spec/milkman/utility_spec.rb
+- spec/milkman_spec.rb
+- spec/spec_helper.rb