lockf.rb 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a49042a4d79251c0a85dbe626fefaa323862ea30a45426012a1d8bab08f63fb
-  data.tar.gz: 57f2c700f963a299ce4502e3a7856cc75283ceb80d1c27864ea08438950047d5
+  metadata.gz: 6002e2f48aae8711b6171d35f4458aab8144d287395c29c7072a71d0d7f5e5ca
+  data.tar.gz: f2d13d124949cb8bb12e2d3116fc24a9dc6b15df4d48212d51fc9adb52bf5878
 SHA512:
-  metadata.gz: 7d5c94dbaa6ad0b2eff1fe114e902d7c49014f2bb0ce69b2c5512ae0d107274d7c3c8b6a2d688672faeb85c7b48510689952efd9c64dc4cc78616e3e566f2e8e
-  data.tar.gz: 27c55d59bbab2f8e76b5370b010b3541d65a346b88279361e7f64110b3e6a1fe3f1ddaf4677fbefcec7f2e6409d70483937298f47cda1e3d729c209122d821df
+  metadata.gz: 8000aea494d1af0f6ce3f17b68cd37e35fc486638338038684c0ce29a8ff99f507df065100fbd9a8a49131db263b18999235807e5e8f4155c72a1e54370dda66
+  data.tar.gz: 70fa6fc1d3251d991124aebf9dccd07b6e7f449d2140d0bc173c551bfb86f4416a11af12bde81b5dc15aee0ed9b340ff651b1fbc02fa7cdd54701b3d0536effc

data/README.md

@@ -1,56 +1,93 @@
 ## About
 
-lockf.rb provides Ruby bindings for
-[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3).
+lockf.rb offers Ruby bindings for the advisory-mode lock
+provided by the
+[lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+function. It is similar to flock(2) in spirit but it also has semantic 
+differences that can be desirable when used across the fork(2) boundary 
+and that is usually the main reason to use this library.
+
+## Background
+
+The primary difference between lockf(3) and flock(2) in practical terms 
+is that locks created with lockf(3) persist across fork(2). That is to 
+say, if a parent process acquires a lock and then forks a child process, 
+the child process will have to wait until the parent process releases 
+the lock before it can acquire the same lock. This is not the case with 
+flock(2).
+
+The technical explanation is that lockf(3) creates a lock that is owned
+by the process rather than the open file description (as is the case with 
+flock(2)). Since a lock belongs to the process, it cannot be acquired
+by more than one process at a time, and with flock(2) the acquisition
+of a lock won't block as long as the lock is held by the same open file
+description, which is the case after fork(2).
+
+To the best of my knowledge, Ruby does not provide built-in support for
+lockf(3) so the library fills that gap.
+
+## Features
+
+* Pure Ruby bindings with zero dependencies outside Ruby's standard library
+* Temporary, unlinked locks backed by a Tempfile
+* Blocking and non-blocking locks
+* Low-level abstraction
 
 ## Examples
 
-### Lock::File
+### Synchronization
 
-__Blocking__
+#### Synchronize
 
-[Lock::File#lock](http://0x1eef.github.io/x/lockf.rb/Lock/File.html#lock-instance_method)
-can be used to acquire a lock.
-[Lock::File.temporary_file](http://0x1eef.github.io/x/lockf.rb/Lock/File.html#temporary_file-class_method)
-returns a lock for an unlinked temporary file.
-[Lock::File#lock](http://0x1eef.github.io/x/lockf.rb/Lock/File.html#lock-instance_method)
-will block when another
-process has acquired a lock beforehand:
+The `synchronize` and `synchronize!` methods provide both a locking,
+and non-blocking lock that is released automatically when the
+block yields and returns control to the caller. The non-blocking
+form (`synchronize!`) raises a subclass of SystemCallError if the
+lock cannot be acquired right away. 
+
+With all that said, the next example uses the blocking-form of
+these two methods, the synchronize method, to create a critical 
+section that is executed serially by multiple processes. The example 
+creates a lock that is backed by a randomly named, unlinked temporary 
+file:
 
 ```ruby
 #!/usr/bin/env ruby
-require "lock/file"
-
-lockf = Lock::File.temporary_file
-lockf.lock
-print "Lock acquired by parent process (#{Time.now.utc})", "\n"
-fork do
-  print "Child process waiting on lock (#{Time.now.utc})", "\n"
-  lockf.lock
-  print "Lock acquired by child process (#{Time.now.utc})", "\n"
+require "lockf"
+
+lockf = Lockf.unlinked
+5.times do
+  Process.detach fork {
+    lockf.synchronize do
+      print "Lock acquired (pid #{Process.pid})", "\n"
+      sleep 5
+    end
+  }
 end
-sleep(3)
-lockf.release
-Process.wait
 
 ##
-# 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)
+# Lock acquired (pid 12345)
+# Lock acquired (pid 12346)
+# ...
 ```
 
-__Non-blocking__
+#### Procedural
+
+When more control over the lock and release process is required,
+the `lock`, `lock_nonblock`, and `release` methods can be used
+to acquire and release locks procedurally without a block.
 
-[Lock::File#lock_nonblock](http://0x1eef.github.io/x/lockf.rb/Lock/File.html#lock_nonblock-instance_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 (`Errno::EAGAIN` / `Errno::EWOULDBLOCK`) instead:
+The following example is different from the last one in that it
+uses the procedural style, and rather than acquiring a blocking
+lock the acquire in this example is non-blocking. When the lock 
+is found to block, a system-specific subclass of SystemCallError
+will be raised:
 
 ```ruby
 #!/usr/bin/env ruby
-require "lock/file"
+require "lockf"
 
-lockf = Lock::File.temporary_file
+lockf = Lockf.unlinked
 lockf.lock_nonblock
 print "Lock acquired by parent process (#{Time.now.utc})", "\n"
 fork do
@@ -73,33 +110,6 @@ Process.wait
 # Lock acquired by child process (2023-02-11 19:03:08 UTC)
 ```
 
-### Lock::File::FFI
-
-__lockf__
-
-[Lock::File::FFI.lockf](http://0x1eef.freebsd.home.network/x/lockf.rb/Lock/File/FFI.html#lockf-instance_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:
-
-```ruby
-#!/usr/bin/env ruby
-require "lock/file"
-require "tempfile"
-
-file = Tempfile.new("lockf-ffi").tap(&:unlink)
-Lock::File::FFI.lockf(file, Lock::File::F_LOCK, 0)
-print "Lock acquired", "\n"
-Lock::File::FFI.lockf(file, Lock::File::F_ULOCK, 0)
-print "Lock released", "\n"
-file.close
-
-##
-# Lock acquired
-# Lock released
-```
-
 ## Documentation
 
 A complete API reference is available at
@@ -113,8 +123,8 @@ lockf.rb can be installed via rubygems.org:
 
 ## Sources
 
-* [GitHub](https://github.com/0x1eef/lockf.rb#readme)
-* [GitLab](https://gitlab.com/0x1eef/lockf.rb#about)
+* [github.com/@0x1eef](https://github.com/0x1eef/lockf.rb#readme)
+* [gitlab.com/@0x1eef](https://gitlab.com/0x1eef/lockf.rb#about)
 
 ## License
 

data/Rakefile.rb

@@ -1,15 +1,28 @@
 require "bundler/setup"
+require "bundler/gem_tasks"
 
 namespace :format do
-  desc "Run rubocop"
-  task :ruby do
+  desc "Apply rubocop fixes"
+  task :apply do
     sh "bundle exec rubocop -A"
   end
+
+  desc "Run rubocop"
+  task :check do
+    sh "bundle exec rubocop"
+  end
 end
-task format: %w[format:ruby]
+task format: %w[format:apply]
+
+desc "Run CI tasks"
+task ci: %i[format:check test]
 
 desc "Run tests"
 task :test do
-  sh "bin/test-runner"
+  sh <<-SHELL
+    for t in test/*_test.rb; do
+      bundle exec ruby ${t} || exit 1
+    done
+  SHELL
 end
 task default: %w[test]

data/lib/{lock/file → lockf}/constants.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Lock::File
+class Lockf
   # The constants found in this module are defined
   # by unistd.h. Their documentation can be found in
   # the

data/lib/lockf/ffi.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Lockf
+  module FFI
+    require "fiddle"
+    include Fiddle::Types
+    extend self
+
+    ##
+    # The common superclass for FFI errors
+    Error = Class.new(RuntimeError)
+
+    ##
+    # The error raised when dlopen(3) fails
+    LinkError = Class.new(Error)
+
+    @libc ||= begin
+      globs = %w[
+        /lib/libc.so.*
+        /usr/lib/libc.so.*
+        /lib/x86_64-linux-gnu/libc.so.*
+        /lib/i386-linux-gnu/libc.so.*
+      ]
+      Fiddle.dlopen(Dir[*globs].first)
+    rescue => ex
+      raise LinkError, "link of libc had an error", cause: ex
+    end unless defined?(@libc)
+
+    @function = Fiddle::Function.new(
+      @libc["lockf"],
+      [INT, INT, INT],
+      INT
+    ) unless defined?(@function)
+
+    ##
+    # Provides a Ruby interface for lockf(3)
+    # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
+    # @param [Integer, #fileno] fd
+    # @param [Integer] fn
+    # @param [Integer] size
+    # @raise [SystemCallError]
+    #  Might raise a subclass of SystemCallError
+    # @return [Boolean]
+    #  Returns true when successful
+    def lockf(fd, fn, size = 0)
+      fileno = fd.respond_to?(:fileno) ? fd.fileno : fd
+      Lockf::FFI.function.call(fileno, fn, size).zero? ||
+        raise(SystemCallError.new("lockf", Fiddle.last_error))
+    end
+
+    ##
+    # @api private
+    def self.function = @function
+  end
+end

data/lib/lockf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Lockf
+  VERSION = "3.0.0"
+end

data/lib/lockf.rb

@@ -1 +1,146 @@
-require_relative "lock/file"
+##
+# {Lockf Lockf} provides an object-oriented
+# [lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
+# interface
+class Lockf
+  require_relative "lockf/version"
+  require_relative "lockf/ffi"
+  require_relative "lockf/constants"
+
+  include FFI
+  include Constants
+
+  ##
+  # Accepts the same parameters as Tempfile.new
+  # @example
+  #  lockf = Lockf.unlinked
+  #  lockf.lock
+  #  # ...
+  # @return [Lockf]
+  #  Returns a {Lockf Lockf} for a random,
+  #  unlinked temporary file
+  def self.unlinked(...)
+    require "tempfile" unless defined?(Tempfile)
+    Lockf.new Tempfile.new(...).tap(&:unlink)
+  end
+
+  ##
+  # @return [<#fileno>]
+  #  Returns a file handle
+  attr_reader :file
+
+  ##
+  # @param [<#fileno>] file
+  # @param [Integer] size
+  # @return [Lockf]
+  #  Returns an instance of {Lockf Lockf}
+  def initialize(file, size = 0)
+    @file = file
+    @size = size
+  end
+
+  ##
+  # Acquire lock (blocking)
+  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
+  # @raise [SystemCallError]
+  #  Might raise a subclass of SystemCallError
+  # @return [Boolean]
+  #  Returns true when successful
+  def lock
+    try(function: F_LOCK)
+  end
+
+  ##
+  # Acquire lock (non-blocking)
+  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
+  # @raise [SystemCallError]
+  #  Might raise a subclass of SystemCallError
+  # @return [Boolean]
+  #  Returns true when successful
+  def lock_nonblock
+    try(function: F_TLOCK)
+  end
+
+  ##
+  # Release lock
+  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
+  # @raise [SystemCallError]
+  #  Might raise a subclass of SystemCallError
+  # @return [Boolean]
+  #  Returns true when successful
+  def release
+    try(function: F_ULOCK)
+  end
+
+  ##
+  # Acquire a blocking lock, yield, and finally release  the lock
+  # @example
+  #  lockf = Lockf.unlinked
+  #  lockf.synchronize do
+  #    # critical section
+  #  end
+  # @raise [SystemCallError]
+  #  Might raise a subclass of SystemCallError
+  # @return [Object]
+  #  Returns the return value of the block
+  def synchronize
+    locked = false
+    lock
+    locked = true
+    yield
+  ensure
+    release if locked
+  end
+
+  ##
+  # Acquire a non-blocking lock, yield, and finally release the lock
+  # @note
+  #  If the lock cannot be acquired, an exception is raised immediately
+  # @example
+  #  lockf = Lockf.unlinked
+  #  lockf.synchronize! do
+  #    # critical section
+  #  end
+  # @raise [SystemCallError]
+  #  Might raise a subclass of SystemCallError
+  # @return [Object]
+  #  Returns the return value of the block
+  def synchronize!
+    locked = false
+    lock_nonblock
+    locked = true
+    yield
+  ensure
+    release if locked
+  end
+
+  ##
+  # @return [Boolean]
+  #  Returns true when lock can be acquired
+  def lockable?
+    try(function: F_TEST)
+    true
+  rescue Errno::EACCES, Errno::EAGAIN, Errno::EWOULDBLOCK
+    false
+  end
+
+  ##
+  # Closes {Lockf#file Lockf#file}
+  # @example
+  #  # Equivalent to:
+  #  lockf = Lockf.unlinked
+  #  lockf.file.close
+  # @return [void]
+  def close
+    @file.respond_to?(:close) ? @file.close : nil
+  end
+
+  private
+
+  def try(function: F_LOCK, attempts: 3)
+    lockf(@file, function, @size)
+  rescue Errno::EINTR => ex
+    attempts -= 1
+    (attempts == 0) ? raise(ex) : retry
+  end
+end

data/share/lockf.rb/examples/{1_lockfile_blocking_variant.rb → 1_lock_file_blocking_variant.rb}

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "lock/file"
-lockf = Lock::File.temporary_file
+require "lockf"
+lockf = Lockf.unlinked
 lockf.lock
 print "Lock acquired by parent process (#{Time.now.utc})", "\n"
 fork do

data/share/lockf.rb/examples/{2_lockfile_nonblocking_variant.rb → 2_lock_file_nonblocking_variant.rb}

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "lock/file"
-lockf = Lock::File.temporary_file
+require "lockf"
+lockf = Lockf.unlinked
 lockf.lock_nonblock
 print "Lock acquired by parent process (#{Time.now.utc})", "\n"
 fork do

data/share/lockf.rb/examples/{3_ffilockf_blocking_variant.rb → 3_ffi_lockf_blocking_variant.rb}

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "lock/file"
+require "lockf"
 require "tempfile"
 file = Tempfile.new("lockf-ffi").tap(&:unlink)
-Lock::File::FFI.lockf(file, Lock::File::F_LOCK, 0)
+Lockf::FFI.lockf(file, Lockf::F_LOCK, 0)
 print "Lock acquired", "\n"
-Lock::File::FFI.lockf(file, Lock::File::F_ULOCK, 0)
+Lockf::FFI.lockf(file, Lockf::F_ULOCK, 0)
 print "Lock released", "\n"
 file.close
 

data/share/lockf.rb/examples/{4_ffilockf_nonblocking_variant.rb → 4_ffi_lockf_nonblocking_variant.rb}

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "lock/file"
+require "lockf"
 require "tempfile"
 file = Tempfile.new("lockf-ffi").tap(&:unlink)
-Lock::File::FFI.lockf(file, Lock::File::F_TLOCK, 0)
+Lockf::FFI.lockf(file, Lockf::F_TLOCK, 0)
 print "Lock acquired", "\n"
-Lock::File::FFI.lockf(file, Lock::File::F_ULOCK, 0)
+Lockf::FFI.lockf(file, Lockf::F_ULOCK, 0)
 print "Lock released", "\n"
 file.close
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lockf.rb
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - '0x1eef'
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fiddle
@@ -24,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.6
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.39'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.39'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -101,38 +114,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".bundle/config"
-- ".clang-format"
-- ".github/workflows/tests.yml"
-- ".gitignore"
-- ".projectile"
-- ".rubocop.yml"
-- ".uncrustify.cfg"
-- ".yardopts"
-- Gemfile
 - LICENSE
 - README.md
 - Rakefile.rb
-- bin/test-runner
-- lib/lock/file.rb
-- lib/lock/file/constants.rb
-- lib/lock/file/ffi.rb
-- lib/lock/file/version.rb
 - lib/lockf.rb
-- lib/lockfile.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
+- lib/lockf/constants.rb
+- lib/lockf/ffi.rb
+- lib/lockf/version.rb
+- share/lockf.rb/examples/1_lock_file_blocking_variant.rb
+- share/lockf.rb/examples/2_lock_file_nonblocking_variant.rb
+- share/lockf.rb/examples/3_ffi_lockf_blocking_variant.rb
+- share/lockf.rb/examples/4_ffi_lockf_nonblocking_variant.rb
 homepage: https://github.com/0x1eef/lockf.rb#readme
 licenses:
 - 0BSD
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -147,8 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby bindings for lockf(3)
 test_files: []

data/.bundle/config

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

data/.clang-format

@@ -1,11 +0,0 @@
-BasedOnStyle: LLVM
-IndentWidth: 2
-SortIncludes: false
-UseTab: Never
-BreakBeforeBraces: Allman
-AllowShortFunctionsOnASingleLine: Inline
-AlwaysBreakAfterDefinitionReturnType: TopLevel
-BreakBeforeBinaryOperators: All
-BinPackArguments: false
-AlignConsecutiveAssignments: true
-AlwaysBreakAfterReturnType: None

data/.github/workflows/tests.yml

@@ -1,23 +0,0 @@
-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

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

data/.projectile

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

data/.rubocop.yml

@@ -1,25 +0,0 @@
-##
-# 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: 3.2
-  Include:
-    - lib/*.rb
-    - lib/**/*.rb
-    - test/*.rb

data/.uncrustify.cfg

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

data/.yardopts

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

data/Gemfile

@@ -1,2 +0,0 @@
-source "https://rubygems.org"
-gemspec

data/bin/test-runner

@@ -1,6 +0,0 @@
-#!/bin/sh
-set -e
-
-for t in test/*_test.rb; do
-    ruby -Itest "${t}"
-done

data/lib/lock/file/ffi.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-class Lock::File
-  module FFI
-    require "fiddle"
-    include Fiddle::Types
-    extend self
-
-    ##
-    # Provides a Ruby interface for lockf(3)
-    #
-    # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
-    # @param [Integer, #fileno] fd
-    # @param [Integer] function
-    # @param [Integer] size
-    # @raise [SystemCallError]
-    #  Might raise a subclass of SystemCallError
-    # @return [Boolean]
-    #  Returns true when successful
-    def lockf(fd, function, size = 0)
-      fileno = fd.respond_to?(:fileno) ? fd.fileno : fd
-      Fiddle::Function.new(
-        libc["lockf"],
-        [INT, INT, INT],
-        INT
-      ).call(fileno, function, size)
-       .zero? || raise(SystemCallError.new("lockf", Fiddle.last_error))
-    end
-
-    private
-
-    def libc
-      @libc ||= Fiddle.dlopen Dir["/lib/libc.*"].first
-    end
-  end
-end

data/lib/lock/file/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Lock::File
-  VERSION = "2.0.0"
-end

data/lib/lock/file.rb

@@ -1,114 +0,0 @@
-module Lock
-end unless defined?(Lock)
-
-##
-# {Lock::File Lock::File} provides an object-oriented
-# [lockf(3)](https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3)
-# interface
-class Lock::File
-  require "tmpdir"
-  require_relative "file/version"
-  require_relative "file/ffi"
-  require_relative "file/constants"
-
-  include FFI
-  include Constants
-
-  ##
-  # @example
-  #  lockf = Lock::File.temporary_file
-  #  lockf.lock
-  #  # ...
-  #
-  # @param [String] basename
-  # @param [String] tmpdir
-  # @return [Lock::File]
-  #  Returns a {Lock::File Lock::File} for a random,
-  #  unlinked temporary file
-  def self.from_temporary_file(basename: "lockf", tmpdir: Dir.tmpdir)
-    require "tempfile" unless defined?(Tempfile)
-    file = Tempfile.new(basename, tmpdir:).tap(&:unlink)
-    Lock::File.new(file)
-  end
-  class << self
-    alias_method :temporary_file, :from_temporary_file
-  end
-
-  ##
-  # @return [<#fileno>]
-  #  Returns a file handle
-  attr_reader :file
-
-  ##
-  # @param [<#fileno>] file
-  # @param [Integer] size
-  # @return [Lock::File]
-  #  Returns an instance of {Lock::File Lock::File}
-  def initialize(file, size = 0)
-    @file = file
-    @size = size
-  end
-
-  ##
-  # Acquire lock (blocking)
-  #
-  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
-  # @raise [SystemCallError]
-  #  Might raise a subclass of SystemCallError
-  # @return [Boolean]
-  #  Returns true when successful
-  def lock
-    tries ||= 0
-    lockf(@file, F_LOCK, @size)
-  rescue Errno::EINTR => ex
-    tries += 1
-    tries == 3 ? raise(ex) : retry
-  end
-
-  ##
-  # Acquire lock (non-blocking)
-  #
-  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
-  # @raise [SystemCallError]
-  #  Might raise a subclass of SystemCallError
-  # @return [Boolean]
-  #  Returns true when successful
-  def lock_nonblock
-    lockf(@file, F_TLOCK, @size)
-  end
-
-  ##
-  # Release lock
-  #
-  # @see https://man.freebsd.org/cgi/man.cgi?query=lockf&sektion=3 lockf(3)
-  # @raise [SystemCallError]
-  #  Might raise a subclass of SystemCallError
-  # @return [Boolean]
-  #  Returns true when successful
-  def release
-    lockf(@file, F_ULOCK, @size)
-  end
-
-  ##
-  # @return [Boolean]
-  #  Returns true when lock is held by another process
-  def locked?
-    lockf(@file, F_TEST, @size)
-    false
-  rescue Errno::EACCES, Errno::EAGAIN
-    true
-  end
-
-  ##
-  # Closes {Lock::File#file Lock::File#file}
-  #
-  # @example
-  #  # Equivalent to:
-  #  lockf = Lock::File.temporary_file
-  #  lockf.file.close
-  # @return [void]
-  def close
-    return unless @file.respond_to?(:close)
-    @file.close
-  end
-end

data/lib/lockfile.rb

@@ -1 +0,0 @@
-require_relative "lock/file"

data/lockf.rb.gemspec

@@ -1,21 +0,0 @@
-require_relative "lib/lockfile"
-
-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 = Lock::File::VERSION
-  gem.licenses = ["0BSD"]
-  gem.files = `git ls-files`.split($/)
-  gem.require_paths = ["lib"]
-  gem.summary = "Ruby bindings for lockf(3)"
-  gem.description = gem.summary
-
-  gem.add_runtime_dependency "fiddle", "~> 1.1"
-  gem.add_development_dependency "yard", "~> 0.9"
-  gem.add_development_dependency "standard", "~> 1.12"
-  gem.add_development_dependency "rubocop", "~> 1.29"
-  gem.add_development_dependency "test-unit", "~> 3.5"
-  gem.add_development_dependency "test-cmd.rb", "~> 0.12"
-end

data/test/lock_file_test.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-require_relative "setup"
-
-class Lock::File::Test < Test::Unit::TestCase
-  attr_reader :file
-  attr_reader :lockf
-
-  def setup
-    @file = Tempfile.new("lockf-test").tap(&:unlink)
-    @lockf = Lock::File.new(file)
-  end
-
-  def teardown
-    file.close
-  end
-
-  ##
-  # LockFile#lock
-  def test_lock
-    assert_equal true, lockf.lock
-  ensure
-    lockf.release
-  end
-
-  def test_lock_in_fork
-    pid = fork_sleep { lockf.lock }
-    sleep(0.1)
-    assert_raises(Errno::EWOULDBLOCK) { lockf.lock_nonblock }
-  ensure
-    Process.kill("KILL", pid)
-    lockf.release
-  end
-
-  ##
-  # LockFile#lock_nonblock
-  def test_lock_nonblock
-    assert_equal true, lockf.lock_nonblock
-  ensure
-    lockf.release
-  end
-
-  def test_lock_nonblock_in_fork
-    pid = fork_sleep { lockf.lock_nonblock }
-    sleep(0.1)
-    assert_raises(Errno::EWOULDBLOCK) { lockf.lock_nonblock }
-  ensure
-    Process.kill("KILL", pid)
-    lockf.release
-  end
-
-  ##
-  # LockFile#locked?
-  def test_locked?
-    pid = fork_sleep { lockf.lock }
-    sleep(0.1)
-    assert_equal true, lockf.locked?
-  ensure
-    Process.kill("KILL", pid)
-    lockf.release
-  end
-
-  ##
-  # LockFile.temporary_file
-  def test_temporary_file
-    lockf = Lock::File.temporary_file
-    assert_equal true, lockf.lock
-    assert_equal true, lockf.release
-  ensure
-    lockf.file.close
-  end
-
-  private
-
-  def fork_sleep
-    fork do
-      yield
-      sleep
-    end
-  end
-end

data/test/readme_test.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "setup"
-require "test/cmd"
-
-class Lock::File::ReadmeTest < Test::Unit::TestCase
-  def test_lockfile_blocking_variant
-    r = ruby(readme_example("1_lockfile_blocking_variant.rb"))
-    ["Lock acquired by parent process \(.+\)\n",
-     "Child process waiting on lock \(.+\)\n",
-     "Lock acquired by child process \(.+\)\n"
-    ].each { assert_match Regexp.new(_1), r.stdout }
-  end
-
-  def test_lockfile_nonblocking_variant
-    r = ruby(readme_example("2_lockfile_nonblocking_variant.rb"))
-    ["Lock acquired by parent process \(.+\)\n",
-     "(Lock would block\n){3,4}",
-     "Lock acquired by child process \(.+\)\n"
-    ].each { assert_match Regexp.new(_1), r.stdout }
-  end
-
-  def test_ffi_lockf_blocking_variant
-    assert_equal "Lock acquired\nLock released\n",
-                 ruby(readme_example("3_ffilockf_blocking_variant.rb")).stdout
-  end
-
-  def test_ffi_lockf_nonblocking_variant
-    assert_equal "Lock acquired\nLock released\n",
-                 ruby(readme_example("4_ffilockf_nonblocking_variant.rb")).stdout
-  end
-
-  private
-
-  def ruby(*argv)
-    cmd("ruby", *argv)
-  end
-
-  def readme_example(example_name)
-    File.join(__dir__, "..", "share", "lockf.rb", "examples", example_name)
-  end
-end

data/test/setup.rb

@@ -1,4 +0,0 @@
-require "bundler/setup"
-require "test/unit"
-require "lock/file"
-require "tempfile"