mac-wifi 1.3.0 → 2.0.0

data/exe/mac-wifi

@@ -19,13 +19,16 @@
 # License: MIT License
 
 
+require 'json'
+require 'yaml'
+
 require 'shellwords'
 require 'tempfile'
 
 module MacWifi
 
 # This version must be kept in sync with the version in the gemspec file.
-VERSION = '1.3.0'
+VERSION = '2.0.0'
 
 
 class BaseModel
@@ -46,6 +49,19 @@ class BaseModel
   end
 
 
+  def run_os_command(command)
+    output = `#{command} 2>&1` # join stderr with stdout
+    if $?.exitstatus != 0
+      raise OsCommandError.new($?.exitstatus, command, output)
+    end
+    if @verbose_mode
+      puts "\n\n#{'-' * 79}\nCommand: #{command}\n\nOutput:\n#{output}#{'-' * 79}\n\n"
+    end
+    output
+  end
+  private :run_os_command
+
+
   # 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,
@@ -135,7 +151,7 @@ class BaseModel
 
   # 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().
+  # Relies on subclass implementation of os_level_connect().
   def connect(network_name, password = nil)
     # Allow symbols and anything responding to to_s for user convenience
     network_name = network_name.to_s if network_name
@@ -145,7 +161,7 @@ class BaseModel
       raise "A network name is required but was not provided."
     end
     wifi_on
-    simple_connect(network_name, password)
+    os_level_connect(network_name, password)
 
     # Verify that the network is now connected:
     actual_network_name = connected_network_name
@@ -175,7 +191,7 @@ class BaseModel
   def preferred_network_password(preferred_network_name)
     preferred_network_name = preferred_network_name.to_s
     if preferred_networks.include?(preferred_network_name)
-      simple_preferred_network_password(preferred_network_name)
+      os_level_preferred_network_password(preferred_network_name)
     else
       raise "Network #{preferred_network_name} not in preferred networks list."
     end
@@ -214,6 +230,21 @@ class BaseModel
       sleep(wait_interval_in_secs)
     end
   end
+
+
+  # Tries an OS command until the stop condition is true.
+  # @command the command to run in the OS
+  # @stop_condition a lambda taking the commands stdout as its sole parameter
+  # @return the stdout produced by the command
+  def try_os_command_until(command, stop_condition, max_tries = 100)
+    max_tries.times do
+      stdout = run_os_command(command)
+      if stop_condition.(stdout)
+        return stdout
+      end
+    end
+    nil
+  end
 end
 
 
@@ -266,37 +297,99 @@ class MacOsModel < BaseModel
     command = "#{AIRPORT_CMD} -s"
     max_attempts = 50
 
+
     reformat_line = ->(line) do
       ssid = line[0..31].strip
       "%-32.32s%s" % [ssid, line[32..-1]]
     end
 
-    max_attempts.times do
-      output = run_os_command(command)
-      if output.size > 0
-        lines = output.split("\n")
-        header_line = lines[0]
-        data_lines = lines[1..-1]
-        data_lines.map! do |line|
-          # Reformat the line so that the name is left instead of right justified
-          reformat_line.(line)
-        end
-        data_lines.sort!
-        return [reformat_line.(header_line)] + data_lines
+
+    process_tabular_data = ->(output) do
+      lines = output.split("\n")
+      header_line = lines[0]
+      data_lines = lines[1..-1]
+      data_lines.map! do |line|
+        # Reformat the line so that the name is left instead of right justified
+        reformat_line.(line)
       end
+      data_lines.sort!
+      [reformat_line.(header_line)] + data_lines
     end
 
 
-    raise "Unable to get available network information after #{max_attempts} attempts."
+    output = try_os_command_until(command, ->(output) do
+      ! ([nil, ''].include?(output))
+    end)
+
+    if output
+      process_tabular_data.(output)
+    else
+      raise "Unable to get available network information after #{max_attempts} attempts."
+    end
   end
 
 
-  # @return an array of unique available network names only, sorted alphabetically
-  def available_network_names
-    available_network_info[1..-1] \
+  def parse_network_names(info)
+    if info.nil?
+      nil
+    else
+      info[1..-1] \
         .map { |line| line[0..32].rstrip } \
         .uniq \
         .sort { |s1, s2| s1.casecmp(s2) }
+    end
+  end
+
+  # @return an array of unique available network names only, sorted alphabetically
+  # Kludge alert: the tabular data does not differentiate between strings with and without leading whitespace
+  # Therefore, we get the data once in tabular format, and another time in XML format.
+  # The XML element will include any leading whitespace. However, it includes all <string> elements,
+  # many of which are not network names.
+  # As an improved approximation of the correct result, for each network name found in tabular mode,
+  # we look to see if there is a corresponding string element with leading whitespace, and, if so,
+  # replace it.
+  #
+  # This will not behave correctly if a given name has occurrences with different amounts of whitespace,
+  # e.g. ' x' and '     x'.
+  #
+  # The reason we don't use an XML parser to get the exactly correct result is that we don't want
+  # users to need to install any external dependencies in order to run this script.
+  def available_network_names
+
+    # Parses the XML text (using grep, not XML parsing) to find
+    # <string> elements, and extracts the network name candidates
+    # containing leading spaces from it.
+    get_leading_space_names = ->(text) do
+      text.split("\n") \
+          .grep(%r{<string>}) \
+          .sort \
+          .uniq \
+          .map { |line| line.gsub("<string>", '').gsub('</string>', '').gsub("\t", '') } \
+          .select { |s| s[0] == ' ' }
+    end
+
+
+    output_is_valid = ->(output) { ! ([nil, ''].include?(output)) }
+    tabular_data = try_os_command_until("#{AIRPORT_CMD} -s", output_is_valid)
+    xml_data     = try_os_command_until("#{AIRPORT_CMD} -s -x", output_is_valid)
+
+    if tabular_data.nil? || xml_data.nil?
+      raise "Unable to get available network information; please try again."
+    end
+
+    tabular_data_lines = tabular_data[1..-1] # omit header line
+    names_no_spaces    = parse_network_names(tabular_data_lines.split("\n")).map(&:strip)
+    names_maybe_spaces =  get_leading_space_names.(xml_data)
+
+    names = names_no_spaces.map do |name_no_spaces|
+      match = names_maybe_spaces.detect do |name_maybe_spaces|
+        %r{[ \t]?#{name_no_spaces}$}.match(name_maybe_spaces)
+      end
+
+      match ? match : name_no_spaces
+    end
+
+    names.sort { |s1, s2| s1.casecmp(s2) }    # sort alphabetically, case insensitively
   end
 
 
@@ -344,7 +437,7 @@ class MacOsModel < BaseModel
 
 
   # This method is called by BaseModel#connect to do the OS-specific connection logic.
-  def simple_connect(network_name, password = nil)
+  def os_level_connect(network_name, password = nil)
     command = "networksetup -setairportnetwork #{wifi_hardware_port} " + "#{Shellwords.shellescape(network_name)}"
     if password
       command << ' ' << Shellwords.shellescape(password)
@@ -359,7 +452,7 @@ class MacOsModel < BaseModel
   #     If not, return nil
   #   else
   #     raise an error
-  def simple_preferred_network_password(preferred_network_name)
+  def os_level_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
@@ -429,19 +522,6 @@ class MacOsModel < BaseModel
   end
 
 
-  def run_os_command(command)
-    output = `#{command} 2>&1` # join stderr with stdout
-    if $?.exitstatus != 0
-      raise OsCommandError.new($?.exitstatus, command, output)
-    end
-    if @verbose_mode
-      puts "\n\n#{'-' * 79}\nCommand: #{command}\n\nOutput:\n#{output}#{'-' * 79}\n\n"
-    end
-    output
-  end
-  private :run_os_command
-
-
   # Parses output like the text below into a hash:
   # SSID: Pattara211
   # MCS: 5
@@ -461,7 +541,7 @@ end
 
 class CommandLineInterface
 
-  attr_reader :model, :interactive_mode
+  attr_reader :model, :interactive_mode, :options
 
   class Command < Struct.new(:min_string, :max_string, :action); end
 
@@ -475,23 +555,29 @@ class CommandLineInterface
 
   # Help text to be used when requested by 'h' command, in case of unrecognized or nonexistent command, etc.
   HELP_TEXT = "
-mac-wifi version #{VERSION} -- Available commands are:
+Command Line Switches:                    [mac-wifi version #{VERSION}]
+
+-o[i,j,p,y]               - outputs data in inspect, JSON, puts, or YAML format when not in shell mode
+-s                        - run in shell mode
+-v                        - verbose mode (prints OS commands and their outputs)
+
+Commands:
 
-a[vailnets]               - array of names of the available networks
+a[vail_nets]              - array of names of the available networks
 ci                        - connected to Internet (not just wifi on)?
 co[nnect] network-name    - turns wifi on, connects to network-name
 cy[cle]                   - turns wifi off, then on, preserving network selection
 d[isconnect]              - disconnects from current network, does not turn off wifi
 h[elp]                    - prints this help
 i[nfo]                    - a hash of wifi-related information
-l[savailnets]             - details about available networks
+l[s_avail_nets]           - details about available networks
 n[etwork_name]            - name (SSID) of currently connected network
 on                        - turns wifi on
 of[f]                     - turns wifi off
 pa[ssword] network-name   - password for preferred network-name
-pr[efnets]                - preferred (not necessarily available) networks
+pr[ef_nets]               - preferred (not necessarily available) networks
 q[uit]                    - exits this program (interactive shell mode only) (see also 'x')
-r[mprefnets] network-name - removes network-name from the preferred networks list
+r[m_pref_nets] network-name - removes network-name from the preferred networks list
                             (can provide multiple names separated by spaces)
 s[hell]                   - opens an interactive pry shell (command line only)
 t[ill]                    - returns when the desired Internet connection state is true. Options:
@@ -507,16 +593,18 @@ When in interactive shell mode:
 "
 
 
-  def initialize
+  def initialize(options)
+    @options = options
     @model = MacOsModel.new(verbose_mode)
-    @interactive_mode = false # will be changed to true if/when user selects shell option on command line
+    @interactive_mode = !!(options.interactive_mode)
+    run_shell if @interactive_mode
   end
 
 
   # Until command line option parsing is added, the only way to specify
   # verbose mode is in the environment variable MAC_WIFI_OPTS.
   def verbose_mode
-    /-v/.match(ENV['MAC_WIFI_OPTS'])
+    options.verbose
   end
 
 
@@ -563,7 +651,7 @@ When in interactive shell mode:
   # Asserts that a command has been passed on the command line.
   def validate_command_line
     if ARGV.empty?
-      puts "Syntax is: #{__FILE__} command [options]"
+      puts "Syntax is: #{__FILE__} [options] command [command_options]"
       print_help
       exit(-1)
     end
@@ -575,23 +663,16 @@ When in interactive shell mode:
   # that is not needed here.
   def run_pry
     binding.pry
+
+    # the seemingly useless line below is needed to avoid pry's exiting
+    # (see https://github.com/deivid-rodriguez/pry-byebug/issues/45)
+    _a = nil
   end
 
 
   # Runs a pry session in the context of this object.
   # Commands and options specified on the command line can also be specified in the shell.
   def run_shell
-    if interactive_mode
-      puts "Already in shell."
-      return
-    end
-
-    @interactive_mode = true
-
-    # For conveniently calling to_json or to_yaml on an object:
-    require 'json'
-    require 'yaml'
-
     begin
       require 'pry'
     rescue LoadError
@@ -656,15 +737,30 @@ When in interactive shell mode:
 
   def cmd_a
     info = model.available_network_names
-    puts_unless_interactive(fancy_string(info))
-    info
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        message = if model.wifi_on?
+          "Available networks are:\n\n#{fancy_string(info)}"
+        else
+          "Wifi is off, cannot see available networks."
+        end
+        puts(message)
+      end
+    end
   end
 
 
   def cmd_ci
     connected = model.connected_to_internet?
-    puts_unless_interactive("Connected to Internet: #{connected}")
-    connected
+    if interactive_mode
+      connected
+    else
+      puts (post_processor ? post_processor.(connected) : "Connected to Internet: #{connected}")
+    end
   end
 
 
@@ -690,22 +786,41 @@ When in interactive shell mode:
 
   def cmd_i
     info = model.wifi_info
-    puts_unless_interactive(fancy_string(info))
-    info
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        puts fancy_string(info)
+      end
+    end
   end
 
 
   def cmd_lsa
     info = model.available_network_info
-    puts_unless_interactive(fancy_string(info))
-    info
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        message = model.wifi_on? ? fancy_string(info) : "Wifi is off, cannot see available networks."
+        puts(message)
+      end
+    end
   end
 
 
   def cmd_n
     name = model.connected_network_name
-    puts_unless_interactive("Network (SSID) name: #{name ? name : '[none]'}")
-    name
+    if interactive_mode
+      name
+    else
+      display_name = name ? name : '[none]'
+      puts (post_processor ? post_processor.(name) : %Q{Network (SSID) name: "#{display_name}"})
+    end
   end
 
 
@@ -722,20 +837,27 @@ When in interactive shell mode:
   def cmd_pa(network)
     password = model.preferred_network_password(network)
 
-    unless interactive_mode
-      output =  %Q{Preferred network "#{network_name}" }
-      output << (password ? %Q{stored password is: "#{password}".} : "has no stored password.")
-      puts output
+    if interactive_mode
+      password
+    else
+      if post_processor
+        puts post_processor.(password)
+        else
+          output =  %Q{Preferred network "#{model.connected_network_name}" }
+          output << (password ? %Q{stored password is "#{password}".} : "has no stored password.")
+          puts output
+      end
     end
-
-    password
   end
 
 
   def cmd_pr
     networks = model.preferred_networks
-    puts_unless_interactive(fancy_string(networks))
-    networks
+    if interactive_mode
+      networks
+    else
+      puts (post_processor ? post_processor.(networks) : fancy_string(networks))
+    end
   end
 
 
@@ -745,12 +867,12 @@ When in interactive shell mode:
 
 
   def cmd_r(*options)
-    model.remove_preferred_networks(*options)
-  end
-
-
-  def cmd_s
-    run_shell
+    removed_networks = model.remove_preferred_networks(*options)
+    if interactive_mode
+      removed_networks
+    else
+      puts (post_processor ? post_processor.(removed_networks) : "Removed networks: #{removed_networks.inspect}")
+    end
   end
 
 
@@ -763,8 +885,11 @@ When in interactive shell mode:
 
   def cmd_w
     on = model.wifi_on?
-    puts_unless_interactive("Wifi on: #{on}")
-    on
+    if interactive_mode
+      on
+    else
+      puts (post_processor ? post_processor.(on) : "Wifi on: #{on}")
+    end
   end
 
 
@@ -775,25 +900,24 @@ When in interactive shell mode:
 
   def commands
     @commands_ ||= [
-        Command.new('a',   'availnets',    -> (*_options) { cmd_a             }),
-        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('l',   'lsavailnets',  -> (*_options) { cmd_lsa           }),
-        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('pr',  'prefnets',     -> (*_options) { cmd_pr            }),
-        Command.new('q',   'quit',         -> (*_options) { cmd_q             }),
-        Command.new('r',   'rmprefnets',   -> (*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             })
+        Command.new('a',   'avail_nets',    -> (*_options) { cmd_a             }),
+        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('l',   'ls_avail_nets', -> (*_options) { cmd_lsa           }),
+        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('pr',  'pref_nets',     -> (*_options) { cmd_pr            }),
+        Command.new('q',   'quit',          -> (*_options) { cmd_q             }),
+        Command.new('r',   'rm_pref_nets',  -> (*options)  { cmd_r(*options)   }),
+        Command.new('t',   'till',          -> (*options)  { cmd_t(*options)   }),
+        Command.new('w',   'wifion',        -> (*_options) { cmd_w             }),
+        Command.new('x',   'xit',           -> (*_options) { cmd_x             })
     ]
   end
 
@@ -809,6 +933,18 @@ When in interactive shell mode:
   end
 
 
+  # If a post-processor has been configured (e.g. YAML or JSON), use it.
+  def post_process(object)
+    post_processor ? post_processor.(object) : object
+  end
+
+
+
+  def post_processor
+    options.post_processor
+  end
+
+
   def call
     validate_command_line
     begin
@@ -822,6 +958,9 @@ When in interactive shell mode:
 end
 
 
+require 'optparse'
+require 'ostruct'
+
 class Main
 
   # @return true if this file is being run as a script, else false
@@ -873,20 +1012,57 @@ class Main
   end
 
 
+  # Parses the command line with Ruby's internal 'optparse'.
+  # Looks for "-v" flag to set verbosity to true.
+  # optparse removes what it processes from ARGV, which simplifies our command parsing.
+  def parse_command_line
+    options = OpenStruct.new
+    OptionParser.new do |parser|
+      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        options.verbose = v
+      end
+
+      parser.on("-s", "--shell", "Start interactive shell") do |v|
+        options.interactive_mode = true
+      end
+
+      parser.on("-o", "--output_format FORMAT", "Format output data") do |v|
+
+        transformers = {
+            'i' => ->(object) { object.inspect },
+            'j' => ->(object) { JSON.pretty_generate(object) },
+            'p' => ->(object) { sio = StringIO.new; sio.puts(object); sio.string },
+            'y' => ->(object) { object.to_yaml }
+        }
+
+        choice = v[0].downcase
+
+        unless transformers.keys.include?(choice)
+          raise %Q{Output format "#{choice}" not in list of available formats} +
+              " (#{transformers.keys.inspect})."
+        end
+
+        options.post_processor = transformers[choice]
+      end
+
+      parser.on("-h", "--help", "Show help") do |_help_requested|
+        ARGV << 'h' # pass on the request to the command processor
+      end
+    end.parse!
+    options
+  end
+
+
   def call
     assert_os_is_mac_os
 
+    options = parse_command_line
+
     # 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?
       begin
-        MacWifi::CommandLineInterface.new.call
-      rescue => error
-        puts error
-        stack_trace_filename = './mac-wifi-error-stack-trace.txt'
-        File.write(stack_trace_filename, caller.join("\n"))
-        puts "Exiting. Stack trace written to '#{File.expand_path(stack_trace_filename)}'."
-        exit(-1)
+        MacWifi::CommandLineInterface.new(options).call
       end
     end
   end

data/mac-wifi.gemspec

@@ -1,6 +1,6 @@
 # coding: utf-8
 # When changing the version, also change the version and the help text in the README.
-VERSION = '1.3.0'
+VERSION = '2.0.0'
 
 Gem::Specification.new do |spec|
   spec.name          = "mac-wifi"