rubsh 0.0.2 → 0.0.3

data/lib/shell_parser.rb

@@ -0,0 +1,141 @@
+class ShellParser
+  Substitution = Struct.new(:source)
+  Word = Struct.new(:parts) do
+    def literal?
+      parts.all? { |part| part.is_a?(String) }
+    end
+
+    def value
+      parts.join
+    end
+  end
+  Stage = Struct.new(:words)
+  Pipeline = Struct.new(:stages)
+
+  def self.parse(source)
+    new(source).parse
+  end
+
+  def initialize(source)
+    @source = source.to_s
+    @index = 0
+    @stages = []
+    @words = []
+    @parts = []
+    @buffer = +''
+    @word_started = false
+  end
+
+  def parse
+    while @index < @source.length
+      char = @source[@index]
+      case char
+      when ' ', "\t", "\r", "\n"
+        flush_buffer
+        flush_word
+        @index += 1
+      when '|'
+        flush_buffer
+        flush_word
+        raise SyntaxError, 'empty pipeline stage' if @words.empty?
+        @stages << Stage.new(@words)
+        @words = []
+        @index += 1
+      when "'"
+        read_single_quote
+      when '"'
+        read_double_quote
+      when '\\'
+        @word_started = true
+        @index += 1
+        raise SyntaxError, 'trailing escape' if @index >= @source.length
+        @buffer << @source[@index]
+        @index += 1
+      when '`'
+        flush_buffer
+        @parts << read_substitution
+      else
+        @word_started = true
+        @buffer << char
+        @index += 1
+      end
+    end
+
+    flush_buffer
+    flush_word
+    raise SyntaxError, 'empty pipeline stage' if @words.empty? && !@stages.empty?
+    @stages << Stage.new(@words) unless @words.empty?
+    raise SyntaxError, 'empty command' if @stages.empty?
+    Pipeline.new(@stages)
+  end
+
+  private
+
+  def flush_buffer
+    return if @buffer.empty?
+    @parts << @buffer
+    @buffer = +''
+  end
+
+  def flush_word
+    return unless @word_started
+    @words << Word.new(@parts)
+    @parts = []
+    @word_started = false
+  end
+
+  def read_single_quote
+    @word_started = true
+    @index += 1
+    start = @index
+    finish = @source.index("'", start)
+    raise SyntaxError, 'unterminated single quote' unless finish
+    @buffer << @source[start...finish]
+    @index = finish + 1
+  end
+
+  def read_double_quote
+    @word_started = true
+    @index += 1
+    loop do
+      raise SyntaxError, 'unterminated double quote' if @index >= @source.length
+      char = @source[@index]
+      if char == '"'
+        @index += 1
+        return
+      elsif char == '\\'
+        @index += 1
+        raise SyntaxError, 'trailing escape' if @index >= @source.length
+        @buffer << @source[@index]
+        @index += 1
+      elsif char == '`'
+        flush_buffer
+        @parts << read_substitution
+      else
+        @buffer << char
+        @index += 1
+      end
+    end
+  end
+
+  def read_substitution
+    @word_started = true
+    @index += 1
+    start = @index
+    escaped = false
+    while @index < @source.length
+      char = @source[@index]
+      if escaped
+        escaped = false
+      elsif char == '\\'
+        escaped = true
+      elsif char == '`'
+        source = @source[start...@index]
+        @index += 1
+        return Substitution.new(source)
+      end
+      @index += 1
+    end
+    raise SyntaxError, 'unterminated command substitution'
+  end
+end

data/lib/shell_pipeline.rb

@@ -0,0 +1,131 @@
+require 'stringio'
+
+
+class ShellPipeline
+  attr_reader :statuses, :stdout, :stderr
+
+  def initialize(stages, stdin: $stdin, stdout: $stdout, stderr: $stderr)
+    @stages = stages
+    @stdin = stdin
+    @stdout_target = stdout
+    @stderr_target = stderr
+    @statuses = []
+    @stdout = +''
+    @stderr = +''
+  end
+
+  def run
+    input = usable_input(@stdin)
+    processes = []
+    output_reader = nil
+    error_readers = []
+    inputs_to_close = []
+    direct_output = @stages.length == 1 && terminal?(@stdout_target)
+
+    @stages.each_with_index do |stage, index|
+      if direct_output
+        output_read = nil
+        output_write = @stdout_target
+      else
+        output_read, output_write = IO.pipe
+      end
+      error_read, error_write = IO.pipe
+      processes << stage.spawn(input, output_write, error_write)
+      output_write.close if output_write != @stdout_target
+      error_write.close
+      inputs_to_close << input if input != @stdin
+
+      if index == @stages.length - 1
+        output_reader = Thread.new do
+          begin
+            output_read.read
+          ensure
+            output_read.close unless output_read.closed?
+          end
+        end unless direct_output
+      else
+        input = output_read
+      end
+      error_readers << Thread.new do
+        begin
+          error_read.read
+        ensure
+          error_read.close unless error_read.closed?
+        end
+      end
+    end
+
+    inputs_to_close.each { |io| io.close unless io.closed? }
+    processes.each_with_index do |pid, index|
+      _, status = Process.wait2(pid)
+      @statuses[index] = status.exitstatus || 1
+    end
+    @stdout = output_reader ? output_reader.value : ''
+    @stderr = error_readers.map(&:value).join
+    @stdout_target.write(@stdout) if @stdout_target.respond_to?(:write)
+    @stderr_target.write(@stderr) if @stderr_target.respond_to?(:write) && !@stderr.empty?
+    @stdout_target.flush if @stdout_target.respond_to?(:flush)
+    self
+  ensure
+    input.close if input && input != @stdin && input.respond_to?(:close) && !input.closed?
+  end
+
+  private
+
+  def terminal?(io)
+    io.respond_to?(:tty?) && io.tty?
+  end
+
+  def usable_input(input)
+    return input if input.respond_to?(:fileno)
+    reader, writer = IO.pipe
+    Thread.new do
+      writer.write(input.read.to_s)
+      writer.close
+    end
+    reader
+  end
+
+  public
+
+  def returncode
+    @statuses.last || 0
+  end
+
+  def pipecode
+    @statuses.find { |status| status != 0 } || 0
+  end
+end
+
+class ShellPipelineStage
+  def initialize(argv, callable: nil)
+    @argv = argv
+    @callable = callable
+  end
+
+  def spawn(input, output, error)
+    if @callable
+      Process.fork do
+        begin
+          $stdin = input
+          $stdout = output
+          $stderr = error
+          $argv = @argv.drop(1)
+          unless input.tty?
+            data = input.read
+            $stdin = StringIO.new(data)
+            $argv.concat(data.lines(chomp: true))
+          end
+          result = @callable.call(@argv)
+          $stdout.write(result.to_s) if result.is_a?(String) && !result.empty?
+          exit! 0
+        rescue Exception => exception
+          $stderr.puts exception.message
+          exit! 1
+        end
+      end
+    else
+      Process.spawn(*@argv, in: input.fileno, out: output.fileno, err: error.fileno)
+    end
+  end
+end

data/rubsh.gemspec

@@ -2,23 +2,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubsh}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Bretoi"]
   s.date = %q{2010-10-09}
-  s.default_executable = %q{rubsh}
+  s.bindir = %q{bin}
   s.description = %q{A ruby shell}
   s.email = %q{daniel@netwalk.org}
   s.executables = ["rubsh"]
-  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc", "bin/rubsh", "lib/alias.rb", "lib/commands.rb", "lib/prompt.rb", "lib/rub_readline.rb", "lib/rubsh.rb"]
-  s.files = ["CHANGELOG", "README.rdoc", "Rakefile", "bin/rubsh", "lib/alias.rb", "lib/commands.rb", "lib/prompt.rb", "lib/rub_readline.rb", "lib/rubsh.rb", "rubsh.gemspec", "Manifest"]
+  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc", "bin/rubsh", "lib/alias.rb", "lib/commands.rb", "lib/completion.rb", "lib/prompt.rb", "lib/rub_readline.rb", "lib/shell_parser.rb", "lib/shell_pipeline.rb", "lib/rubsh.rb"]
+  s.files = ["CHANGELOG", "README.rdoc", "Rakefile", "bin/rubsh", "lib/alias.rb", "lib/commands.rb", "lib/completion.rb", "lib/prompt.rb", "lib/rub_readline.rb", "lib/shell_parser.rb", "lib/shell_pipeline.rb", "lib/rubsh.rb", "test/rubsh_test.rb", "spec/rubsh_spec.rb", "spec/completion_spec.rb", "rubsh.gemspec"]
   s.homepage = %q{http://github.com/danielb2/rubsh}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rubsh", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{rubsh}
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{A ruby shell}
+  s.add_development_dependency "rspec"
+
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/spec/completion_spec.rb

@@ -0,0 +1,45 @@
+require 'tmpdir'
+require 'rubsh'
+
+RSpec.describe CompletionRegistry do
+  it 'merges stackable nested completion declarations' do
+    registry = described_class.new
+    registry.complete('lb') { subcommand 'cal'; option '-v' }
+    registry.complete('lb') do
+      subcommand 'ls' do
+        option '--long'
+      end
+    end
+    expect(registry.show('lb')).to include('cal', 'ls', '-v')
+    expect(registry.suggestions(['lb'], '')).to include('cal', 'ls', '-v')
+    expect(registry.suggestions(['lb', 'ls'], '--')).to include('--long')
+  end
+
+  it 'erases a command completion tree' do
+    registry = described_class.new
+    registry.complete('lb') { subcommand 'cal' }
+    registry.erase('lb')
+    expect(registry.show('lb')).to eq([])
+  end
+
+  it 'completes subcommands after a trailing space' do
+    Dir.mktmpdir do |directory|
+      shell = Rubsh.new
+      path = File.join(directory, 'lb.rb')
+      File.write(path, "complete 'lb' do\n  subcommand 'cal'\n  subcommand 'ls'\n  subcommand 'add'\nend\n")
+      shell.send(:source, path)
+      allow(Reline).to receive(:line_buffer).and_return('lb ')
+      expect(Reline.completion_proc.call('')).to include('cal', 'ls', 'add')
+    end
+  end
+
+  it 'loads a completion definition when explicitly sourced' do
+    Dir.mktmpdir do |directory|
+      shell = Rubsh.new
+      path = File.join(directory, 'tool.rb')
+      File.write(path, "complete 'tool' do\n  subcommand 'run'\nend\n")
+      shell.send(:source, path)
+      expect(shell.instance_variable_get(:@completions).show('tool')).to include('run')
+    end
+  end
+end

data/spec/rubsh_spec.rb

@@ -0,0 +1,177 @@
+require 'tmpdir'
+require 'rubsh'
+
+RSpec.describe Rubsh do
+  let(:shell) { described_class.new }
+
+  describe ShellParser do
+    it 'preserves quoted and escaped argument boundaries' do
+      pipeline = ShellParser.parse('echo "hello world" escaped\ value | tee out.txt')
+      expect(pipeline.stages.map { |stage| stage.words.map(&:value) }).to eq([
+        ['echo', 'hello world', 'escaped value'], ['tee', 'out.txt']
+      ])
+    end
+
+    it 'represents command substitutions as nested nodes' do
+      pipeline = ShellParser.parse('echo `foo`')
+      expect(pipeline.stages.first.words.last.parts).to eq([ShellParser::Substitution.new('foo')])
+    end
+
+    it 'rejects malformed pipelines' do
+      expect { ShellParser.parse('echo |') }.to raise_error(SyntaxError)
+      expect { ShellParser.parse('echo `foo') }.to raise_error(SyntaxError)
+    end
+  end
+
+  it 'reports an invalid definition pipeline without raising' do
+    expect { expect(shell.parse_cmd('def merp; echo blah; end | merp')).to eq(2) }
+      .to output(/cannot pipe a function definition/).to_stderr
+  end
+
+  it 'runs a Ruby function through backtick substitution and tee' do
+    Dir.mktmpdir do |directory|
+      Dir.chdir(directory) do
+        shell.parse_cmd('def foo')
+        shell.parse_cmd('return "ok"')
+        shell.parse_cmd('end')
+        shell.parse_cmd('echo `foo` | tee out.txt')
+        expect(File.read('out.txt')).to eq("ok\n")
+      end
+    end
+  end
+
+  it 'runs a one-line shell command function with a trailing semicolon' do
+    Dir.mktmpdir do |directory|
+      Dir.chdir(directory) do
+        shell.parse_cmd('def merp; echo blah; end;')
+        expect { shell.parse_cmd('merp') }.to output("blah\n").to_stdout
+      end
+    end
+  end
+
+  it 'runs a function and following command on the same input line' do
+    expect { shell.parse_cmd('def merp; echo blah; end; merp') }
+      .to output("blah\n").to_stdout
+  end
+
+  it 'runs a shell command from inside a Ruby function' do
+    Dir.mktmpdir do |directory|
+      Dir.chdir(directory) do
+        File.write('sample', '')
+        shell.parse_cmd('def merp')
+        shell.parse_cmd('ls')
+        shell.parse_cmd('end')
+        shell.parse_cmd('merp | tee out.txt')
+        expect(File.read('out.txt')).to eq("out.txt\nsample\n")
+      end
+    end
+  end
+
+  it 'keeps cd in the parent shell' do
+    Dir.mktmpdir do |directory|
+      original = Dir.pwd
+      shell.parse_cmd("cd #{directory}")
+      expect(File.realpath(Dir.pwd)).to eq(File.realpath(directory))
+    ensure
+      Dir.chdir(original)
+    end
+  end
+
+  it 'stores aliases without losing their source text' do
+    shell.parse_cmd('alias say echo "hello world"')
+    expect(shell.alias['say']).to eq('echo "hello world"')
+  end
+
+  it 'reports aliases before external commands with type' do
+    shell.parse_cmd('alias ls "eza -l"')
+    expect { shell.parse_cmd('type ls') }.to output("ls is a function with definition\n# Defined via alias\nfunction ls\n  eza -l $argv\nend\n").to_stdout
+  end
+
+  it 'prints the Ruby source for a defined function with type' do
+    shell.parse_cmd('def merp')
+    shell.parse_cmd('ls')
+    shell.parse_cmd('end')
+    expect { shell.parse_cmd('type merp') }.to output(/merp is a function with definition.*def merp.*ls.*end/m).to_stdout
+  end
+
+  it 'saves definitions under the config defs directory' do
+    Dir.mktmpdir do |home|
+      original_home = ENV['HOME']
+      ENV['HOME'] = home
+      shell.parse_cmd('def moo')
+      shell.parse_cmd('puts $argv')
+      shell.parse_cmd('end')
+      expect(shell.parse_cmd('def -s moo')).to eq(0)
+      saved = File.read(File.join(home, '.config', 'rubsh', 'defs', 'moo.rb'))
+      expect(saved).to include("def moo")
+      expect(saved).to include("  puts $argv")
+    ensure
+      ENV['HOME'] = original_home
+    end
+  end
+
+  it 'saves aliases as reloadable function definitions' do
+    Dir.mktmpdir do |home|
+      original_home = ENV['HOME']
+      ENV['HOME'] = home
+      shell.parse_cmd('alias ls "eza -l"')
+      expect(shell.parse_cmd('def -s ls')).to eq(0)
+      path = File.join(home, '.config', 'rubsh', 'defs', 'ls.rb')
+      expect(File.read(path)).to eq("alias ls \"eza -l\"\n")
+      reloaded = Rubsh.new
+      reloaded.source(path)
+      expect(reloaded.alias['ls']).to eq('eza -l')
+    ensure
+      ENV['HOME'] = original_home
+    end
+  end
+
+  it 'edits an unsaved function using the configured editor' do
+    Dir.mktmpdir do |home|
+      original_home = ENV['HOME']
+      original_editor = ENV['EDITOR']
+      ENV['HOME'] = home
+      ENV['EDITOR'] = '/usr/bin/true'
+      expect(shell.parse_cmd('def -e fresh')).to eq(0)
+      expect(File.read(File.join(home, '.config', 'rubsh', 'defs', 'fresh.rb'))).to include('def fresh')
+    ensure
+      ENV['HOME'] = original_home
+      ENV['EDITOR'] = original_editor
+    end
+  end
+
+  it 'sources a saved function file from a shell command' do
+    Dir.mktmpdir do |directory|
+      path = File.join(directory, 'hello.rb')
+      File.write(path, "def hello\n  puts 'hi'\nend\n")
+      expect(shell.parse_cmd("source #{path}")).to eq(0)
+      expect { shell.parse_cmd('hello') }.to output("hi\n").to_stdout
+      expect { shell.parse_cmd('type hello') }.to output(/def hello.*puts 'hi'.*end/m).to_stdout
+
+    end
+  end
+
+
+  it 'evaluates Ruby assignments in the persistent context' do
+    shell.parse_cmd('a = 3')
+    expect(shell.instance_variable_get(:@binding).eval('a')).to eq(3)
+  end
+
+  it 'uses assigned Ruby locals in puts and p expressions' do
+    shell.parse_cmd('a = 3')
+    expect { shell.parse_cmd('puts a') }.to output("3\n").to_stdout
+    expect { shell.parse_cmd('p a') }.to output("3\n").to_stdout
+  end
+
+  it 'uses sh_prompt for the interactive prompt' do
+    shell.parse_cmd('def sh_prompt')
+    shell.parse_cmd('return "custom> "')
+    shell.parse_cmd('end')
+    expect(shell.send(:prompt_text)).to eq('custom> ')
+  end
+
+  it 'expands environment variables as shell values' do
+    expect { shell.parse_cmd('$SHELL') }.to output("#{ENV.fetch('SHELL', '')}\n").to_stdout
+    expect { shell.parse_cmd('puts $SHELL') }.to output("#{ENV.fetch('SHELL', '')}\n").to_stdout
+  end
+end

data/test/rubsh_test.rb

@@ -0,0 +1,45 @@
+require 'minitest/autorun'
+require 'tmpdir'
+require 'stringio'
+require 'rubsh'
+
+class RubshTest < Minitest::Test
+  def setup
+    @shell = Rubsh.new
+  end
+
+  def test_parser_preserves_arguments_and_pipeline
+    pipeline = ShellParser.parse(%q{echo "hello world" escaped\ value | tee out.txt})
+    assert_equal 2, pipeline.stages.length
+    assert_equal %w[echo hello\ world escaped\ value], pipeline.stages.first.words.map(&:value)
+    assert_equal %w[tee out.txt], pipeline.stages.last.words.map(&:value)
+  end
+
+  def test_parser_keeps_nested_substitution
+    pipeline = ShellParser.parse('echo `printf "ok\\n"`')
+    word = pipeline.stages.first.words.last
+    assert_instance_of ShellParser::Substitution, word.parts.first
+  end
+
+  def test_requested_function_pipeline
+    Dir.mktmpdir do |directory|
+      Dir.chdir(directory) do
+        @shell.parse_cmd('def foo')
+        @shell.parse_cmd('return "ok"')
+        @shell.parse_cmd('end')
+        @shell.parse_cmd('echo `foo` | tee out.txt')
+        assert_equal "ok\n", File.read('out.txt')
+      end
+    end
+  end
+
+  def test_cd_changes_parent_context
+    Dir.mktmpdir do |directory|
+      original = Dir.pwd
+      @shell.parse_cmd("cd #{directory}")
+      assert_equal File.realpath(directory), File.realpath(Dir.pwd)
+    ensure
+      Dir.chdir(original)
+    end
+  end
+end