easysh 0.1.0

data/lib/easysh.rb

@@ -0,0 +1,185 @@
+# EasySH examples:
+# 
+#  sh = EasySH.new
+#
+#  # basic usage
+#  puts sh.ls
+#  puts sh['/bin/ls']
+#
+#  # command parameters
+#  puts sh.ls['/bin']._l
+#  puts sh.ls._l '/bin'
+#  puts sh.ls('/bin', :l, :color => :always)
+#  puts sh['/bin/ls', '-l', :color => :always]
+#
+#  # enumerable
+#  sh.ls.max
+#  sh.ls.sort
+#  sh.ls.chars.to_a.sample(5)
+#  sh.cat('/dev/urandom').bytes.first(10)
+#  sh.ls._l.map{|l| l.split}
+#  sh.ps._e._o('euser,comm').map(&:split).group_by(&:first)
+#  
+#  # chaining commands
+#  sudo = sh.sudo
+#  tail = sh.tail
+#  sudo[tail._f '/var/log/everything.log'].lines { |l| puts l.upcase }
+#  sudo.tail._f '/var/log/everything.log' do |l| puts l.upcase end
+#
+#  lab = sh.ssh['lab'] # or, sh.ssh.lab
+#  puts lab.ls._l '/bin', color: :always
+#  
+#  # redirects
+#  puts sh.echo('hello') > '/tmp/test'
+#  puts sh.echo 'hello', 1 => '/tmp/stdout', 2 => '/tmp/stderr'
+#  puts sh.cat < '/tmp/test'
+#  puts sh.cat 0 => '/tmp/fffff'
+#
+#  # pipes
+#  puts sh.man('ls') | sh.tail(n: 30) | sh.head(:n, 4)
+#
+#  grep   = sh['grep']
+#  filter = grep['problem'] | grep._v['bugs']
+#  puts sh.man.ls | filter
+#
+#  kat = sh.cat
+#  puts kat['/tmp/foo'] | (kat | kat | kat.|(kat) | (kat | kat) | (kat | kat))
+#
+#  # exit status
+#  p = sh.which('bash')
+#  puts p
+#  p.exitstatus        # => #<Process::Status: pid 5931 exit 0>
+#  p = sh.which.nonexists
+#  puts p
+#  p.exitstatus        # => #<Process::Status: pid 6156 exit 1>
+#
+#
+#  # instant mode
+#  # tired with 'puts' and 'to_s' in REPL? just set instant = true
+#  # [2] pry(main)> sh.instant = false; sh.uptime
+#  # => #<EasySH: uptime>
+#  # [3] pry(main)> sh.instant = true; sh.uptime
+#  # =>  22:14:23 up 1 day,  4:02, 12 users,  load average: 0.69, 0.65, 0.67
+#  # [4] pry(main)> sh = EasySH.instant; sh.uname
+#  # =>  Linux
+# 
+#
+class EasySH < Struct.new(:cmd, :opt, :chain, :instant)
+  include Enumerable
+
+  attr_reader   :exitstatus
+
+  def method_missing name, *args, &block # :no-doc:
+    begin
+      return super(name, *args, &block)
+    rescue NoMethodError, ArgumentError => ex
+      # continue
+    end
+
+    r = if name.is_a? EasySH
+          self.class.new [*cmd, *name.cmd], Hash[*opt, *name.opt], chain, instant
+        else
+          args = [name.to_s.gsub(/^_+/) {|s| '-' * s.size}, *args]
+          *args, opt = *args if args.last.is_a?(Hash) && args.last.keys.find{|k| k.is_a? Integer}
+          args = args.map do |a|
+            case a
+            when Symbol
+              "-#{a.length > 1 ? '-' : ''}#{a}"
+            when Hash
+              a.map { |k,v| k.length > 1 ? "--#{k}=#{v}" : "-#{k} #{v}" }
+            else
+              a.to_s
+            end
+          end.flatten
+          self.class.new [*cmd, *args], Hash[[*self.opt, *opt]], chain, instant
+        end
+    block ? r.each(&block) : r
+  end
+
+  def to_a;           each.to_a; end
+  def to_s(n = "\n"); cmd ? to_a.join(n) : ''; end
+
+  def inspect
+    instant ? to_s : "#<#{self.class}: #{([*chain, [cmd]]).map(&:first).map {|c| c && c.join(' ')}.compact.join(' | ')}>"
+  end
+
+  def |(sh, &block)
+    raise TypeError.new("EasySH expected, got #{sh.inspect}") unless sh.is_a? EasySH
+    self.class.new sh.cmd, sh.opt, [*chain, cmd && [cmd, opt || {}], *sh.chain].compact, instant
+  end
+
+  def < path; self.opt[0] = path; self; end
+  def > path; self.opt[1] = path; self; end
+
+  def to_io
+    return unless cmd
+
+    cur_opt    = opt.clone
+    cur_chain  = (chain || []) + [[cmd, cur_opt]]
+    pipes      = cur_chain.map { IO.pipe }
+    n          = pipes.size
+    cur_opt[0] = pipes[n-1][0] if n > 1
+    lpid, lopt = nil
+    pids       = []
+
+    begin
+      cur_chain.reverse.each_with_index do |cmd_opt, i|
+        i      = n - 1 - i
+        c, o   = *cmd_opt
+        o      = o.clone
+        o[1]   = nil           if i < n - 1
+        o[1] ||= pipes[i][1]
+        o[0]   = pipes[i-1][0] if i > 0
+        pid = spawn(*c, o)
+        pids << pid
+        lopt, lpid = o, pid    if i == n - 1
+      end
+
+      if lopt[1] == pipes[n-1][1]
+        rfd = pipes[n-1][0]
+        (pipes.flatten-[rfd]).each { |io| io.close unless io.closed?  }
+        yield rfd
+      end
+    ensure
+      pipes.flatten.each { |io| io.close unless io.closed? }
+      @exitstatus = Process.wait2(lpid)[-1] rescue nil
+      ['TERM', 'KILL'].each { |sig| Process.kill sig, *pids rescue nil }
+      Process.waitall rescue nil
+    end
+  end
+
+  def each_line
+    return to_enum(:each_line) unless block_given?
+    to_io { |i| while l = i.gets; yield l.chomp; end }
+  end
+
+  def each_char
+    return to_enum(:each_char) unless block_given?
+    to_io { |i| while c = i.getc; yield c; end }
+  end
+
+  def each_byte
+    return to_enum(:each_byte) unless block_given?
+    to_io { |i| while b = i.getbyte; yield b; end }
+  end
+
+  alias :call    :method_missing
+  alias :[]      :method_missing
+  alias :to_ary  :to_a
+  alias :lines   :each_line
+  alias :each    :each_line
+  alias :lines   :each_line
+  alias :chars   :each_char
+  alias :bytes   :each_byte
+  alias :read    :to_s
+  alias :!       :to_s
+
+  def pretty_print(q)
+    q.text self.inspect
+  end
+
+  def self.instant
+    new(nil, {}, [], true)
+  end
+end
+

data/test/test_easysh.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require 'easysh'
+require 'fileutils'
+require 'tmpdir'
+
+class EasySHTest < Test::Unit::TestCase
+
+  def sh; @sh ||= EasySH.new; end
+
+  def with_tmpfile(content = [*0..5].join("\n"))
+    tmppath = File.join(Dir.tmpdir, 'test.txt')
+    begin
+      File.open(tmppath, 'w') { |f| f.write content }
+      yield tmppath, content
+    ensure
+      FileUtils.rm_f tmppath
+    end
+  end
+
+  def fd_count
+    Dir['/proc/self/fd/*'].count
+  end
+
+  def assert_fd_count_equal
+    count = fd_count
+    yield
+    assert_equal fd_count, count
+  end
+
+  def test_execute
+    with_tmpfile do |tmppath, content|
+      assert_equal sh.cat(tmppath).to_s, content
+      assert_equal sh.cat[tmppath].to_s, content
+      assert_equal sh['cat', tmppath].to_s, content
+      kat = sh.cat[tmppath]
+      assert_equal kat.to_s, content
+    end
+  end
+
+  def test_enumerator
+    with_tmpfile [*10..25].join("\n") do |tmppath, content|
+      kat = sh.cat
+      kat_t = kat[tmppath]
+      assert_equal kat[tmppath].min, '10'
+      assert_equal kat_t.max, '25'
+
+      en  = kat_t.each
+      assert_equal en.min, '10'
+      assert_equal en.max, '25'
+
+      assert_equal kat_t.chars.min, "\n"
+      assert_equal kat_t.bytes.min, "\n".ord
+    end
+  end
+
+  def test_options
+    with_tmpfile do |tmppath|
+      assert_include sh.ls._l(tmppath).to_s, '-'
+      assert_equal sh.ls._l(tmppath).read, sh.ls(:l)[tmppath].to_s
+      assert_equal sh.ls._l(tmppath).to_s, sh.ls['-l', tmppath].read
+    end
+  end
+
+  def test_pipes
+    kat = sh.cat
+
+    with_tmpfile do |tmppath, content|
+      assert_fd_count_equal do
+        assert_equal kat[tmppath].to_s, content
+        assert_equal (kat[tmppath] | kat | kat | kat | kat | kat | kat | kat | kat | kat).to_s, content
+        assert_equal (kat[tmppath] | kat | (kat | (kat | kat | kat) | kat | kat) | kat | kat).to_s, content
+      end
+    end
+  end
+
+  def test_broken_pipes
+    kat = sh.cat
+    assert_fd_count_equal do
+      assert_equal (sh.echo('hello') | kat | sh.false | kat | kat).read.empty?, true
+    end
+    assert_raise(TypeError) { sh.echo('hello') | 'abc' }
+  end
+
+  def test_instant
+    kat = sh.cat
+    kat.instant = true
+
+    with_tmpfile do |tmppath, content|
+      assert_fd_count_equal do
+        assert_equal kat[tmppath].inspect, content
+      end
+    end
+  end
+
+  def test_redirects
+    kat = sh.cat
+    with_tmpfile do |tmppath, content|
+      assert_fd_count_equal do
+        assert_equal ((kat < tmppath) | kat).to_s, content
+        ((sh.echo('hello') | kat) > tmppath).!
+        assert_equal File.read(tmppath).chomp, 'hello'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: easysh
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Wu Jun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-17 00:00:00.000000000 Z
+dependencies: []
+description: Synatactic sugars about shell executables, redirects and pipes
+email: quark@zju.edu.cn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/easysh.rb
+- test/test_easysh.rb
+homepage: https://github.com/quark-zju/easyshell
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Make shell task easier for ruby script.
+test_files:
+- test/test_easysh.rb
+has_rdoc: