eodhd.rb 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75d710273541a726ea8483974f5ac0f0a78ddee69fcb5024fe5a003ecfff3f35
-  data.tar.gz: d156d5857f9cc1892d23f54c491a7a5cdefcea49135c50e16f1ab70ea402a0c9
+  metadata.gz: 32a73dbd43fadc7f1f4f84e0e3cd8490fd08cc8ee75afa9207bf6f341514bd20
+  data.tar.gz: d40408203120a0dc787345d3545c118570e58488053705f6c6280bfa0c523971
 SHA512:
-  metadata.gz: 6c09445a3ef620a5ee45be611bf41d4d70c9edc2aef5a52ab691849eb4dea1c06381decb9534faa2b6ff680d11a3e44c47133b4a997125697fa84209add6c49a
-  data.tar.gz: 30f076f3f55ff6c11fbd8551627b01b90791ca467834b6154e3be2f64f66c3edb7695a2dc6ed04be9464f3befd653ea854108833c8313a2939fe0fead7b2c478
+  metadata.gz: f77f80889b5a92557731cb2753be73cafc1f663568dfa0d52ae844532cd1bbc95446f9c8951cbf0bf2874a8a74eb90e3baecf0cf7fdcee223d440611077e9ed1
+  data.tar.gz: ac326a3aba6438c3911a6184f4c932253c7f6fed4875a9bd11bac19dd411c7623c0c25ec7ff7856c677889b15b1b605938b4961ec638839d34fb8a098b982a5e

data/eodhd.rb.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
   spec.name = 'eodhd.rb'
 
   spec.version = Eodhd::VERSION
-  spec.date = '2025-09-16'
+  spec.date = '2025-10-05'
 
   spec.summary = "Access the eodhd.com API with Ruby."
   spec.description = "Access the eodhd.com API with Ruby."
@@ -17,6 +17,15 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.5'
 
   spec.add_dependency('http.rb')
+  spec.add_dependency('iodine')
+
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('minitest-spec-context')
+  spec.add_development_dependency('webmock')
+  spec.add_development_dependency('vcr')
+  spec.add_development_dependency('simplecov')
+
   spec.files = [
     'eodhd.rb.gemspec',
     'Gemfile',

data/lib/Eodhd/Client.rb

@@ -3,13 +3,13 @@
 
 gem 'http.rb'
 
-require 'fileutils'
 require 'http.rb'
 require 'json'
-require 'logger'
 
+require_relative './DefaultLogger'
 require_relative './Error'
 require_relative '../Hash/x_www_form_urlencode'
+require_relative './Validations'
 
 class Eodhd
   class Client
@@ -17,30 +17,13 @@ class Eodhd
     API_HOST = 'eodhd.com'
 
     class << self
-      attr_writer :log_file_path
-
       def path_prefix
         '/api'
       end
-
-      def default_log_file_path
-        File.join(%w{~ log eodhd log.txt})
-      end
-
-      def log_file_path
-        File.expand_path(@log_file_path || default_log_file_path)
-      end
-
-      def log_file
-        FileUtils.mkdir_p(File.dirname(log_file_path))
-        File.open(log_file_path, File::WRONLY | File::APPEND | File::CREAT)
-      end
-
-      def logger
-        @logger ||= Logger.new(log_file, 'daily')
-      end
     end # class << self
 
+    include Validations
+
     # This endpoint always returns json regardless of what fmt is specified.
     def exchanges_list
       response = get(path: '/exchanges-list')
@@ -61,9 +44,7 @@ class Eodhd
         from: from,
         to: to
       )
-      args = {period: period}
-      args.merge!(from: from) if from
-      args.merge!(to: to) if to
+      args = {period: period, from: from, to: to}.compact
       response = get(path: "/eod/#{symbol}.#{exchange_id}", args: args)
       handle_response(response)
     end
@@ -75,20 +56,28 @@ class Eodhd
       handle_response(response)
     end
 
+    def intraday(exchange_code:, symbol:, interval:, from: nil, to: nil)
+      validate_arguments(
+        exchange_code: exchange_code,
+        symbol: symbol,
+        interval: interval,
+        from: from,
+        to: to
+      )
+      args = {interval: interval, from: from, to: to}.compact
+      response = get(path: "/intraday/#{symbol}.#{exchange_code}", args: args)
+      handle_response(response)
+    end
+
+    attr_accessor\
+      :api_token,
+      :logger
+
     private
 
-    def initialize(api_token:)
+    def initialize(api_token: nil, logger: nil, use_default_logger: false)
       @api_token = api_token
-    end
-
-    def validate_arguments(exchange_code: nil, exchange_id: nil, symbol: nil, period: nil, from: nil, to: nil, date: nil)
-      exchange_code ||= exchange_id
-      validate_exchange_code!(exchange_code) if exchange_code
-      validate_symbol!(symbol) if symbol
-      validate_period!(period) if period
-      validate_date!(from, 'from') if from
-      validate_date!(to, 'to') if to
-      validate_date_range!(from, to) if from && to
+      @logger = use_default_logger ? DefaultLogger.logger : logger
     end
 
     def request_string(path)
@@ -104,24 +93,24 @@ class Eodhd
       if log_args?(args)
         log_string << "?#{args.x_www_form_urlencode}"
       end
-      self.class.logger.info(log_string)
+      @logger.info(log_string)
     end
 
     def log_response(code:, message:, body:)
       log_string = "#{code}\n#{message}\n#{body}"
-      self.class.logger.info(log_string)
+      @logger.info(log_string)
     end
 
     def log_error(code:, message:, body:)
       log_string = "#{code}\n#{message}\n#{body}"
-      self.class.logger.error(log_string)
+      @logger.error(log_string)
     end
 
     def do_request(verb:, path:, args: {})
       api_token = args[:api_token] || @api_token
       fmt = args[:fmt] || 'json'
       args.merge!(api_token: api_token, fmt: fmt)
-      log_request(verb: verb, request_string: request_string(path), args: args)
+      log_request(verb: verb, request_string: request_string(path), args: args) if use_logging?
       HTTP.send(verb.to_s.downcase, request_string(path), args)
     end
 
@@ -135,9 +124,13 @@ class Eodhd
         log_response(code: response.code, message: response.message, body: response.body) if use_logging?
         parsed_body
       else
-        log_error(code: response.code, message: response.message, body: response.body)
+        log_error(code: response.code, message: response.message, body: response.body) if use_logging?
         raise Eodhd::Error.new(code: response.code, message: response.message, body: response.body)
       end
     end
+
+    def use_logging?
+      !@logger.nil?
+    end
   end
 end

data/lib/Eodhd/DefaultLogger.rb

@@ -0,0 +1,30 @@
+# Eodhd/DefaultLogger.rb
+# Eodhd::DefaultLogger
+
+require 'fileutils'
+require 'logger'
+
+class Eodhd
+  class DefaultLogger
+    class << self
+      attr_writer :log_filepath
+
+      def default_log_filepath
+        File.join(%w{~ log eodhd log.txt})
+      end
+
+      def log_filepath
+        File.expand_path(@log_filepath || default_log_filepath)
+      end
+
+      def log_file
+        FileUtils.mkdir_p(File.dirname(log_filepath))
+        File.open(log_filepath, File::WRONLY | File::APPEND | File::CREAT)
+      end
+
+      def logger
+        @logger ||= Logger.new(log_file, 'daily')
+      end
+    end
+  end
+end

data/lib/Eodhd/Intraday.rb

@@ -0,0 +1,76 @@
+# Eodhd/Intraday.rb
+# Eodhd::Intraday
+
+class Eodhd
+  class Intraday
+    class << self
+      def all(client: nil, api_token: nil, exchange_code: 'US', symbol:, interval:, from: nil, to: nil)
+        load(
+          client: client,
+          api_token: api_token,
+          exchange_code: exchange_code,
+          symbol: symbol,
+          interval: interval,
+          from: from,
+          to: to
+        )
+      end
+
+      private
+
+      def load(client: nil, api_token: nil, exchange_code: 'US', symbol:, interval:, from:, to:)
+        client ||= Client.new(api_token: api_token)
+        client.intraday(
+          exchange_code: exchange_code,
+          symbol: symbol,
+          interval: interval,
+          from: from,
+          to: to
+        ).collect do |intraday_data|
+          self.new(
+            exchange_code: exchange_code,
+            symbol: symbol,
+            interval: interval,
+            timestamp: intraday_data['timestamp'],
+            gmtoffset: intraday_data['gmtoffset'],
+            datetime: intraday_data['datetime'],
+            open: intraday_data['open'],
+            high: intraday_data['high'],
+            low: intraday_data['low'],
+            close: intraday_data['close'],
+            volume: intraday_data['volume']
+          )
+        end
+      end
+    end # class << self
+
+    attr_reader\
+      :exchange_code,
+      :symbol,
+      :interval,
+      :timestamp,
+      :gmtoffset,
+      :datetime,
+      :open,
+      :high,
+      :low,
+      :close,
+      :volume
+
+    private
+
+    def initialize(exchange_code:, symbol:, interval:, timestamp:, gmtoffset:, datetime:, open:, high:, low:, close:, volume:)
+      @exchange_code = exchange_code
+      @symbol = symbol
+      @interval = interval
+      @timestamp = timestamp
+      @gmtoffset = gmtoffset
+      @datetime = datetime
+      @open = open
+      @high = high
+      @low = low
+      @close = close
+      @volume = volume
+    end
+  end
+end

data/lib/Eodhd/VERSION.rb

@@ -1,3 +1,3 @@
-module Eodhd
-  VERSION = '0.15.0'
+class Eodhd
+  VERSION = '0.17.0'
 end

data/lib/Eodhd/Validations.rb

@@ -1,16 +1,27 @@
 # Eodhd/Validations.rb
 # Eodhd::Validations
 
-module Eodhd
+class Eodhd
   module Validations
-    def validate_exchange_code!(exchange_code)
+    def validate_arguments(exchange_code: nil, exchange_id: nil, symbol: nil, period: nil, interval: nil, from: nil, to: nil, date: nil)
+      exchange_code ||= exchange_id
+      validate_exchange_code(exchange_code)
+      validate_symbol(symbol)
+      validate_period(period)
+      validate_interval(interval)
+      validate_date(from, 'from')
+      validate_date(to, 'to')
+      validate_date_range(from, to)
+    end
+
+    def validate_exchange_code(exchange_code)
       return unless exchange_code
       unless exchange_code.match?(/\A[A-Z]{2,6}\z/)
         raise ArgumentError, "Invalid exchange_code '#{exchange_code}'. Must be 2-6 uppercase letters"
       end
     end
 
-    def validate_symbol!(symbol)
+    def validate_symbol(symbol)
       return unless symbol
       if symbol.strip.empty?
         raise ArgumentError, "Symbol cannot be empty"
@@ -20,7 +31,7 @@ module Eodhd
       end
     end
 
-    def validate_period!(period)
+    def validate_period(period)
       return unless period
       valid_periods = %w[d w m]
       unless valid_periods.include?(period)
@@ -28,7 +39,15 @@ module Eodhd
       end
     end
 
-    def validate_date!(date, param_name = 'date')
+    def validate_interval(interval)
+      return unless interval
+      valid_intervals = %w[1m 5m 15m 30m 1h 4h 1d 1w 1mo]
+      unless valid_intervals.include?(interval)
+        raise ArgumentError, "Invalid interval: #{interval}. Must be one of: #{valid_intervals.join(', ')}"
+      end
+    end
+
+    def validate_date(date, param_name = 'date')
       return unless date
       case date
       when Date
@@ -47,7 +66,7 @@ module Eodhd
       end
     end
 
-    def validate_date_range!(from, to)
+    def validate_date_range(from, to)
       return unless from && to
       from_date = from.is_a?(Date) ? from : Date.parse(from.to_s)
       to_date = to.is_a?(Date) ? to : Date.parse(to.to_s)

data/lib/Eodhd/WebSocketClient.rb

@@ -9,41 +9,23 @@
 #   iv.  Crypto: wss://ws.eodhistoricaldata.com/ws/crypto?api_token=XXX
 
 require 'iodine'
-require 'json' # This line doesn't seem to be necessary in Ruby 3.
+require 'json'
+
+require_relative './DefaultLogger'
+require_relative './Error'
 
 class Eodhd
   class WebSocketClient
     API_HOST = 'ws.eodhistoricaldata.com'
 
     class Handler
-      class << self
-        attr_writer :log_file_path
-
-        def default_log_file_path
-          File.join(%w{~ log eodhd log.txt})
-        end
-
-        def log_file_path
-          File.expand_path(@log_file_path || default_log_file_path)
-        end
-
-        def log_file
-          FileUtils.mkdir_p(File.dirname(log_file_path))
-          File.open(log_file_path, File::WRONLY | File::APPEND | File::CREAT)
-        end
-
-        def logger
-          @logger ||= Logger.new(log_file, 'daily')
-        end
-      end # class << self
-
       def on_open(connection)
         connection.write({action: 'subscribe', symbols: @symbols}.to_json)
       end
 
       def on_message(connection, message)
         dataframe = handle_response(message)
-        @consumer.call(dataframe)
+        @consumer.call(dataframe) if @consumer
       end
 
       def on_close(connection)
@@ -52,29 +34,26 @@ class Eodhd
 
       private
 
-      def initialize(symbols:, consumer:)
+      def initialize(symbols:, consumer:, logger: nil)
         @symbols = symbols
         @consumer = consumer
+        @logger = logger
       end
 
       def log_error(code:, message:, body:)
         log_string = "WebSocketError #{code}\n#{message}\n#{body}"
-        self.class.logger.error(log_string)
+        @logger.error(log_string) if use_logging?
       end
 
       def handle_response(message)
-        if parsed_json = JSON.parse(message)
-          parsed_json
-        else
-          log_error(
-            message: response.message,
-          )
-          raise Eodhd::Error.new(
-            code: 'ws',
-            message: response.message,
-            body: ''
-          )
-        end
+        JSON.parse(message)
+      rescue StandardError => e
+        log_error(code: 'ws_parse_error', message: e.message, body: message)
+        raise Eodhd::Error.new(code: 'ws_parse_error', message: e.message, body: message)
+      end
+
+      def use_logging?
+        !@logger.nil?
       end
     end
 
@@ -104,7 +83,8 @@ class Eodhd
     attr_accessor\
       :api_token,
       :asset_class,
-      :consumer
+      :consumer,
+      :logger
 
     attr_reader\
       :symbols
@@ -115,7 +95,7 @@ class Eodhd
 
     def run
       Iodine.threads = 1
-      Iodine.connect(url: url, handler: Handler.new(symbols: @symbols, consumer: @consumer))
+      Iodine.connect(url: url, handler: Handler.new(symbols: @symbols, consumer: @consumer, logger: @logger))
       Iodine.start
     rescue SystemExit, Interrupt
       return
@@ -123,11 +103,16 @@ class Eodhd
 
     private
 
-    def initialize(api_token:, asset_class:, symbols:, consumer:)
+    def initialize(api_token:, asset_class:, symbols:, consumer:, logger: nil, use_default_logger: false)
       @api_token = api_token
       @asset_class = asset_class # crypto, forex, us-quote, us
       @symbols = format_symbols(symbols)
       @consumer = consumer
+      @logger = use_default_logger ? DefaultLogger.logger : logger
+    end
+
+    def use_logging?
+      !@logger.nil?
     end
 
     def format_symbols(symbols)

data/lib/{eodhd.rb → Eodhd.rb}

@@ -1,12 +1,13 @@
 # Eodhd.rb
 # Eodhd
 
-require_relative 'Eodhd/Client'
-require_relative 'Eodhd/EodBulkLastDay'
-require_relative 'Eodhd/EodData'
-require_relative 'Eodhd/Exchange'
-require_relative 'Eodhd/ExchangeSymbol'
-require_relative 'Eodhd/WebSocketClient'
+require_relative './Eodhd/Client'
+require_relative './Eodhd/EodBulkLastDay'
+require_relative './Eodhd/EodData'
+require_relative './Eodhd/Exchange'
+require_relative './Eodhd/ExchangeSymbol'
+require_relative './Eodhd/Intraday'
+require_relative './Eodhd/WebSocketClient'
 
 class Eodhd
   def initialize(api_token:, consumer: nil)
@@ -34,13 +35,13 @@ class Eodhd
     Eodhd::EodBulkLastDay.all(api_token: @api_token, exchange_code: exchange_code, date: date)
   end
 
+  def intraday(exchange: nil, exchange_code: nil, symbol:, interval:, from: nil, to: nil)
+    exchange_code ||= exchange&.code || 'US'
+    Eodhd::Intraday.all(api_token: @api_token, exchange_code: exchange_code, symbol: symbol, interval: interval, from: from, to: to)
+  end
+
   def web_socket(asset_class:, symbols:)
-    Eodhd::WebSocketClient.new(
-      api_token: @api_token,
-      asset_class: asset_class,
-      symbols: symbols,
-      consumer: @consumer,
-    )
+    Eodhd::WebSocketClient.new(api_token: @api_token, asset_class: asset_class, symbols: symbols, consumer: @consumer)
   end
 
   def stream(asset_class:, symbols:)

data/test/client_test.rb

@@ -0,0 +1,87 @@
+require_relative "helper"
+
+describe Eodhd::Client do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+
+  let(:client){Eodhd::Client.new(api_token: api_token)}
+
+  describe "#exchanges_list" do
+    it "exchanges_list returns parsed JSON array" do
+      VCR.use_cassette("client_exchanges_list") do
+        result = client.exchanges_list
+        _(result).must_be_kind_of(Array)
+        _(result.first["Code"]).wont_be_nil
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette("client_exchanges_list_401_error") do
+        _{client.exchanges_list}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+
+  describe "#exchange_symbol_list" do
+    it "exchange_symbol_list returns parsed JSON array" do
+      VCR.use_cassette("client_exchange_symbol_list") do
+        result = client.exchange_symbol_list(exchange_code: 'AU')
+        _(result).must_be_kind_of(Array)
+        _(result.first['Code']).wont_be_nil
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette("client_exchange_symbol_list_401_error") do
+        _{client.exchange_symbol_list(exchange_code: 'AU')}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+
+  describe "#eod_data" do
+    it "eod_data returns parsed JSON array" do
+      VCR.use_cassette('client_eod_data') do
+        result = client.eod_data(exchange_id: 'AU', symbol: 'BHP', period: 'd')
+        _(result).must_be_kind_of(Array)
+        _(result.first.keys).must_equal(%w{date open high low close adjusted_close volume})
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette('client_eod_data_401_error') do
+        _{client.eod_data(exchange_id: 'AU', symbol: 'BHP', period: 'd')}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+
+  describe "#intraday" do
+    it "intraday returns parsed JSON array" do
+      VCR.use_cassette('client_intraday') do
+        result = client.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')
+        _(result).must_be_kind_of(Array)
+        _(result.first.keys).must_equal(%w{timestamp gmtoffset datetime open high low close volume})
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette('client_intraday_401_error') do
+        _{client.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+
+  describe "#eod_bulk_last_day" do
+    it "eod_bulk_last_day returns parsed JSON array" do
+      VCR.use_cassette("client_eod_bulk_last_day") do
+        result = client.eod_bulk_last_day(exchange_id: 'AU', date: "2024-09-30")
+        _(result).must_be_kind_of(Array)
+        _(result.first.keys).must_equal(%w{code exchange_short_name date open high low close adjusted_close volume})
+      end
+    end
+
+    it "raises Eodhd::Error on failure" do
+      VCR.use_cassette('client_eod_bulk_last_day_401_error') do
+        _{client.eod_bulk_last_day(exchange_id: 'AU', date: "2024-09-30")}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+end

data/test/eodhd_test.rb

@@ -0,0 +1,62 @@
+require_relative "helper"
+
+describe Eodhd do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+
+  let(:eodhd){Eodhd.new(api_token: api_token)}
+
+  describe "#exchanges" do
+    it "delegates to Eodhd::Exchange.all" do
+      VCR.use_cassette('eodhd_exchanges') do
+        exchanges = eodhd.exchanges
+        _(exchanges).must_be_kind_of(Array)
+        _(exchanges).wont_be_empty
+        _(exchanges.first).must_be_kind_of(Eodhd::Exchange)
+      end
+    end
+  end
+
+  describe "#exchange_symbols" do
+    it "delegates to Eodhd::ExchangeSymbol.all" do
+      VCR.use_cassette('eodhd_exchange_symbols') do
+        symbols = eodhd.exchange_symbols(exchange_code: 'AU')
+        _(symbols).must_be_kind_of(Array)
+        _(symbols).wont_be_empty
+        _(symbols.first).must_be_kind_of(Eodhd::ExchangeSymbol)
+      end
+    end
+  end
+
+  describe "#eod_data" do
+    it "delegates to Eodhd::EodData.all" do
+      VCR.use_cassette('eodhd_eod_data') do
+        eod_data = eodhd.eod_data(exchange_code: 'AU', symbol: 'BHP', period: 'd')
+        _(eod_data).must_be_kind_of(Array)
+        _(eod_data).wont_be_empty
+        _(eod_data.first).must_be_kind_of(Eodhd::EodData)
+      end
+    end
+  end
+
+  describe "#eod_bulk_last_day" do
+    it "delegates to Eodhd::EodBulkLastDay.all" do
+      VCR.use_cassette('eodhd_eod_bulk_last_day') do
+        bulk_last_day = eodhd.eod_bulk_last_day(exchange_code: 'AU', date: '2024-09-30')
+        _(bulk_last_day).must_be_kind_of(Array)
+        _(bulk_last_day).wont_be_empty
+        _(bulk_last_day.first).must_be_kind_of(Eodhd::EodBulkLastDay)
+      end
+    end
+  end
+
+  describe "#intraday" do
+    it "delegates to Eodhd::Intraday.all" do
+      VCR.use_cassette('eodhd_intraday') do
+        intraday_data = eodhd.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')
+        _(intraday_data).must_be_kind_of(Array)
+        _(intraday_data).wont_be_empty
+        _(intraday_data.first).must_be_kind_of(Eodhd::Intraday)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest-spec-context'
+require 'vcr'
+require 'webmock/minitest'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require 'Eodhd'
+
+VCR.configure do |config|
+  config.cassette_library_dir = File.expand_path('./fixtures/vcr_cassettes', __dir__)
+  config.hook_into :webmock
+  config.filter_sensitive_data('<API_TOKEN>'){ENV['EODHD_API_TOKEN']}
+end

data/test/test_all.rb

@@ -0,0 +1,5 @@
+require_relative "helper"
+
+Dir[File.expand_path("./**/*_test.rb", __dir__)].each do |file|
+  require file
+end

data/test/validations_test.rb

@@ -0,0 +1,133 @@
+require_relative 'helper'
+
+class DummyIncludingValidations
+  include Eodhd::Validations
+end
+
+describe "Eodhd::Validations" do
+  let(:v){DummyIncludingValidations.new}
+
+  describe "#validate_arguments" do
+    it "accepts all valid arguments" do
+      _{v.validate_arguments(
+        exchange_code: 'AU',
+        symbol: 'BHP',
+        period: 'd',
+        from: '2024-01-01',
+        to: '2024-12-31'
+      )}.must_be_silent
+    end
+
+    it "accepts exchange_id as alias for exchange_code" do
+      _{v.validate_arguments(exchange_id: 'AU')}.must_be_silent
+    end
+
+    it "raises ArgumentError for invalid exchange_code" do
+      _{v.validate_arguments(exchange_code: 'au')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid symbol" do
+      _{v.validate_arguments(symbol: 'bad$')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid period" do
+      _{v.validate_arguments(period: 'h')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid from date" do
+      _{v.validate_arguments(from: '2024/01/01')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid to date" do
+      _{v.validate_arguments(to: '2024-02-30')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for reversed date range" do
+      _{v.validate_arguments(from: '2024-12-31', to: '2024-01-01')}.must_raise(ArgumentError)
+    end
+
+    it "accepts nil values for all arguments" do
+      _{v.validate_arguments}.must_be_silent
+    end
+  end
+
+  describe "#validate_exchange_code" do
+    it "accepts valid exchange codes" do
+      _{v.validate_exchange_code('AU')}.must_be_silent
+      _{v.validate_exchange_code('XETRA')}.must_be_silent
+    end
+
+    it "rejects invalid exchange codes" do
+      _{v.validate_exchange_code('us')}.must_raise(ArgumentError)
+      _{v.validate_exchange_code('U')}.must_raise(ArgumentError)
+      _{v.validate_exchange_code('TOOLONG')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_symbol" do
+    it "accepts valid symbols" do
+      _{v.validate_symbol('AAPL')}.must_be_silent
+      _{v.validate_symbol('BRK.B')}.must_be_silent
+      _{v.validate_symbol('RDS-A')}.must_be_silent
+    end
+
+    it "rejects invalid symbols" do
+      _{v.validate_symbol('')}.must_raise(ArgumentError)
+      _{v.validate_symbol(' ')}.must_raise(ArgumentError)
+      _{v.validate_symbol('THIS_SYMBOL_IS_TOO_LONG')}.must_raise(ArgumentError)
+      _{v.validate_symbol('bad$')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_period" do
+    it "accepts valid periods" do
+      _{v.validate_period('d')}.must_be_silent
+      _{v.validate_period('w')}.must_be_silent
+      _{v.validate_period('m')}.must_be_silent
+    end
+
+    it "rejects invalid periods" do
+      _{v.validate_period('h')}.must_raise(ArgumentError)
+      _{v.validate_period('')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_interval" do
+    it "accepts valid intervals" do
+      _{v.validate_interval('1m')}.must_be_silent
+      _{v.validate_interval('5m')}.must_be_silent
+      _{v.validate_interval('1h')}.must_be_silent
+      _{v.validate_interval('1d')}.must_be_silent
+    end
+
+    it "rejects invalid intervals" do
+      _{v.validate_interval('2m')}.must_raise(ArgumentError)
+      _{v.validate_interval('invalid')}.must_raise(ArgumentError)
+      _{v.validate_interval('')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_date" do
+    it "accepts valid date formats and Date objects" do
+      _{v.validate_date('2024-09-30')}.must_be_silent
+      _{v.validate_date(Date.new(2024,9,30))}.must_be_silent
+    end
+
+    it "rejects invalid dates and formats" do
+      _{v.validate_date('2024/09/30')}.must_raise(ArgumentError)
+      _{v.validate_date('2024-02-30')}.must_raise(ArgumentError)
+      _{v.validate_date(12345)}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_date_range" do
+    it "accepts valid date ranges" do
+      _{v.validate_date_range('2024-01-01','2024-12-31')}.must_be_silent
+      _{v.validate_date_range(Date.new(2024,1,1),Date.new(2024,12,31))}.must_be_silent
+    end
+
+    it "rejects reversed date ranges" do
+      _{v.validate_date_range('2024-12-31','2024-01-01')}.must_raise(ArgumentError)
+    end
+  end
+end

data/test/web_socket_client_test.rb

@@ -0,0 +1,97 @@
+require_relative 'helper'
+
+describe Eodhd::WebSocketClient do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+  let(:consumer){->(data){}}
+
+  describe "#initialize" do
+    it "accepts array of symbols and formats to comma-separated string" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: ['AAPL', 'MSFT'], consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+
+    it "accepts string of symbols" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL,MSFT', consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+  end
+
+  describe "#url" do
+    it "generates correct URL for US trade stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/us?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for US quote stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us-quote', symbols: 'AAPL', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/us-quote?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for forex stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'forex', symbols: 'EURUSD', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/forex?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for crypto stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'crypto', symbols: 'BTC-USD', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/crypto?api_token=#{api_token}")
+    end
+  end
+
+  describe "#format_symbols" do
+    it "converts array to comma-separated string" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: ['AAPL', 'MSFT', 'GOOGL'], consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT,GOOGL')
+    end
+
+    it "returns string as-is" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL,MSFT', consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+  end
+
+  describe "#run" do
+    it "configures Iodine and starts connection" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL', consumer: consumer)
+      
+      iodine_connect_called = false
+      iodine_start_called = false
+      
+      Iodine.stub(:threads=, nil) do
+        Iodine.stub(:connect, ->(opts){iodine_connect_called = true}) do
+          Iodine.stub(:start, ->{iodine_start_called = true}) do
+            client.run
+          end
+        end
+      end
+      
+      _(iodine_connect_called).must_equal(true)
+      _(iodine_start_called).must_equal(true)
+    end
+  end
+
+  describe "Handler" do
+    describe "#on_message" do
+      it "parses JSON and calls consumer" do
+        received_data = nil
+        test_consumer = ->(data){received_data = data}
+        handler = Eodhd::WebSocketClient::Handler.new(symbols: 'AAPL', consumer: test_consumer, logger: nil)
+        
+        message = '{"symbol":"AAPL","price":150.0}'
+        handler.on_message(nil, message)
+        
+        _(received_data).must_be_kind_of(Hash)
+        _(received_data['symbol']).must_equal('AAPL')
+        _(received_data['price']).must_equal(150.0)
+      end
+
+      it "raises Eodhd::Error on invalid JSON" do
+        test_consumer = ->(data){}
+        handler = Eodhd::WebSocketClient::Handler.new(symbols: 'AAPL', consumer: test_consumer, logger: nil)
+        
+        invalid_message = '{invalid json'
+        _{handler.on_message(nil, invalid_message)}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: eodhd.rb
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.17.0
 platform: ruby
 authors:
 - thoran
 bindir: bin
 cert_chain: []
-date: 2025-09-16 00:00:00.000000000 Z
+date: 2025-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http.rb
@@ -23,6 +23,104 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: iodine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-spec-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Access the eodhd.com API with Ruby.
 email: code@thoran.com
 executables: []
@@ -32,19 +130,27 @@ files:
 - Gemfile
 - README.md
 - eodhd.rb.gemspec
+- lib/Eodhd.rb
 - lib/Eodhd/Client.rb
+- lib/Eodhd/DefaultLogger.rb
 - lib/Eodhd/EodBulkLastDay.rb
 - lib/Eodhd/EodData.rb
 - lib/Eodhd/Error.rb
 - lib/Eodhd/Exchange.rb
 - lib/Eodhd/ExchangeSymbol.rb
+- lib/Eodhd/Intraday.rb
 - lib/Eodhd/VERSION.rb
 - lib/Eodhd/Validations.rb
 - lib/Eodhd/WebSocketClient.rb
 - lib/Hash/x_www_form_urlencode.rb
 - lib/Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode.rb
 - lib/Thoran/String/UrlEncode/url_encode.rb
-- lib/eodhd.rb
+- test/client_test.rb
+- test/eodhd_test.rb
+- test/helper.rb
+- test/test_all.rb
+- test/validations_test.rb
+- test/web_socket_client_test.rb
 homepage: http://github.com/thoran/eodhd.rb
 licenses:
 - Ruby