obfusk-util 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ace37fd05ca1a55b9ed7197c9ef69ad8b25b5ebd
-  data.tar.gz: d1f1fd09ce7432c58810fa072358a2b114d138d6
+  metadata.gz: 5bf7375bb3b37224db96e59696194cd81e6a1abc
+  data.tar.gz: d9c148f1ba2b5fefd2e93012ee18a1126a0db3a8
 SHA512:
-  metadata.gz: 48e4a35b37818666e5037dc416b912e2952cdc854eae275b7821a9f14274d921b99db71e47fe7212d47367be6f8e07e8565c57ea100ed4d88eb0217534016a9c
-  data.tar.gz: e0dfe81bb323b6222b408333184edfe287d56aada548352b23bfe6cd2032fd971625aadbb45970d809f56c7b7fe5237c0ef6f04f36b1505f2090d20646fb4b19
+  metadata.gz: 8ee94a5abc89f7cfb162210ea6336cf9dbdc227ef52fb65075a1a126fd5b9bdbda777085a02766d01d551aa09ea8ee26066c1969534098d533c37c59fad4c928
+  data.tar.gz: dfc6216044f4b197ef8c527df107c2743b87f5145c450d46ccc08c0419ab6c2b5f6c71bce3b557058128f937e732855ee223eb9fa344dd2bdaf4d9c84c5d4b8f

data/README.md

@@ -5,7 +5,7 @@
     Date        : 2014-02-20
 
     Copyright   : Copyright (C) 2014  Felix C. Stegerman
-    Version     : v0.4.4
+    Version     : v0.5.0
 
 []: }}}1
 
@@ -197,25 +197,28 @@ end
 ```ruby
 require 'obfusk/util/sh'
 
-Obfusk::Util::sh('echo "$0" ">>$1<<" ">>$FOO<<"',
+Obfusk::Util::sh 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo'
+# stdout: bash >>"one"<< >>foo<<
+
+Obfusk::Util::sh? 'false'
+# => false
+
+Obfusk::Util::sh! 'echo FOO; false'
+# stdout: FOO
+# => RunError
+
+Obfusk::Util::shc('echo "$0" ">>$1<<" ">>$FOO<<"',
   '"one"', 'FOO' => 'foo').stdout
 # => %Q{bash >>"one"<< >>foo<<}
 
-Obfusk::Util::sh('echo step1; false; echo step3',
+Obfusk::Util::shc('echo step1; false; echo step3',
   print: true, exit: true, merge: true).stdout
 # => "+ echo step1\nstep1\n+ false\n"
 
-Obfusk::Util::sh? 'false'
+Obfusk::Util::shc? 'false'
 # => false
 
-Obfusk::Util::sh! 'false'
-# => RunError
-
-Obfusk::Util::sys 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo'
-# stdout: bash >>"one"<< >>foo<<
-
-Obfusk::Util::sys! 'echo FOO; false'
-# stdout: FOO
+Obfusk::Util::shc! 'false'
 # => RunError
 
 ```

data/lib/obfusk/util/sh.rb

@@ -14,8 +14,8 @@ require 'obfusk/util/run'
 # my namespace
 module Obfusk; module Util
 
-  # shell command result
-  class Sh < Struct.new(:cmd, :status, :stdout, :stderr)        # {{{1
+  # common methods for Sh, Shc
+  module ShBase                                                 # {{{1
 
     # was the exitstatus zero?
     def ok?
@@ -32,14 +32,24 @@ module Obfusk; module Util
 
   end                                                           # }}}1
 
+  # shell result
+  class Sh < Struct.new(:cmd, :status)
+    include ShBase
+  end
+
+  # shell capture result
+  class Shc < Struct.new(:cmd, :status, :stdout, :stderr)
+    include ShBase
+  end
+
   # --
 
-  # run a command using bash (w/ arguments) and capture its output;
-  # see also `sys`; uses `capture{2e,3}`
+  # run a command using bash (w/ arguments); see also {shc}; uses
+  # {spawn_w}
   #
   # ```
-  # sh('echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo').stdout
-  # # => %Q{bash >>"one"<< >>foo<<}
+  # sh 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo'
+  # # stdout: bash >>"one"<< >>foo<<
   # ```
   #
   # @param [Hash] args.last
@@ -51,15 +61,11 @@ module Obfusk; module Util
   #   * any other `String` key is added to the `env`
   #   * any other `Symbol` key is passed as an option to `capture3`
   # @return [Sh]
-  def self.sh(cmd, *args)                                       # {{{1
-    c = _sh cmd, args
-    if c[:merge]
-      stderr = nil; stdout, status = capture2e(*c[:cmd], c[:opts])
-    else
-      stdout, stderr, status = capture3(*c[:cmd], c[:opts])
-    end
-    Sh.new c[:cmd], status, stdout, stderr
-  end                                                           # }}}1
+  def self.sh(cmd, *args)
+    c   = _sh cmd, args; o = c[:opts]
+    o_  = c[:merge] ? o.merge(:err => o[:out] ? [:child, :out] : :out) : o
+    Sh.new c[:cmd], spawn_w(*c[:cmd], o_)
+  end
 
   # `sh(...).ok?`
   def self.sh?(cmd, *args)
@@ -73,30 +79,33 @@ module Obfusk; module Util
 
   # --
 
-  # run a command using bash (w/ arguments); takes the same arguments
-  # as `sh`; uses `spawn_w`
+  # run a command using bash (w/ arguments) and capture its stdout and
+  # stderr; accepts the same arguments as {sh}; uses `capture{2e,3}`
   #
   # ```
-  # sys 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo'
-  # # stdout: bash >>"one"<< >>foo<<
+  # shc('echo "$0" ">>$1<<" ">>$FOO<<"', '"one"', 'FOO' => 'foo').stdout
+  # # => %Q{bash >>"one"<< >>foo<<}
   # ```
   #
-  # @return [Process::Status]
-  def self.sys(cmd, *args)
-    c   = _sh cmd, args; o = c[:opts]
-    o_  = c[:merge] ? o.merge(:err => o[:out] ? [:child, :out] : :out) : o
-    spawn_w(*c[:cmd], o_)
-  end
+  # @return [Shc]
+  def self.shc(cmd, *args)                                       # {{{1
+    c = _sh cmd, args
+    if c[:merge]
+      stderr = nil; stdout, status = capture2e(*c[:cmd], c[:opts])
+    else
+      stdout, stderr, status = capture3(*c[:cmd], c[:opts])
+    end
+    Shc.new c[:cmd], status, stdout, stderr
+  end                                                           # }}}1
 
-  # `sys(...).exitstatus == 0`
-  def self.sys?(cmd, *args)
-    sys(cmd, *args).exitstatus == 0
+  # `shc(...).ok?`
+  def self.shc?(cmd, *args)
+    shc(cmd, *args).ok?
   end
 
-  # `sys(...)`
-  # @raise RunError when exitstatus non-zero
-  def self.sys!(cmd, *args)
-    sys(cmd, *args).tap { |s| chk_exitstatus cmd, s.exitstatus }
+  # `shc(...).ok!`
+  def self.shc!(cmd, *args)
+    shc(cmd, *args).ok!
   end
 
   # --
@@ -118,19 +127,19 @@ module Obfusk; module Util
 
   # --
 
-  # ohai + sys; requires `obfusk/util/message`
-  def self.osys(*args)
-    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; sys(*args)
+  # ohai + shc; requires `obfusk/util/message`
+  def self.oshc(*args)
+    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; shc(*args)
   end
 
-  # ohai + sys?; requires `obfusk/util/message`
-  def self.osys?(*args)
-    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; sys?(*args)
+  # ohai + shc?; requires `obfusk/util/message`
+  def self.oshc?(*args)
+    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; shc?(*args)
   end
 
-  # ohai + sys!; requires `obfusk/util/message`
-  def self.osys!(*args)
-    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; sys!(*args)
+  # ohai + shc!; requires `obfusk/util/message`
+  def self.oshc!(*args)
+    ::Obfusk::Util.ohai _spawn_rm_opts(args)*' '; shc!(*args)
   end
 
   # --

data/lib/obfusk/util/version.rb

@@ -1,5 +1,5 @@
 # my namespace
 module Obfusk; module Util
-  VERSION = '0.4.4'
+  VERSION = '0.5.0'
   DATE    = '2014-02-20'
 end; end

data/spec/obfusk/util/sh_spec.rb

@@ -17,87 +17,100 @@ describe 'obfusk/util/sh' do
 
   context 'sh (1)' do                                           # {{{1
     it 'echoes w/ args and env' do
-      r = ou.sh 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"',
-        'FOO' => 'foo'
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq(%Q{bash >>"one"<< >>foo<<\n})
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"',
+        'FOO' => 'foo', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq(%Q{bash >>"one"<< >>foo<<\n})
     end
     it 'works w/ print, exit, and merge' do
-      r = ou.sh 'echo step1; false; echo step3', print: true, exit: true,
-        merge: true
-      expect(r.ok?).to eq(false)
-      expect(r.stdout).to eq("+ echo step1\nstep1\n+ false\n")
-      expect(r.stderr).to eq(nil)
+      r, w = IO.pipe
+      res = ou.sh 'echo step1; false; echo step3', print: true, exit: true,
+        merge: true, out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(false)
+      expect(x).to eq("+ echo step1\nstep1\n+ false\n")
     end
     it 'outputs pwd w/ arg' do
-      r = ou.sh 'cd "$1"; pwd', '/'
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("/\n")
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'cd "$1"; pwd', '/', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq("/\n")
     end
     it 'outputs pwd w/ :chdir' do
-      r = ou.sh 'pwd', chdir: '/'
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("/\n")
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'pwd', chdir: '/', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq("/\n")
     end
   end                                                           # }}}1
 
   context 'sh (2)' do                                           # {{{1
     it 'prints to stderr w/ print/-x' do
-      r = ou.sh 'echo FOO; echo BAR', print: true
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("FOO\nBAR\n")
-      expect(r.stderr).to eq("+ echo FOO\n+ echo BAR\n")
+      ro, wo = IO.pipe; re, we = IO.pipe
+      res = ou.sh 'echo FOO; echo BAR', print: true, out: wo, err: we
+      wo.close; o = ro.read; ro.close
+      we.close; e = re.read; re.close
+      expect(res.ok?).to eq(true)
+      expect(o).to eq("FOO\nBAR\n")
+      expect(e).to eq("+ echo FOO\n+ echo BAR\n")
     end
     it 'ignores false w/o exit/-e' do
-      r = ou.sh 'echo FOO; false; echo BAR'
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("FOO\nBAR\n")
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'echo FOO; false; echo BAR', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq("FOO\nBAR\n")
     end
     it 'stops at false w/ exit/-e' do
-      r = ou.sh 'echo FOO; false; echo BAR', exit: true
-      expect(r.ok?).to eq(false)
-      expect(r.stdout).to eq("FOO\n")
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'echo FOO; false; echo BAR', exit: true, out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(false)
+      expect(x).to eq("FOO\n")
     end
     it 'merges stdout and stderr w/ merge' do
-      r = ou.sh 'echo FOO; echo BAR >&2; echo BAZ', merge: true
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("FOO\nBAR\nBAZ\n")
-      expect(r.stderr).to eq(nil)
+      r, w = IO.pipe
+      res = ou.sh 'echo FOO; echo BAR >&2; echo BAZ', merge: true, out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq("FOO\nBAR\nBAZ\n")
     end
     it 'merges env w/ string keys' do
-      r = ou.sh 'echo $FOO; echo $BAR',
-        env: { 'FOO' => 'no', 'BAR' => 'bar' }, 'FOO' => 'yes'
-      expect(r.ok?).to eq(true)
-      expect(r.stdout).to eq("yes\nbar\n")
-      expect(r.stderr).to eq('')
+      r, w = IO.pipe
+      res = ou.sh 'echo $FOO; echo $BAR',
+        env: { 'FOO' => 'no', 'BAR' => 'bar' }, 'FOO' => 'yes', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(true)
+      expect(x).to eq("yes\nbar\n")
     end
   end                                                           # }}}1
 
   context 'sh (3)' do                                           # {{{1
     it 'false => ok? returns false and ok! raises' do
-      r = ou.sh 'false'
-      expect(r.ok?).to eq(false)
-      expect(r.status.exitstatus).to eq(1)
-      expect { r.ok! } .to \
+      r, w = IO.pipe
+      res = ou.sh 'false', out: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(false)
+      expect(res.status.exitstatus).to eq(1)
+      expect { res.ok! } .to \
         raise_error(ou::RunError, /command returned non-zero/)
-      expect(r.stdout).to eq('')
-      expect(r.stderr).to eq('')
+      expect(x).to eq('')
     end
     it 'fails w/ message on stderr w/ NONEXISTENT' do
-      r = ou.sh 'NONEXISTENT'
-      expect(r.ok?).to eq(false)
-      expect(r.status.exitstatus).to eq(127)
-      expect(r.stdout).to eq('')
-      expect(r.stderr).to eq("bash: NONEXISTENT: command not found\n")
+      r, w = IO.pipe
+      res = ou.sh 'NONEXISTENT', err: w
+      w.close; x = r.read; r.close
+      expect(res.ok?).to eq(false)
+      expect(res.status.exitstatus).to eq(127)
+      expect(x).to eq("bash: NONEXISTENT: command not found\n")
     end
     it 'fails w/ RunError w/ shell NONEXISTENT' do
       expect { ou.sh 'irrelevant', shell: 'NONEXISTENT' } .to \
-        raise_error(ou::RunError, /failed to capture3 command/)
+        raise_error(ou::RunError, /failed to spawn command/)
     end
   end                                                           # }}}1
 
@@ -120,109 +133,107 @@ describe 'obfusk/util/sh' do
     end
   end                                                           # }}}1
 
-  context 'sys (1)' do                                          # {{{1
+  context 'shc (1)' do                                          # {{{1
     it 'echoes w/ args and env' do
-      r, w = IO.pipe
-      res = ou.sys 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"',
-        'FOO' => 'foo', out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq(%Q{bash >>"one"<< >>foo<<\n})
+      r = ou.shc 'echo "$0" ">>$1<<" ">>$FOO<<"', '"one"',
+        'FOO' => 'foo'
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq(%Q{bash >>"one"<< >>foo<<\n})
+      expect(r.stderr).to eq('')
     end
     it 'works w/ print, exit, and merge' do
-      r, w = IO.pipe
-      res = ou.sys 'echo step1; false; echo step3', print: true, exit: true,
-        merge: true, out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to_not eq(0)
-      expect(x).to eq("+ echo step1\nstep1\n+ false\n")
+      r = ou.shc 'echo step1; false; echo step3', print: true, exit: true,
+        merge: true
+      expect(r.ok?).to eq(false)
+      expect(r.stdout).to eq("+ echo step1\nstep1\n+ false\n")
+      expect(r.stderr).to eq(nil)
     end
     it 'outputs pwd w/ arg' do
-      r, w = IO.pipe
-      res = ou.sys 'cd "$1"; pwd', '/', out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq("/\n")
+      r = ou.shc 'cd "$1"; pwd', '/'
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("/\n")
+      expect(r.stderr).to eq('')
     end
     it 'outputs pwd w/ :chdir' do
-      r, w = IO.pipe
-      res = ou.sys 'pwd', chdir: '/', out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq("/\n")
+      r = ou.shc 'pwd', chdir: '/'
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("/\n")
+      expect(r.stderr).to eq('')
     end
   end                                                           # }}}1
 
-  context 'sys (2)' do                                          # {{{1
+  context 'shc (2)' do                                          # {{{1
     it 'prints to stderr w/ print/-x' do
-      ro, wo = IO.pipe; re, we = IO.pipe
-      res = ou.sys 'echo FOO; echo BAR', print: true, out: wo, err: we
-      wo.close; o = ro.read; ro.close
-      we.close; e = re.read; re.close
-      expect(res.exitstatus).to eq(0)
-      expect(o).to eq("FOO\nBAR\n")
-      expect(e).to eq("+ echo FOO\n+ echo BAR\n")
+      r = ou.shc 'echo FOO; echo BAR', print: true
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("FOO\nBAR\n")
+      expect(r.stderr).to eq("+ echo FOO\n+ echo BAR\n")
     end
     it 'ignores false w/o exit/-e' do
-      r, w = IO.pipe
-      res = ou.sys 'echo FOO; false; echo BAR', out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq("FOO\nBAR\n")
+      r = ou.shc 'echo FOO; false; echo BAR'
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("FOO\nBAR\n")
+      expect(r.stderr).to eq('')
     end
     it 'stops at false w/ exit/-e' do
-      r, w = IO.pipe
-      res = ou.sys 'echo FOO; false; echo BAR', exit: true, out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to_not eq(0)
-      expect(x).to eq("FOO\n")
+      r = ou.shc 'echo FOO; false; echo BAR', exit: true
+      expect(r.ok?).to eq(false)
+      expect(r.stdout).to eq("FOO\n")
+      expect(r.stderr).to eq('')
     end
     it 'merges stdout and stderr w/ merge' do
-      r, w = IO.pipe
-      res = ou.sys 'echo FOO; echo BAR >&2; echo BAZ', merge: true, out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq("FOO\nBAR\nBAZ\n")
+      r = ou.shc 'echo FOO; echo BAR >&2; echo BAZ', merge: true
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("FOO\nBAR\nBAZ\n")
+      expect(r.stderr).to eq(nil)
     end
     it 'merges env w/ string keys' do
-      r, w = IO.pipe
-      res = ou.sys 'echo $FOO; echo $BAR',
-        env: { 'FOO' => 'no', 'BAR' => 'bar' }, 'FOO' => 'yes', out: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(0)
-      expect(x).to eq("yes\nbar\n")
+      r = ou.shc 'echo $FOO; echo $BAR',
+        env: { 'FOO' => 'no', 'BAR' => 'bar' }, 'FOO' => 'yes'
+      expect(r.ok?).to eq(true)
+      expect(r.stdout).to eq("yes\nbar\n")
+      expect(r.stderr).to eq('')
     end
   end                                                           # }}}1
 
-  context 'sys (3)' do                                          # {{{1
+  context 'shc (3)' do                                          # {{{1
+    it 'false => ok? returns false and ok! raises' do
+      r = ou.shc 'false'
+      expect(r.ok?).to eq(false)
+      expect(r.status.exitstatus).to eq(1)
+      expect { r.ok! } .to \
+        raise_error(ou::RunError, /command returned non-zero/)
+      expect(r.stdout).to eq('')
+      expect(r.stderr).to eq('')
+    end
     it 'fails w/ message on stderr w/ NONEXISTENT' do
-      r, w = IO.pipe
-      res = ou.sys 'NONEXISTENT', err: w
-      w.close; x = r.read; r.close
-      expect(res.exitstatus).to eq(127)
-      expect(x).to eq("bash: NONEXISTENT: command not found\n")
+      r = ou.shc 'NONEXISTENT'
+      expect(r.ok?).to eq(false)
+      expect(r.status.exitstatus).to eq(127)
+      expect(r.stdout).to eq('')
+      expect(r.stderr).to eq("bash: NONEXISTENT: command not found\n")
     end
     it 'fails w/ RunError w/ shell NONEXISTENT' do
-      expect { ou.sys 'irrelevant', shell: 'NONEXISTENT' } .to \
-        raise_error(ou::RunError, /failed to spawn command/)
+      expect { ou.shc 'irrelevant', shell: 'NONEXISTENT' } .to \
+        raise_error(ou::RunError, /failed to capture3 command/)
     end
   end                                                           # }}}1
 
-  context 'sys?' do                                             # {{{1
+  context 'shc?' do                                             # {{{1
     it 'true => true' do
-      expect(ou.sys? 'true').to eq(true)
+      expect(ou.shc? 'true').to eq(true)
     end
     it 'false => false' do
-      expect(ou.sys? 'false').to eq(false)
+      expect(ou.shc? 'false').to eq(false)
     end
   end                                                           # }}}1
 
-  context 'sys!' do                                             # {{{1
-    it 'true => Process::Status' do
-      expect( ou.sys! 'true' ).to be_an_instance_of(Process::Status)
+  context 'shc!' do                                             # {{{1
+    it 'true => Shc' do
+      expect( ou.shc! 'true' ).to be_an_instance_of(ou::Shc)
     end
     it 'false => RunError' do
-      expect { ou.sys! 'false' } .to \
+      expect { ou.shc! 'false' } .to \
         raise_error(ou::RunError, /command returned non-zero/)
     end
   end                                                           # }}}1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obfusk-util
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Felix C. Stegerman