easysh 0.1.1 → 0.1.2

data/lib/easysh.rb

@@ -1,67 +1,177 @@
-# EasySH examples:
+# 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.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.status        # => #<Process::Status: pid 5931 exit 0>
-#  p = sh.which.nonexists
-#  puts p
-#  p.status        # => #<Process::Status: pid 6156 exit 1>
-#
+# Basic usage:
+# 
+#   require 'easysh'
+#   sh = EasySH.instant;
+#   
+#   sh.ls            # ls
+#   sh['/bin/ls']    # /bin/ls
+# 
+# EasySH automatically convert method names, symbols, hashes to meaningful parameters:
+# 
+# * `_method` will be converted to `-method`
+# * `__method` will be converted to `--method`
+# * `:symbol` will be converted to `--symbol`
+# * `:s` will be converted to `-s`
+# * `{:a => '1', :long => 2}` will be converted to `-a 1`, `--long=2`
+# * strings will be left untouched.
 #
-#  # 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
+# Examples:
+# 
+#   sh.ls('/bin')._l                 # ls /bin -l
+#   sh.ls._l '/bin'                  # ls -l /bin
+#   sh.ls._l '/bin', color: 'always' # ls /bin -l --color=always
+# 
+# EasySH supports method chaining and `[params]`, `method(params)`, just write in any form as you like:
+# 
+#   sh['ls', '-l', :color => :always]
+#   sh.ls '/bin', :l, :color => :always
+#   sh.ls('/bin')['-l', :color => :always]
+#   sh.ls('/bin')._l(:color => :always)
+#   sh.ls._l(:color => :always)['/bin']
+#   sh.ls('/bin', :color => :always)._l
+# 
+# You can save command with parameters to variables for later use:
+# 
+#   myls = sh.ls._l :color => :always;
+#   myls['/bin']  # note: myls '/bin' will not work since myls is an object, not a method
+# 
+# Commands can also be chained freely:
+# 
+#   sudo = sh.sudo;
+#   sudo.whoami
+#   
+#   lab = sh.ssh.lab;      # or: sh.ssh 'lab', sh.ssh['lab'], sh.ssh('lab')
+#   lab.ls._l '/bin'       # ssh lab ls -l /bin
+# 
+# You can pass arrays or EasySH objects(without pipes) as arguments to another EasySH object:
+# 
+#   cmd    = sh.ifconfig.eth0;
+#   opt    = ['mtu', 1440]
+#   sudo[cmd].up           # sudo ifconfig eth0 up
+#   sudo[cmd, opt].up      # sudo ifconfig eth0 up mtu 1440
+#   # sudo[cmd | sh.cat]   # Error: EasySH objects with pipes are not allowed here.
+# 
+# EasySH makes full use of Ruby's Enumerable. `each_line` (`lines`), `each_char` (`chars`), `each_byte` (`bytes`) are available like string. For convenience, `each` is an alias of `each_line`.
+# 
+# Use Enumerable for simple or complex tasks:
+# 
+#   sh.ls.max
+#   sh.ls.sort
+#   sh.ls.chars.to_a.sample(5)                               # pick 5 chars randomly from `ls` output
+#   sh.ps._e._o('euser,comm').map(&:split).group_by(&:first) # group process names by user name
+# 
+# EasySH handles endless stream correctly:
+# 
+#   sh.cat('/dev/urandom').bytes.first(10)
+#   sudo[sh.tail._f '/var/log/everything.log'].lines { |l| puts l.upcase }
+# 
+# You can even omit `lines` or `each` sometimes:
+# 
+#   sh.cat { |l| puts l.upcase }
+#   sudo.tail._f '/var/log/everything.log' do |l| puts l.upcase end
+# 
+# By not passing a block, you can use external iterator: (Note: in this case, make sure that the iteration does reach the end, otherwise background processes do not exit)
+# 
+#   iter = sh.ls('/sys/fs').lines
+#   iter.next             # 'btrfs'
+#   iter.next             # 'cgroup'
+#   iter.next             # 'ext4'
+#   iter.next             # 'fuse'
+#   iter.next             # StopIteration
+# 
+# Redirects
+# ---------
+# 
+# Use `<` or `>` (Note: only one input redirect and one output redirect is supported currently):
 # 
+#   sh.echo('hello') > '/tmp/test'
+#   sh.cat < '/tmp/test'
+#   sh.cat < '/tmp/abc' > '/tmp/def'
+# 
+# You can also associate file descriptor to file directly by using fd numbers => filename Hash (Note: for more information, see Process.spawn. EasySH will distinct Hash parameters from Hash redirects by
+# checking if the Hash has any numeric key):
+# 
+#   sh.echo 'hello', 1 => '/tmp/stdout', 2 => '/tmp/stderr'
+#   sh.cat 0 => '/tmp/test'
+# 
+# Pipes
+# -----
+# 
+# Use `|` (Note: redirects except the rightmost output and leftmost input will be ignored):
+# 
+#   (sh.cat | sh.head(n: 5)).each { |l| puts l.upcase }
+#   sh.man('ls') | sh.tail(n: 30) | sh.head(:n, 4)       # man ls | tail -n 30 | head -n 4
+#   (sh.cat < '/tmp/abc') | sh.cat | sh.cat > '/tmp/def' # cat < /tmp/abc | cat | cat > /tmp/def
+# 
+# EasySH objects connected with pipes can be saved for later use:
+# 
+#   grep   = sh['grep'];   # sh.grep does not work because grep is provided by Enumerable
+#   filter = grep['problem'] | grep._v['bugs'];
+#   sh.man.ls | filter
+# 
+# Since EasySH does some lazy evaluation. You can add parentheses in anywhere in any order:
+# 
+#   kat = sh.cat;
+#   kat['/tmp/foo'] | (kat | (kat | (kat | kat)) | (kat | kat) | (kat | kat))
+# 
+# Exit status
+# -----------
+# 
+# Use `exitcode` or `to_i` to get exitcode directly:
+# 
+#   sh.true.exitcode   # => 0
+#   sh.false.to_i      # => 1
+# 
+# `successful?` is `exitcode == 0` and `failed?` is `exitcode != 0`:
+# 
+#   grep = sh['grep', :q];
+#   (sh.echo.hello | grep['world']).failed?     # => true
+#   (sh.echo.world | grep['world']).successful? # => true
+# 
+# Use `status` method to get a Process::Status object about last run status:
+# 
+#   p = sh.which('bash')
+#   p.status        # => #<Process::Status: pid 5931 exit 0>
+#   p = sh.which.nonexists
+#   p.status        # => #<Process::Status: pid 6156 exit 1>
+# 
+# More sugars
+# -----------
+# 
+# An EasySH object behaves like an Array or a String sometimes.
+# 
+# If you pass arguments like: `[int]`, `[int, int]`, `[range]`; `[regex]`, `[regex, int]`, then `to_a` or `to_s` will be automatically called:
+# 
+#   # like Array
+#   sh.echo("Line 1\nLine 2\nLine 3")[1]    # => "Line 2"
+#   sh.echo("Line 1\nLine 2\nLine 3")[-1]   # => "Line 3"
+#   sh.echo("Line 1\nLine 2\nLine 3")[0, 2] # => ["Line 1", "Line 2"]
+#   sh.echo("Line 1\nLine 2\nLine 3")[1..2] # => ["Line 2", "Line 3"]
+#   
+#   # like String
+#   sh.echo("Hello world\nThis is a test")[/T.*$/]            # => "This is a test"
+#   sh.echo("Hello world\nThis is a test")[/T.* ([^ ]*)$/, 1] # => "test"
+# 
+# Instant mode
+# ------------
+# EasySH object with `instant = true` will execute command when `inspect` is called, which is useful in REPL environment like pry or irb.
+# 
+# If you like traditional `inspect` behavior, you can create the `sh` object using:
+# 
+#   sh = EasySH.new
+# 
+# or set `instant` to false:
+# 
+#   sh.instant = false
+# 
+# With `instant = false`, you need additional `to_s` or `to_a` or `to_i` etc. to get command executed:
+# 
+#   [1] pry(main)> sh = EasySH.new; sh.uname
+#   => #<EasySH: uname>
+#   [2] pry(main)> sh.uname.to_s
+#   => "Linux"
 #
 class EasySH < Struct.new(:cmd, :opt, :chain, :instant) # :no-doc:
   include Enumerable
@@ -75,23 +185,34 @@ class EasySH < Struct.new(:cmd, :opt, :chain, :instant) # :no-doc:
       # continue
     end
 
-    r = if name.is_a? EasySH
-          self.class.new [*cmd, *name.cmd], Hash[*opt, *name.opt], chain, instant
+    args = [name, *args]
+    *args, opt = *args if args.last.is_a?(Hash) && args.last.keys.find{|k| k.is_a? Integer}
+    opt ||= {}
+    args = args.map.with_index do |a, i|
+      case a
+      when Symbol
+        if i == 0
+          a.to_s.gsub(/^_+/) {|s| '-' * s.size}
         else
-          args = [name && name.to_s.gsub(/^_+/) {|s| '-' * s.size}, *args].compact
-          *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.to_s] }
-            else
-              a.to_s
-            end
-          end.flatten
-          self.class.new [*cmd, *args], Hash[[*self.opt, *opt]], chain, instant
+          "-#{a.length > 1 ? '-' : ''}#{a}"
         end
+      when Hash
+        a.map { |k,v| k.length > 1 ? "--#{k}=#{v}" : ["-#{k}", v.to_s] }
+      when EasySH
+        # no Pipe allowed
+        raise ArgumentError.new("#{self.class} argument can not be #{self.class} with pipes") if a.chain && !a.chain.empty?
+        opt = Hash[[*opt, *a.opt]]
+        a.cmd
+      when NilClass
+        nil
+      when Array
+        a
+      else
+        a.to_s
+      end
+    end.compact.flatten
+
+    r = self.class.new [*cmd, *args], Hash[[*self.opt, *opt]], chain, instant
     block ? r.each(&block) : r
   end
 
@@ -99,7 +220,12 @@ class EasySH < Struct.new(:cmd, :opt, :chain, :instant) # :no-doc:
   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(' | ')}>"
+    if instant
+      s = to_s
+      s.empty? ? nil : s
+    else
+      "#<#{self.class}: #{([*chain, [cmd]]).map(&:first).map {|c| c && c.join(' ')}.compact.join(' | ')}>"
+    end
   end
 
   def |(sh, &block)
@@ -107,8 +233,8 @@ class EasySH < Struct.new(:cmd, :opt, :chain, :instant) # :no-doc:
     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 < path; self.opt ||= {}; self.opt[0] = path; self; end
+  def > path; self.opt ||= {}; self.opt[1] = path; self; end
 
   def to_io
     return unless cmd
@@ -188,8 +314,11 @@ class EasySH < Struct.new(:cmd, :opt, :chain, :instant) # :no-doc:
     ! successful?
   end
 
+  def to_ary
+    [*cmd]
+  end
+
   alias :call        :method_missing
-  alias :to_ary      :to_a
   alias :lines       :each_line
   alias :each        :each_line
   alias :lines       :each_line

data/test/test_easysh.rb

@@ -156,4 +156,29 @@ class EasySHTest < Test::Unit::TestCase
     assert_not_equal sh1.status, nil
     assert_equal sh1.exitcode, 0
   end
+
+  def test_sh_in_sh
+    sudo = sh.sudo
+    cmd  = sh.ifconfig.eth0
+
+    assert_equal sudo[cmd].cmd, sh.sudo.ifconfig.eth0.cmd
+    assert_equal sh.sudo(cmd).cmd, sh.sudo.ifconfig.eth0.cmd
+    assert_equal sudo[cmd, 'up'].cmd, sh.sudo.ifconfig.eth0.up.cmd
+    assert_equal sh.sudo(cmd).up.cmd, sh.sudo.ifconfig.eth0.up.cmd
+
+    assert_raise(ArgumentError) { sudo[cmd | cmd] }
+
+    opt = (sh > '/tmp/output')
+    assert_equal sudo.cmd, sudo[opt].cmd
+    assert_not_equal sudo.opt, sudo[opt].opt
+    assert_equal sudo[opt].opt[1], '/tmp/output'
+
+    mtu = sh.mtu['1440']
+    ref_cmd = sh.sudo.ifconfig.eth0.up.mtu['1440'].cmd
+    assert_equal ref_cmd, sh.sudo[cmd].up[mtu].cmd
+    assert_equal ref_cmd, sh.sudo[cmd, 'up', mtu].cmd
+    assert_equal ref_cmd, sh.sudo[cmd, ['up', mtu]].cmd
+    assert_equal ref_cmd, sh.sudo(cmd, 'up', mtu).cmd
+    assert_equal ref_cmd, sh.sudo(cmd, ['up', 'mtu', '1440']).cmd
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easysh
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors: