lutaml-hal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ea54d1764e2083f8ba5e232022fa2bae95db1775db65e1be46101c3dc2db3a8
+  data.tar.gz: 3d519340919d3f8d84b5c6a38bc73796fbf662cc40c4a01cc030b3cfad9b00ea
+SHA512:
+  metadata.gz: 31543a34726a0d12557f07aae9d9f70fba8ea936abb0b3f8792d26741ba4f353fcd7b9fd08e2cbff44e91819e18efcb5b67a3c50714752221c58f6a39c7761f1
+  data.tar.gz: 2422ddeeb2903e7adce861fce307594c11f5d147b185121e082ad49fe19156016a940ee9199d6591ab203942c4713e48c0ab3d375bf03d944df5faa914a1b4b1

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lutaml-hal.gemspec
+gemspec
+
+gem 'rake'
+gem 'rspec', '~> 3.12'
+gem 'rubocop'
+
+gem 'lutaml-model', git: 'https://github.com/lutaml/lutaml-model.git'

data/LICENSE.md

@@ -0,0 +1,33 @@
+Licenses & Copyright
+====================
+
+This license file adheres to the formatting guidelines of
+[readable-licenses](https://github.com/nevir/readable-licenses).
+
+
+Ribose's BSD 2-Clause License
+-----------------------------
+
+Copyright (c) 2024, [Ribose Inc](https://www.ribose.com).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.adoc

@@ -0,0 +1,244 @@
+= LutaML Model for HAL
+
+https://github.com/lutaml/lutaml-hal[image:https://img.shields.io/github/stars/lutaml/lutaml-hal.svg?style=social[GitHub Stars]]
+https://github.com/lutaml/lutaml-hal[image:https://img.shields.io/github/forks/lutaml/lutaml-hal.svg?style=social[GitHub Forks]]
+image:https://img.shields.io/github/license/lutaml/lutaml-hal.svg[License]
+image:https://img.shields.io/github/actions/workflow/status/lutaml/lutaml-hal/test.yml?branch=main[Build Status]
+image:https://img.shields.io/gem/v/lutaml-hal.svg[RubyGems Version]
+
+
+== Purpose
+
+The `lutaml-hal` gem provides a framework for interacting with HAL-compliant
+APIs using the power of LutaML Models.
+
+Hypertext Application Language (HAL)
+(https://www.ietf.org/archive/id/draft-kelly-json-hal-11.html[HAL Internet-Draft])
+is a simple format for representing
+resources and their relationships in a hypermedia-driven API.
+
+It allows clients to navigate and interact with resources using links, making it
+easier to build flexible and extensible applications.
+
+This library provides a set of classes and methods for modeling HAL resources,
+links, and collections, as well as a client for making HTTP requests to HAL
+APIs.
+
+== Features
+
+* Classes for modeling HAL resources and links
+* A client for making HTTP requests to HAL APIs
+* Tools for pagination and resource resolution
+* Integration with the `lutaml-model` serialization framework
+* Error handling and response validation for API interactions
+
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'lutaml-hal'
+----
+
+And then execute:
+
+[source,sh]
+----
+$ bundle install
+----
+
+Or install it yourself as:
+
+[source,sh]
+----
+$ gem install lutaml-hal
+----
+
+== Structure
+
+The classes in this library are organized into the following modules:
+
+`Lutaml::Hal::Client`::
+A client for making HTTP requests to HAL APIs. It includes methods for setting
+the API endpoint, making GET requests, and handling responses.
++
+NOTE: Only GET requests are supported at the moment.
+
+`Lutaml::Hal::ModelRegister`::
+A registry for managing HAL resource models and their endpoints. It allows you
+to register models, define their relationships, and fetch resources from the
+API.
+
+`Lutaml::Hal::Resource`::
+A base class for defining HAL resource models. It includes methods for
+defining attributes, links, and key-value mappings for resources.
+
+`Lutaml::Hal::Link`::
+A class for defining HAL links. It includes methods for specifying the
+relationship between resources and their links, as well as methods for
+resolving links to their target resources.
+
+`Lutaml::Hal::Page`::
+A class for handling pagination in HAL APIs. It includes methods for
+defining pagination attributes, such as `page`, `pages`, `limit`, and
+`total`, as well as methods for accessing linked resources within a page.
+
+
+== Usage
+
+=== General
+
+In order to interact with a HAL API, the following steps are required:
+
+. Create a `Client` that points to the API endpoint.
+. Create a `ModelRegister` to manage the resource models and their
+respective endpoints.
+. Define the resource models using the `Resource` class.
+. Register the models with the `ModelRegister`.
+. Fetch resources from the API using the `ModelRegister`.
+.. Once the resources are fetched, you can access their attributes and links
+and navigate through the resource graph.
+. Pagination, such as on "index" type pages, can be handled by subclassing the `Page` class.
+The `Page` class itself is also implemented as a `Resource`, so you can
+use the same methods to access the page's attributes and links.
+
+
+=== Creating a HAL model register
+
+[source,ruby]
+----
+require 'lutaml-hal'
+
+# Create a new client with API endpoint
+client = Lutaml::Hal::Client.new(api_url: 'https://api.example.com')
+register = Lutaml::Hal::ModelRegister.new(client: client)
+# Or set client later, `register.client = client`
+
+register.add_endpoint(
+  id: :product_index,
+  type: :index,
+  url: '/products',
+  model: Product
+)
+register.add_endpoint(
+  id: :product_resource,
+  type: :resource,
+  url: '/products/{id}',
+  model: Product
+)
+
+register.fetch(:product_index)
+# => client.get('/products')
+
+# => {
+# "page": 1,
+# "pages": 10,
+# "limit": 10,
+# "total": 45,
+# "_links": {
+#   "self": { "href": "/products/1" },
+#   "next": { "href": "/products/2" },
+#   "last": { "href": "/products/5" },
+#   "products": [
+#     { "id": 1, "name": "Product 1", "price": 10.0 },
+#     { "id": 2, "name": "Product 2", "price": 15.0 }
+#   ]
+# }
+
+product_1 = register.fetch(:product_resource, id: 1)
+# => client.get('/products/1')
+
+# => {
+# "id": 1,
+# "name": "Product 1",
+# "price": 10.0,
+# "_links": {
+#   "self": { "href": "/products/1" },
+#   "category": { "href": "/categories/1", "title": "Category 1" },
+#   "related": [
+#      { "href": "/products/3", "title": "Product 3" },
+#      { "href": "/products/5", "title": "Product 5" }
+#   ]
+# }
+# }
+
+product_1
+# => #<Product id: 1, name: "Product 1", price: 10.0, links:
+#      #<ProductLinks self: <ProductLink href: "/products/1">,
+#                     category: <ProductLink href: "/categories/1", title: "Category 1">,
+#                     related: [
+#                         <ProductLink href: "/products/3", title: "Product 3">,
+#                         <ProductLink href: "/products/5", title: "Product 5">
+#                     ]}>
+----
+
+=== Defining resource models
+
+[source,ruby]
+----
+module MyApi
+  class Product < Lutaml::Hal::Resource
+    attribute :id, :string
+    attribute :name, :string
+    attribute :price, :float
+
+    hal_link :self, key: 'self', realize_class: 'Product'
+    hal_link :category, key: 'category', realize_class: 'Category'
+
+    key_value do
+      map 'id', to: :id
+      map 'name', to: :name
+      map 'price', to: :price
+    end
+  end
+
+  # Register the model with the registry
+  Lutaml::Hal::ModelRegister.register(Product, '/products/{id}')
+end
+----
+
+=== Registering endpoints
+
+=== Fetching Resources
+
+[source,ruby]
+----
+# Assume that the client is already created and registered at
+# the ModelRegister
+# Get a resource
+product = client.get('products/123')
+product_resource = MyApi::Product.from_json(product.to_json)
+
+# Follow a link
+category = product_resource.category.realize(register)
+----
+
+=== Working with Collections
+
+[source,ruby]
+----
+class ProductPage < Lutaml::Hal::Page
+  # Define the relationship between page and items
+end
+
+response = client.get('/products')
+products = ProductPage.from_json(response.to_json)
+
+# Access pagination info
+puts "Page #{products.page} of #{products.pages}, total: #{products.total}"
+
+# Access linked items
+products.links.products.each do |product|
+  puts "#{product.name}: $#{product.price}"
+end
+----
+
+
+== License and Copyright
+
+This project is licensed under the BSD 2-clause License.
+See the link:LICENSE.md[] file for details.
+
+Copyright Ribose.

data/lib/lutaml/hal/client.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/follow_redirects'
+require 'json'
+require 'rainbow'
+require_relative 'errors'
+
+module Lutaml
+  module Hal
+    # HAL Client for making HTTP requests to HAL APIs
+    class Client
+      attr_reader :last_response, :api_url, :connection
+
+      def initialize(options = {})
+        @api_url = options[:api_url] || raise(ArgumentError, 'api_url is required')
+        @connection = options[:connection] || create_connection
+        @params_default = options[:params_default] || {}
+        @debug = options[:debug] || !ENV['DEBUG_API'].nil?
+        @cache = options[:cache] || {}
+        @cache_enabled = options[:cache_enabled] || false
+      end
+
+      # Get a resource by its full URL
+      def get_by_url(url, params = {})
+        # Strip API endpoint if it's included
+        path = url.sub(%r{^#{@api_url}/}, '')
+        get(path, params)
+      end
+
+      # Make a GET request to the API
+      def get(url, params = {})
+        cache_key = "#{url}:#{params.to_json}"
+
+        return @cache[cache_key] if @cache_enabled && @cache.key?(cache_key)
+
+        @last_response = @connection.get(url, params)
+
+        response = handle_response(@last_response, url)
+
+        @cache[cache_key] = response if @cache_enabled
+        response
+      rescue Faraday::ConnectionFailed => e
+        raise ConnectionError, "Connection failed: #{e.message}"
+      rescue Faraday::TimeoutError => e
+        raise TimeoutError, "Request timed out: #{e.message}"
+      rescue Faraday::ParsingError => e
+        raise ParsingError, "Response parsing error: #{e.message}"
+      rescue Faraday::Adapter::Test::Stubs::NotFound => e
+        raise LinkResolutionError, "Resource not found: #{e.message}"
+      end
+
+      private
+
+      def create_connection
+        Faraday.new(url: @api_url) do |conn|
+          conn.use Faraday::FollowRedirects::Middleware
+          conn.request :json
+          conn.response :json, content_type: /\bjson$/
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      def handle_response(response, url)
+        debug_log(response, url) if @debug
+
+        case response.status
+        when 200..299
+          response.body
+        when 400
+          raise BadRequestError, response_message(response)
+        when 401
+          raise UnauthorizedError, response_message(response)
+        when 404
+          raise NotFoundError, response_message(response)
+        when 500..599
+          raise ServerError, response_message(response)
+        else
+          raise Error, response_message(response)
+        end
+      end
+
+      def debug_log(response, url)
+        if defined?(Rainbow)
+          puts Rainbow("\n===== DEBUG: HAL API REQUEST =====").blue
+        else
+          puts "\n===== DEBUG: HAL API REQUEST ====="
+        end
+
+        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)
+
+        puts "\nResponse body:"
+        if response.body.is_a?(Hash) || response.body.is_a?(Array)
+          puts JSON.pretty_generate(response.body)
+        else
+          puts response.body.inspect
+        end
+
+        if defined?(Rainbow)
+          puts Rainbow("===== END DEBUG OUTPUT =====\n").blue
+        else
+          puts "===== END DEBUG OUTPUT =====\n"
+        end
+      end
+
+      def response_message(response)
+        message = "Status: #{response.status}"
+        message += ", Error: #{response.body['error']}" if response.body.is_a?(Hash) && response.body['error']
+        message
+      end
+    end
+  end
+end

data/lib/lutaml/hal/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Hal
+    class Error < StandardError; end
+    class NotFoundError < Error; end
+    class UnauthorizedError < Error; end
+    class BadRequestError < Error; end
+    class ServerError < Error; end
+    class LinkResolutionError < Error; end
+  end
+end

data/lib/lutaml/hal/link.rb

@@ -0,0 +1,25 @@
+# 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
+      attribute :href, :string
+      attribute :title, :string
+      attribute :name, :string
+      attribute :templated, :boolean
+      attribute :type, :string
+      attribute :deprecation, :string
+      attribute :profile, :string
+      attribute :lang, :string
+
+      # Fetch the actual resource this link points to
+      def realize(register)
+        register.resolve_and_cast(href)
+      end
+    end
+  end
+end

data/lib/lutaml/hal/model_register.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module Lutaml
+  module Hal
+    # Register to map URL patterns to model classes
+    class ModelRegister
+      attr_accessor :models, :client
+
+      def initialize(client: nil)
+        # If `client` is not set, it can be set later
+        @client = client
+        @models = {}
+      end
+
+      # Register a model with its base URL pattern
+      def add_endpoint(id:, type:, url:, model:)
+        @models ||= {}
+
+        raise "Model with ID #{id} already registered" if @models[id]
+        if @models.values.any? { |m| m[:url] == url && m[:type] == type }
+          raise "Duplicate URL pattern #{url} for type #{type}"
+        end
+
+        @models[id] = {
+          id: id,
+          type: type,
+          url: url,
+          model: model
+        }
+      end
+
+      # Resolve and cast data to the appropriate model based on URL
+      def fetch(endpoint_id, **params)
+        endpoint = @models[endpoint_id] || raise("Unknown endpoint: #{endpoint_id}")
+        raise 'Client not configured' unless client
+
+        url = interpolate_url(endpoint[:url], params)
+        response = client.get(url)
+
+        endpoint[:model].from_json(response.to_json)
+      end
+
+      def resolve_and_cast(href)
+        raise 'Client not configured' unless client
+
+        debug_log("href #{href}")
+        response = client.get_by_url(href)
+
+        # TODO: Merge more content into the resource
+        response_with_link_details = response.to_h.merge({ 'href' => href })
+
+        href_path = href.sub(client.api_url, '')
+        model_class = find_matching_model_class(href_path)
+        raise LinkResolutionError, "Unregistered URL pattern: #{href}" unless model_class
+
+        debug_log("model_class #{model_class}")
+        debug_log("response: #{response.inspect}")
+        debug_log("amended: #{response_with_link_details}")
+
+        model_class.from_json(response_with_link_details.to_json)
+      end
+
+      private
+
+      def interpolate_url(url_template, params)
+        params.reduce(url_template) do |url, (key, value)|
+          url.gsub("{#{key}}", value.to_s)
+        end
+      end
+
+      def find_matching_model_class(href)
+        @models.values.find do |model_data|
+          matches_url?(model_data[:url], href)
+        end&.[](:model)
+      end
+
+      def matches_url?(pattern, href)
+        return false unless pattern && href
+
+        if href.start_with?('/') && client&.api_url
+          # Try both with and without the API endpoint prefix
+          path_pattern = extract_path(pattern)
+          return pattern_match?(path_pattern, href) ||
+                 pattern_match?(pattern, "#{client.api_url}#{href}")
+        end
+
+        pattern_match?(pattern, href)
+      end
+
+      def extract_path(pattern)
+        return pattern unless client&.api_url && pattern.start_with?(client.api_url)
+
+        pattern.sub(client.api_url, '')
+      end
+
+      # Match URL pattern (supports * wildcards and {param} templates)
+      def pattern_match?(pattern, url)
+        return false unless pattern && url
+
+        # Convert {param} to wildcards for matching
+        pattern_with_wildcards = pattern.gsub(/\{[^}]+\}/, '*')
+        # Convert * wildcards to regex pattern
+        regex = Regexp.new("^#{pattern_with_wildcards.gsub('*', '[^/]+')}$")
+        regex.match?(url)
+      end
+
+      def debug_log(message)
+        puts "DEBUG: #{message}" if ENV['DEBUG_API']
+      end
+    end
+  end
+end

data/lib/lutaml/hal/page.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+module Lutaml
+  module Hal
+    # Models the pagination of a collection of resources
+    # This class is used to represent the pagination information
+    # for a collection of resources in the HAL format.
+    class Page < Resource
+      attribute :page, :integer
+      attribute :limit, :integer
+      attribute :pages, :integer
+      attribute :total, :integer
+
+      key_value do
+        map 'page', to: :page
+        map 'limit', to: :limit
+        map 'pages', to: :pages
+        map 'total', to: :total
+      end
+    end
+  end
+end

data/lib/lutaml/hal/resource.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'link'
+
+module Lutaml
+  module Hal
+    # Resource class for all HAL resources
+    class Resource < Lutaml::Model::Serializable
+      class << self
+        attr_accessor :link_definitions
+
+        # Callback for when a subclass is created
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            create_links_class
+            init_links_definition
+          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:, collection: false, type: :link)
+          # Use the provided "key" as the attribute name
+          attribute_name = attr_key.to_sym
+
+          # Create a dynamic Link subclass name based on "realize_class", the
+          # class to realize for a Link object
+          link_klass = create_link_class(realize_class)
+          links_klass = get_links_class
+          links_klass.class_eval do
+            # Declare the corresponding lutaml-model attribute
+            attribute attribute_name, link_klass, collection: collection
+
+            # Define the mapping for the attribute
+            key_value do
+              map attr_key, to: attribute_name
+            end
+          end
+
+          # Create a new link definition for future reference
+          link_def = {
+            attribute_name: attribute_name,
+            key: attr_key,
+            klass: link_klass,
+            collection: collection,
+            type: type
+          }
+
+          @link_definitions ||= {}
+          @link_definitions[key] = link_def
+        end
+
+        # This method obtains the Links class that holds the Link classes
+        def get_links_class
+          parent_klass_name = name.split('::')[0..-2].join('::')
+          child_klass_name = "#{name.split('::').last}Links"
+          klass_name = "#{parent_klass_name}::#{child_klass_name}"
+
+          raise unless Object.const_defined?(klass_name)
+
+          Object.const_get(klass_name)
+        end
+
+        private
+
+        # The "links" class holds the `_links` object which contains
+        # the resource-linked Link classes
+        def create_links_class
+          parent_klass_name = name.split('::')[0..-2].join('::')
+          child_klass_name = "#{name.split('::').last}Links"
+          klass_name = "#{parent_klass_name}::#{child_klass_name}"
+
+          # Check if the Links class is already defined, return if so
+          return Object.const_get(klass_name) if Object.const_defined?(klass_name)
+
+          # Define the links class dynamically as a normal Lutaml::Model class
+          # since it is not a Resource
+          klass = Class.new(Lutaml::Model::Serializable)
+          Object.const_get(parent_klass_name).tap do |parent_klass|
+            parent_klass.const_set(child_klass_name, klass)
+          end
+
+          # Define the Links class with mapping inside the current class
+          class_eval do
+            attribute :links, klass
+            key_value do
+              map '_links', to: :links
+            end
+          end
+        end
+
+        def init_links_definition
+          @link_definitions = {}
+        end
+
+        # This is a Link class that helps us realize the targeted class
+        def create_link_class(realize_class_name)
+          parent_klass_name = name.split('::')[0..-2].join('::')
+          child_klass_name = "#{name.split('::').last}Link"
+          klass_name = "#{parent_klass_name}::#{child_klass_name}"
+
+          return Object.const_get(klass_name) if Object.const_defined?(klass_name)
+
+          # Define the link class dynamically
+          klass = Class.new(Link) do
+            # Define the link class with the specified key and class
+            attribute :type, :string, default: realize_class_name
+          end
+          Object.const_get(parent_klass_name).tap do |parent_klass|
+            parent_klass.const_set(child_klass_name, klass)
+          end
+
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/hal/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Hal
+    VERSION = '0.1.0'
+  end
+end

data/lib/lutaml/hal.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Lutaml
+  # HAL implementation for Lutaml
+  module Hal
+  end
+end
+
+require_relative 'hal/version'
+require_relative 'hal/errors'
+require_relative 'hal/link'
+require_relative 'hal/resource'
+require_relative 'hal/page'
+require_relative 'hal/model_register'
+require_relative 'hal/client'

data/lib/lutaml-hal.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'lutaml/hal'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: lutaml-hal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Hypertext Application Language (HAL) implementation for Lutaml model
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.md
+- README.adoc
+- lib/lutaml-hal.rb
+- lib/lutaml/hal.rb
+- lib/lutaml/hal/client.rb
+- lib/lutaml/hal/errors.rb
+- lib/lutaml/hal/link.rb
+- lib/lutaml/hal/model_register.rb
+- lib/lutaml/hal/page.rb
+- lib/lutaml/hal/resource.rb
+- lib/lutaml/hal/version.rb
+homepage: https://github.com/lutaml/lutaml-hal
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lutaml/lutaml-hal
+  source_code_uri: https://github.com/lutaml/lutaml-hal
+  changelog_uri: https://github.com/lutaml/lutaml-hal/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: HAL implementation for LutaML
+test_files: []