ig_markets 0.1

data/lib/ig_markets/model.rb

@@ -0,0 +1,185 @@
+module IGMarkets
+  # This class is intended to be subclassed in order to create models that contain a set of attributes, where each
+  # attribute is defined by a call to {attribute}. Attributes have standard getter and setter methods and can also
+  # be subject to a variety of constraints and validations, see {attribute} for further details.
+  class Model
+    # @return [Hash] The current attribute values set on this model.
+    attr_reader :attributes
+
+    # Initializes this new model with the given attribute values. Attributes not known to this model will raise
+    # `ArgumentError`.
+    #
+    # @param [Hash] attributes The attribute values to set on this new model.
+    def initialize(attributes = {})
+      defined_attribute_names = self.class.defined_attribute_names
+
+      defined_attribute_names.each do |name|
+        send "#{name}=", attributes[name]
+      end
+
+      (attributes.keys - defined_attribute_names).map do |attribute|
+        value = attributes[attribute]
+        value = value.inspect unless value.is_a? DateTime
+
+        raise ArgumentError, "Unknown attribute: #{self.class.name}##{attribute}, value: #{value}"
+      end
+    end
+
+    # Compares this model to another, the attributes and class must match for them to be considered equal.
+    #
+    # @param [#class, #attributes] other The other model to compare to.
+    #
+    # @return [Boolean]
+    def ==(other)
+      self.class == other.class && attributes == other.attributes
+    end
+
+    # Returns a human-readable string containing this model's type and all its current attribute values.
+    #
+    # @return [String]
+    def inspect
+      formatted_attributes = self.class.defined_attribute_names.map do |attribute|
+        value = send attribute
+
+        "#{attribute}: #{value.is_a?(DateTime) ? value : value.inspect}"
+      end
+
+      "#<#{self.class.name} #{formatted_attributes.join ', '}>"
+    end
+
+    class << self
+      # @return [Hash] A hash containing details of all attributes that have been defined on this model.
+      attr_accessor :defined_attributes
+
+      # Returns the names of all currently defined attributes for this model.
+      #
+      # @return [Array<Symbol>]
+      def defined_attribute_names
+        (defined_attributes || {}).keys
+      end
+
+      # Returns the array of allowed values for the specified attribute that was passed to {attribute}.
+      #
+      # @param [Symbol] attribute_name The name of the attribute to return the allowed values for.
+      #
+      # @return [Array]
+      def allowed_values(attribute_name)
+        defined_attributes.fetch(attribute_name).fetch(:allowed_values)
+      end
+
+      # Defines setter and getter methods for a new attribute on this class.
+      #
+      # @param [Symbol] name The name of the new attribute.
+      # @param [Boolean, String, DateTime, Fixnum, Float, Symbol, #from] type The attribute's type.
+      # @param [Hash] options The configuration options for the new attribute.
+      # @option options [Array] :allowed_values The set of values that this attribute is allowed to be set to. An
+      #                 attempt to set this attribute to a value not in this list will raise `ArgumentError`. Optional.
+      # @option options [Array] :nil_if Values that, when set on the attribute, should be converted to `nil`.
+      # @option options [Regexp] :regex When `type` is `String` only values matching this regex will be allowed.
+      #                 Optional.
+      # @option options [String] :format When `type` is `DateTime` this specifies the format for parsing String and
+      #                 Fixnum instances assigned to this attribute. See `DateTime#strptime` for details.
+      #
+      # @macro [attach] attribute
+      #   The $1 attribute.
+      #   @return [$2]
+      def attribute(name, type = String, options = {})
+        define_attribute_reader name
+        define_attribute_writer name, type, options
+
+        (self.defined_attributes ||= {})[name] = options.merge type: type
+      end
+
+      # Creates a new Model instance from the specified source, which can take a variety of different forms.
+      #
+      # @param [nil, Hash, Model, Array] source The source object to create a new `Model` instance from. If `source` is
+      #        `nil` then `nil` is returned. If `source` is a hash then a new `Model` instance is returned and the
+      #        hash is passed to `Model#initialize`. If `source` is an instance of this class then `dup` is called on it
+      #        and the duplicate returned. If source is an array then it is mapped into a new array with each item
+      #        having been recursively passed through this method.
+      #
+      # @return [nil, Array, Model]
+      def from(source)
+        return nil if source.nil?
+        return new source if source.is_a? Hash
+        return source.dup if source.is_a? self
+        return source.map { |item| from item } if source.is_a? Array
+
+        raise ArgumentError, "Unable to make a #{self} from instance of #{source.class}"
+      end
+
+      private
+
+      def define_attribute_reader(name)
+        define_method(name) { @attributes[name] }
+      end
+
+      def define_attribute_writer(name, type, options)
+        typecaster = typecaster_for type
+
+        define_method "#{name}=" do |value|
+          value = nil if Array(options.fetch(:nil_if, [])).include? value
+
+          value = typecaster.call(value, options)
+
+          allowed_values = options[:allowed_values]
+          if !value.nil? && allowed_values
+            raise ArgumentError, "#{self}##{name}: invalid value: #{value.inspect}" unless allowed_values.include? value
+          end
+
+          (@attributes ||= {})[name] = value
+        end
+      end
+
+      def typecaster_for(type)
+        if [Boolean, String, Fixnum, Float, Symbol, DateTime].include? type
+          method "typecaster_#{type.to_s.gsub(/\AIGMarkets::/, '').downcase}"
+        elsif type.respond_to? :from
+          -> (value, _options) { type.from value }
+        end
+      end
+
+      def typecaster_boolean(value, _options)
+        return value if [nil, true, false].include? value
+
+        raise ArgumentError, "#{self}: invalid boolean value: #{value}"
+      end
+
+      def typecaster_string(value, options)
+        return nil if value.nil?
+
+        if options.key? :regex
+          raise ArgumentError, "#{self}: invalid string value: #{value}" unless options[:regex].match value.to_s
+        end
+
+        value.to_s
+      end
+
+      def typecaster_fixnum(value, _options)
+        value.nil? ? nil : value.to_s.to_i
+      end
+
+      def typecaster_float(value, _options)
+        value.nil? ? nil : Float(value)
+      end
+
+      def typecaster_symbol(value, _options)
+        value.nil? ? nil : value.to_s.downcase.to_sym
+      end
+
+      def typecaster_datetime(value, options)
+        raise ArgumentError, "#{self}: invalid or missing date time format" unless options[:format].is_a? String
+
+        if value.is_a?(String) || value.is_a?(Fixnum)
+          begin
+            DateTime.strptime(value.to_s, options[:format])
+          rescue ArgumentError
+            raise ArgumentError, "#{self}: failed parsing date '#{value}' with format '#{options[:format]}'"
+          end
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/ig_markets/password_encryptor.rb

@@ -0,0 +1,31 @@
+module IGMarkets
+  # Encrypts account passwords in the manner required for authentication with the IG Markets API.
+  class PasswordEncryptor
+    # @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}.
+    attr_accessor :time_stamp
+
+    # Takes an encoded public key and calls {#public_key=} with the decoded key.
+    #
+    # @param [String] encoded_public_key The public key encoded in Base64.
+    def encoded_public_key=(encoded_public_key)
+      self.public_key = OpenSSL::PKey::RSA.new Base64.strict_decode64 encoded_public_key
+    end
+
+    # Encrypts a password using this encryptor's public key and time stamp, which must have been set prior to calling
+    # this method.
+    #
+    # @param [String] password The password to encrypt.
+    #
+    # @return [String] The encrypted password encoded in Base64.
+    def encrypt(password)
+      encoded_password = Base64.strict_encode64 "#{password}|#{time_stamp}"
+
+      encrypted_password = public_key.public_encrypt encoded_password
+
+      Base64.strict_encode64 encrypted_password
+    end
+  end
+end

data/lib/ig_markets/payload_formatter.rb

@@ -0,0 +1,38 @@
+module IGMarkets
+  # Contains methods for formatting payloads that can be passed to the IG Markets API.
+  module PayloadFormatter
+    module_function
+
+    # Takes a {Model} and returns its attributes in a hash ready to be passed as a payload to the IG Markets API.
+    # Attribute names will be converted to use camel case rather than snake case, `Symbol` attributes will be converted
+    # to strings and will be uppercased, and `DateTime` attributes will be converted to strings using their ':format'
+    # option.
+    #
+    # @param [Model] model The model instance to convert attributes for.
+    #
+    # @return [Hash] The resulting attributes hash.
+    def format(model)
+      model.class.defined_attributes.each_with_object({}) do |(name, options), formatted|
+        value = model.send name
+
+        next if value.nil?
+
+        value = value.to_s.upcase if options[:type] == Symbol
+        value = value.strftime(options.fetch(:format)) if options[:type] == DateTime
+
+        formatted[snake_case_to_camel_case(name)] = value
+      end
+    end
+
+    # Takes a string or symbol that uses snake case and converts it to a camel case symbol.
+    #
+    # @param [String, Symbol] value The string or symbol to convert to camel case.
+    #
+    # @return [Symbol]
+    def snake_case_to_camel_case(value)
+      pieces = value.to_s.split '_'
+
+      (pieces[0] + pieces[1..-1].map(&:capitalize).join).to_sym
+    end
+  end
+end

data/lib/ig_markets/position.rb

@@ -0,0 +1,191 @@
+module IGMarkets
+  # Contains details on a trading position. Returned by {DealingPlatform::PositionMethods#all} and
+  # {DealingPlatform::PositionMethods#[]}.
+  class Position < Model
+    attribute :contract_size, Float
+    attribute :controlled_risk, Boolean
+    attribute :created_date, DateTime, format: '%Y/%m/%d %H:%M:%S:%L'
+    attribute :created_date_utc, DateTime, format: '%Y-%m-%dT%H:%M:%S'
+    attribute :currency, String, regex: Regex::CURRENCY
+    attribute :deal_id
+    attribute :direction, Symbol, allowed_values: [:buy, :sell]
+    attribute :level, Float
+    attribute :limit_level, Float
+    attribute :size, Fixnum
+    attribute :stop_level, Float
+    attribute :trailing_step, Float
+    attribute :trailing_stop_distance, Fixnum
+
+    attribute :market, MarketOverview
+
+    # Returns whether this position has a trailing stop.
+    def trailing_stop?
+      !trailing_step.nil? && !trailing_stop_distance.nil?
+    end
+
+    # Returns the favorable difference in the price between {#level} and the current market price as stored in
+    # {#market}. If {#direction} is `:buy` and the market has since risen then this method will return a positive value,
+    # but if {#direction} is `:sell` and the market has since risen then this method will return a negative value.
+    #
+    # @return [Float]
+    def price_delta
+      if direction == :buy
+        market.bid - level
+      elsif direction == :sell
+        level - market.offer
+      end
+    end
+
+    # Returns whether this position is currently profitable based on the current market state as stored in {#market}.
+    def profitable?
+      price_delta > 0.0
+    end
+
+    # Returns this position's current profit or loss, denominated in its {#currency}, and based on the current market
+    # state as stored in {#market}. {#formatted_profit_loss} can be used to get a human-readable representation of this
+    # value.
+    #
+    # @return [Float]
+    def profit_loss
+      price_delta * size * market.lot_size * market.scaling_factor
+    end
+
+    # Returns a human-readable string describing this position's current profit or loss, denominated in its {#currency},
+    # and based on the current market state as stored in {#market}. Some examples of the format of the return value:
+    #
+    # - `"USD -130.40"`
+    # - `"AUD 539.10"`
+    # - `"JPY 3560"`
+    #
+    # @return [String]
+    def formatted_profit_loss
+      format_string = (currency == 'JPY' ? '%.0f' : '%.2f')
+      "#{currency} #{format format_string, profit_loss}"
+    end
+
+    # Returns this position's {#size} as a string prefixed with a `+` if {#direction} is `:buy`, or a `-` if
+    # {#direction} is `:sell`.
+    #
+    # @return [String]
+    def formatted_size
+      "#{{ buy: '+', sell: '-' }.fetch(direction)}#{size}"
+    end
+
+    # Closes this position. If called with no options then this position will be fully closed at current market prices,
+    # partial closes and greater control over the close conditions can be achieved with the relevant options.
+    #
+    # @param [Hash] options The options for the position close.
+    # @option options [Float] :level Required if and only if `:order_type` is `:limit` or `:quote`.
+    # @option options [:limit, :market, :quote] :order_type The order type. `:market` indicates to fill the order at
+    #                 current market level(s). `:limit` indicates to fill at the price specified by `:level` (or a more
+    #                 favorable one). `:quote` is only permitted following agreement with IG Markets. Defaults to
+    #                 `:market`.
+    # @option options [String] :quote_id The Lightstreamer quote ID. Required when `:order_type` is `:quote`.
+    # @option options [Float] :size The size of the position to close. Defaults to {#size} which will close the entire
+    #                 position, or alternatively specify a smaller value to partially close this position.
+    # @option options [:execute_and_eliminate, :fill_or_kill] :time_in_force The order fill strategy.
+    #                 `:execute_and_eliminate` will fill this order as much as possible within the constraints set by
+    #                 `:order_type`, `:level` and `:quote_id`. `:fill_or_kill` will try to fill this entire order within
+    #                 the constraints, however if this is not possible then the order will not be filled at all. If
+    #                 `:order_type` is `:market` (the default) then `:time_in_force` will be automatically set to
+    #                 `:execute_and_eliminate`.
+    #
+    # @return [String] The resulting deal reference, use {DealingPlatform#deal_confirmation} to check the result of
+    #         the position close.
+    def close(options = {})
+      options[:deal_id] = deal_id
+      options[:direction] = { buy: :sell, sell: :buy }.fetch(direction)
+      options[:size] ||= size
+
+      model = PositionCloseAttributes.build options
+      model.validate
+
+      payload = PayloadFormatter.format model
+
+      @dealing_platform.session.delete('positions/otc', payload, API_V1).fetch(:deal_reference)
+    end
+
+    # Updates this position. No attributes are mandatory, and any attributes not specified will be kept at their
+    # current value.
+    #
+    # @param [Hash] new_attributes The attributes of this position to update.
+    # @option new_attributes [Float] :limit_level The new limit level for this position.
+    # @option new_attributes [Float] :stop_level The new stop level for this position.
+    # @option new_attributes [Boolean] :trailing_stop Whether to use a trailing stop for this position.
+    # @option new_attributes [Fixnum] :trailing_stop_distance The distance away in pips to place the trailing stop.
+    # @option new_attributes [Fixnum] :trailing_stop_increment The step increment to use for the trailing stop.
+    #
+    # @return [String] The deal reference of the update operation. Use {DealingPlatform#deal_confirmation} to check
+    #         the result of the position update.
+    def update(new_attributes)
+      new_attributes = { limit_level: limit_level, stop_level: stop_level, trailing_stop: trailing_stop?,
+                         trailing_stop_distance: trailing_stop_distance, trailing_stop_increment: trailing_step
+                       }.merge new_attributes
+
+      unless new_attributes[:trailing_stop]
+        new_attributes[:trailing_stop_distance] = new_attributes[:trailing_stop_increment] = nil
+      end
+
+      payload = PayloadFormatter.format PositionUpdateAttributes.new new_attributes
+
+      @dealing_platform.session.put("positions/otc/#{deal_id}", payload, API_V2).fetch(:deal_reference)
+    end
+
+    # Validates the internal consistency of the `:order_type`, `:quote_id` and `:level` attributes.
+    #
+    # @param [Hash] attributes The attributes hash to validate.
+    def self.validate_order_type_constraints(attributes)
+      if (attributes[:order_type] == :quote) == attributes[:quote_id].nil?
+        raise ArgumentError, 'set quote_id if and only if order_type is :quote'
+      end
+
+      if [:limit, :quote].include?(attributes[:order_type]) == attributes[:level].nil?
+        raise ArgumentError, 'set level if and only if order_type is :limit or :quote'
+      end
+    end
+
+    # Internal model used by {#close}.
+    class PositionCloseAttributes < Model
+      attribute :deal_id
+      attribute :direction, Symbol, allowed_values: [:buy, :sell]
+      attribute :level, Float
+      attribute :order_type, Symbol, allowed_values: [:limit, :market, :quote]
+      attribute :quote_id
+      attribute :size, Fixnum
+      attribute :time_in_force, Symbol, allowed_values: [:execute_and_eliminate, :fill_or_kill]
+
+      # 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
+        [:deal_id, :direction, :order_type, :size, :time_in_force].each do |attribute|
+          raise ArgumentError, "#{attribute} attribute must be set" if attributes[attribute].nil?
+        end
+
+        Position.validate_order_type_constraints attributes
+      end
+
+      # Builds a new {PositionCloseAttributes} instance with the given attributes and applies relevant defaults.
+      #
+      # @param [Hash] attributes
+      #
+      # @return [PositionCloseAttributes]
+      def self.build(attributes)
+        new(attributes).tap do |model|
+          model.order_type ||= :market
+          model.time_in_force = :execute_and_eliminate if model.order_type == :market
+        end
+      end
+    end
+
+    # Internal model used by {#update}.
+    class PositionUpdateAttributes < Model
+      attribute :limit_level, Float
+      attribute :stop_level, Float
+      attribute :trailing_stop, Boolean
+      attribute :trailing_stop_distance, Fixnum
+      attribute :trailing_stop_increment, Fixnum
+    end
+
+    private_constant :PositionCloseAttributes, :PositionUpdateAttributes
+  end
+end