sperant-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 870356b1e113b4da8ab850d488569b39b1d8ba1ef626d66d71b365abfd582935
+  data.tar.gz: ff69f45c39a84969c6fbbe740a10c0b5256aeb89f8342f93d7b1c84eb74b3c39
+SHA512:
+  metadata.gz: 84410faecd8b3829e4ddd6475cd55341caafd32b8936a91433be2d96acbcd0851c862b2601ea9ed2dbfa9cb4a1d99ebb8eacbd89c3beff8f6a4436c7057711c6
+  data.tar.gz: fe670ebde1bef5c54286c40c4da34cb6ba35a3c35f69e949c92d5eebbb53a9339aafe9a05c3ec77e02bdecfa6858feb6ab8dabe64ee6f58779e247617c9b8fa0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Eterniasoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# Sperant API
+
+Cliente Ruby para la [API v3 de Sperant](https://sperant.gitbook.io/apiv3). Permite consultar proyectos, clientes y unidades de forma sencilla, con configuración de token y entorno (prueba o producción).
+
+---
+
+## ⚠️ Esta gema no es oficial
+
+**Esta gema no es oficial.** Es mantenida por **vitualizz** y **no está respaldada ni por Eterniasoft ni por Sperant.**
+
+La documentación oficial de la API está en [sperant.gitbook.io/apiv3](https://sperant.gitbook.io/apiv3).
+
+---
+
+## Instalación
+
+Añade la gema a tu `Gemfile`:
+
+```ruby
+gem "sperant-api"
+```
+
+Luego ejecuta:
+
+```bash
+bundle install
+```
+
+O instala la gema directamente:
+
+```bash
+gem install sperant-api
+```
+
+## Configuración
+
+### Uso standalone (script o consola)
+
+Puedes configurar la gema de forma global y luego usar el cliente sin argumentos:
+
+```ruby
+require "sperant_api"
+
+SperantApi.configure do |c|
+  c.access_token = "tu-token-entregado-por-sperant"
+  c.environment = :test   # o :production
+end
+
+client = SperantApi::Client.new
+```
+
+O crear un cliente con configuración explícita (sin usar la configuración global):
+
+```ruby
+require "sperant_api"
+
+client = SperantApi::Client.new(
+  access_token: "tu-token",
+  environment: :production
+)
+```
+
+- **`environment`**: `:test` (por defecto) usa `https://api.eterniasoft.com`; `:production` usa `https://api.sperant.com`.
+- **`access_token`**: Token API Key proporcionado por Sperant (solicitar a soporte@sperant.com).
+
+### Uso en Ruby on Rails
+
+Crea un inicializador, por ejemplo `config/initializers/sperant_api.rb`:
+
+```ruby
+require "sperant_api"
+
+SperantApi.configure do |c|
+  c.access_token = ENV["SPERANT_API_TOKEN"] || Rails.application.credentials.dig(:sperant, :api_token)
+  c.environment = Rails.env.production? ? :production : :test
+end
+```
+
+Luego en controladores o servicios:
+
+```ruby
+client = SperantApi::Client.new
+client.projects.list(q: "Prados")
+```
+
+## Uso básico
+
+### Listar proyectos
+
+```ruby
+client = SperantApi::Client.new(access_token: "tu-token", environment: :test)
+
+# Todos los proyectos (paginado, 20 por página)
+response = client.projects.list
+response.data      # array de proyectos
+response.meta      # metadatos (p. ej. page.total)
+response.links     # enlaces de paginación
+response.total_pages
+
+# Con filtros
+response = client.projects.list(q: "Prados")
+response = client.projects.list(code: "PRADOS")
+response = client.projects.list(page: 2)
+```
+
+### Listar clientes
+
+```ruby
+response = client.clients.list
+response = client.clients.list(q: "+51999...")  # filtrar por documento, email o celular (con código de país)
+response = client.clients.list(page: 1)
+```
+
+### Listar unidades de un proyecto
+
+```ruby
+response = client.units.list(project_id: 7)
+response = client.units.list(
+  project_id: 7,
+  block_id: 10,                    # ID de subdivisión (opcional)
+  commercial_status_id: 1,         # 1=Disponible, 2=No disponible, etc. (opcional)
+  page: 2
+)
+```
+
+## Respuesta paginada
+
+Los métodos `list` devuelven un objeto `SperantApi::Response::Paginated` con:
+
+- **`data`**: array de ítems (proyectos, clientes o unidades).
+- **`meta`**: hash con metadatos (p. ej. `meta["page"]["total"]`).
+- **`links`**: hash con enlaces de paginación (`prev`, `next`, `last`).
+- **`total_pages`**: atajo a `meta.dig("page", "total")`.
+
+La API devuelve 20 elementos por página por defecto.
+
+## Manejo de errores
+
+La gema define excepciones específicas que puedes rescatar:
+
+```ruby
+begin
+  client.projects.list
+rescue SperantApi::ConfigurationError => e
+  # Token faltante o inválido, entorno no permitido
+rescue SperantApi::RateLimitError => e
+  # Límite de 15 peticiones por segundo superado (429)
+rescue SperantApi::ApiError => e
+  # Otro error HTTP (4xx/5xx)
+  puts "Status: #{e.status_code}, body: #{e.response_body}"
+end
+```
+
+## Rate limit
+
+Según la documentación de Sperant, el límite es de **15 peticiones por segundo**. Respeta este límite en tu integración para evitar `SperantApi::RateLimitError`.
+
+## Documentación de la API
+
+- [Introducción y esquema](https://sperant.gitbook.io/apiv3)
+- [Listar proyectos](https://sperant.gitbook.io/apiv3/proyecto/listar-proyectos)
+- [Listar clientes](https://sperant.gitbook.io/apiv3/clientes/listar-cliente)
+- [Listar unidades](https://sperant.gitbook.io/apiv3/unidades/listar-unidades)
+
+## Desarrollo y pruebas
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+### Documentación (YARD)
+
+La API pública está documentada con [YARD](https://yardoc.org). Para generar la documentación HTML:
+
+```bash
+bundle exec yard doc
+```
+
+Se generará el directorio `doc/` con la documentación. Abre `doc/index.html` en el navegador.
+
+## Licencia
+
+MIT. Ver [LICENSE](LICENSE).

data/lib/sperant_api/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SperantApi
+  # Punto de entrada principal: expone los recursos (proyectos, clientes, unidades)
+  # y usa la configuración global o la pasada en la construcción.
+  class Client
+    # @return [Configuration] Configuración usada por este cliente.
+    attr_reader :configuration
+    # @return [Resources::Projects] Recurso para listar proyectos.
+    attr_reader :projects
+    # @return [Resources::Clients] Recurso para listar clientes.
+    attr_reader :clients
+    # @return [Resources::Units] Recurso para listar unidades de un proyecto.
+    attr_reader :units
+
+    # Crea un cliente. La configuración se resuelve en este orden:
+    # 1. El objeto +configuration+ si se pasa.
+    # 2. Una nueva {Configuration} con +access_token+ (y opcionalmente +environment+).
+    # 3. La configuración global de {SperantApi.configure} (si existe).
+    #
+    # @param configuration [Configuration, nil] Configuración ya construida (opcional).
+    # @param access_token [String, nil] Token API (opcional si hay configuración global o +configuration+).
+    # @param environment [Symbol, nil] +:test+ o +:production+ (solo se usa si se pasa +access_token+).
+    # @return [Client]
+    # @raise [ConfigurationError] Si no hay configuración ni token ni configuración global.
+    #
+    # @example Con configuración global
+    #   SperantApi.configure { |c| c.access_token = "token"; c.environment = :test }
+    #   client = SperantApi::Client.new
+    #
+    # @example Con parámetros explícitos
+    #   client = SperantApi::Client.new(access_token: "token", environment: :production)
+    def initialize(configuration: nil, access_token: nil, environment: nil)
+      @configuration = resolve_configuration(
+        configuration: configuration,
+        access_token: access_token,
+        environment: environment
+      )
+      conn = Connection.new(configuration: @configuration)
+      @projects = Resources::Projects.new(connection: conn)
+      @clients = Resources::Clients.new(connection: conn)
+      @units = Resources::Units.new(connection: conn)
+    end
+
+    private
+
+    def resolve_configuration(configuration:, access_token:, environment:)
+      return configuration if configuration
+
+      if access_token
+        opts = { access_token: access_token }
+        opts[:environment] = environment if environment
+        return Configuration.new(**opts)
+      end
+
+      SperantApi.configuration || raise(ConfigurationError, "No configuration. Set SperantApi.configure { ... } or pass access_token:")
+    end
+  end
+end

data/lib/sperant_api/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SperantApi
+  # Configuración del cliente: token, entorno y tamaño de página.
+  # Se valida el entorno al asignar y el token al asignar o al llamar a {#validate!}.
+  class Configuration
+    # @return [String, nil] Token API Key proporcionado por Sperant.
+    attr_accessor :access_token
+    # @return [Symbol] Entorno: +:test+ (api.eterniasoft.com) o +:production+ (api.sperant.com).
+    attr_accessor :environment
+    # @return [Integer] Tamaño de página por defecto para listados (p. ej. 20).
+    attr_accessor :page_size
+
+    # @param access_token [String, nil] Token de la API (opcional en la construcción).
+    # @param environment [Symbol, String] +:test+ o +:production+. Por defecto +:test+.
+    # @param page_size [Integer] Número de elementos por página (por defecto 20).
+    def initialize(access_token: nil, environment: Constants::ENVIRONMENTS.first, page_size: Constants::DEFAULT_PAGE_SIZE)
+      @access_token = access_token
+      @environment = environment.to_sym
+      @page_size = page_size
+      validate_environment!
+      validate_token! if access_token
+    end
+
+    # @param value [Symbol, String] +:test+ o +:production+.
+    def environment=(value)
+      @environment = value.to_sym
+      validate_environment!
+    end
+
+    # @param value [String, nil] Token de la API.
+    def access_token=(value)
+      @access_token = value
+      validate_token!
+    end
+
+    # URL base según el entorno configurado.
+    # @return [String] URL base (ej. https://api.eterniasoft.com o https://api.sperant.com).
+    # @raise [ConfigurationError] Si el entorno no es reconocido.
+    def base_url
+      base = Constants::BASE_URLS[environment]
+      raise ConfigurationError, "Unknown environment: #{environment}" unless base
+
+      base
+    end
+
+    # Valida token y entorno. Útil antes de realizar peticiones.
+    # @raise [ConfigurationError] Si el token está vacío o el entorno es inválido.
+    def validate!
+      validate_token!
+      validate_environment!
+    end
+
+    private
+
+    def validate_token!
+      token = access_token.to_s.strip
+      raise ConfigurationError, "access_token is required" if token.empty?
+    end
+
+    def validate_environment!
+      return if Constants::ENVIRONMENTS.include?(environment)
+
+      raise ConfigurationError,
+            "Invalid environment: #{environment}. Must be one of: #{Constants::ENVIRONMENTS.join(', ')}"
+    end
+  end
+end

data/lib/sperant_api/connection.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module SperantApi
+  class Connection
+    attr_reader :configuration, :adapter
+
+    def initialize(configuration:, adapter: nil)
+      @configuration = configuration
+      @adapter = adapter
+    end
+
+    def get(path, query_params = {})
+      configuration.validate!
+      uri = build_uri(path, query_params)
+      request = build_request(uri)
+      response = perform_request(uri, request)
+      handle_response(response)
+    end
+
+    private
+
+    def build_uri(path, query_params)
+      path = path.join("/") if path.is_a?(Array)
+      base = configuration.base_url
+      version = Constants::API_VERSION
+      path_part = [version, path].join("/").gsub(%r{/+}, "/")
+      base_uri = URI.parse(base)
+      query_string = query_params.any? { |_, v| !v.nil? && v != "" } ? URI.encode_www_form(query_params.compact) : nil
+      URI::HTTPS.build(host: base_uri.host, port: base_uri.port, path: "/#{path_part}", query: query_string)
+    end
+
+    def build_request(uri)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request[Constants::HEADER_AUTHORIZATION] = configuration.access_token
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "application/json"
+      request
+    end
+
+    def perform_request(uri, request)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.request(request)
+    end
+
+    def handle_response(response)
+      status = response.code.to_i
+      body = response.body.to_s
+
+      case status
+      when 200..299
+        body.empty? ? {} : JSON.parse(body)
+      when Constants::HTTP_STATUS_RATE_LIMIT
+        raise RateLimitError.new(response_body: body)
+      when 400..599
+        raise ApiError.new(
+          "Request failed with status #{response.code}",
+          status_code: status,
+          response_body: body
+        )
+      else
+        body.empty? ? {} : JSON.parse(body)
+      end
+    end
+  end
+end

data/lib/sperant_api/constants.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Constants
+    ENVIRONMENTS = %i[test production].freeze
+
+    BASE_URLS = {
+      test: "https://api.eterniasoft.com",
+      production: "https://api.sperant.com"
+    }.freeze
+
+    API_VERSION = "v3"
+    DEFAULT_PAGE_SIZE = 20
+
+    HEADER_AUTHORIZATION = "Authorization"
+
+    PATH_PROJECTS = "projects"
+    PATH_CLIENTS = "clients"
+    PATH_UNITS = "units"
+
+    HTTP_STATUS_RATE_LIMIT = 429
+  end
+end

data/lib/sperant_api/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SperantApi
+  # Error base de la gema. Todas las excepciones específicas heredan de esta.
+  class Error < StandardError; end
+
+  # Error de configuración: token faltante o inválido, entorno no permitido, etc.
+  class ConfigurationError < Error; end
+
+  # Error devuelto por la API (respuesta 4xx/5xx). Incluye código HTTP y cuerpo de respuesta.
+  class ApiError < Error
+    # @return [Integer, nil] Código de estado HTTP (ej. 404, 500).
+    attr_reader :status_code
+    # @return [String, nil] Cuerpo de la respuesta HTTP.
+    attr_reader :response_body
+
+    # @param message [String, nil] Mensaje de error (por defecto se genera con +status_code+).
+    # @param status_code [Integer, nil] Código HTTP.
+    # @param response_body [String, nil] Cuerpo de la respuesta.
+    def initialize(message = nil, status_code: nil, response_body: nil)
+      @status_code = status_code
+      @response_body = response_body
+      super(message || "API request failed (status: #{status_code})")
+    end
+  end
+
+  # Límite de tasa superado (HTTP 429). Sperant permite 15 peticiones por segundo.
+  class RateLimitError < ApiError
+    # @param message [String] Mensaje por defecto sobre el límite de 15 req/s.
+    # @param status_code [Integer] 429.
+    # @param response_body [String, nil] Cuerpo de la respuesta.
+    def initialize(message = "Rate limit exceeded (15 requests per second)", status_code: 429, response_body: nil)
+      super(message, status_code: status_code, response_body: response_body)
+    end
+  end
+end

data/lib/sperant_api/resources/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Resources
+    # Clase base para recursos que exponen listados paginados.
+    # Las subclases definen +list+ y usan {#get_list} con el path y parámetros adecuados.
+    class Base
+      # @return [Connection] Conexión HTTP usada para las peticiones.
+      attr_reader :connection
+
+      # @param connection [Connection] Conexión ya configurada.
+      def initialize(connection:)
+        @connection = connection
+      end
+
+      protected
+
+      # Realiza GET al path y devuelve una respuesta paginada.
+      # @param path [String, Array<String>] Segmentos del path (se unen con +/+).
+      # @param query_params [Hash] Parámetros de consulta.
+      # @return [Response::Paginated]
+      def get_list(path, query_params = {})
+        path = Array(path).join("/")
+        raw = connection.get(path, query_params)
+        build_paginated_response(raw)
+      end
+
+      def build_paginated_response(raw)
+        Response::Paginated.new(
+          data: raw["data"] || [],
+          meta: raw["meta"] || {},
+          links: raw["links"] || {}
+        )
+      end
+    end
+  end
+end

data/lib/sperant_api/resources/clients.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Resources
+    # Recurso de clientes. Permite listar clientes con filtros opcionales.
+    class Clients < Base
+      # Lista clientes (paginado). El parámetro +q+ filtra por documento, email o celular (con código de país).
+      #
+      # @param q [String, nil] Búsqueda (ej. "+51999..." para celular).
+      # @param page [Integer, nil] Número de página.
+      # @return [Response::Paginated] Respuesta con +data+, +meta+, +links+ y +total_pages+.
+      #
+      # @example
+      #   response = client.clients.list
+      #   response = client.clients.list(q: "+51999123456")
+      def list(q: nil, page: nil)
+        query = { q: q, page: page }.compact
+        get_list(Constants::PATH_CLIENTS, query)
+      end
+    end
+  end
+end

data/lib/sperant_api/resources/projects.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Resources
+    # Recurso de proyectos. Permite listar proyectos con filtros opcionales.
+    class Projects < Base
+      # Lista proyectos (paginado, 20 por página por defecto).
+      #
+      # @param code [String, nil] Filtrar por código del proyecto.
+      # @param q [String, nil] Búsqueda (nombre, código, etc.).
+      # @param page [Integer, nil] Número de página.
+      # @return [Response::Paginated] Respuesta con +data+, +meta+, +links+ y +total_pages+.
+      #
+      # @example
+      #   response = client.projects.list
+      #   response = client.projects.list(q: "Prados", page: 2)
+      def list(code: nil, q: nil, page: nil)
+        query = { code: code, q: q, page: page }.compact
+        get_list(Constants::PATH_PROJECTS, query)
+      end
+    end
+  end
+end

data/lib/sperant_api/resources/units.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Resources
+    # Recurso de unidades. Lista unidades de un proyecto (y opcionalmente por bloque o estado comercial).
+    class Units < Base
+      # Lista unidades de un proyecto (paginado).
+      #
+      # @param project_id [Integer] ID del proyecto.
+      # @param block_id [Integer, nil] ID de subdivisión/bloque (opcional).
+      # @param commercial_status_id [Integer, nil] Estado comercial (ej. 1=Disponible, 2=No disponible) (opcional).
+      # @param page [Integer, nil] Número de página.
+      # @return [Response::Paginated] Respuesta con +data+, +meta+, +links+ y +total_pages+.
+      #
+      # @example
+      #   response = client.units.list(project_id: 7)
+      #   response = client.units.list(project_id: 7, commercial_status_id: 1, page: 2)
+      def list(project_id:, block_id: nil, commercial_status_id: nil, page: nil)
+        path = [Constants::PATH_PROJECTS, project_id, Constants::PATH_UNITS]
+        query = { block_id: block_id, commercial_status_id: commercial_status_id, page: page }.compact
+        get_list(path, query)
+      end
+    end
+  end
+end

data/lib/sperant_api/response/paginated.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SperantApi
+  module Response
+    # Respuesta paginada de los métodos +list+ de los recursos.
+    # Encapsula +data+, +meta+ y +links+ para no depender de hashes con keys literales.
+    class Paginated
+      # @return [Array<Hash>] Lista de ítems (proyectos, clientes o unidades).
+      attr_reader :data
+      # @return [Hash] Metadatos de la API (p. ej. +"page" => { "total" => 5 }+).
+      attr_reader :meta
+      # @return [Hash] Enlaces de paginación (+prev+, +next+, +last+, etc.).
+      attr_reader :links
+
+      # @param data [Array] Array de ítems.
+      # @param meta [Hash] Metadatos.
+      # @param links [Hash] Enlaces de paginación.
+      def initialize(data:, meta: {}, links: {})
+        @data = data
+        @meta = meta
+        @links = links
+      end
+
+      # Número total de páginas según la API.
+      # @return [Integer, nil] Valor de +meta["page"]["total"]+ o nil si no está presente.
+      def total_pages
+        meta.dig("page", "total")
+      end
+    end
+  end
+end

data/lib/sperant_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SperantApi
+  VERSION = "0.1.0"
+end

data/lib/sperant_api.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "sperant_api/version"
+require_relative "sperant_api/constants"
+require_relative "sperant_api/errors"
+require_relative "sperant_api/configuration"
+require_relative "sperant_api/connection"
+require_relative "sperant_api/response/paginated"
+require_relative "sperant_api/resources/base"
+require_relative "sperant_api/resources/projects"
+require_relative "sperant_api/resources/clients"
+require_relative "sperant_api/resources/units"
+require_relative "sperant_api/client"
+
+# Cliente Ruby no oficial para la API v3 de Sperant (proyectos, clientes, unidades).
+# Configuración por token y entorno (:test o :production).
+#
+# @example Configuración global y uso del cliente
+#   SperantApi.configure do |c|
+#     c.access_token = "tu-token"
+#     c.environment = :test
+#   end
+#   client = SperantApi::Client.new
+#   client.projects.list(q: "Prados")
+#
+# @see https://sperant.gitbook.io/apiv3 Documentación oficial de la API
+module SperantApi
+  class << self
+    # @return [Configuration, nil] Configuración global actual (nil hasta llamar a {configure}).
+    attr_accessor :configuration
+
+    # Configura la gema de forma global. Crea una instancia de {Configuration} si no existe
+    # y permite modificarla mediante el bloque.
+    #
+    # @yield [configuration] Bloque opcional que recibe la configuración.
+    # @yieldparam configuration [Configuration] Objeto de configuración a modificar.
+    # @return [Configuration] La configuración resultante.
+    #
+    # @example
+    #   SperantApi.configure do |c|
+    #     c.access_token = ENV["SPERANT_API_TOKEN"]
+    #     c.environment = :production
+    #   end
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+      configuration
+    end
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: sperant-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lee Palacios
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 'Unofficial client gem for Sperant API v3: projects, clients, and units.
+  Configurable token and test/production environment. Not maintained by Sperant.'
+email:
+- vitualizz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sperant_api.rb
+- lib/sperant_api/client.rb
+- lib/sperant_api/configuration.rb
+- lib/sperant_api/connection.rb
+- lib/sperant_api/constants.rb
+- lib/sperant_api/errors.rb
+- lib/sperant_api/resources/base.rb
+- lib/sperant_api/resources/clients.rb
+- lib/sperant_api/resources/projects.rb
+- lib/sperant_api/resources/units.rb
+- lib/sperant_api/response/paginated.rb
+- lib/sperant_api/version.rb
+homepage: https://github.com/eterniasoft/sperant-api-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/eterniasoft/sperant-api-ruby
+  source_code_uri: https://github.com/eterniasoft/sperant-api-ruby
+  documentation_uri: https://sperant.gitbook.io/apiv3
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Unofficial Ruby client for Sperant API v3
+test_files: []