ruby-gems-publish-test 0.1.0

data/lib/ruby_gems_publish_test/models/pet.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    class Pet
+      include ::RubyGemsPublishTest::Models::Serializable
+      include ::RubyGemsPublishTest::Models::OpenModel
+
+      def self.wire_keys
+        {
+          id: 'id',
+          name: 'name',
+          category: 'category',
+          photo_urls: 'photoUrls',
+          tags: 'tags',
+          status: 'status',
+        }.freeze
+      end
+
+      def id
+        val = @id
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def name
+        val = @name
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def category
+        val = @category
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def photo_urls
+        val = @photo_urls
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def tags
+        val = @tags
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def status
+        val = @status
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(
+        id: ::RubyGemsPublishTest::Models::UNSET,
+        name: ::RubyGemsPublishTest::Models::UNSET,
+        category: ::RubyGemsPublishTest::Models::UNSET,
+        photo_urls: ::RubyGemsPublishTest::Models::UNSET,
+        tags: ::RubyGemsPublishTest::Models::UNSET,
+        status: ::RubyGemsPublishTest::Models::UNSET,
+        additional_properties: {}
+      )
+        @id = id
+        @name = name
+        @category = category
+        @photo_urls = photo_urls
+        @tags = tags
+        @status = status
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          id: hash.fetch('id', ::RubyGemsPublishTest::Models::UNSET),
+          name: hash.fetch('name', ::RubyGemsPublishTest::Models::UNSET),
+          category:
+            hash.key?('category') ? ::RubyGemsPublishTest::Models::Category.from_hash(hash['category']) : ::RubyGemsPublishTest::Models::UNSET,
+          photo_urls: hash.fetch('photoUrls', ::RubyGemsPublishTest::Models::UNSET),
+          tags: hash.fetch('tags', ::RubyGemsPublishTest::Models::UNSET),
+          status: hash.fetch('status', ::RubyGemsPublishTest::Models::UNSET),
+          additional_properties: hash.except('id', 'name', 'category', 'photoUrls', 'tags', 'status'),
+        )
+      end
+
+      def attributes
+        {
+          id: @id,
+          name: @name,
+          category: @category,
+          photo_urls: @photo_urls,
+          tags: @tags,
+          status: @status,
+        }
+      end
+
+      def validate!
+        @category&.validate! if !@category.equal?(::RubyGemsPublishTest::Models::UNSET) && @category.respond_to?(:validate!)
+        @tags&.each { |item| item.validate! if item.respond_to?(:validate!) } unless @tags.equal?(::RubyGemsPublishTest::Models::UNSET)
+        @status&.validate! if !@status.equal?(::RubyGemsPublishTest::Models::UNSET) && @status.respond_to?(:validate!)
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/models/pet_status.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    module PetStatus
+      AVAILABLE = 'available'
+      PENDING = 'pending'
+      SOLD = 'sold'
+      VALUES = [AVAILABLE, PENDING, SOLD].freeze
+    end
+  end
+end

data/lib/ruby_gems_publish_test/models/serializable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    # Sentinel value for model fields that were never explicitly set.
+    # Distinguishes "field not provided" from "field explicitly set to nil",
+    # which matters for PATCH requests where nil means "clear this field".
+    UNSET = Object.new.tap do |o|
+      o.define_singleton_method(:inspect) { 'UNSET' }
+      o.define_singleton_method(:to_s) { 'UNSET' }
+    end.freeze
+
+    # Marker module for generated model classes.
+    #
+    # Including classes must implement:
+    #   - .wire_keys → { attr_sym: 'wire_name', ... }.freeze
+    #   - .from_hash(hash) → model instance or nil
+    #   - #attributes → { attr_sym: raw_value, ... }
+    #
+    # In return, this module provides:
+    #   - #to_h → { attr_sym: value, ... } with nested models recursively converted,
+    #             omitting fields set to UNSET but preserving explicit nil
+    module Serializable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def wire_keys
+          raise NotImplementedError, "#{name} must implement .wire_keys"
+        end
+
+        def from_hash(_hash)
+          raise NotImplementedError, "#{name} must implement .from_hash"
+        end
+      end
+
+      def to_h
+        self.class.wire_keys.each_with_object({}) do |(attr, _key), hash|
+          val = attributes[attr]
+          next if val.equal?(UNSET)
+
+          hash[attr] = coerce_to_h(val)
+        end
+      end
+
+      def attributes
+        raise NotImplementedError, "#{self.class} must implement #attributes"
+      end
+
+      private
+
+      def coerce_to_h(val)
+        return val.to_h if val.is_a?(Serializable)
+        return val.map { |item| coerce_to_h(item) } if val.is_a?(Array)
+        # Typed maps (additionalProperties): recurse values, preserving the dynamic string keys.
+        return val.transform_values { |item| coerce_to_h(item) } if val.is_a?(Hash)
+
+        val
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/models/tag.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    class Tag
+      include ::RubyGemsPublishTest::Models::Serializable
+      include ::RubyGemsPublishTest::Models::OpenModel
+
+      def self.wire_keys
+        {
+          id: 'id',
+          name: 'name',
+        }.freeze
+      end
+
+      def id
+        val = @id
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def name
+        val = @name
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(
+        id: ::RubyGemsPublishTest::Models::UNSET,
+        name: ::RubyGemsPublishTest::Models::UNSET,
+        additional_properties: {}
+      )
+        @id = id
+        @name = name
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          id: hash.fetch('id', ::RubyGemsPublishTest::Models::UNSET),
+          name: hash.fetch('name', ::RubyGemsPublishTest::Models::UNSET),
+          additional_properties: hash.except('id', 'name'),
+        )
+      end
+
+      def attributes
+        {
+          id: @id,
+          name: @name,
+        }
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/models/union_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    # Marker module for oneOf/anyOf union wrapper classes.
+    #
+    # Including classes hold one typed variant in +#value+.
+    # Serializers check for this module to delegate serialization to the wrapped value.
+    module UnionType
+    end
+  end
+end

data/lib/ruby_gems_publish_test/models/user.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubyGemsPublishTest
+  module Models
+    class User
+      include ::RubyGemsPublishTest::Models::Serializable
+      include ::RubyGemsPublishTest::Models::OpenModel
+
+      def self.wire_keys
+        {
+          id: 'id',
+          username: 'username',
+          first_name: 'firstName',
+          last_name: 'lastName',
+          email: 'email',
+          password: 'password',
+          phone: 'phone',
+          user_status: 'userStatus',
+        }.freeze
+      end
+
+      def id
+        val = @id
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def username
+        val = @username
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def first_name
+        val = @first_name
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def last_name
+        val = @last_name
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def email
+        val = @email
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def password
+        val = @password
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def phone
+        val = @phone
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      def user_status
+        val = @user_status
+        val.equal?(::RubyGemsPublishTest::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(
+        id: ::RubyGemsPublishTest::Models::UNSET,
+        username: ::RubyGemsPublishTest::Models::UNSET,
+        first_name: ::RubyGemsPublishTest::Models::UNSET,
+        last_name: ::RubyGemsPublishTest::Models::UNSET,
+        email: ::RubyGemsPublishTest::Models::UNSET,
+        password: ::RubyGemsPublishTest::Models::UNSET,
+        phone: ::RubyGemsPublishTest::Models::UNSET,
+        user_status: ::RubyGemsPublishTest::Models::UNSET,
+        additional_properties: {}
+      )
+        @id = id
+        @username = username
+        @first_name = first_name
+        @last_name = last_name
+        @email = email
+        @password = password
+        @phone = phone
+        @user_status = user_status
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          id: hash.fetch('id', ::RubyGemsPublishTest::Models::UNSET),
+          username: hash.fetch('username', ::RubyGemsPublishTest::Models::UNSET),
+          first_name: hash.fetch('firstName', ::RubyGemsPublishTest::Models::UNSET),
+          last_name: hash.fetch('lastName', ::RubyGemsPublishTest::Models::UNSET),
+          email: hash.fetch('email', ::RubyGemsPublishTest::Models::UNSET),
+          password: hash.fetch('password', ::RubyGemsPublishTest::Models::UNSET),
+          phone: hash.fetch('phone', ::RubyGemsPublishTest::Models::UNSET),
+          user_status: hash.fetch('userStatus', ::RubyGemsPublishTest::Models::UNSET),
+          additional_properties:
+            hash.except('id', 'username', 'firstName', 'lastName', 'email', 'password', 'phone', 'userStatus'),
+        )
+      end
+
+      def attributes
+        {
+          id: @id,
+          username: @username,
+          first_name: @first_name,
+          last_name: @last_name,
+          email: @email,
+          password: @password,
+          phone: @phone,
+          user_status: @user_status,
+        }
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/serializers/form_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RubyGemsPublishTest
+  module Serializers
+    # Serializes models or hashes to form-encoded and multipart bodies.
+    module Form
+      # Encodes a model or hash as application/x-www-form-urlencoded.
+      def self.to_urlencoded(value)
+        URI.encode_www_form(flatten(value))
+      end
+
+      # Configures a Net::HTTP request for multipart/form-data.
+      def self.set_multipart(request, value)
+        request.set_form(
+          flatten(value).map { |k, v| [k.to_s, v.to_s] },
+          'multipart/form-data',
+        )
+      end
+
+      private_class_method def self.flatten(value)
+        value = value.value if value.is_a?(Models::UnionType)
+        if value.is_a?(Models::Serializable)
+          declared = value.class.wire_keys.filter_map do |attr, key|
+            val = value.attributes[attr]
+            # Form encoding cannot represent null; both UNSET and explicit nil are omitted.
+            # Unlike JSON (which serializes nil as null), form bodies have no null concept.
+            [key, val] unless val.nil? || val.equal?(Models::UNSET)
+          end
+          extras = value.is_a?(Models::OpenModel) ? value.open_model_extras.compact.to_a : []
+          declared + extras
+        elsif value.is_a?(Hash)
+          value.compact.to_a
+        else
+          [['body', value.to_s]]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/serializers/json_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubyGemsPublishTest
+  module Serializers
+    # Serializes models to JSON-ready hashes and deserializes hashes back to models.
+    module Json
+      # Converts a model, array, or primitive to a plain Ruby hash/value
+      # suitable for JSON.generate / .to_json.
+      def self.serialize(value)
+        return value.map { |item| serialize(item) } if value.is_a?(Array)
+        # Typed maps (additionalProperties): serialize values, keeping the dynamic string keys.
+        return value.transform_values { |item| serialize(item) } if value.is_a?(Hash)
+        return serialize(value.value) if value.is_a?(Models::UnionType)
+        return serialize_model(value) if value.is_a?(Models::Serializable)
+
+        value
+      end
+
+      # Builds a model instance from a plain hash (already JSON.parsed).
+      # Returns the raw data unchanged when no model class is provided.
+      def self.deserialize(data, model_class = nil)
+        return data unless model_class
+
+        model_class.from_hash(data)
+      end
+
+      private_class_method def self.serialize_model(model)
+        result = model.class.wire_keys.each_with_object({}) do |(attr, key), hash|
+          val = model.attributes[attr]
+          next if val.equal?(Models::UNSET)
+
+          hash[key] = serialize(val)
+        end
+        model.open_model_extras.each { |k, v| result[k] = serialize(v) unless result.key?(k) } if model.is_a?(Models::OpenModel)
+        result
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/serializers/xml_serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module RubyGemsPublishTest
+  module Serializers
+    # Serializes models to XML strings and deserializes XML strings back to models.
+    # Uses Ruby's stdlib REXML.
+    module Xml
+      # Converts a model or primitive to an XML string.
+      # root: the name of the wrapping XML element (defaults to 'root').
+      def self.serialize(value, root: 'root')
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+        build_element(doc.add_element(root.to_s), value)
+        doc.to_s
+      end
+
+      # Builds a model instance from an XML string.
+      # Returns the raw string unchanged when no model class is provided.
+      def self.deserialize(xml_string, model_class = nil, root: nil)
+        return xml_string unless model_class
+        return unless xml_string
+
+        doc  = REXML::Document.new(xml_string)
+        el   = root ? (doc.root.elements[root.to_s] || doc.root) : doc.root
+        hash = element_to_hash(el, model_class)
+        model_class.from_hash(hash)
+      end
+
+      private_class_method def self.build_element(parent, value)
+        case value
+        when Models::UnionType
+          build_element(parent, value.value)
+        when Models::Serializable
+          value.class.wire_keys.each do |attr, key|
+            build_element(parent.add_element(key.to_s), value.attributes[attr])
+          end
+        when Array
+          value.each { |item| build_element(parent.add_element('item'), item) }
+        when nil
+          nil
+        else
+          parent.text = value.to_s
+        end
+      end
+
+      private_class_method def self.element_to_hash(element, model_class)
+        model_class.wire_keys.each_with_object({}) do |(_attr, key), hash|
+          child      = element.elements[key.to_s]
+          hash[key]  = child&.text
+        end
+      end
+    end
+  end
+end

data/lib/ruby_gems_publish_test/services/pet.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RubyGemsPublishTest
+  class Pet
+    NO_OVERRIDE = Object.new.freeze
+    private_constant :NO_OVERRIDE
+
+    def initialize(connection, config = nil)
+      @connection = connection
+      @config = config
+    end
+
+    # Add a new pet to the store.
+    def add_pet(body:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      body.validate! if body.respond_to?(:validate!)
+      conn = resolve_connection(config)
+      response = conn.post('/pet', body, headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::RubyGemsPublishTest::Models::Pet.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Update an existing pet.
+    def update_pet(body:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      body.validate! if body.respond_to?(:validate!)
+      conn = resolve_connection(config)
+      response = conn.put('/pet', body, headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::RubyGemsPublishTest::Models::Pet.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Finds Pets by status.
+    def find_pets_by_status(status:, config: NO_OVERRIDE)
+      query_params = {
+        'status' => status,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.get('/pet/findByStatus', query_params, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = response.body.map { |item| ::RubyGemsPublishTest::Models::Pet.from_hash(item) }
+      result&.each { |item| item&.validate! } if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Finds Pets by tags.
+    def find_pets_by_tags(tags:, config: NO_OVERRIDE)
+      query_params = {
+        'tags' => tags,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.get('/pet/findByTags', query_params, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = response.body.map { |item| ::RubyGemsPublishTest::Models::Pet.from_hash(item) }
+      result&.each { |item| item&.validate! } if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Find pet by ID.
+    def get_pet_by_id(pet_id:, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.get("/pet/#{pet_id}", {}, headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::RubyGemsPublishTest::Models::Pet.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Updates a pet in the store with form data.
+    def update_pet_with_form(pet_id:, name: nil, status: nil, config: NO_OVERRIDE)
+      query_params = {
+        'name' => name,
+        'status' => status,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      url = query_params.empty? ? "/pet/#{pet_id}" : "/pet/#{pet_id}?#{URI.encode_www_form(query_params)}"
+      response = conn.post(url, nil, headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::RubyGemsPublishTest::Models::Pet.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    # Deletes a pet.
+    def delete_pet(pet_id:, api_key: nil, config: NO_OVERRIDE)
+      headers = config_headers(config).merge(
+        {
+          'api_key' => api_key,
+        }.compact,
+      ).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      response = conn.delete("/pet/#{pet_id}", headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      response.body
+    end
+
+    # Uploads an image.
+    def upload_file(pet_id:, additional_metadata: nil, body: nil, config: NO_OVERRIDE)
+      query_params = {
+        'additionalMetadata' => additional_metadata,
+      }.compact
+      query_params = query_params.merge(resolve_config(config)&.additional_query_parameters || {})
+      headers = config_headers(config).merge(resolve_config(config)&.additional_headers || {})
+      conn = resolve_connection(config)
+      url = query_params.empty? ? "/pet/#{pet_id}/uploadImage" : "/pet/#{pet_id}/uploadImage?#{URI.encode_www_form(query_params)}"
+      response = conn.post(url, body, content_type: 'application/octet-stream', headers: headers)
+      return response if !config.equal?(NO_OVERRIDE) && config&.return_raw
+      result = ::RubyGemsPublishTest::Models::ApiResponse.from_hash(response.body)
+      result&.validate! if resolve_config(config)&.enable_response_validation
+      result
+    end
+
+    private
+
+    def config_headers(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return {} unless cfg
+
+      HTTP::Auth.new(token: cfg.token, api_key: cfg.api_key).headers
+    end
+
+    def resolve_connection(override_config)
+      cfg = override_config.equal?(NO_OVERRIDE) ? @config : override_config
+      return @connection unless cfg&.base_url || cfg&.timeout || cfg&.retry_config
+
+      HTTP::Connection.new(
+        cfg.base_url || @connection.base_url,
+        @connection.default_headers,
+        timeout: cfg.timeout || @connection.timeout,
+        retry_config: cfg.retry_config || @connection.retry_config,
+      )
+    end
+
+    def resolve_config(override_config)
+      override_config.equal?(NO_OVERRIDE) ? @config : override_config
+    end
+  end
+end