executioner 0.2.0

data/LICENSE

@@ -0,0 +1,18 @@
+(c) 2009 Fingertips, Eloy Duran <eloy@fngtps.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "executioner"
+    s.summary  = s.description = "Execute CLI utilities"
+    s.email    = "eloy@fngtps.com"
+    s.homepage = "http://fingertips.github.com"
+    s.authors  = ["Eloy Duran"]
+  end
+rescue LoadError
+end
+
+begin
+  require 'jewelry_portfolio/tasks'
+  JewelryPortfolio::Tasks.new do |p|
+    p.account = 'Fingertips'
+  end
+rescue LoadError
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 2
+:patch: 0
+:major: 0

data/lib/executioner.rb

@@ -0,0 +1,98 @@
+require 'open3'
+
+module Executioner
+  class ExecutionerError < StandardError; end
+  class ProcessError < ExecutionerError; end
+  class ExecutableNotFoundError < ExecutionerError; end
+  
+  SEARCH_PATHS = %w{ /bin /usr/bin /usr/local/bin /opt/local/bin }
+  
+  class << self
+    attr_accessor :logger
+    
+    def included(klass)
+      klass.extend ClassMethods
+    end
+  end
+  
+  def execute(command, options={})
+    command = "#{options[:env].map { |k,v| "#{k}='#{v}'" }.join(' ')} #{command}" if options[:env]
+    
+    Executioner.logger.debug("Executing: `#{command}'") if Executioner.logger
+    
+    output = nil
+    Open3.popen3(command) do |stdin, stdout, stderr|
+      stdout, stderr = stderr, stdout if options[:switch_stdout_and_stderr]
+      
+      output = stdout.gets(nil)
+      if output.nil? && (error_message = stderr.gets(nil))
+        if error_message =~ /:in\s`exec':\s(.+)\s\(.+\)$/
+          error_message = $1
+        end
+        raise ProcessError, "Command: \"#{command}\"\nOutput: \"#{error_message.chomp}\""
+      end
+    end
+    output
+  end
+  module_function :execute
+  
+  def concat_args(args)
+    args.map { |a,v| "-#{a} #{v}" }.join(' ')
+  end
+  
+  def queue(command)
+    @commands ||= []
+    @commands << command
+  end
+  
+  def queued_commands
+    @commands ? @commands.join(' && ') : ''
+  end
+  
+  def execute_queued(options={})
+    execute(queued_commands, options)
+    @commands = []
+  end
+  
+  module ClassMethods
+    def executable(executable, options={})
+      options[:switch_stdout_and_stderr] ||= false
+      options[:use_queue]                ||= false
+      
+      executable = executable.to_s if executable.is_a? Symbol
+      use_queue = options.delete(:use_queue)
+      
+      if selection_proc = options.delete(:select_if)
+        advance_from = nil
+        while executable_path = find_executable(executable, advance_from)
+          break if selection_proc.call(executable_path)
+          advance_from = File.dirname(executable_path)
+        end
+      else
+        executable_path = options[:path] || find_executable(executable)
+      end
+      
+      if executable_path
+        if use_queue
+          body = "queue(\"#{executable_path} \#{args}\")"
+        else
+          body = "execute(\"#{executable_path} \#{args}\", #{options.inspect}.merge(options))"
+        end
+      else
+        body = "raise Executioner::ExecutableNotFoundError, \"Unable to find the executable '#{executable}' in: #{Executioner::SEARCH_PATHS.join(', ')}\""
+      end
+      
+      class_eval "def #{executable.gsub(/-/, '_')}(args, options = {}); #{body}; end", __FILE__, __LINE__
+    end
+    
+    def find_executable(executable, advance_from = nil)
+      search_paths = Executioner::SEARCH_PATHS
+      search_paths = search_paths[(search_paths.index(advance_from) + 1)..-1] if advance_from
+      
+      if executable_in_path = search_paths.find { |path| File.exist? File.join(path, executable) }
+        File.join executable_in_path, executable
+      end
+    end
+    module_function :find_executable
+  end
+end

data/test/executioner_test.rb

@@ -0,0 +1,195 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class AClassThatUsesSubshells
+  include Executioner
+  executable :sh
+  executable :doesnotexistforsure
+  executable 'executable-with-dash'
+  executable :with_path, :path => '/path/to/executable'
+  executable :with_env,  :path => '/path/to/executable', :env => { :foo => 'bar' }
+  
+  public :execute
+end
+
+describe "Executioner, when executing" do
+  before do
+    @object = AClassThatUsesSubshells.new
+  end
+  
+  it "should open a pipe with the given command" do
+    Open3.expects(:popen3).with('/the/command')
+    @object.execute('/the/command')
+  end
+  
+  it "should return the output received from stdout" do
+    stub_popen3 'stdout output', ''
+    @object.execute('/the/command').should == 'stdout output'
+  end
+  
+  it "should return the output received from stderr if they should be reversed" do
+    stub_popen3 '', 'stderr output'
+    @object.execute('/the/command', :switch_stdout_and_stderr => true).should == 'stderr output'
+  end
+  
+  it "should raise a Executioner::ProcessError if stdout is empty and stderr is not" do
+    stub_popen3 '', 'stderr output'
+    lambda { @object.execute('foo') }.should.raise Executioner::ProcessError
+  end
+  
+  it "should raise a Executioner::ProcessError if stderr is empty and stdout is not and the streams are reversed" do
+    stub_popen3 'stdout output', ''
+    lambda { @object.execute('foo', :switch_stdout_and_stderr => true) }.should.raise Executioner::ProcessError
+  end
+  
+  it "should prepend the given env variables" do
+    Open3.expects(:popen3).with("foo='bar' /the/command")
+    @object.execute('/the/command', :env => { :foo => :bar })
+  end
+  
+  it "should log the command that's going to be executed if a logger is available" do
+    begin
+      logger = mock('Logger')
+      Executioner.logger = logger
+      
+      logger.expects(:debug).with("Executing: `foo'")
+      stub_popen3
+      @object.execute('foo')
+    ensure
+      Executioner.logger = nil
+    end
+  end
+  
+  private
+  
+  def stub_popen3(stdout = '', stderr = '')
+    Open3.stubs(:popen3).yields(*['stdin', stdout, stderr].map { |s| StringIO.new(s) })
+  end
+end
+
+describe "Executioner, instance methods" do
+  before do
+    @object = AClassThatUsesSubshells.new
+  end
+  
+  it "should raise a Executioner::ProcessError if a command could not be executed" do
+    proc = lambda { @object.send(:execute, "/bin/sh -M") }
+    
+    proc.should.raise Executioner::ProcessError
+    
+    begin
+      proc.call
+    rescue Executioner::ProcessError => error
+      error.message.should =~ %r%Command: "/bin/sh -M"%
+      error.message.should =~ %r%Output: "/bin/sh: -M: invalid option%
+    end
+  end
+  
+  it "should be able to switch stdout and stderr, for instance for ffmpeg" do
+    lambda { @object.send(:execute, "/bin/sh -M", :switch_stdout_and_stderr => true) }.should.not.raise Executioner::ProcessError
+  end
+  
+  it "should help concat arguments" do
+    @object.send(:concat_args, [[:foo, 'foo'], [:bar, 'bar']]).should == "-foo foo -bar bar"
+  end
+  
+  it "should queue one command" do
+    @object.send(:queue, 'ls')
+    @object.send(:queued_commands).should == 'ls'
+  end
+  
+  it "should queue multiple commands" do
+    @object.send(:queue, 'ls')
+    @object.send(:queue, 'cat')
+    @object.send(:queued_commands).should == 'ls && cat'
+  end
+  
+  it "should execute queued commands" do
+    @object.send(:queue, 'ls')
+    @object.send(:queue, 'ls')
+    @object.expects(:execute).with(@object.send(:queued_commands), {})
+    @object.send(:execute_queued)
+    @object.send(:queued_commands).should == ''
+  end
+end
+
+describe "Executioner, class methods" do
+  before do
+    @object = AClassThatUsesSubshells.new
+  end
+  
+  it "should define an instance method for the specified binary that's needed" do
+    AClassThatUsesSubshells.instance_methods.should.include 'sh'
+  end
+  
+  it "should define an instance method which calls #execute with the correct path to the executable" do
+    @object.expects(:execute).with('/bin/sh with some args', { :switch_stdout_and_stderr => false })
+    @object.sh 'with some args'
+  end
+  
+  it "should define an instance method for an executable with dashes replaced by underscores" do
+    @object.should.respond_to :executable_with_dash
+  end
+  
+  it "should be possible to switch stdin and stderr" do
+    AClassThatUsesSubshells.class_eval { executable(:sh, { :switch_stdout_and_stderr => true }) }
+    @object.expects(:execute).with('/bin/sh with some args', { :switch_stdout_and_stderr => true })
+    @object.sh 'with some args'
+  end
+  
+  it "should be possible to use the queue by default" do
+    AClassThatUsesSubshells.class_eval { executable(:sh, { :use_queue => true }) }
+    @object.expects(:execute).with('/bin/sh arg1 && /bin/sh arg2', {})
+    @object.sh 'arg1'
+    @object.sh 'arg2'
+    @object.execute_queued
+  end
+  
+  it "should be possible to specify the path to the executable" do
+    @object.expects(:execute).with { |command, options| command == "/path/to/executable arg1" }
+    @object.with_path 'arg1'
+  end
+  
+  it "should be possible to specify the env that's to be prepended to the command" do
+    @object.expects(:execute).with { |command, options| options[:env] == { :foo => 'bar' } }
+    @object.with_env 'arg1'
+  end
+  
+  it "should merge options onto the default options" do
+    @object.expects(:execute).with { |command, options| options[:env] == { :foo => 'foo' } }
+    @object.with_env 'arg1', :env => { :foo => 'foo' }
+  end
+  
+  it "should be possible to find an executable" do
+    File.stubs(:exist?).with('/bin/sh').returns(true)
+    Executioner::ClassMethods.find_executable('sh').should == '/bin/sh'
+  end
+  
+  it "should be possible to find an executable advancing from a given path" do
+    File.stubs(:exist?).with('/usr/bin/sh').returns(true)
+    Executioner::ClassMethods.find_executable('sh', '/bin').should == '/usr/bin/sh'
+  end
+  
+  it "should yield all found executables, but use the one for which the proc returns a truthful value" do
+    File.stubs(:exist?).with('/bin/with_selection_proc').returns(true)
+    File.stubs(:exist?).with('/usr/bin/with_selection_proc').returns(true)
+    File.stubs(:exist?).with('/usr/local/bin/with_selection_proc').returns(true)
+    File.stubs(:exist?).with('/opt/local/bin/with_selection_proc').returns(true)
+    
+    AClassThatUsesSubshells.executable(:with_selection_proc, :select_if => lambda { |executable| nil })
+    lambda { @object.with_selection_proc('foo') }.should.raise Executioner::ExecutableNotFoundError
+    
+    AClassThatUsesSubshells.executable(:with_selection_proc, :select_if => lambda { |executable| executable == '/usr/bin/with_selection_proc' })
+    @object.expects(:execute).with("/usr/bin/with_selection_proc foo", {:switch_stdout_and_stderr => false})
+    @object.with_selection_proc('foo')
+    
+    AClassThatUsesSubshells.executable(:with_selection_proc, :select_if => lambda { |executable| executable == '/opt/local/bin/with_selection_proc' })
+    @object.expects(:execute).with("/opt/local/bin/with_selection_proc foo", {:switch_stdout_and_stderr => false})
+    @object.with_selection_proc('foo')
+  end
+  
+  it "should define an instance method which raises a Executioner::ExecutableNotFoundError error if the executable could not be found" do
+    lambda {
+      @object.doesnotexistforsure 'right?'
+    }.should.raise Executioner::ExecutableNotFoundError
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require "rubygems"
+require "test/spec"
+require "mocha"
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require "executioner"

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: executioner
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-08 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Execute CLI utilities
+email: eloy@fngtps.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/executioner.rb
+- test/executioner_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://fingertips.github.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Execute CLI utilities
+test_files: 
+- test/executioner_test.rb
+- test/test_helper.rb