lutaml-hal 0.2.1 → 0.2.3

data/lib/lutaml/hal/resource.rb

@@ -1,33 +1,20 @@
 # frozen_string_literal: true
 
 require 'lutaml/model'
-require_relative 'link'
-require_relative 'link_class_factory'
-require_relative 'link_set_class_factory'
 
 module Lutaml
   module Hal
-    # Resource class for all HAL resources
     class Resource < Lutaml::Model::Serializable
-      # This is the model register that has fetched this resource, and
-      # will be used to resolve links unless overriden in resource#realize()
-      attr_accessor :_global_register_id
+      attr_accessor :_global_register_id, :embedded_data
 
-      # Embedded resources from the HAL `_embedded` section, retained so that
-      # links can be realized from already-fetched content.
-      attr_accessor :embedded_data
-
-      # Check if embedded data exists for a given key
       def has_embedded?(key)
         embedded_data&.key?(key.to_s)
       end
 
-      # Get embedded content for a specific key
       def get_embedded(key)
         embedded_data&.[](key.to_s)
       end
 
-      # Create a resource instance from embedded JSON data
       def self.from_embedded(json_data, register_name = nil)
         instance = from_json(json_data.to_json)
         instance._global_register_id = register_name if register_name
@@ -37,7 +24,6 @@ module Lutaml
       class << self
         attr_accessor :link_definitions
 
-        # Callback for when a subclass is created
         def inherited(subclass)
           super
           subclass.class_eval do
@@ -45,12 +31,6 @@ module Lutaml
           end
         end
 
-        # The developer defines a link to another resource
-        # The "key" is the name of the attribute in the JSON
-        # The "realize_class" is the class to be realized
-        # The "collection" is a boolean indicating if the link
-        # is a collection of resources or a single resource
-        # The "type" is the type of the link (default is :link, can be :resource)
         def hal_link(attr_key,
                      key:,
                      realize_class:,
@@ -58,56 +38,42 @@ module Lutaml
                      link_set_class: nil,
                      collection: false,
                      type: :link)
-          # Validate required parameters
           raise ArgumentError, 'realize_class parameter is required' if realize_class.nil?
 
-          # Use the provided "key" as the attribute name
           attribute_name = attr_key.to_sym
 
           Hal.debug_log "Defining HAL link for `#{attr_key}` with realize class `#{realize_class}`"
 
-          # Normalize realize_class to a string for consistent handling
-          # Support both Class objects (when autoload is available) and strings (for delayed interpretation)
           realize_class_name = case realize_class
                                when Class
-                                 realize_class.name.split('::').last # Use simple name from actual class
+                                 realize_class.name.split('::').last
                                when String
-                                 realize_class # Use string as-is for lazy resolution
+                                 realize_class
                                else
                                  raise ArgumentError,
                                        "realize_class must be a Class or String, got #{realize_class.class}"
                                end
 
-          # Create a dynamic LinkSet class if `link_set_class:` is not provided.
-          # This must happen BEFORE creating the Link class to ensure proper order
           link_set_klass = link_set_class || create_link_set_class
 
-          # Ensure it was actually created
           raise 'Failed to create LinkSet class' if link_set_klass.nil?
 
-          # Create a dynamic Link subclass name based on "realize_class", the
-          # class to realize for a Link object, if `link_class:` is not provided.
           link_klass = link_class || create_link_class(realize_class_name)
 
-          # Now add the link to the LinkSet class
           unless link_set_class
             link_set_klass.class_eval do
-              # Declare the corresponding lutaml-model attribute
-              # Pass collection parameter correctly to the attribute definition
               if collection
                 attribute attribute_name, link_klass, collection: true
               else
                 attribute attribute_name, link_klass
               end
 
-              # Define the mapping for the attribute
               key_value do
                 map key, to: attribute_name
               end
             end
           end
 
-          # Create a new link definition for future reference
           link_def = {
             attribute_name: attribute_name,
             key: attr_key,
@@ -120,15 +86,10 @@ module Lutaml
           @link_definitions[key] = link_def
         end
 
-        # This method obtains the Links class that holds the Link classes
-        # Delegates to LinkSetClassFactory for simplified implementation
         def get_link_set_class
           create_link_set_class
         end
 
-        # The "links" class holds the `_links` object which contains
-        # the resource-linked Link classes
-        # Delegates to LinkSetClassFactory for simplified implementation
         def create_link_set_class
           LinkSetClassFactory.create_for(self)
         end
@@ -137,8 +98,6 @@ module Lutaml
           @link_definitions = {}
         end
 
-        # Creates a Link class that helps us realize the targeted class
-        # Delegates to LinkClassFactory for simplified implementation
         def create_link_class(realize_class_name)
           LinkClassFactory.create_for(self, realize_class_name)
         end

data/lib/lutaml/hal/single_flight.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Hal
+    # Coalesces concurrent calls that share a key so the work runs once and the
+    # result (or error) is shared by all callers. Calls for *different* keys run
+    # in parallel — only same-key callers wait on the in-flight leader.
+    #
+    # Pure stdlib (Mutex + ConditionVariable); no external dependency. In-flight
+    # entries are removed once resolved, so memory is bounded by concurrency,
+    # not by the number of distinct keys ever seen.
+    class SingleFlight
+      Call = Struct.new(:mutex, :cond, :done, :value, :error)
+
+      def initialize
+        @registry_mutex = Mutex.new
+        @calls = {}
+      end
+
+      # Run the block at most once per key under concurrency, returning its
+      # result. The first caller for a key (the leader) runs the block; others
+      # wait and receive the same value (or re-raise the same error).
+      def run(key)
+        leader = false
+        call = @registry_mutex.synchronize do
+          @calls[key] ||= begin
+            leader = true
+            Call.new(Mutex.new, ConditionVariable.new, false)
+          end
+        end
+
+        return await(call) unless leader
+
+        begin
+          call.value = yield
+        rescue StandardError => e
+          call.error = e
+        ensure
+          @registry_mutex.synchronize { @calls.delete(key) }
+          call.mutex.synchronize do
+            call.done = true
+            call.cond.broadcast
+          end
+        end
+
+        raise call.error if call.error
+
+        call.value
+      end
+
+      private
+
+      def await(call)
+        call.mutex.synchronize do
+          call.cond.wait(call.mutex) until call.done
+        end
+        raise call.error if call.error
+
+        call.value
+      end
+    end
+  end
+end

data/lib/lutaml/hal/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Hal
-    VERSION = '0.2.1'
+    VERSION = '0.2.3'
   end
 end

data/lib/lutaml/hal.rb

@@ -4,22 +4,38 @@ require 'lutaml/model'
 require 'lutaml/store'
 
 module Lutaml
-  # HAL implementation for Lutaml
   module Hal
+    REGISTER_ID_ATTR_NAME = '_global_register_id'
+
     def self.debug_log(message)
       puts "[Lutaml::Hal] DEBUG: #{message}" if ENV['DEBUG_API']
     end
+
+    autoload :VERSION, 'lutaml/hal/version'
+    autoload :Error, 'lutaml/hal/errors'
+    autoload :NotFoundError, 'lutaml/hal/errors'
+    autoload :UnauthorizedError, 'lutaml/hal/errors'
+    autoload :BadRequestError, 'lutaml/hal/errors'
+    autoload :ServerError, 'lutaml/hal/errors'
+    autoload :LinkResolutionError, 'lutaml/hal/errors'
+    autoload :ParsingError, 'lutaml/hal/errors'
+    autoload :ConnectionError, 'lutaml/hal/errors'
+    autoload :TimeoutError, 'lutaml/hal/errors'
+    autoload :TooManyRequestsError, 'lutaml/hal/errors'
+    autoload :Cache, 'lutaml/hal/cache'
+    autoload :Client, 'lutaml/hal/client'
+    autoload :EndpointConfiguration, 'lutaml/hal/endpoint_configuration'
+    autoload :EndpointParameter, 'lutaml/hal/endpoint_parameter'
+    autoload :GlobalRegister, 'lutaml/hal/global_register'
+    autoload :Link, 'lutaml/hal/link'
+    autoload :LinkClassFactory, 'lutaml/hal/link_class_factory'
+    autoload :LinkSet, 'lutaml/hal/link_set'
+    autoload :LinkSetClassFactory, 'lutaml/hal/link_set_class_factory'
+    autoload :ModelRegister, 'lutaml/hal/model_register'
+    autoload :Page, 'lutaml/hal/page'
+    autoload :RateLimiter, 'lutaml/hal/rate_limiter'
+    autoload :Resource, 'lutaml/hal/resource'
+    autoload :SingleFlight, 'lutaml/hal/single_flight'
+    autoload :TypeResolver, 'lutaml/hal/type_resolver'
   end
 end
-
-require_relative 'hal/version'
-require_relative 'hal/errors'
-require_relative 'hal/rate_limiter'
-require_relative 'hal/endpoint_parameter'
-require_relative 'hal/link'
-require_relative 'hal/link_set'
-require_relative 'hal/resource'
-require_relative 'hal/page'
-require_relative 'hal/global_register'
-require_relative 'hal/model_register'
-require_relative 'hal/client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-hal
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -92,11 +92,12 @@ files:
 - README.adoc
 - lib/lutaml-hal.rb
 - lib/lutaml/hal.rb
+- lib/lutaml/hal/cache.rb
 - lib/lutaml/hal/cache/cache_configuration.rb
 - lib/lutaml/hal/cache/cache_entry.rb
 - lib/lutaml/hal/cache/cache_manager.rb
 - lib/lutaml/hal/cache/cache_metadata.rb
-- lib/lutaml/hal/cache/simple_cache_store.rb
+- lib/lutaml/hal/cache/response_adapter.rb
 - lib/lutaml/hal/client.rb
 - lib/lutaml/hal/endpoint_configuration.rb
 - lib/lutaml/hal/endpoint_parameter.rb
@@ -110,6 +111,7 @@ files:
 - lib/lutaml/hal/page.rb
 - lib/lutaml/hal/rate_limiter.rb
 - lib/lutaml/hal/resource.rb
+- lib/lutaml/hal/single_flight.rb
 - lib/lutaml/hal/type_resolver.rb
 - lib/lutaml/hal/version.rb
 homepage: https://github.com/lutaml/lutaml-hal

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Hal
-    module Cache
-      # Simple in-memory cache store for testing and fallback scenarios.
-      #
-      # Thread-safe: a single mutex guards the cache and its LRU bookkeeping so
-      # it can back the register cache when consumers realize links from many
-      # threads (e.g. a parallel fetcher).
-      class SimpleCacheStore
-        attr_reader :max_size
-
-        def initialize(max_size = 100)
-          @max_size = max_size
-          @cache = {}
-          @access_order = []
-          @mutex = Mutex.new
-        end
-
-        def get(key)
-          @mutex.synchronize do
-            return nil unless @cache.key?(key)
-
-            # Update access order for LRU
-            @access_order.delete(key)
-            @access_order.push(key)
-
-            @cache[key]
-          end
-        end
-
-        def set(key, value)
-          @mutex.synchronize do
-            # Remove existing entry if present
-            if @cache.key?(key)
-              @access_order.delete(key)
-            elsif @cache.size >= @max_size
-              # Evict least recently used item
-              lru_key = @access_order.shift
-              @cache.delete(lru_key)
-            end
-
-            @cache[key] = value
-            @access_order.push(key)
-          end
-        end
-
-        def delete(key)
-          @mutex.synchronize do
-            @access_order.delete(key)
-            @cache.delete(key)
-          end
-        end
-
-        def clear
-          @mutex.synchronize do
-            @cache.clear
-            @access_order.clear
-          end
-        end
-
-        def size
-          @mutex.synchronize { @cache.size }
-        end
-
-        def stats
-          @mutex.synchronize do
-            {
-              size: @cache.size,
-              max_size: @max_size,
-              keys: @cache.keys
-            }
-          end
-        end
-
-        def cache_info
-          stats
-        end
-      end
-    end
-  end
-end