imgurapi 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bf0890e8455b773f65d61bf4610a1c184ae1efe
+  data.tar.gz: 2def72d0ba0969f465fa2068e804f893656c56d6
+SHA512:
+  metadata.gz: 28772edd6e0ddc0fdf123b422e740b7d0d245c0ff238e60112f2d94b4f59482b2e33a06f27addd3f5779d2af1779bf5fdc087bf65e4b8c05f80ec16537780b7f
+  data.tar.gz: 719bd53a67db00ead9a5db9d7dd239edafdb1238f5ef6e8bccdc5fcea09092f543126ec3ad2f693ae6c3e00669abf26f813219eb7ec69acd07b615c9ba68454d

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Daniel Cruz Horts
+
+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,123 @@
+# Imgur
+
+This gem allows you to interact with Imgur's authenticated API, version 3.
+It doesn't implement all the available endpoints. So far:
+- image upload, find and delete
+- account image count, account details, account image list
+
+## Imgur set-up
+
+In order to upload images to Imgur you are going to need an Imgur application. Using an application is the preferred way, because you get twice the credits (100 per hour) than uploading as an anonymous user.
+Of course, if you already have an Imgur application, you can skip this section.
+
+To create an application visit https://imgur.com/register/api_oauth and fill the form. Pay attention to select these options:
+- Application Type: Browser
+- Access Type: Read & Write
+
+Check your inbox, you will receive an email with your application Client Id and Client Secret. We are going to need them later on.
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'imgurruby'
+```
+
+And then run:
+```bash
+$ bundle install
+```
+
+## Authorize your Ruby application
+
+We now need to grant access to our Imgur user to Imgur the application, so we can upload images in his behalf. Type this and follow the instructions:
+```bash
+$ rake imgur:authorize CLIENT_ID='CLIENT_ID' CLIENT_SECRET='CLIENT_SECRET'
+Visit this URL: http://api.imgur.com/oauth/authorize?oauth_token=xxx
+And after you approved the authorization please enter your verification code: yyy
+
+Authorization was successful. Use these credentials to initialize the library:
+
+access_token: ACCESS_TOKEN
+refresh_token: REFRESH_TOKEN
+```
+
+## Usage and overview
+
+Create a session object to communicate to Imgur.
+```ruby
+imgur_session = Imgur::Session.new(client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET', refresh_token: 'REFRESH_TOKEN')
+```
+
+Your account:
+```ruby
+account = imgur_session.account
+{"id"=>123, "url"=>"my_account", "bio"=>nil, "reputation"=>7, "created"=>1352279501, "pro_expiration"=>false}
+```
+
+How many images you have:
+```ruby
+puts imgur_session.account.image_count
+```
+
+Upload your first image. Argument can be either a String or a File:
+```ruby
+image = imgur_session.image.image.upload('portrait.jpg')
+```
+
+image is now an instance of Imgur::Image, a convenient way to manage all the attributes of your image (at least more convenient than a multilevel dictionary):
+```ruby
+name = nil
+title = nil
+caption = nil
+hash = "xyzzy"
+deletehash = "abcdef"
+datetime = "2012-11-18 16:22:00"
+type = "image/jpeg"
+animated = "false"
+width = 654
+height = 273
+size = 47584
+views = 0
+bandwidth = 0
+link = "http://imgur.com/xyzzy"
+```
+
+Do you need to retrieve a previously uploaded image?
+```ruby
+my_image = imgur_session.image.image('hash_code')
+```
+Granted, another Image object. It will return nil if it could not find an image matching your hash.
+
+Feel free to use it in your Rails views:
+```ruby
+<%= image_tag my_image.link %>
+```
+
+How many images do you have at the moment?
+```ruby
+puts imgur_session.account.image_count
+```
+
+We want to delete some images. Argument can be either a String or an Image:
+```ruby
+imgur_session.image.image_delete(image)
+imgur_session.image.image_delete('xyzzy')
+```
+It will return true if succeeded, false otherwise.
+
+## Available endpoints
+Not all the endpoints available at https://api.imgur.com/ have been implemented.
+Feel free to suggest or pull request your needs.
+
+The API methods have been named following Imgur's endpoints, for easy mental mapping.
+Although I consider this is clearer, in the future it may change to follow the naming conventions of the official Python API.
+
+| Type | API method | Imgur doc URL |
+|---|---|---|
+| Account | account.account | https://api.imgur.com/endpoints/account#account |
+| Account | account.images | https://api.imgur.com/endpoints/account#images |
+| Account | account.image_count | https://api.imgur.com/endpoints/account#image-count |
+| Image | image.image | https://api.imgur.com/endpoints/image#image |
+| Image | image.image_upload | https://api.imgur.com/endpoints/image#image-upload |
+| Image | image.image_delete | https://api.imgur.com/endpoints/image#image-delete |

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+load 'imgur/tasks/tasks.rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/lib/imgur/api/account.rb

@@ -0,0 +1,23 @@
+module Imgur
+  module Api
+    class Account < Base
+
+      # https://api.imgur.com/endpoints/account#account
+      def account
+        Imgur::Account.new communication.call(:get, 'account/me')
+      end
+
+      # https://api.imgur.com/endpoints/account#images
+      def images(page = 0)
+        communication.call(:get, "account/me/images/#{page}").map do |image|
+          Imgur::Image.new image
+        end
+      end
+
+      # https://api.imgur.com/endpoints/account#image-count
+      def image_count
+        communication.call(:get, 'account/me/images/count')
+      end
+    end
+  end
+end

data/lib/imgur/api/base.rb

@@ -0,0 +1,11 @@
+module Imgur
+  module Api
+    Base = Struct.new(:session) do
+
+      def communication
+        Communication.new(session)
+      end
+
+    end
+  end
+end

data/lib/imgur/api/image.rb

@@ -0,0 +1,37 @@
+module Imgur
+  module Api
+    class Image < Base
+
+      # https://api.imgur.com/endpoints/image#image
+      def image(id)
+        raise 'Please provide a valid image identificator' if id.nil? or !id.kind_of? String or id == '' or !!(id =~ /[^\w]/)
+
+        Imgur::Image.new communication.call(:get, "image/#{id}")
+      end
+
+      # https://api.imgur.com/endpoints/image#image-upload
+      def image_upload(local_file)
+        if local_file.kind_of? String
+          file = File.open(local_file, 'rb')
+        elsif local_file.respond_to? :read
+          file = local_file
+        else
+          raise 'Must provide a File or file path'
+        end
+
+        Imgur::Image.new communication.call(:post, 'image', image: Base64.encode64(file.read))
+      end
+
+      # https://api.imgur.com/endpoints/image#image-delete
+      def image_delete(id)
+        if id.kind_of? Imgur::Image
+          id = id.id
+        end
+
+        raise 'Please provide a valid image identificator' if id.nil? or !id.kind_of? String or id == '' or !!(id =~ /[^\w]/)
+
+        communication.call(:delete, "image/#{id}")
+      end
+    end
+  end
+end

data/lib/imgur/communication.rb

@@ -0,0 +1,59 @@
+module Imgur
+  Communication = Struct.new(:session) do
+
+    API_VERSION = 3
+
+    # RESTful network call
+    def call(method, endpoint, params = nil)
+      request do
+        session.connection.send method, "/#{API_VERSION}/#{endpoint}.json", params
+      end
+    end
+
+    private
+
+    # Processes RESTful response according the status code
+    def request(&block)
+      3.times do
+        response = yield
+
+        case response.status
+        when 200, 404
+          return parse_message(response.body)['data']
+        when 401, 500
+          error_message = parse_message response.body
+          raise "Unauthorized: #{error_message['error']['message']}"
+        when 403
+          get_new_and_reset_token
+
+          request &block # and retry the request
+        else
+          puts response.body
+          raise "Response code #{response.status} not recognized"
+        end
+      end
+
+      raise "Retried 3 times but could not get an access_token"
+    end
+
+    def get_new_and_reset_token
+      access_token = parse_message(
+        session.connection.post(
+          '/oauth2/token',
+          session.params.merge(grant_type: 'refresh_token')
+        ).body
+      )['access_token']
+
+      session.access_token = access_token
+    end
+
+    # Parses the response as JSON and returns the resulting hash
+    def parse_message(message)
+      begin
+        JSON.parse(message)
+      rescue => e
+        raise "Failed trying to parse response: #{e}"
+      end
+    end
+  end
+end

data/lib/imgur/extensions/array.rb

@@ -0,0 +1,9 @@
+class Array # :nodoc:
+  def extract_options! # :nodoc:
+    last.is_a?(::Hash) ? pop : {}
+  end unless method_defined?(:extract_options!)
+
+  def to_hash # :nodoc:
+    inject({}) { |hsh, (k,v)| hsh[k] = v  ; hsh }
+  end unless method_defined?(:to_hash)
+end

data/lib/imgur/extensions/hash.rb

@@ -0,0 +1,61 @@
+class Hash # :nodoc:
+  def slice(*keys) #:nodoc:
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end unless method_defined?(:slice)
+
+  def symbolize_keys # :nodoc:
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end unless method_defined?(:symbolize_keys)
+
+  def symbolize_keys! # :nodoc:
+    self.replace(self.symbolize_keys)
+  end unless method_defined?(:symbolize_keys!)
+
+  def symbolize_keys_recursively # :nodoc:
+    hsh = symbolize_keys
+    hsh.each { |k, v| hsh[k] = v.symbolize_keys_recursively if v.kind_of?(Hash) }
+    hsh.each { |k, v| hsh[k] = v.map { |i| i.kind_of?(Hash) ? i.symbolize_keys_recursively : i } if v.kind_of?(Array) }
+    return hsh
+  end unless method_defined?(:symbolize_keys_recursively)
+
+  def stringify_keys # :nodoc:
+    inject({}) do |options, (key, value)|
+      options[(key.to_s rescue key) || key] = value
+      options
+    end
+  end unless method_defined?(:stringify_keys)
+
+  def stringify_keys! # :nodoc:
+    self.replace(self.stringify_keys)
+  end unless method_defined?(:stringify_keys!)
+
+  def stringify_keys_recursively # :nodoc:
+    hsh = stringify_keys
+    hsh.each { |k, v| hsh[k] = v.stringify_keys_recursively if v.kind_of?(Hash) }
+    hsh.each { |k, v| hsh[k] = v.map { |i| i.kind_of?(Hash) ? i.stringify_keys_recursively : i } if v.kind_of?(Array) }
+    return hsh
+  end unless method_defined?(:stringify_keys_recursively)
+
+  def to_struct # :nodoc:
+    struct = Struct.new(*keys).new(*values)
+    # attach methods for any predicate keys, since Struct.new doesn't seem to do that
+    pred_keys = slice(*(keys.select { |key| key.to_s.ends_with?('?') }))
+    pred_keys.each do |key, val|
+      struct.eigenclass.send(:define_method, key.to_sym) { return val }
+    end
+    return struct
+  end unless method_defined?(:to_struct)
+
+  def to_struct_recursively # :nodoc:
+    hsh = dup
+    hsh.each { |k, v| hsh[k] = v.to_struct_recursively if v.kind_of?(Hash) }
+    hsh.each { |k, v| hsh[k] = v.map { |i| i.kind_of?(Hash) ? i.to_struct_recursively : i } if v.kind_of?(Array) }
+    return hsh.to_struct
+  end unless method_defined?(:to_struct_recursively)
+end

data/lib/imgur/extensions/string.rb

@@ -0,0 +1,9 @@
+class String # :nodoc:
+  def starts_with?(prefix) # :nodoc:
+    self[0, prefix.length] == prefix
+  end unless method_defined?(:starts_with?)
+
+  def ends_with?(suffix) # :nodoc:
+    self[-suffix.length, suffix.length] == suffix
+  end unless method_defined?(:ends_with?)
+end

data/lib/imgur/models/account.rb

@@ -0,0 +1,3 @@
+module Imgur
+  class Account < Base; end
+end

data/lib/imgur/models/base.rb

@@ -0,0 +1,12 @@
+module Imgur
+  class Base
+    def initialize(hsh = {})
+      hsh.each do |k, v|
+        singleton_class.class_eval do
+          attr_accessor k
+        end
+        send("#{k}=", v)
+      end
+    end
+  end
+end

data/lib/imgur/models/image.rb

@@ -0,0 +1,19 @@
+module Imgur
+  class Image < Base
+
+    # Provides the download URL in case you know a valid imgur hash and don't want to make a network trip with .find
+    # Just in case you don't need the full Imgur::Image object
+    def url(size = nil)
+      size = case size
+             when :small_square
+               's'
+             when :large_thumbnail
+               'l'
+             end
+
+      splitted_link = link.split('.')
+
+      splitted_link.insert(splitted_link.size - 1, size).join
+    end
+  end
+end

data/lib/imgur/session.rb

@@ -0,0 +1,45 @@
+module Imgur
+  class Session
+    HOST = 'https://api.imgur.com'
+
+    # Creates the session instance that handles all the API calls to Imgur
+    # access_token is optional
+    def initialize(options)
+      required_arguments = %i(client_id client_secret refresh_token)
+      raise ArgumentError if required_arguments & options.keys != required_arguments
+
+      @client_id = options[:client_id]
+      @client_secret = options[:client_secret]
+      @access_token = options[:access_token]
+      @refresh_token = options[:refresh_token]
+    end
+
+    %w(Account Image).each do |clazz|
+      define_method clazz.downcase do
+        Imgur::Api.const_get(clazz).new(self)
+      end
+    end
+
+    def access_token=(access_token)
+      @access_token = access_token
+
+      # Forces to create a new connection with new header
+      @connection = nil
+    end
+
+    def params
+      {
+        refresh_token: @refresh_token,
+        client_id:     @client_id,
+        client_secret: @client_secret
+      }
+    end
+
+    def connection
+      @connection ||= Faraday.new(
+        HOST,
+        headers: {'Authorization' => 'Bearer ' << @access_token}
+      )
+    end
+  end
+end

data/lib/imgur/tasks/railtie.rb

@@ -0,0 +1,10 @@
+module Imgur
+  module Tasks
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load 'imgur/tasks/tasks.rake'
+      end
+    end
+  end
+end
+

data/lib/imgur/tasks/rake.rb

@@ -0,0 +1,36 @@
+module Imgur
+
+  module Rake
+    extend self
+
+    AUTHORIZE_ENDPOINT = '/oauth2/authorize'
+    TOKEN_ENDPOINT = '/oauth2/token'
+
+    def authorize(client_id, client_secret)
+      connection = Faraday.new(HOST)
+
+      puts "\nVisit this URL: #{HOST}#{AUTHORIZE_ENDPOINT}?client_id=#{client_id}&response_type=pin"
+      print 'And after you approved the authorization please enter your verification code: '
+
+      pin = STDIN.gets.strip
+
+      begin
+        response = JSON.parse connection.post(TOKEN_ENDPOINT, pin: pin, client_id: client_id, client_secret: client_secret, grant_type: 'pin').body
+      rescue
+        puts "Authorization failed.\nPlease try again."
+        exit
+      end
+
+      puts <<-MESSAGE
+
+Authorization was successful. Use these credentials to initialize the library:
+
+access_token: #{response['access_token']}
+refresh_secret: #{response['refresh_token']}
+
+        MESSAGE
+    end
+
+  end
+
+end

data/lib/imgur/tasks/tasks.rake

@@ -0,0 +1,14 @@
+require 'imgur' # We need HOST to be available
+require 'imgur/tasks/rake'
+
+namespace :imgur do
+  desc 'Obtain your Imgur tokens'
+  task :authorize do
+    if ENV['CLIENT_ID'].nil? or ENV['CLIENT_SECRET'].nil?
+      puts "USAGE: `rake imgur:authorize CLIENT_ID=your_client_id CLIENT_SECRET=your_client_secret`"
+      exit
+    end
+
+    Imgur::Rake.authorize(ENV['CLIENT_ID'], ENV['CLIENT_SECRET'])
+  end
+end

data/lib/imgur/version.rb

@@ -0,0 +1,5 @@
+module Imgur
+
+  VERSION = '2.0.0'
+
+end

data/lib/imgur.rb

@@ -0,0 +1,20 @@
+# Gem dependencies
+require 'faraday'
+require 'json'
+require 'base64'
+
+# Some nice extensions to base classes
+require 'imgur/extensions/array'
+require 'imgur/extensions/hash'
+require 'imgur/extensions/string'
+
+# This gem real code
+require 'imgur/version'
+require 'imgur/api/base'
+require 'imgur/api/account'
+require 'imgur/api/image'
+require 'imgur/communication'
+require 'imgur/session'
+require 'imgur/models/base'
+require 'imgur/models/account'
+require 'imgur/models/image'

data/spec/imgur/session_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+require 'imgur'
+
+describe Imgur::Session do
+
+  context 'incorrect credentials' do
+    it { expect { Imgur::Session.new }.to raise_error }
+    it { expect { Imgur::Session.new(random_key: nil) }.to raise_error }
+    it { expect { Imgur::Session.new(client_id: nil, random_key: nil) }.to raise_error }
+    it { expect { Imgur::Session.new({}) }.to raise_error }
+  end
+
+  context 'correct credentials' do
+    it do
+      expect(
+        Imgur::Session.new(client_id: 'ID', client_secret: 'SECRET', refresh_token: 'TOKEN')
+      ).to be_an_instance_of Imgur::Session
+    end
+  end
+end

data/spec/imgur_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'imgur'
+
+describe Imgur do
+
+  describe 'placeholder classes' do
+
+    it 'should create an Image with the fields provided' do
+      image = Imgur::Image.new
+      image.should be_an_instance_of Imgur::Image
+
+      fields = {:a => 1, :b => 2}
+      image = Imgur::Image.new(fields)
+      image.should be_an_instance_of Imgur::Image
+      image.a.should eq(1)
+      image.b.should eq(2)
+    end
+
+    it 'should create a Link with the fields provided' do
+      links = Imgur::Links.new
+      links.should be_an_instance_of Imgur::Links
+
+      fields = {:a => 1, :b => 2}
+      links = Imgur::Links.new(fields)
+      links.should be_an_instance_of Imgur::Links
+      links.a.should eq(1)
+      links.b.should eq(2)
+    end
+
+  end
+
+  describe 'api' do
+
+    it 'should return a download URL' do
+      imgur_hash = 'random_valid_hash'
+
+      @session.url(:foo).should eq('')
+      @session.url().should eq('')
+      @session.url(imgur_hash).should eq("http://i.imgur.com/#{imgur_hash}.jpg")
+      @session.url(imgur_hash, :random_size).should eq("http://i.imgur.com/#{imgur_hash}.jpg")
+      @session.url(imgur_hash, :small_square).should eq("http://i.imgur.com/#{imgur_hash}s.jpg")
+      @session.url(imgur_hash, :large_thumbnail).should eq("http://i.imgur.com/#{imgur_hash}l.jpg")
+    end
+
+  end
+
+  describe 'communication' do
+
+    before(:all) do
+      credentials = read_credentials_file
+      @session = Imgur::Session.new(credentials)
+    end
+
+    it 'should parse_message' do
+      @session.send(:parse_message, '[]').should eq([])
+      expect { session.send(:parse_message) }.to raise_error
+    end
+
+    it 'should process_message' do
+      Response = Struct.new(:code, :body)
+
+      response = Response.new(200, '[]')
+      @session.send(:process_response, response).should eq([])
+
+      response = Response.new(404, '[]')
+      @session.send(:process_response, response).should eq([])
+
+      response = Response.new(401, '{"error": {"message": "1"}}')
+      expect { @session.send(:process_response, response) }.to raise_error "Unauthorized: 1"
+
+      response = Response.new(500, '{"error": {"message": "1"}}')
+      expect { @session.send(:process_response, response) }.to raise_error "Unauthorized: 1"
+
+      code = rand(999)
+      response = Response.new(code, '')
+      expect { @session.send(:process_response, response) }.to raise_error "Response code #{code} not recognized"
+    end
+
+    it 'should compose_image' do
+      @session.send(:compose_image, {}).should eq(nil)
+      @session.send(:compose_image, {:imags => {:image => {}, :links => {}}}).should eq(nil)
+      @session.send(:compose_image, {:images => {:imae => {}, :links => {}}}).should eq(nil)
+      @session.send(:compose_image, {:images => {:image => {}, :lins => {}}}).should eq(nil)
+      @session.send(:compose_image, {:images => {}}).should eq(nil)
+
+      from_hash = {:images => {:image => {}, :links => {}}}
+      @session.send(:compose_image, from_hash).should be_an_instance_of Imgur::Image
+      @session.send(:compose_image, from_hash).links.should be_an_instance_of Imgur::Links
+    end
+
+  end
+
+  describe 'image management calls' do
+
+    before(:all) do
+      credentials = read_credentials_file
+      @session = Imgur::Session.new(credentials)
+      @upload_path, @upload_file = my_sample_image
+    end
+
+    it 'should return my account information' do
+      @session.account.should be_an_instance_of Hash
+    end
+
+    it 'should return the number of images stored' do
+      @session.images_count.should > 0
+    end
+
+    it 'should upload the image' do
+      expect { @session.upload('') }.to raise_error
+      expect { @session.upload(:not_the_expected_object) }.to raise_error
+
+      @@image_by_path = @session.upload(@upload_path) #FIXME I know this is horrible, but I need to share the same image between tests http://brentlavelle.wordpress.com/2011/04/04/rspec-and-instance-variables/
+      @@image_by_path.should be_an_instance_of Imgur::Image
+
+      @@image_by_file = @session.upload(@upload_file)
+      @@image_by_file.should be_an_instance_of Imgur::Image
+    end
+
+    it 'should retrieve the image' do
+      expect { @session.find(:not_an_image_hash) }.to raise_error
+      expect { @session.find('r4ndom ha5h') }.to raise_error
+
+      image = @session.find('valid_hash_not_related_to_any_image')
+      image.should be_nil
+
+      image = @session.find(@@image_by_path.hash)
+      image.should be_an_instance_of Imgur::Image
+
+      image.hash.should eq(@@image_by_path.hash)
+    end
+
+    it 'should delete the image' do
+      expect { @session.destroy(:not_an_image_hash) }.to raise_error
+      expect { @session.destroy('r4ndom ha5h') }.to raise_error
+
+      @session.destroy('valid_hash_not_related_to_any_image').should be_false
+
+      @session.destroy(@@image_by_path).should be_true #deletes first image
+
+      @session.destroy(@@image_by_file.hash).should be_true #deletes second image
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+module EverythingAsExpected
+
+  def read_credentials_file
+    unless File.exist? 'credentials.json'
+      raise "Please add a credentials.json file to the project directory containing your Imgur app_key, app_secret, access_token and access_token_secret. See credentials.json.example to get started."
+    end
+    
+    credentials_file_contents = File.open('credentials.json', 'r').read
+    credentials = JSON.parse(credentials_file_contents)
+    if credentials.keys.count != 4 and credentials.keys & [:app_key, :app_secret, :access_token, :access_token_secret] != [:app_key, :app_secret, :access_token, :access_token_secret]
+      raise "Your credentials.json file does contain all the required information. See credentials.json.example for more help."
+    end
+    
+    credentials.symbolize_keys
+  end
+
+  def my_sample_image
+    unless File.exist? 'sample.jpg'
+      raise "Please add a sample.jpg file to the project directory to test upload and download. Recommended size: under 30kB"
+    end
+    
+    ['sample.jpg', File.open('sample.jpg', 'r')]
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include(EverythingAsExpected)
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: imgurapi
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Daniel Cruz Horts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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: 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-byebug
+  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: An interface to the Imgur authenticated API
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/imgur.rb
+- lib/imgur/api/account.rb
+- lib/imgur/api/base.rb
+- lib/imgur/api/image.rb
+- lib/imgur/communication.rb
+- lib/imgur/extensions/array.rb
+- lib/imgur/extensions/hash.rb
+- lib/imgur/extensions/string.rb
+- lib/imgur/models/account.rb
+- lib/imgur/models/base.rb
+- lib/imgur/models/image.rb
+- lib/imgur/session.rb
+- lib/imgur/tasks/railtie.rb
+- lib/imgur/tasks/rake.rb
+- lib/imgur/tasks/tasks.rake
+- lib/imgur/version.rb
+- spec/imgur/session_spec.rb
+- spec/imgur_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dncrht/imgur
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Imgur authenticated API
+test_files:
+- spec/imgur/session_spec.rb
+- spec/imgur_spec.rb
+- spec/spec_helper.rb
+has_rdoc: