net-ping 2.0.9 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3139e0db447950138a58ab9e60996ef49a89fc89e157ef1b66bf67ef5557450
-  data.tar.gz: 7529e34db8bf6d258a830fd725969af4dd6eee3ee59a500423e1f13256372079
+  metadata.gz: 12d4bcbcdb97fb3b116be13a5bc7ad632b4efc116127d9b5859531b5605be3ae
+  data.tar.gz: 22603f15d676ac4e3a4137a0bdec76019b7a52b8ae5ca028b452b8760ad6bd15
 SHA512:
-  metadata.gz: '0947a086f3da9bb83a81f16e84d4e5fa761508f6a71109051e2ec315c972c83806085863a67d4cc5299e7c337a8ecef9f4bf8aa4afd907064bbd589dc9ff7966'
-  data.tar.gz: d16d032dcea9783d50305592c6dd4242436a1357f73233b2af787fafc68a03c6d408f5c1d3b328b2cc62395a7f7f64acd8ca4915fee647154fbb25b0474f98eb
+  metadata.gz: ab74625d886822f7801e5c9c6e7704664bb789f745b47a29ec54cf8e7baa4cbb1a86c332df8bc16a4757900987dc3389642c290cf4d38d98badbc1e60df7ffa1
+  data.tar.gz: bb55d09ac91ec4ac1e407e7050f655d7fd305f3fcab3fa2093613745509724d138b25b22282d2d00d63eb5880d50814d7bfe0ac4d9e414904fbeb2d0e2618ec5

data/CHANGES

@@ -1,3 +1,25 @@
+== 2.1.1 - 16-Aug-2026
+* Fix the license format in net-ping.gemspec to use the SPDX identifier
+  "Artistic-2.0" [#47](https://github.com/eitoball/net-ping/pull/47).
+* Exclude CLAUDE.md and docs/ from the packaged gem files
+  [#48](https://github.com/eitoball/net-ping/pull/48).
+
+== 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/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.1)
 
 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/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.1'
+  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,17 @@
-require 'rbconfig'
+require_relative "lib/net/ping/version"
 
 Gem::Specification.new do |spec|
   spec.name      = 'net-ping'
-  spec.version   = '2.0.9'
-  spec.license   = 'Artistic 2.0'
+  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 do |f|
+    f.include?('git') || File.extname(f) == '.gem' || f == 'CLAUDE.md' || f == 'docs' || f.start_with?('docs/')
+  end
   spec.metadata = {
     'bug_tracker_uri' => "#{spec.homepage}/issues",
     'changelog_uri' => "#{spec.homepage}/blob/master/CHANGES",
@@ -28,17 +30,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,343 @@
+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_create_excludes_non_distributable_project_files_from_spec_files
+    load_specifications.each do |path, spec|
+      non_distributable = spec.files.select do |f|
+        f == 'CLAUDE.md' || f == 'docs' || f.start_with?('docs/')
+      end
+
+      assert_equal([], non_distributable, path)
+    end
+  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.1
 platform: ruby
 authors:
 - Chris Chernesky
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -97,10 +97,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
@@ -108,7 +112,7 @@ files:
 - test/test_net_ping_wmi.rb
 homepage: https://github.com/chernesk/net-ping
 licenses:
-- Artistic 2.0
+- Artistic-2.0
 metadata:
   bug_tracker_uri: https://github.com/chernesk/net-ping/issues
   changelog_uri: https://github.com/chernesk/net-ping/blob/master/CHANGES