expectr 1.1.0 → 1.1.1

data/lib/expectr/version.rb

@@ -1,3 +1,3 @@
 class Expectr
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

data/lib/expectr.rb

@@ -30,9 +30,15 @@ require 'expectr/version'
 #     # Do other stuff
 #   end
 class Expectr
+  DEFAULT_TIMEOUT      = 30
+  DEFAULT_FLUSH_BUFFER = true
+  DEFAULT_BUFFER_SIZE  = 8192
+  DEFAULT_CONSTRAIN    = false
+  DEFAULT_FORCE_MATCH  = false
+
   # Public: Gets/sets the number of seconds a call to Expectr#expect may last
   attr_accessor :timeout
-  # Public: Gets/sets whether to flush program output to STDOUT
+  # Public: Gets/sets whether to flush program output to $stdout
   attr_accessor :flush_buffer
   # Public: Gets/sets the number of bytes to use for the internal buffer
   attr_accessor :buffer_size
@@ -69,52 +75,21 @@ class Expectr
   #                        set to false, preventing further matches until more
   #                        output is generated otherwise. (default: false)
   def initialize(cmd, args={})
-    unless cmd.kind_of? String or cmd.kind_of? File
-      raise ArgumentError, "String or File expected"
-    end
-
-    cmd = cmd.path if cmd.kind_of? File
-
-    @buffer = ''.encode("UTF-8")
-    @discard = ''.encode("UTF-8")
-
-    @timeout = args[:timeout] || 30
-    @flush_buffer = args[:flush_buffer].nil? ? true : args[:flush_buffer]
-    @buffer_size = args[:buffer_size] || 8192
-    @constrain = args[:constrain] || false
-    @force_match = args[:force_match] || false
+    cmd = cmd.path if cmd.kind_of?(File)
+    raise ArgumentError, "String or File expected" unless cmd.kind_of?(String)
 
+    parse_options(args)
+    @buffer = ''
+    @discard = ''
     @out_mutex = Mutex.new
     @out_update = false
     @interact = false
 
     @stdout,@stdin,@pid = PTY.spawn(cmd)
-    @stdout.winsize = STDOUT.winsize
+    @stdout.winsize = $stdout.winsize if $stdout.tty?
 
     Thread.new do
-      while @pid > 0
-        unless select([@stdout], nil, nil, @timeout).nil?
-          buf = ''.encode("UTF-8")
-
-          begin
-            @stdout.sysread(@buffer_size, buf)
-          rescue Errno::EIO #Application went away.
-            @pid = 0
-            break
-          end
-
-          force_utf8(buf) unless buf.valid_encoding?
-          print_buffer(buf)
-
-          @out_mutex.synchronize do
-            @buffer << buf
-            if @buffer.length > @buffer_size && @constrain
-              @buffer = @buffer[-@buffer_size..-1]
-            end
-            @out_update = true
-          end
-        end
-      end
+      process_output
     end
 
     Thread.new do
@@ -139,41 +114,19 @@ class Expectr
 
     blocking = args[:blocking] || false
     @flush_buffer = args[:flush_buffer].nil? ? true : args[:flush_buffer]
-    @interact = true
-
-    # Save our old tty settings and set up our new environment
-    old_tty = `stty -g`
-    `stty -icanon min 1 time 0 -echo`
 
-    # SIGINT should be sent along to the process.
-    old_int_trap = trap 'INT' do
-      send "\C-c"
-    end
-
-    # SIGTSTP should be sent along to the process as well.
-    old_tstp_trap = trap 'TSTP' do
-      send "\C-z"
-    end
-
-    # SIGWINCH should trigger an update to the child process
-    old_winch_trap = trap 'WINCH' do
-      @stdout.winsize = STDOUT.winsize
-    end
-    
     interact = Thread.new do
-      input = ''.encode("UTF-8")
+      env = prepare_interact_environment
+      input = ''
+
       while @pid > 0 && @interact
-        if select([STDIN], nil, nil, 1)
-          c = STDIN.getc.chr
+        if select([$stdin], nil, nil, 1)
+          c = $stdin.getc.chr
           send c unless c.nil?
         end
       end
 
-      trap 'INT', old_int_trap
-      trap 'TSTP', old_tstp_trap
-      trap 'WINCH', old_winch_trap
-      `stty #{old_tty}`
-      @interact = false
+      restore_environment(env)
     end
 
     blocking ? interact.join : interact
@@ -256,27 +209,15 @@ class Expectr
   # Raises Timeout::Error if a match isn't found in time, unless recoverable
   def expect(pattern, recoverable = false)
     match = nil
-    @out_update = true if @force_match
-
-    case pattern
-    when String
-      pattern = Regexp.new(Regexp.quote(pattern))
-    when Regexp
-    else
+    @out_update ||= @force_match
+    pattern = Regexp.new(Regexp.quote(pattern)) if pattern.kind_of?(String)
+    unless pattern.kind_of?(Regexp)
       raise TypeError, "Pattern class should be String or Regexp"
     end
 
     begin
       Timeout::timeout(@timeout) do
-        while match.nil?
-          if @out_update
-            @out_mutex.synchronize do
-              match = pattern.match @buffer
-              @out_update = false
-            end
-          end
-          sleep 0.1
-        end
+        match = check_match(pattern)
       end
 
       @out_mutex.synchronize do
@@ -296,7 +237,7 @@ class Expectr
   # Returns nothing.
   def clear_buffer!
     @out_mutex.synchronize do
-      @buffer = ''.encode("UTF-8")
+      @buffer = ''
       @out_update = false
     end
   end
@@ -308,14 +249,14 @@ class Expectr
     @stdout.winsize
   end
 
-  # Internal: Print buffer to STDOUT if @flush_buffer is true
+  # Internal: Print buffer to $stdout if @flush_buffer is true
   #
-  # buf - String to be printed to STDOUT
+  # buf - String to be printed to $stdout
   #
   # Returns nothing.
   def print_buffer(buf)
     print buf if @flush_buffer
-    STDOUT.flush unless STDOUT.sync
+    $stdout.flush unless $stdout.sync
   end
 
   # Internal: Encode a String twice to force UTF-8 encoding, dropping           
@@ -325,6 +266,128 @@ class Expectr
   #                                                                             
   # 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                                                                           
+
+  private
+
+  # Internal: Determine values of instance options and set instance variables
+  # appropriately, allowing for default values where nothing is passed.
+  #
+  # 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.
+  #        :flush_buffer - Whether to flush output of the process to the
+  #                        console.
+  #        :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.
+  #        :constrain    - Whether to constrain the internal buffer from the
+  #                        sub-process to :buffer_size.
+  #        :force_match  - Whether to always attempt to match against the
+  #                        internal buffer on a call to Expectr#expect.  This
+  #                        is relevant following a failed call to
+  #                        Expectr#expect, which will leave the update status
+  #                        set to false, preventing further matches until more
+  #                        output is generated otherwise.
+  #
+  # Returns nothing.
+  def parse_options(args)
+    @timeout = args[:timeout] || DEFAULT_TIMEOUT
+    @buffer_size = args[:buffer_size] || DEFAULT_BUFFER_SIZE
+    @constrain = args[:constrain] || DEFAULT_CONSTRAIN
+    @force_match = args[:force_match] || DEFAULT_FORCE_MATCH
+    @flush_buffer = args[:flush_buffer]
+    @flush_buffer = DEFAULT_FLUSH_BUFFER if @flush_buffer.nil?
+  end
+
+  # Internal: Read from the process's stdout.  Force UTF-8 encoding, append to
+  # the internal buffer, and print to $stdout if appropriate.
+  #                                                                             
+  # Returns nothing.
+  def process_output
+    while @pid > 0
+      unless select([@stdout], nil, nil, @timeout).nil?
+        buf = ''
+
+        begin
+          @stdout.sysread(@buffer_size, buf)
+        rescue Errno::EIO #Application went away.
+          @pid = 0
+          return
+        end
+
+        print_buffer(force_utf8(buf))
+
+        @out_mutex.synchronize do
+          @buffer << buf
+          if @constrain && @buffer.length > @buffer_size
+            @buffer = @buffer[-@buffer_size..-1]
+          end
+          @out_update = true
+        end
+      end
+    end
+  end
+
+  # Internal: Prepare environment for interact mode, saving original
+  # environment parameters.
+  #                                                                             
+  # Returns a Hash object with two keys: :tty containing original tty
+  # information and :sig containing signal handlers which have been replaced.
+  def prepare_interact_environment
+    env = {sig: {}}
+    # Save our old tty settings and set up our new environment
+    env[:tty] = `stty -g`
+    `stty -icanon min 1 time 0 -echo`
+
+    # SIGINT should be sent along to the process.
+    env[:sig]['INT'] = trap 'INT' do
+      send "\C-c"
+    end
+
+    # SIGTSTP should be sent along to the process as well.
+    env[:sig]['TSTP'] = trap 'TSTP' do
+      send "\C-z"
+    end
+
+    # SIGWINCH should trigger an update to the child process
+    env[:sig]['WINCH'] = trap 'WINCH' do
+      @stdout.winsize = $stdout.winsize
+    end
+
+    @interact = true
+    env
+  end
+
+  # Internal: Restore environment post interact mode from saved parameters.
+  #                                                                             
+  # Returns nothing.
+  def restore_environment(env)
+    env[:sig].each_key do |sig|
+      trap sig, env[:sig][sig]
+    end
+    `stty #{env[:tty]}`
+    @interact = false
+  end
+
+  # Internal: Check for a match against a given pattern until a match is found.
+  # This method should be wrapped in a Timeout block or otherwise have some
+  # mechanism to break out of the loop.
+  #
+  # Returns a MatchData object containing the match found.
+  def check_match(pattern)
+    match = nil
+    while match.nil?
+      if @out_update
+        @out_mutex.synchronize do
+          match = pattern.match(@buffer)
+          @out_update = false
+        end
+      end
+      sleep 0.1
+    end
+    match
+  end
 end

data/test/test_core.rb

@@ -4,7 +4,7 @@ class CoreTests < Test::Unit::TestCase
   # For the purpose of testing, we will assume we are working within a POSIX
   # environment.
   def setup
-    @exp = Expectr.new("ls /dev", flush_buffer: false, timeout: 1,
+    @exp = Expectr.new("ls /dev && sleep 5", flush_buffer: false, timeout: 1,
                        buffer_size: 4096)
   end
 
@@ -33,7 +33,7 @@ class CoreTests < Test::Unit::TestCase
 
   def test_clear_buffer
     sleep 1
-    assert_not_equal(@exp.buffer, '')
+    assert_not_equal('', @exp.buffer)
     @exp.clear_buffer!
     assert_equal('', @exp.buffer)
   end
@@ -45,6 +45,6 @@ class CoreTests < Test::Unit::TestCase
   end
 
   def test_pid_set
-    assert @exp.pid > 0
+    assert_not_equal(0, @exp.pid)
   end
 end

data/test/test_interaction.rb

@@ -38,26 +38,26 @@ class InteractionTest < Test::Unit::TestCase
   end
 
   def test_winsize_set
-    assert_not_equal [0, 0], @exp.winsize
+    assert_not_equal([0, 0], @exp.winsize)
   end
 
   def test_interact_sets_appropriate_flags
     [
       Thread.new {
-        assert_equal false, @exp.interact?
+        assert_equal(false, @exp.interact?)
 
         sleep 0.5
         @exp.interact!.join
       },
       Thread.new {
         sleep 1
-        assert_equal true, @exp.flush_buffer
-        assert_equal true, @exp.interact?
+        assert_equal(true, @exp.flush_buffer)
+        assert_equal(true, @exp.interact?)
 
         @exp.flush_buffer = false
         @exp.send("quit\n")
       }
-    ].each {|x| x.join}
+    ].each { |x| x.join }
   end
 
   def test_interact_mode
@@ -72,9 +72,9 @@ class InteractionTest < Test::Unit::TestCase
         @exp.send("300+21\n")
         @exp.send("quit\n")
       }
-    ].each {|x| x.join}
+    ].each { |x| x.join }
 
-    assert_not_nil @exp.expect(/321/)
+    assert_not_nil(@exp.expect(/321/))
   end
 
   def test_leaving_interact_mode
@@ -87,10 +87,10 @@ class InteractionTest < Test::Unit::TestCase
         sleep 1
         @exp.flush_buffer = false
         assert_nothing_raised { @exp.leave! }
-        assert_equal false, @exp.interact?
+        assert_equal(false, @exp.interact?)
         @exp.send("quit\n")
       }
-    ].each {|x| x.join}
+    ].each { |x| x.join }
   end
 
   def test_blocking_interact_mode
@@ -105,8 +105,8 @@ class InteractionTest < Test::Unit::TestCase
         @exp.send("300+21\n")
         @exp.send("quit\n")
       }
-    ].each {|x| x.join}
+    ].each { |x| x.join }
 
-    assert_not_nil @exp.expect(/321/)
+    assert_not_nil(@exp.expect(/321/))
   end
 end

data/test/test_signals.rb

@@ -14,22 +14,23 @@ class SignalHandlerTest < Test::Unit::TestCase
       },
       Thread.new {
         sleep 1
-        @exp.flush_buffer=false
+        @exp.flush_buffer = false
         assert_nothing_raised do
-          $stdout.winsize = [10,10]
+          $stdout.winsize = [10, 10]
         end
         sleep 0.1
-        assert_equal [10,10], @exp.winsize
+        assert_equal([10, 10], @exp.winsize)
         @exp.puts("quit")
       }
-    ].each {|x| x.join}
+    ].each { |x| x.join }
 
     $stdout.winsize = winsize
   end
 
   def test_kill_process
-    assert_equal true, @exp.kill!
-    assert_equal 0, @exp.pid
+    assert_equal(true, @exp.kill!)
+    sleep 0.5
+    assert_equal(0, @exp.pid)
     assert_raises(Expectr::ProcessError) { @exp.send("test\n") }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expectr
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-18 00:00:00.000000000 Z
+date: 2013-05-03 00:00:00.000000000 Z
 dependencies: []
 description: Expectr is an interface to the functionality of Expect in Ruby
 email: chris@chriswuest.com