rubysh 0.0.3 → 0.0.4

data/README.md

@@ -58,10 +58,18 @@ are arbitrary symbols):
     runner.data(:stdout) # "hi\n"
     runner.data(:stderr) # ""
 
-Support for controlled input isn't quite ready, but the syntax will be
-similar to the above. I want to support interactivity (so being able
-to write data, read some data, and then write more data), and haven't
-quite decided on the right API for this yet.
+## Controlled input
+
+You can easily read and write data interactively:
+
+    >> runner = Rubysh('examples/dots.sh', Rubysh.>).run_async
+    => Rubysh::Runner: examples/dots.sh >:stdout (readers: :stdout, pid: 78296)
+    >> runner.read(:how => :partial) # block until some output available
+    => ".\n.\n.\n.\n.\n.\n.\n.\n.\n"
+    >> runner.read(:how => :nonblock)
+    => ""
+    >> runner.read # block until all output available
+    => [truncated]
 
 ## API
 

data/examples/dots.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+for i in $(seq 1 100); do
+    echo .
+    sleep 1
+done

data/lib/rubysh/base_command.rb

@@ -9,6 +9,8 @@ module Rubysh
       case arg
       when BaseCommand, BaseDirective
         arg.stringify
+      when Hash
+        arg.inspect
       else
         Shellwords.shellescape(arg.to_s)
       end
@@ -26,12 +28,16 @@ module Rubysh
       Runner.new(self)
     end
 
-    def run
-      create_runner.run
+    def run(&blk)
+      create_runner.run(&blk)
     end
 
-    def run_async
-      create_runner.run_async
+    def run_async(&blk)
+      create_runner.run_async(&blk)
+    end
+
+    def check_call(&blk)
+      create_runner.check_call(&blk)
     end
 
     def |(other)

data/lib/rubysh/command.rb

@@ -6,6 +6,7 @@ module Rubysh
       @raw_args = args
       @directives = []
       @args = nil
+      @opts = {}
 
       process_args
     end
@@ -18,6 +19,9 @@ module Rubysh
         when BaseDirective
           @directives << arg
           nil
+        when Hash
+          @opts.merge!(arg)
+          nil
         else
           arg.to_s
         end
@@ -87,6 +91,14 @@ module Rubysh
       state(runner)[:extra_directives] ||= []
     end
 
+    def base_post_forks
+      post_forks = []
+      if cwd = @opts[:cwd]
+        post_forks << Proc.new {Dir.chdir(cwd)}
+      end
+      post_forks
+    end
+
     def extra_post_forks(runner)
       state(runner)[:extra_post_forks] ||= []
     end
@@ -95,7 +107,7 @@ module Rubysh
       # extras first because they are currently only used for
       # pipeline, which should not win out over internal redirects.
       directives = extra_directives(runner) + @directives
-      post_forks = extra_post_forks(runner)
+      post_forks = base_post_forks + extra_post_forks(runner)
       state(runner)[:subprocess] = Subprocess.new(args, directives, post_forks, runner)
     end
   end

data/lib/rubysh/error.rb

@@ -16,5 +16,6 @@ module Rubysh
     class UnreachableError < BaseError; end
     class AlreadyClosedError < BaseError; end
     class AlreadyRunError < BaseError; end
+    class BadExitError < BaseError; end
   end
 end

data/lib/rubysh/redirect.rb

@@ -1,3 +1,5 @@
+require 'stringio'
+
 module Rubysh
   # Note that in bash, the semantics of redirection appear to be
   # following (tested empirically, rather than reading a spec):
@@ -119,7 +121,10 @@ module Rubysh
         :target_reading? => target_reading?,
         :target => target_reading? ? pipe.reader : pipe.writer,
         :complement => target_reading? ? pipe.writer : pipe.reader,
-        :buffer => []
+        :buffer => StringIO.new,
+        :target_name => target_name,
+        :read_pos => 0,
+        :subprocess_fd_number => Util.to_fileno(source)
       }
     end
 

data/lib/rubysh/runner.rb

@@ -14,10 +14,70 @@ module Rubysh
       prepare!
     end
 
-    def data(target_name)
-      state = target_state(target_name)
-      raise Rubysh::Error::BaseError.new("Can only access data for readable FDs") unless state[:target_reading?]
-      state[:buffer].join
+    def write(bytes, target=0)
+      raise Rubysh::Error::AlreadyRunError.new("Can only write to a runner in runner_state :started, not #{@runner_state.inspect}") unless @runner_state == :started
+      state = target_state(target, false)
+      target_name = state[:target_name]
+      @parallel_io.write(target_name, bytes, false)
+    end
+
+    # A bit of an unothordox read interface, not sure if I like
+    # it. Also, the target/opts magic is probably too magical (and not
+    # consistent with write!)
+    #
+    # You can do:
+    #
+    # read: finish the subprocess, and read from FD 1 in the child
+    # read(:how => :partial): wait until there are bytes on FD 1, and
+    #   then return what you can
+    # read(2, :how => :partial): Do the same for FD 2
+    # read(:stdout, :how => :partial): Do the same with whatever the named
+    #   descriptor :stdout
+    # read(:how => :nonblock): Return whatever is immediately available
+    def read(target=nil, opts=nil)
+      raise Rubysh::Error::AlreadyRunError.new("Can only read from a runner in runner_state :started or :waited, not #{@runner_state.inspect}") unless @runner_state == :started || @runner_state == :waited
+
+      if target.kind_of?(Hash)
+        opts = target
+        target = nil
+      end
+      target ||= 1
+      opts ||= {}
+
+      # TODO: add a stringio
+      state = target_state(target, true)
+      target_name = state[:target_name]
+
+      # Be nice to people and validate the hash
+      valid_keys = [:how]
+      extra_keys = opts.keys - valid_keys
+      raise raise Rubysh::Error::BaseError.new("Unrecognized keys #{extra_keys.inspect}. (Valid keys: #{valid_keys.inspect}") if extra_keys.length > 0
+
+      case how = opts[:how]
+      when :partial
+        # Read until we get some bytes
+        @parallel_io.run_once until state[:buffer].length != state[:read_pos]
+      when :nonblock
+        @parallel_io.read_available(state[:target])
+      when nil
+        communicate if @runner_state == :started
+      else
+        raise Rubysh::Error::BaseError.new("Invalid read directive #{how.inspect}")
+      end
+
+      state[:buffer].pos = state[:read_pos]
+      bytes = state[:buffer].read
+      # Could also increment by bytes, but meh.
+      state[:read_pos] = state[:buffer].pos
+      bytes
+    end
+
+    def communicate
+      raise Rubysh::Error::AlreadyRunError.new("Can only communicate with a runner in runner_state :started, not #{@runner_state.inspect}") unless @runner_state == :started
+      writers.each do |io, target_name|
+        @parallel_io.close(target_name) unless io.closed?
+      end
+      wait
     end
 
     # Ruby's Process::Status. Has fun things like pid and signaled?
@@ -40,6 +100,11 @@ module Rubysh
       end
     end
 
+    def exec_error
+      subprocess = state(@command)[:subprocess]
+      subprocess.exec_error
+    end
+
     # API for running/waiting
     def run_async
       raise Rubysh::Error::AlreadyRunError.new("You have already run this #{self.class} instance. Cannot run again. You can run its command directly though, which will create a fresh #{self.class} instance.") unless @runner_state == :initialized
@@ -49,15 +114,22 @@ module Rubysh
       self
     end
 
-    def wait
+    def run(input={}, &blk)
+      run_async
+      blk.call(self) if blk
       run_io
       do_wait
+      self
     end
 
-    def run(input={})
-      run_async
-      run_io
-      do_wait
+    def check_call(&blk)
+      run
+      status = full_status
+      unless status.success?
+        raise Rubysh::Error::BadExitError.new("#{@command} exited with #{rendered_status(status)}")
+      end
+      status
+      self
     end
 
     def readers
@@ -87,12 +159,12 @@ module Rubysh
     def inspect
       extras = []
       valid_readers = readers.values.map(&:inspect).join(', ')
-      valid_writers = readers.values.map(&:inspect).join(', ')
+      valid_writers = writers.values.map(&:inspect).join(', ')
 
       extras << "readers: #{valid_readers}" if valid_readers.length > 0
       extras << "writers: #{valid_writers}" if valid_writers.length > 0
-      if status = exitstatus
-        extras << "exitstatus: #{status}"
+      if status = full_status
+        extras << rendered_status(status)
       elsif mypid = pid
         extras << "pid: #{pid}"
       end
@@ -107,21 +179,54 @@ module Rubysh
     end
 
     # Internal helpers
-    def target_state(target_name)
-      @targets[target_name] || raise(Rubysh::Error::BaseError.new("Invalid target: #{target_name.inspect} (valid targets are: #{@targets.keys.inspect})"))
+    def target_state(target_name, reading=nil)
+      case target_name
+      when Symbol
+        target_state = @targets[target_name]
+        raise Rubysh::Error::BaseError.new("Invalid target symbol: #{target_name.inspect} (valid target symbols are: #{@targets.keys.inspect})") unless target_state
+      when Fixnum
+        targets = targets_by_fd_numbers
+        target_state = targets[target_name]
+        raise Rubysh::Error::BaseError.new("Invalid target fd number: #{target_name.inspect} (valid target fd numbers are: #{targets.keys.inspect}})") unless target_state
+      else
+        raise Rubysh::Error::BaseError.new("Invalid type for target name: #{target_name.inspect} (#{target_name.class}). Valid types are Symbol and Fixnum.")
+      end
+
+      if reading.nil?
+        # No checking
+      elsif target_state[:target_reading?] && !reading
+        raise Rubysh::Error::BaseError.new("Trying to write to read pipe #{target_name}")
+      elsif !target_state[:target_reading?] && reading
+        raise Rubysh::Error::BaseError.new("Trying to read from write pipe #{target_name}")
+      end
+
+      target_state
     end
 
     private
 
+    def wait
+      run_io
+      do_wait
+    end
+
+    def targets_by_fd_numbers
+      @targets.inject({}) do |hash, (_, target_state)|
+        fd_num = target_state[:subprocess_fd_number]
+        hash[fd_num] = target_state
+        hash
+      end
+    end
+
     def do_wait
-      raise Rubysh::Error::AlreadyRunError.new("You must run parallel io before waiting. (Perhaps you want to use the 'run' method, which takes care of the plumbing for you?)") unless @runner_state == :parallel_io_ran
+      return unless @runner_state == :parallel_io_ran
       @command.wait(self)
       @runner_state = :waited
       self
     end
 
     def run_io
-      raise Rubysh::Error::AlreadyRunError.new("You must start the subprocesses before running parallel io. (Perhaps you want to use the 'run' method, which takes care of the plumbing for you?)") unless @runner_state == :started
+      return unless @runner_state == :started
       @parallel_io.run
       @runner_state = :parallel_io_ran
       self
@@ -136,11 +241,16 @@ module Rubysh
     def prepare_io
       @parallel_io = Subprocess::ParallelIO.new(readers, writers)
       @parallel_io.on_read do |target_name, data|
+        state = @targets[target_name]
+        buffer = state[:buffer]
         if data == Subprocess::ParallelIO::EOF
           Rubysh.log.debug("EOF reached on #{target_name.inspect}")
+          buffer.close_write
         else
           Rubysh.log.debug("Just read #{data.inspect} on #{target_name.inspect}")
-          @targets[target_name][:buffer] << data
+          # Seek to end
+          buffer.pos = buffer.length
+          buffer.write(data)
         end
       end
 
@@ -152,5 +262,16 @@ module Rubysh
         end
       end
     end
+
+    def rendered_status(status)
+      if exitstatus = status.exitstatus
+        "exitstatus: #{exitstatus}"
+      elsif termsig = status.termsig
+        name, _ = Signal.list.detect {|name, number| number == termsig}
+        "termsig: #{name} [signal number #{termsig}]"
+      else
+        ''
+      end
+    end
   end
 end

data/lib/rubysh/subprocess/parallel_io.rb

@@ -65,8 +65,6 @@ class Rubysh::Subprocess
       end
     end
 
-    private
-
     def run_once
       potential_readers = available_readers
       potential_writers = available_writers
@@ -97,6 +95,8 @@ class Rubysh::Subprocess
       end
     end
 
+    private
+
     def finalize_reader(reader)
       @finished_readers.add(reader)
       issue_reader_callback(reader, EOF)

data/lib/rubysh/subprocess/pipe_wrapper.rb

@@ -1,5 +1,17 @@
 class Rubysh::Subprocess
   class PipeWrapper
+    begin
+      require 'json'
+      SERIALIZER = JSON
+    rescue LoadError => e
+      if ENV['RUBYSH_ENABLE_YAML']
+        require 'yaml'
+        SERIALIZER = YAML
+      else
+        raise LoadError.new("Could not import JSON (#{e}). You should either run in an environment with rubygems and JSON, or you can set the RUBYSH_ENABLE_YAML environment variable to allow Rubysh to internally use YAML for communication rather than JSON. This is believed safe, but YAML-parsing of untrusted input is bad, so only do this if you really can't get JSON.")
+      end
+    end
+
     attr_accessor :reader, :writer
 
     def initialize(reader_cloexec=true, writer_cloexec=true)
@@ -36,18 +48,22 @@ class Rubysh::Subprocess
       end
     end
 
-    def dump_yaml_and_close(msg)
+    def dump_json_and_close(msg)
+      dumped = SERIALIZER.dump(msg)
       begin
-        YAML.dump(msg, @writer)
+        @writer.write(dumped)
       ensure
         @writer.close
         Rubysh.assert(@reader.closed?, "Reader should already be closed")
       end
     end
 
-    def load_yaml_and_close
+    def load_json_and_close
+      contents = @reader.read
+      return false if contents.length == 0
+
       begin
-        YAML.load(@reader)
+        SERIALIZER.load(contents)
       rescue ArgumentError => e
         # e.g. ArgumentError: syntax error on line 0, col 2: `' (could
         # happen if the subprocess was killed while writing a message)

data/lib/rubysh/subprocess.rb

@@ -3,13 +3,6 @@ require 'fcntl'
 require 'timeout'
 require 'thread'
 
-# Using YAML to avoid the JSON dep. open4 uses Marshal to pass around
-# the exception object, but I'm always a bit sketched by Marshal when
-# it's not needed (i.e. don't want the subprocess to have the ability
-# to execute code in the parent, even if it should lose that ability
-# post-exec.)
-require 'yaml'
-
 require 'rubysh/subprocess/parallel_io'
 require 'rubysh/subprocess/pipe_wrapper'
 
@@ -131,7 +124,7 @@ module Rubysh
           # TODO: this may need coercion in Ruby1.9
           'caller' => e.send(:caller)
         }
-        @exec_status.dump_yaml_and_close(msg)
+        @exec_status.dump_json_and_close(msg)
         # Note: atexit handlers will fire in this case. May want to do
         # something about that.
         raise
@@ -139,7 +132,7 @@ module Rubysh
     end
 
     def handle_exec_error
-      msg = @exec_status.load_yaml_and_close
+      msg = @exec_status.load_json_and_close
 
       case msg
       when false

data/lib/rubysh/triple_less_than.rb

@@ -8,7 +8,7 @@ module Rubysh
         @fd = fd
       end
 
-      def <(literal)
+      def <(literal=:stdin)
         TripleLessThan.new(@fd, literal)
       end
 

data/lib/rubysh/version.rb

@@ -1,3 +1,3 @@
 module Rubysh
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/rubysh.rb

@@ -89,9 +89,14 @@ end
 
 module Rubysh
   # Convenience methods
-  def self.run(command)
-    command = Rubysh::Command.new(command) unless command.kind_of?(Rubysh::Command)
-    command.run
+  def self.run(*args, &blk)
+    command = Rubysh::Command.new(args)
+    command.run(&blk)
+  end
+
+  def self.check_call(*args, &blk)
+    command = Rubysh::Command.new(*args)
+    command.check_call(&blk)
   end
 
   def self.Command(*args)
@@ -118,15 +123,15 @@ module Rubysh
     FD.new(2)
   end
 
-  def self.>(target)
+  def self.>(target=:stdout)
     Redirect.new(1, '>', target)
   end
 
-  def self.>>(target)
+  def self.>>(target=:stdout)
     Redirect.new(1, '>>', target)
   end
 
-  def self.<(target)
+  def self.<(target=:stdin)
     Redirect.new(0, '<', target)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubysh
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
+date: 2013-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -55,6 +55,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- examples/dots.sh
 - lib/rubysh.rb
 - lib/rubysh/base_command.rb
 - lib/rubysh/base_directive.rb
@@ -109,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: ! 'Rubysh makes shelling out easy with a __sh__-like syntax layer for Ruby:  irb