ig_markets 0.3 → 0.4

data/lib/ig_markets/cli/positions_command.rb

@@ -1,20 +1,111 @@
 module IGMarkets
   module CLI
     # Implements the `ig_markets positions` command.
-    class Main
-      desc 'positions', 'Prints open positions'
+    class Positions < Thor
+      desc 'list', 'Prints open positions'
 
-      def positions
-        begin_session do
+      def list
+        Main.begin_session(options) do |dealing_platform|
           dealing_platform.positions.all.each do |position|
-            print <<-END
-#{position.deal_id}: \
-#{position.formatted_size} of #{position.market.epic} at #{position.level}, \
-profit/loss: #{Format.currency position.profit_loss, position.currency}
-END
+            Output.print_position position
           end
         end
       end
+
+      default_task :list
+
+      desc 'create', 'Creates a new position'
+
+      option :currency_code, required: true, desc: 'The 3 character currency code, must be one of the instrument\'s ' \
+                                                   'currencies'
+      option :direction, required: true, desc: 'The trade direction, must be \'buy\' or \'sell\''
+      option :epic, required: true, desc: 'The EPIC of the market to trade'
+      option :expiry, desc: 'The expiry date of the instrument (if applicable), format: yyyy-mm-dd'
+      option :force_open, type: :boolean, default: false, desc: 'Whether a force open is required'
+      option :guaranteed_stop, type: :boolean, default: false, desc: 'Whether a guaranteed stop is required'
+      option :level, type: :numeric, desc: 'Required if and only if --order-type is \'limit\' or \'quote\''
+      option :limit_distance, type: :numeric, desc: 'The distance away in pips to place the limit, if set then ' \
+                                                    '--limit-level must not be used'
+      option :limit_level, type: :numeric, desc: 'The limit level, if set then --limit-distance must not be used'
+      option :order_type, default: 'market', desc: 'The order type, must be \'limit\', \'market\' or \'quote\''
+      option :quote_id, desc: 'The Lightstreamer quote ID, required when using --order-type=quote'
+      option :size, type: :numeric, required: true, desc: 'The size of the position'
+      option :stop_distance, type: :numeric, desc: 'The distance away in pips to place the stop, if set then ' \
+                                                   '--stop-level must not be used'
+      option :stop_level, type: :numeric, desc: 'The stop level, if set then --stop-distance must not be used'
+      option :time_in_force, desc: 'The order fill strategy, either \'execute_and_eliminate\' or \'fill_or_kill\''
+      option :trailing_stop, type: :boolean, desc: 'Whether to use a trailing stop, defaults to false'
+      option :trailing_stop_increment, type: :numeric, desc: 'The increment step in pips for the trailing stop, ' \
+                                                             'required when --trailing-stop is specified'
+
+      def create
+        Main.begin_session(options) do |dealing_platform|
+          deal_reference = dealing_platform.positions.create position_attributes
+
+          puts "Deal reference: #{deal_reference}"
+
+          Output.print_deal_confirmation dealing_platform.deal_confirmation(deal_reference)
+        end
+      end
+
+      desc 'update <DEAL-ID>', 'Updates attributes of an existing position'
+
+      option :limit_level, type: :numeric, desc: 'The limit level'
+      option :stop_level, type: :numeric, desc: 'The stop level'
+      option :trailing_stop, type: :boolean, desc: 'Whether to use a trailing stop, defaults to false'
+      option :trailing_stop_distance, type: :numeric, desc: 'The distance away in pips to place the trailing stop'
+      option :trailing_stop_increment, type: :numeric, desc: 'The increment step in pips for the trailing stop'
+
+      def update(deal_id)
+        with_position(deal_id) do |position|
+          position.update position_attributes
+        end
+      end
+
+      desc 'close <DEAL-ID>', 'Closes or partially closes a position'
+
+      option :level, type: :numeric, desc: 'Required if and only if --order-type is \'limit\' or \'quote\''
+      option :order_type, default: 'market', desc: 'The order type, must be \'limit\', \'market\' or \'quote\''
+      option :quote_id, desc: 'The Lightstreamer quote ID, required when using --order-type=quote'
+      option :size, type: :numeric, desc: 'The size of the position to close, if not specified then the entire ' \
+                                          'position will be closed'
+      option :time_in_force, desc: 'The order fill strategy, either \'execute_and_eliminate\' or \'fill_or_kill\''
+
+      def close(deal_id)
+        with_position(deal_id) do |position|
+          position.close position_attributes
+        end
+      end
+
+      private
+
+      def position_attributes
+        attributes = options.each_with_object({}) do |(key, value), new_hash|
+          next unless [:currency_code, :direction, :epic, :expiry, :force_open, :guaranteed_stop, :level,
+                       :limit_distance, :limit_level, :order_type, :quote_id, :size, :stop_distance, :stop_level,
+                       :time_in_force, :trailing_stop, :trailing_stop_increment].include? key.to_sym
+
+          new_hash[key.to_sym] = value
+        end
+
+        Main.parse_date_time attributes, :expiry, Date, '%F', 'yyyy-mm-dd'
+
+        attributes
+      end
+
+      def with_position(deal_id)
+        Main.begin_session(options) do |dealing_platform|
+          position = dealing_platform.positions[deal_id]
+
+          raise 'no position with the specified ID' unless position
+
+          deal_reference = yield position
+
+          puts "Deal reference: #{deal_reference}"
+
+          Output.print_deal_confirmation dealing_platform.deal_confirmation(deal_reference)
+        end
+      end
     end
   end
 end

data/lib/ig_markets/cli/search_command.rb

@@ -2,29 +2,15 @@ module IGMarkets
   module CLI
     # Implements the `ig_markets search` command.
     class Main < Thor
-      desc 'search', 'Searches markets based on a query string'
+      desc 'search <QUERY>', 'Searches markets based on the specified query string'
 
-      option :query, aliases: '-q', required: true, desc: 'The search query'
-
-      def search
-        begin_session do
-          dealing_platform.markets.search(options[:query]).each do |market|
-            print_market_overview market
+      def search(query)
+        self.class.begin_session(options) do |dealing_platform|
+          dealing_platform.markets.search(query).each do |market_overview|
+            Output.print_market_overview market_overview
           end
         end
       end
-
-      private
-
-      def print_market_overview(market)
-        print <<-END
-#{market.epic}: \
-#{market.instrument_name}, \
-type: #{market.instrument_type}, \
-bid: #{market.bid} \
-offer: #{market.offer}
-END
-      end
     end
   end
 end

data/lib/ig_markets/cli/sentiment_command.rb

@@ -2,34 +2,23 @@ module IGMarkets
   module CLI
     # Implements the `ig_markets sentiment` command.
     class Main
-      desc 'sentiment', 'Prints sentiment for the specified market'
+      desc 'sentiment <MARKET>', 'Prints sentiment for the specified market'
 
-      option :market, aliases: '-m', required: true, desc: 'The name of the market to print sentiment for'
-      option :related, aliases: '-r', type: :boolean, desc: 'Whether to print sentiment for related markets as well'
+      option :related, type: :boolean, desc: 'Whether to print sentiment for related markets as well'
 
-      def sentiment
-        begin_session do
-          result = dealing_platform.client_sentiment[options[:market]]
+      def sentiment(market)
+        self.class.begin_session(options) do |dealing_platform|
+          client_sentiment = dealing_platform.client_sentiment[market]
 
-          print_sentiment result
+          Output.print_client_sentiment client_sentiment
 
           if options[:related]
-            result.related_sentiments.each do |model|
-              print_sentiment model
+            client_sentiment.related_sentiments.each do |model|
+              Output.print_client_sentiment model
             end
           end
         end
       end
-
-      private
-
-      def print_sentiment(model)
-        print <<-END
-#{model.market_id}: \
-longs: #{model.long_position_percentage}%, \
-shorts: #{model.short_position_percentage}%
-END
-      end
     end
   end
 end

data/lib/ig_markets/cli/sprints_command.rb

@@ -1,27 +1,55 @@
 module IGMarkets
   module CLI
     # Implements the `ig_markets sprints` command.
-    class Main
-      desc 'sprints', 'Prints open sprint market positions'
+    class Sprints < Thor
+      desc 'list', 'Prints open sprint market positions'
 
-      def sprints
-        begin_session do
-          dealing_platform.sprint_market_positions.all.each do |sprint|
-            print_sprint_market_position sprint
+      def list
+        Main.begin_session(options) do |dealing_platform|
+          dealing_platform.sprint_market_positions.all.each do |sprint_market_position|
+            Output.print_sprint_market_position sprint_market_position
           end
         end
       end
 
+      default_task :list
+
+      desc 'create', 'Creates a new sprint market position'
+
+      option :direction, required: true, desc: 'The trade direction, must be \'buy\' or \'sell\')'
+      option :epic, required: true, desc: 'The EPIC of the market to trade'
+      option :expiry_period, required: true, desc: 'The expiry period in seconds, must be 1, 2, 5, 20 or 60'
+      option :size, required: true, desc: 'The position size'
+
+      def create
+        Main.begin_session(options) do |dealing_platform|
+          deal_reference = dealing_platform.sprint_market_positions.create new_sprint_market_position_attributes
+
+          puts "Deal reference: #{deal_reference}"
+
+          Output.print_deal_confirmation dealing_platform.deal_confirmation deal_reference
+        end
+      end
+
       private
 
-      def print_sprint_market_position(sprint)
-        print <<-END
-#{sprint.deal_id}: \
-#{Format.currency sprint.size, sprint.currency} on #{sprint.epic} \
-to be #{{ buy: 'above', sell: 'below' }.fetch(sprint.direction)} #{sprint.strike_level} \
-in #{Format.seconds sprint.seconds_till_expiry}, \
-payout: #{Format.currency sprint.payout_amount, sprint.currency}
-END
+      def new_sprint_market_position_attributes
+        {
+          direction: options[:direction],
+          epic: options[:epic],
+          expiry_period: expiry_period,
+          size: options[:size]
+        }
+      end
+
+      def expiry_period
+        {
+          '1' => :one_minute,
+          '2' => :two_minutes,
+          '5' => :five_minutes,
+          '20' => :twenty_minutes,
+          '60' => :sixty_minutes
+        }.fetch options[:expiry_period]
       end
     end
   end

data/lib/ig_markets/cli/transactions_command.rb

@@ -2,16 +2,17 @@ module IGMarkets
   module CLI
     # Implements the `ig_markets transactions` command.
     class Main
-      desc 'transactions', 'Prints recent transactions'
+      desc 'transactions', 'Prints account transactions'
 
-      option :days, default: 3, type: :numeric, desc: 'The number of days to print recent transactions for'
+      option :days, type: :numeric, required: true, desc: 'The number of days to print account transactions for'
+      option :start_date, desc: 'The start date to print account transactions from, format: yyyy-mm-dd'
 
       def transactions
-        begin_session do
-          transactions = dealing_platform.account.recent_transactions(seconds).sort_by(&:date)
+        self.class.begin_session(options) do |dealing_platform|
+          transactions = gather_transactions(dealing_platform, options[:days], options[:start_date]).sort_by(&:date)
 
           transactions.each do |transaction|
-            print_transaction transaction
+            Output.print_transaction transaction
           end
 
           print_transaction_totals transactions
@@ -20,6 +21,16 @@ module IGMarkets
 
       private
 
+      def gather_transactions(dealing_platform, days, start_date = nil)
+        if start_date
+          start_date = Date.strptime options[:start_date], '%F'
+
+          dealing_platform.account.transactions_in_date_range start_date, start_date + days.to_i
+        else
+          dealing_platform.account.recent_transactions days
+        end
+      end
+
       def transaction_totals(transactions)
         transactions.each_with_object({}) do |transaction, hash|
           profit_loss = transaction.profit_and_loss_amount
@@ -31,19 +42,9 @@ module IGMarkets
         end
       end
 
-      def print_transaction(transaction)
-        print <<-END
-#{transaction.reference}: #{transaction.date.strftime '%Y-%m-%d'}, \
-#{transaction.formatted_transaction_type}, \
-#{"#{transaction.size} of " if transaction.size}\
-#{transaction.instrument_name}, \
-profit/loss: #{Format.currency transaction.profit_and_loss_amount, transaction.currency}
-END
-      end
-
       def print_transaction_totals(transactions)
         transaction_totals(transactions).each do |currency, value|
-          print <<-END
+          puts <<-END
 
 Totals for currency '#{currency}':
   Interest: #{Format.currency value[:interest], currency}

data/lib/ig_markets/cli/watchlists_command.rb

@@ -1,33 +1,72 @@
 module IGMarkets
   module CLI
     # Implements the `ig_markets watchlists` command.
-    class Main
-      desc 'watchlists', 'Prints all watchlists and their markets'
+    class Watchlists < Thor
+      desc 'list', 'Prints all watchlists and their markets'
 
-      def watchlists
-        begin_session do
+      def list
+        Main.begin_session(options) do |dealing_platform|
           dealing_platform.watchlists.all.each do |watchlist|
-            print_watchlist watchlist
+            Output.print_watchlist watchlist
 
-            watchlist.markets.each do |market|
+            watchlist.markets.each do |market_overview|
               print '  - '
-              print_market_overview market
+              Output.print_market_overview market_overview
             end
-            print "\n"
+
+            puts ''
+          end
+        end
+      end
+
+      default_task :list
+
+      desc 'create <NAME> [<EPIC> <EPIC> ...]', 'Creates a new watchlist with the specified name and EPICs'
+
+      def create(name, *epics)
+        Main.begin_session(options) do |dealing_platform|
+          new_watchlist = dealing_platform.watchlists.create(name, *epics)
+
+          puts "New watchlist ID: #{new_watchlist.id}"
+        end
+      end
+
+      desc 'add-markets <WATCHLIST-ID> <EPIC> [<EPIC> ...]', 'Adds the specified markets to a watchlist'
+
+      def add_markets(watchlist_id, *epics)
+        with_watchlist(watchlist_id) do |watchlist|
+          epics.each do |epic|
+            watchlist.add_market epic
           end
         end
       end
 
+      desc 'remove-markets <WATCHLIST-ID> <EPIC> [<EPIC> ...]', 'Removes the specified markets from a watchlist'
+
+      def remove_markets(watchlist_id, *epics)
+        with_watchlist(watchlist_id) do |watchlist|
+          epics.each do |epic|
+            watchlist.remove_market epic
+          end
+        end
+      end
+
+      desc 'delete <WATCHLIST-ID>', 'Deletes the watchlist with the specified ID'
+
+      def delete(watchlist_id)
+        with_watchlist(watchlist_id, &:delete)
+      end
+
       private
 
-      def print_watchlist(watchlist)
-        print <<-END
-#{watchlist.id}: \
-#{watchlist.name}, \
-editable: #{watchlist.editable}, \
-deleteable: #{watchlist.deleteable}, \
-default: #{watchlist.default_system_watchlist}
-END
+      def with_watchlist(watchlist_id)
+        Main.begin_session(options) do |dealing_platform|
+          watchlist = dealing_platform.watchlists[watchlist_id]
+
+          raise 'no watchlist with the specified ID' unless watchlist
+
+          yield watchlist
+        end
       end
     end
   end

data/lib/ig_markets/dealing_platform/account_methods.rb

@@ -29,13 +29,13 @@ module IGMarkets
         @dealing_platform.gather "history/activity/#{from_date}/#{to_date}", :activities, AccountActivity
       end
 
-      # Returns all account activities that occurred in the most recent specified number of seconds.
+      # Returns all account activities that occurred in the most recent specified number of days.
       #
-      # @param [Integer, Float] seconds The number of seconds to return recent activities for.
+      # @param [Fixnum, Float] days The number of days to return recent activities for.
       #
       # @return [Array<AccountActivity>]
-      def recent_activities(seconds)
-        @dealing_platform.gather "history/activity/#{(seconds * 1000.0).to_i}", :activities, AccountActivity
+      def recent_activities(days)
+        @dealing_platform.gather "history/activity/#{milliseconds(days)}", :activities, AccountActivity
       end
 
       # Returns all transactions that occurred in the specified date range.
@@ -56,16 +56,16 @@ module IGMarkets
         @dealing_platform.gather url, :transactions, AccountTransaction
       end
 
-      # Returns all transactions that occurred in the last specified number of seconds.
+      # Returns all transactions that occurred in the last specified number of days.
       #
-      # @param [Integer, Float] seconds The number of seconds to return recent transactions for.
+      # @param [Fixnum, Float] days The number of days to return recent transactions for.
       # @param [:all, :all_deal, :deposit, :withdrawal] transaction_type The type of transactions to return.
       #
       # @return [Array<AccountTransaction>]
-      def recent_transactions(seconds, transaction_type = :all)
+      def recent_transactions(days, transaction_type = :all)
         validate_transaction_type transaction_type
 
-        url = "history/transactions/#{transaction_type.to_s.upcase}/#{(seconds * 1000.0).to_i}"
+        url = "history/transactions/#{transaction_type.to_s.upcase}/#{milliseconds(days)}"
 
         @dealing_platform.gather url, :transactions, AccountTransaction
       end
@@ -87,6 +87,15 @@ module IGMarkets
       def format_date(date)
         date.strftime '%d-%m-%Y'
       end
+
+      # Converts a number of days into a number of milliseconds.
+      #
+      # @param [Fixnum, Float] days The number of days.
+      #
+      # @return [Fixnum]
+      def milliseconds(days)
+        (days.to_f * 24 * 60 * 60 * 1000).to_i
+      end
     end
   end
 end

data/lib/ig_markets/dealing_platform/position_methods.rb

@@ -36,7 +36,7 @@ module IGMarkets
       #                    currencies (see {Instrument#currencies}). Required.
       # @option attributes [:buy, :sell] :direction The position direction. Required.
       # @option attributes [String] :epic The EPIC of the instrument to create a position for. Required.
-      # @option attributes [Time] :expiry The expiry date of the instrument, if it has one. Optional.
+      # @option attributes [Date] :expiry The expiry date of the instrument, if it has one. Optional.
       # @option attributes [Boolean] :force_open Whether a force open is required. Defaults to `false`.
       # @option attributes [Boolean] :guaranteed_stop Whether a guaranteed stop is required. Defaults to `false`.
       # @option attributes [Float] :level Required if and only if `:order_type` is `:limit` or `:quote`.
@@ -68,11 +68,6 @@ module IGMarkets
       # @return [String] The resulting deal reference, use {DealingPlatform#deal_confirmation} to check the result of
       #         the position creation.
       def create(attributes)
-        attributes[:force_open] = false unless attributes.key? :force_open
-        attributes[:guaranteed_stop] = false unless attributes.key? :guaranteed_stop
-        attributes[:order_type] ||= :market
-        attributes[:time_in_force] = :execute_and_eliminate if attributes[:order_type] == :market
-
         model = PositionCreateAttributes.new attributes
         model.validate
 
@@ -89,7 +84,7 @@ module IGMarkets
         attribute :currency_code, String, regex: Regex::CURRENCY
         attribute :direction, Symbol, allowed_values: [:buy, :sell]
         attribute :epic, String, regex: Regex::EPIC
-        attribute :expiry, Time, format: '%d-%b-%y'
+        attribute :expiry, Date, format: '%d-%b-%y'
         attribute :force_open, Boolean
         attribute :guaranteed_stop, Boolean
         attribute :level, Float
@@ -104,10 +99,16 @@ module IGMarkets
         attribute :trailing_stop, Boolean
         attribute :trailing_stop_increment, Fixnum
 
+        def initialize(attributes = {})
+          super
+
+          set_defaults
+        end
+
         # Runs a series of validations on this model's attributes to check whether it is ready to be sent to the IG
         # Markets API.
         def validate
-          validate_required_attributes_present
+          validate_required_attributes
           Position.validate_order_type_constraints attributes
           validate_trailing_stop_constraints
           validate_stop_and_limit_constraints
@@ -116,8 +117,15 @@ module IGMarkets
 
         private
 
+        def set_defaults
+          self.force_open = false if force_open.nil?
+          self.guaranteed_stop = false if guaranteed_stop.nil?
+          self.order_type ||= :market
+          self.time_in_force = :execute_and_eliminate if order_type == :market
+        end
+
         # Checks that all required attributes for position creation are present.
-        def validate_required_attributes_present
+        def validate_required_attributes
           required = [:currency_code, :direction, :epic, :force_open, :guaranteed_stop, :order_type, :size,
                       :time_in_force]
 

data/lib/ig_markets/dealing_platform/working_order_methods.rb

@@ -40,19 +40,15 @@ module IGMarkets
       #                    currencies (see {Instrument#currencies}). Required.
       # @option attributes [:buy, :sell] :direction Order direction. Required.
       # @option attributes [String] :epic The EPIC of the instrument for the order. Required.
-      # @option attributes [Time] :expiry The expiry date of the instrument (if applicable). Optional.
+      # @option attributes [Date] :expiry The expiry date of the instrument (if applicable). Optional.
       # @option attributes [Boolean] :force_open Whether a force open is required. Defaults to `false`.
-      # @option attributes [Time] :good_till_date The date that the working order will live till. Must be set if
-      #                    `:time_in_force` is `:good_till_date`.
+      # @option attributes [Time] :good_till_date The date that the working order will live till. If not specified then
+      #                    the working order will remain until it is cancelled.
       # @option attributes [Boolean] :guaranteed_stop Whether a guaranteed stop is required. Defaults to `false`.
-      # @option attributes [Float] :level The level at which the order will be triggered.
+      # @option attributes [Float] :level The level at which the order will be triggered. Required.
       # @option attributes [Fixnum] :limit_distance The distance away in pips to place the limit. Optional.
       # @option attributes [Float] :size The size of the working order. Required.
       # @option attributes [Fixnum] :stop_distance The distance away in pips to place the stop. Optional.
-      # @option attributes [:good_till_cancelled, :good_till_date] :time_in_force The lifespan of the working order.
-      #                    `:good_till_cancelled` means the working order will live until it is explicitly cancelled.
-      #                    `:good_till_date` means the working order will live until the date specified by
-      #                    `:good_till_date`. Defaults to `:good_till_cancelled`.
       # @option attributes [:limit, :stop] :type `:limit` means the working order is intended to buy at a price lower
       #                    than at present, or to sell at a price higher than at present, i.e. there is an expectation
       #                    of a market reversal at the specified `:level`. `:stop` means the working order is intended
@@ -64,7 +60,7 @@ module IGMarkets
       def create(attributes)
         attributes[:force_open] ||= false
         attributes[:guaranteed_stop] ||= false
-        attributes[:time_in_force] ||= :good_till_cancelled
+        attributes[:time_in_force] = attributes[:good_till_date] ? :good_till_date : :good_till_cancelled
 
         model = build_working_order_model attributes
 
@@ -85,10 +81,6 @@ module IGMarkets
           raise ArgumentError, "#{attribute} attribute must be set" if attributes[attribute].nil?
         end
 
-        if model.time_in_force == :good_till_date && !model.good_till_date.is_a?(Time)
-          raise ArgumentError, 'good_till_date must be set when time_in_force is :good_till_date'
-        end
-
         model
       end
 
@@ -97,9 +89,9 @@ module IGMarkets
         attribute :currency_code, String, regex: Regex::CURRENCY
         attribute :direction, Symbol, allowed_values: [:buy, :sell]
         attribute :epic, String, regex: Regex::EPIC
-        attribute :expiry, Time, format: '%d-%b-%y'
+        attribute :expiry, Date, format: '%d-%b-%y'
         attribute :force_open, Boolean
-        attribute :good_till_date, Time, format: '%F %T'
+        attribute :good_till_date, Time, format: '%Y/%m/%d %R:%S'
         attribute :guaranteed_stop, Boolean
         attribute :level, Float
         attribute :limit_distance, Fixnum

data/lib/ig_markets/model/typecasters.rb

@@ -64,15 +64,24 @@ module IGMarkets
         raise ArgumentError, "#{self}: invalid or missing time format" unless options[:format].is_a? String
 
         if value.is_a?(String) || value.is_a?(Fixnum)
-          begin
-            Time.strptime "#{value}#{options[:time_zone]}", "#{options[:format]}#{'%z' if options[:time_zone]}"
-          rescue ArgumentError
-            raise ArgumentError, "#{self}: failed parsing time '#{value}' with format '#{options[:format]}'"
-          end
+          parse_time_from_string value.to_s, options
         else
           value
         end
       end
+
+      def parse_time_from_string(value, options)
+        format = options[:format]
+        time_zone = options[:time_zone]
+
+        time_zone ||= '+0000' unless format == '%Q'
+
+        begin
+          Time.strptime "#{value}#{time_zone}", "#{format}#{'%z' if time_zone}"
+        rescue ArgumentError
+          raise ArgumentError, "#{self}: failed parsing time '#{value}' with format '#{format}'"
+        end
+      end
     end
   end
 end

data/lib/ig_markets/model.rb

@@ -90,7 +90,8 @@ module IGMarkets
       # @option options [String] :format When `type` is `Date` or `Time` this specifies the format for parsing String
       #                 and `Fixnum` instances assigned to this attribute.
       # @option options [String] :time_zone When `type` is `Time` this specifies the time zone to append to
-      #                 `String` values assigned to this attribute prior to parsing them with `:format`. Optional.
+      #                 `String` values assigned to this attribute prior to parsing them with `:format`. Defaults to
+      #                 `+0000` (UTC) unless `:format` is `%Q`.
       #
       # @macro [attach] attribute
       #   The $1 attribute.

data/lib/ig_markets/password_encryptor.rb

@@ -4,9 +4,18 @@ module IGMarkets
     # @return [OpenSSL::PKey::RSA] The public key used by {#encrypt}, can also be set using {#encoded_public_key=}.
     attr_accessor :public_key
 
-    # @return [String] The timestamp used by {#encrypt}.
+    # @return [String] The time stamp used by {#encrypt}.
     attr_accessor :time_stamp
 
+    # Initializes this password encryptor with the specified encoded public key and timestamp.
+    #
+    # @param [String] encoded_public_key
+    # @param [String] time_stamp
+    def initialize(encoded_public_key = nil, time_stamp = nil)
+      self.encoded_public_key = encoded_public_key if encoded_public_key
+      self.time_stamp = time_stamp
+    end
+
     # Takes an encoded public key and calls {#public_key=} with the decoded key.
     #
     # @param [String] encoded_public_key The public key encoded in Base64.