net-ping 2.0.8 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e9436106f779445d897726f1fc77636c9a1b4c11
-  data.tar.gz: f5e7497bb832da92f13a9c042daef2007416dec4
+SHA256:
+  metadata.gz: 27c470dd18b95b9b05e68e1dd6e79da70a8c8d4eaaa28581e770fa4d0d028aca
+  data.tar.gz: fc020ad255eb094dd057f552e67c36f83a00e87aa88e12837ceb3f2bf1c8673b
 SHA512:
-  metadata.gz: 20d939475ab877628d7b4730054583533e3f148c8e179abe000c743c7f538e381df82d9b76f67be2a98ace8a9f5ee1edc92acae6c2b5a4f050bcdca345efb9da
-  data.tar.gz: d4b67f90593db6045162d533b73fb520075997ec7db028a1c5c07686b2062cda1e436c71649270d30a4f6510575a92b992d007dac00f4809030752d1d3ef7893
+  metadata.gz: 4fc2c4d695cbdb27ddd478b92929f6f9164eb07d768b56ee8f6d69cb102ded9bfe435ff0fd389136b77a86f200440da26f6078bca87561275f881f5b5abb7c24
+  data.tar.gz: 5c45a5a55df135b3145e6aab5b3286c27d92487e9a5ac0329ada3641659acef7a8c69a4fb8f22ac2d04b6c68627a6335fd7c9ca2c681987c35713da78472cdbe

data/CHANGES

@@ -1 +1,28 @@
-Updated changes coming soon..
+== 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).
+* Replace FakeWeb with WebMock and update the test suite for current Ruby
+  versions [#38](https://github.com/eitoball/net-ping/pull/38).
+* Skip external-ping tests when the system ping command is unavailable
+  [#33](https://github.com/eitoball/net-ping/pull/33).
+* Fix the macOS ping6 interval option
+  [#40](https://github.com/eitoball/net-ping/pull/40).
+* Update README wording [#30](https://github.com/eitoball/net-ping/pull/30).
+* Align Net::Ping::VERSION with the gem version
+  [#37](https://github.com/eitoball/net-ping/pull/37).

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,35 +1,53 @@
 PATH
   remote: .
   specs:
-    net-ping (2.0.8)
+    net-ping (2.1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    byebug (11.0.1)
-    coderay (1.1.2)
-    fakeweb (1.3.0)
-    method_source (0.9.2)
-    power_assert (1.1.5)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
-      byebug (~> 11.0)
-      pry (~> 0.10)
-    rake (13.0.1)
-    test-unit (3.3.5)
+    addressable (2.9.0)
+      public_suffix (>= 2.0.2, < 8.0)
+    bigdecimal (4.1.2)
+    byebug (13.0.0)
+      reline (>= 0.6.0)
+    coderay (1.1.3)
+    crack (1.0.1)
+      bigdecimal
+      rexml
+    hashdiff (1.2.1)
+    io-console (0.8.2)
+    method_source (1.1.0)
+    power_assert (3.0.1)
+    pry (0.16.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+      reline (>= 0.6.0)
+    pry-byebug (3.12.0)
+      byebug (~> 13.0)
+      pry (>= 0.13, < 0.17)
+    public_suffix (7.0.5)
+    rake (13.4.2)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rexml (3.4.4)
+    test-unit (3.7.8)
       power_assert
+    webmock (3.26.2)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
   ruby
+  x86_64-darwin-24
 
 DEPENDENCIES
-  fakeweb
   net-ping!
   pry-byebug
   rake
   test-unit
+  webmock
 
 BUNDLED WITH
-   2.1.4
+   2.5.22

data/README.md

@@ -3,8 +3,10 @@ A collection of classes that provide different ways to ping computers.
 
 ## Prerequisites
   * ffi
-  * win32-security (MS Windows only)
-  * fakeweb (test 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)
 
   Ruby users should use Ruby 1.9.3 or later.
@@ -50,7 +52,7 @@ A collection of classes that provide different ways to ping computers.
 
 ## Contributions
   Although this library is free, please consider having your company
-  setup a gittip if used by your company professionally.
+  set up a gittip if used by your company professionally.
 
   http://www.gittip.com/djberg96/
 

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.