nse_data 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22de3ed7cc3399b101e16132f7be88dc775557eed246ab3d1f68973202acfe39
-  data.tar.gz: 708446fcffe3a854afced4693d795442eb115bcf975ff4564f17c50491cf93ef
+  metadata.gz: 21c958d7054c952556fa1e0bbb44141261a68ecab2e8d5248c559b54bf92150e
+  data.tar.gz: 1f3a1d07073957985cb97cc37174bdc1a247f1b50ee14e691c3bdd4df6e889f0
 SHA512:
-  metadata.gz: 8b7969d444c186b8aca15431be34c5024f835276f03a16d8fa4e201465c4ee84b5b38a08fba99fb57fb7a771b2b5ca95b4c63671f171685afcf152baec574cc7
-  data.tar.gz: 560ae057148dfefa964ad19f5c486c39f0e9862eeead183edd82a953af00661e2b0ce51af398d6e913faa875f83bcc17ee8da415eb9ebf755622daa86e41e460
+  metadata.gz: 0fa0f5c7860022322fa7df8f08048c64496227ddcaa45860610a0711ff9a4e24906220006dcb0690b0cdaf3d61dfd6228e5ab552262c218ba78d146a36af66f3
+  data.tar.gz: 965e60d16d87a3625803096ca3ebae37ad67b4fd02f5be8bc2024bc8fcb68a3ee83ab25e4efc35567f495972ee835eb680130e0359c12090f58bfabcc6898589

data/README.md

@@ -1,4 +1,6 @@
 # NseData
+[![Gem Version](https://badge.fury.io/rb/nse_data.svg)](https://badge.fury.io/rb/nse_data)
+
 ## Table of Contents
 - [NseData](#nsedata)
   - [Table of Contents](#table-of-contents)

data/lib/nse_data/config/api_endpoints.yml

@@ -1,3 +1,4 @@
+base_url: https://www.nseindia.com/api/
 apis:
   all_indices:
     path: "allIndices"

data/lib/nse_data/nse_api_client.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'api_wrapper'
+
+module NseData
+  # Handles API interactions with the NSE using ApiWrapper.
+  class NseApiClient
+    attr_reader :api_configuration_path, :cache_store
+
+    # Initializes with optional custom settings.
+    #
+    # @param api_configuration_path [String] Path to the API configuration file.
+    # @param cache_store [Object] Custom cache store for caching responses.
+    def initialize(api_configuration_path: nil, cache_store: nil)
+      @api_configuration_path = api_configuration_path || default_configuration_path
+      @cache_store = cache_store
+      configure_api_wrapper
+    end
+
+    # Fetches data from the specified API endpoint.
+    #
+    # @param endpoint_key [String] Key for the API endpoint.
+    # @param force_refresh [Boolean] Skip cache if true.
+    # @return [Hash, String] Response data or raises an error if unsuccessful.
+    def fetch_data(endpoint_key, force_refresh: false)
+      response = ApiWrapper.fetch_data(endpoint_key, force_refresh:)
+      handle_response(response)
+    end
+
+    # Returns all API endpoints available in the configuration.
+    #
+    # @return [Hash] List of endpoints.
+    def endpoints
+      @endpoints ||= ApiWrapper::ApiManager.new(api_configuration_path).endpoints
+    end
+
+    private
+
+    # Configures ApiWrapper with the provided settings.
+    def configure_api_wrapper
+      ApiWrapper.configure do |config|
+        config.api_configuration_path = api_configuration_path
+        config.cache_store = cache_store if cache_store
+      end
+    end
+
+    # Processes the API response.
+    #
+    # @param response [Faraday::Response] The API response.
+    # @return [Hash, String] Parsed response or error message.
+    def handle_response(response)
+      raise ApiError, "Error: #{response.status} - #{response.body}" unless response.success?
+
+      response.body
+    end
+
+    # Default path to the API configuration file.
+    def default_configuration_path
+      File.join(__dir__, 'config', 'api_endpoints.yml')
+    end
+  end
+
+  # Custom error class for handling API errors.
+  class ApiError < StandardError; end
+end

data/lib/nse_data/version.rb

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

data/lib/nse_data.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'nse_data/version'
-require_relative 'nse_data/api_manager'
-require_relative 'nse_data/config/logger'
+require_relative 'nse_data/nse_api_client'
 
 # The NseData module serves as the namespace for the NSE Data gem,
 # which provides an interface to interact with and retrieve stock market data
@@ -11,12 +10,16 @@ module NseData
   class Error < StandardError; end
 
   class << self
-    # This module provides functionality for accessing NSE data.
+    # Caches the instance of NseApiClient.
+    def nse_api_client
+      @nse_api_client ||= NseApiClient.new
+    end
+
+    # Dynamically define fetch methods for each API endpoint.
     def define_api_methods
-      api_manager = APIManager.new
-      api_manager.endpoints.each_key do |method_name|
-        define_singleton_method("fetch_#{method_name}") do
-          api_manager.fetch_data(method_name).body
+      nse_api_client.endpoints.each_key do |method_name|
+        define_singleton_method("fetch_#{method_name}") do |force_refresh: false|
+          nse_api_client.fetch_data(method_name, force_refresh:)
         end
       end
     end
@@ -25,41 +28,19 @@ module NseData
     #
     # @return [Array] An array of endpoint names.
     def list_all_endpoints
-      @list_all_endpoints ||= APIManager.new.load_endpoints
-    end
-
-    # Configure the logger for the NseData gem.
-    #
-    # This method allows users to customize the logger used throughout the library.
-    # To use it, call `NseData.configure` and provide a block to set up the logger.
-    #
-    # Example:
-    #
-    # NseData.configure do |config|
-    #   custom_logger = Logger.new('nse_data.log')
-    #   custom_logger.level = Logger::DEBUG
-    #   config.logger = custom_logger
-    # end
-    #
-    # @yieldparam [NseData::Config::Logger] config The configuration object to be customized.
-    def configure
-      @logger_config ||= Config::Logger.new
-      yield(@logger_config) if block_given?
+      nse_api_client.endpoints
     end
 
-    # Access the configured logger.
+    # Fetches data from a specific API endpoint.
     #
-    # This method returns the Logger instance configured through `NseData.configure`.
-    #
-    # @return [Logger] The configured Logger instance.
-    # @raise [RuntimeError] If the logger has not been configured.
-    def logger
-      @logger_config&.logger || (raise 'Logger not configured. Please call NseData.configure first.')
+    # @param endpoint [String] The endpoint key.
+    # @param force_refresh [Boolean] Skip cache if true.
+    # @return [Hash, String] The API response.
+    def fetch_data(endpoint, force_refresh: false)
+      nse_api_client.fetch_data(endpoint, force_refresh:)
     end
   end
 
-  # Initialize configuration with default settings.
-  @logger_config = Config::Logger.new
+  # Define API methods at runtime.
+  define_api_methods
 end
-
-NseData.define_api_methods

data/nse_data.gemspec

@@ -29,6 +29,5 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'faraday', '~> 2.11'
-  spec.add_dependency 'faraday-http-cache', '~> 2.5', '>= 2.5.1'
+  spec.add_dependency 'api_wrapper'
 end

metadata

@@ -1,49 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: nse_data
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Sonu Saha
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-10 00:00:00.000000000 Z
+date: 2024-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: api_wrapper
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.11'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.11'
-- !ruby/object:Gem::Dependency
-  name: faraday-http-cache
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: '0'
 description: Retrieves stock market data from the NSE (National Stock Exchange) of
   India
 email:
@@ -90,16 +70,8 @@ files:
 - doc/method_list.html
 - doc/top-level-namespace.html
 - lib/nse_data.rb
-- lib/nse_data/api_manager.rb
-- lib/nse_data/cache/README.md
-- lib/nse_data/cache/cache_policy.rb
-- lib/nse_data/cache/cache_store.rb
-- lib/nse_data/cache/redis_cache_store.rb
 - lib/nse_data/config/api_endpoints.yml
-- lib/nse_data/config/base.rb
-- lib/nse_data/config/logger.rb
-- lib/nse_data/http_client/base_client.rb
-- lib/nse_data/http_client/faraday_client.rb
+- lib/nse_data/nse_api_client.rb
 - lib/nse_data/version.rb
 - nse_data.gemspec
 homepage: https://github.com/ahasunos/nse_data

data/lib/nse_data/api_manager.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require_relative 'http_client/faraday_client'
-require_relative 'cache/cache_policy'
-require_relative 'cache/cache_store'
-
-module NseData
-  # APIManager class to handle API calls to NSE (National Stock Exchange) India website.
-  class APIManager
-    BASE_URL = 'https://www.nseindia.com/api/'
-
-    # Initializes a new instance of the APIManager class.
-    #
-    # @param cache_store [CacheStore, RedisCacheStore, nil] The cache store to use for caching.
-    # If nil, in-memory cache is used.
-    def initialize(cache_store: nil)
-      # Initialize cache policy with the provided cache store or default to in-memory cache.
-      @cache_policy = NseData::Cache::CachePolicy.new(cache_store || NseData::Cache::CacheStore.new)
-
-      # Configure cache policy (e.g., setting endpoints with no cache or custom TTL).
-      configure_cache_policy
-
-      # Initialize Faraday client with the base URL and cache policy.
-      @client = NseData::HttpClient::FaradayClient.new(BASE_URL, @cache_policy)
-
-      # Load API endpoints from the configuration file.
-      @endpoints = load_endpoints
-    end
-
-    # Fetches data from the specified API endpoint.
-    #
-    # @param endpoint_key [String] The key of the API endpoint to fetch data from.
-    # @param force_refresh [Boolean] Whether to force refresh the data, bypassing the cache.
-    # @return [Faraday::Response] The response object containing the fetched data.
-    # @raise [ArgumentError] If the provided endpoint key is invalid.
-    def fetch_data(endpoint_key, force_refresh: false)
-      NseData.logger.debug("#{self.class}##{__method__}: fetching data for #{endpoint_key}")
-      endpoint = @endpoints[endpoint_key]
-      raise ArgumentError, "Invalid endpoint key: #{endpoint_key}" unless endpoint
-
-      # Use cache policy to fetch data, with an option to force refresh.
-      @cache_policy.fetch(endpoint['path'], force_refresh:) do
-        @client.get(endpoint['path'])
-      end
-    end
-
-    # Loads the API endpoints from the configuration file.
-    #
-    # @return [Hash] The hash containing the loaded API endpoints.
-    # @raise [RuntimeError] If the configuration file is missing or has syntax errors.
-    def load_endpoints
-      yaml_content = YAML.load_file(File.expand_path('config/api_endpoints.yml', __dir__))
-      yaml_content['apis']
-    rescue Errno::ENOENT => e
-      raise "Configuration file not found: #{e.message}"
-    rescue Psych::SyntaxError => e
-      raise "YAML syntax error: #{e.message}"
-    end
-
-    # @return [Hash] The hash containing the loaded API endpoints.
-    attr_reader :endpoints
-
-    private
-
-    # Configures the cache policy with specific settings.
-    #
-    # This method sets endpoints that should not be cached and custom TTL values for specific endpoints.
-    def configure_cache_policy
-      # TODO: Review and refine cache policy for endpoints.
-      # Plan to analyze the API responses and categorize endpoints into:
-      # - No cache
-      # - Cacheable
-      # - Custom TTL
-
-      # Set specific endpoints that should not be cached.
-      @cache_policy.add_no_cache_endpoint('market_status')
-
-      # Set custom TTL (time-to-live) for specific endpoints.
-      @cache_policy.add_custom_ttl('equity_master', 600) # Custom TTL: 10 mins
-    end
-  end
-end

data/lib/nse_data/cache/README.md

@@ -1,77 +0,0 @@
-# Caching Mechanism Usage and Customization
-
-## Overview
-
-The **NseData** gem includes a flexible caching mechanism to improve performance and reduce redundant API calls. This documentation provides an overview of how to use and customize the caching mechanism.
-
-## Cache Policy
-
-The `CachePolicy` class is responsible for managing caching behavior, including setting global TTLs, custom TTLs for specific endpoints, and controlling which endpoints should bypass the cache.
-
-### Initializing CachePolicy
-
-To use caching, you need to initialize the `CachePolicy` with a cache store and optional global TTL:
-
-```ruby
-require 'nse_data/cache/cache_policy'
-require 'nse_data/cache/cache_store'
-
-# Initialize the cache store (e.g., in-memory cache store)
-cache_store = NseData::Cache::CacheStore.new
-
-# Initialize the CachePolicy with the cache store and a global TTL of 300 seconds (5 minutes)
-cache_policy = NseData::Cache::CachePolicy.new(cache_store, global_ttl: 300)
-```
-
-### Configuring Cache Policy
-#### Adding No-Cache Endpoints
-You can specify endpoints that should bypass the cache:
-```ruby
-# Add an endpoint to the no-cache list
-cache_policy.add_no_cache_endpoint('/no-cache')
-```
-
-#### Adding Custom TTLs
-You can define custom TTLs for specific endpoints:
-
-```ruby
-# Set a custom TTL of 600 seconds (10 minutes) for a specific endpoint
-cache_policy.add_custom_ttl('/custom-ttl', ttl: 600)
-```
-
-#### Fetching Data with Cache
-Use the fetch method to retrieve data with caching applied:
-
-```ruby
-# Fetch data for an endpoint with optional cache
-data = cache_policy.fetch('/some-endpoint') do
-  # The block should fetch fresh data if cache is not used or is stale
-  # e.g., perform an API call or other data retrieval operation
-  Faraday::Response.new(body: 'fresh data')
-end
-```
-## Custom Cache Stores
-You can extend the caching mechanism to support different types of cache stores. Implement a custom cache store by inheriting from the CacheStore base class and overriding the read and write methods.
-
-### Example Custom Cache Store
-```ruby
-class CustomCacheStore < NseData::Cache::CacheStore
-  def read(key)
-    # Implement custom read logic
-  end
-
-  def write(key, value, ttl)
-    # Implement custom write logic
-  end
-end
-```
-### Using a Custom Cache Store
-To use a custom cache store, initialize CachePolicy with an instance of your custom cache store:
-
-```ruby
-# Initialize the custom cache store
-custom_cache_store = CustomCacheStore.new
-
-# Initialize CachePolicy with the custom cache store
-cache_policy = NseData::Cache::CachePolicy.new(custom_cache_store, global_ttl: 300)
-```

data/lib/nse_data/cache/cache_policy.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module NseData
-  module Cache
-    # CachePolicy manages caching behavior, including cache storage and time-to-live (TTL) settings.
-    #
-    # It allows setting global TTLs, custom TTLs for specific endpoints, and controlling which
-    # endpoints should not use the cache.
-    #
-    # @attr_reader [CacheStore] cache_store The cache store used for storing cached data.
-    class CachePolicy
-      attr_reader :cache_store
-
-      # Initializes the CachePolicy with a cache store and global TTL.
-      #
-      # @param cache_store [CacheStore, RedisCacheStore] The cache store to use for caching.
-      # @param global_ttl [Integer] The default TTL (in seconds) for caching.
-      def initialize(cache_store, global_ttl = 300)
-        @cache_store = cache_store
-        @global_ttl = global_ttl
-        @custom_ttls = {}
-        @no_cache_endpoints = []
-      end
-
-      # Adds an endpoint that should bypass the cache.
-      #
-      # @param endpoint [String] The endpoint to exclude from caching.
-      def add_no_cache_endpoint(endpoint)
-        @no_cache_endpoints << endpoint
-      end
-
-      # Adds a custom TTL for a specific endpoint.
-      #
-      # @param endpoint [String] The endpoint to apply a custom TTL to.
-      # @param ttl [Integer] The custom TTL value in seconds.
-      def add_custom_ttl(endpoint, ttl = 300)
-        @custom_ttls[endpoint] = ttl
-      end
-
-      # Returns the TTL for a specific endpoint. Defaults to the global TTL if no custom TTL is set.
-      #
-      # @param endpoint [String] The endpoint to fetch the TTL for.
-      # @return [Integer] The TTL in seconds.
-      def ttl_for(endpoint)
-        @custom_ttls.fetch(endpoint, @global_ttl)
-      end
-
-      # Determines if caching should be used for the given endpoint.
-      #
-      # @param endpoint [String] The endpoint to check.
-      # @return [Boolean] True if caching is enabled for the endpoint, false otherwise.
-      def use_cache?(endpoint)
-        !@no_cache_endpoints.include?(endpoint)
-      end
-
-      # Fetches the data for the given endpoint, using cache if applicable.
-      #
-      # @param endpoint [String] The endpoint to fetch data for.
-      # @param force_refresh [Boolean] Whether to force refresh the data, bypassing the cache.
-      # @yield The block that fetches fresh data if cache is not used or is stale.
-      # @return [Object] The data fetched from cache or fresh data.
-      def fetch(endpoint, force_refresh: false, &block)
-        if force_refresh || !use_cache?(endpoint)
-          fetch_fresh_data(endpoint, &block)
-        else
-          fetch_cached_or_fresh_data(endpoint, &block)
-        end
-      end
-
-      private
-
-      # Fetches fresh data and writes it to the cache if applicable.
-      #
-      # @param endpoint [String] The endpoint to fetch fresh data for.
-      # @yield The block that fetches fresh data.
-      # @return [Object] The fresh data.
-      def fetch_fresh_data(endpoint)
-        NseData.logger.debug("#{self.class}##{__method__}: fetching fresh data for #{endpoint}")
-
-        fresh_data = yield
-        cache_fresh_data(endpoint, fresh_data)
-        fresh_data
-      end
-
-      # Fetches cached data or fresh data if not available in the cache.
-      #
-      # @param endpoint [String] The endpoint to fetch data for.
-      # @yield The block that fetches fresh data if cache is not used or is stale.
-      # @return [Object] The cached or fresh data.
-      def fetch_cached_or_fresh_data(endpoint, &block)
-        cached_data = @cache_store.read(endpoint)
-        if cached_data
-          NseData.logger.debug("#{self.class}##{__method__}: fetching cached data for #{endpoint}")
-          Faraday::Response.new(body: cached_data)
-        else
-          fetch_fresh_data(endpoint, &block)
-        end
-      end
-
-      # Writes fresh data to the cache.
-      #
-      # @param endpoint [String] The endpoint for which to store the data.
-      # @param fresh_data [Object] The data to be stored in the cache.
-      def cache_fresh_data(endpoint, fresh_data)
-        ttl = determine_ttl(endpoint)
-        @cache_store.write(endpoint, fresh_data.body, ttl) if fresh_data.is_a?(Faraday::Response)
-      end
-
-      # Determines the TTL value for the given endpoint.
-      #
-      # @param endpoint [String] The endpoint to fetch the TTL for.
-      # @return [Integer] The TTL value in seconds.
-      def determine_ttl(endpoint)
-        @custom_ttls.fetch(endpoint, @global_ttl)
-      end
-    end
-  end
-end

data/lib/nse_data/cache/cache_store.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module NseData
-  module Cache
-    # CacheStore class provides an in-memory caching mechanism.
-    class CacheStore
-      def initialize
-        @store = {}
-      end
-
-      # Retrieves the cached data for the given key, or fetches fresh data if not cached or expired.
-      #
-      # @param key [String] The cache key.
-      # @param ttl [Integer] The time-to-live in seconds.
-      # @yield Fetches fresh data if cache is expired or not present.
-      # @return [Object] The cached data or the result of the block if not cached or expired.
-      def fetch(key, ttl)
-        if cached?(key, ttl)
-          @store[key][:data]
-        else
-          fresh_data = yield
-          store(key, fresh_data, ttl)
-          fresh_data
-        end
-      end
-
-      # Reads data from the cache.
-      #
-      # @param key [String] The cache key.
-      # @return [Object, nil] The cached data, or nil if not present.
-      def read(key)
-        cached?(key) ? @store[key][:data] : nil
-      end
-
-      # Writes data to the cache with an expiration time.
-      #
-      # @param key [String] The cache key.
-      # @param data [Object] The data to cache.
-      # @param ttl [Integer] The time-to-live in seconds.
-      def write(key, data, ttl)
-        store(key, data, ttl)
-      end
-
-      # Deletes data from the cache.
-      #
-      # @param key [String] The cache key.
-      def delete(key)
-        @store.delete(key)
-      end
-
-      private
-
-      # Checks if the data for the given key is cached and not expired.
-      #
-      # @param key [String] The cache key.
-      # @param ttl [Integer] The time-to-live in seconds.
-      # @return [Boolean] Whether the data is cached and valid.
-      def cached?(key, ttl = nil)
-        return false unless @store.key?(key)
-
-        !expired?(key, ttl)
-      end
-
-      # Checks if the cached data for the given key has expired.
-      #
-      # @param key [String] The cache key.
-      # @param ttl [Integer] The time-to-live in seconds.
-      # @return [Boolean] Whether the cached data has expired.
-      def expired?(key, ttl)
-        stored_time = @store[key][:timestamp]
-        ttl && (Time.now - stored_time) >= ttl
-      end
-
-      # Stores the data in the cache.
-      #
-      # @param key [String] The cache key.
-      # @param data [Object] The data to cache.
-      # @param ttl [Integer] The time-to-live in seconds.
-      def store(key, data, ttl)
-        @store[key] = { data:, timestamp: Time.now, ttl: }
-      end
-    end
-  end
-end

data/lib/nse_data/cache/redis_cache_store.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-# TODO: Implement in near future :)

data/lib/nse_data/config/base.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module NseData
-  module Config
-    # Base serves as the base class for configuration settings.
-    #
-    # It allows for storing and accessing various configuration settings
-    # through a hash-like interface.
-    #
-    # @attr_reader [Hash] settings The hash storing configuration settings.
-    class Base
-      attr_reader :settings
-
-      # Initializes the Base with optional initial settings.
-      #
-      # @param initial_settings [Hash] Optional hash of initial settings.
-      def initialize(initial_settings = {})
-        @settings = initial_settings
-      end
-
-      # Retrieves a configuration setting by key.
-      #
-      # @param key [Symbol, String] The key for the setting.
-      # @return [Object] The value associated with the key.
-      def [](key)
-        @settings[key]
-      end
-
-      # Sets a configuration setting by key.
-      #
-      # @param key [Symbol, String] The key for the setting.
-      # @param value [Object] The value to set for the key.
-      def []=(key, value)
-        @settings[key] = value
-      end
-    end
-  end
-end

data/lib/nse_data/config/logger.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-require 'tempfile'
-require_relative 'base'
-
-module NseData
-  module Config
-    # Logger handles configuration specifically for logging.
-    #
-    # It inherits from Base to utilize the hash-like configuration
-    # interface and provides default settings for logging.
-    #
-    # @attr_reader [Logger] logger The Logger instance configured by this class.
-    class Logger < Base
-      # Creates a default temporary log file.
-      def self.default_log_file
-        return $stdout if ENV['NSE_DEV']
-
-        temp_file = Tempfile.new(['nse_data', '.log'])
-        temp_file.close # Close the file immediately after creation
-        temp_file.path # Return the file path for the Logger
-      end
-
-      # Initializes the Logger with a default or custom Logger instance.
-      #
-      # @param logger [Logger] Optional custom Logger instance.
-      def initialize(logger = ::Logger.new(self.class.default_log_file))
-        super()
-        @logger = logger
-        @settings[:logger] = logger
-        # puts "Log file created at: #{self.class.default_log_file}"
-      end
-
-      # Retrieves/Sets the Logger instance.
-      attr_accessor :logger
-    end
-  end
-end

data/lib/nse_data/http_client/base_client.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module NseData
-  module HttpClient
-    # Base class for HTTP clients
-    class BaseClient
-      # Initializes a new instance of the BaseClient class.
-      #
-      # @param base_url [String] The base URL for the HTTP client.
-      def initialize(base_url, cache_policy)
-        @base_url = base_url
-        @cache_policy = cache_policy
-      end
-
-      # Sends a GET request to the specified endpoint.
-      #
-      # @param endpoint [String] The endpoint to send the GET request to.
-      # @raise [NotImplementedError] If the method is not implemented by subclasses.
-      def get(endpoint)
-        raise NotImplementedError, 'Subclasses must implement the get method'
-      end
-
-      # TODO: Other HTTP methods like post, put, delete can be added here if needed
-    end
-  end
-end

data/lib/nse_data/http_client/faraday_client.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'faraday-http-cache'
-require 'json'
-require_relative 'base_client'
-
-module NseData
-  module HttpClient
-    # FaradayClient class is responsible for making HTTP requests using Faraday.
-    class FaradayClient < BaseClient
-      # Sends a GET request to the specified endpoint.
-      #
-      # @param endpoint [String] The endpoint to send the request to.
-      # @param force_refresh [Boolean] Whether to force a cache refresh.
-      # @return [Faraday::Response] The response object.
-      def get(endpoint, force_refresh: false)
-        NseData.logger.debug("#{self.class}##{__method__}: invoking the endpoint #{endpoint}")
-        # Use the cache policy to determine whether to fetch from cache or refresh.
-        @cache_policy.fetch(endpoint, force_refresh:) do
-          handle_connection(endpoint) do |connection|
-            connection.get(endpoint)
-          end
-        end
-      end
-
-      private
-
-      # Handles the connection to the base URL.
-      #
-      # @yield [connection] The Faraday connection object.
-      # @yieldparam connection [Faraday::Connection] The Faraday connection object.
-      # @return [Object] The result of the block execution.
-      # @raise [Faraday::Error] If there is an error with the connection.
-      def handle_connection(endpoint)
-        connection = build_faraday_connection(endpoint)
-        yield(connection)
-      rescue Faraday::Error => e
-        NseData.logger.error("#{self.class}##{__method__}: exception is raised - #{e.message}")
-        handle_faraday_error(e)
-      end
-
-      def build_faraday_connection(endpoint)
-        Faraday.new(url: @base_url) do |faraday|
-          configure_faraday(faraday)
-          apply_cache_policy(faraday, endpoint) if @cache_policy.use_cache?(endpoint)
-          faraday.adapter Faraday.default_adapter
-        end
-      end
-
-      def configure_faraday(faraday)
-        faraday.request :json
-        faraday.headers['User-Agent'] = 'NSEDataClient/1.0'
-        faraday.response :json
-        faraday.headers['Accept'] = 'application/json'
-      end
-
-      def apply_cache_policy(faraday, endpoint)
-        ttl = @cache_policy.ttl_for(endpoint)
-        faraday.use :http_cache, store: @cache_policy.cache_store, expire_after: ttl
-      end
-
-      def handle_faraday_error(error)
-        raise error.message
-      end
-    end
-  end
-end