docker-swarm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97102c26aff73c5426373e1cfbfb542fd2cf4e82404a3b1de4833b8e82d5d66a
+  data.tar.gz: 3a9288b1dc9eae6d4849503de616561c94af264ec467e9450c2a4e2863e4706f
+SHA512:
+  metadata.gz: fb9eea1d60221c643681e50ea18a4a9830967e46ef226543c62df85c26102c9fd60b26a6f77f35f12c6e5ff86ca15ec280175ca656c266587e7737414837f91c
+  data.tar.gz: 0b223dd63b9c69a14a24c07b3be527876d9535c1114f53a507152fd2d28cbf126a387b0b72ddbba18290aa621c49369adaf83f2e80ca68f3d2dad8def9c749bf

data/README.md

@@ -0,0 +1,63 @@
+# Docker Swarm Gem
+
+[![Gem Version](https://badge.fury.io/rb/docker-swarm.svg)](https://badge.fury.io/rb/docker-swarm)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`docker-swarm` es un ORM ligero y cliente API robusto para interactuar con Docker Swarm desde Ruby. Diseñado para sentirse familiar a los desarrolladores de Rails, utiliza `ActiveModel` para ofrecer una interfaz limpia y potente.
+
+## 🚀 Inicio Rápido
+
+```ruby
+require 'docker_swarm'
+
+# Configurar (opcional, usa defaults)
+DockerSwarm.configure do |config|
+  config.socket_path = "unix:///var/run/docker.sock"
+end
+
+# Listar servicios
+services = DockerSwarm::Service.all
+services.each { |s| puts "#{s.ID}: #{s.Spec['Name']}" }
+
+# Crear un nuevo servicio
+service = DockerSwarm::Service.create(
+  Spec: {
+    Name: "my-webapp",
+    TaskTemplate: {
+      ContainerSpec: { Image: "nginx:latest" }
+    }
+  }
+)
+
+# Obtener logs
+puts service.logs
+```
+
+## 📖 Documentación Completa
+
+Para profundizar en el uso de la gema, consulta las siguientes guías:
+
+1.  **[Guía de Configuración](docs/configuration.md)**: Cómo configurar el socket, logger y opciones globales.
+2.  **[Uso del ORM (Modelos)](docs/models.md)**: Todo sobre el ciclo de vida de los recursos (`Service`, `Node`, `Task`, etc.).
+3.  **[Cliente de API (Bajo Nivel)](docs/api.md)**: Cómo realizar peticiones personalizadas directamente a la API de Docker.
+4.  **[Manejo de Errores](docs/errors.md)**: Jerarquía de excepciones y mapeo de errores de Docker.
+5.  **[Pruebas y Mocking](docs/testing.md)**: Guía para testear tu aplicación sin depender de un socket de Docker real.
+
+## 🛠 Características Clave
+
+- **Mapeo PascalCase**: Mantiene la fidelidad con los atributos de Docker (e.g., `s.ID`, `s.Spec`) evitando transformaciones costosas.
+- **ActiveModel Ready**: Soporta validaciones, serialización JSON y comportamientos estándar de modelos Ruby.
+- **Surgical Updates**: Actualizaciones precisas enviando solo el índice de versión y el payload necesario.
+- **Excon Stack**: Basado en `Excon` con middlewares para encoding de peticiones, parseo de respuestas y gestión de errores.
+
+## 🤝 Contribuir
+
+Las contribuciones son bienvenidas. Por favor, lee `CLAUDE.md` para las guías de desarrollo y asegúrate de que todos los tests pasen antes de enviar un PR.
+
+```bash
+bundle exec rspec
+```
+
+## 📄 Licencia
+
+Este proyecto está bajo la licencia MIT.

data/lib/docker_swarm/api.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Api
+    ENDPOINTS = {
+      swarm: { show: { method: :get, path: "swarm" } },
+      system: {
+        info: { method: :get, path: "info" },
+        version: { method: :get, path: "version" },
+        up: { method: :get, path: "_ping" },
+        df: { method: :get, path: "system/df" }
+      },
+      nodes: {
+        index: { method: :get, path: "nodes" },
+        show: { method: :get, path: "nodes/%<id>s" },
+        update: { method: :post, path: "nodes/%<id>s/update" },
+        destroy: { method: :delete, path: "nodes/%<id>s" }
+      },
+      tasks: {
+        index: { method: :get, path: "tasks" },
+        show: { method: :get, path: "tasks/%<id>s" },
+        logs: { method: :get, path: "tasks/%<id>s/logs" }
+      },
+      services: {
+        index: { method: :get, path: "services" },
+        show: { method: :get, path: "services/%<id>s" },
+        create: { method: :post, path: "services/create" },
+        update: { method: :post, path: "services/%<id>s/update" },
+        destroy: { method: :delete, path: "services/%<id>s" },
+        logs: { method: :get, path: "services/%<id>s/logs" }
+      },
+      configs: {
+        index: { method: :get, path: "configs" },
+        show: { method: :get, path: "configs/%<id>s" },
+        create: { method: :post, path: "configs/create" },
+        destroy: { method: :delete, path: "configs/%<id>s" }
+      },
+      secrets: {
+        index: { method: :get, path: "secrets" },
+        show: { method: :get, path: "secrets/%<id>s" },
+        create: { method: :post, path: "secrets/create" },
+        destroy: { method: :delete, path: "secrets/%<id>s" }
+      },
+      networks: {
+        index: { method: :get, path: "networks" },
+        show: { method: :get, path: "networks/%<id>s" },
+        create: { method: :post, path: "networks/create" },
+        update: { method: :post, path: "networks/%<id>s/update" },
+        destroy: { method: :delete, path: "networks/%<id>s" }
+      },
+      volumes: {
+        index: { method: :get, path: "volumes" },
+        show: { method: :get, path: "volumes/%<id>s" },
+        create: { method: :post, path: "volumes/create" },
+        destroy: { method: :delete, path: "volumes/%<id>s" }
+      },
+      containers: {
+        index: { method: :get, path: "containers/json" },
+        show: { method: :get, path: "containers/%<id>s/json" },
+        create: { method: :post, path: "containers/create" },
+        start: { method: :post, path: "containers/%<id>s/start" },
+        stop: { method: :post, path: "containers/%<id>s/stop" },
+        destroy: { method: :delete, path: "containers/%<id>s" },
+        logs: { method: :get, path: "containers/%<id>s/logs" }
+      },
+      images: {
+        index: { method: :get, path: "images/json" },
+        show: { method: :get, path: "images/%<id>s/json" },
+        create: { method: :post, path: "images/create?fromImage=%<id>s" },
+        destroy: { method: :delete, path: "images/%<id>s" }
+      }
+    }.freeze
+
+    def self.request(action:, arguments: {}, query_params: {}, payload: nil)
+      path = format(action[:path], arguments)
+      DockerSwarm.request(
+        method: action[:method],
+        path: path,
+        query: query_params,
+        body: payload
+      )
+    end
+  end
+end

data/lib/docker_swarm/base.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Base
+    include ActiveModel::Model
+
+    class << self
+      def resource_name
+        name.demodulize.downcase.pluralize
+      end
+
+      def routes
+        Api::ENDPOINTS[resource_name.to_sym]
+      end
+
+      def all(filters = {})
+        _fetch_all(filters).map { |data| new(data) }
+      end
+
+      def find(id)
+        data = Api.request(action: routes[:show], arguments: { id: id })
+        new(data)
+      rescue Errors::NotFound
+        nil
+      end
+
+      def where(filters)
+        all(filters)
+      end
+
+      private
+
+      def _fetch_all(filters = {})
+        query = {}
+
+        if filters.present?
+          global_params = filters.slice(:all, :force, :limit, :since, :before)
+          docker_filters = filters.except(:all, :force, :limit, :since, :before)
+
+          query = global_params
+
+          if docker_filters.any?
+            normalized = docker_filters.transform_keys { |k| k.to_s.downcase }
+                                       .transform_values { |v| Array(v) }
+            query[:filters] = normalized.to_json
+          end
+        end
+
+        Api.request(action: routes[:index], query_params: query)
+      end
+    end
+
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes.present?
+      super()
+    end
+
+    def assign_attributes(new_attributes)
+      return if new_attributes.blank?
+
+      attributes_to_assign = new_attributes.deep_dup
+
+      if attributes_to_assign.is_a?(Hash)
+        attributes_to_assign = attributes_to_assign.with_indifferent_access
+        normalized_attributes = {}
+
+        attributes_to_assign.each do |key, value|
+          normalized_key = key.to_s == "Id" ? "ID" : key.to_s
+          _define_dynamic_accessor(normalized_key)
+
+          if normalized_key == "Spec" && respond_to?(:Spec) && self.Spec.is_a?(Hash) && value.is_a?(Hash)
+            value = self.Spec.deep_merge(value)
+          end
+
+          normalized_attributes[normalized_key] = value
+        end
+
+        super(normalized_attributes)
+      else
+        Array(attributes_to_assign).each do |item|
+          next unless item.is_a?(Hash)
+          item.each_key { |key| _define_dynamic_accessor(key) }
+        end
+      end
+    end
+
+    def attributes
+      instance_values.except("validation_context", "errors", "context_for_validation")
+    end
+
+    def serializable_hash(_options = nil)
+      attributes
+    end
+
+    def as_json(options = nil)
+      serializable_hash(options)
+    end
+
+    def payload_for_docker
+      data = attributes.except("ID", "Id", "Version", "CreatedAt", "UpdatedAt").compact
+      return data unless data.key?("Spec")
+
+      spec = data.delete("Spec").deep_dup
+      spec.merge!(data)
+    end
+
+    def persisted?
+      respond_to?(:ID) && self.ID.present?
+    end
+
+    def id
+      self.ID
+    end
+
+    def reload
+      fresh = self.class.find(id)
+      assign_attributes(fresh.attributes) if fresh
+      self
+    end
+
+    def method_missing(method_name, *args, &block)
+      method_str = method_name.to_s
+
+      if method_str.end_with?("=")
+        _define_dynamic_accessor(method_str.chomp("="))
+        instance_variable_set("@#{method_str.chomp('=')}", args.first)
+      elsif _valid_attribute_name?(method_str) && instance_variable_defined?("@#{method_str}")
+        instance_variable_get("@#{method_str}")
+      elsif !method_str.end_with?("?")
+        _define_dynamic_accessor(method_str)
+        nil
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_str = method_name.to_s
+      method_str.end_with?("=") ||
+        (_valid_attribute_name?(method_str) && instance_variable_defined?("@#{method_str}")) ||
+        (!method_str.end_with?("?") && _valid_attribute_name?(method_str)) ||
+        super
+    end
+
+    private
+
+    def _define_dynamic_accessor(key)
+      return if self.class.method_defined?("#{key}=")
+      self.class.send(:attr_accessor, key)
+    end
+
+    def _valid_attribute_name?(name)
+      /\A[a-zA-Z_]\w*\z/.match?(name)
+    end
+  end
+end

data/lib/docker_swarm/concerns/creatable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Concerns
+    module Creatable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def create(attributes = {})
+          resource = new(attributes)
+          resource.save
+          resource
+        end
+      end
+
+      def save
+        return false unless valid?
+        return update if persisted?
+
+        response = Api.request(
+          action: self.class.routes[:create],
+          payload: payload_for_docker
+        )
+
+        self.ID = response["ID"] || response["Id"] || response["Name"]
+        reload
+        true
+      end
+    end
+  end
+end

data/lib/docker_swarm/concerns/deletable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Concerns
+    module Deletable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def destroy(id)
+          Api.request(action: routes[:destroy], arguments: { id: id })
+          true
+        rescue Errors::NotFound
+          nil
+        end
+      end
+
+      def destroy
+        self.class.destroy(self.ID)
+      end
+    end
+  end
+end

data/lib/docker_swarm/concerns/updatable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Concerns
+    module Updatable
+      extend ActiveSupport::Concern
+
+      def update(new_attributes = {})
+        assign_attributes(new_attributes) if new_attributes.present?
+        return false unless valid?
+
+        Api.request(
+          action: self.class.routes[:update],
+          arguments: { id: self.ID },
+          query_params: { version: self.Version&.dig("Index") },
+          payload: payload_for_docker
+        )
+
+        true
+      end
+    end
+  end
+end

data/lib/docker_swarm/connection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Connection
+    attr_reader :socket_path, :logger
+
+    def initialize(socket_path, logger)
+      @socket_path = socket_path
+      @logger = logger
+    end
+
+    def request(options = {})
+      normalized_path = socket_path.sub(/^unix:\/\//, "")
+      client(normalized_path).request(options).body
+    rescue => e
+      if e.is_a?(Excon::Error::Socket)
+        raise Errors::Communication, "Docker socket error: #{e.message}"
+      else
+        raise e
+      end
+    end
+    private
+
+    def client(path)
+      @client ||= Excon.new(
+        "unix:///",
+        socket: path,
+        middlewares: [
+          Excon::Middleware::ResponseParser,
+          Excon::Middleware::RedirectFollower,
+          Middleware::RequestEncoder,
+          Middleware::ResponseJSONParser,
+          Middleware::ErrorHandler
+        ]
+      )
+    end
+  end
+end

data/lib/docker_swarm/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Error < StandardError; end
+
+  module Errors
+    class BadRequest < Error; end
+    class Unauthorized < Error; end
+    class Forbidden < Error; end
+    class NotFound < Error; end
+    class NotAcceptable < Error; end
+    class RequestTimeout < Error; end
+    class Conflict < Error; end
+    class UnprocessableEntity < Error; end
+    class InternalServerError < Error; end
+    class BadGateway < Error; end
+    class ServiceUnavailable < Error; end
+    class GatewayTimeout < Error; end
+    class TooManyRequests < Error; end
+    class Communication < Error; end
+  end
+end

data/lib/docker_swarm/middleware/error_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Middleware
+    class ErrorHandler < Excon::Middleware::Base
+      def response_call(env)
+        return @stack.response_call(env) unless env[:response]
+
+        status = env[:response][:status]
+        body = env[:response][:body]
+
+        case status
+        when 200..299
+          # Continuar normalmente
+        when 400 then raise Errors::BadRequest, error_message(body)
+        when 401 then raise Errors::Unauthorized, error_message(body)
+        when 403 then raise Errors::Forbidden, error_message(body)
+        when 404 then raise Errors::NotFound, error_message(body)
+        when 406 then raise Errors::NotAcceptable, error_message(body)
+        when 408 then raise Errors::RequestTimeout, error_message(body)
+        when 409 then raise Errors::Conflict, error_message(body)
+        when 422 then raise Errors::UnprocessableEntity, body
+        when 429 then raise Errors::TooManyRequests, error_message(body)
+        when 500 then raise Errors::InternalServerError, error_message(body)
+        when 502 then raise Errors::BadGateway, error_message(body)
+        when 503 then raise Errors::ServiceUnavailable, error_message(body)
+        when 504 then raise Errors::GatewayTimeout, error_message(body)
+        else
+          raise Errors::Error, "HTTP #{status}: #{error_message(body)}"
+        end
+
+        @stack.response_call(env)
+      end
+
+      private
+
+      def error_message(body)
+        if body.is_a?(Hash)
+          body["message"] || body["error"] || body.to_json
+        else
+          body.to_s
+        end
+      end
+    end
+  end
+end

data/lib/docker_swarm/middleware/request_encoder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Middleware
+    class RequestEncoder < Excon::Middleware::Base
+      def request_call(env)
+        if env[:body] && env[:body].is_a?(Hash)
+          env[:body] = env[:body].to_json
+          env[:headers]["Content-Type"] ||= "application/json"
+        end
+        @stack.request_call(env)
+      end
+    end
+  end
+end

data/lib/docker_swarm/middleware/response_json_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  module Middleware
+    class ResponseJSONParser < Excon::Middleware::Base
+      def response_call(env)
+        if env[:response]
+          body = env[:response][:body]
+          headers = env[:response][:headers] || {}
+
+          if body && !body.empty? && headers["Content-Type"]&.include?("application/json")
+            begin
+              parsed = JSON.parse(body)
+              env[:response][:body] = parsed.is_a?(Hash) ? parsed.with_indifferent_access : parsed
+            rescue JSON::ParserError
+              # Keep original body if parsing fails
+            end
+          end
+        end
+        
+        @stack.response_call(env)
+      end
+    end
+  end
+end

data/lib/docker_swarm/models/config.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Config < Base
+    include Concerns::Creatable
+    include Concerns::Deletable
+  end
+end

data/lib/docker_swarm/models/container.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Container < Base
+    include Concerns::Deletable
+
+    def start
+      Api.request(action: self.class.routes[:start], arguments: { id: self.ID })
+    end
+
+    def stop
+      Api.request(action: self.class.routes[:stop], arguments: { id: self.ID })
+    end
+
+    def logs(query_params = { stdout: 1, stderr: 1 })
+      Api.request(action: self.class.routes[:logs], arguments: { id: self.ID }, query_params: query_params)
+    end
+  end
+end

data/lib/docker_swarm/models/image.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Image < Base
+    include Concerns::Creatable
+    include Concerns::Deletable
+  end
+end

data/lib/docker_swarm/models/network.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Network < Base
+    include Concerns::Creatable
+    include Concerns::Updatable
+    include Concerns::Deletable
+
+    validate :validate_name_presence
+
+    private
+
+    def validate_name_presence
+      name = attributes["Name"] || (respond_to?(:Name) ? Name : nil)
+      errors.add(:Name, "can't be blank") if name.blank?
+    end
+  end
+end

data/lib/docker_swarm/models/node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Node < Base
+    include Concerns::Updatable
+    include Concerns::Deletable
+  end
+end

data/lib/docker_swarm/models/secret.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Secret < Base
+    include Concerns::Creatable
+    include Concerns::Deletable
+  end
+end

data/lib/docker_swarm/models/service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  # Represents a Docker Swarm Service
+  # @see https://docs.docker.com/engine/api/v1.41/#tag/Service
+  class Service < Base
+    include Concerns::Creatable
+    include Concerns::Updatable
+    include Concerns::Deletable
+
+    validate :validate_name_presence
+
+    # Fetches logs for the service
+    # @param query_params [Hash] Query parameters for the logs endpoint (stdout, stderr, follow, etc.)
+    # @return [String] The raw log stream
+    def logs(query_params = { stdout: 1, stderr: 1 })
+      Api.request(action: self.class.routes[:logs], arguments: { id: self.ID }, query_params: query_params)
+    end
+
+    private
+
+    def validate_name_presence
+      name = attributes["Name"] || (respond_to?(:Name) ? Name : nil)
+      errors.add(:Name, "can't be blank") if name.blank?
+    end
+  end
+end

data/lib/docker_swarm/models/swarm.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Swarm < Base
+    def self.resource_name
+      "swarm"
+    end
+
+    def self.show
+      Api.request(action: routes[:show])
+    end
+  end
+end

data/lib/docker_swarm/models/system.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class System < Base
+    def self.resource_name
+      "system"
+    end
+
+    def self.info
+      Api.request(action: routes[:info])
+    end
+
+    def self.version
+      Api.request(action: routes[:version])
+    end
+
+    def self.up
+      Api.request(action: routes[:up])
+    end
+
+    def self.df
+      Api.request(action: routes[:df])
+    end
+  end
+end

data/lib/docker_swarm/models/task.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Task < Base
+    def logs(query_params = { stdout: 1, stderr: 1 })
+      Api.request(action: self.class.routes[:logs], arguments: { id: self.ID }, query_params: query_params)
+    end
+  end
+end

data/lib/docker_swarm/models/volume.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DockerSwarm
+  class Volume < Base
+    include Concerns::Creatable
+    include Concerns::Deletable
+
+    def self.all(filters = {})
+      response = _fetch_all(filters)
+      return [] if response.blank?
+      
+      data = response.is_a?(Hash) ? response["Volumes"] : response
+      Array(data).map { |item| new(item) }
+    end
+  end
+end

data/lib/docker_swarm/version.rb

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

data/lib/docker_swarm.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "excon"
+require "json"
+require "logger"
+
+require_relative "docker_swarm/version"
+require_relative "docker_swarm/errors"
+require_relative "docker_swarm/middleware/request_encoder"
+require_relative "docker_swarm/middleware/response_json_parser"
+require_relative "docker_swarm/middleware/error_handler"
+require_relative "docker_swarm/connection"
+require_relative "docker_swarm/api"
+require_relative "docker_swarm/base"
+require_relative "docker_swarm/concerns/creatable"
+require_relative "docker_swarm/concerns/updatable"
+require_relative "docker_swarm/concerns/deletable"
+
+# Models
+require_relative "docker_swarm/models/swarm"
+require_relative "docker_swarm/models/system"
+require_relative "docker_swarm/models/service"
+require_relative "docker_swarm/models/node"
+require_relative "docker_swarm/models/task"
+require_relative "docker_swarm/models/container"
+require_relative "docker_swarm/models/image"
+require_relative "docker_swarm/models/network"
+require_relative "docker_swarm/models/config"
+require_relative "docker_swarm/models/secret"
+require_relative "docker_swarm/models/volume"
+
+module DockerSwarm
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def connection
+      configure unless configuration
+      @connection ||= Connection.new(configuration.socket_path, configuration.logger)
+    end
+
+    def request(options = {})
+      connection.request(options)
+    end
+  end
+
+  class Configuration
+    attr_accessor :socket_path, :logger
+
+    def initialize
+      @socket_path = "unix:///var/run/docker.sock"
+      @logger = defined?(Rails) ? Rails.logger : Logger.new($stdout)
+    end
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: docker-swarm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gabriel
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.80'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.80'
+- !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'
+description: Simplifies interactions with Docker Swarm through an ActiveModel-compatible
+  ORM and a robust Excon-based API client.
+email:
+- gabriel@wispro.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/docker_swarm.rb
+- lib/docker_swarm/api.rb
+- lib/docker_swarm/base.rb
+- lib/docker_swarm/concerns/creatable.rb
+- lib/docker_swarm/concerns/deletable.rb
+- lib/docker_swarm/concerns/updatable.rb
+- lib/docker_swarm/connection.rb
+- lib/docker_swarm/errors.rb
+- lib/docker_swarm/middleware/error_handler.rb
+- lib/docker_swarm/middleware/request_encoder.rb
+- lib/docker_swarm/middleware/response_json_parser.rb
+- lib/docker_swarm/models/config.rb
+- lib/docker_swarm/models/container.rb
+- lib/docker_swarm/models/image.rb
+- lib/docker_swarm/models/network.rb
+- lib/docker_swarm/models/node.rb
+- lib/docker_swarm/models/secret.rb
+- lib/docker_swarm/models/service.rb
+- lib/docker_swarm/models/swarm.rb
+- lib/docker_swarm/models/system.rb
+- lib/docker_swarm/models/task.rb
+- lib/docker_swarm/models/volume.rb
+- lib/docker_swarm/version.rb
+homepage: https://github.com/wispro/docker-swarm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wispro/docker-swarm
+  source_code_uri: https://github.com/wispro/docker-swarm
+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.4.19
+signing_key:
+specification_version: 4
+summary: A Ruby ORM and API client for Docker Swarm.
+test_files: []