deathbycaptcha 4.1.5 → 5.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85231874d833eab0bd84ac29b980d0c00bcb308d
+  data.tar.gz: 91e8dec5412a607e32032e6f8b209a969d288ca7
+SHA512:
+  metadata.gz: 2d397c364a4b95457252ddd07bdf9a52e8bc0d298932a591515812074310cb98492278cf8679e49e4c1c5b2b33b2eed9faeaff009347699856130724899f7829
+  data.tar.gz: 9f0e76625b2565b2340866068dc10b9290259d2346ec91f8505ea70234e8ca2df09ec0b41a0d573d064b6c74a8128ebbad8dca21fdc61de91c6a102a4264ba0c

data/.gitignore

@@ -1,4 +1,17 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/credentials.yml
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version
+.ruby-gemset

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+### Comming next
+
+* Review Socket client, check if it's worth keeping a pool of open connections
+* Add more tests
+
+### 5.0.0 - 2015-01-26
+
+* The code has been completely refactored/rewritten
+* Bugs reported until 2014-12-31 fixed
+* Suggestions from community have been taken in consideration
+* We no longer follow the versioninig system of the official clients of
+DeathByCaptcha. We have bumped to version 5.0.0 and will use Semantic Versioning
+from now on.
+
+### 4.x
+
+The code was a port from the official DeathByCaptcha python client.
+
+It didn't have many Ruby conventions, so we decided to abandon it and write a
+new version 5.0.0.

data/Gemfile

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

data/{MIT-LICENSE → LICENSE.txt}

@@ -1,4 +1,6 @@
-Copyright (C) 2011 by Infosimples. http://www.infosimples.com.br/
+Copyright (c) 2015 Rafael Barbolo
+
+MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,94 +1,175 @@
-DeathByCaptcha
-==============
+Developed by [Infosimples](https://infosimples.com), a brazilian company that
+offers [data extraction solutions](https://infosimples.com/en/data-engineering)
+and [Ruby on Rails development](https://infosimples.com/en/software-development).
 
-DeathByCaptcha is a Ruby API for acessing the http://www.deathbycaptcha.com services.
 
-It supports HTTP and socket-based connections, with the latter being recommended for having faster responses and overall better performance.
+# DeathByCaptcha
 
-When using socket connections, make sure that outgoing TCP traffic to <b>api.deathbycaptcha.com</b> to the ports range in <b>8123-8130</b> is not blocked by your firewall.
+DeathByCaptcha is a Ruby API for DeathByCaptcha - http://www.deathbycaptcha.com.
 
-Thread-safety note
-------------------
 
-The API is thread-safe, which means it is perfectly fine to share a client instance between multiple threads.
+## Installation
 
-Installation
-------------
+Add this line to your application's Gemfile:
 
-You can install the latest DeathByCaptcha gem with:
+```ruby
+gem 'deathbycaptcha', '~> 5.0.0'
+```
 
-	gem install deathbycaptcha
+And then execute:
 
-You can add it to your Gemfile:
+    $ bundle
 
-	gem 'deathbycaptcha'
+Or install it yourself as:
 
-Examples
---------
+    $ gem install deathbycaptcha
 
-### Create a client
 
-#### HTTP client
+## Usage
 
-	require 'deathbycaptcha'
+1. **Create a client**
 
-	client = DeathByCaptcha.http_client('myusername', 'mypassword')
+  ```ruby
+  # Create a client (:socket and :http clients are available)
+  #
+  client = DeathByCaptcha.new('myusername', 'mypassword', :socket)
+  ```
 
-#### Socket client
+2. **Solve a captcha**
 
-	require 'deathbycaptcha'
+  There are two methods available: **decode** and **decode!**
+    * **decode** doesn't raise exceptions.
+    * **decode!** may raise a *DeathByCaptcha::Error* if something goes wrong.
 
-	client = DeathByCaptcha.socket_client('myusername', 'mypassword')
+  If the solution is not available, an empty captcha object will be returned.
 
-#### Verbose mode (for debugging purposes)
+  ```ruby
+  captcha = client.decode(url: 'http://bit.ly/1xXZcKo')
+  captcha.text        # Solution of the captcha
+  captcha.id          # Numeric ID of the captcha solved by DeathByCaptcha
+  captcha.is_correct  # true if the solution is correct
+  ```
 
-	client.config.is_verbose = true
+  You can also specify *path*, *file*, *raw* and *raw64* when decoding an image.
 
-#### Decoding captcha
+  ```ruby
+  client.decode(path: 'path/to/my/captcha/file')
 
-##### From URL
+  client.decode(file: File.open('path/to/my/captcha/file', 'rb'))
 
-	response = client.decode 'http://www.phpcaptcha.org/securimage/securimage_show.php'
+  client.decode(raw: File.open('path/to/my/captcha/file', 'rb').read)
 
-	puts "captcha id: #{response['captcha']}, solution: #{response['text']}, is_correct: #{response['is_correct']}}"
+  client.decode(raw64: Base64.encode64(File.open('path/to/my/captcha/file', 'rb').read))
+  ```
 
-##### From file path
+  > Internally, the gem will always convert the image to raw64 (binary base64 encoded).
 
-	response = client.decode 'path/to/my/captcha/file'
+3. **Retrieve a previously solved captcha**
 
-	puts "captcha id: #{response['captcha']}, solution: #{response['text']}, is_correct: #{response['is_correct']}}"
+  ```ruby
+  captcha = client.captcha('130920620') # with 130920620 as the captcha id
+  ```
 
-##### From a file
+4. **Report incorrectly solved captcha for refund**
 
-	file = File.open('path/to/my/captcha/file', 'r')
+  ```ruby
+  captcha = client.report!('130920620') # with 130920620 as the captcha id
+  ```
 
-	response = client.decode file
+  > ***Warning:*** *do not abuse on this method, otherwise you may get banned*
 
-	puts "captcha id: #{response['captcha']}, solution: #{response['text']}, is_correct: #{response['is_correct']}}"
+5. **Retrieve your user information (which has the current credit balance)**
 
-##### From raw content
+  ```ruby
+  user = client.user()
+  user.is_banned  # true if the user is banned
+  user.balance    # Credit balance in US cents
+  user.rate       # Captcha rate, i.e. charges for one solved captcha in US cents
+  user.id         # Numeric ID of your account
+  ```
 
-	raw_content = File.open('path/to/my/captcha/file', 'r').read
+6. **Retrieve DeathByCaptcha server status**
 
-	response = client.decode(raw_content, :is_raw_content => true)
+  ```ruby
+  status = client.status()
+  status.todays_accuracy        # Current accuracy of DeathByCaptcha
+  status.solved_in              # Estimated seconds to solve a captcha right now
+  status.is_service_overloaded  # true if DeathByCaptcha is overloaded/unresponsive
+  ```
 
-	puts "captcha id: #{response['captcha']}, solution: #{response['text']}, is_correct: #{response['is_correct']}}"
+## Notes
 
-#### Get the solution of a captcha
+#### Thread-safety
 
-	puts client.get_captcha('130920620')['text'] # where 130920620 is the captcha id
+The API is thread-safe, which means it is perfectly fine to share a client
+instance between multiple threads.
 
-#### Get user account information
+#### HTTP and Socket clients
 
-	puts client.get_user
+The API supports HTTP and socket-based connections, with the latter being
+recommended for having faster responses and overall better performance. The two
+clients have the same methods/interface.
 
-Maintainers
------------
+When using the socket client, make sure that outgoing TCP traffic to
+**api.dbcapi.me** to the ports in range **8123-8130** is not blocked by your
+firewall.
 
-* Rafael Barbolo Lopes (http://github.com/barbolo)
-* Rafael Ivan Garcia (http://github.com/rafaelivan)
+#### Ruby dependencies
 
-License
--------
+DeathByCaptcha >= 5.0.0 don't require specific dependencies. That saves you
+memmory and avoid conflicts with other gems.
 
-MIT License. Copyright (C) 2011 by Infosimples. http://www.infosimples.com.br
+#### Input image format
+
+Any format you use in the decode method (url, file, path, raw, raw64) will
+always be converted to a raw64, which is a binary base64 encoded string. So, if
+you already have this format available on your side, there's no need to do
+convertions before calling the API.
+
+> Our recomendation is to never convert your image format, unless needed. Let
+> the gem convert internally. It may save you resources (CPU, memmory and IO).
+
+#### Versioning
+
+We no longer follow the versioninig system of the official clients of
+DeathByCaptcha. We have bumped to version 5.0.0 and will use
+[Semantic Versioning](http://semver.org/) from now on.
+
+#### Upgrade from 4.x to 5.x
+
+Any 5.x version is incompatible with any 4.x version. Please, review your code
+before upgrading.
+
+#### Ruby versions
+
+This gem has been tested on the following versions of Ruby:
+
+* MRI 2.2.0
+* MRI 2.1.5
+* MRI 2.0.0
+* MRI 1.9.3
+
+# Maintainers
+
+* [Débora Setton Fernandes](http://github.com/deborasetton)
+* [Rafael Barbolo](http://github.com/barbolo)
+* [Rafael Ivan Garcia](http://github.com/rafaelivan)
+
+
+## Contributing
+
+1. Fork it ( https://github.com/infosimples/deathbycaptcha/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. **Run/add tests (RSpec)**
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+7. Yay. Thanks for contributing :)
+
+All contributors:
+https://github.com/infosimples/deathbycaptcha/graphs/contributors
+
+
+# License
+
+MIT License. Copyright (C) 2011-2015 Infosimples. https://infosimples.com/

data/Rakefile

@@ -1,2 +1,2 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require "bundler/gem_tasks"
+

data/deathbycaptcha.gemspec

@@ -1,24 +1,24 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "deathbycaptcha/version"
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'deathbycaptcha/version'
 
-Gem::Specification.new do |s|
-  s.add_dependency 'rest-client', '~> 1.6.1'
-  s.add_dependency 'json', '>= 1.4.6'
-  
-  s.name        = "deathbycaptcha"
-  s.version     = DeathByCaptcha::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Rafael Barbolo Lopes, Rafael Ivan Garcia"]
-  s.email       = ["tech@infosimples.com.br"]
-  s.homepage    = "http://www.infosimples.com.br/en/open-source/captcha-solving-api/"
-  s.summary     = %q{Ruby API for DeathByCaptcha (Captcha Solver as a Service)}
-  s.description = %q{Ruby API for DeathByCaptcha (Captcha Solver as a Service)}
+Gem::Specification.new do |spec|
+  spec.name          = "deathbycaptcha"
+  spec.version       = DeathByCaptcha::VERSION
+  spec.authors       = ["Débora Setton Fernandes, Rafael Barbolo, Rafael Ivan Garcia"]
+  spec.email         = ["team@infosimples.com.br"]
+  spec.summary       = %q{Ruby API for DeathByCaptcha (Captcha Solver as a Service)}
+  spec.description   = %q{DeathByCaptcha allows you to solve captchas with manual labor}
+  spec.homepage      = "https://github.com/infosimples/deathbycaptcha"
+  spec.license       = "MIT"
 
-  s.rubyforge_project = "deathbycaptcha"
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"]
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+end

data/lib/deathbycaptcha.rb

@@ -1,9 +1,14 @@
-require 'deathbycaptcha/version'
-require 'deathbycaptcha/config'
-require 'deathbycaptcha/errors'
-require 'deathbycaptcha/client'
-require 'deathbycaptcha/http_client'
-require 'deathbycaptcha/socket_client'
+require 'base64'
+require 'json'
+require 'bigdecimal'
+require 'socket'
+require 'net/http'
 
 module DeathByCaptcha
 end
+
+require 'deathbycaptcha/client'
+require 'deathbycaptcha/exceptions'
+require 'deathbycaptcha/models'
+require 'deathbycaptcha/patches'
+require 'deathbycaptcha/version'

data/lib/deathbycaptcha/client.rb

@@ -1,188 +1,202 @@
-require 'logger'
-require 'digest/sha1'
-require 'rest_client'
-
 module DeathByCaptcha
 
+  # Create a DeathByCaptcha API client. This is a shortcut to
+  # DeathByCaptcha::Client.create.
   #
-  # DeathByCaptcha API Client
+  def self.new(*args)
+    DeathByCaptcha::Client.create(*args)
+  end
+
+  # DeathByCaptcha::Client is a common interface inherited by DBC clients like
+  # DeathByCaptcha::Client::HTTP and DeathByCaptcha::Client::Socket.
   #
   class Client
 
-    attr_accessor :config
-
-    def initialize(username, password, extra = {})
-      data = {
-        :is_verbose             => false, # If true, prints messages during execution.
-        :logger_output          => STDOUT, # Logger output path or IO instance.
-        :api_version            => API_VERSION, # API version (used as user-agent with http requests).
-        :software_vendor_id     => 0, # API unique software ID.
-        :max_captcha_file_size  => (64 * 1024), # Maximum CAPTCHA image filesize, currently 64K.
-        :default_timeout        => 60, # Default CAPTCHA timeout.
-        :polls_interval         => 5, # Default decode polling interval.
-        :http_base_url          => 'http://api.dbcapi.me/api', # Base HTTP API url.
-        :http_response_type     => 'application/json', # Preferred HTTP API server's response content type, do not change.
-        :socket_host            => 'api.dbcapi.me', # Socket API server's host.
-        :socket_ports           => (8123..8130).map { |p| p }, # Socket API server's ports range.
-        :username               => username, # DeathByCaptcha username.
-        :password               => password, # DeathByCaptcha user's password not encrypted.
-      }.merge(extra)
-
-      @config = DeathByCaptcha::Config.new(data) # Config instance.
-      @logger = Logger.new(@config.logger_output) # Logger.
-    end
-
-    #
-    # Fetch the user's details -- balance, rate and banned status.
-    #
-    def get_user
-      raise DeathByCaptcha::Errors::NotImplemented
-    end
+    attr_accessor :username, :password, :timeout, :polling
 
+    # Create a DeathByCaptcha API client
     #
-    # Fetch the user's balance (in US cents).
-    #
-    def get_balance
-      raise DeathByCaptcha::Errors::NotImplemented
-    end
-
+    # @param [String] username Username of the DeathByCaptcha account.
+    # @param [String] password Password of the DeathByCaptcha account.
+    # @param [Symbol] connection Connection type (:socket, :http)
+    # @param [Hash]   options  Options hash.
+    # @option options [Integer] :timeout (60) Seconds before giving up.
+    # @option options [Integer] :polling (5) Seconds for polling the solution.
     #
-    # Fetch a CAPTCHA details -- its numeric ID, text and correctness.
+    # @return [DeathByCaptcha::Client] A Socket or HTTP Client instance.
     #
-    def get_captcha(cid)
-      raise DeathByCaptcha::Errors::NotImplemented
+    def self.create(username, password, connection = :socket, options = {})
+      case connection
+      when :socket
+        DeathByCaptcha::Client::Socket.new(username, password, options)
+      when :http
+        DeathByCaptcha::Client::HTTP.new(username, password, options)
+      else
+        raise DeathByCaptcha::InvalidClientConnection
+      end
     end
 
+    # Create a DeathByCaptcha client.
     #
-    # Fetch a CAPTCHA text.
-    #
-    def get_text(cid)
-      raise DeathByCaptcha::Errors::NotImplemented
-    end
-
+    # @param [String] username Username of the DeathByCaptcha account.
+    # @param [String] password Password of the DeathByCaptcha account.
+    # @param [Hash]   options  Options hash.
+    # @option options [Integer] :timeout (60) Seconds before giving up.
+    # @option options [Integer] :polling (5) Seconds for polling the solution.
     #
-    # Report a CAPTCHA as incorrectly solved.
+    # @return [DeathByCaptcha::Client] A Client instance.
     #
-    def report(cid)
-      raise DeathByCaptcha::Errors::NotImplemented
+    def initialize(username, password, options = {})
+      self.username   = username
+      self.password   = password
+      self.timeout    = options[:timeout] || 60
+      self.polling    = options[:polling] || 5
     end
 
+    # Decode the text from an image (i.e. solve a captcha).
     #
-    # Upload a CAPTCHA.
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url    URL of the image to be decoded.
+    # @option options [String]  :path   File path of the image to be decoded.
+    # @option options [File]    :file   File instance with image to be decoded.
+    # @option options [String]  :raw    Binary content of the image to be decoded.
+    # @option options [String]  :raw64  Binary content encoded in base64 of the image to be decoded.
     #
-    # Accepts file names, file objects or urls, and an optional flag telling
-    # whether the CAPTCHA is case-sensitive or not.  Returns CAPTCHA details
-    # on success.
+    # @return [DeathByCaptcha::Captcha] The captcha (with solution) or an empty hash if something goes wrong.
     #
-    def upload(captcha, options = {})
-      raise DeathByCaptcha::Errors::NotImplemented
+    def decode(options = {})
+      decode!(options)
+    rescue DeathByCaptcha::Error
+      DeathByCaptcha::Captcha.new
     end
 
+    # Decode the text from an image (i.e. solve a captcha).
     #
-    # Try to solve a CAPTCHA.
-    #
-    # See Client.upload() for arguments details.
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url    URL of the image to be decoded.
+    # @option options [String]  :path   File path of the image to be decoded.
+    # @option options [File]    :file   File instance with image to be decoded.
+    # @option options [String]  :raw    Binary content of the image to be decoded.
+    # @option options [String]  :raw64  Binary content encoded in base64 of the image to be decoded.
     #
-    # Uploads a CAPTCHA, polls for its status periodically with arbitrary
-    # timeout (in seconds).  Removes unsolved CAPTCHAs.  Returns CAPTCHA
-    # details if (correctly) solved.
+    # @return [DeathByCaptcha::Captcha] The captcha (with solution if an error is not raised).
     #
-    def decode(captcha, options = {})
-      options = {
-        :timeout            => config.default_timeout,
-        :is_case_sensitive  => false,
-        :is_raw_content     => false
-      }.merge(options)
+    def decode!(options = {})
+      deadline = Time.now + self.timeout
 
-      deadline = Time.now + options[:timeout]
-      c = upload(captcha, options)
-      if c
+      raw64 = load_captcha(options)
+      raise DeathByCaptcha::InvalidCaptcha if raw64.to_s.empty?
 
-        while deadline > Time.now and (c['text'].nil? or c['text'].empty?)
-          sleep(config.polls_interval)
-          c = get_captcha(c['captcha'])
-        end
+      _captcha = self.upload(raw64)
+      while _captcha.text.to_s.empty? && deadline > Time.now
+        sleep(self.polling)
+        _captcha = self.captcha(_captcha.id)
+      end
 
-        if c['text']
-          return c if c['is_correct']
-        else
-          remove(c['captcha'])
-        end
+      raise DeathByCaptcha::IncorrectSolution if !_captcha.is_correct
+      raise DeathByCaptcha::Timeout if _captcha.text.to_s.empty?
 
-      end
+      _captcha
     end
 
+    # Retrieve information from an uploaded captcha.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
     #
-    # Protected methods.
+    # @return [DeathByCaptcha::Captcha] The captcha object.
     #
-    protected
+    def captcha(captcha_id)
+      raise NotImplementedError
+    end
 
+    # Report incorrectly solved captcha for refund.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
     #
-    # Return a hash with the user's credentials
+    # @return [DeathByCaptcha::Captcha] The captcha object.
     #
-    def userpwd
-      { :username => config.username, :password => config.password }
+    def report!(captcha_id)
+      raise NotImplementedError
     end
 
+    # Retrieve your user information (which has the current credit balance).
     #
-    # Private methods.
+    # @return [DeathByCaptcha::User] The user object.
     #
-    private
+    def user
+      raise NotImplementedError
+    end
 
+    # Retrieve DeathByCaptcha server status.
     #
-    # Log a command and a message
+    # @return [DeathByCaptcha::ServerStatus] The server status object.
     #
-    def log(cmd, msg = '')
-      if @config.is_verbose
-        @logger.info "#{cmd}: #{msg}"
-      end
+    def status
+      raise NotImplementedError
     end
 
+    # Upload a captcha to DeathByCaptcha.
     #
-    # Return the File instance that corresponds to the captcha
+    # This method will not return the solution. It's only useful if you want to
+    # implement your own "decode" function.
     #
-    # captcha can be:
-    # => a raw file content if is_raw_content is true
-    # => a File if its kind of File
-    # => a url if it's a String and starts with 'http://'
-    # => a filesystem path otherwise
+    # @return [DeathByCaptcha::Captcha] The captcha object (not solved yet).
     #
-    def load_file(captcha, is_raw_content = false, headers = {})
-
-      file = nil
-
-      if is_raw_content
-        # Create a temporary file, write the raw content and return it
-        tmp_file_path = File.join(Dir.tmpdir, "captcha_#{Time.now.to_i}_#{rand}")
-        File.open(tmp_file_path, 'wb') { |f| f.write captcha }
-        file = File.open(tmp_file_path, 'r')
-
-      elsif captcha.kind_of? File
-        # simply return the file
-        file = captcha
+    def upload(raw64)
+      raise NotImplementedError
+    end
 
-      elsif captcha.kind_of? String and captcha.match(/^https?:\/\//i)
-        # Create a temporary file, download the file, write it to tempfile and return it
-        tmp_file_path = File.join(Dir.tmpdir, "captcha_#{Time.now.to_i}_#{rand}")
-        File.open(tmp_file_path, 'wb') { |f| f.write RestClient.get(captcha, headers) }
-        file = File.open(tmp_file_path, 'r')
+    private
 
+    # Load a captcha raw content encoded in base64 from options.
+    #
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url    URL of the image to be decoded.
+    # @option options [String]  :path   File path of the image to be decoded.
+    # @option options [File]    :file   File instance with image to be decoded.
+    # @option options [String]  :raw    Binary content of the image to be decoded.
+    # @option options [String]  :raw64  Binary content encoded in base64 of the image to be decoded.
+    #
+    # @return [String] The binary image base64 encoded.
+    #
+    def load_captcha(options)
+      if options[:raw64]
+        options[:raw64]
+      elsif options[:raw]
+        Base64.encode64(options[:raw])
+      elsif options[:file]
+        Base64.encode64(options[:file].read())
+      elsif options[:path]
+        Base64.encode64(File.open(options[:path], 'rb').read)
+      elsif options[:url]
+        Base64.encode64(open_url(options[:url]))
       else
-        # Return the File opened
-        file = File.open(captcha, 'r')
-
+        ''
       end
+    rescue
+      ''
+    end
+
+    def open_url(url)
+      uri = URI(url)
 
-      if file.nil?
-        raise DeathByCaptcha::Errors::CaptchaEmpty
-      elsif config.max_captcha_file_size <= File.size?(file).to_i
-        raise DeathByCaptcha::Errors::CaptchaOverflow
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
 
-      file
+      res = http.get(uri.request_uri)
 
+      if (redirect = res.header['location'])
+        open_url(redirect)
+      else
+        res.body
+      end
     end
-
   end
-
 end
+
+require 'deathbycaptcha/client/http'
+require 'deathbycaptcha/client/socket'