unix_socks 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e300523dc5acc1d27d11f2179a7beba1e5f5ee2ae82cba1a92de33747bc94c07
+  data.tar.gz: 033f4aae216f6c5c8d31df5c7df136167e9169aa8729f200081b6bf636003e5a
+SHA512:
+  metadata.gz: 551193b2e23226c7f3434811d679b8df9f296b69a1c9a4639327db8110cf1870095589c352b35c5a12b7e423023f07de0f088a8f52ce4fa62e1d77d934c4b47e
+  data.tar.gz: 5b7e2c93ff081a4794ccf2dd94bb8f9181da4d2d1104b79d4051253f5c36948046615e000c858e8d360d4894871eee5a366687a72286b321176a7e3078a58e89

data/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## 2025-07-01 v0.0.0
+
+  * Start

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright Florian Frank
+
+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,118 @@
+# UnixSocks 🧦🧦
+
+## Description
+
+A Ruby library for handling Unix socket-based communication.
+
+## Features
+
+- **Message Handling**: Simplify sending and receiving messages over Unix sockets.
+- **Dynamic Method Access**: Access message body values using method names (e.g., `message.key`).
+- **Background Processing**: Run the server in a background thread to avoid blocking main execution.
+- **Robust Error Handling**: Gracefully handle socket disconnections and JSON parsing errors.
+
+## Installation
+
+Add this gem to your Gemfile:
+
+```ruby
+gem 'unix_socks'
+```
+
+And install it using Bundler:
+
+```bash
+bundle install
+```
+
+Or install the gem directly:
+
+```bash
+gem install unix_socks
+```
+
+## Usage
+
+### 1. Server Setup
+
+Create a server instance and start listening for connections:
+
+```ruby
+require 'unix_socks'
+
+server = UnixSocks::Server.new(socket_name: 'my_socket')
+
+# Run the server in the background to avoid blocking
+thread = server.receive_in_background(force: true) do |message|
+  puts "Received message: #{message.inspect}"
+end
+
+thread.join
+```
+
+### 2. Sending Messages
+
+Transmit messages to connected clients:
+
+```ruby
+client = UnixSocks::Server.new(socket_name: 'my_socket')
+
+# Prepare your message
+message = { status: 'success', data: [1, 2, 3] }
+
+# Send the message
+client.transmit(message)
+```
+
+### 3. Responding to Messages
+
+Handle incoming messages and send responses:
+
+```ruby
+require 'unix_socks'
+
+server = UnixSocks::Server.new(socket_name: 'my_socket')
+
+def handle_message(message)
+  # Access message body values using method names
+  puts "Received status: #{message.status}"
+  
+  # Send a response
+  message.respond({ status: 'acknowledged' })
+end
+
+# Use in your server setup
+thread = server.receive_in_background(force: true) do |message|
+  handle_message(message)
+end
+
+thread.join
+```
+
+And in the client:
+```ruby
+client = UnixSocks::Server.new(socket_name: 'my_socket')
+
+# Prepare your message
+message = { status: 'success', data: [1, 2, 3] }
+
+# Send the message
+response = client.transmit_with_response(message)
+
+# Receive the response
+puts "Received server response status: #{response.status}"
+```
+
+### 4. Message Object Features
+
+- **Dynamic Access**: Methods like `message.status` automatically map to the message body.
+- **Disconnect Handling**: Safely close socket connections using `disconnect`.
+- **Error Resilience**: The `respond` method handles disconnections gracefully.
+
+## Author
+
+[Florian Frank](mailto:flori@ping.de)
+
+## License
+
+[MIT License](./LICENSE)

data/Rakefile

@@ -0,0 +1,42 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'unix_socks'
+  module_type :module
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "https://github.com/flori/#{name}"
+  summary     <<~EOT
+    A Ruby library for inter-process communication via Unix sockets with
+    dynamic message handling
+  EOT
+  description <<~EOT
+    This library enables communication between processes using Unix sockets. It
+    handles message transmission, socket management, and cleanup, supporting
+    both synchronous and asynchronous operations while providing error handling
+    for robust development.
+  EOT
+  test_dir    'spec'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.AppleDouble', '.bundle',
+    '.yardoc', 'doc', 'tags', 'errors.lst', 'cscope.out', 'coverage', 'tmp',
+    'yard'
+  package_ignore '.all_images.yml', '.tool-versions', '.gitignore', 'VERSION',
+    '.rspec', *Dir.glob('.github/**/*', File::FNM_DOTMATCH)
+  readme      'README.md'
+
+  required_ruby_version  '~> 3.1'
+
+  dependency             'json',        '~> 2.0'
+  dependency             'tins',        '~> 1.3'
+  development_dependency 'all_images',            '~> 0.4'
+  development_dependency 'rspec',                 '~> 3.2'
+  development_dependency 'debug'
+  development_dependency 'simplecov'
+  development_dependency 'yard'
+
+  licenses << 'MIT'
+
+  clobber 'coverage'
+end

data/lib/unix_socks/message.rb

@@ -0,0 +1,30 @@
+require 'tins/xt/ask_and_send'
+require 'json'
+
+# Represents a message sent or received over a Unix socket, extending
+# JSON::GenericObject for dynamic access to message attributes.
+class UnixSocks::Message < JSON::GenericObject
+  # Disconnects the socket connection.
+  #
+  # Closes the underlying socket, effectively ending the communication session.
+  def disconnect
+    socket.close
+  end
+
+  # The respond method sends a response back to the client over the Unix socket
+  # connection.
+  #
+  # It first converts the provided answer into JSON format, and then writes it
+  # to the socket using socket.puts.
+  #
+  # @param answer [ Object ] The response to be sent back to the client.
+  #
+  # @return [ UnixSocks::Message ] The current message object.
+  def respond(answer)
+    answer = answer.ask_and_send(:to_json) or
+      raise TypeError, 'needs to be convertibla to JSON'
+    socket.puts answer
+  rescue Errno::EPIPE
+    self
+  end
+end

data/lib/unix_socks/server.rb

@@ -0,0 +1,126 @@
+# Manages Unix socket-based communication, providing both server and client
+# functionality.
+class UnixSocks::Server
+  include FileUtils
+
+  # Initializes a new UnixSocks::Server instance.
+  #
+  # @param socket_name [ String ] The name of the server socket file.
+  # @param runtime_dir [ String, nil ] The path to the runtime directory where
+  #   the server socket will be created. If not provided, it defaults to the
+  #   value returned by #default_runtime_dir.
+  def initialize(socket_name:, runtime_dir: default_runtime_dir)
+    @socket_name, @runtime_dir = socket_name, runtime_dir
+  end
+
+  # Returns the default runtime directory path based on the XDG_RUNTIME_DIR
+  # environment variable.
+  #
+  # If the XDG_RUNTIME_DIR environment variable is set, its value is used as
+  # the runtime directory path. Otherwise, the default path '~/.local/run' is
+  # used.
+  #
+  # @return [ String ] The default runtime directory path.
+  def default_runtime_dir
+    File.expand_path(ENV.fetch('XDG_RUNTIME_DIR',  '~/.local/run'))
+  end
+
+  # Returns the path to the server socket file.
+  #
+  # This method constructs the full path to the server socket by joining the
+  # runtime directory and the socket name.
+  #
+  # @return [ String ] The path to the server socket file.
+  def server_socket_path
+    File.expand_path(File.join(@runtime_dir, @socket_name))
+  end
+
+  # The transmit method sends a message over the Unix socket connection.
+  #
+  # It first prepares the message by converting it to JSON format, and then
+  # establishes a connection to the server socket using UNIXSocket.new.
+  #
+  # Finally, it writes the prepared message to the socket using socket.puts,
+  # ensuring that the socket is properly closed after use.
+  #
+  # @param message [ Message ] The message to be sent over the Unix socket.
+  def transmit(message)
+    mkdir_p @runtime_dir
+    socket = UNIXSocket.new(server_socket_path)
+    socket.puts JSON(message)
+    socket
+  end
+
+  # Sends a message and returns the parsed JSON response.
+  #
+  # @param message [Object] The message to be sent as JSON.
+  # @return [Hash, nil] The parsed JSON response or nil if parsing fails.
+  def transmit_with_response(message)
+    socket = transmit(message)
+    parse_json_message(socket.gets, socket)
+  end
+
+  # Receives messages from clients connected to the server socket.
+  #
+  # This method establishes a connection to the server socket and listens for incoming
+  # messages. When a message is received, it is parsed as JSON and converted into a
+  # UnixSocks::Message object. The block provided to this method is then called with
+  # the message object as an argument.
+  #
+  # If the `force` parameter is set to true, any existing server socket file will be
+  # overwritten without raising an error.
+  #
+  # @param force [ Boolean ] Whether to overwrite any existing server socket file.
+  # @yield [ UnixSocks::Message ] The received message.
+  def receive(force: false, &block)
+    mkdir_p @runtime_dir
+    if !force && socket_path_exist?
+      raise Errno::EEXIST, "Path already exists #{server_socket_path.inspect}"
+    end
+    Socket.unix_server_loop(server_socket_path) do |socket, client_addrinfo|
+      message = pop_message(socket) and block.(message)
+    end
+  end
+
+  # The receive_in_background method runs the server socket listener in a
+  # separate thread, allowing it to continue executing without blocking the
+  # main program flow.
+  #
+  # @param force [ Boolean ] Whether to overwrite any existing server socket file.
+  # @yield [ UnixSocks::Message ] The received message.
+  def receive_in_background(force: false, &block)
+    Thread.new do
+      receive(force:, &block)
+    ensure
+      remove_socket_path
+    end
+  end
+
+  # Checks if the server socket file exists.
+  #
+  # @return [ Boolean ] True if the socket file exists, false otherwise.
+  def socket_path_exist?
+    File.exist?(server_socket_path)
+  end
+
+  # Safely removes the server socket file from the filesystem.
+  def remove_socket_path
+    FileUtils.rm_f server_socket_path
+  end
+
+  private
+
+  def pop_message(socket)
+    parse_json_message(socket.gets, socket)
+  end
+
+  def parse_json_message(data, socket)
+    data = data.strip
+    data.empty? and return nil
+    obj = JSON.parse(data, object_class: UnixSocks::Message)
+    obj.socket = socket
+    obj
+  rescue JSON::ParserError => e
+    warn "Caught #{e.class}: #{e} for #{data[0, 512].inspect}"
+  end
+end

data/lib/unix_socks/version.rb

@@ -0,0 +1,8 @@
+module UnixSocks
+  # UnixSocks version
+  VERSION         = '0.0.0'
+  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/unix_socks.rb

@@ -0,0 +1,14 @@
+require 'json'
+require 'fileutils'
+require 'socket'
+require 'tins'
+
+# Provides classes for handling inter-process communication via Unix 🧦🧦.
+# Supports dynamic message handling, background processing, and robust error
+# management.
+module UnixSocks
+end
+
+require 'unix_socks/version'
+require 'unix_socks/message'
+require 'unix_socks/server'

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+if ENV['START_SIMPLECOV'].to_i == 1
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "#{File.basename(File.dirname(__FILE__))}/"
+  end
+end
+require 'rspec'
+begin
+  require 'debug'
+rescue LoadError
+end
+require 'unix_socks'

data/spec/unix_socks/message_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe UnixSocks::Message do
+  let(:socket) { instance_double(Socket) }
+  let(:key) { 'value' }
+
+  subject { described_class[key:, socket:] }
+
+  describe '#initialize' do
+    it 'sets the body and socket' do
+      expect(subject).to be_a described_class
+      expect(subject.key).to eq 'value'
+      expect(subject.socket).to eq(socket)
+    end
+  end
+
+  describe '#disconnect' do
+    it 'closes the socket' do
+      expect(socket).to receive(:close)
+      subject.disconnect
+    end
+  end
+
+  describe '#respond' do
+    let(:answer) { { response: 'ok' } }
+
+    it 'sends a JSON response over the socket' do
+      expected_json = answer.to_json
+      expect(socket).to receive(:puts).with(expected_json)
+      subject.respond(answer)
+    end
+
+    it 'handles EPIPE errors gracefully' do
+      allow(socket).to receive(:puts).and_raise(Errno::EPIPE)
+      expect { subject.respond(answer) }.not_to raise_error
+    end
+  end
+end

data/spec/unix_socks/server_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'tins/xt/expose'
+
+describe UnixSocks::Server do
+  let(:socket_name) { 'test_socket' }
+  let(:runtime_dir) { './tmp' }
+  let(:server) { UnixSocks::Server.new(socket_name: socket_name, runtime_dir: runtime_dir).expose }
+
+  describe '#initialize' do
+    it 'sets the socket name and runtime directory' do
+      expect(server.instance_variable_get(:@socket_name)).to eq(socket_name)
+      expect(server.instance_variable_get(:@runtime_dir)).to eq(runtime_dir)
+    end
+  end
+
+  describe '#default_runtime_dir' do
+    it 'returns the correct default runtime directory' do
+      ENV['XDG_RUNTIME_DIR'] = nil
+      expect(server.default_runtime_dir).to eq(File.expand_path('~/.local/run'))
+
+      ENV['XDG_RUNTIME_DIR'] = '/tmp/runtime'
+      expect(server.default_runtime_dir).to eq('/tmp/runtime')
+    end
+  end
+
+  describe '#server_socket_path' do
+    it 'returns the correct socket path' do
+      expected_path = File.expand_path(File.join(runtime_dir, socket_name))
+      expect(server.server_socket_path).to eq(expected_path)
+    end
+  end
+
+  describe '#transmit' do
+    let(:message) { { test: 'message' } }
+
+    it 'sends a message over the Unix socket' do
+      expect(server).to receive(:mkdir_p).with(runtime_dir)
+      expect(UNIXSocket).to receive(:new).with(server.server_socket_path).
+        and_return(double('socket', puts: nil, close: nil))
+      server.transmit(message)
+    end
+  end
+
+  describe '#transmit_with_response' do
+    let(:message) { { test: 'message' } }
+
+    it 'parses a valid JSON response' do
+      allow(server).to receive(:mkdir_p)
+      mock_socket = double('socket', puts: nil, gets: '{"status": "success"}')
+      expect(UNIXSocket).to receive(:new).and_return(mock_socket)
+
+      response = server.transmit_with_response(message)
+      expect(response).to be_a UnixSocks::Message
+      expect(response.status).to eq 'success'
+    end
+
+    it 'handles JSON parsing errors' do
+      allow(server).to receive(:mkdir_p)
+      mock_socket = double('socket', puts: nil, gets: 'invalid_json')
+      expect(server).to receive(:warn).
+        with(/Caught JSON::ParserError: unexpected character: 'invalid_json'/)
+      expect(UNIXSocket).to receive(:new).and_return(mock_socket)
+
+      response = server.transmit_with_response(message)
+      expect(response).to be nil
+    end
+
+    it 'handles empty responses' do
+      allow(server).to receive(:mkdir_p)
+      mock_socket = double('socket', puts: nil, gets: '')
+      expect(UNIXSocket).to receive(:new).and_return(mock_socket)
+
+      response = server.transmit_with_response(message)
+      expect(response).to be nil
+    end
+  end
+
+  describe '#receive' do
+    it 'raises an error if the socket already exists and force is false' do
+      allow(server).to receive(:socket_path_exist?).and_return(true)
+      expect { server.receive(force: false) }.to\
+        raise_error(Errno::EEXIST, /Path already exists/)
+    end
+
+    it 'does not raise an error if force is true' do
+      allow(server).to receive(:socket_path_exist?).and_return(true)
+      expect(Socket).to receive(:unix_server_loop).with(server.server_socket_path)
+      server.receive(force: true)
+    end
+  end
+
+  describe 'pop_message' do
+    it 'parses a valid JSON message' do
+      mock_socket = double('socket')
+      allow(mock_socket).to receive(:gets).and_return('{"test": "message"}')
+
+      message = server.pop_message(mock_socket)
+      expect(message).to be_a(UnixSocks::Message)
+      expect(message.test).to eq 'message'
+    end
+
+    it 'handles a JSON parsing error' do
+      mock_socket = double('socket')
+      allow(mock_socket).to receive(:gets).and_return('invalid_json')
+      expect(server).to receive(:warn).
+        with(/Caught JSON::ParserError: unexpected character: 'invalid_json'/)
+      expect(server.pop_message(mock_socket)).to be nil
+    end
+  end
+
+  describe '#receive_in_background' do
+    it 'runs the receiver in a background thread' do
+      expect(Thread).to receive(:new).and_yield
+      expect(FileUtils).to receive(:rm_f).with(server.server_socket_path)
+      expect(server).to receive(:receive).with(force: true)
+
+      server.receive_in_background(force: true)
+    end
+  end
+
+  describe '#socket_path_exist?' do
+    it 'returns false if the socket file does not exist' do
+      FileUtils.rm_f(server.server_socket_path)
+      expect(server.socket_path_exist?).to be false
+    end
+
+    it 'returns true if the socket file does exist' do
+      FileUtils.touch(server.server_socket_path)
+      expect(server.socket_path_exist?).to be true
+    end
+  end
+
+  describe '#remove_socket_path' do
+    it 'removes the socket file' do
+      expect(FileUtils).to receive(:rm_f).with(server.server_socket_path)
+
+      server.remove_socket_path
+    end
+  end
+end

data/unix_socks.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+# stub: unix_socks 0.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "unix_socks".freeze
+  s.version = "0.0.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Florian Frank".freeze]
+  s.date = "1980-01-02"
+  s.description = "This library enables communication between processes using Unix sockets. It\nhandles message transmission, socket management, and cleanup, supporting\nboth synchronous and asynchronous operations while providing error handling\nfor robust development.\n".freeze
+  s.email = "flori@ping.de".freeze
+  s.extra_rdoc_files = ["README.md".freeze, "lib/unix_socks.rb".freeze, "lib/unix_socks/message.rb".freeze, "lib/unix_socks/server.rb".freeze, "lib/unix_socks/version.rb".freeze]
+  s.files = ["CHANGES.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "lib/unix_socks.rb".freeze, "lib/unix_socks/message.rb".freeze, "lib/unix_socks/server.rb".freeze, "lib/unix_socks/version.rb".freeze, "spec/spec_helper.rb".freeze, "spec/unix_socks/message_spec.rb".freeze, "spec/unix_socks/server_spec.rb".freeze, "unix_socks.gemspec".freeze]
+  s.homepage = "https://github.com/flori/unix_socks".freeze
+  s.licenses = ["MIT".freeze]
+  s.rdoc_options = ["--title".freeze, "UnixSocks - A Ruby library for inter-process communication via Unix sockets with\ndynamic message handling\n".freeze, "--main".freeze, "README.md".freeze]
+  s.required_ruby_version = Gem::Requirement.new("~> 3.1".freeze)
+  s.rubygems_version = "3.6.9".freeze
+  s.summary = "A Ruby library for inter-process communication via Unix sockets with dynamic message handling".freeze
+  s.test_files = ["spec/spec_helper.rb".freeze, "spec/unix_socks/message_spec.rb".freeze, "spec/unix_socks/server_spec.rb".freeze]
+
+  s.specification_version = 4
+
+  s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.20".freeze])
+  s.add_development_dependency(%q<all_images>.freeze, ["~> 0.4".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, ["~> 3.2".freeze])
+  s.add_development_dependency(%q<debug>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<simplecov>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<yard>.freeze, [">= 0".freeze])
+  s.add_runtime_dependency(%q<json>.freeze, ["~> 2.0".freeze])
+  s.add_runtime_dependency(%q<tins>.freeze, ["~> 1.3".freeze])
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: unix_socks
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Florian Frank
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gem_hadar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+- !ruby/object:Gem::Dependency
+  name: all_images
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: tins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: |
+  This library enables communication between processes using Unix sockets. It
+  handles message transmission, socket management, and cleanup, supporting
+  both synchronous and asynchronous operations while providing error handling
+  for robust development.
+email: flori@ping.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- lib/unix_socks.rb
+- lib/unix_socks/message.rb
+- lib/unix_socks/server.rb
+- lib/unix_socks/version.rb
+files:
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/unix_socks.rb
+- lib/unix_socks/message.rb
+- lib/unix_socks/server.rb
+- lib/unix_socks/version.rb
+- spec/spec_helper.rb
+- spec/unix_socks/message_spec.rb
+- spec/unix_socks/server_spec.rb
+- unix_socks.gemspec
+homepage: https://github.com/flori/unix_socks
+licenses:
+- MIT
+metadata: {}
+rdoc_options:
+- "--title"
+- |
+  UnixSocks - A Ruby library for inter-process communication via Unix sockets with
+  dynamic message handling
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Ruby library for inter-process communication via Unix sockets with dynamic
+  message handling
+test_files:
+- spec/spec_helper.rb
+- spec/unix_socks/message_spec.rb
+- spec/unix_socks/server_spec.rb