cocaine 0.1.0 → 0.2.0

data/README.md

@@ -75,7 +75,17 @@ But don't fear, you can specify where to look for the command.
 ```ruby
 Cocaine::CommandLine.path = "/opt/bin"
 line = Cocaine::CommandLine.new("lolwut")
-line.command # => "/opt/bin/lolwut"
+line.command # => "lolwut", but it looks in /opt/bin for it.
+```
+
+You can even give it a bunch of places to look.
+
+```ruby
+FileUtils.rm("/opt/bin/lolwut")
+`echo 'echo Hello' > /usr/local/bin/lolwut`
+Cocaine::CommandLine.path = ["/opt/bin", "/usr/local/bin"]
+line = Cocaine::CommandLine.new("lolwut")
+line.run # => prints 'Hello', because it searches the path
 ```
 
 Or, just, you know, put it in the command.
@@ -96,6 +106,20 @@ rescue Cocaine::ExitStatusError => e
 end
 ```
 
+You can see what's getting run. The 'Command' part it logs is in green for visibility!
+
+```ruby
+line = Cocaine::CommandLine.new("echo", ":var", :var => "LOL!", :logger => Logger.new(STDOUT))
+line.run # => Logs this with #info -> Command :: echo 'LOL!'
+```
+
+But you don't have to, as you saw above where it doesn't use this. But you CAN log every command!
+
+```ruby
+Cocaine::CommandLine.logger = Logger.new(STDOUT)
+Cocaine::CommandLine.new("date").run # => Logs this -> Command :: date
+```
+
 ## License
 
 Copyright 2011 Jon Yurek and thoughtbot, inc. This is free software, and may be redistributed under the terms specified in the LICENSE file.

data/lib/cocaine.rb

@@ -1,3 +1,4 @@
+require 'rbconfig'
 require 'cocaine/command_line'
 require 'cocaine/exceptions'
 

data/lib/cocaine/command_line.rb

@@ -1,13 +1,14 @@
 module Cocaine
   class CommandLine
     class << self
-      attr_accessor :path
+      attr_accessor :path, :logger
     end
 
     def initialize(binary, params = "", options = {})
       @binary            = binary.dup
       @params            = params.dup
       @options           = options.dup
+      @logger            = @options.delete(:logger) || self.class.logger
       @swallow_stderr    = @options.delete(:swallow_stderr)
       @expected_outcodes = @options.delete(:expected_outcodes)
       @expected_outcodes ||= [0]
@@ -25,6 +26,7 @@ module Cocaine
       output = ''
       begin
         with_modified_path do
+          @logger.info("\e[32mCommand\e[0m :: #{command}") if @logger
           output = self.class.send(:'`', command)
         end
       rescue Errno::ENOENT
@@ -66,7 +68,7 @@ module Cocaine
     end
 
     def invalid_variables
-      %w(expected_outcodes swallow_stderr)
+      %w(expected_outcodes swallow_stderr logger)
     end
 
     def interpolation(vars, key)
@@ -89,7 +91,7 @@ module Cocaine
     end
 
     def self.unix?
-      File.exist?("/dev/null")
+      (Config::CONFIG['host_os'] =~ /mswin|mingw/).nil?
     end
   end
 end

data/lib/cocaine/version.rb

@@ -1,3 +1,3 @@
 module Cocaine
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/cocaine/command_line_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Cocaine::CommandLine do
   before do
     Cocaine::CommandLine.path = nil
-    File.stubs(:exist?).with("/dev/null").returns(true)
+    on_unix! # Assume we're on unix unless otherwise specified.
   end
 
-  it "takes a command and parameters and produce a shell command for bash" do
+  it "takes a command and parameters and produces a Bash command line" do
     cmd = Cocaine::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
     cmd.command.should == "convert a.jpg b.png"
   end
 
-  it "specifies the path where the command should be run" do
+  it "specifies the $PATH where the command can be found" do
     Cocaine::CommandLine.path = "/path/to/command/dir"
     cmd = Cocaine::CommandLine.new("ruby", "-e 'puts ENV[%{PATH}]'")
     cmd.command.should == "ruby -e 'puts ENV[%{PATH}]'"
@@ -19,7 +19,7 @@ describe Cocaine::CommandLine do
     output.should match(%r{/path/to/command/dir})
   end
 
-  it "specifies more than one path where the command should be run" do
+  it "specifies more than one path where the command can be found" do
     Cocaine::CommandLine.path = ["/path/to/command/dir", "/some/other/path"]
     cmd = Cocaine::CommandLine.new("ruby", "-e 'puts ENV[%{PATH}]'")
     output = cmd.run
@@ -27,41 +27,41 @@ describe Cocaine::CommandLine do
     output.should match(%r{/some/other/path})
   end
 
-  it "can interpolate quoted variables into the parameters" do
+  it "can interpolate quoted variables into the command line's parameters" do
     cmd = Cocaine::CommandLine.new("convert",
-                                     ":one :{two}",
-                                     :one => "a.jpg",
-                                     :two => "b.png",
-                                     :swallow_stderr => false)
+                                   ":one :{two}",
+                                   :one => "a.jpg",
+                                   :two => "b.png",
+                                   :swallow_stderr => false)
     cmd.command.should == "convert 'a.jpg' 'b.png'"
   end
 
   it "quotes command line options differently if we're on windows" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
+    on_windows!
     cmd = Cocaine::CommandLine.new("convert",
-                                     ":one :{two}",
-                                     :one => "a.jpg",
-                                     :two => "b.png",
-                                     :swallow_stderr => false)
+                                   ":one :{two}",
+                                   :one => "a.jpg",
+                                   :two => "b.png",
+                                   :swallow_stderr => false)
     cmd.command.should == 'convert "a.jpg" "b.png"'
   end
 
   it "can quote and interpolate dangerous variables" do
     cmd = Cocaine::CommandLine.new("convert",
-                                     ":one :two",
-                                     :one => "`rm -rf`.jpg",
-                                     :two => "ha'ha.png",
-                                     :swallow_stderr => false)
+                                   ":one :two",
+                                   :one => "`rm -rf`.jpg",
+                                   :two => "ha'ha.png",
+                                   :swallow_stderr => false)
     cmd.command.should == "convert '`rm -rf`.jpg' 'ha'\\''ha.png'"
   end
 
   it "can quote and interpolate dangerous variables even on windows" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
+    on_windows!
     cmd = Cocaine::CommandLine.new("convert",
-                                     ":one :two",
-                                     :one => "`rm -rf`.jpg",
-                                     :two => "ha'ha.png",
-                                     :swallow_stderr => false)
+                                   ":one :two",
+                                   :one => "`rm -rf`.jpg",
+                                   :two => "ha'ha.png",
+                                   :swallow_stderr => false)
     cmd.command.should == %{convert "`rm -rf`.jpg" "ha'ha.png"}
   end
 
@@ -70,36 +70,39 @@ describe Cocaine::CommandLine do
     cmd.command.should == "convert 'a.jpg' xc:black 'b.jpg'"
   end
 
-  it "adds redirection to get rid of stderr in bash" do
-    File.stubs(:exist?).with("/dev/null").returns(true)
+  it "can redirect stderr to the bit bucket if requested" do
     cmd = Cocaine::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :swallow_stderr => true)
+                                   "a.jpg b.png",
+                                   :swallow_stderr => true)
 
     cmd.command.should == "convert a.jpg b.png 2>/dev/null"
   end
 
-  it "adds redirection to get rid of stderr in cmd.exe" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
+  it "can redirect stderr to the bit bucket on windows" do
+    on_windows!
     cmd = Cocaine::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :swallow_stderr => true)
+                                   "a.jpg b.png",
+                                   :swallow_stderr => true)
 
     cmd.command.should == "convert a.jpg b.png 2>NUL"
   end
 
-  it "raises if trying to interpolate :swallow_stderr or :expected_outcodes" do
-    cmd = Cocaine::CommandLine.new("convert",
-                                     ":swallow_stderr :expected_outcodes",
-                                     :swallow_stderr => false,
-                                     :expected_outcodes => [0, 1])
+  it "raises if trying to interpolate :swallow_stderr" do
+    cmd = Cocaine::CommandLine.new("convert", ":swallow_stderr", :swallow_stderr => false)
+    lambda { cmd.command }.should raise_error(Cocaine::CommandLineError)
+  end
+
+  it "raises if trying to interpolate :expected_outcodes" do
+    cmd = Cocaine::CommandLine.new("convert", ":expected_outcodes", :expected_outcodes => [0])
+    lambda { cmd.command }.should raise_error(Cocaine::CommandLineError)
+  end
 
-    lambda do
-      cmd.command
-    end.should raise_error(Cocaine::CommandLineError)
+  it "raises if trying to interpolate :logger" do
+    cmd = Cocaine::CommandLine.new("convert", ":logger", :logger => stub)
+    lambda { cmd.command }.should raise_error(Cocaine::CommandLineError)
   end
 
-  it "runs the #command it's given and return the output" do
+  it "runs the command it's given and return the output" do
     cmd = Cocaine::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
     cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
     with_exitstatus_returning(0) do
@@ -107,7 +110,7 @@ describe Cocaine::CommandLine do
     end
   end
 
-  it "raises a CommandLineError if the result code isn't expected" do
+  it "raises a CommandLineError if the result code from the command isn't expected" do
     cmd = Cocaine::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
     cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
     with_exitstatus_returning(1) do
@@ -117,11 +120,11 @@ describe Cocaine::CommandLine do
     end
   end
 
-  it "does not raise a CommandLineError if the result code is expected" do
+  it "does not raise if the result code is expected, even if nonzero" do
     cmd = Cocaine::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :expected_outcodes => [0, 1],
-                                     :swallow_stderr => false)
+                                   "a.jpg b.png",
+                                   :expected_outcodes => [0, 1],
+                                   :swallow_stderr => false)
     cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
     with_exitstatus_returning(1) do
       lambda do
@@ -130,13 +133,37 @@ describe Cocaine::CommandLine do
     end
   end
 
-  it "detects that the system is unix or windows based on presence of /dev/null" do
-    File.stubs(:exist?).returns(true)
-    Cocaine::CommandLine.unix?.should == true
+  it "detects that the system is unix" do
+    Cocaine::CommandLine.unix?.should be_true
+  end
+
+  it "detects that the system is windows" do
+    on_windows!
+    Cocaine::CommandLine.unix?.should be_false
+  end
+
+  it "detects that the system is windows (mingw)" do
+    on_windows!("mingw")
+    Cocaine::CommandLine.unix?.should be_false
+  end
+
+  it "logs the command to a supplied logger" do
+    logger = stub
+    logger.stubs(:info).with(anything).returns(nil)
+    Cocaine::CommandLine.new("echo", "'Logging!'", :logger => logger).run
+    logger.should have_received(:info).with("\e[32mCommand\e[0m :: echo 'Logging!'")
+  end
+
+  it "logs the command to a default logger" do
+    Cocaine::CommandLine.logger = stub
+    Cocaine::CommandLine.logger.stubs(:info).with(anything).returns(nil)
+    Cocaine::CommandLine.new("echo", "'Logging!'").run
+    Cocaine::CommandLine.logger.should have_received(:info).with("\e[32mCommand\e[0m :: echo 'Logging!'")
   end
 
-  it "detects that the system is not unix or windows based on absence of /dev/null" do
-    File.stubs(:exist?).returns(false)
-    Cocaine::CommandLine.unix?.should_not == true
+  it "is fine if no logger is supplied" do
+    Cocaine::CommandLine.logger = nil
+    cmd = Cocaine::CommandLine.new("echo", "'Logging!'", :logger => nil)
+    lambda { cmd.run }.should_not raise_error
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 require './spec/support/with_exitstatus'
+require './spec/support/stub_os'
 require 'mocha'
 require 'bourne'
 require 'cocaine'
@@ -7,4 +8,5 @@ require 'cocaine'
 RSpec.configure do |config|
   config.mock_with :mocha
   config.include WithExitstatus
+  config.include StubOS
 end

data/spec/support/stub_os.rb

@@ -0,0 +1,14 @@
+module StubOS
+  def on_windows!(host_string = 'mswin')
+    stub_os(host_string)
+  end
+
+  def on_unix!(host_string = 'darwin11.0.0')
+    stub_os(host_string)
+  end
+
+  def stub_os(host_string)
+    # http://blog.emptyway.com/2009/11/03/proper-way-to-detect-windows-platform-in-ruby/
+    Config::CONFIG.stubs(:[]).with('host_os').returns(host_string)
+  end
+end

data/spec/support/with_exitstatus.rb

@@ -2,10 +2,10 @@ module WithExitstatus
   def with_exitstatus_returning(code)
     saved_exitstatus = $?.nil? ? 0 : $?.exitstatus
     begin
-      `ruby -e 'exit #{code.to_i}'`
+      `ruby -e "exit #{code.to_i}"`
       yield
     ensure
-      `ruby -e 'exit #{saved_exitstatus.to_i}'`
+      `ruby -e "exit #{saved_exitstatus.to_i}"`
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cocaine
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jon Yurek
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-05 00:00:00 -04:00
+date: 2011-08-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,12 +72,13 @@ files:
 - README.md
 - LICENSE
 - Rakefile
-- lib/cocaine.rb
 - lib/cocaine/command_line.rb
 - lib/cocaine/exceptions.rb
 - lib/cocaine/version.rb
-- spec/spec_helper.rb
+- lib/cocaine.rb
 - spec/cocaine/command_line_spec.rb
+- spec/spec_helper.rb
+- spec/support/stub_os.rb
 - spec/support/with_exitstatus.rb
 has_rdoc: true
 homepage: http://www.thoughtbot.com/projects/cocaine
@@ -109,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A small library for doing (command) lines