deathbycaptcha 4.1.5 → 5.0.0

data/lib/deathbycaptcha/client/http.rb

@@ -0,0 +1,135 @@
+module DeathByCaptcha
+
+  # HTTP client for DeathByCaptcha API.
+  #
+  class Client::HTTP < Client
+
+    BASE_URL = 'http://api.dbcapi.me/api'
+
+    # Retrieve information from an uploaded captcha.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object.
+    #
+    def captcha(captcha_id)
+      response = perform("captcha/#{captcha_id}")
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    # Report incorrectly solved captcha for refund.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object.
+    #
+    def report!(captcha_id)
+      response = perform("captcha/#{captcha_id}/report", :post)
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    # Retrieve your user information (which has the current credit balance)
+    #
+    # @return [DeathByCaptcha::User] The user object.
+    #
+    def user
+      response = perform('user')
+      DeathByCaptcha::User.new(response)
+    end
+
+    # Retrieve DeathByCaptcha server status.
+    #
+    # @return [DeathByCaptcha::ServerStatus] The server status object.
+    #
+    def status
+      response = perform('status')
+      DeathByCaptcha::ServerStatus.new(response)
+    end
+
+    # Upload a captcha to DeathByCaptcha.
+    #
+    # This method will not return the solution. It's only useful if you want to
+    # implement your own "decode" function.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object (not solved yet).
+    #
+    def upload(raw64)
+      response = perform('captcha', :post_multipart, captchafile: "base64:#{raw64}")
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    private
+
+    # Perform an HTTP request to the DeathByCaptcha API.
+    #
+    # @param [String] action  API method name.
+    # @param [Symbol] method  HTTP method (:get, :post, :post_multipart).
+    # @param [Hash]   payload Data to be sent through the HTTP request.
+    #
+    # @return [Hash] Response from the DeathByCaptcha API.
+    #
+    def perform(action, method = :get, payload = {})
+      payload.merge!(username: self.username, password: self.password)
+
+      headers = { 'User-Agent' => DeathByCaptcha::API_VERSION }
+
+      if method == :post
+        uri = URI("#{BASE_URL}/#{action}")
+        req = Net::HTTP::Post.new(uri.request_uri, headers)
+        req.set_form_data(payload)
+
+      elsif method == :post_multipart
+        uri = URI("#{BASE_URL}/#{action}")
+        req = Net::HTTP::Post.new(uri.request_uri, headers)
+        boundary, body = prepare_multipart_data(payload)
+        req.content_type = "multipart/form-data; boundary=#{boundary}"
+        req.body = body
+
+      else
+        uri = URI("#{BASE_URL}/#{action}?#{URI.encode_www_form(payload)}")
+        req = Net::HTTP::Get.new(uri.request_uri, headers)
+      end
+
+      res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+        http.request(req)
+      end
+
+      case res
+      when Net::HTTPSuccess, Net::HTTPSeeOther
+        Hash[URI.decode_www_form(res.body)]
+      when Net::HTTPForbidden
+        raise DeathByCaptcha::APIForbidden
+      when Net::HTTPBadRequest
+        raise DeathByCaptcha::APIBadRequest
+      when Net::HTTPRequestEntityTooLarge
+        raise DeathByCaptcha::APICaptchaTooLarge
+      when Net::HTTPServiceUnavailable
+        raise DeathByCaptcha::APIServiceUnavailable
+      else
+        raise DeathByCaptcha::APIResponseError.new(res.body)
+      end
+    end
+
+    # Prepare the multipart data to be sent via a :post_multipart request.
+    #
+    # @param [Hash] payload Data to be prepared via a multipart post.
+    #
+    # @return [String,String] Boundary and body for the multipart post.
+    #
+    def prepare_multipart_data(payload)
+      boundary = "infosimples" + rand(1_000_000).to_s # a random unique string
+
+      content = []
+      payload.each do |param, value|
+        content << '--' + boundary
+        content << "Content-Disposition: form-data; name=\"#{param}\""
+        content << ''
+        content << value
+      end
+      content << '--' + boundary + '--'
+      content << ''
+
+      [boundary, content.join("\r\n")]
+    end
+  end
+end

data/lib/deathbycaptcha/client/socket.rb

@@ -0,0 +1,113 @@
+module DeathByCaptcha
+
+  # Socket client for DeathByCaptcha API.
+  #
+  class Client::Socket < Client
+
+    HOST  = 'api.dbcapi.me'
+    PORTS = (8123..8130).to_a
+
+    # Retrieve information from an uploaded captcha.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object.
+    #
+    def captcha(captcha_id)
+      response = perform('captcha', captcha: captcha_id)
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    # Report incorrectly solved captcha for refund.
+    #
+    # @param [Integer] captcha_id Numeric ID of the captcha.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object.
+    #
+    def report!(captcha_id)
+      response = perform('report', captcha: captcha_id)
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    # Retrieve your user information (which has the current credit balance)
+    #
+    # @return [DeathByCaptcha::User] The user object.
+    #
+    def user
+      response = perform('user')
+      DeathByCaptcha::User.new(response)
+    end
+
+    # Retrieve DeathByCaptcha server status. This method won't use a Socket
+    # connection, it will use an HTTP connection.
+    #
+    # @return [DeathByCaptcha::ServerStatus] The server status object.
+    #
+    def status
+      http_client.status
+    end
+
+    # Upload a captcha to DeathByCaptcha.
+    #
+    # This method will not return the solution. It's only useful if you want to
+    # implement your own "decode" function.
+    #
+    # @return [DeathByCaptcha::Captcha] The captcha object (not solved yet).
+    #
+    def upload(raw64)
+      response = perform('upload', captcha: raw64)
+      DeathByCaptcha::Captcha.new(response)
+    end
+
+    private
+
+    # Perform a Socket communication with the DeathByCaptcha API.
+    #
+    # @param [String] action  API method name.
+    # @param [Hash]   payload Data to be exchanged in the communication.
+    #
+    # @return [Hash] Response from the DeathByCaptcha API.
+    #
+    def perform(action, payload = {})
+      payload.merge!(
+        cmd: action,
+        version: DeathByCaptcha::API_VERSION,
+        username: self.username,
+        password: self.password
+      )
+
+      response = ::Socket.tcp(HOST, PORTS.sample) do |socket|
+        socket.puts payload.to_json
+        socket.read
+      end
+
+      begin
+        response = JSON.parse(response)
+      rescue
+        raise DeathByCaptcha::APIResponseError.new("invalid JSON: #{response}")
+      end
+
+      if !(error = response['error'].to_s).empty?
+        case error
+        when 'not-logged-in', 'invalid-credentials', 'banned', 'insufficient-funds'
+          raise DeathByCaptcha::APIForbidden
+        when 'invalid-captcha'
+          raise DeathByCaptcha::APIBadRequest
+        when 'service-overload'
+          raise DeathByCaptcha::APIServiceUnavailable
+        else
+          raise DeathByCaptcha::APIResponseError.new(error)
+        end
+      end
+
+      response
+    end
+
+    # Return a cached http client for methods that doesn't work with sockets.
+    #
+    def http_client
+      @http_client ||= DeathByCaptcha.new(self.username, self.password, :http)
+    end
+
+  end
+end

data/lib/deathbycaptcha/exceptions.rb

@@ -0,0 +1,62 @@
+module DeathByCaptcha
+
+  # This is the base DeathByCaptcha exception class. Rescue it if you want to
+  # catch any exception that might be raised.
+  #
+  class Error < Exception
+  end
+
+  class InvalidClientConnection < Error
+    def initialize
+      super('You have specified an invalid client connection (valid connections are :socket, :http)')
+    end
+  end
+
+  class InvalidCaptcha < Error
+    def initialize
+      super('The captcha is empty or invalid')
+    end
+  end
+
+  class Timeout < Error
+    def initialize
+      super('The captcha was not solved in the expected time')
+    end
+  end
+
+  class IncorrectSolution < Error
+    def initialize
+      super('CAPTCHA was not solved by DeathByCaptcha. Try again.')
+    end
+  end
+
+  class APIResponseError < Error
+    def initialize(info)
+      super("Invalid API response: #{info}")
+    end
+  end
+
+  class APIForbidden < Error
+    def initialize
+      super('Access denied, please check your credentials and/or balance')
+    end
+  end
+
+  class APIServiceUnavailable < Error
+    def initialize
+      super('CAPTCHA was rejected due to service overload, try again later')
+    end
+  end
+
+  class APIBadRequest < Error
+    def initialize
+      super('CAPTCHA was rejected by the service, check if it\'s a valid image')
+    end
+  end
+
+  class APICaptchaTooLarge < Error
+    def initialize
+      super('CAPTCHA image size is too large')
+    end
+  end
+end

data/lib/deathbycaptcha/models.rb

@@ -0,0 +1,16 @@
+module DeathByCaptcha
+
+  # Base class of a model object returned by DeathByCaptcha API.
+  #
+  class Model
+    def initialize(values = {})
+      values.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to?("#{key}=")
+      end
+    end
+  end
+end
+
+require 'deathbycaptcha/models/captcha'
+require 'deathbycaptcha/models/server_status'
+require 'deathbycaptcha/models/user'

data/lib/deathbycaptcha/models/captcha.rb

@@ -0,0 +1,20 @@
+module DeathByCaptcha
+
+  # Model of a Captcha returned by DeathByCaptcha API.
+  #
+  class Captcha < DeathByCaptcha::Model
+    attr_accessor :captcha, :is_correct, :text
+
+    def id
+      @captcha
+    end
+
+    def is_correct=(value)
+      @is_correct = ['1', true].include?(value)
+    end
+
+    def captcha=(value)
+      @captcha = value.to_i
+    end
+  end
+end

data/lib/deathbycaptcha/models/server_status.rb

@@ -0,0 +1,20 @@
+module DeathByCaptcha
+
+  # Model of a server status returned by DeathByCaptcha API.
+  #
+  class ServerStatus < DeathByCaptcha::Model
+    attr_accessor :todays_accuracy, :solved_in, :is_service_overloaded
+
+    def todays_accuracy=(value)
+      @todays_accuracy = value.to_f
+    end
+
+    def solved_in=(value)
+      @solved_in = value.to_i
+    end
+
+    def is_service_overloaded=(value)
+      @is_service_overloaded = ['1', true].include?(value)
+    end
+  end
+end

data/lib/deathbycaptcha/models/user.rb

@@ -0,0 +1,28 @@
+module DeathByCaptcha
+
+  # Model of a User returned by DeathByCaptcha API.
+  #
+  class User < DeathByCaptcha::Model
+    attr_accessor :is_banned, :balance, :rate, :user
+
+    def id
+      @user
+    end
+
+    def is_banned=(value)
+      @is_banned = ['1', true].include?(value)
+    end
+
+    def balance=(value)
+      @balance = value.to_f
+    end
+
+    def rate=(value)
+      @rate = value.to_f
+    end
+
+    def user=(value)
+      @user = value.to_i
+    end
+  end
+end

data/lib/deathbycaptcha/patches.rb

@@ -0,0 +1,9 @@
+# Patches are added so older versions of Ruby work with this gem
+#
+unless ''.respond_to?(:empty?)
+  class String
+    def empty?
+      self.length == 0
+    end
+  end
+end

data/lib/deathbycaptcha/version.rb

@@ -1,4 +1,4 @@
 module DeathByCaptcha
-  VERSION = "4.1.5"
-  API_VERSION = "DBC/Ruby v4.1.2"
-end
+  VERSION = "5.0.0"
+  API_VERSION = "DBC/Ruby v#{VERSION}"
+end

data/spec/credentials.yml.example

@@ -0,0 +1,3 @@
+username: myusername
+password: mypassword
+captcha_id: 12345 # use any ID of a captcha solved on your account

data/spec/lib/client_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+username    = CREDENTIALS['username']
+password    = CREDENTIALS['password']
+captcha_id  = CREDENTIALS['captcha_id']
+image64     = Base64.encode64(File.open('captchas/1.png', 'rb').read)
+
+describe DeathByCaptcha::Client do
+  describe '.create' do
+    context 'http' do
+      let(:client) { DeathByCaptcha.new(username, password, :http) }
+      it { expect(client).to be_a(DeathByCaptcha::Client::HTTP) }
+    end
+
+    context 'socket' do
+      let(:client) { DeathByCaptcha.new(username, password, :socket) }
+      it { expect(client).to be_a(DeathByCaptcha::Client::Socket) }
+    end
+
+    context 'default' do
+      let(:client) { DeathByCaptcha.new(username, password) }
+      it { expect(client).to be_a(DeathByCaptcha::Client::Socket) }
+    end
+
+    context 'other' do
+      it { expect {
+          DeathByCaptcha.new(username, password, :other)
+        }.to raise_error(DeathByCaptcha::InvalidClientConnection)
+      }
+    end
+  end
+
+  context 'http' do
+    subject(:client) { DeathByCaptcha.new(username, password, :http) }
+
+    describe '#load_captcha' do
+      it { expect(client.send(:load_captcha, url: 'http://bit.ly/1xXZcKo')).to eq(image64) }
+      it { expect(client.send(:load_captcha, path: 'captchas/1.png')).to eq(image64) }
+      it { expect(client.send(:load_captcha, file: File.open('captchas/1.png', 'rb'))).to eq(image64) }
+      it { expect(client.send(:load_captcha, raw: File.open('captchas/1.png', 'rb').read)).to eq(image64) }
+      it { expect(client.send(:load_captcha, raw64: image64)).to eq(image64) }
+      it { expect(client.send(:load_captcha, other: nil)).to eq('') }
+    end
+  end
+end
+
+shared_examples 'a client' do
+  describe '#captcha' do
+    before(:all) { @captcha = @client.captcha(captcha_id) }
+    it { expect(@captcha).to be_a(DeathByCaptcha::Captcha) }
+    it { expect(@captcha.text.size).to be > 0 }
+    it { expect([true, false]).to include(@captcha.is_correct) }
+    it { expect(@captcha.id).to be > 0 }
+    it { expect(@captcha.id).to eq(@captcha.captcha) }
+  end
+
+  describe '#user' do
+    before(:all) { @user = @client.user() }
+    it { expect(@user).to be_a(DeathByCaptcha::User) }
+    it { expect([true, false]).to include(@user.is_banned) }
+    it { expect(@user.balance).to be > 0 }
+    it { expect(@user.rate).to be > 0 }
+    it { expect(@user.id).to eq(@user.user) }
+  end
+
+  describe '#status' do
+    before(:all) { @status = @client.status() }
+    it { expect(@status).to be_a(DeathByCaptcha::ServerStatus) }
+    it { expect(@status.todays_accuracy).to be > 0 }
+    it { expect(@status.solved_in).to be > 0 }
+    it { expect([true, false]).to include(@status.is_service_overloaded) }
+  end
+
+  describe '#decode!' do
+    before(:all) { @captcha = @client.decode!(raw64: image64) }
+    it { expect(@captcha).to be_a(DeathByCaptcha::Captcha) }
+    it { expect(@captcha.text).to eq 'infosimples' }
+    it { expect(@captcha.is_correct).to be true }
+    it { expect(@captcha.id).to be > 0 }
+    it { expect(@captcha.id).to eq(@captcha.captcha) }
+  end
+end
+
+describe DeathByCaptcha::Client::HTTP do
+  it_behaves_like 'a client' do
+    before(:all) { @client = DeathByCaptcha.new(username, password, :http) }
+  end
+end
+
+describe DeathByCaptcha::Client::Socket do
+  it_behaves_like 'a client' do
+    before(:all) { @client = DeathByCaptcha.new(username, password, :socket) }
+  end
+end