picturelife 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70cb3e82a2e7a9da6aef56b46beedb101c8dd3a3
+  data.tar.gz: 814c20f34212c76c3ef2ab463482c045eebc4fb4
+SHA512:
+  metadata.gz: 7a293f8d2025a200ce2c9eddb7b81b4a8a273771817f9bed148f6a072b12552bec02b883bb562b130b9b84f2f1e3153efcbad3fa779b56418b904fce2198c15c
+  data.tar.gz: 4f630b5d9a3bf5ff323b32d1a604153c8dab6090be1dea547d6e41ddd9b927104c519c86d9765836ed1c779647ad2ac236c6108fb84853a390a3a3e9dbe50eba

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in picturelife.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,11 @@
+guard 'rspec' do
+
+  watch(%r{^lib/(.+).rb$}) do |m|
+    "spec/#{m[1]}_spec.rb"
+  end
+
+  watch(%r{^spec/(.+).rb$}) do |m|
+    "spec/#{m[1]}.rb"
+  end
+
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Albert Zak
+
+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,58 @@
+# Picturelife
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'picturelife'
+
+And then execute:
+
+    $ bundle
+
+## Features
+
+  - Resumable photo upload
+  - Authentication via OAuth
+  - Minimal dependencies
+  - Ruby syntax
+
+## Usage
+
+### Setup
+```ruby
+
+    require 'picturelife'
+
+    Picturelife.client_id     = ENV['CLIENT_ID']
+    Picturelife.client_secret = ENV['CLIENT_SECRET']
+
+    Picturelife.redirect_uri  = 'http://localhost:3000/oauth'
+
+```
+
+### Authorization
+
+```ruby
+
+      <a href="<%= Picturelife.authorization_uri %>">Click here</a> to connect to Picturelife!</a>
+
+```
+
+```ruby
+
+    get '/oauth' do
+      code = params['code']
+      Picturelife.access_token_from_code = code
+    end
+
+```
+
+```ruby
+    
+    Picturelife::Medias.index(limit: 10)
+
+
+```
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'nested']
+end
+
+task :default => :spec

data/lib/picturelife.rb

@@ -0,0 +1,22 @@
+require 'cgi'
+require 'json'
+require 'oauth'
+require 'excon'
+require 'net/http'
+require 'digest/sha2'
+require 'picturelife/error'
+require 'picturelife/util'
+require 'picturelife/base'
+require 'picturelife/stub'
+require 'picturelife/oauth'
+require 'picturelife/api'
+require 'picturelife/ruler'
+
+Excon.defaults[:ssl_verify_peer] = false
+
+include Picturelife::Util
+include Picturelife::Ruler
+
+module Picturelife
+  VERSION = "0.0.1"
+end

data/lib/picturelife/api.rb

@@ -0,0 +1,37 @@
+module Picturelife
+
+  API_ENDPOINT = "https://api.picturelife.com/"
+
+  class Api
+    class << self
+
+      def call(uri, args = nil)
+        needs_token!
+
+        api_get(build_uri(uri, args))
+      end
+
+      private
+
+      def build_uri(uri, args = nil)
+        [API_ENDPOINT, uri, build_parameters(args)].join
+      end
+
+      def build_parameters(args = nil)
+        args = {} if args.nil?
+
+        args.merge!(access_token: Picturelife.access_token)
+
+        return ['?', URI.encode_www_form(args)].join
+      end
+
+      def api_get(uri)
+        uri      = URI(URI.encode(uri))
+        response = Net::HTTP.get(uri)
+        response = JSON.parse(response)
+        raise ApiError.new(response["status"], response["error"], response) if (response["status"] != 20000 && response["status"] != 200)
+        response
+      end
+    end
+  end
+end

data/lib/picturelife/base.rb

@@ -0,0 +1,35 @@
+module Picturelife
+  class << self
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :access_token
+    attr_accessor :refresh_token
+    attr_reader   :redirect_uri
+
+    def redirect_uri=(uri)
+      @redirect_uri = escape_uri(uri)
+    end
+
+    def configured?
+      @client_id     &&
+      @client_secret &&
+      @redirect_uri
+    end
+
+    def authenticated?
+      !! @access_token
+    end
+
+    def reset_configuration!
+      @client_id     = nil
+      @client_secret = nil
+      @redirect_uri  = nil
+      reset_authentication!
+    end
+
+    def reset_authentication!
+      @access_token  = nil
+      @refresh_token = nil
+    end
+  end
+end

data/lib/picturelife/error.rb

@@ -0,0 +1,51 @@
+module Picturelife
+
+  class NotConfiguredError < StandardError
+    def initialize
+      super <<-MSG.gsub(/^ {6}/, '')
+
+        You need to set up your API Credentials like this:
+          Picturelife.client_id     = ENV['CLIENT_ID']
+          Picturelife.client_secret = ENV['CLIENT_SECRET']
+          Picturelife.redirect_uri  = 'http://localhost:3000/oauth'
+      MSG
+    end
+  end
+
+  class NotAuthenticatedError < StandardError
+    def initialize
+      super <<-MSG.gsub(/^ {6}/, '')
+
+        Send your User to `Picturelife.authorization_uri` and catch
+        the access token from your `Picturelife.redirect_uri` like so:
+          Picturelife.access_token(params[:code])
+      MSG
+    end
+  end
+
+  class ApiError < StandardError
+    attr_reader :code
+    def initialize(code = nil, msg = nil, response = nil)
+      puts @code = code
+      puts response.to_s
+      super msg
+    end
+  end
+
+  class RulerError < ApiError; end
+  class OAuthError < ApiError; end
+
+  module Util
+
+    def needs_configuration!
+      raise NotConfiguredError unless Picturelife.configured?
+    end
+
+    def needs_token!
+      needs_configuration!
+      raise NotAuthenticatedError unless Picturelife.authenticated?
+    end
+
+  end
+
+end

data/lib/picturelife/oauth.rb

@@ -0,0 +1,105 @@
+module Picturelife
+
+  OAUTH_ENDPOINT = "https://api.picturelife.com/oauth/"
+
+  class << self
+    def authorization_uri
+      needs_configuration!
+
+      [
+        OAUTH_ENDPOINT,
+        "authorize?",
+        "client_id=#{@client_id}",
+        "&client_secret=#{@client_secret}",
+        "&redirect_uri=#{@redirect_uri}",
+        "&response_type=code"
+      ].join
+    end
+
+    def access_token_from_code=(code)
+      needs_configuration!
+
+      uri = [
+        OAUTH_ENDPOINT,
+        "access_token?",
+        "client_id=#{@client_id}",
+        "&client_secret=#{@client_secret}",
+        "&code=#{code}",
+        "&client_uuid=#{client_uuid}"
+      ].join
+
+      res = api_oauth_get(uri)
+
+      if res['status'] != 200
+        raise OAuthError.new(res['status'], res['error'], res)
+      else
+        @refresh_token = res['refresh_token']
+        @user_id       = res['user_id']
+        @token_expires = Time.at(res['expires'])
+        @access_token  = res['access_token']        
+      end
+    end
+
+    private
+
+    def api_oauth_get(uri)
+      uri      = URI(URI.encode(uri))
+      response = Net::HTTP.get(uri)
+      response = JSON.parse(hashrocket_to_json(response))
+      raise OAuthError.new(response["error"]) if response["status"] != 200
+      response
+    end
+  end
+
+
+  class OAuth
+
+    attr_accessor :verb, :uri, :body
+
+    def initialize(verb, uri, body)
+      @verb   = verb
+      @uri    = uri
+      @body = body
+    end
+
+    def authorization_header
+      header = "OAuth "
+      oauth_params.each do |k, v|
+        header += "#{k}=\"#{v}\", "
+      end
+      header.slice(0..-3) # chop off last ", "
+    end
+
+    private
+
+    def oauth_params
+      {
+        'oauth_timestamp'        => Time.now.getutc.to_i.to_s,
+        'oauth_token'            => escape_uri(Picturelife.access_token),
+        'oauth_consumer_key'     => Picturelife.client_id,
+        'oauth_signature_method' => 'HMAC-SHA1',
+        'oauth_signature'        => signature,
+        'oauth_nonce'            => nonce,
+        'oauth_version'          => '1.0'
+      }
+    end
+
+    def signature
+      body = @body.dup
+      body['access_token'] = Picturelife.access_token
+      body = body.map      { |k, v| [k.to_s, v.to_s] }
+      body = body.sort.map { |k, v| escape_uri("#{k}=#{v}") }.join('%26')
+
+      base   = [verb, escape_uri(uri), body].join('&')
+      key    = [Picturelife.client_secret, Picturelife.access_token].join('&')
+      escape_uri(sign(key, base))
+    end
+
+    def sign(key, base)
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      hmac   = OpenSSL::HMAC.digest(digest, key, base)
+      Base64.encode64(hmac).chomp.gsub(/\n/, '')
+    end
+
+  end
+end

data/lib/picturelife/ruler.rb

@@ -0,0 +1,103 @@
+module Picturelife
+
+  RULER_ENDPOINT  = "https://services.picturelife.com/ruler/"
+
+  module Ruler
+
+    def upload(file_path, options = {}, processing_needs = [])
+      needs_token!
+
+      @file_path        = file_path
+      @signature        = get_signature(file_path)
+      @filename         = get_filename(file_path)
+      @force            = !! options[:force]
+      @options          = options
+      @processing_needs = processing_needs
+
+      media_exists || perform_upload
+
+    rescue RulerError => e
+      (e.code == 519256) ? retry : raise(e)
+    rescue Timeout::Error, Errno::ECONNRESET
+      retry
+    end
+
+    def head(file_path)
+      @file_path = file_path
+      @signature = get_signature(file_path)
+      @filename  = get_filename(file_path)
+
+      ruler('HEAD')
+    end
+
+    private
+
+    def media_exists
+      medias = Picturelife::Medias.check_signatures(signatures: @signature)['signatures'] || {}
+      return false if medias.empty?
+      return Picturelife::Medias.show(media_id: medias[@signature]['media_id']) unless @force
+      return false
+    end
+
+    def perform_upload      
+      header   = { 'Content-Range'  => "bytes #{filesize_uploaded}-#{filesize_total}/#{filesize_total}" }
+      location = ruler(:put, file_partial, header)['location']
+      create_media_from_ruler(location)
+    end
+
+    def file_partial
+      IO.binread(@file_path, nil, filesize_uploaded)
+    end
+
+    def filesize_total
+      File.size(@file_path)
+    end
+
+    def filesize_uploaded
+      @filesize_uploaded ||= lambda do
+        uploaded = ruler(:head)['X-Ruler-Size']
+        uploaded = uploaded.first if uploaded
+        uploaded.to_i
+      end.call
+    end
+
+    def create_media_from_ruler(location)
+      Picturelife::Media.create({
+        url: location,
+        signature: @signature,
+        force: (!!@force).to_s,
+        local_path: @file_path,
+        processing_needs: @processing_needs.map(&:to_s).join(',')
+      }.merge(@options))
+    end
+
+    def auth
+      { 
+        'Authorization' => "Bearer #{Picturelife.access_token}",
+        'User-Agent'    => "rubygem/#{VERSION}"
+      }
+    end
+
+    def ruler(verb, data = nil, headers = {})
+      http = Excon.new(RULER_ENDPOINT + @filename)
+      res  = http.request(
+        method:     verb,
+        query:      { signature: @signature },
+        headers:    auth.merge(headers),
+        body:       data,
+        idempotent: true
+      )
+
+      body = res.body
+      body = (body && body.length >= 2) ? JSON.parse(body) : {}
+      body.merge!(res.headers)
+
+      unless body['X-Ruler-Error-Code'].to_s.empty?
+        raise RulerError.new(body['X-Ruler-Error-Code'], body['X-Ruler-Error'], body)
+      else
+        body
+      end
+    end
+
+  end
+end

data/lib/picturelife/stub.rb

@@ -0,0 +1,22 @@
+module Picturelife
+
+  def self.const_missing(name)
+    Stub.new(underscore(name.to_s))
+  end
+
+  class Stub
+    
+    attr_reader :module_name
+
+    def initialize(module_name)
+      @module_name = module_name
+    end
+
+    def method_missing(name, args = nil)
+      method = [module_name, name].join('/')
+      Api.call(method, args)
+    end
+
+  end
+
+end

data/lib/picturelife/util.rb

@@ -0,0 +1,39 @@
+module Picturelife
+  module Util
+
+    def escape_uri(text)
+      return '' if text.nil?
+      CGI::escape(text)
+    end
+
+    def underscore(camelcase)
+      camelcase.gsub(/(.)([A-Z])/,'\1_\2').downcase
+    end
+
+    def api_get(uri)
+      uri = URI(URI.encode(uri))
+      JSON.parse(Net::HTTP.get(uri))
+    end
+
+    def hashrocket_to_json(string)
+      string.gsub('=>', ':')
+    end
+
+    def client_uuid
+      @client_uuid ||= rand(10**10).to_s
+    end
+
+    def nonce
+      rand(10**10).to_s
+    end
+    
+    def get_signature(file_path)
+      Digest::SHA256.hexdigest File.read(file_path)
+    end
+
+    def get_filename(file_path)
+      [get_signature(file_path), '_', client_uuid, File.extname(file_path)].join
+    end
+
+  end
+end

data/picturelife.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'picturelife'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'picturelife'
+  spec.version       = Picturelife::VERSION
+  spec.authors       = ['Albert Zak']
+  spec.email         = ['me@albertzak.com']
+  spec.summary       = %q{Picturelife API. OAuth. Resumable Uploads.}
+  spec.description   = 'A gem to access the Picturelife API.'
+  spec.homepage      = 'https://github.com/albertzak/picturelife'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'json'
+  spec.add_dependency 'excon'
+  spec.add_dependency 'oauth'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-nc'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-remote'
+  spec.add_development_dependency 'pry-nav'
+end

data/spec/picturelife_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Picturelife do
+  before(:each) do
+    Picturelife.client_id     = 'aaa'
+    Picturelife.client_secret = 'bbb'
+    Picturelife.redirect_uri  = 'ccc'
+
+    Picturelife.stub(:authenticated?).and_return(true)
+
+    Net::HTTP.stub(:get).and_return('{"status":20000}')
+
+    File.stub(:read).and_return('image')
+    File.stub(:extname).and_return('jpg')
+  end
+
+  it 'accepts api keys' do
+    expect { Picturelife.client_id     = 'test' }.not_to raise_error
+    expect { Picturelife.client_secret = 'test' }.not_to raise_error
+    expect { Picturelife.redirect_uri  = 'test' }.not_to raise_error
+  end
+
+  it 'raises error if not configured' do
+    Picturelife.reset_configuration!
+    expect { Picturelife.authorization_uri }. to raise_error(Picturelife::NotConfiguredError)
+  end
+
+  it 'raises error if not authenticated' do
+    Picturelife.stub(:authenticated?).and_return(false)
+    expect { Picturelife::Api.call('/') }. to raise_error(Picturelife::NotAuthenticatedError)
+  end
+
+  it 'escapes redirect uri' do
+    Picturelife.redirect_uri = 'http://localhost:4567/?code=a'
+    expect(Picturelife.redirect_uri).to eq 'http%3A%2F%2Flocalhost%3A4567%2F%3Fcode%3Da'
+  end
+
+  it 'builds valid authorization url' do
+    expect(Picturelife.authorization_uri).to include 'aaa'
+    expect(Picturelife.authorization_uri).to include 'bbb'
+    expect(Picturelife.authorization_uri).to include 'ccc'
+  end
+
+  it 'gets and sets access token' do
+    Net::HTTP.stub(:get).and_return('{"access_token":"token","status":200}')
+
+    Picturelife.access_token_from_code = 'code'
+    expect(Picturelife.access_token).to eq 'token'
+  end
+
+  it 'generated client uuid' do
+    expect(Picturelife.send(:client_uuid)).to be_kind_of(String)
+  end
+
+  it 'caches uuid' do
+    uuid = Proc.new { Picturelife.send(:client_uuid) } 
+    expect(uuid).to eq uuid
+  end
+
+  it 'queries API' do
+    expect(Net::HTTP).to receive(:get) do |uri|
+      expect(uri.scheme).to eq 'https'
+      expect(uri.query).to include 'client_id=aaa'
+      expect(uri.query).to include 'client_secret=bbb'
+      expect(uri.query).to include 'code=code'
+      expect(uri.to_s).to include Picturelife::OAUTH_ENDPOINT
+    end.and_return('{"access_token"=>"ddd","status"=>200}')
+
+    Picturelife.access_token_from_code = 'code'
+  end
+
+  it 'API returns hashrocket that is converted to json' do
+    parsable = hashrocket_to_json('{"access_token"=>"ddd"}')
+    expect { JSON.parse(parsable) }.not_to raise_error
+  end
+
+  it 'stubs missing constant names' do
+    expect { Picturelife::SmartFilters }.not_to raise_error
+  end
+
+  it 'stubs missing methods on missing constants' do
+    expect { Picturelife::SmartFilters.index }.not_to raise_error
+  end
+
+  it 'stubs call correct api method' do
+    expect(Picturelife::Api).to receive(:call).with('smart_filters/index', nil)
+    Picturelife::SmartFilters.index
+  end
+
+  it 'stubs call correct api method with argument' do
+    expect(Picturelife::Api).to receive(:call).with('smart_filters/index', include_system: true)
+    Picturelife::SmartFilters.index(include_system: true)
+  end
+
+  it 'stubs call correct api method with multiple args' do
+    expect(Picturelife::Api).to receive(:call).with('smart_filters/index', { include_system: true, limit: 10 })
+    Picturelife::SmartFilters.index({ include_system: true, limit: 10 })
+  end
+
+  it 'builds url parameters without args' do
+    url = Picturelife::Api.send(:build_uri, 'smart_filters/index')
+    expect(url).to include('https://api.picturelife.com/smart_filters/index')
+  end
+
+  it 'builds url parameters from args' do
+    url = Picturelife::Api.send(:build_uri, 'smart_filters/index', {limit: 10})
+    expect(url).to include('https://api.picturelife.com/smart_filters/index?limit=10')
+  end
+
+  it 'builds url parameters from multiple args' do
+    url = Picturelife::Api.send(:build_uri, 'smart_filters/index', {limit: 10, include_system: true})
+    expect(url).to include('https://api.picturelife.com/smart_filters/index?limit=10&include_system=true')
+  end
+
+  it 'adds access token to url parameters' do
+    Picturelife.stub(:access_token).and_return('123')
+    url = Picturelife::Api.send(:build_uri, 'smart_filters/index', {limit: 10, include_system: true})
+    expect(url).to eq('https://api.picturelife.com/smart_filters/index?limit=10&include_system=true&access_token=123')
+  end
+
+  it 'needs authentication for calls to api' do
+    Picturelife.stub(:authenticated?).and_return(false)
+    expect { Picturelife::Api.call('index') }.to raise_error(Picturelife::NotAuthenticatedError)
+  end
+
+  it 'needs authentication for calls to ruler' do
+    Picturelife.stub(:authenticated?).and_return(false)
+    expect { Picturelife::Ruler.upload(StringIO.new) }.to raise_error(Picturelife::NotAuthenticatedError)
+  end
+
+  it 'needs authentication for calls to ruler' do
+    Picturelife::Ruler.should_receive(:media_exists).and_return('media_id')
+    expect(Picturelife::Ruler.upload(StringIO.new)).to eq('media_id')
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'pry'
+require 'picturelife'

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: picturelife
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Albert Zak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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: excon
+  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: oauth
+  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: bundler
+  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: rake
+  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
+  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-nc
+  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: guard
+  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: guard-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: pry
+  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: pry-remote
+  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: pry-nav
+  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 gem to access the Picturelife API.
+email:
+- me@albertzak.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/picturelife.rb
+- lib/picturelife/api.rb
+- lib/picturelife/base.rb
+- lib/picturelife/error.rb
+- lib/picturelife/oauth.rb
+- lib/picturelife/ruler.rb
+- lib/picturelife/stub.rb
+- lib/picturelife/util.rb
+- picturelife.gemspec
+- spec/picturelife_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/albertzak/picturelife
+licenses:
+- MIT
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Picturelife API. OAuth. Resumable Uploads.
+test_files:
+- spec/picturelife_spec.rb
+- spec/spec_helper.rb