lutaml-hal 0.2.2 → 0.2.4

data/lib/lutaml/hal/cache/cache_metadata.rb

@@ -5,7 +5,6 @@ require 'lutaml/model'
 module Lutaml
   module Hal
     module Cache
-      # Represents HTTP response metadata from the request that created the HAL resource
       class CacheMetadata < Lutaml::Model::Serializable
         attribute :etag, :string
         attribute :last_modified, :string
@@ -16,23 +15,21 @@ module Lutaml
         attribute :date, :string
         attribute :vary, :string
 
-        # Extract metadata from HTTP response headers
         def self.from_response(response)
-          headers = extract_headers(response)
+          headers = ResponseAdapter.headers(response)
 
           new(
             etag: headers['etag'],
             last_modified: headers['last-modified'],
             cache_control: headers['cache-control'],
             expires: headers['expires'],
-            status_code: extract_status_code(response),
+            status_code: ResponseAdapter.status_code(response),
             content_type: headers['content-type'],
             date: headers['date'],
             vary: headers['vary']
           )
         end
 
-        # Generate conditional request headers for cache validation
         def conditional_headers
           headers = {}
           headers['If-None-Match'] = etag if etag
@@ -40,7 +37,6 @@ module Lutaml
           headers
         end
 
-        # Check if the metadata indicates the response is cacheable
         def cacheable?
           return false if cache_control&.include?('no-cache')
           return false if cache_control&.include?('no-store')
@@ -49,7 +45,6 @@ module Lutaml
           true
         end
 
-        # Extract TTL from cache-control header
         def max_age
           return nil unless cache_control
 
@@ -57,46 +52,8 @@ module Lutaml
           match ? match[1].to_i : nil
         end
 
-        # Check if the response can be revalidated with conditional requests
         def revalidatable?
-          !etag.nil? && !etag.empty? || !last_modified.nil? && !last_modified.empty?
-        end
-
-        def self.extract_headers(response)
-          case response
-          when Hash
-            # Response is already a hash, extract headers directly
-            response.select { |k, _| k.is_a?(String) && k.match?(/^[a-z-]+$/) }
-          when ->(r) { r.respond_to?(:headers) }
-            # Response has headers method
-            response.headers.to_h
-          when ->(r) { r.respond_to?(:[]) }
-            # Response is hash-like, try to extract common headers
-            {
-              'etag' => response['etag'],
-              'last-modified' => response['last-modified'],
-              'cache-control' => response['cache-control'],
-              'expires' => response['expires'],
-              'content-type' => response['content-type'],
-              'date' => response['date'],
-              'vary' => response['vary']
-            }.compact
-          else
-            {}
-          end
-        end
-
-        def self.extract_status_code(response)
-          case response
-          when Hash
-            response['status'] || response[:status] || 200
-          when ->(r) { r.respond_to?(:status) }
-            response.status
-          when ->(r) { r.respond_to?(:code) }
-            response.code.to_i
-          else
-            200
-          end
+          !!(etag && !etag.empty?) || !!(last_modified && !last_modified.empty?)
         end
       end
     end

data/lib/lutaml/hal/cache/response_adapter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Hal
+    module Cache
+      module ResponseAdapter
+        def self.headers(response)
+          case response
+          when Hash
+            response.select { |k, _| k.is_a?(String) && k.match?(/^[a-z-]+$/) }
+          when nil
+            {}
+          else
+            response.headers.to_h
+          end
+        end
+
+        def self.status_code(response)
+          case response
+          when Hash
+            response['status'] || response[:status] || 200
+          when nil
+            200
+          else
+            response.status
+          end
+        rescue NoMethodError
+          200
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/hal/cache.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Hal
+    module Cache
+      autoload :CacheConfiguration, 'lutaml/hal/cache/cache_configuration'
+      autoload :CacheEntry, 'lutaml/hal/cache/cache_entry'
+      autoload :CacheManager, 'lutaml/hal/cache/cache_manager'
+      autoload :CacheMetadata, 'lutaml/hal/cache/cache_metadata'
+      autoload :ResponseAdapter, 'lutaml/hal/cache/response_adapter'
+    end
+  end
+end

data/lib/lutaml/hal/client.rb

@@ -4,12 +4,9 @@ require 'faraday'
 require 'faraday/follow_redirects'
 require 'json'
 require 'rainbow'
-require_relative 'errors'
-require_relative 'rate_limiter'
 
 module Lutaml
   module Hal
-    # HAL Client for making HTTP requests to HAL APIs
     class Client
       attr_reader :last_response, :api_url, :connection, :rate_limiter
 
@@ -19,46 +16,38 @@ module Lutaml
         @params_default = options[:params_default] || {}
         @debug = options[:debug] || !ENV['DEBUG_API'].nil?
         @rate_limiter = options[:rate_limiter] || RateLimiter.new(options[:rate_limiting] || {})
-
         @api_url = strip_api_url(@api_url)
       end
 
-      # Strip any trailing slash from the API URL
       def strip_api_url(url)
         url.sub(%r{/\Z}, '')
       end
 
-      # Get a resource by its full URL
       def get_by_url(url, params = {})
-        # Strip API endpoint if it's included
         path = strip_api_url(url)
         get(path, params)
       end
 
-      # Get a resource by its full URL with custom headers (e.g. conditional
-      # request headers for cache revalidation)
       def get_by_url_with_headers(url, headers = {})
         path = strip_api_url(url)
         get_with_headers(path, headers)
       end
 
-      # Make a GET request to the API
       def get(url, params = {})
         @rate_limiter.with_rate_limiting do
           @last_response = @connection.get(url, params)
           handle_response(@last_response, url)
         end
       rescue Faraday::ConnectionFailed => e
-        raise Lutaml::Hal::ConnectionError, "Connection failed: #{e.message}"
+        raise ConnectionError, "Connection failed: #{e.message}"
       rescue Faraday::TimeoutError => e
-        raise Lutaml::Hal::TimeoutError, "Request timed out: #{e.message}"
+        raise TimeoutError, "Request timed out: #{e.message}"
       rescue Faraday::ParsingError => e
-        raise Lutaml::Hal::ParsingError, "Response parsing error: #{e.message}"
+        raise ParsingError, "Response parsing error: #{e.message}"
       rescue Faraday::Adapter::Test::Stubs::NotFound => e
-        raise Lutaml::Hal::LinkResolutionError, "Resource not found: #{e.message}"
+        raise LinkResolutionError, "Resource not found: #{e.message}"
       end
 
-      # Make a GET request with custom headers
       def get_with_headers(url, headers = {})
         @rate_limiter.with_rate_limiting do
           @last_response = @connection.get(url) do |req|
@@ -67,13 +56,13 @@ module Lutaml
           handle_response(@last_response, url)
         end
       rescue Faraday::ConnectionFailed => e
-        raise Lutaml::Hal::ConnectionError, "Connection failed: #{e.message}"
+        raise ConnectionError, "Connection failed: #{e.message}"
       rescue Faraday::TimeoutError => e
-        raise Lutaml::Hal::TimeoutError, "Request timed out: #{e.message}"
+        raise TimeoutError, "Request timed out: #{e.message}"
       rescue Faraday::ParsingError => e
-        raise Lutaml::Hal::ParsingError, "Response parsing error: #{e.message}"
+        raise ParsingError, "Response parsing error: #{e.message}"
       rescue Faraday::Adapter::Test::Stubs::NotFound => e
-        raise Lutaml::Hal::LinkResolutionError, "Resource not found: #{e.message}"
+        raise LinkResolutionError, "Resource not found: #{e.message}"
       end
 
       private
@@ -124,7 +113,6 @@ module Lutaml
         puts "URL: #{url}"
         puts "Status: #{response.status}"
 
-        # Format headers as JSON
         puts "\nHeaders:"
         headers_hash = response.headers.to_h
         puts JSON.pretty_generate(headers_hash)

data/lib/lutaml/hal/global_register.rb

@@ -4,14 +4,6 @@ require 'singleton'
 
 module Lutaml
   module Hal
-    # Global register for model registers
-    # This class is a singleton that manages the registration and retrieval of model registers.
-    # It ensures that each model register is unique and provides a way to access them globally.
-    #
-    # @example
-    #   global_register = GlobalRegister.instance
-    #   global_register.register(:example, ExampleModelRegister.new)
-    #   example_register = global_register.get(:example)
     class GlobalRegister
       include Singleton
 
@@ -44,17 +36,14 @@ module Lutaml
         delete(name)
       end
 
-      # Cache management methods for all registered model registers
       def clear_all_caches
-        @model_registers.each_value do |register|
-          register.clear_cache if register.respond_to?(:clear_cache)
-        end
+        @model_registers.each_value(&:clear_cache)
       end
 
       def cache_stats
         stats = {}
         @model_registers.each do |name, register|
-          stats[name] = register.cache_info if register.respond_to?(:cache_info)
+          stats[name] = register.cache_info
         end
         stats
       end

data/lib/lutaml/hal/link.rb

@@ -1,18 +1,11 @@
 # frozen_string_literal: true
 
 require 'lutaml/model'
-require_relative 'model_register'
 
 module Lutaml
   module Hal
-    # HAL Link representation with realization capability
     class Link < Lutaml::Model::Serializable
-      # This is the model register that has fetched the origin of this link, and
-      # will be used to resolve unless overriden in resource#realize()
-      attr_accessor :_global_register_id
-
-      # Store reference to parent resource for automatic embedded content detection
-      attr_accessor :parent_resource
+      attr_accessor :_global_register_id, :parent_resource
 
       attribute :href, :string
       attribute :title, :string
@@ -23,25 +16,17 @@ module Lutaml
       attribute :profile, :string
       attribute :lang, :string
 
-      # Fetch the actual resource this link points to.
-      # This method will use the global register according to the source of the Link object.
-      # If the Link does not have a register, a register needs to be provided explicitly
-      # via the `register:` parameter.
       def realize(register: nil, parent_resource: nil, force_refresh: false)
-        # Use provided parent_resource or fall back to stored parent_resource
         effective_parent = parent_resource || @parent_resource
 
         register = find_register(register)
         raise "No register provided for link resolution (class: #{self.class}, href: #{href})" if register.nil?
 
-        # Priority 1: Check embedded content first (unless force_refresh)
         if !force_refresh && effective_parent && (embedded_content = check_embedded_content(effective_parent, register))
-          # Cache embedded content too, so later lookups by href are served locally
           register.cache_manager&.set(href, nil, embedded_content)
           return embedded_content
         end
 
-        # Force refresh bypasses any cached entry for this href
         register.cache_manager&.invalidate(href) if force_refresh
 
         Hal.debug_log "Resolving link href: #{href} using register"
@@ -51,17 +36,12 @@ module Lutaml
       private
 
       def check_embedded_content(parent_resource, register = nil)
-        return nil unless parent_resource.respond_to?(:embedded_data)
+        return nil unless parent_resource.is_a?(Resource) && parent_resource.embedded_data
 
-        # Try to find embedded content that matches this link
-        # Look for embedded content by matching the link's key or href pattern
         embedded_data = parent_resource.embedded_data
         return nil unless embedded_data
 
-        # Try to find matching embedded content
-        # This is a simplified approach - in practice, you might need more sophisticated matching
         embedded_data.each_value do |content|
-          # If content is an array, check if any item matches this link
           if content.is_a?(Array)
             matching_item = content.find { |item| matches_embedded_item?(item) }
             return create_embedded_resource(matching_item, parent_resource, register) if matching_item
@@ -76,25 +56,17 @@ module Lutaml
       def matches_embedded_item?(item)
         return false unless item.is_a?(Hash)
 
-        # Check if the embedded item's self link matches this link's href
-        item_self_link = item.dig('_links', 'self', 'href')
-        return true if item_self_link == href
-
-        # Additional matching logic could be added here
-        false
+        item.dig('_links', 'self', 'href') == href
       end
 
       def create_embedded_resource(embedded_item, _parent_resource, register = nil)
-        # Get the register to determine the appropriate model class
         register = find_register(register)
         return nil unless register
 
-        # Try to find the model class for this href
         href_path = href.sub(register.client.api_url, '') if register.client
         model_class = register.find_matching_model_class(href_path)
         return nil unless model_class
 
-        # Create the resource from embedded data
         resource = model_class.from_embedded(embedded_item, _global_register_id)
         register.mark_model_links_with_register(resource)
         resource
@@ -106,7 +78,7 @@ module Lutaml
         register_id = _global_register_id
         return nil if register_id.nil?
 
-        register = Lutaml::Hal::GlobalRegister.instance.get(register_id)
+        register = GlobalRegister.instance.get(register_id)
         if register.nil?
           raise 'GlobalRegister in use but unable to find the register. '\
             'Please provide a register to the `#realize` method to resolve the link'

data/lib/lutaml/hal/link_class_factory.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'link'
-require_relative 'type_resolver'
-
 module Lutaml
   module Hal
-    # Factory class responsible for creating dynamic Link classes
     class LinkClassFactory
       def self.create_for(resource_class, realize_class_name)
         new(resource_class, realize_class_name).create
@@ -74,8 +70,6 @@ module Lutaml
       def register_constant(klass, class_names)
         parent_klass = resolve_parent_class(class_names[:parent_namespace])
 
-        # Avoid registering constants on Object in test scenarios
-        # This prevents conflicts with test mocks that expect specific const_set calls
         return if parent_klass == Object && in_test_environment?
 
         parent_klass.const_set(class_names[:child_name], klass)
@@ -92,7 +86,6 @@ module Lutaml
       end
 
       def in_test_environment?
-        # Check if we're in a test environment by looking for RSpec or test-related constants
         defined?(RSpec) || defined?(Test::Unit) || ENV['RAILS_ENV'] == 'test' || ENV['RACK_ENV'] == 'test'
       end
     end

data/lib/lutaml/hal/link_set.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 require 'lutaml/model'
-require_relative 'model_register'
 
 module Lutaml
   module Hal
-    # HAL Link representation with realization capability
     class LinkSet < Lutaml::Model::Serializable
       attr_accessor :_global_register_id
     end

data/lib/lutaml/hal/link_set_class_factory.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'link_set'
-
 module Lutaml
   module Hal
-    # Factory class responsible for creating dynamic LinkSet classes
     class LinkSetClassFactory
       def self.create_for(resource_class)
         new(resource_class).create
@@ -79,7 +76,6 @@ module Lutaml
       end
 
       def setup_resource_mapping(link_set_class)
-        # Define the LinkSet class with mapping inside the resource class
         @resource_class.class_eval do
           attribute :links, link_set_class
           key_value do