tayle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c3659dae92c4938d1fcd1b672acdaae573381d210e53c760960dac3ba03fe91
+  data.tar.gz: f0a81610b40f35d0aae755aebd0e48f87eee4facc711cc8bad4167b8ebc5bfa2
+SHA512:
+  metadata.gz: 315cec2e7111c0e0ce81ee01df7fe0c15cb96e24b7f9d778214dcdd45d3d6f3e8a6bde57111ba85d08105425410d223987f2eb17f2d4d1418a0c0da5d24f7937
+  data.tar.gz: e5f7be6634d58b59df2dc222476b136ba481c388f7f022bad00a8f64240ef08442a9f937c9958568709e3e932cb160df8db39cfd257a85495fc1e8549934f956

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,476 @@
+# =============================================================================
+# RuboCop configuration
+#
+# Base:       stock RuboCop defaults (verified against 1.91.0)
+# Plugins:    rubocop-claude (AI guardrails), rubocop-rspec, rubocop-performance
+#             (chain-hostile cops disabled), rubocop-rake
+# Philosophy: idiomatic Ruby, pipeline-style chaining, strict for AI agents,
+#             readable for humans.
+# =============================================================================
+
+plugins:
+  - rubocop-claude
+  - rubocop-rspec
+  - rubocop-performance
+  - rubocop-rake
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 4.0
+  Exclude:
+    - bin/*
+    - vendor/**/*
+
+# =============================================================================
+# Layout
+# =============================================================================
+
+# Consistent 2-space indent for a first argument on its own line, never
+# aligned to a nested call.
+#
+#   # bad
+#   foo = some_method(nested_call(
+#                       nested_first_param
+#                     ))
+#
+#   # good
+#   foo = some_method(nested_call(
+#     nested_first_param
+#   ))
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent
+
+# Dot-aligned chaining: the dots form a visual column. This is stock's default,
+# restated here because rubocop-claude switches it to `indented`.
+#
+#   # bad
+#   ROOT = Pathname(__dir__)
+#     .parent
+#
+#   # good
+#   ROOT = Pathname(__dir__)
+#          .parent
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: aligned
+
+# =============================================================================
+# Metrics
+# =============================================================================
+
+# Short blocks push toward small chained steps instead of fat lambdas.
+# Stock default is 25. We want 8.
+#
+#   # bad - 9 lines of body
+#   users.map do |user|
+#     name = user.full_name
+#     parts = name.split(" ")
+#     first = parts.first
+#     last = parts.last
+#     domain = user.email.split("@").last
+#     address = "#{first}.#{last}@#{domain}"
+#     normalized = address.downcase
+#     handle = normalized.strip
+#     handle.to_sym
+#   end
+#
+#   # good - each step is one line
+#   users
+#     .map(&:full_name)
+#     .map { it.split(" ") }
+#     .map { "#{it.first}.#{it.last}" }
+#     .map(&:downcase)
+#
+# CountAsOne: a multiline array, hash, heredoc, or method call is one line.
+#
+#   # good - the hash spans 10 lines but counts as 1
+#   users.each do |user|
+#     attributes = {
+#       id: user.id,
+#       name: user.name,
+#       email: user.email,
+#       role: user.role,
+#       plan: user.plan,
+#       status: user.status,
+#       created_at: user.created_at,
+#       updated_at: user.updated_at,
+#     }
+#     audit(attributes)
+#   end
+#
+# AllowedMethods: DSL blocks are exempt. Replaces stock's `refine` entry.
+#
+#   # good - long, but `describe` is allowed
+#   describe Foo do
+#     # ... any number of lines
+#   end
+#
+# Exclude: the gemspec is one long block by construction.
+Metrics/BlockLength:
+  Max: 8
+  CountAsOne:
+    - array
+    - hash
+    - heredoc
+    - method_call
+  AllowedMethods:
+    - command
+    - describe
+    - context
+    - namespace
+    - shared_examples
+    - shared_examples_for
+    - shared_context
+  Exclude:
+    - "tayle.gemspec"
+
+# =============================================================================
+# Style: strings
+# =============================================================================
+
+# Double quotes everywhere. One less decision to make.
+#
+#   # bad
+#   name = 'Alice'
+#
+#   # good
+#   name = "Alice"
+#   greeting = "Hello, #{name}"
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# Same rule inside interpolation. Stock wants single quotes here.
+#
+#   # bad
+#   status = "Tests #{success ? 'PASS' : 'FAIL'}"
+#
+#   # good
+#   status = "Tests #{success ? "PASS" : "FAIL"}"
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+# Frozen string literal is transitional cruft. Ruby 3.4 has chilled strings,
+# and full default freeze is coming. `never` makes autocorrect strip existing
+# magic comments.
+#
+#   # bad - autocorrect will strip this
+#   # frozen_string_literal: true
+#
+#   class Foo
+#   end
+#
+#   # good
+#   class Foo
+#   end
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: never
+
+# =============================================================================
+# Style: literals
+# =============================================================================
+
+# Write arrays like arrays. Disabled cops flag the second form in stock.
+#
+#   # allowed here, flagged by stock
+#   colors = ["red", "green", "blue"]
+#
+#   # not used
+#   colors = %w[red green blue]
+Style/WordArray:
+  Enabled: false
+
+#   # allowed here, flagged by stock
+#   statuses = [:active, :inactive, :pending]
+#
+#   # not used
+#   statuses = %i[active inactive pending]
+Style/SymbolArray:
+  Enabled: false
+
+# Trailing commas in multiline literals and arguments. Cleaner diffs: adding an
+# element doesn't touch the previous line, and appending saves a keystroke.
+# `comma` applies only when each element sits on its own line.
+#
+#   # bad
+#   method_call(
+#     arg1,
+#     arg2
+#   )
+#
+#   # good
+#   method_call(
+#     arg1,
+#     arg2,
+#   )
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+#   # bad
+#   colors = [
+#     "red",
+#     "green"
+#   ]
+#
+#   # good
+#   colors = [
+#     "red",
+#     "green",
+#   ]
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+#   # bad
+#   hash = {
+#     name: "Alice",
+#     age: 30
+#   }
+#
+#   # good
+#   hash = {
+#     name: "Alice",
+#     age: 30,
+#   }
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+# Only literal mutable values get flagged. The Zeitwerk loader is mutable by
+# design — it keeps registering autoloads after LOADER is assigned.
+#
+#   # bad
+#   COLORS = ["red", "green", "blue"]
+#
+#   # good
+#   COLORS = ["red", "green", "blue"].freeze
+#
+#   # good - not a literal, so `strict` would be wrong here
+#   LOADER = Zeitwerk::Loader.for_gem.tap(&:setup)
+Style/MutableConstant:
+  EnforcedStyle: literals
+
+# =============================================================================
+# Style: blocks and pipelines
+# =============================================================================
+
+# Pipeline style. Chaining multiline blocks is the whole point. Stock forbids
+# a multiline block followed by another call.
+#
+#   # allowed here, flagged by stock
+#   users
+#     .select do |user|
+#       user.active?
+#       user.confirmed?
+#     end
+#     .map do |user|
+#       user.name
+#     end
+Style/MultilineBlockChain:
+  Enabled: false
+
+# Block delimiters are a taste call. Braces for functional transforms, do/end
+# for side effects. No cop captures this nuance.
+#
+#   # allowed here, flagged by stock (multiline braces)
+#   names = users.map { |user|
+#     user.name.downcase
+#   }
+#
+#   # good in both
+#   users.each do |user|
+#     send_notification(user)
+#     log_activity(user)
+#   end
+Style/BlockDelimiters:
+  Enabled: false
+
+# =============================================================================
+# Style: error handling
+# =============================================================================
+
+# Inline fallback is fine when the failure mode is obvious.
+#
+#   # allowed here, flagged by stock
+#   port = Integer(ENV["PORT"]) rescue 3000
+Style/RescueModifier:
+  Enabled: false
+
+# An explicit begin/rescue/end scopes what's being rescued. Without it, the
+# rescue reads as part of the method signature. Stock flags a begin that wraps
+# the entire body.
+#
+#   # allowed here, flagged by stock
+#   def process
+#     begin
+#       dangerous_call
+#     rescue NetworkError => e
+#       retry_later(e)
+#     end
+#   end
+#
+#   # also fine, and needs no exemption: begin scopes only part of the body
+#   def process
+#     logger.info("starting")
+#     begin
+#       dangerous_call
+#     rescue NetworkError => e
+#       retry_later(e)
+#     end
+#     logger.info("done")
+#   end
+Style/RedundantBegin:
+  Enabled: false
+
+# =============================================================================
+# Style: methods and documentation
+# =============================================================================
+
+# Named args are explicit and portable. Anonymous forwarding (*, **, &) breaks
+# TruffleRuby, JRuby, and Ruby < 3.2. Stock wants `...` or anonymous.
+#
+#   # allowed here, flagged by stock
+#   def process(*args, **kwargs, &block)
+#     other_method(*args, **kwargs, &block)
+#   end
+Style/ArgumentsForwarding:
+  Enabled: false
+
+# Same rationale as above. Stock wants a bare `&`.
+#
+#   # bad
+#   def process(&)
+#     other_method(&)
+#   end
+#
+#   # good
+#   def process(&block)
+#     other_method(&block)
+#   end
+Naming/BlockForwarding:
+  EnforcedStyle: explicit
+
+# Endless methods are a one-line trick. Every method gets def/end. Stock
+# only forbids the multiline form.
+#
+#   # bad
+#   def upstream = "http://#{host}:#{port}"
+#
+#   # good
+#   def upstream
+#     "http://#{host}:#{port}"
+#   end
+Style/EndlessMethod:
+  EnforcedStyle: disallow
+
+# Classes get rdoc. Run `rake rdoc` and keep it honest. Already on in stock;
+# the override only exempts specs and tests.
+#
+#   # bad
+#   class UserService
+#     attr_reader :user
+#   end
+#
+#   # good
+#   # Handles user lifecycle operations.
+#   class UserService
+#     attr_reader :user
+#   end
+Style/Documentation:
+  Enabled: true
+  Exclude:
+    - "spec/**/*"
+    - "test/**/*"
+
+# Compact class names are fine for small files and tests.
+#
+#   # allowed here, flagged by stock
+#   class Tayle::Writer
+#   end
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# =============================================================================
+# Overrides from rubocop-claude — loosen where pipeline style conflicts
+# =============================================================================
+
+# Safe navigation reads fine two links deep; past that it hides a nil bug.
+Claude/NoOverlyDefensiveCode:
+  MaxSafeNavigationChain: 2
+
+Style/SafeNavigation:
+  MaxChainLength: 2
+
+# Allow `return a, b` for tuple-style returns.
+Style/RedundantReturn:
+  AllowMultipleReturnValues: true
+
+# The gemspec's `\x0`-delimited `git ls-files` reader is deliberate, not fancy,
+# and the PTY specs have to send real control characters: ctrl+c and ctrl+z.
+Claude/NoFancyUnicode:
+  AllowedUnicode:
+    - "\u0003" # ctrl+c
+    - "\u001A" # ctrl+z
+  Exclude:
+    - "tayle.gemspec"
+
+# lib/ documents with rdoc, whose usage examples are indented code in comments.
+# The cop only recognizes YARD's `@example`, so every rdoc example reads as
+# commented-out code to it.
+Claude/NoCommentedCode:
+  Exclude:
+    - "lib/**/*"
+
+# =============================================================================
+# Overrides from rubocop-performance — disable chain-hostile cops
+# =============================================================================
+
+Performance/ChainArrayAllocation:
+  Enabled: false
+
+Performance/MapMethodChain:
+  Enabled: false
+
+# =============================================================================
+# RSpec — rubocop-rspec overrides
+# =============================================================================
+
+# spec/fixtures holds programs the specs run, not specs. They are ordinary
+# Ruby and the RSpec cops have nothing to say about them.
+RSpec:
+  Exclude:
+    - "spec/fixtures/**/*"
+
+# Not every describe block wraps a class.
+RSpec/DescribeClass:
+  Enabled: false
+
+# spec_helper gives every example `aggregate_failures`, so a second expectation
+# still reports both failures instead of masking the later one.
+RSpec/MultipleExpectations:
+  Max: 2
+
+# These specs nest by process state: shell, then job control, then signal.
+RSpec/NestedGroups:
+  Max: 5
+
+# `in` for the shell a watcher runs in, `and` for a context that narrows the
+# one above it.
+RSpec/ContextWording:
+  Prefixes:
+    - when
+    - with
+    - without
+    - in
+    - and
+
+# Subject placement is a readability call, not a rule.
+RSpec/LeadingSubject:
+  Enabled: false
+
+# Block style for expect { }.to change { } reads like a sentence.
+RSpec/ExpectChange:
+  EnforcedStyle: block
+
+RSpec/NamedSubject:
+  Enabled: false
+
+# Shared contexts legitimately define many helpers.
+RSpec/MultipleMemoizedHelpers:
+  Max: 10

data/.ruby-version

@@ -0,0 +1 @@
+4.0.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 David Gillis
+
+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,40 @@
+# Tayle
+
+Follow a file by name with GNU tail -F, across rotation and truncation
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add tayle
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install tayle
+
+## Usage
+
+`Tayle.new` follows a file by name, so it keeps going across log rotation and
+truncation. Reading starts at the current end of the file:
+
+```ruby
+Tayle.new("app.log") do |tayle|
+  tayle.each_line(chomp: true).lazy.map(&:upcase).each { puts it }
+end
+```
+
+Pass `position: :start` to read what the log already holds first, `writer_pid:`
+to stop once the process writing it does, and `tail_path:` to run a `tail`
+other than the first on `PATH`. See the rdoc on `Tayle` for the details.
+
+Requires GNU coreutils `tail` 8.28 or newer; anything else raises
+`Tayle::Unsupported`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake` to run the specs and RuboCop.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+require "gempilot/version_task"
+Gempilot::VersionTask.new
+
+require "gempilot/zeitwerk_task"
+Gempilot::ZeitwerkTask.new
+
+task default: [:spec, :rubocop]

data/lib/tayle/command.rb

@@ -0,0 +1,36 @@
+class Tayle
+  POSITIONS = [:start, :end].freeze
+  private_constant :POSITIONS
+
+  Command = Data.define(:executable, :path, :writer, :position) do
+    def initialize(executable:, path:, writer:, position:)
+      unless POSITIONS.include?(position)
+        raise ArgumentError, "position: must be :start or :end, not #{position.inspect}"
+      end
+
+      super(executable:, path: Pathname(path), writer:, position:)
+    end
+
+    def argv
+      [
+        executable.to_s,
+        "-F",
+        "--sleep-interval=0.1",
+        *writer&.flag,
+        "--bytes=+#{first_byte}",
+        "--",
+        path.to_s,
+      ]
+    end
+
+    private
+
+    def first_byte
+      case position
+      in :start then 1
+      in :end then path.size?.to_i + 1
+      end
+    end
+  end
+  private_constant :Command
+end

data/lib/tayle/gnu_tail.rb

@@ -0,0 +1,37 @@
+class Tayle
+  OLDEST_SUPPORTED_VERSION = [8, 28].freeze
+  private_constant :OLDEST_SUPPORTED_VERSION
+
+  GnuTail = Data.define(:executable, :version) do
+    def self.locate(command)
+      executable = list_candidates(command).find { it.file? && it.executable? }
+      raise Unsupported, "#{command} not found or not executable" unless executable
+
+      new(executable:, version: read_version(executable)).tap(&:check_supported)
+    end
+
+    def self.list_candidates(command)
+      return [Pathname(command)] if command.to_s.include?("/")
+
+      ENV
+        .fetch("PATH", "")
+        .split(File::PATH_SEPARATOR)
+        .map { Pathname(it).join(command) }
+    end
+
+    def self.read_version(executable)
+      IO.popen([executable.to_s, "--version"], err: File::NULL, &:read)
+        .match(/\Atail \(GNU coreutils\) (\d+)\.(\d+)/)
+        &.then { [Integer(it[1]), Integer(it[2])] }
+    end
+    private_class_method :list_candidates, :read_version
+
+    def check_supported
+      raise Unsupported, "#{executable} is not GNU coreutils tail" unless version
+      return unless (version <=> OLDEST_SUPPORTED_VERSION).negative?
+
+      raise Unsupported, "#{executable} is GNU coreutils tail #{version.join(".")}; Tayle needs 8.28 or newer"
+    end
+  end
+  private_constant :GnuTail
+end

data/lib/tayle/version.rb

@@ -0,0 +1,3 @@
+class Tayle
+  VERSION = "0.0.1".freeze
+end

data/lib/tayle/writer.rb

@@ -0,0 +1,23 @@
+class Tayle
+  Writer = Data.define(:pid) do
+    def initialize(pid:)
+      super(pid: Integer(pid))
+    end
+
+    def flag
+      "--pid=#{pid}"
+    end
+
+    def gone?
+      begin
+        Process.kill(0, pid)
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ESRCH
+        true
+      end
+    end
+  end
+  private_constant :Writer
+end

data/lib/tayle.rb

@@ -0,0 +1,128 @@
+require "zeitwerk"
+
+##
+# Follows a file by name with GNU <tt>tail -F</tt>, so it keeps going across log rotation and
+# truncation.  If this process dies without #close, +tail+ exits once nothing holds the read end
+# of its pipe: at once with inotify, within 0.1s when polling.
+#
+# GNU tail's own limits still apply: records written to a log after it is rotated away are lost,
+# and a log truncated and refilled past its old size before +tail+ notices is read from the old
+# offset.
+#
+#   Tayle.new("app.log") do |tayle|
+#     tayle.each_line(chomp: true).lazy.map(&:upcase).each { puts it }
+#   end
+#
+# Pass <tt>position: :start</tt> to read what the log already holds first, +writer_pid+ to stop
+# when the process writing it does, and +tail_path+ to run a +tail+ other than the first on +PATH+:
+#
+#   writer_pid = Integer(Pathname("app.pid").read)
+#   Tayle.new("app.log", position: :start, writer_pid:, tail_path: "/opt/coreutils/bin/tail") do |tayle|
+#     tayle.each { print it }
+#   end
+class Tayle
+  include Enumerable
+
+  ##
+  # The Zeitwerk loader autoloading everything under +lib/tayle/+.
+  LOADER = Zeitwerk::Loader.for_gem.tap(&:setup)
+
+  ##
+  # Raised by Tayle.new unless +tail_path+ names an executable GNU coreutils +tail+ 8.28 or newer,
+  # the first release to exit by itself once nothing reads its output.
+  class Unsupported < StandardError
+  end
+
+  ##
+  # Raised by #each if +tail+ stops for any reason but its writer exiting: killed, say, or failed.
+  class Exited < StandardError
+    ##
+    # The Process::Status of +tail+, or +nil+ if something else reaped it first.
+    attr_reader :status
+
+    def initialize(status:)
+      @status = status
+      super("tail exited: #{status || "unknown status"}")
+    end
+  end
+
+  ##
+  # The number of lines #each has yielded, across every call; still readable after #close.
+  attr_reader :lines_read
+
+  ##
+  # Follows +path+ (a String or Pathname) from its current end, so only what is appended from now
+  # on is yielded; <tt>position: :start</tt> yields what is already there first.  A missing +path+
+  # is read from its first byte once it appears, though GNU tail then polls instead of using
+  # inotify.
+  #
+  # With +writer_pid+, <tt>tail --pid</tt> exits within 0.1s of that process being reaped (an
+  # unreaped zombie still counts as alive), after one last read, and #each returns.
+  #
+  # +tail_path+ (a String or Pathname) names the +tail+ to run: a path if it contains a slash,
+  # otherwise a command looked up on +PATH+.  Raises Unsupported unless that is an executable GNU
+  # coreutils +tail+ 8.28 or newer.
+  #
+  # With a block, yields the Tayle and closes it when the block exits.
+  def initialize(path, writer_pid: nil, tail_path: "tail", position: :end, &block)
+    @writer = writer_pid&.then { Writer.new(pid: it) }
+    @lines_read = 0
+    @owner_pid = Process.pid
+    gnu_tail = GnuTail.locate(tail_path)
+    @command = Command.new(executable: gnu_tail.executable, path:, writer: @writer, position:)
+    @pipe = IO.popen(@command.argv)
+    yield_and_close(&block) if block
+  end
+
+  ##
+  # The Pathname being followed.
+  def path
+    @command.path
+  end
+
+  ##
+  # Where reading began: +:start+ or +:end+ of #path.  Not a live offset, since +tail+ moves on to
+  # a new file when the log is rotated.
+  def position
+    @command.position
+  end
+
+  ##
+  # Yields each line as it is appended, blocking until the next one arrives; +chomp+ strips the
+  # line ending.  Returns an Enumerator without a block, or +self+ once +tail+ exits after the
+  # writer has; raises Exited if +tail+ stops any other way.  As with any IO, #close from another
+  # thread raises IOError in the thread iterating.
+  def each(chomp: false)
+    return enum_for(__method__, chomp:) unless block_given?
+
+    @pipe.each_line(chomp:) do |line|
+      @lines_read += 1
+      yield line
+    end
+    @pipe.close
+    raise Exited.new(status: Process.last_status) unless @writer&.gone?
+
+    self
+  end
+  alias each_line each
+
+  ##
+  # Kills +tail+ with SIGKILL, which it cannot ignore, and reaps it; in a forked child, only drops
+  # the child's copy of the pipe.  Safe to call more than once.
+  def close
+    return if @pipe.closed?
+
+    Process.kill(:KILL, @pipe.pid) if Process.pid == @owner_pid
+    @pipe.close
+  end
+
+  private
+
+  def yield_and_close
+    begin
+      yield self
+    ensure
+      close
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: tayle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Gillis
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- david@flipmine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tayle.rb
+- lib/tayle/command.rb
+- lib/tayle/gnu_tail.rb
+- lib/tayle/version.rb
+- lib/tayle/writer.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.22
+specification_version: 4
+summary: Follow a file by name with GNU tail -F, across rotation and truncation
+test_files: []