metal_archives 2.2.3 → 3.2.0

data/lib/metal_archives.rb

@@ -1,33 +1,49 @@
 # frozen_string_literal: true
 
-require "openssl"
-
 require "zeitwerk"
-loader = Zeitwerk::Loader.for_gem
-load.enable_reloading if ENV["METAL_ARCHIVES_ENV"] == "development"
-loader.inflector.inflect(
-  "id" => "ID",
-  "api" => "API",
-  "http_client" => "HTTPClient",
-  "lru_cache" => "LRUCache"
-)
-loader.collapse("lib/metal_archives/models")
-loader.setup
+require "byebug" if ENV["METAL_ARCHIVES_ENV"] == "development"
+require "active_support/all"
 
 ##
 # Metal Archives Ruby API
 #
 module MetalArchives
   class << self
+    # Code loader instance
+    attr_reader :loader
+
+    ##
+    # Root path
+    #
+    def root
+      @root ||= Pathname.new(File.expand_path(File.join("..", ".."), __FILE__))
+    end
+
+    ##
+    # HTTP client
+    #
+    def http
+      @http ||= HTTPClient.new
+    end
+
     ##
     # API configuration
     #
     # Instance of rdoc-ref:MetalArchives::Configuration
     #
     def config
-      raise MetalArchives::Errors::InvalidConfigurationError, "Gem has not been configured" unless @config
+      @config ||= Configuration.new
+    end
 
-      @config
+    ##
+    # Cache instance
+    #
+    def cache
+      raise MetalArchives::Errors::InvalidConfigurationError, "cache has not been configured" unless config.cache_strategy
+
+      @cache ||= Cache
+        .const_get(loader.inflector.camelize(config.cache_strategy, root))
+        .new(config.cache_options)
     end
 
     ##
@@ -40,17 +56,37 @@ module MetalArchives
     # - rdoc-ref:InvalidConfigurationException
     #
     def configure
-      raise MetalArchives::Errors::InvalidConfigurationError, "No configuration block given" unless block_given?
+      raise Errors::InvalidConfigurationError, "no configuration block given" unless block_given?
 
-      @config = MetalArchives::Configuration.new
-      yield @config
+      yield config
 
-      raise MetalArchives::Errors::InvalidConfigurationError, "app_name has not been configured" unless MetalArchives.config.app_name && !MetalArchives.config.app_name.empty?
-      raise MetalArchives::Errors::InvalidConfigurationError, "app_version has not been configured" unless MetalArchives.config.app_version && !MetalArchives.config.app_version.empty?
+      config.validate!
+    end
 
-      return if MetalArchives.config.app_contact && !MetalArchives.config.app_contact.empty?
+    ##
+    # Set up application framework
+    #
+    def setup
+      @loader = Zeitwerk::Loader.for_gem
 
-      raise MetalArchives::Errors::InvalidConfigurationError, "app_contact has not been configured"
+      # Register inflections
+      require root.join("config/inflections.rb")
+
+      # Set up code loader
+      loader.enable_reloading if ENV["METAL_ARCHIVES_ENV"] == "development"
+      loader.collapse(root.join("lib/metal_archives/models"))
+      loader.do_not_eager_load(root.join("lib/metal_archives/cache"))
+      loader.setup
+      loader.eager_load
+
+      # Load initializers
+      Dir[root.join("config/initializers/*.rb")].sort.each { |f| require f }
     end
   end
 end
+
+def reload!
+  MetalArchives.loader.reload
+end
+
+MetalArchives.setup

data/lib/metal_archives/cache/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Cache
+    ##
+    # Generic cache interface
+    #
+    class Base
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+
+        validate!
+      end
+
+      def validate!; end
+
+      def []
+        raise NotImplementedError
+      end
+
+      def []=(_key, _value)
+        raise NotImplementedError
+      end
+
+      def clear
+        raise NotImplementedError
+      end
+
+      def include?(_key)
+        raise NotImplementedError
+      end
+
+      def delete(_key)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/metal_archives/cache/memory.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Cache
+    ##
+    # Generic LRU memory cache
+    #
+    class Memory < Base
+      def validate!
+        raise Errors::InvalidConfigurationError, "size has not been configured" if options[:size].blank?
+        raise Errors::InvalidConfigurationError, "size must be a number" unless options[:size].is_a? Integer
+      end
+
+      def [](key)
+        if keys.include? key
+          MetalArchives.config.logger.debug "Cache hit for #{key}"
+          keys.delete key
+          keys << key
+        else
+          MetalArchives.config.logger.debug "Cache miss for #{key}"
+        end
+
+        cache[key]
+      end
+
+      def []=(key, value)
+        cache[key] = value
+
+        keys.delete key if keys.include? key
+
+        keys << key
+
+        pop if keys.size > options[:size]
+      end
+
+      def clear
+        cache.clear
+        keys.clear
+      end
+
+      def include?(key)
+        cache.include? key
+      end
+
+      def delete(key)
+        cache.delete key
+      end
+
+      private
+
+      def cache
+        # Underlying data store
+        @cache ||= {}
+      end
+
+      def keys
+        # Array of keys in order of insertion
+        @keys ||= []
+      end
+
+      def pop
+        to_remove = keys.shift(keys.size - options[:size])
+
+        to_remove.each { |key| cache.delete key }
+      end
+    end
+  end
+end

data/lib/metal_archives/cache/null.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Cache
+    ##
+    # Null cache
+    #
+    class Null < Base
+      def [](_key); end
+
+      def []=(_key, _value); end
+
+      def clear; end
+
+      def include?(_key)
+        false
+      end
+
+      def delete(_key); end
+    end
+  end
+end

data/lib/metal_archives/cache/redis.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "redis"
+
+module MetalArchives
+  module Cache
+    ##
+    # Redis-backed cache
+    #
+    class Redis < Base
+      def initialize(options = {})
+        super
+
+        # Default TTL is 1 month
+        options[:ttl] ||= (30 * 24 * 60 * 60)
+      end
+
+      def [](key)
+        redis.get cache_key_for(key)
+      end
+
+      def []=(key, value)
+        redis.set cache_key_for(key), value, ex: options[:ttl]
+      end
+
+      def clear
+        redis.keys(cache_key_for("*")).each { |key| redis.del key }
+      end
+
+      def include?(key)
+        redis.exists? cache_key_for(key)
+      end
+
+      def delete(key)
+        redis.del cache_key_for(key)
+      end
+
+      private
+
+      def cache_key_for(key)
+        "metal_archives.cache.#{key}"
+      end
+
+      def redis
+        @redis ||= ::Redis.new(**options.except(:ttl))
+      end
+    end
+  end
+end

data/lib/metal_archives/collection.rb

@@ -22,15 +22,13 @@ module MetalArchives
     # Calls the given block once for each element, passing that element as a parameter.
     # If no block is given, an Enumerator is returned.
     #
-    def each
-      return to_enum :each unless block_given?
+    def each(&block)
+      return to_enum :each unless block
 
       loop do
         items = instance_exec(&@proc)
 
-        items.each do |item|
-          yield item
-        end
+        items.each(&block)
 
         break if items.empty?
       end

data/lib/metal_archives/configuration.rb

@@ -3,6 +3,8 @@
 require "logger"
 
 module MetalArchives
+  CACHE_STRATEGIES = %w(memory redis).freeze
+
   ##
   # Contains configuration options
   #
@@ -23,10 +25,9 @@ module MetalArchives
     attr_accessor :app_contact
 
     ##
-    # Override Metal Archives endpoint (defaults to http://www.metal-archives.com/)
+    # Override Metal Archives endpoint (defaults to https://www.metal-archives.com/)
     #
     attr_accessor :endpoint
-    attr_reader :default_endpoint
 
     ##
     # Endpoint HTTP Basic authentication
@@ -35,39 +36,45 @@ module MetalArchives
     attr_accessor :endpoint_password
 
     ##
-    # Additional Faraday middleware
+    # Logger instance
     #
-    attr_accessor :middleware
+    attr_accessor :logger
 
     ##
-    # Request throttling rate (in seconds per request per path)
+    # Cache strategy
     #
-    attr_accessor :request_rate
+    attr_accessor :cache_strategy
 
     ##
-    # Request timeout (in seconds per request per path)
+    # Cache strategy options
     #
-    attr_accessor :request_timeout
+    attr_accessor :cache_options
 
     ##
-    # Logger instance
+    # Default configuration values
     #
-    attr_accessor :logger
+    def initialize(**attributes)
+      attributes.each { |key, value| send(:"#{key}=", value) }
 
-    ##
-    # Cache size (per object class)
-    #
-    attr_accessor :cache_size
+      @endpoint ||= "https://www.metal-archives.com/"
+      @logger ||= Logger.new $stdout
+
+      @cache_strategy ||= "memory"
+      @cache_options ||= { size: 100 }
+    end
 
     ##
-    # Default configuration values
+    # Validate configuration
+    #
+    # [Raises]
+    # - rdoc-ref:MetalArchives::Errors::ConfigurationError when configuration is invalid
     #
-    def initialize
-      @default_endpoint = "https://www.metal-archives.com/"
-      @throttle_rate = 1
-      @throttle_wait = 3
-      @logger = Logger.new STDOUT
-      @cache_size = 100
+    def validate!
+      raise Errors::InvalidConfigurationError, "app_name has not been configured" if app_name.blank?
+      raise Errors::InvalidConfigurationError, "app_version has not been configured" if app_version.blank?
+      raise Errors::InvalidConfigurationError, "app_contact has not been configured" if app_contact.blank?
+      raise Errors::InvalidConfigurationError, "cache_strategy has not been configured" if cache_strategy.blank?
+      raise Errors::InvalidConfigurationError, "cache_strategy must be one of: #{CACHE_STRATEGIES.join(', ')}" if CACHE_STRATEGIES.exclude?(cache_strategy.to_s)
     end
   end
 end

data/lib/metal_archives/errors.rb

@@ -32,7 +32,15 @@ module MetalArchives
     ##
     # Error in backend response
     #
-    class APIError < Error; end
+    class APIError < Error
+      attr_reader :code
+
+      def initialize(response)
+        super("#{response.reason}: #{response.body}")
+
+        @code = response.code
+      end
+    end
 
     ##
     # Error in method argument

data/lib/metal_archives/http_client.rb

@@ -1,66 +1,62 @@
 # frozen_string_literal: true
 
-require "faraday"
-require "faraday_throttler"
+require "http"
 
 module MetalArchives
   ##
-  # HTTP request client
+  # Generic HTTP client
   #
-  class HTTPClient # :nodoc:
-    class << self
-      ##
-      # Retrieve a HTTP resource
-      #
-      # [Raises]
-      # - rdoc-ref:MetalArchives::Errors::InvalidIDError when receiving a status code == 404n
-      # - rdoc-ref:MetalArchives::Errors::APIError when receiving a status code >= 400 (except 404)
-      #
-      def get(*params)
-        response = client.get(*params)
+  class HTTPClient
+    attr_reader :endpoint, :metrics
 
-        raise Errors::InvalidIDError, response.status if response.status == 404
-        raise Errors::APIError, response.status if response.status >= 400
+    def initialize(endpoint = MetalArchives.config.endpoint)
+      @endpoint = endpoint
+      @metrics = { hit: 0, miss: 0 }
+    end
 
-        response
-      rescue Faraday::ClientError => e
-        MetalArchives.config.logger.error e.response
-        raise Errors::APIError, e
-      end
+    def get(path, params = {})
+      response = http
+        .get(url_for(path), params: params)
 
-      private
+      # Log cache status
+      status = response.headers["x-cache-status"]&.downcase&.to_sym
+      MetalArchives.config.logger.info "Cache #{status} for #{path}" if status
 
-      ##
-      # Retrieve a HTTP client
-      #
-      #
-      def client
-        raise Errors::InvalidConfigurationError, "Not configured yet" unless MetalArchives.config
+      case status
+      when :hit
+        metrics[:hit] += 1
+      when :miss, :bypass, :expired, :stale, :updating, :revalidated
+        metrics[:miss] += 1
+      end
+      raise Errors::InvalidIDError, response if response.code == 404
+      raise Errors::APIError, response unless response.status.success?
 
-        @faraday ||= Faraday.new do |f|
-          f.request   :url_encoded # form-encode POST params
-          f.response  :logger, MetalArchives.config.logger
+      response
+    end
 
-          f.use       MetalArchives::Middleware::Headers
-          f.use       MetalArchives::Middleware::CacheCheck
-          f.use       MetalArchives::Middleware::RewriteEndpoint
-          f.use       MetalArchives::Middleware::Encoding
+    private
 
-          MetalArchives.config.middleware&.each { |m| f.use m }
+    def http
+      @http ||= HTTP
+        .headers(headers)
+        .use(logging: { logger: MetalArchives.config.logger })
+        .encoding("utf-8")
 
-          f.use       :throttler,
-                      rate: MetalArchives.config.request_rate,
-                      wait: MetalArchives.config.request_timeout,
-                      logger: MetalArchives.config.logger
+      return @http unless MetalArchives.config.endpoint_user && MetalArchives.config.endpoint_password
 
-          f.adapter   Faraday.default_adapter
+      @http
+        .basic_auth(user: MetalArchives.config.endpoint_user, pass: MetalArchives.config.endpoint_password)
+    end
 
-          next unless MetalArchives.config.endpoint_user
+    def headers
+      {
+        user_agent: "#{MetalArchives.config.app_name}/#{MetalArchives.config.app_version} (#{MetalArchives.config.app_contact})",
+        accept: "application/json",
+      }
+    end
 
-          f.basic_auth MetalArchives.config.endpoint_user,
-                       MetalArchives.config.endpoint_password
-        end
-      end
+    def url_for(path)
+      "#{endpoint}#{path}"
     end
   end
 end