metal_archives 2.2.0 → 3.1.1

data/Rakefile

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'rake'
-require 'rake/testtask'
+require "rake"
+require "rake/testtask"
+require "zeitwerk"
 
 Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/*/*_test.rb']
+  t.libs << "test"
+  t.test_files = FileList["test/*/*_test.rb"]
   t.verbose = true
 end
 
-require 'rdoc/task'
+require "rdoc/task"
 RDoc::Task.new do |rdoc|
-  rdoc.main = 'README.md'
-  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
 end

data/bin/console

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "logger"
+
+require "bundler/setup"
+require "metal_archives"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+MetalArchives.configure do |c|
+  ## Application identity (required)
+  c.app_name = "My App"
+  c.app_version = "1.0"
+  c.app_contact = "support@mymusicapp.com"
+
+  ## Enable Redis as caching backend (optional, overrides default memory cache)
+  ## Available cache strategies: :memory, :redis or :null (disable caching)
+  # c.cache_strategy = :redis
+  # c.cache_options = { url: "redis://redis:6379", ttl: 1.month.to_i }
+
+  ## Metal Archives endpoint (optional, overrides default)
+  c.endpoint = ENV["MA_ENDPOINT"] if ENV["MA_ENDPOINT"]
+  c.endpoint_user = ENV["MA_ENDPOINT_USER"] if ENV["MA_ENDPOINT_USER"]
+  c.endpoint_password = ENV["MA_ENDPOINT_PASSWORD"] if ENV["MA_ENDPOINT_PASSWORD"]
+
+  ## Custom logger (optional)
+  c.logger = Logger.new $stdout
+  c.logger.level = Logger::WARN
+end
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/inflections.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+MetalArchives.loader.inflector.inflect(
+  "id" => "ID",
+  "http_client" => "HTTPClient",
+  "lru_cache" => "LRUCache",
+)

data/docker-compose.yml

@@ -0,0 +1,23 @@
+version: "3.7"
+
+services:
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "0.0.0.0:8080:80"
+    volumes:
+      - ./nginx/:/etc/nginx/conf.d/
+      - nginx:/cache/
+    restart: always
+
+  redis:
+    image: redis:alpine
+    ports:
+      - "0.0.0.0:6379:6379"
+    volumes:
+      - redis:/data/
+    restart: always
+
+volumes:
+  nginx:
+  redis:

data/lib/metal_archives.rb

@@ -1,37 +1,92 @@
 # frozen_string_literal: true
 
-require 'openssl'
+require "zeitwerk"
+require "byebug" if ENV["METAL_ARCHIVES_ENV"] == "development"
+require "active_support/all"
 
-require 'metal_archives/middleware/headers'
-require 'metal_archives/middleware/cache_check'
-require 'metal_archives/middleware/rewrite_endpoint'
-require 'metal_archives/middleware/encoding'
+##
+# Metal Archives Ruby API
+#
+module MetalArchives
+  class << self
+    # Code loader instance
+    attr_reader :loader
 
-require 'metal_archives/version'
-require 'metal_archives/configuration'
-require 'metal_archives/error'
+    ##
+    # Root path
+    #
+    def root
+      @root ||= Pathname.new(File.expand_path(File.join("..", ".."), __FILE__))
+    end
 
-require 'metal_archives/utils/range'
-require 'metal_archives/utils/collection'
-require 'metal_archives/utils/lru_cache'
-require 'metal_archives/utils/nil_date'
+    ##
+    # HTTP client
+    #
+    def http
+      @http ||= HTTPClient.new
+    end
 
-require 'metal_archives/models/base_model'
-require 'metal_archives/models/label'
-require 'metal_archives/models/artist'
-require 'metal_archives/models/band'
-require 'metal_archives/models/release'
+    ##
+    # API configuration
+    #
+    # Instance of rdoc-ref:MetalArchives::Configuration
+    #
+    def config
+      @config ||= Configuration.new
+    end
 
-require 'metal_archives/parsers/parser'
-require 'metal_archives/parsers/label'
-require 'metal_archives/parsers/artist'
-require 'metal_archives/parsers/band'
-require 'metal_archives/parsers/release'
+    ##
+    # Cache instance
+    #
+    def cache
+      raise MetalArchives::Errors::InvalidConfigurationError, "cache has not been configured" unless config.cache_strategy
 
-require 'metal_archives/http_client'
+      @cache ||= Cache
+        .const_get(loader.inflector.camelize(config.cache_strategy, root))
+        .new(config.cache_options)
+    end
 
-##
-# Metal Archives Ruby API
-#
-module MetalArchives
+    ##
+    # Configure API options.
+    #
+    # A block must be specified, to which a
+    # rdoc-ref:MetalArchives::Configuration parameter will be passed.
+    #
+    # [Raises]
+    # - rdoc-ref:InvalidConfigurationException
+    #
+    def configure
+      raise Errors::InvalidConfigurationError, "no configuration block given" unless block_given?
+
+      yield config
+
+      config.validate!
+    end
+
+    ##
+    # Set up application framework
+    #
+    def setup
+      @loader = Zeitwerk::Loader.for_gem
+
+      # 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/{utils/collection.rb → 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

@@ -1,37 +1,9 @@
 # frozen_string_literal: true
 
-module MetalArchives
-  class << self
-    ##
-    # API configuration
-    #
-    # Instance of rdoc-ref:MetalArchives::Configuration
-    #
-    def config
-      raise MetalArchives::Errors::InvalidConfigurationError, 'Gem has not been configured' unless @config
+require "logger"
 
-      @config
-    end
-
-    ##
-    # Configure API options.
-    #
-    # A block must be specified, to which a
-    # rdoc-ref:MetalArchives::Configuration parameter will be passed.
-    #
-    # [Raises]
-    # - rdoc-ref:InvalidConfigurationException
-    #
-    def configure
-      raise MetalArchives::Errors::InvalidConfigurationError, 'No configuration block given' unless block_given?
-      @config = MetalArchives::Configuration.new
-      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?
-      raise MetalArchives::Errors::InvalidConfigurationError, 'app_contact has not been configured' unless MetalArchives.config.app_contact && !MetalArchives.config.app_contact.empty?
-    end
-  end
+module MetalArchives
+  CACHE_STRATEGIES = %w(memory redis).freeze
 
   ##
   # Contains configuration options
@@ -53,45 +25,56 @@ 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
 
     ##
-    # Additional Faraday middleware
+    # Endpoint HTTP Basic authentication
     #
-    attr_accessor :middleware
+    attr_accessor :endpoint_user
+    attr_accessor :endpoint_password
 
     ##
-    # Request throttling rate (in seconds per request per path)
+    # Logger instance
     #
-    attr_accessor :request_rate
+    attr_accessor :logger
 
     ##
-    # Request timeout (in seconds per request per path)
+    # Cache strategy
     #
-    attr_accessor :request_timeout
+    attr_accessor :cache_strategy
 
     ##
-    # Logger instance
+    # Cache strategy options
     #
-    attr_accessor :logger
+    attr_accessor :cache_options
 
     ##
-    # Cache size (per object class)
+    # Default configuration values
     #
-    attr_accessor :cache_size
+    def initialize(**attributes)
+      attributes.each { |key, value| send(:"#{key}=", value) }
+
+      @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