mac-wifi 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5763b7c0bc11d558c50e82e2e7fd52ba6bd5e3cb
-  data.tar.gz: 29878b297569049bff109647d9583ad6afad5a65
+  metadata.gz: 0ad551f63f23b9370fc52e8206e4b7314efd99e3
+  data.tar.gz: b2d4b85d37dc5e964f2dd7fe054233fcd54f66c6
 SHA512:
-  metadata.gz: 5c70472f1d31785cae9a124ef5641f1157eb63549267c97773f120e4ce033588faad198bfded7f56ddb8e2eb8fbbeaae0d1ed31e20ddceaf5d0c7bd00140f8a6
-  data.tar.gz: 32007be9ff30e8fd38996ba433386a29ee11193c868d1b37afb1bc534e11c93173c9658a116bbc66d95692a26809b8864d7a78f1e8f1d28426e3c393ba223e9b
+  metadata.gz: ef70403c2cbd5731e2835a79ea6334278c34746c06970cf074e3a6006e520d343d90d91db070007b7cfd7c96b065ee9e942b3f495c308cb3f56dbeee24bb7a47
+  data.tar.gz: 5a8ccde48e2cf1e28b9f4cdaaaa02f97ef39b4657988fd318e3f9fbc75a67e0e0f824e189eaba72de2c608c53aa65d5733c3f2d00f3bc178433608d8768fc7b4

data/Gemfile

@@ -2,5 +2,5 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in mac-wifi-2.gemspec
+# Specify your gem's dependencies in mac-wifi.gemspec
 gemspec

data/README.md

@@ -1,12 +1,15 @@
 # mac-wifi
 
-This script enables the query and management of wifi configuration and environment on a Mac.
+The script installed by this gem (or otherwise copied) enables the query and management of wifi configuration and environment on a Mac.
+The code encapsulates the Mac OS specific logic in a minimal class to more easily add support for other operating systems,
+but as of now, only Mac OS is supported. (Feel free to add an OS!)
 
 It can be run in single-command or interactive mode. Interactive mode uses the `pry` gem,
 providing an interface familiar to Rubyists and other 
 [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) users.
 
-It is not necessary to download this repo; this script file is all you need to run the application.
+It is not necessary to download this repo or even install this gem; the `bin/mac-wifi` script file is all you need to run the application.
+
 
 ### Usage
 
@@ -48,6 +51,7 @@ Internally, it uses several Mac command line utilities. This is not ideal,
 I would have preferred OS system calls, but the current approach enabled me to develop
 this script quickly and simply.
 
+
 ### Pretty Output
 
 For nicely formatted output of the `info` command in non-interactive mode,
@@ -83,7 +87,7 @@ of stale data.
 
 If you try to run the shell, the script will require the `pry` gem, so that will need to be installed.
 `pry` in turn requires access to a `readline` library. If you encounter an error relating to finding a
-`readline` library, this can be fixed by installing the `pry-coolline` gem: `gem install pry-coolline`.
+`readline` library, this can probably be fixed by installing the `pry-coolline` gem: `gem install pry-coolline`.
 If you are using the Ruby packaged with Mac OS, or for some other reason require root access to install
 gems, you will need to precede those commands with `sudo`:
 
@@ -105,6 +109,7 @@ session. It can be useful when:
 * you want to combine the results of commands with other OS commands 
   (you can shell out to run other command line programs by preceding the command with a period (`.`).
 
+
 ### Using Variables in the Shell
 
 There are a couple of things (that may be surprising) to keep in mind
@@ -123,12 +128,12 @@ may override this app's commands.  For example:
 => 123
 [3] pry(#<MacWifiView>)> n  # 'n' no longer calls the method
 => 123
-[4] pry(#<MacWifiView>)> ne  # but any other name starting with 'ne' will still call the method
+[4] pry(#<MacWifiView>)> ne  # but any other name that `network_name starts with will still call the method
 => ".@ AIS SUPER WiFi"
 [5] pry(#<MacWifiView>)> network_name
 => ".@ AIS SUPER WiFi"
 [6] pry(#<MacWifiView>)> ne_xzy123
-=> ".@ AIS SUPER WiFi"
+"ne_xyz123" is not a valid command or option. If you intend for this to be a string literal, use quotes.
 ``` 
 
 If you don't want to deal with this, you could use global variables, instance variables,
@@ -150,7 +155,6 @@ or constants, which will _not_ hide the methods:
 the result may be mysterious.  For example, if I were write the wifi information
 to a file, this would work:
 
-
 ```
 [1] pry(#<MacWifiView>)> File.write('x.txt', info)
 => 431
@@ -210,8 +214,12 @@ You are connected on port en0 to .@ AIS SUPER WiFi on IP address 172.27.145.225.
 > puts "There are #{lsp.size} preferred networks."
 There are 341 preferred networks.
 
-# Delete all preferred networks whose names begin with "TOTTGUEST":
-> lsp.grep(/^TOTTGUEST/).each { |n| puts "Deleting preferred network #{n}."; rm(n) }
+# Delete all preferred networks whose names begin with "TOTTGUEST", the hard way:
+> lsp.grep(/^TOTTGUEST/).each { |n| rm(n) }
+
+# Delete all preferred networks whose names begin with "TOTTGUEST", the easy way.
+# rm can take multiple network names, but they must be specified as separate parameters; thus the '*'.
+> rm(*lsp.grep(/^TOTTGUEST/))
 
 # Define a method to wait for the Internet connection to be active.
 # (This functionality is included in the `till` command.)
@@ -227,15 +235,34 @@ Connected!
 Connected!
 ```
 
-### Cautions
 
-If the wifi networking changes from on to off while `till(:off)` is waiting,
-the program will hang indefinitely. I am currently looking into this problem.
-It also happens outside of this program; you can reproduce it by running `curl`,
-preferably on a longer running request, then turning off your wifi. This is pretty
-serious, and I'm considering removing the `:off` option from the `till` command.
+### Distribution, or Why All The Code is in One Humongous File
+
+This code would be neater and easier to read if each class were in a file of its own.
+The reason everything is in one file is to simplify distribution for some users.
+Although installation as a gem is simple, being able to download a single file may work better when:
+
+* the user wants to install the script once, rather than once per Ruby version and/or gemset.
+* the user needs or wants to specify the exact location of the script (e.g. `~/bin`),
+and/or does not want it buried in the gem directory tree (e.g. `/Users/kbennett/.rvm/gems/ruby-2.4.0/bin/mac-wifi`).
+* the user is not familiar with Ruby and does not want to use the `gem` command
+* the user is concerned about security and would prefer to install a single file to a known location
+rather than run the gem installation
+* installing gems is controlled by the user's organization, and getting authorization is not practical
+* installing gems requires root access, and the user does not have root access
 
+That said, installation as a gem is highly recommended, since:
 
+* this will greatly simplify acquiring future fixes and enhancements
+* if the user wants to use the shell mode, they will need to `gem install pry` anyway
+
+Currently, the only gems used by the program are:
+
+* `pry`, to provide the interactive shell
+* `awesome_print` (optional), to more nicely format output in non-interactive mode
+
+So the user can avoid installing gems altogether as long as they don't need to use the interactive shell,
+and as long as they are comfortable with the less pretty output.
 
 ### Password Lookup Oddity
 
@@ -244,10 +271,17 @@ You may find it odd (I did, anyway) that even if you issue the password command
 with a graphical dialog for both a user id and password. This is no doubt
 for better security, but it's unfortunate in that it makes it impossible to fully automate this task.
 
-In particular, it would be nice for the `cycle` command to be able to reconnect to the original
-network after turning the network on. This is not possible where that network required a password.
+In particular, it would be nice for the `cycle` command to be able to fetch the current network's
+password, cycle the network, and then reconnect to the original network with it after turning the network on.
+However, since fetching the password without user intervention is not possible, this cannot be automated.
+
 If you don't mind storing the network password in plain text somewhere, then you could easily
-automate it (e.g. `mac-wifi cycle && mac-wifi connect a-network a-password`).
+automate it (e.g. `mac-wifi cycle && mac-wifi connect a-network a-password`). Also, you might find it handy
+to create a script for your most commonly used networks containing something like this:
+
+```
+mac-wifi  connect  my-usual-network  its-password
+```
 
 
 ### License

data/bin/mac-wifi

@@ -26,40 +26,34 @@ require 'tempfile'
 module MacWifi
 
 # This version must be kept in sync with the version in the gemspec file.
-VERSION = '0.0.1'
+VERSION = '1.0.0'
 
-class Model
-
-  AIRPORT_CMD = '/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'
 
+class BaseModel
 
   def initialize(verbose = false)
     @verbose_mode = verbose
   end
 
 
-  def connected_to_internet_curl_unused?
-
-    connected = false
-
-    begin
-      run_os_command('curl --silent --head http://www.google.com/')
-      connected = true
-    rescue OsCommandError => e
-      if e.exitstatus == 6
-        connected = false
-      else
-        raise
-      end
-    end
-    connected
-  end
-
-
   # This method returns whether or not there is a working Internet connection.
   # Because of a Mac issue which causes a request to hang if the network is turned
   # off during its lifetime, we give it only 5 seconds per try,
   # and limit the number of tries to 3.
+  #
+  # This implementation will probably strike you as overly complex. The following
+  # code looks like it is all that should be necessary, but unfortunately
+  # this implementation often hangs when wifi is turned off while curl is active
+  #
+  # def connected_to_internet?
+  #   script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $?"
+  #   result = `#{script}`.chomp
+  #   puts result
+  #   result == '0'
+  # end
+
+  # TODO Investigate using Curl options: --connect-timeout 1 --max-time 2 --retry 0
+  # to greatly simplify this method.
   def connected_to_internet?
 
     tempfile = Tempfile.open('mac-wifi-')
@@ -94,7 +88,7 @@ class Model
             return get_connected_state_from_curl.()
           end
         end
-        Process.kill('KILL', pid)
+        Process.kill('KILL', pid) if process_is_running.(pid)
         :hung
       end
 
@@ -111,13 +105,109 @@ class Model
 
   end
 
-  # This implementation often hangs when wifi is turned off while curl is active
-  # def connected_to_internet?
-  #   script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $?"
-  #   result = `#{script}`.chomp
-  #   puts result
-  #   result == '0'
-  # end
+
+  # Turns wifi off and then on, reconnecting to the originally connecting network.
+  def cycle_network
+    # TODO: Make this network name saving and restoring conditional on it not having a password.
+    # If the disabled code below is enabled, an error will be raised if a password is required,
+    # even though it is stored.
+    # network_name = current_network
+    wifi_off
+    wifi_on
+    # connect(network_name) if network_name
+  end
+
+
+  def connected_to?(network_name)
+    network_name == connected_network_name
+  end
+
+
+  # Connects to the passed network name, optionally with password.
+  # Turns wifi on first, in case it was turned off.
+  # Relies on subclass implementation of simple_connect().
+  def connect(network_name, password = nil)
+    if network_name.nil? || network_name.empty?
+      raise "A network name is required but was not provided."
+    end
+    wifi_on
+    simple_connect(network_name, password)
+
+    # Verify that the network is now connected:
+    actual_network_name = connected_network_name
+    unless actual_network_name == network_name
+      message = %Q{Expected to connect to "#{network_name}" but }
+      if actual_network_name
+        message << %Q{connected to "#{connected_network_name}" instead.}
+      else
+        message << "unable to connect to any network. Did you "
+      end
+      message << (password ? "provide the correct password?" : "need to provide a password?")
+      raise message
+    end
+    nil
+  end
+
+
+  # Removes the specified network(s) from the preferred network list.
+  # @param network_names names of networks to remove; may be empty or contain nonexistent networks
+  # @return names of the networks that were removed (excludes non-preexisting networks)
+  def remove_preferred_networks(*network_names)
+    networks_to_remove = network_names & preferred_networks # exclude any nonexistent networks
+    networks_to_remove.each do |name|
+      run_os_command("sudo networksetup -removepreferredwirelessnetwork " +
+                         "#{wifi_hardware_port} #{Shellwords.shellescape(name)}")
+    end
+    networks_to_remove
+  end
+
+
+  def preferred_network_password(preferred_network_name)
+    if preferred_networks.include?(preferred_network_name)
+      simple_preferred_network_password(preferred_network_name)
+    else
+      raise "Network #{preferred_network_name} not in preferred networks list."
+    end
+  end
+
+
+  # Waits for the Internet connection to be in the desired state.
+  # @param status must be in [:conn, :disc, :off, :on]; waits for that state
+  # @param wait_interval_in_secs sleeps this interval between retries
+  #
+  def till(status, wait_interval_in_secs = nil)
+
+    wait_interval_in_secs ||= 0.5
+
+    exit_when = case status
+      when :conn
+        -> { connected_to_internet? }
+      when :disc
+        -> { ! connected_to_internet? }
+      when :on
+        -> { wifi_on? }
+      when :off
+        -> { ! wifi_on? }
+    else
+        raise ArgumentError.new("Option must be one of [:conn, :disc, :off, :on]. Was: #{status.inspect}")
+    end
+
+    loop do
+      return if exit_when.()
+      sleep(wait_interval_in_secs)
+    end
+  end
+
+end
+
+
+class MacOsModel < BaseModel
+
+  AIRPORT_CMD = '/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'
+
+  def initialize(verbose)
+    super
+  end
 
 
   # This is determined by whether or not a line like the following appears in the output of `netstat -nr`:
@@ -205,54 +295,18 @@ class Model
   end
 
 
-  # Turns wifi off and then on, reconnecting to the originally connecting network.
-  def cycle_network
-    # TODO: Make this network name saving and restoring conditional on it not having a password.
-    # If the disabled code below is enabled, an error will be raised if a password is required,
-    # even though it is stored.
-    # network_name = current_network
-    wifi_off
-    wifi_on
-    # connect(network_name) if network_name
-  end
-
-
   def connected_network_name
     wifi_info['SSID']
   end
 
 
-  def connected_to?(network_name)
-    network_name == connected_network_name
-  end
-
-
-  # Connects to the passed network name, optionally with password.
-  # Turns wifi on first, in case it was turned off.
-  def connect(network_name, password = nil)
-    if network_name.nil? || network_name.empty?
-      raise "A network name is required but was not provided."
-    end
-    wifi_on
+  # This method is called by BaseModel#connect to do the OS-specific connection logic.
+  def simple_connect(network_name, password = nil)
     command = "networksetup -setairportnetwork #{wifi_hardware_port} " + "#{Shellwords.shellescape(network_name)}"
     if password
       command << ' ' << Shellwords.shellescape(password)
     end
     run_os_command(command)
-
-    # Verify that the network is now connected:
-    actual_network_name = connected_network_name
-    unless actual_network_name == network_name
-      message = %Q{Expected to connect to "#{network_name}" but }
-      if actual_network_name
-        message << %Q{connected to "#{connected_network_name}" instead.}
-      else
-        message << "unable to connect to any network. Did you "
-      end
-      message << (password ? "provide the correct password?" : "need to provide a password?")
-      raise message
-    end
-    nil
   end
 
 
@@ -262,20 +316,16 @@ class Model
   #     If not, return nil
   #   else
   #     raise an error
-  def preferred_network_password(preferred_network_name)
-    if preferred_networks.include?(preferred_network_name)
-      command = %Q{security find-generic-password -D "AirPort network password" -a "#{preferred_network_name}" -w 2>&1}
-      begin
-        return run_os_command(command).chomp
-      rescue OsCommandError => error
-        if error.exitstatus == 44 # network has no password stored
-          nil
-        else
-          raise
-        end
+  def simple_preferred_network_password(preferred_network_name)
+    command = %Q{security find-generic-password -D "AirPort network password" -a "#{preferred_network_name}" -w 2>&1}
+    begin
+      return run_os_command(command).chomp
+    rescue OsCommandError => error
+      if error.exitstatus == 44 # network has no password stored
+        nil
+      else
+        raise
       end
-    else
-      raise "Network #{preferred_network_name} not in preferred networks list."
     end
   end
 
@@ -294,16 +344,9 @@ class Model
   end
 
 
-  # Removes the specified network(s) from the preferred network list.
-  # @param network_names names of networks to remove; may be empty or contain nonexistent networks
-  # @return names of the networks that were removed (excludes non-preexisting networks)
-  def remove_preferred_networks(*network_names)
-    networks_to_remove = network_names & preferred_networks # exclude any nonexistent networks
-    networks_to_remove.each do |name|
-      run_os_command("sudo networksetup -removepreferredwirelessnetwork " +
-                         "#{wifi_hardware_port} #{Shellwords.shellescape(name)}")
-    end
-    networks_to_remove
+  def remove_preferred_network(network_name)
+    run_os_command("sudo networksetup -removepreferredwirelessnetwork " +
+        "#{wifi_hardware_port} #{Shellwords.shellescape(network_name)}")
   end
 
 
@@ -342,46 +385,17 @@ class Model
   end
 
 
-  # Waits for the Internet connection to be in the desired state.
-  # @param status must be in [:conn, :disc, :off, :on]; waits for that state
-  # @param wait_interval_in_secs sleeps this interval between retries
-  #
-  # NOTE!: This is experimental and sometimes hangs.
-  def till(status, wait_interval_in_secs = nil)
-
-    wait_interval_in_secs ||= 0.5
-
-    exit_when = case status
-      when :conn
-        -> { connected_to_internet? }
-      when :disc
-        -> { ! connected_to_internet? }
-      when :on
-        -> { wifi_on? }
-      when :off
-        -> { ! wifi_on? }
-      else
-        raise ArgumentError.new("Option must be one of [:conn, :disc, :off, :on]. Was: #{status.inspect}")
-    end
+  class OsCommandError < RuntimeError
+    attr_reader :exitstatus, :command, :text
 
-    loop do
-      return if exit_when.()
-      sleep(wait_interval_in_secs)
+    def initialize(exitstatus, command, text)
+      @exitstatus = exitstatus
+      @command = command
+      @text = text
     end
   end
 
 
-  class OsCommandError < RuntimeError
-            attr_reader :exitstatus, :command, :text
-
-            def initialize(exitstatus, command, text)
-              @exitstatus = exitstatus
-              @command = command
-              @text = text
-            end
-          end
-
-
   def run_os_command(command)
     output = `#{command} 2>&1` # join stderr with stdout
     if $?.exitstatus != 0
@@ -435,7 +449,7 @@ pa[ssword] network-name - shows password for preferred network-name
 q[uit]                  - exits this program (interactive shell mode only)
 r[m] network-name       - removes network-name from the preferred networks list
 s[hell]                 - opens an interactive pry shell (command line only)
-t[ill]                  - (experimental!) returns when the desired Internet connection state is true. Options:
+t[ill]                  - returns when the desired Internet connection state is true. Options:
                           'on'/:on or 'off'/:off
                           wait interval, in seconds (optional, defaults to 0.5 seconds)
 w[ifion]                - is the wifi on?
@@ -449,12 +463,12 @@ When in interactive shell mode:
 
 
   def initialize
-    @model = Model.new(verbose_mode)
+    @model = MacOsModel.new(verbose_mode)
     @interactive_mode = false # will be true if/when user selects shell option on command line
   end
 
 
-  class Command < Struct.new(:regex, :action); end
+  class Command < Struct.new(:min_string, :max_string, :action); end
 
 
   class BadCommandError < RuntimeError
@@ -557,7 +571,8 @@ When in interactive shell mode:
 
   # For use by the shell; when typing a command and options, it is passed to process_command_line
   def method_missing(method_name, *options)
-    method_valid = !! find_command_action(method_name.to_s)
+    method_name = method_name.to_s
+    method_valid = !! find_command_action(method_name)
     if method_valid
       process_command_line(method_name, options)
     else
@@ -703,30 +718,30 @@ When in interactive shell mode:
 
   def commands
     @commands_ ||= [
-        Command.new(/^ci/,  -> (*_options) { cmd_ci            }),
-        Command.new(/^co/,  -> (*options)  { cmd_co(*options)  }),
-        Command.new(/^cy/,  -> (*_options) { cmd_cy            }),
-        Command.new(/^d/,   -> (*_options) { cmd_d             }),
-        Command.new(/^h/,   -> (*_options) { cmd_h             }),
-        Command.new(/^i/,   -> (*_options) { cmd_i             }),
-        Command.new(/^lsa/, -> (*_options) { cmd_lsa           }),
-        Command.new(/^lsp/, -> (*_options) { cmd_lsp           }),
-        Command.new(/^n/,   -> (*_options) { cmd_n             }),
-        Command.new(/^of/,  -> (*_options) { cmd_of            }),
-        Command.new(/^on/,  -> (*_options) { cmd_on            }),
-        Command.new(/^pa/,  -> (*options)  { cmd_pa(*options)  }),
-        Command.new(/^q/,   -> (*_options) { cmd_q             }),
-        Command.new(/^r/,   -> (*options)  { cmd_r(*options)   }),
-        Command.new(/^s/,   -> (*_options) { cmd_s             }),
-        Command.new(/^t/,   -> (*options)  { cmd_t(*options)   }),
-        Command.new(/^w/,   -> (*_options) { cmd_w             }),
-        Command.new(/^x/,   -> (*_options) { cmd_x             })
+        Command.new('ci',  'ci',           -> (*_options) { cmd_ci            }),
+        Command.new('co',  'connect',      -> (*options)  { cmd_co(*options)  }),
+        Command.new('cy',  'cycle',        -> (*_options) { cmd_cy            }),
+        Command.new('d',   'disconnect',   -> (*_options) { cmd_d             }),
+        Command.new('h',   'help',         -> (*_options) { cmd_h             }),
+        Command.new('i',   'info',         -> (*_options) { cmd_i             }),
+        Command.new('lsa', 'lsavailable',  -> (*_options) { cmd_lsa           }),
+        Command.new('lsp', 'lspreferred',  -> (*_options) { cmd_lsp           }),
+        Command.new('n',   'network_name', -> (*_options) { cmd_n             }),
+        Command.new('of',  'off',          -> (*_options) { cmd_of            }),
+        Command.new('on',  'on',           -> (*_options) { cmd_on            }),
+        Command.new('pa',  'password',     -> (*options)  { cmd_pa(*options)  }),
+        Command.new('q',   'quit',         -> (*_options) { cmd_q             }),
+        Command.new('r',   'rm',           -> (*options)  { cmd_r(*options)   }),
+        Command.new('s',   'shell',        -> (*_options) { cmd_s             }),
+        Command.new('t',   'till',         -> (*options)  { cmd_t(*options)   }),
+        Command.new('w',   'wifion',       -> (*_options) { cmd_w             }),
+        Command.new('x',   'xit',          -> (*_options) { cmd_x             })
     ]
   end
 
 
   def find_command_action(command_string)
-    result = commands.detect { |cmd| cmd.regex.match(command_string) }
+    result = commands.detect { |cmd| cmd.max_string.start_with?(command_string) }
     result ? result.action : nil
   end
 
@@ -741,12 +756,11 @@ When in interactive shell mode:
       exit(-1)
     end
   end
-
 end
-
 end
 
 
+
 # @return true if this file is being run as a script, else false
 #
 # This file could be called as a script in either of these two ways:
@@ -763,6 +777,15 @@ def running_as_script?
 end
 
 
+def assert_os_is_mac_os
+  uname = `uname`.chomp
+  unless uname == 'Darwin'
+    raise "This program currently works only on Mac OS. Platform is '#{uname}'."
+  end
+end
+
+assert_os_is_mac_os
+
 # If this file is being called as a script, run it.
 # Else, it may be loaded to use the model in a different way.
 if running_as_script?

data/mac-wifi.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-VERSION = '0.0.1'
+VERSION = '1.0.0'
 
 Gem::Specification.new do |spec|
   spec.name          = "mac-wifi"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mac-wifi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Keith Bennett
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-09-17 00:00:00.000000000 Z
+date: 2017-09-24 00:00:00.000000000 Z
 dependencies: []
 description: A command line interface for managing wifi on a Mac.
 email:
@@ -29,7 +29,7 @@ homepage: https://github.com/keithrbennett/mac-wifi
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -44,9 +44,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 2.6.13
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Mac wifi utility
 test_files: