expectr 1.1.1 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb60ae1f64e5710fe3e5cfdff6e49bf938a9aaa3
+  data.tar.gz: 98fd24b1cadf73f5c88a313dd48cd1edb0e6f64d
+SHA512:
+  metadata.gz: 1748339aa16a902c05c7b19a17e6469a94eaf3a2e21d3143ac92a2291d932cd52a3ecad280607efaa409ec7fb1cd017e5945c09d5a9bafda4a2906800a86a64c
+  data.tar.gz: 7d21a1bc05f4067f823d0f0292f1242dcee4bb4952d7df7ca520f8287e5aa4280de8e5b281f4f0b60c9321ae53bf45a76171abc35c7b48ea139067a2e00bc0b2

data/bin/expectr

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'expectr'
+require 'expectr/interpreter'
+
+class Expectr
+  module Main extend self
+    # Public: Read and run source passed in to the interpreter.
+    #
+    # Returns nothing.
+    def run
+      src = ARGF.read
+      exit 2 unless src
+
+      interpreter = Expectr::Interpreter.new(src.untaint)
+      interpreter.filename = $FILENAME
+      interpreter.run
+    end
+  end
+end
+
+Expectr::Main.run

data/lib/expectr/adopt.rb

@@ -0,0 +1,50 @@
+require 'expectr'
+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.
+    # IO Objects are named in such a way as to maintain interoperability with
+    # the methods from the Expectr::Child class.
+    #
+    # 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)
+        raise(TypeError, Errstr::IO_EXPECTED)
+      end
+      @stdin = stdin
+      @stdout = stdout
+      @stdout.winsize = $stdout.winsize if $stdout.tty?
+    end
+
+    # Public: Present a streamlined interface to create a new Expectr instance.
+    #
+    # stdout - IO object open for reading.
+    # stdin  - IO object open for writing.
+    # pid    - FixNum corresponding to the PID of the process being adopted
+    #          (default: 1)
+    # args   - A Hash used to specify options for the new object, per
+    #          Expectr#initialize.
+    #
+    # Returns a new Expectr object
+    def self.spawn(stdout, stdin, pid = 1, args = {})
+      args[:interface] = :adopt
+      args[:stdin] = stdin
+      args[:stdout] = stdout
+      args[:pid] = pid
+      Expectr.new('', args)
+    end
+  end
+end

data/lib/expectr/child.rb

@@ -0,0 +1,165 @@
+require 'pty'
+require 'expectr/interface'
+
+class Expectr
+  # Internal: The Expectr::Child class contains the interface to 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
+    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.
+    #
+    # cmd - A String or File referencing the application to launch.
+    #
+    # Raises TypeError if argument is anything other than String or File.
+    def initialize(cmd)
+      cmd = cmd.path if cmd.kind_of?(File)
+      unless cmd.kind_of?(String)
+        raise(TypeError, Errstr::STRING_FILE_EXPECTED)
+      end
+
+      @stdout,@stdin,@pid = PTY.spawn(cmd)
+      @stdout.winsize = $stdout.winsize if $stdout.tty?
+    end
+
+    # 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)
+    #
+    # 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
+      }
+    end
+
+    # Public: Send input to the active child process.
+    #
+    # 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
+      }
+    end
+
+    # Public: Read the child process's output, 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)
+          end
+        end
+      }
+    end
+
+    def interface_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`
+
+        # 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
+
+        # 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.
+    #
+    # Returns a Thread containing the running loop.
+    def interface_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
+            end
+          ensure
+            restore_environment(env)
+          end
+        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

data/lib/expectr/error.rb

@@ -1,5 +1,16 @@
 class Expectr
-  # Public: Error to denote a problem with the running Process associated with
-  # the current Expectr object
+  # Public: Denotes a problem with the running Process associated with a
+  # Child Interface
   class ProcessError < StandardError; end
+
+  module Interface
+    # Public: Denotes an interface which cannot be killed (e.g. Lambda Interface)
+    class NotKillableError < StandardError; end
+  end
+
+  class Interpreter
+    # Public: Denotes that input was attempted to be sent to a non-existant
+    # process.
+    class NotRunningError < StandardError; end
+  end
 end

data/lib/expectr/errstr.rb

@@ -0,0 +1,33 @@
+class Expectr
+  module Errstr
+    EXPECT_WRONG_TYPE = "Pattern should be of class String, Regexp, or Hash"
+    ALREADY_INTERACT  = "Already in interact mode"
+  end
+
+  class Child
+    module Errstr
+      STRING_FILE_EXPECTED = "Command should be of type String or File"
+      PROCESS_NOT_RUNNING  = "No process is running"
+      PROCESS_GONE         = "Child process no longer exists"
+    end
+  end
+
+  class Adopt < Child
+    module Errstr
+      IO_EXPECTED = "Arguments of type IO expected"
+    end
+  end
+
+  class Interpreter
+    module Errstr
+      BOOLEAN_OR_FIXNUM   = "Boolean or Fixnum expected, received a %s"
+      PROCESS_NOT_RUNNING = "No process is running"
+    end
+  end
+
+  class Lambda
+    module Errstr
+      PROC_EXPECTED = "Proc Objects expected for reader and writer"
+    end
+  end
+end

data/lib/expectr/interface.rb

@@ -0,0 +1,53 @@
+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 { }
+      }
+    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
+      -> {
+        {}
+      }
+    end
+
+    # Internal: Restore environment after interact mode has been left.
+    #
+    # 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
+      }
+    end
+  end
+end

data/lib/expectr/interpreter.rb

@@ -0,0 +1,119 @@
+require 'expectr'
+
+class Expectr
+  # Internal: Provide an interface to Expectr in a manner designed to mimic
+  # Expect's original functionality.
+  class Interpreter
+    DEFAULT_TIMEOUT = 10
+
+    # Public: Filename of currently executing script.
+    attr_accessor :filename
+
+    # Public: Initialize a new Expectr interface.
+    #
+    # source - String containing the source to be executed.
+    def initialize(source)
+      @source = source
+      @variables = { timeout: DEFAULT_TIMEOUT }
+      @expect = nil
+    end
+
+    # Public: Run the source associated with the Interface object, bound to the
+    # Object.
+    #
+    # Returns nothing.
+    def run
+      eval(@source, binding, (@filename || "(expectr)"), 0)
+    end
+
+    # Public: Print one or more messages to $stdout.
+    #
+    # str - String or Array of Strings to print to $stdout.
+    #
+    # Returns nothing.
+    def send_user(*str)
+      str.each { |line| $stdout.print line }
+    end
+
+    # Public: Set whether output from the active Expectr object should be
+    # echoed to the user.
+    #
+    # enable - Boolean value denoting whether output to the screen should be
+    #          enabled.
+    #          In order to keep compatibility with Expect, a Fixnum can be
+    #          passed, such that any number greater than 0 is evaluated as
+    #          true, and 0 or less is false.
+    # 
+    # Returns nothing.
+    # Raises Argument
+    def log_user(enable)
+      if enable.is_a?(Numeric)
+        enable = (enable > 0)
+      end
+      unless enable.is_a?(TrueClass) || enable.is_a?(FalseClass)
+        raise(TypeError, Errstr::BOOLEAN_OR_FIXNUM % enable.class.name)
+      end
+
+      set(:flush_buffer, enable)
+    end
+
+    # Public: Spawn an instance of a command via Expectr.
+    #
+    # cmd - String referencing the application to spawn.
+    #
+    # Returns nothing.
+    def spawn(cmd)
+      @expect = Expectr.new(cmd, @variables)
+    end
+
+    # Public: Provide an interface to Expectr#expect.
+    #
+    # args - Arguments to be passed through to the Expectr object.
+    #
+    # Returns per Expectr#expect.
+    def expect(*args)
+      @expect.expect(*args)
+    end
+
+    # Public: Send a String to the process referenced by the active Expectr
+    # object.
+    #
+    # str - String to send to the process.
+    #
+    # Returns nothing.
+    # Raises NotRunningError if no Expectr object is active.
+    def send(str)
+      if @expect.nil?
+        raise(NotRunningError, Errstr::PROCESS_NOT_RUNNING)
+      end
+      @expect.send(str)
+    end
+
+    # Public: Terminate any process associated with the Interpreter.
+    #
+    # Returns nothing.
+    def close
+      @expect.kill!(:KILL) if @expect.respond_to?(:kill!)
+    rescue Expectr::ProcessError
+    ensure
+      @expect = nil
+    end
+
+    private
+
+    # Internal: Set value in internal Hash and update attr_accessor value in
+    # the active Expectr object if applicable.
+    #
+    # variable_name - Name of key to set in the internal Hash.
+    # value         - Value to associate with the key.
+    #
+    # Returns nothing.
+    def set(variable_name, value)
+      @variables[variable_name] = value
+      method_name = (variable_name.to_s + "=").to_sym
+      if @expect.methods.include?(method_name)
+        @expect.method(method_name).call(value)
+      end
+    end
+  end
+end

data/lib/expectr/lambda.rb

@@ -0,0 +1,131 @@
+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
+    include Expectr::Interface
+    attr_reader :reader
+    attr_reader :writer
+
+    # Public: Initialize a new Expectr::Lambda object.
+    #
+    # 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)
+        raise(TypeError, Errstr::PROC_EXPECTED)
+      end
+
+      @reader = reader
+      @writer = writer
+    end
+
+    # Public: Present a streamlined interface to create a new Expectr instance.
+    #
+    # 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   - A Hash used to specify options for the new object, per
+    #          Expectr#initialize.
+    #
+    # Returns a new Expectr object
+    def self.spawn(reader, writer, args = {})
+      args[:interface] = :lambda
+      args[:reader] = reader
+      args[:writer] = writer
+      Expectr.new('', args)
+    end
+
+    # Public: Send input to the active child process.
+    #
+    # args - Arguments to pass to the reader interface.
+    #
+    # Returns nothing.
+    def interface_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: {}}
+
+        # 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
+
+        # SIGTSTP should be sent to the process as \C-z
+        env[:sig]['TSTP'] = trap 'TSTP' do
+          send "\C-z"
+        end
+
+        @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
+
+          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.
+    #
+    # 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)
+        end
+      }
+    end
+  end
+end

data/lib/expectr/version.rb

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