net-ping 2.0.9 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3139e0db447950138a58ab9e60996ef49a89fc89e157ef1b66bf67ef5557450
-  data.tar.gz: 7529e34db8bf6d258a830fd725969af4dd6eee3ee59a500423e1f13256372079
+  metadata.gz: 27c470dd18b95b9b05e68e1dd6e79da70a8c8d4eaaa28581e770fa4d0d028aca
+  data.tar.gz: fc020ad255eb094dd057f552e67c36f83a00e87aa88e12837ceb3f2bf1c8673b
 SHA512:
-  metadata.gz: '0947a086f3da9bb83a81f16e84d4e5fa761508f6a71109051e2ec315c972c83806085863a67d4cc5299e7c337a8ecef9f4bf8aa4afd907064bbd589dc9ff7966'
-  data.tar.gz: d16d032dcea9783d50305592c6dd4242436a1357f73233b2af787fafc68a03c6d408f5c1d3b328b2cc62395a7f7f64acd8ca4915fee647154fbb25b0474f98eb
+  metadata.gz: 4fc2c4d695cbdb27ddd478b92929f6f9164eb07d768b56ee8f6d69cb102ded9bfe435ff0fd389136b77a86f200440da26f6078bca87561275f881f5b5abb7c24
+  data.tar.gz: 5c45a5a55df135b3145e6aab5b3286c27d92487e9a5ac0329ada3641659acef7a8c69a4fb8f22ac2d04b6c68627a6335fd7c9ca2c681987c35713da78472cdbe

data/CHANGES

@@ -1,3 +1,19 @@
+== 2.1.0 - 08-Aug-2026
+* Publish platform-specific gem metadata so Linux installs cap2 and current
+  Windows RubyInstaller installs win32-security for ICMP support
+  [#44](https://github.com/eitoball/net-ping/pull/44).
+* Fix the FreeBSD ping6 timeout option
+  [#43](https://github.com/eitoball/net-ping/pull/43).
+* Add Ruby 4.0 to the test matrix and add win32ole as an explicit Windows
+  dependency, since it is no longer a default gem as of Ruby 4.0
+  [#41](https://github.com/eitoball/net-ping/pull/41).
+* Move Net::Ping::VERSION into its own file so the gemspec version can no
+  longer drift out of sync with it
+  [#37](https://github.com/eitoball/net-ping/pull/37).
+* Fix `Net::Ping::External#ping6` setting a spurious "undefined method '=~'
+  for false" exception on success
+  [#39](https://github.com/eitoball/net-ping/pull/39).
+
 == 2.0.9 - 25-Jul-2026
 * Add GitHub Actions CI [#33](https://github.com/eitoball/net-ping/pull/33)
   and update its supported Ruby versions [#38](https://github.com/eitoball/net-ping/pull/38).

data/CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development commands
+
+Install dependencies:
+
+```sh
+bundle install
+```
+
+Run the default suite:
+
+```sh
+bundle exec rake test
+```
+
+Run one protocol-specific test file through its Rake task:
+
+```sh
+bundle exec rake test:tcp
+bundle exec rake test:http
+bundle exec rake test:udp
+bundle exec rake test:external
+bundle exec rake test:icmp
+bundle exec rake test:wmi
+```
+
+There is no lint task or linter configuration. Build the gem with
+`bundle exec rake gem:create`; `bundle exec rake gem:install` builds and
+installs it locally.
+
+`test:icmp` requires elevated privileges: root or `net_raw` capability on
+Unix (checked via the `cap2` gem, falling back to a root check if `cap2`
+isn't available), or elevated security on Windows (via `win32-security`).
+The aggregate `test` task (`test/test_net_ping.rb`) only requires the ICMP
+test file when that privilege check passes. External-ping tests invoke the
+system `ping` command; HTTP tests use FakeWeb/webmock except the timeout
+case, which makes a real network connection.
+
+CI (`.github/workflows/test.yml`) runs `bundle exec rake test` on
+ubuntu-latest and windows-latest across Ruby 2.7-3.4.
+
+## Architecture
+
+This is a Ruby gem that exposes `Net::Ping` implementations for several
+reachability mechanisms:
+
+- `lib/net/ping/ping.rb` defines the abstract `Net::Ping` base class and its
+  shared state: `host`, `port`, `timeout`, `exception`, `warning`, and
+  `duration`.
+- `lib/net/ping/{tcp,udp,icmp,external,http}.rb` implement socket, raw ICMP,
+  system-command, and HTTP pings. `wmi.rb` is loaded only on Windows
+  (`File::ALT_SEPARATOR` check).
+- `lib/net/ping.rb` is the all-in-one entry point (`require 'net/ping'`);
+  requiring a protocol file directly (e.g. `require 'net/ping/tcp'`) loads
+  only that implementation and reduces memory footprint.
+- Each protocol has a matching `test/test_net_ping_<protocol>.rb` file. The
+  aggregate `test/test_net_ping.rb` requires the supported protocol suites
+  based on the platform/privilege checks described above.
+
+## Repository-specific conventions
+
+- A subclass `ping` method calls `super(host)` first. The base implementation
+  validates that a host is present and resets `@exception`, `@warning`, and
+  `@duration` for each attempt.
+- `ping` returns a truthy success value or `false`; callers inspect
+  `exception` after failures rather than receive connection errors. Set
+  `duration` only after a successful ping and leave it `nil` on failure.
+  `ping?` is the boolean wrapper supplied by the base class (or an explicit
+  alias in `External`).
+- TCP and UDP treat connection refusal according to their class-level
+  `service_check` setting (aliased as `econnrefused`/`ecr`). Keep the
+  Boolean-only setter validation and test both modes when changing that
+  behavior.
+- Preserve platform branches: `External` maps `ping`/`ping6` options to each
+  OS's `ping`/`ping6` syntax (Linux, AIX, BSD/macOS, Solaris, HP-UX, Windows),
+  ICMP requires raw-socket privileges, and WMI is Windows-only.
+- HTTP tests stub requests with FakeWeb/webmock and reset proxy environment
+  variables in `setup`; register any new HTTP cases rather than making
+  ordinary tests depend on live services.
+
+## Repository layout notes
+
+- `.worktrees/` contains git worktrees for in-progress branches; treat them
+  as separate checkouts, not part of the main tree.
+- `docs/superpowers/` holds plan/spec documents from prior sessions using the
+  `superpowers` skill set — reference material, not source.

data/Gemfile

@@ -1,2 +1,8 @@
 source 'https://rubygems.org'
 gemspec
+gem 'win32-security', '>= 0.2.0' if Gem.win_platform?
+
+# No longer a default gem as of Ruby 4.0. Used by the WMI ping class.
+gem 'win32ole', '>= 1.8.8' if Gem.win_platform?
+
+gem 'cap2', '>= 0.2.2' if RUBY_PLATFORM =~ /linux/i

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    net-ping (2.0.9)
+    net-ping (2.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,7 +3,9 @@ A collection of classes that provide different ways to ping computers.
 
 ## Prerequisites
   * ffi
-  * win32-security (MS Windows only)
+  * win32-security (installed from the Windows gem artifact)
+  * win32ole (installed from the Windows gem artifact)
+  * cap2 (installed from the Linux gem artifact)
   * webmock (test only)
   * test-unit (test only)
 

data/Rakefile

@@ -5,25 +5,110 @@ include Object.const_defined?(:RbConfig) ? RbConfig : Config
 
 CLEAN.include("**/*.gem", "**/*.rbc")
 
+GEMSPEC_FILES = %w[
+  net-ping.gemspec
+  net-ping-universal-linux.gemspec
+  net-ping-universal-mingw-ucrt.gemspec
+].freeze
+
+EXPECTED_GEM_METADATA = {
+  'net-ping.gemspec' => ['ruby', {}],
+  'net-ping-universal-linux.gemspec' => ['universal-linux', {'cap2' => '>= 0.2.2'}],
+  'net-ping-universal-mingw-ucrt.gemspec' => [
+    'universal-mingw-ucrt',
+    {'win32-security' => '>= 0.2.0', 'win32ole' => '>= 1.8.8'}
+  ]
+}.freeze
+
+def load_gem_specifications
+  GEMSPEC_FILES.map do |path|
+    spec = Gem::Specification.load(path)
+    abort("Unable to load #{path}") unless spec
+    spec
+  end
+end
+
+def with_unbundled_env
+  if defined?(Bundler) && Bundler.respond_to?(:with_unbundled_env)
+    Bundler.with_unbundled_env { yield }
+  elsif defined?(Bundler) && Bundler.respond_to?(:with_clean_env)
+    Bundler.with_clean_env { yield }
+  else
+    yield
+  end
+end
+
+def platform_round_trips?(platform_string)
+  Gem::Platform.new(platform_string).to_s == platform_string
+end
+
+def platform_installable?(spec)
+  if Gem::Platform.respond_to?(:installable?)
+    Gem::Platform.installable?(spec)
+  else
+    Gem::Platform.match(spec.platform)
+  end
+end
+
+def select_install_specification(specifications = load_gem_specifications)
+  specific = specifications.find do |spec|
+    spec.platform != Gem::Platform::RUBY && platform_installable?(spec)
+  end
+  spec = specific || specifications.find { |item| item.platform == Gem::Platform::RUBY }
+  abort('Unable to find a Ruby fallback gem specification') unless spec
+  spec
+end
+
 namespace 'gem' do
-  desc 'Create the net-ping gem'
+  desc 'Create the net-ping gem artifacts (ruby, universal-linux, universal-mingw-ucrt)'
   task :create => [:clean] do
-    spec = eval(IO.read('net-ping.gemspec'))
+    specifications = load_gem_specifications
     if Gem::VERSION.to_f < 2.0
-      Gem::Builder.new(spec).build
+      specifications.each do |spec|
+        Gem::Builder.new(spec).build
+      end
     else
       require 'rubygems/package'
-      Gem::Package.build(spec)
+      specifications.each do |spec|
+        Gem::Package.build(spec)
+      end
+    end
+  end
+
+  desc 'Validate the net-ping gem artifacts'
+  task :check do
+    require 'rubygems/package'
+
+    EXPECTED_GEM_METADATA.each do |path, expectation|
+      expected_platform, expected_dependencies = expectation
+      artifact = Gem::Specification.load(path).file_name
+      packaged_spec = Gem::Package.new(artifact).spec
+      actual_dependencies = packaged_spec.runtime_dependencies.each_with_object({}) do |dependency, memo|
+        memo[dependency.name] = dependency.requirement.to_s
+      end
+
+      if platform_round_trips?(expected_platform) && packaged_spec.platform.to_s != expected_platform
+        abort("#{artifact}: expected platform #{expected_platform.inspect}, got #{packaged_spec.platform.to_s.inspect}")
+      end
+
+      if actual_dependencies != expected_dependencies
+        abort("#{artifact}: expected dependencies #{expected_dependencies.inspect}, got #{actual_dependencies.inspect}")
+      end
     end
   end
 
   desc 'Install the net-ping gem'
   task :install => [:create] do
-    gem_file = Dir["*.gem"].first
-    if RUBY_PLATFORM == 'java'
-      sh "jruby -S gem install -l #{gem_file}"
+    spec = select_install_specification
+
+    install_command = if RUBY_PLATFORM == 'java'
+      ['jruby', '-S', 'gem', 'install', '-l', spec.file_name]
     else
-      sh "gem install -l #{gem_file}"
+      ['gem', 'install', '-l', spec.file_name]
+    end
+
+    with_unbundled_env do
+      sh(*install_command)
     end
   end
 end

data/docs/superpowers/plans/2026-07-25-platform-specific-gems.md

@@ -0,0 +1,317 @@
+# Platform-specific Gem Dependencies Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build and validate RubyGems artifacts that install `cap2` on Linux and `win32-security` on current Windows RubyInstaller systems.
+
+**Architecture:** Keep `net-ping.gemspec` OS-independent and create two small gemspec overlays for Linux and `mingw-ucrt`. Centralize artifact generation and metadata validation in the Rake gem namespace, then run that validation in the existing Linux/Windows CI matrix.
+
+**Tech Stack:** Ruby, RubyGems (`Gem::Specification`, `Gem::Package`, `Gem::Platform`), Rake, test-unit, GitHub Actions.
+
+## Global Constraints
+
+- Produce exactly three same-version `net-ping` gems: `ruby`, `universal-linux`, and `universal-mingw-ucrt`.
+- `universal-linux` must add `cap2 (>= 0.2.2)`; `universal-mingw-ucrt` must add `win32-security (>= 0.2.0)`.
+- The Ruby gem must not contain either OS-specific runtime dependency.
+- Support `mingw-ucrt` only; legacy `mingw32` is out of scope.
+- CI builds and validates artifacts but never publishes them.
+- Do not create git commits for this work.
+
+---
+
+## File Structure
+
+| File | Responsibility |
+| --- | --- |
+| `net-ping.gemspec` | Define the OS-independent Ruby artifact and common metadata. |
+| `net-ping-universal-linux.gemspec` | Overlay `universal-linux` and the `cap2` runtime dependency. |
+| `net-ping-universal-mingw-ucrt.gemspec` | Overlay `universal-mingw-ucrt` and the `win32-security` runtime dependency. |
+| `Rakefile` | Build, inspect, and locally install the platform-appropriate artifact. |
+| `test/test_net_ping_gem_packaging.rb` | Build temporary artifacts and assert their platform/dependency metadata. |
+| `test/test_net_ping.rb` | Load the packaging test in the aggregate suite. |
+| `.github/workflows/test.yml` | Run gem artifact checks on Linux and Windows. |
+| `README.md` | Explain automatic platform-specific dependency installation. |
+| `CHANGES` | Record the metadata correction for the next release. |
+
+### Task 1: Define and test platform gem specifications
+
+**Files:**
+- Create: `net-ping-universal-linux.gemspec`
+- Create: `net-ping-universal-mingw-ucrt.gemspec`
+- Create: `test/test_net_ping_gem_packaging.rb`
+- Modify: `net-ping.gemspec:1-40`
+- Modify: `test/test_net_ping.rb`
+
+**Interfaces:**
+- Consumes: `net-ping.gemspec`, which supplies the shared `Gem::Specification`.
+- Produces: three loadable gemspecs whose `platform` and `runtime_dependencies` describe their target platform.
+
+- [ ] **Step 1: Write the failing package-metadata test**
+
+Create `test/test_net_ping_gem_packaging.rb`. Load every gemspec before building any artifact so `spec.files` cannot include an artifact created for an earlier specification. Build the loaded specifications into temporary `.gem` files, open each using `Gem::Package`, and assert the platform and runtime dependencies:
+
+```ruby
+require 'rubygems/package'
+require 'test/unit'
+
+class TestNetPingGemPackaging < Test::Unit::TestCase
+  EXPECTATIONS = {
+    'net-ping.gemspec' => ['ruby', {}],
+    'net-ping-universal-linux.gemspec' => ['universal-linux', {'cap2' => '>= 0.2.2'}],
+    'net-ping-universal-mingw-ucrt.gemspec' => [
+      'universal-mingw-ucrt',
+      {'win32-security' => '>= 0.2.0'}
+    ]
+  }.freeze
+
+  def setup
+    @specifications = EXPECTATIONS.keys.map do |path|
+      [path, Gem::Specification.load(path)]
+    end
+    @gem_files = @specifications.map { |_, spec| Gem::Package.build(spec) }
+  end
+
+  def teardown
+    @gem_files.each { |path| File.delete(path) if File.exist?(path) }
+  end
+
+  def test_platforms_and_runtime_dependencies
+    @specifications.each do |path, spec|
+      expected_platform, expected_dependencies = EXPECTATIONS.fetch(path)
+      packaged_spec = Gem::Package.new(spec.file_name).spec
+      dependencies = packaged_spec.runtime_dependencies.to_h do |dependency|
+        [dependency.name, dependency.requirement.to_s]
+      end
+
+      assert_equal(expected_platform, packaged_spec.platform.to_s, path)
+      assert_equal(expected_dependencies, dependencies, path)
+    end
+  end
+end
+```
+
+Add `require 'test_net_ping_gem_packaging'` to `test/test_net_ping.rb`.
+
+- [ ] **Step 2: Run the new test to verify it fails**
+
+Run:
+
+```sh
+bundle exec ruby -Itest test/test_net_ping_gem_packaging.rb
+```
+
+Expected: failure because the Linux and Windows overlay gemspec files do not exist.
+
+- [ ] **Step 3: Make the base gemspec OS-independent and add overlays**
+
+Remove the `File::ALT_SEPARATOR`, `RbConfig`, and `RUBY_PLATFORM` conditional runtime dependency logic from `net-ping.gemspec`; leave only shared metadata and development dependencies.
+
+Create `net-ping-universal-linux.gemspec`:
+
+```ruby
+spec = Gem::Specification.load('net-ping.gemspec')
+spec.platform = Gem::Platform.new(['universal', 'linux'])
+spec.add_dependency('cap2', '>= 0.2.2')
+spec
+```
+
+Create `net-ping-universal-mingw-ucrt.gemspec`:
+
+```ruby
+spec = Gem::Specification.load('net-ping.gemspec')
+spec.platform = Gem::Platform.new(['universal', 'mingw-ucrt'])
+spec.add_dependency('win32-security', '>= 0.2.0')
+spec
+```
+
+Use the project’s existing block-style `Gem::Specification.new` format for the base gemspec. Verify the installed RubyGems version accepts the two platform strings with `Gem::Platform.new`.
+
+- [ ] **Step 4: Run the package-metadata test to verify it passes**
+
+Run:
+
+```sh
+bundle exec ruby -Itest test/test_net_ping_gem_packaging.rb
+```
+
+Expected: PASS; all three artifacts have the expected platform and exactly the expected runtime dependencies.
+
+- [ ] **Step 5: Run the aggregate test suite**
+
+Run:
+
+```sh
+bundle exec rake test
+```
+
+Expected: PASS.
+
+### Task 2: Make Rake build, validate, and install platform artifacts deterministically
+
+**Files:**
+- Modify: `Rakefile:6-29`
+
+**Interfaces:**
+- Consumes: the three gemspec paths from Task 1.
+- Produces: `gem:create` builds all artifacts; `gem:check` aborts on invalid artifact metadata; `gem:install` installs the local platform’s specific artifact or the Ruby fallback.
+
+- [ ] **Step 1: Add a failing artifact-validation command**
+
+Add `gem:check` to the `gem` namespace. It must load the three expected gem files with `Gem::Package`, map each runtime dependency to `name => requirement.to_s`, and abort if the platform or dependency hash differs from:
+
+```ruby
+{
+  'ruby' => {},
+  'universal-linux' => {'cap2' => '>= 0.2.2'},
+  'universal-mingw-ucrt' => {'win32-security' => '>= 0.2.0'}
+}
+```
+
+Run it before changing `gem:create`:
+
+```sh
+bundle exec rake clean gem:create gem:check
+```
+
+Expected: FAIL because `gem:create` still builds only one artifact.
+
+- [ ] **Step 2: Implement deterministic specification loading and artifact creation**
+
+Define the shared list once in `Rakefile`:
+
+```ruby
+GEMSPEC_FILES = %w[
+  net-ping.gemspec
+  net-ping-universal-linux.gemspec
+  net-ping-universal-mingw-ucrt.gemspec
+].freeze
+```
+
+Update `gem:create` to load all files before it builds any artifact:
+
+```ruby
+specifications = GEMSPEC_FILES.map { |path| Gem::Specification.load(path) }
+specifications.each { |spec| Gem::Package.build(spec) }
+```
+
+Retain the existing RubyGems pre-2.0 builder branch if support for it is still required. In either branch, load every specification before beginning the build loop.
+
+Implement `gem:check` using `Gem::Package.new(file).spec`; use `abort` with the artifact filename and expected/actual values when a check fails.
+
+Update `gem:install` to load the same specification list and select:
+
+```ruby
+specific = specifications.find do |spec|
+  spec.platform != Gem::Platform::RUBY && Gem::Platform.installable?(spec)
+end
+spec = specific || specifications.find { |item| item.platform == Gem::Platform::RUBY }
+```
+
+Install `spec.file_name`, not `Dir['*.gem'].first`; abort when no Ruby fallback specification is found.
+
+- [ ] **Step 3: Run artifact validation to verify it passes**
+
+Run:
+
+```sh
+bundle exec rake gem:create gem:check
+```
+
+Expected: PASS and creation of `net-ping-<version>.gem`,
+`net-ping-<version>-universal-linux.gem`, and
+`net-ping-<version>-universal-mingw-ucrt.gem`.
+
+- [ ] **Step 4: Verify local artifact selection**
+
+Run:
+
+```sh
+bundle exec rake gem:install
+gem specification net-ping platform
+```
+
+Expected on Linux: `universal-linux`; on Windows: `universal-mingw-ucrt`; on
+other platforms: `ruby`.
+
+- [ ] **Step 5: Re-run tests**
+
+Run:
+
+```sh
+bundle exec rake test
+```
+
+Expected: PASS.
+
+### Task 3: Enforce packaging in CI and document the behavior
+
+**Files:**
+- Modify: `.github/workflows/test.yml:19-28`
+- Modify: `README.md:4-15`
+- Modify: `CHANGES:1-13`
+
+**Interfaces:**
+- Consumes: `gem:create` and `gem:check` from Task 2.
+- Produces: CI verification on both matrix operating systems and accurate end-user dependency documentation.
+
+- [ ] **Step 1: Add the CI packaging verification step**
+
+After the existing `bundle exec rake test` step, add:
+
+```yaml
+      - run: bundle exec rake gem:create gem:check
+```
+
+Do not add RubyGems credentials, publishing actions, or tag triggers.
+
+- [ ] **Step 2: Document platform-specific dependency resolution**
+
+Replace the prerequisite list’s unconditional `win32-security (MS Windows
+only)` wording with text that states RubyGems installs `win32-security` from
+the Windows artifact and `cap2` from the Linux artifact when installing
+`net-ping`. Keep the installation command `gem install net-ping`.
+
+At the beginning of `CHANGES`, add:
+
+```text
+== Next Release
+* Publish platform-specific gem metadata so Linux installs cap2 and current
+  Windows RubyInstaller installs win32-security for ICMP support.
+```
+
+- [ ] **Step 3: Run targeted packaging and full test verification**
+
+Run:
+
+```sh
+bundle exec rake gem:create gem:check
+bundle exec rake test
+```
+
+Expected: both commands PASS.
+
+- [ ] **Step 4: Inspect the final diff without committing**
+
+Run:
+
+```sh
+git diff --check
+git diff -- net-ping.gemspec net-ping-universal-linux.gemspec \
+  net-ping-universal-mingw-ucrt.gemspec Rakefile \
+  test/test_net_ping_gem_packaging.rb test/test_net_ping.rb \
+  .github/workflows/test.yml README.md CHANGES
+```
+
+Expected: only the planned packaging, CI, test, and documentation changes;
+no whitespace errors and no git commit.
+
+## Plan Self-Review
+
+- **Spec coverage:** Task 1 creates the three required artifacts and assigns
+  their dependencies; Task 2 validates metadata and selects a local artifact;
+  Task 3 runs validation in CI and documents the behavior. CI publishing,
+  legacy `mingw32`, and runtime protocol changes are excluded.
+- **Placeholder scan:** No unresolved item, unspecified test, or ambiguous
+  implementation step remains.
+- **Consistency:** The gemspec filenames, platform names, dependency
+  versions, and Rake task names are identical across all tasks.

data/docs/superpowers/specs/2026-07-25-platform-specific-gems-design.md

@@ -0,0 +1,71 @@
+# Platform-specific gem dependencies
+
+## Goal
+
+Resolve issue #31 by publishing platform-specific `net-ping` gems whose
+runtime dependencies accurately describe the requirements for ICMP support.
+The solution also corrects the equivalent Linux `cap2` metadata omission.
+
+## Scope
+
+The release produces three gems with the same name and version:
+
+| Gem platform | Additional runtime dependency |
+| --- | --- |
+| `ruby` | None |
+| `universal-linux` | `cap2 (>= 0.2.2)` |
+| `universal-mingw-ucrt` | `win32-security (>= 0.2.0)` |
+
+Only the current RubyInstaller `mingw-ucrt` platform is supported for Windows.
+Legacy `mingw32` is out of scope.
+
+The CI workflow builds and validates these gems, but does not publish them.
+The existing release process remains responsible for pushing all three files
+to RubyGems.
+
+## Design
+
+`net-ping.gemspec` becomes the OS-independent Ruby gemspec. It must not
+inspect the host OS or add OS-specific runtime dependencies.
+
+`net-ping-universal-linux.gemspec` loads the base specification, changes its
+platform to `universal-linux`, and adds `cap2`. The platform is intentionally
+CPU-independent so RubyGems can select it for supported Linux CPU variants.
+
+`net-ping-universal-mingw-ucrt.gemspec` loads the same base specification,
+changes its platform to `universal-mingw-ucrt`, and adds `win32-security`.
+
+The Rake gem namespace explicitly enumerates the three gemspecs. `gem:create`
+cleans old gem artifacts and builds all three. `gem:install` selects the
+specific generated specification compatible with the local platform, falling
+back to the Ruby specification when no platform-specific specification
+matches, then installs its artifact.
+
+## Verification
+
+Add `gem:check`, which reads each generated gem through RubyGems and fails
+when its platform or runtime dependencies differ from this specification:
+
+- Ruby gem: platform `ruby`; neither `cap2` nor `win32-security`.
+- Linux gem: platform `universal-linux`; includes `cap2`.
+- Windows gem: platform `universal-mingw-ucrt`; includes `win32-security`.
+
+The existing GitHub Actions matrix continues to run the test suite. It also
+runs `gem:create` and `gem:check` on both Ubuntu and Windows. A missing,
+malformed, or incorrectly attributed dependency causes the job to fail.
+
+## Documentation
+
+Update the prerequisite/install documentation to state that RubyGems chooses
+the platform-specific package and installs the Linux or Windows ICMP
+dependency automatically.
+
+Add a `CHANGES` entry describing the corrected platform-specific dependency
+metadata.
+
+## Non-goals
+
+- Publishing gems from CI.
+- Supporting legacy `mingw32`.
+- Changing ICMP runtime behavior.
+- Altering non-ICMP protocol implementations or tests.

data/lib/net/ping/external.rb

@@ -66,7 +66,7 @@ module Net
                 bool = true  # Success, at least one response.
               end
 
-              if err & (err =~ /warning/i)
+              if err && (err =~ /warning/i)
                 @warning = err.chomp
               end
             when 2
@@ -116,6 +116,8 @@ module Net
           pcmd += ['-i', interval.to_s] unless RbConfig::CONFIG['busybox']
         when /aix/i
           pcmd += ['-c', count.to_s, '-w', timeout.to_s, host]
+        when /freebsd/i
+          pcmd += ['-c', count.to_s, '-x', timeout.to_s, host]
         when /bsd|osx|mach|darwin/i
           pcmd += ['-c', count.to_s, '-i', interval.to_s, host]
         when /solaris|sunos/i
@@ -147,7 +149,7 @@ module Net
                 bool = true  # Success, at least one response.
               end
 
-              if err & err =~ /warning/i
+              if err && (err =~ /warning/i)
                 @warning = err.chomp
               end
             when 2

data/lib/net/ping/ping.rb

@@ -1,6 +1,8 @@
 require 'socket'
 require 'timeout'
 
+require_relative 'version'
+
 # The Net module serves as a namespace only.
 #
 module Net
@@ -9,9 +11,6 @@ module Net
    # types. You should not instantiate this class directly.
    #
    class Ping
-      # The version of the net-ping library.
-      VERSION = '2.0.9'
-
       # The host to ping. In the case of Ping::HTTP, this is the URI.
       attr_accessor :host
 

data/lib/net/ping/version.rb

@@ -0,0 +1,6 @@
+module Net
+  class Ping
+    # The version of the net-ping library.
+    VERSION = '2.1.0'
+  end
+end

data/net-ping-universal-linux.gemspec

@@ -0,0 +1,4 @@
+spec = Gem::Specification.load('net-ping.gemspec').dup
+spec.platform = Gem::Platform.new(['universal', 'linux'])
+spec.add_dependency('cap2', '>= 0.2.2')
+spec

data/net-ping-universal-mingw-ucrt.gemspec

@@ -0,0 +1,7 @@
+spec = Gem::Specification.load('net-ping.gemspec').dup
+spec.platform = Gem::Platform.new(['universal', 'mingw-ucrt'])
+spec.add_dependency('win32-security', '>= 0.2.0')
+
+# No longer a default gem as of Ruby 4.0. Used by the WMI ping class.
+spec.add_dependency('win32ole', '>= 1.8.8')
+spec

data/net-ping.gemspec

@@ -1,15 +1,15 @@
-require 'rbconfig'
+require_relative "lib/net/ping/version"
 
 Gem::Specification.new do |spec|
   spec.name      = 'net-ping'
-  spec.version   = '2.0.9'
+  spec.version   = Net::Ping::VERSION
   spec.license   = 'Artistic 2.0'
   spec.author    = 'Chris Chernesky'
   spec.email     = 'chris.netping@tinderglow.com'
   spec.homepage  = 'https://github.com/chernesk/net-ping'
   spec.summary   = 'A ping interface for Ruby.'
   spec.test_file = 'test/test_net_ping.rb'
-  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.files     = Dir['**/*'].reject { |f| f.include?('git') || File.extname(f) == '.gem' }
   spec.metadata = {
     'bug_tracker_uri' => "#{spec.homepage}/issues",
     'changelog_uri' => "#{spec.homepage}/blob/master/CHANGES",
@@ -28,17 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('rake', '>= 0')
   spec.add_development_dependency('pry-byebug', '>= 0')
 
-  if File::ALT_SEPARATOR
-    require 'rbconfig'
-    arch = RbConfig::CONFIG['build_os'] || 'mingw32' # JRuby
-    spec.platform = Gem::Platform.new(['universal', arch])
-    spec.platform.version = nil
-
-    # Used for icmp pings.
-    spec.add_dependency('win32-security', '>= 0.2.0')
-  end
-  spec.add_dependency('cap2', '>= 0.2.2') if RUBY_PLATFORM =~ /linux/i
-
   spec.description = <<-EOF
     The net-ping library provides a ping interface for Ruby. It includes
     separate TCP, HTTP, LDAP, ICMP, UDP, WMI (for Windows) and external ping

data/test/test_net_ping.rb

@@ -5,6 +5,7 @@
 # class test won't be run unless this is run as a privileged process.
 ######################################################################
 require 'test_net_ping_external'
+require 'test_net_ping_gem_packaging'
 require 'test_net_ping_http'
 require 'test_net_ping_tcp'
 require 'test_net_ping_udp'
@@ -38,6 +39,6 @@ end
 
 class TC_Net_Ping < Test::Unit::TestCase
   def test_net_ping_version
-    assert_equal('2.0.9', Net::Ping::VERSION)
+    assert_equal(Gem::Specification.load('net-ping.gemspec').version.to_s, Net::Ping::VERSION)
   end
 end

data/test/test_net_ping_external.rb

@@ -140,6 +140,30 @@ class TC_Net_Ping_External < Test::Unit::TestCase
     assert_false(@bad.ping?)
   end
 
+  test "ping6 uses timeout for FreeBSD" do
+    command = nil
+    original_os = RbConfig::CONFIG['host_os']
+    original_popen3 = Open3.method(:popen3)
+
+    RbConfig::CONFIG['host_os'] = 'freebsd'
+    Open3.define_singleton_method(:popen3) do |*args, &block|
+      command = args
+      stdin = StringIO.new
+      stdout = StringIO.new
+      stderr = StringIO.new
+      status = Struct.new(:exitstatus).new(0)
+      thread = Struct.new(:value).new(status)
+      block.call(stdin, stdout, stderr, thread)
+    end
+
+    @pe.ping6('example.test', 2, 3, 4)
+
+    assert_equal(['ping6', '-c', '2', '-x', '4', 'example.test'], command)
+  ensure
+    RbConfig::CONFIG['host_os'] = original_os
+    Open3.define_singleton_method(:popen3, original_popen3)
+  end
+
   test "ping6 uses interval for macOS" do
     command = nil
     original_os = RbConfig::CONFIG['host_os']
@@ -164,6 +188,41 @@ class TC_Net_Ping_External < Test::Unit::TestCase
     Open3.define_singleton_method(:popen3, original_popen3)
   end
 
+  test "ping6 succeeds without an exception when stderr is empty" do
+    stdin = StringIO.new
+    stdout = StringIO.new('64 bytes from ::1')
+    stderr = StringIO.new
+    status = Struct.new(:exitstatus).new(0)
+    thread = Struct.new(:value).new(status)
+    popen3 = Open3.method(:popen3)
+    nil_match = NilClass.instance_method(:=~) if NilClass.instance_methods(false).include?(:=~)
+    false_match = FalseClass.instance_method(:=~) if FalseClass.instance_methods(false).include?(:=~)
+
+    Open3.singleton_class.send(:define_method, :popen3) do |*args, &block|
+      block.call(stdin, stdout, stderr, thread)
+    end
+    [NilClass, FalseClass].each do |klass|
+      klass.send(:define_method, :=~) do |*args|
+        raise NoMethodError, "undefined method '=~' for #{self.inspect}"
+      end
+    end
+
+    assert_true(@pe.ping6('::1'))
+    assert_nil(@pe.exception)
+  ensure
+    Open3.singleton_class.send(:define_method, :popen3, popen3) if popen3
+    if nil_match
+      NilClass.send(:define_method, :=~, nil_match)
+    else
+      NilClass.send(:remove_method, :=~)
+    end
+    if false_match
+      FalseClass.send(:define_method, :=~, false_match)
+    else
+      FalseClass.send(:remove_method, :=~)
+    end
+  end
+
   def teardown
     @host  = nil
     @bogus = nil

data/test/test_net_ping_gem_packaging.rb

@@ -0,0 +1,333 @@
+require 'open3'
+require 'rake'
+require 'rubygems/package'
+require 'test/unit'
+
+class TestNetPingGemPackaging < Test::Unit::TestCase
+  GemfileRecorder = Struct.new(:dependencies) do
+    def initialize
+      super({})
+    end
+
+    def source(*); end
+    def gemspec(*); end
+
+    def gem(name, *requirements)
+      dependencies[name] = requirements
+    end
+  end
+
+  EXPECTATIONS = {
+    'net-ping.gemspec' => ['ruby', {}],
+    'net-ping-universal-linux.gemspec' => ['universal-linux', {'cap2' => '>= 0.2.2'}],
+    'net-ping-universal-mingw-ucrt.gemspec' => [
+      'universal-mingw-ucrt',
+      {'win32-security' => '>= 0.2.0', 'win32ole' => '>= 1.8.8'}
+    ]
+  }.freeze
+  ROOT = File.expand_path('..', __dir__)
+
+  def test_platforms_and_runtime_dependencies
+    gem_files = nil
+    specifications = load_specifications
+
+    Dir.chdir(ROOT) do
+      gem_files = specifications.map { |_, spec| Gem::Package.build(spec) }
+    end
+
+    specifications.each do |path, spec|
+      expected_platform, expected_dependencies = EXPECTATIONS.fetch(path)
+      packaged_spec = Gem::Package.new(File.join(ROOT, spec.file_name)).spec
+      dependencies = packaged_spec.runtime_dependencies.each_with_object({}) do |dependency, memo|
+        memo[dependency.name] = dependency.requirement.to_s
+      end
+
+      assert_equal(expected_dependencies, dependencies, path)
+
+      if platform_round_trips_for_test?(expected_platform)
+        assert_equal(expected_platform, packaged_spec.platform.to_s, path)
+      else
+        omit("this RubyGems (#{Gem::VERSION}) cannot round-trip the #{expected_platform.inspect} platform string")
+      end
+    end
+  ensure
+    delete_files(gem_files)
+  end
+
+  def test_rake_create_builds_all_expected_artifacts_and_validates_them
+    stdout, stderr, status = run_rake('clean', 'gem:create', 'gem:check')
+
+    assert(status.success?, [stdout, stderr].join)
+    assert_equal(expected_gem_files, built_gem_files)
+  ensure
+    delete_files(built_gem_files)
+  end
+
+  def test_gem_create_excludes_generated_artifacts_from_spec_files_and_keeps_bundle_exec_usable
+    stdout, stderr, status = run_rake('clean', 'gem:create')
+
+    assert(status.success?, [stdout, stderr].join)
+    load_specifications.each do |path, spec|
+      assert_equal([], spec.files.grep(/\.gem$/).sort, path)
+    end
+
+    stdout, stderr, status = run_bundle_exec('ruby', '-e', 'puts :bundle_exec_after_gem_create')
+    assert(status.success?, [stdout, stderr].join)
+    assert_equal("bundle_exec_after_gem_create\n", stdout)
+  ensure
+    delete_files(built_gem_files)
+  end
+
+  def test_gem_check_uses_fixed_expectations_instead_of_loaded_specifications
+    stdout, stderr, status = run_rake('clean', 'gem:create')
+
+    assert(status.success?, [stdout, stderr].join)
+
+    specifications = load_specifications.map do |path, spec|
+      if path == 'net-ping-universal-linux.gemspec'
+        [path, specification_with_reported_platform(spec, Gem::Platform::RUBY)]
+      else
+        [path, spec]
+      end
+    end
+
+    with_rakefile do |application|
+      with_stubbed_load_gem_specifications(specifications.map(&:last)) do
+        assert_nothing_raised { application['gem:check'].invoke }
+      end
+    end
+  ensure
+    delete_files(built_gem_files)
+  end
+
+  def test_gem_install_selects_local_compatible_specification
+    with_rakefile do
+      assert_equal(expected_install_platform, select_install_specification.platform.to_s)
+    end
+  end
+
+  def test_gemfile_adds_win32_security_only_for_windows_development
+    assert_nil(gemfile_dependencies_for(win_platform: false)['win32-security'])
+    assert_equal(
+      ['>= 0.2.0'],
+      gemfile_dependencies_for(win_platform: true)['win32-security']
+    )
+  end
+
+  def test_with_unbundled_env_prefers_with_unbundled_env_when_available
+    calls = []
+
+    with_rakefile do
+      with_stubbed_bundler_methods(
+        :with_unbundled_env => proc do |&block|
+          calls << :with_unbundled_env
+          block.call
+        end,
+        :with_clean_env => proc do |&block|
+          calls << :with_clean_env
+          block.call
+        end
+      ) do
+        assert_equal(:ran, with_unbundled_env { calls << :block; :ran })
+      end
+    end
+
+    assert_equal([:with_unbundled_env, :block], calls)
+  end
+
+  def test_with_unbundled_env_falls_back_to_with_clean_env
+    calls = []
+
+    with_rakefile do
+      with_stubbed_bundler_methods(
+        :with_clean_env => proc do |&block|
+          calls << :with_clean_env
+          block.call
+        end
+      ) do
+        assert_equal(:ran, with_unbundled_env { calls << :block; :ran })
+      end
+    end
+
+    assert_equal([:with_clean_env, :block], calls)
+  end
+
+  def test_platform_installable_prefers_installable_when_available
+    spec = Struct.new(:platform).new(:preferred_platform)
+    calls = []
+
+    with_rakefile do
+      with_stubbed_platform_methods(
+        :installable? => proc do |candidate|
+          calls << [:installable?, candidate.platform]
+          true
+        end,
+        :match => proc do |platform|
+          calls << [:match, platform]
+          false
+        end
+      ) do
+        assert_equal(true, platform_installable?(spec))
+      end
+    end
+
+    assert_equal([[:installable?, :preferred_platform]], calls)
+  end
+
+  def test_platform_installable_falls_back_to_match
+    spec = Struct.new(:platform).new(:fallback_platform)
+    calls = []
+
+    with_rakefile do
+      with_stubbed_platform_methods(
+        :match => proc do |platform|
+          calls << [:match, platform]
+          true
+        end
+      ) do
+        assert_equal(true, platform_installable?(spec))
+      end
+    end
+
+    assert_equal([[:match, :fallback_platform]], calls)
+  end
+
+  private
+
+  def load_specifications
+    Dir.chdir(ROOT) do
+      EXPECTATIONS.keys.map do |path|
+        assert(File.exist?(path), "#{path} does not exist")
+
+        loaded_spec = Gem::Specification.load(path)
+        spec = loaded_spec ? loaded_spec.dup : nil
+        assert_not_nil(spec, "expected #{path} to load")
+
+        [path, spec]
+      end
+    end
+  end
+
+  def expected_gem_files
+    load_specifications.map { |_, spec| spec.file_name }.sort
+  end
+
+  def built_gem_files
+    Dir.chdir(ROOT) { Dir['net-ping-*.gem'].sort }
+  end
+
+  def expected_install_platform
+    specifications = load_specifications.map(&:last)
+    specific = specifications.find do |spec|
+      spec.platform != Gem::Platform::RUBY && platform_installable_for_test?(spec)
+    end
+    (specific || specifications.find { |spec| spec.platform == Gem::Platform::RUBY }).platform.to_s
+  end
+
+  def run_rake(*tasks, env: {})
+    Open3.capture3(env, Gem.ruby, '-S', 'bundle', 'exec', 'rake', *tasks, chdir: ROOT)
+  end
+
+  def run_bundle_exec(*command, env: {})
+    Open3.capture3(env, Gem.ruby, '-S', 'bundle', 'exec', *command, chdir: ROOT)
+  end
+
+  def with_rakefile
+    original = Rake.application
+    application = Rake::Application.new
+    Rake.application = application
+
+    Dir.chdir(ROOT) do
+      load File.join(ROOT, 'Rakefile')
+      yield(application)
+    end
+  ensure
+    Rake.application = original
+  end
+
+  def gemfile_dependencies_for(win_platform:)
+    recorder = GemfileRecorder.new
+    singleton_class = class << Gem; self; end
+    original = singleton_class.instance_method(:win_platform?)
+    singleton_class.send(:define_method, :win_platform?) { win_platform }
+    recorder.instance_eval(File.read(File.join(ROOT, 'Gemfile')), File.join(ROOT, 'Gemfile'))
+
+    recorder.dependencies
+  ensure
+    singleton_class.send(:define_method, :win_platform?, original) if singleton_class && original
+  end
+
+  def delete_files(paths)
+    Array(paths).each do |path|
+      file = File.join(ROOT, path)
+      File.delete(file) if File.exist?(file)
+    end
+  end
+
+  def specification_with_reported_platform(spec, platform)
+    file_name = spec.file_name
+    mutated = spec.dup
+    mutated.platform = platform
+    mutated.define_singleton_method(:file_name) { file_name }
+    mutated
+  end
+
+  def with_stubbed_load_gem_specifications(specifications)
+    original = Object.instance_method(:load_gem_specifications)
+    Object.send(:remove_method, :load_gem_specifications)
+    Object.send(:define_method, :load_gem_specifications) { specifications }
+    Object.send(:private, :load_gem_specifications)
+    yield
+  ensure
+    Object.send(:remove_method, :load_gem_specifications)
+    Object.send(:define_method, :load_gem_specifications, original)
+    Object.send(:private, :load_gem_specifications)
+  end
+
+  def with_stubbed_bundler_methods(methods)
+    bundler = Module.new
+    methods.each do |name, implementation|
+      bundler.define_singleton_method(name, &implementation)
+    end
+
+    with_replaced_constant(Object, :Bundler, bundler) do
+      yield
+    end
+  end
+
+  def with_stubbed_platform_methods(methods)
+    platform = Module.new
+    methods.each do |name, implementation|
+      platform.define_singleton_method(name, &implementation)
+    end
+    platform.const_set(:RUBY, Gem::Platform::RUBY)
+
+    with_replaced_constant(Gem, :Platform, platform) do
+      yield
+    end
+  end
+
+  def with_replaced_constant(container, name, replacement)
+    original = container.const_get(name) if container.const_defined?(name, false)
+    container.send(:remove_const, name) if container.const_defined?(name, false)
+    container.const_set(name, replacement)
+    yield
+  ensure
+    container.send(:remove_const, name) if container.const_defined?(name, false)
+    if original
+      container.const_set(name, original)
+    end
+  end
+
+  def platform_round_trips_for_test?(platform_string)
+    Gem::Platform.new(platform_string).to_s == platform_string
+  end
+
+  def platform_installable_for_test?(spec)
+    if Gem::Platform.respond_to?(:installable?)
+      Gem::Platform.installable?(spec)
+    else
+      Gem::Platform.match(spec.platform)
+    end
+  end
+end

data/test/test_net_ping_http.rb

@@ -131,12 +131,11 @@ class TC_Net_Ping_HTTP < Test::Unit::TestCase
     assert_equal(5, @bad.timeout)
   end
 
-  # TODO: Figure out how to do this with WebMock.
   test 'ping fails if timeout exceeded' do
-    WebMock.allow_net_connect!
+    stub_request(:head, 'https://www.google.com/').to_timeout
     @http = Net::Ping::HTTP.new('https://www.google.com', 443, 0.001)
     assert_false(@http.ping?)
-    assert(['Failed to open TCP connection to www.google.com:443 (execution expired)', 'execution expired', 'Net::OpenTimeout'].include?(@http.exception))
+    assert_include(['execution expired', 'Net::OpenTimeout'], @http.exception)
   end
 
   test 'exception attribute basic functionality' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: net-ping
 version: !ruby/object:Gem::Version
-  version: 2.0.9
+  version: 2.1.0
 platform: ruby
 authors:
 - Chris Chernesky
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -80,12 +80,15 @@ extra_rdoc_files:
 files:
 - CHANGES
 - CHANGES.out_of_date
+- CLAUDE.md
 - Gemfile
 - Gemfile.lock
 - MANIFEST
 - README.md
 - Rakefile
 - doc/ping.txt
+- docs/superpowers/plans/2026-07-25-platform-specific-gems.md
+- docs/superpowers/specs/2026-07-25-platform-specific-gems-design.md
 - examples/example_pingexternal.rb
 - examples/example_pinghttp.rb
 - examples/example_pingtcp.rb
@@ -97,10 +100,14 @@ files:
 - lib/net/ping/ping.rb
 - lib/net/ping/tcp.rb
 - lib/net/ping/udp.rb
+- lib/net/ping/version.rb
 - lib/net/ping/wmi.rb
+- net-ping-universal-linux.gemspec
+- net-ping-universal-mingw-ucrt.gemspec
 - net-ping.gemspec
 - test/test_net_ping.rb
 - test/test_net_ping_external.rb
+- test/test_net_ping_gem_packaging.rb
 - test/test_net_ping_http.rb
 - test/test_net_ping_icmp.rb
 - test/test_net_ping_tcp.rb