lockf.rb 0.12.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc7a6787621983c5bcea9dc35a899eb064d8d09f20d905b90b8391e8fc018f64
+  data.tar.gz: e32dcc7d52786b2c1c2acdb652264b450506debd976583a2ff8f46a367b2efe9
+SHA512:
+  metadata.gz: b275ee5e97c06f6dfcfbf32074139b1514b3fe4795ab1669bdbb188336f0039aee368846146b6e4b6ef15fc41d0077816844cfcf772e52039584b5816d5e8cbb
+  data.tar.gz: ffab08187b049fd42ad5549e060c0ba5da31228212c1e5419c3c9640a8842c96617a20cd54ee6f14edc265a5b28ddf50bc00e8dc343493fce0ec6a96a388a3cb

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_PATH: ".gems"

data/.github/workflows/tests.yml

@@ -0,0 +1,23 @@
+name: lockf.rb
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  specs:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: [3.2]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - run: bundle install
+    - run: bundle exec rake

data/.gitignore

@@ -0,0 +1,10 @@
+*.so
+*.o
+*.lock
+Makefile
+tmp/
+pkg/
+*~
+.yardoc/
+.gems/
+doc/

data/.projectile

@@ -0,0 +1,3 @@
++./
++.github/
+-.gems/

data/.rubocop.yml

@@ -0,0 +1,21 @@
+##
+# Plugins
+require:
+  - standard
+
+##
+# Defaults: standard-rb
+inherit_gem:
+  standard: config/base.yml
+
+##
+# Disabled cops
+Layout/MultilineMethodCallIndentation:
+  Enabled: false
+Layout/ArgumentAlignment:
+  Enabled: false
+
+##
+# Options for all cops.
+AllCops:
+  TargetRubyVersion: 2.7

data/.uncrustify.cfg

@@ -0,0 +1,2 @@
+indent_with_tabs = 0
+indent_columns = 4

data/.yardopts

@@ -0,0 +1,4 @@
+-m markdown -M redcarpet --no-private
+-
+README.md
+LICENSE

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec
+gem "test-cmd.rb", github: "0x1eef/test-cmd.rb", tag: "v0.4.0"

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright (C) 2023 by 0x1eef <0x1eef@protonmail.com>
+
+Permission to use, copy, modify, and/or distribute this
+software for any purpose with or without fee is hereby
+granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS
+ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,165 @@
+## About
+
+lockf.rb is a C extension that provides a Ruby interface to
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3).
+The
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+function implements an advisory-mode lock that can be placed on select
+regions of a file, or on the entire contents of a file.
+
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+can be used to synchronize access to a file between multiple
+processes, or be used more generally to synchronize access to a shared
+resource being accessed by multiple processes at the same time. When used
+generally,
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+can provide something similar to a mutex that works across multiple
+processes rather than multiple threads.
+
+## Examples
+
+### LockFile
+
+The
+[`LockFile`](https://0x1eef.github.io/x/lockf.rb/LockFile.html)
+class provides an abstract, Ruby-oriented interface to
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3).
+
+__Blocking lock__
+
+The `LockFile#lock` method can be used to acquire a lock. The method will
+block when another process has acquired a lock beforehand:
+
+```ruby
+require "lockf"
+
+lockf = LockFile.temporary_file
+lockf.lock
+print "Lock acquired by parent process (#{Time.now.utc})", "\n"
+pid = fork do
+  print "Child process waiting on lock (#{Time.now.utc})", "\n"
+  lockf.lock
+  print "Lock acquired by child process (#{Time.now.utc})", "\n"
+end
+sleep(3)
+lockf.release
+Process.wait(pid)
+lockf.file.close
+
+##
+# Lock acquired by parent process (2023-02-11 16:43:15 UTC)
+# Child process waiting on lock (2023-02-11 16:43:15 UTC)
+# Lock acquired by child process (2023-02-11 16:43:18 UTC)
+```
+
+__Non-blocking lock__
+
+The `LockFile#lock_nonblock` method can be used to acquire a lock
+without blocking. When it is found that acquiring a lock would block
+the method will raise an exception (ie `Errno::EAGAIN` /`Errno::EWOULDBLOCK`)
+instead:
+
+```ruby
+require "lockf"
+
+lockf = LockFile.temporary_file
+lockf.lock_nonblock
+print "Lock acquired by parent process (#{Time.now.utc})", "\n"
+pid = fork do
+  lockf.lock_nonblock
+  print "Lock acquired by child process (#{Time.now.utc})", "\n"
+rescue Errno::EWOULDBLOCK
+  print "Lock would block", "\n"
+  sleep 1
+  retry
+end
+sleep 3
+lockf.release
+Process.wait(pid)
+lockf.file.close
+
+##
+# Lock acquired by parent process (2023-02-11 19:03:05 UTC)
+# Lock would block
+# Lock would block
+# Lock would block
+# Lock acquired by child process (2023-02-11 19:03:08 UTC)
+```
+
+### LockFile.lockf
+
+The
+[`LockFile.lockf`](https://0x1eef.github.io/x/lockf.rb/LockFile.html#lockf-class_method)
+method provides a direct interface to
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+that is more or less equivalent to how the function would be called
+from C.
+
+__Blocking lock__
+
+```ruby
+require "lockf"
+require "tempfile"
+
+file = Tempfile.new("lockf-ffi").tap(&:unlink)
+LockFile.lockf(file.fileno, LockFile::F_LOCK, 0)
+print "Lock acquired", "\n"
+LockFile.lockf(file.fileno, LockFile::F_ULOCK, 0)
+print "Lock released", "\n"
+file.close
+
+##
+# Lock acquired
+# Lock released
+```
+
+__Non-blocking lock__
+
+```ruby
+require "lockf"
+require "tempfile"
+
+file = Tempfile.new("lockf-ffi").tap(&:unlink)
+LockFile.lockf(file.fileno, LockFile::F_TLOCK, 0)
+print "Lock acquired", "\n"
+LockFile.lockf(file.fileno, LockFile::F_ULOCK, 0)
+print "Lock released", "\n"
+file.close
+
+##
+# Lock acquired
+# Lock released
+```
+
+## Sources
+
+* [Source code (GitHub)](https://github.com/0x1eef/lockf.rb#readme)
+* [Source code (GitLab)](https://gitlab.com/0x1eef/lockf.rb#about)
+
+## Install
+
+**Git**
+
+lockf.rb is distributed as a RubyGem through its git repositories. <br>
+[GitHub](https://github.com/0x1eef/lockf.rb),
+and
+[GitLab](https://gitlab.com/0x1eef/lockf.rb)
+are available as sources.
+
+``` ruby
+# Gemfile
+gem "lock.fb", github: "0x1eef/lockf.rb", tag: "v0.12.0"
+```
+
+**Rubygems.org**
+
+lock.rb can also be installed via rubygems.org.
+
+    gem install lockf.rb
+
+## License
+
+[BSD Zero Clause](https://choosealicense.com/licenses/0bsd/).
+<br>
+See [LICENSE](./LICENSE).
+

data/Rakefile.rb

@@ -0,0 +1,24 @@
+require "rake/extensiontask"
+require "rake/testtask"
+
+namespace :linters do
+  desc "Run the C linter"
+  task :c do
+    sh "uncrustify -c .uncrustify.cfg --no-backup --replace ext/lockf.rb/*.c"
+  end
+
+  desc "Run the Ruby linter"
+  task :ruby do
+    sh "bundle exec rubocop -A Rakefile.rb lib/**/*.rb spec/**/*.rb"
+  end
+end
+task lint: ["linters:c", "linters:ruby"]
+
+Rake::ExtensionTask.new("lockf.rb")
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList["test/*_test.rb"]
+  t.verbose = true
+  t.warning = false
+end
+task default: %w[clobber compile test]

data/ext/lockf.rb/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+[
+  "INSTALL_DATA", "INSTALL_SCRIPT",
+  "INSTALL_PROGRAM", "INSTALL_DATA",
+  "INSTALL"
+].each do
+  CONFIG[_1].sub!(/-o [a-zA-Z0-9]+/, "")
+  CONFIG[_1].sub!(/-g [a-zA-Z0-9]+/, "")
+end
+
+create_makefile "lockf.rb"

data/ext/lockf.rb/lockf.c

@@ -0,0 +1,36 @@
+#include <ruby.h>
+#include <unistd.h>
+#include <errno.h>
+#include "lockf.h"
+
+static VALUE
+lockf_lock(VALUE self, VALUE fd, VALUE cmd, VALUE len)
+{
+  int result;
+
+  Check_Type(fd, T_FIXNUM);
+  Check_Type(cmd, T_FIXNUM);
+  Check_Type(len, T_FIXNUM);
+  errno = 0;
+  result = lockf(NUM2INT(fd), NUM2INT(cmd), NUM2INT(len));
+  if (result == -1) {
+    rb_syserr_fail(errno, "lockf");
+  } else {
+    return INT2NUM(result);
+  }
+}
+
+void
+Init_lockf(void)
+{
+  VALUE cLockf, mFcntl;
+
+  rb_require("fcntl");
+  cLockf = rb_define_class("LockFile", rb_cObject);
+  mFcntl = rb_const_get(rb_cObject, rb_intern("Fcntl"));
+  rb_define_const(mFcntl, "F_LOCK", INT2NUM(F_LOCK));
+  rb_define_const(mFcntl, "F_TLOCK", INT2NUM(F_TLOCK));
+  rb_define_const(mFcntl, "F_ULOCK", INT2NUM(F_ULOCK));
+  rb_define_const(mFcntl, "F_TEST", INT2NUM(F_TEST));
+  rb_define_singleton_method(cLockf, "lockf", lockf_lock, 3);
+}

data/ext/lockf.rb/lockf.h

@@ -0,0 +1 @@
+void Init_lockf(void);

data/lib/lockf/version.rb

@@ -0,0 +1,3 @@
+class LockFile
+  VERSION = "0.12.0"
+end

data/lib/lockf.rb

@@ -0,0 +1,140 @@
+##
+# The
+# [`LockFile`](https://0x1eef.github.io/x/lockf.rb/LockFile.html)
+# class provides a Ruby-oriented interface to the C function
+# [lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3).
+class LockFile
+  require "tmpdir"
+  require_relative "lockf.rb.so"
+  include Fcntl
+
+  ##
+  # @!method self.lockf(fd, cmd, len)
+  #   @example
+  #     LockFile.lockf(5, LockFile::F_LOCK, 0)
+  #
+  #   @param [Integer] fd
+  #     A number that represents a file descriptor.
+  #
+  #   @param [Integer] cmd
+  #     {LockFile::F_LOCK}, {LockFile::F_TLOCK}, {LockFile::F_ULOCK}, or
+  #     {LockFile::F_TEST}.
+  #
+  #   @param [Integer] len
+  #     The number of bytes to place a lock on.
+  #     A value of "0" covers the entire file.
+  #
+  #   @raise [SystemCallError]
+  #     Might raise a number of Errno exception classes.
+  #
+  #   @return [Integer]
+  #     Returns 0 on success.
+  #
+  #   @see (https://man7.org/linux/man-pages/man3/lockf.3.html) lockf man page (Linux)
+  #   @see (https://man.openbsd.org/lockf.3) lockf man page (OpenBSD)
+  #   @see (https://www.freebsd.org/cgi/man.cgi?query=lockf) lockf man page (FreeBSD)
+
+  ##
+  # @example
+  #   lockf = LockFile.temporary_file
+  #   lockf.lock
+  #   lockf.release
+  #   lockf.file.close
+  #
+  # @param [String] basename
+  #  The basename of the temporary file.
+  #
+  # @param [String] tmpdir
+  #  The path to the parent directory of the temporary file.
+  #
+  # @return [LockFile]
+  #  Returns an instance of {LockFile LockFile} backed by an
+  #  unlinked instance of Tempfile.
+  def self.from_temporary_file(basename: "lockf", tmpdir: Dir.tmpdir)
+    require "tempfile" unless defined?(Tempfile)
+    file = Tempfile.new(basename, tmpdir:).tap(&:unlink)
+    LockFile.new(file)
+  end
+  class << self
+    alias_method :temporary_file, :from_temporary_file
+  end
+
+  ##
+  # @return [<File, Tempfile, #fileno>]
+  #  Returns a file object.
+  attr_reader :file
+
+  ##
+  # @param [<File, TempFile, String, #fileno>] file
+  #  The file to place a lock on.
+  #
+  # @param [Integer] len
+  #  The number of bytes to place a lock on.
+  #  A value of "0" covers the entire file.
+  #
+  # @return [LockFile]
+  #  Returns an instance of {LockFile LockFile}.
+  def initialize(file, len = 0)
+    @file = String === file ? File.open(file, "r+") : file
+    @len = len
+  end
+
+  ##
+  # Acquire a lock (blocking)
+  # @raise [Errno::EBADF]
+  # @raise [Errno::EDEADLK]
+  # @raise [Errno::EINTR]
+  # @raise [Errno::ENOLCK]
+  # @return [Integer]
+  def lock
+    attempts ||= 0
+    LockFile.lockf(@file.fileno, F_LOCK, @len)
+  rescue Errno::EINTR => ex
+    attempts += 1
+    attempts == 3 ? raise(ex) : retry
+  end
+
+  ##
+  # Acquire a lock (non-blocking)
+  # @raise [Errno::EAGAIN]
+  # @raise [Errno::EBADF]
+  # @raise [Errno::ENOLCK]
+  # @raise [Errno::EINVAL]
+  # @return [Integer]
+  def lock_nonblock
+    LockFile.lockf(@file.fileno, F_TLOCK, @len)
+  end
+
+  ##
+  # Release a lock
+  # @raise [Errno::EBADF]
+  # @raise [Errno::ENOLCK]
+  # @return [Integer]
+  def release
+    LockFile.lockf(@file.fileno, F_ULOCK, @len)
+  end
+
+  ##
+  # @return [Boolean]
+  #  Returns true when a lock has been acquired by another process.
+  def locked?
+    LockFile.lockf(@file.fileno, F_TEST, @len)
+    false
+  rescue Errno::EACCES, Errno::EAGAIN
+    true
+  end
+
+  ##
+  # Closes {LockFile#file LockFile#file}.
+  #
+  # @example
+  #   # Equivalent to:
+  #   lockf = LockFile.temporary_file
+  #   lockf.file.close
+  #
+  # @return [void]
+  def close
+    return unless @file.respond_to?(:close)
+    @file.close
+  end
+end

data/lockf.rb.gemspec

@@ -0,0 +1,24 @@
+require "./lib/lockf/version"
+
+Gem::Specification.new do |gem|
+  gem.name = "lockf.rb"
+  gem.authors = ["0x1eef"]
+  gem.email = ["0x1eef@protonmail.com"]
+  gem.homepage = "https://github.com/0x1eef/lockf.rb#readme"
+  gem.version = LockFile::VERSION
+  gem.licenses = ["0BSD"]
+  gem.files = `git ls-files`.split($/)
+  gem.require_paths = ["lib"]
+  gem.extensions = %w[ext/lockf.rb/extconf.rb]
+  gem.summary = "A Ruby interface for lockf(3)"
+  gem.description = gem.summary
+  gem.add_development_dependency "yard", "~> 0.9"
+  gem.add_development_dependency "redcarpet", "~> 3.5"
+  gem.add_development_dependency "standard", "= 1.12.1"
+  gem.add_development_dependency "rubocop", "= 1.29.1"
+  gem.add_development_dependency "test-unit", "~> 3.5.7"
+  gem.add_development_dependency "rake-compiler", "= 1.2.0"
+  gem.add_development_dependency "rack", "~> 3.0"
+  gem.add_development_dependency "rackup", "~> 2.1"
+  gem.add_development_dependency "test-cmd.rb", "~> 0.4"
+end

data/share/lockf.rb/examples/1_lockfile_blocking_variant.rb

@@ -0,0 +1,19 @@
+require "lockf"
+
+lockf = LockFile.from_temporary_file
+lockf.lock
+print "Lock acquired by parent process (#{Time.now.utc})", "\n"
+pid = fork do
+  print "Child process waiting on lock (#{Time.now.utc})", "\n"
+  lockf.lock
+  print "Lock acquired by child process (#{Time.now.utc})", "\n"
+end
+sleep(3)
+lockf.release
+Process.wait(pid)
+lockf.file.close
+
+##
+# Lock acquired by parent process (2023-02-11 16:43:15 UTC)
+# Child process waiting on lock (2023-02-11 16:43:15 UTC)
+# Lock acquired by child process (2023-02-11 16:43:18 UTC)

data/share/lockf.rb/examples/2_lockfile_nonblocking_variant.rb

@@ -0,0 +1,24 @@
+require "lockf"
+
+lockf = LockFile.from_temporary_file
+lockf.lock_nonblock
+print "Lock acquired by parent process (#{Time.now.utc})", "\n"
+pid = fork do
+  lockf.lock_nonblock
+  print "Lock acquired by child process (#{Time.now.utc})", "\n"
+rescue Errno::EWOULDBLOCK
+  sleep 1
+  print "Lock would block", "\n"
+  retry
+end
+sleep 3
+lockf.release
+Process.wait(pid)
+lockf.file.close
+
+##
+# Lock acquired by parent process (2023-02-11 19:03:05 UTC)
+# Lock would block
+# Lock would block
+# Lock would block
+# Lock acquired by child process (2023-02-11 19:03:08 UTC)

data/share/lockf.rb/examples/3_ffilockf_blocking_variant.rb

@@ -0,0 +1,13 @@
+require "lockf"
+require "tempfile"
+
+file = Tempfile.new("lockf-ffi").tap(&:unlink)
+LockFile.lockf(file.fileno, LockFile::F_LOCK, 0)
+print "Lock acquired", "\n"
+LockFile.lockf(file.fileno, LockFile::F_ULOCK, 0)
+print "Lock released", "\n"
+file.close
+
+##
+# Lock acquired
+# Lock released

data/share/lockf.rb/examples/4_ffilockf_nonblocking_variant.rb

@@ -0,0 +1,13 @@
+require "lockf"
+require "tempfile"
+
+file = Tempfile.new("lockf-ffi").tap(&:unlink)
+LockFile.lockf(file.fileno, LockFile::F_TLOCK, 0)
+print "Lock acquired", "\n"
+LockFile.lockf(file.fileno, LockFile::F_ULOCK, 0)
+print "Lock released", "\n"
+file.close
+
+##
+# Lock acquired
+# Lock released

data/test/lock_file_test.rb

@@ -0,0 +1,92 @@
+require_relative "setup"
+class LockFile::Test < Test::Unit::TestCase
+  include Timeout
+  include FileUtils
+  attr_reader :lockf
+
+  def setup
+    @lockf = LockFile.new(file)
+  end
+
+  def teardown
+    file.close
+  end
+
+  ##
+  # Lock::File#lock tests
+  def test_lock
+    assert_equal 0, lockf.lock
+  ensure
+    lockf.release
+  end
+
+  def test_lock_in_fork
+    Process.wait fork {
+      lockf.lock
+      Process.kill("SIGINT", Process.ppid)
+      sleep(1)
+    }
+  rescue Interrupt
+    assert_raises(Timeout::Error) { timeout(0.5) { lockf.lock } }
+  ensure
+    lockf.release
+  end
+
+  ##
+  # Lock::File#lock_nonblock tests
+  def test_lock_nonblock
+    assert_equal 0, lockf.lock_nonblock
+  ensure
+    lockf.release
+  end
+
+  def test_lock_nonblock_in_fork
+    Process.wait fork {
+      lockf.lock_nonblock
+      Process.kill("SIGINT", Process.ppid)
+      sleep(1)
+    }
+  rescue Interrupt
+    assert_raises(Errno::EAGAIN) { lockf.lock_nonblock }
+  ensure
+    lockf.release
+  end
+
+  ##
+  # Lock::File#locked? tests
+  def test_locked?
+    lockf.lock
+    Process.wait fork { lockf.locked? ? exit(0) : exit(1) }
+    assert_equal 0, $?.exitstatus
+  ensure
+    lockf.release
+  end
+
+  ##
+  # LockFile#initialize
+  def test_initialize_with_str_path
+    path = File.join(Dir.getwd, "test", "tmp.txt")
+    touch(path)
+    lockf = LockFile.new(path)
+    assert_equal 0, lockf.lock
+    assert_equal 0, lockf.release
+  ensure
+    lockf.file.close
+    rm(path)
+  end
+
+  ##
+  # LockFile.from_temporary_file
+  def test_from_temporary_file
+    lockf = LockFile.from_temporary_file
+    assert_equal 0, lockf.lock
+    assert_equal 0, lockf.release
+    lockf.file.close
+  end
+
+  private
+
+  def file
+    @file ||= Tempfile.new("lockf-test").tap(&:unlink)
+  end
+end

data/test/readme_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "test/cmd"
+
+class LockFile::ReadmeTest < Test::Unit::TestCase
+  include Test::Cmd
+
+  def test_lockfile_blocking_variant
+    r = 'Lock acquired by parent process \(.+\)\s*' \
+    'Child process waiting on lock \(.+\)\s*' \
+    'Lock acquired by child process \(.+\)\s*'
+    assert_match Regexp.new(r),
+                 readme_example("1_lockfile_blocking_variant.rb").stdout
+  end
+
+  def test_lockfile_nonblocking_variant
+    r = 'Lock acquired by parent process \(.+\)\s*' \
+    '(Lock would block\s*){3,4}' \
+    'Lock acquired by child process \(.+\)\s*'
+    assert_match Regexp.new(r),
+                 readme_example("2_lockfile_nonblocking_variant.rb").stdout
+  end
+
+  def test_ffi_lockf_blocking_variant
+    assert_equal "Lock acquired\nLock released\n",
+                 readme_example("3_ffilockf_blocking_variant.rb").stdout
+  end
+
+  def test_ffi_lockf_nonblocking_variant
+    assert_equal "Lock acquired\nLock released\n",
+                 readme_example("4_ffilockf_nonblocking_variant.rb").stdout
+  end
+
+  private
+
+  def readme_example(path)
+    examples_dir = File.join(Dir.getwd, "share", "lockf.rb", "examples")
+    example = File.join(examples_dir, path)
+    cmd "bundle exec ruby #{example}"
+  end
+end

data/test/setup.rb

@@ -0,0 +1,6 @@
+require "bundler/setup"
+require "test/unit"
+require "lockf"
+require "timeout"
+require "fileutils"
+require "tempfile"

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: lockf.rb
+version: !ruby/object:Gem::Version
+  version: 0.12.0
+platform: ruby
+authors:
+- '0x1eef'
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-01-06 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.29.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.29.1
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: test-cmd.rb
+  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'
+description: A Ruby interface for lockf(3)
+email:
+- 0x1eef@protonmail.com
+executables: []
+extensions:
+- ext/lockf.rb/extconf.rb
+extra_rdoc_files: []
+files:
+- ".bundle/config"
+- ".github/workflows/tests.yml"
+- ".gitignore"
+- ".projectile"
+- ".rubocop.yml"
+- ".uncrustify.cfg"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile.rb
+- ext/lockf.rb/extconf.rb
+- ext/lockf.rb/lockf.c
+- ext/lockf.rb/lockf.h
+- lib/lockf.rb
+- lib/lockf/version.rb
+- lockf.rb.gemspec
+- share/lockf.rb/examples/1_lockfile_blocking_variant.rb
+- share/lockf.rb/examples/2_lockfile_nonblocking_variant.rb
+- share/lockf.rb/examples/3_ffilockf_blocking_variant.rb
+- share/lockf.rb/examples/4_ffilockf_nonblocking_variant.rb
+- test/lock_file_test.rb
+- test/readme_test.rb
+- test/setup.rb
+homepage: https://github.com/0x1eef/lockf.rb#readme
+licenses:
+- 0BSD
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '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: A Ruby interface for lockf(3)
+test_files: []