unix_commander 0.0.2 → 0.1.1

data/README.md

@@ -34,6 +34,17 @@ comm = UnixCommander::Command.new
 comm.cat("file").tail("-n10").grep("'something'").run
 ```
 
+<<<<<<< HEAD
+=======
+You can use redirection too
+```
+require 'unix_commander'
+
+comm = UnixCommander::Command.new
+comm.cat("file").tail("-n10").grep("'something'").out_to("my_file").err_to("/dev/null")
+```
+
+>>>>>>> development
 You don't have to run the commands right away, we can create a command and run it whe we see fit:
 
 ```
@@ -56,7 +67,21 @@ require 'unix_commander'
 comm = UnixCommander::Command.new
 comm.cat("file").tail("-n10").grep("'something'").run_ssh("Batou99","secret","remote_server")
 ```
+<<<<<<< HEAD
+=======
 
+After running a command you can access it output using **out**, **err** or **both**
+```
+require 'unix_commander'
+>>>>>>> development
+
+comm = UnixCommander::Command.new
+comm.cat("file").tail("-n10").grep("'something'").run_ssh("Batou99","secret","remote_server").out
+# Or
+comm.cat("file").tail("-n10").grep("'something'").run_ssh("Batou99","secret","remote_server").err
+# Or
+comm.cat("file").tail("-n10").grep("'something'").run_ssh("Batou99","secret","remote_server").both
+```
 ## Contributing
 
 1. Fork it

data/lib/unix_commander/version.rb

@@ -1,3 +1,3 @@
 module UnixCommander
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/lib/unix_commander.rb

@@ -5,32 +5,69 @@ require 'net/ssh'
 
 module UnixCommander
 
-  class Command
+  # This class encapsulates the output of a command. It also has the logic to run a command locally or remotely
+  class Runner
 
-    attr :cmd
+    # @return [Command]
+    attr :command
 
-    def initialize(_cmd = "")
-      @cmd = _cmd
+
+    # Creates a new Runner
+    # @param _command The command to be run by the runner
+    def initialize(_command)
+      @command = _command
     end
 
-    def method_missing(m, *args, &block)
-      if cmd == ""
-        Command.new("#{m} #{args.join(' ')}".strip)
-      else
-        Command.new("#{cmd} | #{m} #{args.join(' ')}".strip)
-      end
+    # Return a string with the output of the command
+    # If the command has not been run yet it returns an empty string
+    # @return [String] *stdout* and *stderr* of the command (*stdout* \\n *stderr*)
+    def to_s
+      both.join("\n")
     end
 
-    def run
-      @in, @out, @err = Open3.popen3("#{cmd}")
+    # Returns the output (stdout) of the command
+    # If the command has not been run yet it returns an empty string
+    # @return [String] *stdout* of the command
+    def out
+      return "" if @out==nil
+      return @out if @out.class==String
       @out.read
     end
 
+    # Returns the output (stderr) of the command
+    # If the command has not been run yet it returns an empty string
+    # @return [String] *stderr* of the command
+    def err
+      return "" if @err==nil
+      return @err if @err.class==String
+      @err.read
+    end
+
+    # Return a string with the output of the command
+    # If the command has not been run yet it returns ["",""]
+    # @return [Array] *stdout* and *stderr* of the command
+    def both
+      [out, err]
+    end
+
+    # Runs the stored command locally
+    # @return [Runner] Returns itself
+    def run
+      @in, @out, @err = Open3.popen3("#{@command.cmd}")
+      self
+    end
+
+    # Runs the stored command remotely
+    # @param _username The ssh username to access the remote server
+    # @param _password The ssh password to access the remote server
+    # @param _address The ssh server address to access the remote server. It defaults to localhost.
+    # @return [Runner] Returns itself
     def run_ssh(_username, _password = "", _address = "127.0.0.1")
       stdout_data = ""
+      stderr_data = ""
       Net::SSH.start(_address,_username,:password => _password) do |ssh|
         channel = ssh.open_channel do |ch|
-          ch.exec(@cmd) do |ch,success|
+          ch.exec(@command.cmd) do |ch,success|
             # "on_data" is called when the process writes something to stdout
             ch.on_data do |c, data|
               stdout_data += data
@@ -38,13 +75,98 @@ module UnixCommander
 
             # "on_extended_data" is called when the process writes something to stderr
             ch.on_extended_data do |c, type, data|
-              raise "Error on command: #{data}"
+              stderr_data += data
             end
           end
         end
       end
-      # We have to strip the extra linefeed
-      stdout_data
+      @out = stdout_data
+      @err = stderr_data
+      self
+    end
+  end
+
+  # This class encapsulates a command that will run in a unix machine locally or remotely
+  class Command
+
+    # @return [String]
+    attr :cmd
+
+    # Creates a new command
+    # @param [String] create a command with some unix code inside (defaults to "")
+    def initialize(_cmd = "")
+      @cmd = _cmd
+    end
+    # Shows the string representation of the command being run in unix
+    # @return [String]
+    def to_s
+      cmd
+    end
+
+    # This is the main method of the library. Every unknown method you call on a Command object
+    # is interpreted as a unix command and its args are used as the args of the unix command.
+    # When the command already has some unix command inside, it pipes them together (|)
+    # @param [String] m name of the unix command you want to execute
+    # @param [Array] *args args for the aforementioned command
+    # @return [Command] new command with internal unix commands piped together
+    def method_missing(m, *args, &block)
+      if cmd == ""
+        Command.new("#{m} #{args.join(' ')}".strip)
+      else
+        Command.new("#{cmd} | #{m} #{args.join(' ')}".strip)
+      end
+    end
+
+    # Redirects *stdout* to someplace (Using >). By default it uses destructive redirection.
+    # @param [String] place to redirect the output (e.g. /dev/null)
+    # @param [true,false] append if true uses append redirection (>>) it defaults to false.
+    # @return [Command] New command with *stdout* redirected to _str
+    def out_to(_str,_append=false)
+      if cmd == ""
+        raise ArgumentError, "Cannot redirect with an empty command"
+      else
+        _append ? Command.new("#{cmd} >> #{_str}") : Command.new("#{cmd} > #{_str}")
+      end
+    end
+
+    # Redirects *stderr* to someplace (Using >). By default it uses destructive redirection.
+    # @param [String] place to redirect the output (e.g. /dev/null)
+    # @param [true,false] append if true uses append redirection (>>) it defaults to false.
+    # @return [Command] New command with *stderr* redirected to _str
+    def err_to(_str,_append=false)
+      if cmd == ""
+        raise ArgumentError, "Cannot redirect with an empty command"
+      else
+        _append ? Command.new("#{cmd} 2>> #{_str}") : Command.new("#{cmd} 2> #{_str}")
+      end
+    end
+
+    # Redirects *stdout* and *stderr* to someplace (Using >). By default it uses destructive redirection.
+    # @param [String] place to redirect the output (e.g. /dev/null)
+    # @param [true,false] append if true uses append redirection (>>) it defaults to false.
+    # @return [Command] New command with *stdout and stderr* redirected to _str
+    def both_to(_str,_append=false)
+      if cmd == ""
+        raise ArgumentError, "Cannot redirect with an empty command"
+      else
+        _append ? Command.new("#{cmd} >> #{_str} 2>&1") : Command.new("#{cmd} > #{_str} 2>&1")
+      end
+    end
+
+    # Run the Command locally. The output is encapsulated in a Runner object
+    # @return [Runner] runner object with the output inside
+    def run
+      Runner.new(self).run
+    end
+
+    # Run the Command remotely via ssh. The output is encapsulated in a Runner object
+    # @param _username The ssh username to access the remote server
+    # @param _password The ssh password to access the remote server
+    # @param _address The ssh server address to access the remote server. It defaults to localhost.
+    # @return [Runner] runner object with the output inside
+    def run_ssh(_username, _password = "", _address = "127.0.0.1")
+      Runner.new(self).run_ssh(_username,_password,_address)
     end
   end
+      
 end

data/spec/command_spec.rb

@@ -0,0 +1,83 @@
+require 'pry'
+require './lib/unix_commander'
+
+describe "Commands without chaining" do
+  before do
+    @command = UnixCommander::Command.new
+  end
+
+  it "should accept commands with no args" do
+    version = %x[uname]
+    @command.uname.to_s.should == "uname"
+  end
+
+  it "should accept commands with one arg" do
+    @command.uname("-a").to_s.should == "uname -a"
+  end
+
+end
+
+describe "Commands with chaining" do
+  before do
+    @command = UnixCommander::Command.new
+  end
+
+  it "can chain 2 commands" do
+    @command.uname("-a").cut("-d'#' -f1").to_s.should == "uname -a | cut -d'#' -f1"
+  end
+
+  it "can chain 3 commands" do
+    @command.cat("/proc/cpuinfo").awk("'{ print $1 }'").head("-n1").to_s.should == "cat /proc/cpuinfo | awk '{ print $1 }' | head -n1"
+  end
+end
+
+describe "Running" do
+  before do
+    @command = UnixCommander::Command.new.uname
+  end
+
+  it "should call a runner" do
+    UnixCommander::Runner.any_instance.should_receive(:run).and_return(%x[uname -a])
+    @command.run.should == %x[uname -a]
+  end
+
+  it "should call a runner over ssh" do
+    UnixCommander::Runner.any_instance.should_receive(:run_ssh).with('dev','devpass','localhost').and_return(%x[uname -a])
+    @command.run_ssh('dev','devpass','localhost').should == %x[uname -a]
+  end
+end
+
+describe "Redirection" do
+  before do
+    @command = UnixCommander::Command.new.uname("-a").cut("-d' ' -f1")
+  end
+  
+  it "should translate to_s correctly" do
+    @command.to_s.should == "uname -a | cut -d' ' -f1" 
+  end
+
+  it "should redirect stdout" do
+    @command.out_to('/dev/null').to_s.should == "uname -a | cut -d' ' -f1 > /dev/null" 
+  end
+
+  it "should redirect stderr" do
+    @command.err_to('/dev/null').to_s.should == "uname -a | cut -d' ' -f1 2> /dev/null" 
+  end
+
+  it "should redirect both" do
+    @command.both_to('/dev/null').to_s.should == "uname -a | cut -d' ' -f1 > /dev/null 2>&1" 
+  end
+
+  it "should append stdout" do
+    @command.out_to('/dev/null',true).to_s.should == "uname -a | cut -d' ' -f1 >> /dev/null" 
+  end
+
+  it "should append stderr" do
+    @command.err_to('/dev/null',true).to_s.should == "uname -a | cut -d' ' -f1 2>> /dev/null" 
+  end
+
+  it "should append both" do
+    @command.both_to('/dev/null',true).to_s.should == "uname -a | cut -d' ' -f1 >> /dev/null 2>&1" 
+  end
+end
+

data/spec/runner_spec.rb

@@ -0,0 +1,73 @@
+require 'pry'
+require './lib/unix_commander'
+
+describe "Runner local" do
+  before do
+    @command = UnixCommander::Command.new("uname")
+  end
+
+  it "can access out after run command" do
+    UnixCommander::Runner.new(@command).run.out.should == %x[uname]
+  end
+
+  it "can access err after run command with no errors" do
+    UnixCommander::Runner.new(@command).run.err.should == ""
+  end
+  
+  it "can access err after run command with errors" do
+    @command = UnixCommander::Command.new("cat /etc/shadow")
+    UnixCommander::Runner.new(@command).run.err.should_not == ""
+  end
+
+  it "can access out and err after run command with errors" do
+    @command = UnixCommander::Command.new("grep abc /etc/*")
+    UnixCommander::Runner.new(@command).run.err.should_not == ""
+    UnixCommander::Runner.new(@command).run.out.should == %x[grep abc /etc/* 2> /dev/null]
+  end
+  
+  it "should have empty data before run" do
+    UnixCommander::Runner.new(@command).out == ""
+    UnixCommander::Runner.new(@command).err == ""
+  end
+
+  it "can access out and err with an array" do
+    @command = UnixCommander::Command.new("grep abc /etc/*")
+    out_err = UnixCommander::Runner.new(@command).run.both
+    out_err[0].should_not == ""
+    out_err[1].should_not == ""
+  end
+  
+end
+
+describe "Runner ssh" do
+  before do
+    @command = UnixCommander::Command.new("uname")
+  end
+
+  it "can access out after run command" do
+    UnixCommander::Runner.new(@command).run_ssh('dev','dev').out.should == %x[uname]
+  end
+
+  it "can access err after run command with no errors" do
+    UnixCommander::Runner.new(@command).run_ssh('dev','dev').err.should == ""
+  end
+  
+  it "can access err after run command with errors" do
+    @command = UnixCommander::Command.new("cat /etc/shadow")
+    UnixCommander::Runner.new(@command).run_ssh('dev','dev').err.should_not == ""
+  end
+
+  it "can access out and err after run command with errors" do
+    @command = UnixCommander::Command.new("grep abc /etc/*")
+    UnixCommander::Runner.new(@command).run_ssh('dev','dev').err.should_not == ""
+    UnixCommander::Runner.new(@command).run_ssh('dev','dev').out.should == %x[grep abc /etc/* 2> /dev/null]
+  end
+  
+  it "can access out and err with an array" do
+    @command = UnixCommander::Command.new("grep abc /etc/*")
+    out_err = UnixCommander::Runner.new(@command).run_ssh('dev','dev').both
+    out_err[0].should_not == ""
+    out_err[1].should_not == ""
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unix_commander
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2012-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -139,8 +139,9 @@ files:
 - Rakefile
 - lib/unix_commander.rb
 - lib/unix_commander/version.rb
+- spec/command_spec.rb
 - spec/fixtures/ps_list.txt
-- spec/single_commands_spec.rb
+- spec/runner_spec.rb
 - unix_commander.gemspec
 homepage: https://github.com/Batou99/unix_commander
 licenses: []
@@ -167,5 +168,7 @@ signing_key:
 specification_version: 3
 summary: A gem to run unix commands on a more ruby-esque way
 test_files:
+- spec/command_spec.rb
 - spec/fixtures/ps_list.txt
-- spec/single_commands_spec.rb
+- spec/runner_spec.rb
+has_rdoc: 

data/spec/single_commands_spec.rb

@@ -1,46 +0,0 @@
-require 'pry'
-require './lib/unix_commander'
-
-describe "Commands without chaining" do
-  before do
-    @command = UnixCommander::Command.new
-  end
-
-  it "should run commands with no args" do
-    version = %x[uname]
-    @command.uname.run.should == version
-  end
-
-  it "should run commands with one arg" do
-    long_version = %x[uname -a]
-    @command.uname("-a").run.should == long_version
-  end
-
-end
-
-describe "Commands with chaining" do
-  before do
-    @command = UnixCommander::Command.new
-  end
-
-  it "can chain 2 commands" do
-    uname_cut = %x[uname -a | cut -d'#' -f1]
-    @command.uname("-a").cut("-d'#' -f1").run.should == uname_cut
-  end
-
-  it "can chain 3 commands" do
-    cpuinfo = %x[ cat /proc/cpuinfo | awk '{ print $1 }' | head -n1]
-    @command.cat("/proc/cpuinfo").awk("'{ print $1 }'").head("-n1").run.should == cpuinfo
-  end
-end
-
-describe "Run via ssh" do
-  before do
-    @command = UnixCommander::Command.new
-  end
-  
-  it "can chain 2 commands" do
-    uname_cut = %x[uname -a | cut -d'#' -f1]
-    @command.uname("-a").cut("-d'#' -f1").run_ssh('dev','dev').should == uname_cut
-  end
-end