expectr 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb60ae1f64e5710fe3e5cfdff6e49bf938a9aaa3
-  data.tar.gz: 98fd24b1cadf73f5c88a313dd48cd1edb0e6f64d
+  metadata.gz: fdb63c98692074edfb85dfd5652de4bb858b98bc
+  data.tar.gz: c0cf8fcfbc6d926bf779884265db4fb1a484839f
 SHA512:
-  metadata.gz: 1748339aa16a902c05c7b19a17e6469a94eaf3a2e21d3143ac92a2291d932cd52a3ecad280607efaa409ec7fb1cd017e5945c09d5a9bafda4a2906800a86a64c
-  data.tar.gz: 7d21a1bc05f4067f823d0f0292f1242dcee4bb4952d7df7ca520f8287e5aa4280de8e5b281f4f0b60c9321ae53bf45a76171abc35c7b48ea139067a2e00bc0b2
+  metadata.gz: fb3dac4b059cc9d1453637b020ffa0fa0c094ca04ff5a62acba1dc95d23de265ac4781daf3ce59bd174cc0110a839d4826127a01298e06a4f2650ca5f1047b55
+  data.tar.gz: 47d9d136860390bcb8deb5296b6f3b2eac9406db8ef561770ae6a610a5600eaf07f8ec3acd0c260710278b72585c877106e61d63012d626f58f16684909b4ce6

data/lib/expectr/adopt.rb

@@ -3,33 +3,43 @@ require 'expectr/interface'
 require 'expectr/child'
 
 class Expectr
-  # Internal: The Expectr::Adopt Class contains the interface to interacting
-  # with child processes not spawned by Expectr.
-  #
-  # All methods with the prefix 'interface_' in their name will return a Proc
-  # designed to be defined as an instance method in the primary Expectr object.
-  # These methods will all be documented as if they are the Proc in question.
-  class Adopt < Expectr::Child
-    # Public: Initialize a new Expectr::Adopt object.
+  # Public: The Expectr::Adopt Module defines the interface for interacting
+  # with child processes without spawning them through Expectr.
+  module Adopt
+    include Expectr::Child
+
+    # Public: Initialize the Expectr interface, adopting IO objects to act on
+    # them as if they were produced by spawning a child process.
     # IO Objects are named in such a way as to maintain interoperability with
-    # the methods from the Expectr::Child class.
+    # the methods from the Expectr::Child module.
     #
-    # stdin  - IO object open for writing.
-    # stdout - IO object open for reading.
-    # pid    - FixNum corresponding to the PID of the process being adopted
-    #          (default: 1)
+    # args - Hash containing IO Objects and optionally a PID to watch.
+    #        stdin  - IO object open for writing.
+    #        stdout - IO object open for reading.
+    #        pid    - FixNum corresponding to the PID of the process being
+    #                 adopted. (default: 1)
     #
-    # Raises TypeError if arguments are of type other than IO.
-    def initialize(stdin, stdout)
-      unless stdin.kind_of?(IO) && stdout.kind_of?(IO)
+    # Returns nothing.
+    # Raises TypeError if args[:stdin] or args[:stdout] aren't of type IO.
+    def init_interface(args)
+      unless args[:stdin].kind_of?(IO) && args[:stdout].kind_of?(IO)
         raise(TypeError, Errstr::IO_EXPECTED)
       end
-      @stdin = stdin
-      @stdout = stdout
+      @stdin = args[:stdin]
+      @stdout = args[:stdout]
       @stdout.winsize = $stdout.winsize if $stdout.tty?
+      @pid = args[:pid] || 0
+
+      if @pid > 0
+        Thread.new do
+          Process.wait @pid
+          @pid = 0
+        end
+      end
     end
 
-    # Public: Present a streamlined interface to create a new Expectr instance.
+    # Public: Present a streamlined interface to create a new Expectr instance
+    # using the Adopt interface.
     #
     # stdout - IO object open for reading.
     # stdin  - IO object open for writing.
@@ -44,7 +54,7 @@ class Expectr
       args[:stdin] = stdin
       args[:stdout] = stdout
       args[:pid] = pid
-      Expectr.new('', args)
+      Expectr.new(args)
     end
   end
 end

data/lib/expectr/child.rb

@@ -1,28 +1,26 @@
 require 'pty'
+require 'expectr'
 require 'expectr/interface'
 
 class Expectr
-  # Internal: The Expectr::Child class contains the interface to interacting
+  # Public: The Expectr::Child Module defines the interface for interacting
   # with child processes.
-  #
-  # All methods with the prefix 'interface_' in their name will return a Proc
-  # designed to be defined as an instance method in the primary Expectr object.
-  # These methods will all be documented as if they are the Proc in question.
-  class Child
+  module Child
     include Expectr::Interface
-    attr_reader :stdin
-    attr_reader :stdout
-    attr_reader :pid
 
-    # Public: Initialize a new Expectr::Child object.
-    # Spawns a sub-process and attaches to STDIN and STDOUT for the new
-    # process.
+    # Public: Initialize the Expectr interface, spawning a sub-process
+    # attaching to STDIN and STDOUT of the new process.
     #
-    # cmd - A String or File referencing the application to launch.
+    # args - A Hash containing arguments to Expectr.  Only :cmd is presently
+    #        used for this function.
+    #        :cmd - A String or File referencing the application to launch.
     #
-    # Raises TypeError if argument is anything other than String or File.
-    def initialize(cmd)
+    # Returns nothing.
+    # Raises TypeError if args[:cmd] is anything other than String or File.
+    def init_interface(args)
+      cmd = args[:cmd]
       cmd = cmd.path if cmd.kind_of?(File)
+
       unless cmd.kind_of?(String)
         raise(TypeError, Errstr::STRING_FILE_EXPECTED)
       end
@@ -33,19 +31,17 @@ class Expectr
 
     # Public: Send a signal to the running child process.
     #
-    # signal - Symbol, String or FixNum corresponding to the symbol to be sent
-    # to the running process. (default: :TERM)
+    # signal - Symbol, String or FixNum indicating the symbol to be sent to the
+    #          running process. (default: :TERM)
     #
     # Returns a boolean indicating whether the process was successfully sent
     # the signal.
     # Raises ProcessError if the process is not running (@pid = 0).
-    def interface_kill!
-      ->(signal = :TERM) {
-        unless @pid > 0
-          raise(ProcessError, Errstr::PROCESS_NOT_RUNNING)
-        end
-        Process::kill(signal.to_sym, @pid) == 1
-      }
+    def kill!(signal = :TERM)
+      unless @pid > 0
+        raise(ProcessError, Errstr::PROCESS_NOT_RUNNING)
+      end
+      Process::kill(signal.to_sym, @pid) == 1
     end
 
     # Public: Send input to the active child process.
@@ -53,113 +49,98 @@ class Expectr
     # str - String to be sent.
     #
     # Returns nothing.
-    # Raises Expectr::ProcessError if the process is not running (@pid = 0)
-    def interface_send
-      ->(str) {
-        begin
-          @stdin.syswrite str
-        rescue Errno::EIO #Application is not running
-          @pid = 0
-        end
-        unless @pid > 0
-          raise(Expectr::ProcessError, Errstr::PROCESS_GONE)
-        end
-      }
+    # Raises Expectr::ProcessError if the process is not running (@pid = 0).
+    def send(str)
+      begin
+        @stdin.syswrite str
+      rescue Errno::EIO #Application is not running
+        @pid = 0
+      end
+      unless @pid > 0
+        raise(Expectr::ProcessError, Errstr::PROCESS_GONE)
+      end
     end
 
-    # Public: Read the child process's output, force UTF-8 encoding, then
+    # Public: Read the output of the child process, force UTF-8 encoding, then
     # append to the internal buffer and print to $stdout if appropriate.
     #
     # Returns nothing.
-    def interface_output_loop
-      -> {
-        while @pid > 0
-          unless select([@stdout], nil, nil, @timeout).nil?
-            buf = ''
-
-            begin
-              @stdout.sysread(@buffer_size, buf)
-            rescue Errno::EIO #Application is not running
-              @pid = 0
-              return
-            end
-            process_output(buf)
+    def output_loop
+      while @pid > 0
+        unless select([@stdout], nil, nil, @timeout).nil?
+          buf = ''
+
+          begin
+            @stdout.sysread(@buffer_size, buf)
+          rescue Errno::EIO #Application is not running
+            @pid = 0
+            return
           end
+          process_output(buf)
         end
-      }
+      end
     end
 
-    def interface_prepare_interact_environment
-      -> {
-        env = {sig: {}}
+    # Public: Return the PTY's window size.
+    #
+    # Returns a two-element Array (same as IO#winsize)
+    def winsize
+      @stdout.winsize
+    end
 
-        # Save old tty settings and set up the new environment
-        env[:tty] = `stty -g`
-        `stty -icanon min 1 time 0 -echo`
+    private
 
-        # SIGINT should be sent to the child as \C-c
-        env[:sig]['INT'] = trap 'INT' do
-          send "\C-c"
-        end
+    # Internal: Set up the execution environment to prepare for entering
+    # interact mode.
+    # Presently assumes a Linux system.
+    #
+    # Returns nothing.
+    def prepare_interact_environment
+      env = {sig: {}}
 
-        # SIGTSTP should be sent to the process as \C-z
-        env[:sig]['TSTP'] = trap 'TSTP' do
-          send "\C-z"
-        end
+      # Save old tty settings and set up the new environment
+      env[:tty] = `stty -g`
+      `stty -icanon min 1 time 0 -echo`
 
-        # SIGWINCH should trigger an update to the child processes window size
-        env[:sig]['WINCH'] = trap 'WINCH' do
-          @stdout.winsize = $stdout.winsize
-        end
+      # SIGINT should be sent to the child as \C-c
+      env[:sig]['INT'] = trap 'INT' do
+        send "\C-c"
+      end
+
+      # SIGTSTP should be sent to the process as \C-z
+      env[:sig]['TSTP'] = trap 'TSTP' do
+        send "\C-z"
+      end
 
-        env
-      }
+      # SIGWINCH should trigger an update to the child processes window size
+      env[:sig]['WINCH'] = trap 'WINCH' do
+        @stdout.winsize = $stdout.winsize
+      end
+
+      env
     end
 
-    # Public: Create a Thread containing the loop which is responsible for
-    # handling input from the user in interact mode.
+    # Internal: Create a Thread containing the loop which is responsible for
+    # handling input from the user while in interact mode.
     #
     # Returns a Thread containing the running loop.
-    def interface_interact_thread
-      -> {
-        @interact = true
-        env = prepare_interact_environment
-        Thread.new do
-          begin
-            input = ''
+    def interact_thread
+      @interact = true
+      env = prepare_interact_environment
+      Thread.new do
+        begin
+          input = ''
 
-            while @pid > 0 && @interact
-              if select([$stdin], nil, nil, 1)
-                c = $stdin.getc.chr
-                send c unless c.nil?
-              end
+          while @pid > 0 && @interact
+            if select([$stdin], nil, nil, 1)
+              c = $stdin.getc.chr
+              send c unless c.nil?
             end
-          ensure
-            restore_environment(env)
           end
+        ensure
+          restore_environment(env)
         end
-      }
-    end
-
-    # Public: Return the PTY's window size.
-    #
-    # Returns a two-element Array (same as IO#winsize)
-    def interface_winsize
-      -> {
-        @stdout.winsize
-      }
-    end
-
-    # Public: Present a streamlined interface to create a new Expectr instance.
-    #
-    # cmd  - A String or File referencing the application to launch.
-    # args - A Hash used to specify options for the new object, per
-    #        Expectr#initialize.
-    #
-    # Returns a new Expectr object
-    def self.spawn(cmd, args = {})
-      args[:interface] = :child
-      Expectr.new(cmd, args)
+      end
     end
   end
 end

data/lib/expectr/errstr.rb

@@ -4,7 +4,7 @@ class Expectr
     ALREADY_INTERACT  = "Already in interact mode"
   end
 
-  class Child
+  module Child
     module Errstr
       STRING_FILE_EXPECTED = "Command should be of type String or File"
       PROCESS_NOT_RUNNING  = "No process is running"
@@ -12,7 +12,7 @@ class Expectr
     end
   end
 
-  class Adopt < Child
+  module Adopt
     module Errstr
       IO_EXPECTED = "Arguments of type IO expected"
     end
@@ -25,7 +25,7 @@ class Expectr
     end
   end
 
-  class Lambda
+  module Lambda
     module Errstr
       PROC_EXPECTED = "Proc Objects expected for reader and writer"
     end

data/lib/expectr/interface.rb

@@ -1,53 +1,35 @@
 class Expectr
   module Interface
-    # Public: Enumerate and expose all interface functions for a given
-    # Interface.
-    #
-    # Returns a two-dimensional Array containing a name for the new method and
-    # a reference to the extant method.
-    def init_instance
-      methods = []
-      public_methods.select { |m| m =~ /^interface_/ }.each do |name|
-        method = public_method(name)
-        name = name.to_s.gsub(/^interface_/, '').to_sym
-        methods << [name, method]
-      end
-      methods
-    end
-
     # Public: Return a Thread which does nothing, representing an interface
     # with no functional interact environment available.
     #
     # Returns a Thread.
-    def interface_interact_thread
-      -> {
-        Thread.new { }
-      }
+    def interact_thread
+      Thread.new { }
     end
 
     # Public: Return an empty Hash representing a case where no action needed
     # to be taken in order to prepare the environment for interact mode.
     #
     # Returns an empty Hash.
-    def interface_prepare_interact_interface
-      -> {
-        {}
-      }
+    def prepare_interact_interface
+      {}
     end
 
-    # Internal: Restore environment after interact mode has been left.
+    private
+
+    # Internal: Restore environment (TTY parameters, signal handlers) after
+    # leaving interact mode.
     #
     # Returns nothing.
-    def interface_restore_environment
-      ->(env) {
-        env[:sig].each do |signal, handler|
-          trap signal, handler
-        end
-        unless env[:tty].nil?
-          `stty #{env[:tty]}`
-        end
-        @interact = false
-      }
+    def restore_environment(env)
+      env[:sig].each do |signal, handler|
+        trap signal, handler
+      end
+      unless env[:tty].nil?
+        `stty #{env[:tty]}`
+      end
+      @interact = false
     end
   end
 end

data/lib/expectr/interpreter.rb

@@ -9,7 +9,7 @@ class Expectr
     # Public: Filename of currently executing script.
     attr_accessor :filename
 
-    # Public: Initialize a new Expectr interface.
+    # Public: Initialize a new Expectr Interpreter interface.
     #
     # source - String containing the source to be executed.
     def initialize(source)
@@ -18,8 +18,7 @@ class Expectr
       @expect = nil
     end
 
-    # Public: Run the source associated with the Interface object, bound to the
-    # Object.
+    # Public: Run the source associated with the Interface object.
     #
     # Returns nothing.
     def run
@@ -45,7 +44,7 @@ class Expectr
     #          true, and 0 or less is false.
     # 
     # Returns nothing.
-    # Raises Argument
+    # Raises TypeError if enable is not a boolean.
     def log_user(enable)
       if enable.is_a?(Numeric)
         enable = (enable > 0)

data/lib/expectr/lambda.rb

@@ -2,33 +2,29 @@ require 'expectr'
 require 'expectr/interface'
 
 class Expectr
-  # Internal: The Expectr::Lambda Class contains the interface to interacting
-  # with ruby objects transparently via lambdas in a manner consistent with
-  # other Expectr interfaces.
-  #
-  # All methods with the prefix 'interface_' in their name will return a Proc
-  # designed to be defined as an instance method in the primary Expectr object.
-  # These methods will all be documented as if they are the Proc in question.
-  class Lambda
+  # Public: The Expectr::Lambda Module defines the interface for interacting
+  # with Proc objects in a manner which is similar to interacting with
+  # processes.
+  module Lambda
     include Expectr::Interface
-    attr_reader :reader
-    attr_reader :writer
 
-    # Public: Initialize a new Expectr::Lambda object.
+    # Public: Initialize the Expectr Lambda interface.
     #
-    # reader - Lambda which is meant to be interacted with as if it were
-    #          analogous to STDIN for a child process.
-    # writer - Lambda which is meant to be interacted with as if it were
-    #          analogous to STDOUT for a child process.
+    # args - Hash containing Proc objects to act as reader and writer:
+    #        reader - Lambda which is meant to be interacted with as if it were
+    #                 analogous to STDIN for a child process.
+    #        writer - Lambda which is meant to be interacted with as if it were
+    #                 analogous to STDOUT for a child process.
     #
     # Raises TypeError if arguments aren't of type Proc.
-    def initialize(reader, writer)
-      unless reader.kind_of?(Proc) && writer.kind_of?(Proc)
+    def init_interface(args)
+      unless args[:reader].kind_of?(Proc) && args[:writer].kind_of?(Proc)
         raise(TypeError, Errstr::PROC_EXPECTED)
       end
 
-      @reader = reader
-      @writer = writer
+      @pid = -1
+      @reader = args[:reader]
+      @writer = args[:writer]
     end
 
     # Public: Present a streamlined interface to create a new Expectr instance.
@@ -45,87 +41,82 @@ class Expectr
       args[:interface] = :lambda
       args[:reader] = reader
       args[:writer] = writer
-      Expectr.new('', args)
+      Expectr.new(args)
     end
 
-    # Public: Send input to the active child process.
+    # Public: Send input to the reader Proc.
     #
     # args - Arguments to pass to the reader interface.
     #
     # Returns nothing.
-    def interface_send
-      ->(args) {
-        @reader.call(*args)
-      }
+    def send(args)
+      @reader.call(*args)
     end
 
     # Public: Prepare the operating environment for interact mode, set the
     # interact flag to true.
     #
     # Returns a Hash containing old signal handlers and tty parameters.
-    def interface_prepare_interact_environment
-      -> {
-        env = {sig: {}}
+    def prepare_interact_environment
+      env = {sig: {}}
 
-        # Save old tty settings and set up the new environment
-        env[:tty] = `stty -g`
-        `stty -icanon min 1 time 0 -echo`
+      # Save old tty settings and set up the new environment
+      env[:tty] = `stty -g`
+      `stty -icanon min 1 time 0 -echo`
 
-        # SIGINT should be sent to the child as \C-c
-        env[:sig]['INT'] = trap 'INT' do
-          send "\C-c"
-        end
+      # SIGINT should be sent to the child as \C-c
+      env[:sig]['INT'] = trap 'INT' do
+        send "\C-c"
+      end
 
-        # SIGTSTP should be sent to the process as \C-z
-        env[:sig]['TSTP'] = trap 'TSTP' do
-          send "\C-z"
-        end
+      # SIGTSTP should be sent to the process as \C-z
+      env[:sig]['TSTP'] = trap 'TSTP' do
+        send "\C-z"
+      end
 
-        @interact = true
-        env
-      }
+      @interact = true
+      env
     end
 
     # Public: Create a Thread containing the loop which is responsible for
     # handling input from the user in interact mode.
     #
     # Returns a Thread containing the running loop.
-    def interface_interact_thread
-      -> {
-        Thread.new do
-          env = prepare_interact_environment
-          input = ''
-
-          while @interact
-            if select([$stdin], nil, nil, 1)
-              c = $stdin.getc.chr
-              send c unless c.nil?
-            end
-          end
+    def interact_thread
+      Thread.new do
+        env = prepare_interact_environment
+        input = ''
 
-          restore_environment(env)
+        while @interact
+          if select([$stdin], nil, nil, 1)
+            c = $stdin.getc.chr
+            send c unless c.nil?
+          end
         end
-      }
+
+        restore_environment(env)
+      end
     end
 
-    # Internal: Call the writer lambda, reading the output, forcing UTF-8 and
-    # appending to the internal buffer and printing to $stdout if appropriate.
+    private
+
+    # Internal: Call the writer lambda, reading the output produced, forcing
+    # UTF-8, appending to the internal buffer and printing to $stdout if
+    # appropriate.
     #
     # Returns nothing.
-    def interface_output_loop
-      -> {
-        buf = ''
-        loop do
-          buf.clear
-
-          begin
-            buf << @writer.call.to_s
-          rescue Errno::EIO # Lambda is signaling that execution should end.
-            return
-          end
-          process_output(buf)
+    def output_loop
+      buf = ''
+      loop do
+        buf.clear
+
+        begin
+          buf << @writer.call.to_s
+        rescue Errno::EIO # Lambda is signaling that execution should end.
+          return
         end
-      }
+        process_output(buf)
+      end
     end
   end
 end

data/lib/expectr/version.rb

@@ -1,3 +1,3 @@
 class Expectr
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/lib/expectr.rb

@@ -13,10 +13,9 @@ require 'expectr/lambda'
 # Public: Expectr is an API to the functionality of Expect (see
 # http://expect.nist.gov) implemented in ruby.
 #
-# Expectr contrasts with Ruby's built-in Expect class by avoiding tying in
-# with the IO class, instead creating a new object entirely to allow for more
-# grainular control over the execution and display of the program being
-# run.
+# Expectr contrasts with Ruby's built-in expect.rb by avoiding tying in with
+# the IO class in favor of creating a new object entirely to allow for more
+# granular control over the execution and display of the program being run.
 #
 # Examples
 #
@@ -57,51 +56,57 @@ class Expectr
   # Public: Initialize a new Expectr object.
   # Spawns a sub-process and attaches to STDIN and STDOUT for the new process.
   #
-  # cmd  - A String or File referencing the application to launch (default: '')
-  # args - A Hash used to specify options for the new object (default: {}):
-  #        :timeout      - Number of seconds that a call to Expectr#expect has
-  #                        to complete (default: 30)
-  #        :flush_buffer - Whether to flush output of the process to the
-  #                        console (default: true)
-  #        :buffer_size  - Number of bytes to attempt to read from sub-process
-  #                        at a time.  If :constrain is true, this will be the
-  #                        maximum size of the internal buffer as well.
-  #                        (default: 8192)
-  #        :constrain    - Whether to constrain the internal buffer from the
-  #                        sub-process to :buffer_size (default: false)
-  #        :interface    - Interface Object to use when instantiating the new
-  #                        Expectr object. (default: Child)
-  def initialize(cmd = '', args = {})
+  # cmd_args - This may be either a Hash containing arguments (described below)
+  #            or a String or File Object referencing the application to launch
+  #            (assuming Child interface).  This argument, if not a Hash, will
+  #            be changed into the Hash { cmd: cmd_args }.  This argument will
+  #            be  merged with the args Hash, overriding any arguments
+  #            specified there.
+  #            This argument is kept around for the sake of backward
+  #            compatibility with extant Expectr scripts and may be deprecated
+  #            in the future.  (default: {})
+  # args     - A Hash used to specify options for the instance. (default: {}):
+  #            :timeout      - Number of seconds that a call to Expectr#expect
+  #                            has to complete (default: 30)
+  #            :flush_buffer - Whether to flush output of the process to the
+  #                            console (default: true)
+  #            :buffer_size  - Number of bytes to attempt to read from
+  #                            sub-process at a time.  If :constrain is true,
+  #                            this will be the maximum size of the internal
+  #                            buffer as well.  (default: 8192)
+  #            :constrain    - Whether to constrain the internal buffer from
+  #                            the sub-process to :buffer_size characters.
+  #                            (default: false)
+  #            :interface    - Interface Object to use when instantiating the
+  #                            new Expectr object. (default: Child)
+  def initialize(cmd_args = '', args = {})
     setup_instance
     parse_options(args)
 
-    case args[:interface]
-    when :lambda
-      interface = call_lambda_interface(args)
-    when :adopt
-      interface = call_adopt_interface(args)
-    else
-      interface = call_child_interface(cmd)
-    end
+    cmd_args = { cmd: cmd_args } unless cmd_args.is_a?(Hash)
+    args.merge!(cmd_args)
 
-    interface.init_instance.each do |spec|
-      ->(name, func) { define_singleton_method(name, func.call) }.call(*spec)
+    unless [:lambda, :adopt, :child].include?(args[:interface])
+      args[:interface] = :child
     end
 
+    self.extend self.class.const_get(args[:interface].capitalize)
+    init_interface(args)
+
     Thread.new { output_loop }
   end
 
-  # Public: Relinquish control of the running process to the controlling
+  # Public: Allow direct control of the running process from the controlling
   # terminal, acting as a pass-through for the life of the process (or until
   # the leave! method is called).
   #
-  # args - A Hash used to specify options to be used for interaction (default:
-  #        {}):
+  # args - A Hash used to specify options to be used for interaction.
+  #        (default: {}):
   #        :flush_buffer - explicitly set @flush_buffer to the value specified
   #        :blocking     - Whether to block on this call or allow code
   #                        execution to continue (default: false)
   #
-  # Returns the interaction Thread
+  # Returns the interaction Thread, calling #join on it if :blocking is true.
   def interact!(args = {})
     if @interact
       raise(ProcessError, Errstr::ALREADY_INTERACT)
@@ -111,23 +116,23 @@ class Expectr
     args[:blocking] ? interact_thread.join : interact_thread
   end
 
-  # Public: Report whether or not current Expectr object is in interact mode
+  # Public: Report whether or not current Expectr object is in interact mode.
   #
-  # Returns true or false
+  # Returns a boolean.
   def interact?
     @interact
   end
 
-  # Public: Cause the current Expectr object to drop out of interact mode
+  # Public: Cause the current Expectr object to leave interact mode.
   #
   # Returns nothing.
   def leave!
     @interact=false
   end
 
-  # Public: Wraps Expectr#send, appending a newline to the end of the string
+  # Public: Wraps Expectr#send, appending a newline to the end of the string.
   #
-  # str - String to be sent to the active process (default: '')
+  # str - String to be sent to the active process. (default: '')
   #
   # Returns nothing.
   def puts(str = '')
@@ -135,7 +140,8 @@ class Expectr
   end
 
   # Public: Begin a countdown and search for a given String or Regexp in the
-  # output buffer.
+  # output buffer, optionally taking further action based upon which, if any,
+  # match was found.
   #
   # pattern     - Object String or Regexp representing pattern for which to
   #               search, or a Hash containing pattern -> Proc mappings to be
@@ -163,7 +169,7 @@ class Expectr
   #            "Second possibility" => -> { puts "option b" },
   #            default:             => -> { puts "called on timeout" } }
   #   exp.expect(hash)
-  # 
+  #
   # Returns a MatchData object once a match is found if no block is given
   # Yields the MatchData object representing the match
   # Raises TypeError if something other than a String or Regexp is given
@@ -196,7 +202,7 @@ class Expectr
   #     /option 2/ => -> { puts "action 2" },
   #     :default   => -> { puts "default" }
   #   })
-  # 
+  #
   # Calls the procedure associated with the pattern provided.
   def expect_procmap(pattern_map)
     pattern_map, pattern, recoverable = process_procmap(pattern_map)
@@ -215,7 +221,7 @@ class Expectr
     nil
   end
 
-  # Public: Clear output buffer
+  # Public: Clear output buffer.
   #
   # Returns nothing.
   def clear_buffer!
@@ -226,9 +232,10 @@ class Expectr
 
   private
 
-  # Internal: Print buffer to $stdout if @flush_buffer is true
+  # Internal: Print buffer to $stdout if program output is expected to be
+  # echoed.
   #
-  # buf - String to be printed to $stdout
+  # buf - String to be printed to $stdout.
   #
   # Returns nothing.
   def print_buffer(buf)
@@ -236,19 +243,18 @@ class Expectr
     $stdout.flush unless $stdout.sync
   end
 
-  # Internal: Encode a String twice to force UTF-8 encoding, dropping           
-  # problematic characters in the process.                                      
-  #                                                                             
-  # buf  - String to be encoded.                                                
-  #                                                                             
-  # Returns the encoded String.                                                 
-  def force_utf8(buf)                                                           
+  # Internal: Encode a String twice to force UTF-8 encoding, dropping
+  # problematic characters in the process.
+  #
+  # buf  - String to be encoded.
+  #
+  # Returns the encoded String.
+  def force_utf8(buf)
     return buf if buf.valid_encoding?
-    buf.force_encoding('ISO-8859-1').encode('UTF-8', 'UTF-8', replace: nil)     
-  end                                                                           
+    buf.force_encoding('ISO-8859-1').encode('UTF-8', 'UTF-8', replace: nil)
+  end
 
-  # Internal: Determine values of instance options and set instance variables
-  # appropriately, allowing for default values where nothing is passed.
+  # Internal: Initialize instance variables based upon arguments provided.
   #
   # args - A Hash used to specify options for the new object (default: {}):
   #        :timeout      - Number of seconds that a call to Expectr#expect has
@@ -283,7 +289,7 @@ class Expectr
 
   # Internal: Handle data from the interface, forcing UTF-8 encoding, appending
   # it to the internal buffer, and printing it to $stdout if appropriate.
-  #                                                                             
+  #
   # Returns nothing.
   def process_output(buf)
     force_utf8(buf)
@@ -302,8 +308,7 @@ class Expectr
   # This method should be wrapped in a Timeout block or otherwise have some
   # mechanism to break out of the loop.
   #
-  # pattern     - String or Regexp object containing the pattern for which to
-  #               watch.
+  # pattern - String or Regexp containing the pattern for which to watch.
   #
   # Returns a MatchData object containing the match found.
   def check_match(pattern)
@@ -320,62 +325,8 @@ class Expectr
     @thread = nil
   end
 
-  # Internal: Call the Child Interface to instantiate the Expectr object.
-  # 
-  # cmd - String or File object referencing the command to be run.
-  #
-  # Returns the Interface object.
-  def call_child_interface(cmd)
-    interface = Expectr::Child.new(cmd)
-    @stdin = interface.stdin
-    @stdout = interface.stdout
-    @pid = interface.pid
-
-    Thread.new do
-      Process.wait @pid
-      @pid = 0
-    end
-
-    interface
-  end
-
-  # Internal: Call the Lambda Interface to instantiate the Expectr object.
-  # 
-  # args - Arguments hash passed per #initialize.
-  #
-  # Returns the Interface object.
-  def call_lambda_interface(args)
-    interface = Expectr::Lambda.new(args[:reader], args[:writer])
-    @pid = -1
-    @reader = interface.reader
-    @writer = interface.writer
-
-    interface
-  end
-
-  # Internal: Call the Adopt Interface to instantiate the Expectr object.
-  # 
-  # args - Arguments hash passed per #initialize.
-  #
-  # Returns the Interface object.
-  def call_adopt_interface(args)
-    interface = Expectr::Adopt.new(args[:stdin], args[:stdout])
-    @stdin = interface.stdin
-    @stdout = interface.stdout
-    @pid = args[:pid] || 1
-
-    if @pid > 0
-      Thread.new do
-        Process.wait @pid
-        @pid = 0
-      end
-    end
-
-    interface
-  end
-
   # Internal: Watch for a match within the timeout period.
-  # 
+  #
   # pattern     - String or Regexp object containing the pattern for which to
   #               watch.
   # recoverable - Boolean denoting whether a failure to find a match should be
@@ -404,23 +355,31 @@ class Expectr
   # Internal: Process a pattern to procedure mapping, producing a sanitized
   # Hash, a unified Regexp and a boolean denoting whether an Exception should
   # be raised upon timeout.
-  # 
+  #
   # pattern_map - A Hash containing mappings between patterns designated by
   #               either strings or Regexp objects, to procedures.  Optionally,
   #               either :default or :timeout may be mapped to a procedure in
-  #               order to designate an action to take upon timeout.
+  #               order to designate an action to take upon failure to match
+  #               any other pattern.
   #
   # Returns a Hash, Regexp and boolean object.
   def process_procmap(pattern_map)
+    # Normalize Hash keys, allowing only Regexps and Symbols for keys.
     pattern_map = pattern_map.reduce({}) do |c,e|
-      c.merge((e[0].is_a?(Symbol) ? e[0] : Regexp.new(e[0].to_s)) => e[1])
+      unless e[0].is_a?(Symbol) || e[0].is_a?(Regexp)
+        e[0] = Regexp.new(Regexp.escape(e[0].to_s))
+      end
+      c.merge(e[0] => e[1])
     end
-    pattern = pattern_map.keys.reduce("") do |c,e|
-      e.is_a?(Regexp) ? c + "(#{e.source})|" : c
+
+    # Separate out non-Symbol keys and build a unified Regexp.
+    regex_keys = pattern_map.keys.select { |e| e.is_a?(Regexp) }
+    pattern = regex_keys.reduce("") do |c,e|
+      c += "|" unless c.empty?
+      c + "(#{e.source})"
     end
-    pattern = Regexp.new(pattern.gsub(/\|$/, ''))
-    recoverable   = pattern_map.keys.include?(:default)
-    recoverable ||= pattern_map.keys.include?(:timeout)
+
+    recoverable = regex_keys.include?(:default) || regex_keys.include?(:timeout)
 
     return pattern_map, pattern, recoverable
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expectr
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Chris Wuest
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies: []
 description: Expectr is an interface to the functionality of Expect in Ruby
 email: chris@chriswuest.com
@@ -47,7 +47,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: Expect for Ruby