xtb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c368d7138b3a90d013565212661d39e0dd339c57c8a4c235eaa30ad786e4601
-  data.tar.gz: c1613af477c8de260af049d7fc1ac42df8ead3d327967ecc2b575c8599cdbe19
+  metadata.gz: 7d9a9468ded9f433834ca0a96a2fafa64f18b39ae8dd11fb71a6ad4b93522477
+  data.tar.gz: '091e39d9c4fc4e36a738f8c2e2bc6d177e13a8cee71cea3d641788f69fecaf4a'
 SHA512:
-  metadata.gz: 98a5f73fb940d41c98f338c14bbb7a11f5b546214d1b9a7249bc3594797f4968216fbc449118a39a7cb5ba5bf8a0837560334521cf758d8eb50cc52ad3678e9a
-  data.tar.gz: '046729d8d9a8efad3203bfef09ce870fbb2086b196343460114232f052b8ef194a5063e56d119324595d7ed53db27f3bd9a3217b0ce161c44ec5efe16728ffba'
+  metadata.gz: b367e84969900e94217dfa3c982989cd02ce5e41c8bbd5928118e2f8409a2a7de433d55b441ce8da1800e0bd97c2dccfdd1bbd064b6e3fdf3ae8fc527bacb379
+  data.tar.gz: 8c30d8723954a1aa85e871d2884457b3675929a384999869e6f2f5a5046c85fc74dd02880bd23eeea24b2d1d0d407a39b5e81ee6713f68df6d143b38621f013d

data/.rubocop.yml

@@ -1,3 +1,5 @@
+require: rubocop-rspec
+
 AllCops:
   TargetRubyVersion: 3.1
 

data/CHANGELOG.md

@@ -1,3 +1,7 @@
 ## 0.1.0
 
 - Initial release
+
+## 0.1.1
+
+- Add support for connection pooling

data/README.md

@@ -6,33 +6,38 @@ This gem allows you to connect to the XTB broker and execute trades, get account
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add xtb
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ gem install xtb
 
 ## Usage
 
 ### Configuration
 
-Before you can connect to the XTB API, you need to configure the connection. 
-You can do this by creating a configuration object and passing it to the client.
+Before you can connect to the XTB API, you need to configure the connection.
     
-```ruby
-
+```shell
+XTB__USER_ID=your_user_id
+XTB__PASSWORD=your_password
 ```
 
 ### Connect to the XTB API
 
 ```ruby
+require 'xtb'
 
+# You're ready to use the API
+Xtb::Http::CurrentUserData.call
 ```
+Note that there is no need to log in first or log out afterwards. The gem handles the connection for you.
+
+### Subscribing to the XTB API streaming commands
 
+🚧 The streaming API is not yet supported.
 
 ## Development
 

data/lib/xtb/config.rb

@@ -3,25 +3,34 @@
 module Xtb
   # Configuration mapping for XTB API.
   class Config
+    DEFAULT_HTTP_HOST = 'xapi.xtb.com'
+    DEFAULT_HTTP_PORT = 5124
+    DEFAULT_WEB_SOCKET_HOST = 'ws.xtb.com'
+    DEFAULT_WEB_SOCKET_PORT = 5125
+    DEFAULT_WEB_SOCKET_PATH = 'demo'
+    DEFAULT_CONNECTION_POOL_SIZE = 5
+    MAX_CONNECTION_POOL_SIZE = 50
+    MIN_REQUEST_INTERVAL = 200 # in milliseconds
+
     class << self
       def https_host
-        ENV.fetch('XTB__HTTPS_HOST', 'xapi.xtb.com')
+        ENV.fetch('XTB__HTTPS_HOST', DEFAULT_HTTP_HOST)
       end
 
       def https_port
-        ENV.fetch('XTB__HTTPS_PORT', 5124).to_i
+        ENV.fetch('XTB__HTTPS_PORT', DEFAULT_HTTP_PORT).to_i
       end
 
       def wss_host
-        ENV.fetch('XTB__WSS_HOST', 'ws.xtb.com')
+        ENV.fetch('XTB__WSS_HOST', DEFAULT_WEB_SOCKET_HOST)
       end
 
       def wss_path
-        ENV.fetch('XTB__WSS_PATH', 'demo')
+        ENV.fetch('XTB__WSS_PATH', DEFAULT_WEB_SOCKET_PATH)
       end
 
       def wss_port
-        ENV.fetch('XTB__WSS_PORT', 5125).to_i
+        ENV.fetch('XTB__WSS_PORT', DEFAULT_WEB_SOCKET_PORT).to_i
       end
 
       def user_id
@@ -32,8 +41,20 @@ module Xtb
         ENV.fetch('XTB__PASSWORD') { raise 'XTB__PASSWORD is required' }
       end
 
+      def connection_pool_size
+        size = ENV.fetch('XTB__CONNECTION_POOL_SIZE', DEFAULT_CONNECTION_POOL_SIZE).to_i
+        raise "Max connection pool size is #{MAX_CONNECTION_POOL_SIZE}" if size > MAX_CONNECTION_POOL_SIZE
+
+        size
+      end
+
       def min_request_interval
-        ENV.fetch('XTB__MIN_REQUEST_INTERVAL', 0.2).to_f
+        requests_interval = ENV.fetch('XTB__MIN_REQUEST_INTERVAL', MIN_REQUEST_INTERVAL).to_i
+        if requests_interval < MIN_REQUEST_INTERVAL
+          raise "Minimum request interval must be greater than or equal to #{MIN_REQUEST_INTERVAL}"
+        end
+
+        requests_interval
       end
     end
   end

data/lib/xtb/error.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Xtb
+  # http://developers.xstore.pro/documentation/#error-messages
+  class Error < StandardError; end
+
+  class InvalidPriceError < Error; end
+
+  class InvalidStopLossOrTakeProfitError < Error; end
+
+  class InvalidVolumeError < Error; end
+
+  class LoginDisabledError < Error; end
+
+  class InvalidLoginOrPasswordError < Error; end
+
+  class MarketClosedError < Error; end
+
+  class MismatchedParametersError < Error; end
+
+  class ModificationDeniedError < Error; end
+
+  class NotEnoughMoneyError < Error; end
+
+  class OffQuotesError < Error; end
+
+  class OppositePositionsProhibitedError < Error; end
+
+  class ShortPositionsProhibitedError < Error; end
+
+  class PriceChangedError < Error; end
+
+  class RequestTooFrequentError < Error; end
+
+  class TooManyTradeRequestsError < Error; end
+
+  class TradingOnInstrumentDisabledError < Error; end
+
+  class TradingTimeoutError < Error; end
+
+  class OtherError < Error; end
+
+  class SymbolDoesNotExistForAccountError < Error; end
+
+  class AccountCannotTradeOnSymbolError < Error; end
+
+  class PendingOrderCannotBeClosedError < Error; end
+
+  class CannotCloseOrderError < Error; end
+
+  class NoSuchTransactionError < Error; end
+
+  class UnknownInstrumentSymbolError < Error; end
+
+  class UnknownTransactionTypeError < Error; end
+
+  class NotLoggedInError < Error; end
+
+  class MethodDoesNotExistError < Error; end
+
+  class IncorrectPeriodError < Error; end
+
+  class MissingDataError < Error; end
+
+  class IncorrectCommandFormatError < Error; end
+
+  class SymbolDoesNotExistError < Error; end
+
+  class InvalidTokenError < Error; end
+
+  class AlreadyLoggedInError < Error; end
+
+  class SessionTimedOutError < Error; end
+
+  class InvalidParametersError < Error; end
+
+  class InternalError < Error; end
+
+  class NoAccessError < Error; end
+
+  class ConnectionLimitError < Error; end
+
+  class DataLimitExceededError < Error; end
+
+  class BlacklistedError < Error; end
+
+  class CommandNotAllowedError < Error; end
+end

data/lib/xtb/error_factory.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Xtb
+  # Factory for creating error objects based on error codes.
+  class ErrorFactory
+    ERROR_CODES = {
+      'BE001': { klass: 'InvalidPriceError', description: 'Invalid price' },
+      'BE002': { klass: 'InvalidStopLossOrTakeProfitError', description: 'Invalid StopLoss or TakeProfit' },
+      'BE003': { klass: 'InvalidVolumeError', description: 'Invalid volume' },
+      'BE004': { klass: 'LoginDisabledError', description: 'Login disabled' },
+      'BE005': { klass: 'InvalidLoginOrPasswordError', description: 'Invalid login or password' },
+      'BE006': { klass: 'MarketClosedError', description: 'Market for instrument is closed' },
+      'BE007': { klass: 'MismatchedParametersError', description: 'Mismatched parameters' },
+      'BE008': { klass: 'ModificationDeniedError', description: 'Modification is denied' },
+      'BE009': { klass: 'NotEnoughMoneyError', description: 'Not enough money on account to perform trade' },
+      'BE010': { klass: 'OffQuotesError', description: 'Off quotes' },
+      'BE011': { klass: 'OppositePositionsProhibitedError', description: 'Opposite positions prohibited' },
+      'BE012': { klass: 'ShortPositionsProhibitedError', description: 'Short positions prohibited' },
+      'BE013': { klass: 'PriceChangedError', description: 'Price has changed' },
+      'BE014': { klass: 'RequestTooFrequentError', description: 'Request too frequent' },
+      'BE016': { klass: 'TooManyTradeRequestsError', description: 'Too many trade requests' },
+      'BE018': { klass: 'TradingOnInstrumentDisabledError', description: 'Trading on instrument disabled' },
+      'BE019': { klass: 'TradingTimeoutError', description: 'Trading timeout' },
+      'BE020': { klass: 'OtherError', description: 'Other error' },
+      'BE094': { klass: 'SymbolDoesNotExistForAccountError', description: 'Symbol does not exist for given account' },
+      'BE095': { klass: 'AccountCannotTradeOnSymbolError', description: 'Account cannot trade on given symbol' },
+      'BE096': { klass: 'PendingOrderCannotBeClosedError',
+                 description: 'Pending order cannot be closed. Pending order must be deleted' },
+      'BE097': { klass: 'CannotCloseOrderError', description: 'Cannot close already closed order' },
+      'BE098': { klass: 'NoSuchTransactionError', description: 'No such transaction' },
+      'BE101': { klass: 'UnknownInstrumentSymbolError', description: 'Unknown instrument symbol' },
+      'BE102': { klass: 'UnknownTransactionTypeError', description: 'Unknown transaction type' },
+      'BE103': { klass: 'NotLoggedInError', description: 'User is not logged' },
+      'BE104': { klass: 'MethodDoesNotExistError', description: 'Method does not exist' },
+      'BE105': { klass: 'IncorrectPeriodError', description: 'Incorrect period given' },
+      'BE106': { klass: 'MissingDataError', description: 'Missing data' },
+      'BE110': { klass: 'IncorrectCommandFormatError', description: 'Incorrect command format' },
+      'BE115': { klass: 'SymbolDoesNotExistError', description: 'Symbol does not exist' },
+      'BE116': { klass: 'SymbolDoesNotExistError', description: 'Symbol does not exist' },
+      'BE117': { klass: 'InvalidTokenError', description: 'Invalid token' },
+      'BE118': { klass: 'AlreadyLoggedInError', description: 'User already logged' },
+      'BE200': { klass: 'SessionTimedOutError', description: 'Session timed out' },
+      'EX000': { klass: 'InvalidParametersError', description: 'Invalid parameters' },
+      'EX001': { klass: 'InternalError', description: 'Internal error, in case of such error, please contact support' },
+      'EX003': { klass: 'InternalError', description: 'Internal error, request timed out' },
+      'EX004': { klass: 'InvalidVolumeError',
+                 description: 'Login credentials are incorrect or this login is not allowed to use an application \
+                  with this appId' },
+      'EX005': { klass: 'InvalidVolumeError', description: 'Internal error' },
+      'EX006': { klass: 'NoAccessError', description: 'No access' },
+      'EX007': { klass: 'InvalidVolumeError',
+                 description: 'Invalid login or password. This login/password is disabled for 10 minutes' },
+      'EX008': { klass: 'ConnectionLimitError', description: 'You have reached the connection limit' },
+      'EX009': { klass: 'DataLimitExceededError', description: 'Data limit potentially exceeded' },
+      'EX010': { klass: 'BlacklistedError', description: 'Your login is on the black list' },
+      'EX011': { klass: 'CommandNotAllowedError', description: 'You are not allowed to execute this command' }
+    }.freeze
+
+    ERROR_CODE_DUPLICATES = {
+      'BE016': ['BE017'],
+      'BE020': ('BE021'..'BE037').to_a + ['BE099'],
+      'BE115': ['BE116'],
+      'EX001': %w[BE000 EX002]
+    }.freeze
+
+    # Create an error object based on the error code. The API specifies multiple error codes can be
+    # matched to the same error, so a list of duplicates is provided, plus a mapping for codes
+    # matching 'SExxx' to 'EX001'.
+    # @param error_code [String]
+    # @param error_description [String] (optional)
+    # @return [Xtb::Error]
+    def self.create(error_code, error_description = '')
+      error_code = error_code.to_sym
+      mapped_code = ERROR_CODES.keys.include?(error_code) ? error_code : error_code_for_duplicate(error_code)
+      error = ERROR_CODES.fetch(mapped_code, nil)
+      return default_error(error_code, error_description) if error.nil?
+
+      error_description = error_description.empty? ? error[:description] : error_description
+      message = "(#{error_code}) #{error_description}"
+      Xtb.const_get(error[:klass]).new(message)
+    end
+
+    def self.default_error(error_code, error_description)
+      Xtb::Error.new("(#{error_code}) #{error_description}")
+    end
+
+    def self.error_code_for_duplicate(error_code_duplicate)
+      code = nil
+
+      if error_code_duplicate.start_with?('SE')
+        code = :EX001
+      else
+        ERROR_CODE_DUPLICATES.each do |error_code, duplicates|
+          code = error_code if duplicates.include?(error_code_duplicate)
+        end
+      end
+
+      code
+    end
+  end
+end

data/lib/xtb/http/all_symbols.rb

@@ -5,7 +5,7 @@ module Xtb
     # http://developers.xstore.pro/documentation/2.5.0#getAllSymbols
     class AllSymbols < Command
       def call
-        super.map { |symbol| Xtb::SymbolRecord.new(**symbol) }
+        super.return_data.map { |symbol| Xtb::SymbolRecord.new(**symbol) }
       end
 
       private

data/lib/xtb/http/calendar.rb

@@ -17,7 +17,7 @@ module Xtb
       end
 
       def call
-        super.map { |record| CalendarRecord.new(**record) }
+        super.return_data.map { |record| CalendarRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/chart_last_request.rb

@@ -14,10 +14,12 @@ module Xtb
         @period = period
         @start = start
         @symbol = symbol
+
+        super()
       end
 
       def call
-        digits, rate_infos = super.values_at(:digits, :rate_infos)
+        digits, rate_infos = super.return_data.values_at(:digits, :rate_infos)
         rate_infos = rate_infos.map { |record| RateInfoRecord.new(**record) }
         ChartLastRequestResponse.new(digits:, rate_infos:)
       end

data/lib/xtb/http/chart_range_request.rb

@@ -18,10 +18,12 @@ module Xtb
         @start_time = start_time
         @symbol = symbol
         @ticks = ticks
+
+        super()
       end
 
       def call
-        digits, rate_infos = super.values_at(:digits, :rate_infos)
+        digits, rate_infos = super.return_data.values_at(:digits, :rate_infos)
         rate_infos = rate_infos.map { |record| RateInfoRecord.new(**record) }
         ChartLastRequestResponse.new(digits:, rate_infos:)
       end

data/lib/xtb/http/client.rb

@@ -1,39 +1,69 @@
 # frozen_string_literal: true
 
-require_relative 'ssl_client'
-require_relative '../errors'
+require 'connection_pool'
+
+require_relative '../error'
+require_relative '../config'
 require_relative '../request_queue'
 
 module Xtb
   module Http
+    # Client for XTB API.
     class Client
       include RequestQueue
 
-      class << self
-        def post(payload)
+      def initialize
+        @ssl_socket = new_ssl_socket
+      end
+
+      # Sends a request to the broker server. It utilizes a connection pool to manage connections.
+      def self.post
+        connection_pool.with do |connection|
           with_request_queue do
-            Xtb::Http::SslClient.request(payload)
+            yield connection
           end
-          # rescue NotLoggedInError => e
-          #   return if command == :logout
-          #
-          #   Rails.logger.debug(e)
-          #
-          #   BrokerClients::Xtb::Login.call
-          #   retry
-          # rescue AlreadyLoggedInError => _e
-          #   # noop
         end
+      end
+
+      def request(payload)
+        ssl_socket.puts(payload)
+        response
+      end
+
+      def stream_session_id
+        @stream_session_id ||= BrokerClients::Xtb::Login.call.stream_session_id
+      end
 
-        def stream_session_id
-          @stream_session_id ||= BrokerClients::Xtb::Login.call.stream_session_id
+      private
+
+      attr_reader :ssl_socket
+
+      def self.connection_pool
+        @connection_pool ||= ConnectionPool.new(size: Config.connection_pool_size, timeout: 30) do
+          connection = new
+          Xtb::Http::Login.call(connection:)
+
+          connection
         end
+      end
 
-        private
+      def response
+        buffer = []
 
-        def ssl_client
-          @ssl_client ||= Xtb::Http::SslClient.new
+        while (line = ssl_socket.gets)
+          break if line.strip.empty?
+
+          buffer << line
         end
+
+        buffer.join.strip
+      end
+
+      def new_ssl_socket
+        OpenSSL::SSL::SSLSocket.open(Config.https_host, Config.https_port).tap do |socket|
+          socket.hostname = Config.https_host
+          socket.sync_close = true
+        end.connect
       end
     end
   end

data/lib/xtb/http/command.rb

@@ -2,7 +2,8 @@
 
 require 'json'
 require 'active_support/inflector'
-require_relative '../errors'
+require_relative '../error'
+require_relative '../error_factory'
 
 module Xtb
   module Http
@@ -35,14 +36,20 @@ module Xtb
           @response = parse
         end
 
-        def success?
+        def status
           response[:status]
         end
 
+        alias_method :success?, :status
+
         def return_data
           response[:return_data]
         end
 
+        def stream_session_id
+          response[:stream_session_id]
+        end
+
         def error_code
           response[:error_code]
         end
@@ -73,41 +80,42 @@ module Xtb
         end
       end
 
-      def initialize(**args); end
+      def initialize(**args)
+        @args = args
+        @request_data = Request.new(command:, arguments:).to_json
+      end
 
       def self.call(**args)
         new(**args).call
       end
 
       def call
-        request_data = Request.new(command:, arguments:).to_json
-        raw_response = Client.post(request_data)
+        raw_response = if args[:connection]
+                         args.fetch(:connection).request(request_data)
+                       else
+                         Xtb::Http::Client.post do |connection|
+                           connection.request(request_data)
+                         end
+                       end
+
         response = Response.new(command:, raw_response:)
-        raise_error(response.error_code, response.error_description) unless response.success?
 
-        response.return_data
+        raise ErrorFactory.create(response.error_code, response.error_description) unless response.success?
+
+        response
       end
 
       private
 
+      attr_reader :args, :request_data
+
       def command
-        raise NotImplementedError
+        raise NotImplementedError('You must implement the command method')
       end
 
       def arguments
         nil
       end
-
-      def raise_error(error_code, error_description)
-        case error_code
-        when 'BE103'
-          raise NotLoggedInError, "(#{error_code}) #{error_description}"
-        when 'BE118'
-          raise AlreadyLoggedInError, "(#{error_code}) #{error_description}"
-        else
-          raise "(#{error_code}) #{error_description}"
-        end
-      end
     end
   end
 end

data/lib/xtb/http/commission_def.rb

@@ -11,10 +11,12 @@ module Xtb
       def initialize(symbol, volume)
         @symbol = symbol
         @volume = volume
+
+        super()
       end
 
       def call
-        CommissionDefResponse.new(**super)
+        CommissionDefResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/current_user_data.rb

@@ -8,7 +8,7 @@ module Xtb
                                             :leverage_multiplier, :spread_type, :trailing_stop)
 
       def call
-        CurrentUserDataResponse.new(**super)
+        CurrentUserDataResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/login.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Xtb
+  module Http
+    # http://developers.xstore.pro/documentation/2.5.0#login
+    class Login < Command
+      LoginResponse = Data.define(:stream_session_id)
+
+      def call
+        LoginResponse.new(super.stream_session_id)
+      end
+
+      private
+
+      def command = :login
+
+      def arguments
+        {
+          user_id:,
+          password:
+        }
+      end
+
+      def user_id
+        Xtb::Config.user_id
+      end
+
+      def password
+        Xtb::Config.password
+      end
+    end
+  end
+end

data/lib/xtb/http/logout.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Xtb
+  module Http
+    # http://developers.xstore.pro/documentation/2.5.0#logout
+    class Logout < Command
+      private
+
+      def command = :logout
+    end
+  end
+end

data/lib/xtb/http/margin_level.rb

@@ -7,7 +7,7 @@ module Xtb
       MarginLevelResponse = Data.define(:balance, :credit, :currency, :equity, :margin, :margin_free, :margin_level)
 
       def call
-        MarginLevelResponse.new(**super)
+        MarginLevelResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/margin_trade.rb

@@ -11,10 +11,12 @@ module Xtb
       def initialize(symbol, volume)
         @symbol = symbol
         @volume = volume
+
+        super()
       end
 
       def call
-        MarginTradeResponse.new(**super)
+        MarginTradeResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/news.rb

@@ -11,10 +11,12 @@ module Xtb
       def initialize(end_time, start_time)
         @end_time = end_time
         @start_time = start_time
+
+        super()
       end
 
       def call
-        super.map { |record| NewsTopicRecord.new(**record) }
+        super.return_data.map { |record| NewsTopicRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/ping.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Xtb
+  module Http
+    # http://developers.xstore.pro/documentation/2.5.0#ping
+    class Ping < Command
+      private
+
+      def command = :ping
+    end
+  end
+end

data/lib/xtb/http/profit_calculation.rb

@@ -17,10 +17,12 @@ module Xtb
         @open_price = open_price
         @symbol = symbol
         @volume = volume
+
+        super()
       end
 
       def call
-        ProfitCalculationResponse.new(**super)
+        ProfitCalculationResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/server_time.rb

@@ -7,7 +7,7 @@ module Xtb
       ServerTimeResponse = Data.define(:time, :time_string)
 
       def call
-        ServerTimeResponse.new(**super)
+        ServerTimeResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/step_rules.rb

@@ -7,7 +7,7 @@ module Xtb
       StepRecord = Data.define(:from_value, :step)
 
       def call
-        super.map { |record| StepRecord.new(**record) }
+        super.return_data.map { |record| StepRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/symbol.rb

@@ -7,10 +7,12 @@ module Xtb
       # @param symbol [String|Symbol]
       def initialize(symbol)
         @symbol = symbol
+
+        super()
       end
 
       def call
-        Xtb::SymbolRecord.new(**super)
+        Xtb::SymbolRecord.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/tick_prices.rb

@@ -11,10 +11,12 @@ module Xtb
         @level = level
         @symbols = symbols
         @timestamp = timestamp
+
+        super()
       end
 
       def call
-        super[:quotations].map { |record| TickRecord.new(**record) }
+        super.return_data[:quotations].map { |record| TickRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/trade_records.rb

@@ -7,10 +7,12 @@ module Xtb
       # @param orders [Array<Integer>] list of order ids
       def initialize(orders)
         @orders = orders
+
+        super()
       end
 
       def call
-        super.map { |record| Xtb::TradeRecord.new(**record) }
+        super.return_data.map { |record| Xtb::TradeRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/trade_transaction.rb

@@ -6,7 +6,7 @@ module Xtb
     class TradeTransaction < Command
       TradeTransactionResponse = Data.define(:order)
 
-      # @param cmd [Symbol]
+      # @param cmd [Symbol] One of :buy, :sell, :buy_limit, :sell_limit, :buy_stop, :sell_stop, :balance, or :credit
       # @param custom_comment [String]
       # @param expiration [Integer]
       # @param offset [Integer]
@@ -15,7 +15,7 @@ module Xtb
       # @param stop_loss [Float]
       # @param symbol [String]
       # @param take_profit [Float]
-      # @param type [Symbol]
+      # @param type [Symbol] One of :open, :pending, :close, :modify, or :delete
       # @param volume [Float]
       def initialize(cmd:, custom_comment:, expiration:, offset:, order:, price:, stop_loss:, symbol:, take_profit:,
                      type:, volume:)
@@ -30,10 +30,12 @@ module Xtb
         @take_profit = take_profit
         @type = type
         @volume = volume
+
+        super()
       end
 
       def call
-        TradeTransactionResponse.new(**super)
+        TradeTransactionResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http/trades.rb

@@ -7,10 +7,12 @@ module Xtb
       # @param opened_only [Boolean]
       def initialize(opened_only)
         @opened_only = opened_only
+
+        super()
       end
 
       def call
-        super.map { |record| Xtb::TradeRecord.new(**record) }
+        super.return_data.map { |record| Xtb::TradeRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/trades_history.rb

@@ -9,10 +9,12 @@ module Xtb
       def initialize(end_time, start_time)
         @end_time = end_time
         @start_time = start_time
+
+        super()
       end
 
       def call
-        super.map { |record| Xtb::TradeRecord.new(**record) }
+        super.return_data.map { |record| Xtb::TradeRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/trading_hours.rb

@@ -4,10 +4,10 @@ module Xtb
   module Http
     # http://developers.xstore.pro/documentation/2.5.0#getTradingHours
     class TradingHours < Command
-      TradingHoursRecord = Data.define(:quotes, :symbol, :trading) do
-        # Represents both quotes and trading times records.
-        TimesRecord = Data.define(:day, :from_t, :to_t)
+      # Represents both quotes and trading times records.
+      TimesRecord = Data.define(:day, :from_t, :to_t)
 
+      TradingHoursRecord = Data.define(:quotes, :symbol, :trading) do
         def initialize(symbol:, quotes: TimesRecord.new, trading: TimesRecord.new)
           super(quotes:, symbol:, trading:)
         end
@@ -16,10 +16,12 @@ module Xtb
       # @param symbols [Array<String|Symbol>]
       def initialize(symbols)
         @symbols = symbols
+
+        super()
       end
 
       def call
-        super.map { |record| TradingHoursRecord.new(**record) }
+        super.return_data.map { |record| TradingHoursRecord.new(**record) }
       end
 
       private

data/lib/xtb/http/version.rb

@@ -7,7 +7,7 @@ module Xtb
       VersionResponse = Data.define(:version)
 
       def call
-        VersionResponse.new(**super)
+        VersionResponse.new(**super.return_data)
       end
 
       private

data/lib/xtb/http.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
 require_relative 'http/client'
+require_relative 'http/command'
 
 # commands
-require_relative 'http/command'
 require_relative 'http/all_symbols'
 require_relative 'http/calendar'
 require_relative 'http/chart_last_request'
 require_relative 'http/chart_range_request'
 require_relative 'http/commission_def'
 require_relative 'http/current_user_data'
+require_relative 'http/login'
+require_relative 'http/logout'
 require_relative 'http/margin_level'
 require_relative 'http/margin_trade'
 require_relative 'http/news'
+require_relative 'http/ping'
 require_relative 'http/profit_calculation'
 require_relative 'http/server_time'
 require_relative 'http/step_rules'
 require_relative 'http/symbol'
 require_relative 'http/tick_prices'
 require_relative 'http/trade_records'
+require_relative 'http/trade_transaction'
 require_relative 'http/trades'
 require_relative 'http/trades_history'
 require_relative 'http/trading_hours'

data/lib/xtb/request_queue.rb

@@ -10,29 +10,28 @@ module Xtb
       base.extend(ClassMethods)
     end
 
-    module ClassMethods
-      private
-
-      def with_request_queue(&block)
-        queue << block
-        queue << wait_proc
-
-        result = queue.pop.call
-        queue.pop.call
+    module ClassMethods # :nodoc:
+      def with_request_queue
+        sleep(time_to_next_request / 1000) unless @last_request_time.nil?
 
-        result
+        yield
+      ensure
+        @last_request_time = Time.now
       end
 
-      def queue
-        @queue ||= Queue.new
+      private
+
+      def time_to_next_request
+        [0, min_request_interval - time_since_last_request].max.to_f
       end
 
-      def wait_proc
-        proc { sleep(min_request_interval) }
+      # @return [Integer] time elapsed since the last request in milliseconds
+      def time_since_last_request
+        (1000 * (@last_request_time - Time.now)).to_i.abs
       end
 
       def min_request_interval
-        Config.min_request_interval
+        @min_request_interval ||= Config.min_request_interval
       end
     end
   end

data/lib/xtb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Xtb
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/xtb/web_socket/client.rb

@@ -2,6 +2,7 @@
 
 module Xtb
   module WebSocket
+    # Client for WebSocket connection.
     class Client
       include RequestQueue
 

data/lib/xtb/web_socket.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Xtb
-  module WebSocket
+  module WebSocket # :nodoc:
   end
 end

data/lib/xtb.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'xtb/version'
+require_relative 'xtb/error'
 require_relative 'xtb/http'
 require_relative 'xtb/web_socket'
 require_relative 'xtb/config'
@@ -14,7 +15,7 @@ module Xtb
     m30: 30,
     h1: 60,
     h4: 240,
-    d1: 1440,
+    d1: 1_440,
     w1: 10_080,
     mn1: 43_200
   }.freeze

metadata

@@ -1,15 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: xtb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
-- jacekmaciag
+- Jacek Maciag
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
-dependencies: []
+date: 2024-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: 'The XTB API (xAPI) client for Ruby provides a simple and easy to use
   interface to interact with XTB API.
 
@@ -28,7 +98,8 @@ files:
 - Rakefile
 - lib/xtb.rb
 - lib/xtb/config.rb
-- lib/xtb/errors.rb
+- lib/xtb/error.rb
+- lib/xtb/error_factory.rb
 - lib/xtb/http.rb
 - lib/xtb/http/all_symbols.rb
 - lib/xtb/http/calendar.rb
@@ -38,13 +109,14 @@ files:
 - lib/xtb/http/command.rb
 - lib/xtb/http/commission_def.rb
 - lib/xtb/http/current_user_data.rb
+- lib/xtb/http/login.rb
+- lib/xtb/http/logout.rb
 - lib/xtb/http/margin_level.rb
 - lib/xtb/http/margin_trade.rb
 - lib/xtb/http/news.rb
+- lib/xtb/http/ping.rb
 - lib/xtb/http/profit_calculation.rb
-- lib/xtb/http/response.rb
 - lib/xtb/http/server_time.rb
-- lib/xtb/http/ssl_client.rb
 - lib/xtb/http/step_rules.rb
 - lib/xtb/http/symbol.rb
 - lib/xtb/http/tick_prices.rb
@@ -58,7 +130,6 @@ files:
 - lib/xtb/version.rb
 - lib/xtb/web_socket.rb
 - lib/xtb/web_socket/client.rb
-- sig/xtb.rbs
 homepage: https://github.com/jacekmaciag/xtb
 licenses:
 - MIT
@@ -66,7 +137,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/jacekmaciag/xtb
   source_code_uri: https://github.com/jacekmaciag/xtb
-  changelog_uri: https://github.com/jacekmaciag/xtb/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/jacekmaciag/xtb/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/xtb/errors.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Xtb
-  class Error < StandardError; end
-
-  class NotLoggedInError < Error; end
-  class AlreadyLoggedInError < Error; end
-end

data/lib/xtb/http/response.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Xtb
-  module Http
-    class Response
-      def initialize(raw_response, command)
-        @response = parse_json(raw_response)
-        @command = command
-      end
-
-      def self.parse(raw_response, command)
-        new(raw_response, command).parse
-      end
-
-      def parse
-        return data if success?
-
-        raise_error
-      end
-
-      private
-
-      attr_reader :response, :command
-
-      def parse_json(raw_response)
-        JSON.parse(raw_response).deep_transform_keys { |key| key.underscore.to_sym }
-      end
-
-      def success?
-        response[:status]
-      end
-
-      def data
-        return response if command == :login
-
-        response[:return_data]
-      end
-
-      def error_code
-        response[:error_code]
-      end
-
-      def error_description
-        response[:error_descr]
-      end
-
-      def error_string
-        "(#{error_code}) #{error_description}"
-      end
-
-      def raise_error
-        case error_code
-        when 'BE103'
-          raise NotLoggedInError, error_string
-        when 'BE118'
-          raise AlreadyLoggedInError, error_string
-        else
-          raise BrokerError, error_string
-        end
-      end
-    end
-  end
-end

data/lib/xtb/http/ssl_client.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'openssl'
-require_relative '../config'
-
-module Xtb
-  module Http
-    class SslClient
-      class << self
-        def request(payload)
-          ssl_socket.connect
-          ssl_socket.puts(payload)
-          next_line
-        end
-
-        private
-
-        def next_line
-          line = ssl_socket.gets.chomp
-          return line unless line.empty?
-
-          next_line
-        end
-
-        def ssl_context
-          @ssl_context ||= OpenSSL::SSL::SSLContext.new
-        end
-
-        def ssl_socket
-          @ssl_socket ||= OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context) do |socket|
-            socket.hostname = Config.https_host
-            socket.sync_close = true
-            socket
-          end
-        end
-
-        def tcp_socket
-          TCPSocket.new(Config.https_host, Config.https_port)
-        end
-      end
-    end
-  end
-end

data/sig/xtb.rbs

@@ -1,4 +0,0 @@
-module Xtb
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end