ig_markets 0.1

data/spec/ig_markets/dealing_platform_spec.rb

@@ -0,0 +1,40 @@
+describe IGMarkets::DealingPlatform do
+  let(:session) { IGMarkets::Session.new }
+  let(:platform) do
+    IGMarkets::DealingPlatform.new.tap do |platform|
+      platform.instance_variable_set :@session, session
+    end
+  end
+
+  it 'has a valid session' do
+    expect(IGMarkets::DealingPlatform.new.session).to be_an_instance_of(IGMarkets::Session)
+  end
+
+  it 'can sign in' do
+    expect(session).to receive(:sign_in).and_return({})
+    expect(platform.sign_in('username', 'password', 'api_key', :production)).to eq({})
+    expect(session.username).to eq('username')
+    expect(session.password).to eq('password')
+    expect(session.api_key).to eq('api_key')
+    expect(session.platform).to eq(:production)
+  end
+
+  it 'can sign out' do
+    expect(session).to receive(:sign_out).and_return(nil)
+    expect(platform.sign_out).to eq(nil)
+  end
+
+  it 'can retrieve a deal confirmation' do
+    deal_confirmation = build :deal_confirmation
+
+    expect(session).to receive(:get).with('confirms/deal_id', IGMarkets::API_V1).and_return(deal_confirmation)
+    expect(platform.deal_confirmation('deal_id')).to eq(deal_confirmation)
+  end
+
+  it 'can retrieve the current applications' do
+    applications = [build(:application)]
+
+    expect(session).to receive(:get).with('operations/application', IGMarkets::API_V1).and_return(applications)
+    expect(platform.applications).to eq(applications)
+  end
+end

data/spec/ig_markets/model_spec.rb

@@ -0,0 +1,127 @@
+describe IGMarkets::Model do
+  class TestModel < IGMarkets::Model
+    attribute :id
+    attribute :bool, IGMarkets::Boolean
+    attribute :string, String, regex: /\A[A-Z]{3}\Z/, nil_if: '-'
+    attribute :date, DateTime, format: '%Y-%m-%d'
+    attribute :float, Float
+    attribute :symbol, Symbol, allowed_values: [:a, :b]
+  end
+
+  let(:model) { TestModel.new }
+
+  it 'initializes with specified attribute values' do
+    expect(TestModel.new(id: 'test', bool: true).attributes).to eq(
+      id: 'test', bool: true, string: nil, date: nil, float: nil, symbol: nil)
+  end
+
+  it 'fails when initialized with an unknown attribute' do
+    expect { TestModel.new id: 'test', unknown: '' }.to raise_error(ArgumentError)
+  end
+
+  it 'has the correct getter and setter methods' do
+    [:id, :id=, :bool, :bool=, :string, :string=, :date, :date=, :float, :float=, :symbol, :symbol=].each do |id|
+      expect(model.respond_to?(id)).to eq(true)
+    end
+  end
+
+  it 'has the correct attributes hash' do
+    expect(model.attributes).to eq(id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil)
+  end
+
+  it 'inspects attributes' do
+    expect(model.inspect).to eq('#<TestModel id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil>')
+  end
+
+  it 'inspects attributes in nested models' do
+    class TestModel2 < IGMarkets::Model
+      attribute :test, TestModel
+    end
+
+    model = TestModel2.new test: TestModel.new
+
+    expect(model.inspect).to eq(
+      '#<TestModel2 test: #<TestModel id: nil, bool: nil, string: nil, date: nil, float: nil, symbol: nil>>')
+  end
+
+  it '#from accepts nil' do
+    expect(TestModel.from(nil)).to eq(nil)
+  end
+
+  it '#from accepts an attributes hash' do
+    expect(TestModel.from(id: 'test').attributes).to eq(
+      id: 'test', bool: nil, string: nil, date: nil, float: nil, symbol: nil)
+  end
+
+  it '#from accepts an instance and creates a copy' do
+    instance = TestModel.new(id: 'test')
+
+    expect(TestModel.from(instance)).to eq(instance)
+    expect(TestModel.from(instance)).not_to eql(instance)
+  end
+
+  it '#from accepts an Array of attributes hashes' do
+    expect(TestModel.from([{ id: 'a' }, { id: 'b' }])).to eq([TestModel.new(id: 'a'), TestModel.new(id: 'b')])
+  end
+
+  it '#from raises on invalid inputs' do
+    ['', DateTime.new, IGMarkets::Model.new].each do |invalid_input|
+      expect { TestModel.from(invalid_input) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it 'raises ArgumentError for an invalid boolean' do
+    expect { model.bool = '' }.to raise_error(ArgumentError)
+  end
+
+  it 'raises ArgumentError when string value does not match the regex' do
+    expect { model.string = 'abc' }.to raise_error(ArgumentError)
+  end
+
+  it 'raises ArgumentError for an invalid date' do
+    expect { model.date = '2015-29-01' }.to raise_error(ArgumentError)
+  end
+
+  it 'raises ArgumentError for an invalid float' do
+    expect { model.float = 'a' }.to raise_error(ArgumentError)
+  end
+
+  it 'raises ArgumentError for an invalid symbol' do
+    expect { model.symbol = :invalid }.to raise_error(ArgumentError)
+  end
+
+  it 'returns the correct set of allowed values for an attribute' do
+    expect(TestModel.allowed_values(:symbol)).to eq([:a, :b])
+  end
+
+  it 'sets attribute to nil when value matches a nil_if' do
+    model.string = '-'
+    expect(model.string).to eq(nil)
+  end
+
+  it 'correctly parses a date in the expected format' do
+    model.date = '2015-01-10'
+    expect(model.date).to eq(DateTime.new(2015, 1, 10))
+  end
+
+  context 'with all attributes set' do
+    before do
+      model.id = 'id'
+      model.bool = true
+      model.string = 'ABC'
+      model.date = '2015-01-10'
+      model.float = '1.0'
+      model.symbol = 'a'
+    end
+
+    it 'has the correct attributes hash' do
+      expect(model.attributes).to eq(
+        id: 'id', bool: true, string: 'ABC', date: DateTime.new(2015, 1, 10), float: 1.0, symbol: :a)
+    end
+
+    it 'inspects attributes' do
+      expect(model.inspect).to eq(
+        '#<TestModel id: "id", bool: true, string: "ABC", date: 2015-01-10T00:00:00+00:00, float: 1.0, symbol: :a>')
+    end
+  end
+end

data/spec/ig_markets/password_encryptor_spec.rb

@@ -0,0 +1,23 @@
+describe IGMarkets::PasswordEncryptor do
+  let(:encryptor) { IGMarkets::PasswordEncryptor.new }
+  let(:rsa_key_pair) { OpenSSL::PKey::RSA.new 2048 }
+
+  it 'can set its public key from an encoded public key' do
+    expect { encryptor.encoded_public_key = Base64.strict_encode64 rsa_key_pair.to_pem }.not_to raise_error
+  end
+
+  it 'can encrypt a password' do
+    password = 'test'
+
+    encryptor.time_stamp = '1000'
+    encryptor.public_key = rsa_key_pair
+
+    encoded_encrypted_password = encryptor.encrypt password
+
+    decoded_encrypted_password = Base64.strict_decode64 encoded_encrypted_password
+    encoded_decrypted_password = rsa_key_pair.private_decrypt decoded_encrypted_password
+    decoded_decrypted_password = Base64.strict_decode64 encoded_decrypted_password
+
+    expect(decoded_decrypted_password).to eq("#{password}|#{encryptor.time_stamp}")
+  end
+end

data/spec/ig_markets/payload_formatter_spec.rb

@@ -0,0 +1,19 @@
+describe IGMarkets::PayloadFormatter do
+  class PayloadModel < IGMarkets::Model
+    attribute :the_string
+    attribute :the_symbol, Symbol, allowed_values: [:two_three]
+    attribute :the_date, DateTime, format: '%Y/%m/%d'
+  end
+
+  it 'formats payloads correctly' do
+    model = PayloadModel.new the_string: 'string', the_symbol: :two_three, the_date: '2010/10/20'
+
+    expect(IGMarkets::PayloadFormatter.format(model)).to eq(
+      theString: 'string', theSymbol: 'TWO_THREE', theDate: '2010/10/20')
+  end
+
+  it 'camel cases snake case strings' do
+    expect(IGMarkets::PayloadFormatter.snake_case_to_camel_case('one')).to eq(:one)
+    expect(IGMarkets::PayloadFormatter.snake_case_to_camel_case('one_two_three')).to eq(:oneTwoThree)
+  end
+end

data/spec/ig_markets/position_spec.rb

@@ -0,0 +1,37 @@
+describe IGMarkets::Position do
+  let(:profitable_position) do
+    market = build :market_overview, bid: 4.0, lot_size: 3, scaling_factor: 5
+    build :position, currency: 'USD', level: 1.0, direction: :buy, size: 2, market: market
+  end
+  let(:unprofitable_position) do
+    market = build :market_overview, offer: 4.0, lot_size: 3, scaling_factor: 5
+    build :position, currency: 'USD', level: 1.0, direction: :sell, size: 2, market: market
+  end
+
+  it 'knows if it has a trailing stop' do
+    expect(build(:position).trailing_stop?).to be false
+    expect(build(:position, trailing_step: 1, trailing_stop_distance: 10).trailing_stop?).to be true
+  end
+
+  it 'calculates correct price deltas' do
+    expect(profitable_position.price_delta).to eq(3.0)
+    expect(unprofitable_position.price_delta).to eq(-3.0)
+    expect(profitable_position.profitable?).to be true
+    expect(unprofitable_position.profitable?).to be false
+  end
+
+  it 'calculates correct profit/loss amounts' do
+    expect(profitable_position.profit_loss).to eq(90)
+    expect(unprofitable_position.profit_loss).to eq(-90)
+  end
+
+  it 'correctly formats profit/loss amounts' do
+    expect(profitable_position.formatted_profit_loss).to eq('USD 90.00')
+    expect(unprofitable_position.formatted_profit_loss).to eq('USD -90.00')
+  end
+
+  it 'correctly formats position size' do
+    expect(profitable_position.formatted_size).to eq('+2')
+    expect(unprofitable_position.formatted_size).to eq('-2')
+  end
+end

data/spec/ig_markets/response_parser_spec.rb

@@ -0,0 +1,13 @@
+describe IGMarkets::ResponseParser do
+  it 'snake cases camel case keys' do
+    parsed = IGMarkets::ResponseParser.parse(update: 1, updateTime: 1, updateTimeUTC: 1, updateUTCTime: 1)
+
+    expect(parsed).to eq(update: 1, update_time: 1, update_time_utc: 1, update_utc_time: 1)
+  end
+
+  it 'parses arrays' do
+    parsed = IGMarkets::ResponseParser.parse([{ aB: 1 }, { cD: 2 }])
+
+    expect(parsed).to eq([{ a_b: 1 }, { c_d: 2 }])
+  end
+end

data/spec/ig_markets/session_spec.rb

@@ -0,0 +1,134 @@
+describe IGMarkets::Session do
+  let(:response) { instance_double 'RestClient::Response' }
+  let(:rest_client) { RestClient::Request }
+
+  context 'a non-signed in session' do
+    let(:session) do
+      IGMarkets::Session.new.tap do |session|
+        session.username = 'username'
+        session.password = 'password'
+        session.api_key = 'api_key'
+        session.platform = :production
+      end
+    end
+
+    it 'is not alive' do
+      expect(session.alive?).to eq(false)
+    end
+
+    it 'can sign in' do
+      expect(response).to receive(:code).exactly(4).times.and_return(200)
+      expect(response).to receive(:headers).and_return(cst: '1', x_security_token: '2')
+      expect(response).to receive(:body).twice.and_return(
+        { encryptionKey: Base64.strict_encode64(OpenSSL::PKey::RSA.new(256).to_pem), timeStamp: '1000' }.to_json,
+        {}.to_json
+      )
+      expect(rest_client).to receive(:execute).twice.and_return(response)
+
+      expect(session.sign_in).to eq(nil)
+
+      expect(session.cst).to eq('1')
+      expect(session.x_security_token).to match('2')
+      expect(session.alive?).to eq(true)
+    end
+
+    it 'fails to sign in when required attributes are missing' do
+      %i(username password api_key platform).each do |attribute|
+        session.send "#{attribute}=", nil
+        expect { session.sign_in }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'a signed in session' do
+    let(:session) do
+      IGMarkets::Session.new.tap do |s|
+        s.instance_variable_set :@cst, 'cst'
+        s.instance_variable_set :@x_security_token, 'x_security_token'
+        s.instance_variable_set :@api_key, 'api_key'
+        s.instance_variable_set :@platform, :production
+      end
+    end
+
+    it 'is alive' do
+      expect(session.alive?).to eq(true)
+    end
+
+    it 'passes correct details for a post request' do
+      expect(response).to receive_messages(code: 200, body: { ids: [1, 2] }.to_json)
+      expect(rest_client).to receive(:execute).with(params(:post, 'url', id: 1)).and_return(response)
+      expect(session.post('url', { id: 1 }, IGMarkets::API_V1)).to eq(ids: [1, 2])
+    end
+
+    it 'can sign out' do
+      expect(response).to receive_messages(code: 200, body: {}.to_json)
+      expect(rest_client).to receive(:execute).with(params(:delete, 'session')).and_return(response)
+      expect(session.sign_out).to eq(nil)
+      expect(session.alive?).to eq(false)
+    end
+
+    it 'fails when the HTTP response is not 200' do
+      expect(response).to receive_messages(code: 404, body: { errorCode: '1' }.to_json)
+      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception, response)
+      expect { session.get('url', IGMarkets::API_V1) }.to raise_error do |error|
+        expect(error).to be_a(IGMarkets::RequestFailedError)
+        expect(error.error).to eq('1')
+        expect(error.http_code).to eq(404)
+      end
+    end
+
+    it 'handles when the HTTP response is not JSON' do
+      expect(response).to receive_messages(code: 404, body: 'not_valid_json')
+      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception, response)
+      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
+    end
+
+    it 'converts a SocketError into a RequestFailedError' do
+      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(SocketError)
+      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
+    end
+
+    it 'converts a RestClient::Exception that has no response into a RequestFailedError' do
+      expect(rest_client).to receive(:execute).with(params(:get, 'url')).and_raise(RestClient::Exception)
+      expect { session.get('url', IGMarkets::API_V1) }.to raise_error(IGMarkets::RequestFailedError)
+    end
+
+    it 'can process a PUT request' do
+      expect(response).to receive_messages(code: 200, body: '')
+      expect(rest_client).to receive(:execute).with(params(:put, 'url', id: 1)).and_return(response)
+      expect(session.put('url', { id: 1 }, IGMarkets::API_V1)).to eq({})
+    end
+
+    it 'can process a DELETE request with a payload' do
+      execute_params = params :post, 'url', id: 1
+      execute_params[:headers]['_method'] = :delete
+
+      expect(response).to receive_messages(code: 204, body: '')
+      expect(rest_client).to receive(:execute).with(execute_params).and_return(response)
+      expect(session.delete('url', { id: 1 }, IGMarkets::API_V1)).to eq({})
+    end
+
+    it 'inspects correctly' do
+      expect(session.inspect).to eq('#<IGMarkets::Session cst, x_security_token>')
+    end
+
+    def headers
+      hash = {}
+      hash[:accept] = hash[:content_type] = 'application/json; charset=UTF-8'
+      hash[:version] = 1
+      hash[:cst] = 'cst'
+      hash[:x_security_token] = 'x_security_token'
+      hash[:'X-IG-API-KEY'] = 'api_key'
+      hash
+    end
+
+    def params(method, url, payload = nil)
+      hash = {}
+      hash[:method] = method
+      hash[:url] = "https://api.ig.com/gateway/deal/#{url}"
+      hash[:headers] = headers
+      hash[:payload] = payload && payload.to_json
+      hash
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'codeclimate-test-reporter'
+if ENV.key? 'CODECLIMATE_REPO_TOKEN'
+  CodeClimate::TestReporter.start
+else
+  SimpleCov.start
+end
+
+require 'ig_markets'
+
+require 'support/factory_girl'
+require 'support/random_test_order'

data/spec/support/factory_girl.rb

@@ -0,0 +1,7 @@
+require 'factory_girl'
+
+FactoryGirl.find_definitions
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+end

data/spec/support/random_test_order.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.order = :random
+end

metadata

@@ -0,0 +1,261 @@
+--- !ruby/object:Gem::Specification
+name: ig_markets
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Richard Viney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Ruby client for the IG Markets dealing platform.
+email: richard.viney@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.md
+- README.md
+- ig_markets.gemspec
+- lib/ig_markets.rb
+- lib/ig_markets/account.rb
+- lib/ig_markets/account_activity.rb
+- lib/ig_markets/account_transaction.rb
+- lib/ig_markets/api_versions.rb
+- lib/ig_markets/application.rb
+- lib/ig_markets/boolean.rb
+- lib/ig_markets/client_sentiment.rb
+- lib/ig_markets/deal_confirmation.rb
+- lib/ig_markets/dealing_platform.rb
+- lib/ig_markets/dealing_platform/account_methods.rb
+- lib/ig_markets/dealing_platform/client_sentiment_methods.rb
+- lib/ig_markets/dealing_platform/market_methods.rb
+- lib/ig_markets/dealing_platform/position_methods.rb
+- lib/ig_markets/dealing_platform/sprint_market_position_methods.rb
+- lib/ig_markets/dealing_platform/watchlist_methods.rb
+- lib/ig_markets/dealing_platform/working_order_methods.rb
+- lib/ig_markets/historical_price_result.rb
+- lib/ig_markets/instrument.rb
+- lib/ig_markets/market.rb
+- lib/ig_markets/market_hierarchy_result.rb
+- lib/ig_markets/market_overview.rb
+- lib/ig_markets/model.rb
+- lib/ig_markets/password_encryptor.rb
+- lib/ig_markets/payload_formatter.rb
+- lib/ig_markets/position.rb
+- lib/ig_markets/regex.rb
+- lib/ig_markets/request_failed_error.rb
+- lib/ig_markets/response_parser.rb
+- lib/ig_markets/session.rb
+- lib/ig_markets/sprint_market_position.rb
+- lib/ig_markets/version.rb
+- lib/ig_markets/watchlist.rb
+- lib/ig_markets/working_order.rb
+- spec/factories/ig_markets/account.rb
+- spec/factories/ig_markets/account_activity.rb
+- spec/factories/ig_markets/account_balance.rb
+- spec/factories/ig_markets/account_transaction.rb
+- spec/factories/ig_markets/application.rb
+- spec/factories/ig_markets/client_sentiment.rb
+- spec/factories/ig_markets/deal_confirmation.rb
+- spec/factories/ig_markets/historical_price_result.rb
+- spec/factories/ig_markets/historical_price_result_data_allowance.rb
+- spec/factories/ig_markets/historical_price_result_price.rb
+- spec/factories/ig_markets/historical_price_result_snapshot.rb
+- spec/factories/ig_markets/instrument.rb
+- spec/factories/ig_markets/instrument_currency.rb
+- spec/factories/ig_markets/instrument_expiry_details.rb
+- spec/factories/ig_markets/instrument_margin_deposit_band.rb
+- spec/factories/ig_markets/instrument_opening_hours.rb
+- spec/factories/ig_markets/instrument_rollover_details.rb
+- spec/factories/ig_markets/instrument_slippage_factor.rb
+- spec/factories/ig_markets/market.rb
+- spec/factories/ig_markets/market_dealing_rules.rb
+- spec/factories/ig_markets/market_dealing_rules_rule_details.rb
+- spec/factories/ig_markets/market_hierarchy_result.rb
+- spec/factories/ig_markets/market_hierarchy_result_hierarchy_node.rb
+- spec/factories/ig_markets/market_overview.rb
+- spec/factories/ig_markets/market_snapshot.rb
+- spec/factories/ig_markets/position.rb
+- spec/factories/ig_markets/sprint_market_position.rb
+- spec/factories/ig_markets/watchlist.rb
+- spec/factories/ig_markets/working_order.rb
+- spec/ig_markets/account_transaction_spec.rb
+- spec/ig_markets/dealing_platform/account_methods_spec.rb
+- spec/ig_markets/dealing_platform/client_sentiment_methods_spec.rb
+- spec/ig_markets/dealing_platform/market_methods_spec.rb
+- spec/ig_markets/dealing_platform/position_methods_spec.rb
+- spec/ig_markets/dealing_platform/sprint_market_position_methods_spec.rb
+- spec/ig_markets/dealing_platform/watchlist_methods_spec.rb
+- spec/ig_markets/dealing_platform/working_order_methods_spec.rb
+- spec/ig_markets/dealing_platform_spec.rb
+- spec/ig_markets/model_spec.rb
+- spec/ig_markets/password_encryptor_spec.rb
+- spec/ig_markets/payload_formatter_spec.rb
+- spec/ig_markets/position_spec.rb
+- spec/ig_markets/response_parser_spec.rb
+- spec/ig_markets/session_spec.rb
+- spec/spec_helper.rb
+- spec/support/factory_girl.rb
+- spec/support/random_test_order.rb
+homepage: https://github.com/rviney/ig_markets
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby client for the IG Markets dealing platform.
+test_files: []
+has_rdoc: