corl 0.4.0 → 0.4.1

data/lib/corl_core/util/shell.rb

@@ -1,239 +0,0 @@
-
-module CORL
-module Util
-class Shell < Core
-  
-  include Celluloid
-  
-  #-----------------------------------------------------------------------------
-  
-  @@supervisors = {}
-  
-  #-----------------------------------------------------------------------------
-  # Execution result interface
-  
-  class Result
-    attr_accessor :status
-    attr_reader :command
-    
-    def initialize(command)
-      @command = command
-      @output  = ''
-      @errors  = ''
-      @status  = CORL.code.success
-    end
-    
-    #---
-    
-    def output
-      @output.strip
-    end
-    
-    def errors
-      @errors.strip
-    end
-    
-    #---
-    
-    def append_output(output_str)
-      @output << output_str
-    end
-    
-    def append_errors(error_str)
-      @errors << error_str
-    end  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Shell interface
-  
-  def self.connection(name = :core)
-    name = name.to_sym
-    init_shell(name) unless @@supervisors.has_key?(name)
-    @@supervisors[name]
-  end  
-  
-  def self.init_shell(name)
-    name = name.to_sym
-    
-    Shell.supervise_as name
-    @@supervisors[name] = Celluloid::Actor[name]  
-  end
-  
-  #---
-  
-  execute_block_on_receiver :exec
-    
-  def exec(command, options = {}, &code)
-    config = Config.ensure(options)
-    
-    min   = config.get(:min, 1).to_i
-    tries = config.get(:tries, min).to_i
-    tries = ( min > tries ? min : tries )
-    
-    info_prefix  = config.get(:info_prefix, '')
-    info_suffix  = config.get(:info_suffix, '')
-    error_prefix = config.get(:error_prefix, '')
-    error_suffix = config.get(:error_suffix, '')
-    
-    ui           = config.get(:ui, CORL.ui)
-    
-    conditions   = CORL.events(config.get(:exit, {}), true)
-    
-    $stdout.sync = true
-    $stderr.sync = true
-    
-    system_result = Result.new(command)
-    
-    for i in tries.downto(1)
-      logger.info(">> running: #{command}")
-      
-      begin
-        t1, output_new, output_orig, output_reader = pipe_exec_stream($stdout, conditions, { 
-          :prefix => info_prefix, 
-          :suffix => info_suffix, 
-        }, 'output') do |data|
-          system_result.append_output(data)
-          block_given? ? code.call(:output, command, data) : true
-        end
-        
-        t2, error_new, error_orig, error_reader = pipe_exec_stream($stderr, conditions, { 
-          :prefix => error_prefix, 
-          :suffix => error_suffix, 
-        }, 'error') do |data|
-          system_result.append_errors(data)
-          block_given? ? code.call(:error, command, data) : true
-        end
-      
-        system_success       = system(command)
-        system_result.status = $?.exitstatus
-        
-      ensure
-        output_success = close_exec_pipe(t1, $stdout, output_orig, output_new, 'output')
-        error_success  = close_exec_pipe(t2, $stderr, error_orig, error_new, 'error')
-      end
-      
-      success = ( system_success && output_success && error_success )
-                  
-      min -= 1
-      break if success && min <= 0 && conditions.empty?
-    end
-    system_result
-  end
-  
-  #---
-  
-  def pipe_exec_stream(output, conditions, options, label, &code)
-    original     = output.dup
-    read, write  = IO.pipe
-    
-    match_prefix = ( options[:match_prefix] ? options[:match_prefix] : 'EXIT' )
-    
-    thread = process_stream(read, original, options, label) do |data|
-      check_conditions(data, conditions, match_prefix) do
-        block_given? ? code.call(data) : true
-      end
-    end
-    
-    thread.abort_on_exception = false
-    
-    output.reopen(write)    
-    return thread, write, original, read
-  end
-  protected :pipe_exec_stream
-  
-  #---
-  
-  def close_exec_pipe(thread, output, original, write, label)
-    output.reopen(original)
-     
-    write.close
-    success = thread.value
-    
-    original.close
-    return success
-  end
-  protected :close_exec_pipe
-  
-  #---
-  
-  def check_conditions(data, conditions, match_prefix = '', &code)
-    prefix = ''
-    
-    unless ! conditions || conditions.empty?
-      conditions.each do |key, event|
-        if event.check(data)
-          prefix = match_prefix
-          conditions.delete(key)
-        end
-      end
-    end
-    
-    result = true
-    if block_given?
-      result = code.call
-      
-      unless prefix.empty?
-        case result
-        when Hash
-          result[:prefix] = prefix
-        else
-          result = { :success => result, :prefix => prefix }
-        end
-      end
-    end
-    return result
-  end
-  protected :check_conditions
-  
-  #---
-  
-  def process_stream(input, output, options, label, &code)
-    return Thread.new do
-      success        = true      
-      default_prefix = ( options[:prefix] ? options[:prefix] : '' )
-      default_suffix = ( options[:suffix] ? options[:suffix] : '' )
-      
-      begin
-        while ( data = input.readpartial(1024) )
-          message = data.strip
-          newline = ( data[-1,1].match(/\n/) ? true : false )
-                                 
-          unless message.empty?
-            lines = message.split(/\n/)
-            lines.each_with_index do |line, index|
-              prefix  = default_prefix
-              suffix  = default_suffix
-              
-              unless line.empty?
-                if block_given?
-                  result = code.call(line)
-                                          
-                  if result && result.is_a?(Hash)
-                    prefix = result[:prefix]
-                    suffix = result[:suffix]
-                    result = result[:success]                 
-                  end
-                  success = result if success
-                end
-            
-                prefix = ( prefix && ! prefix.empty? ? "#{prefix}: " : '' )
-                suffix = ( suffix && ! suffix.empty? ? suffix : '' )            
-                eol    = ( index < lines.length - 1 || newline ? "\n" : ' ' )
-            
-                output.write(prefix.lstrip + line + suffix.rstrip + eol)
-              end
-            end
-          end
-        end
-      rescue EOFError
-      end
-      
-      input.close()
-      success
-    end
-  end
-  protected :process_stream
-end
-end
-end

data/spec/corl_core/interface_spec.rb

@@ -1,489 +0,0 @@
-
-require 'spec_helper'
-
-module CORL
-
-  describe Util::Interface do
-
-    #---------------------------------------------------------------------------
-    # UI functionality
-    
-    describe "#say" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).say(:info, 'message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Output formats
-
-      it "prints a message with default options" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ :output => output1 }).say(:info, 'message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('[component] message')
-        
-        Util::Interface.new({
-          :resource => 'component', 
-          :output   => output2, 
-        }).say(:info, 'message')      
-      end
-      
-      #---
-      
-      it "prints a message with and without newlines included" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Interface.new({ :output => output1 })
-        test.say(:info, 'message', { :new_line => true })
-        
-        output2 = double('output2')
-        output2.should_receive(:print).with('message')
-        
-        test = Util::Interface.new({ :output => output2 })
-        test.say(:info, 'message', { :new_line => false })      
-      end
-      
-      #---
-      
-      it "routes message to output and error channels based on type given" do       
-        [:info, :warn, :success].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message')
-        
-          Util::Interface.new({
-            :output  => output,
-            :printer => :puts,
-            :color   => false,
-          }).say(type, 'message')
-        end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        }).say(:error, 'message')   
-      end
-      
-      #---
-      
-      it "routes message to output and error channels based on channel given" do
-        [:info, :warn, :success].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message')
-        
-          Util::Interface.new({
-            :output  => output,
-            :printer => :puts,
-          }).say(:info, 'message', { :channel => type })        
-        end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        }).say(:info, 'message', { :channel => :error })
-      end  
-    end
-    
-    #---
-    
-    describe "#ask" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method"
-      
-      #-------------------------------------------------------------------------
-      # Input
-      
-      it "displays a prompt and returns user feedback"
-    end
-    
-    #---
-    
-    describe "#info" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).info('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored information message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts, 
-        }).info('message')
-      end    
-    end
-    
-    #---
-    
-    describe "#warn" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).warn('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored warning message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).warn('message')
-      end
-      
-      #---
-      
-      it "prints a colored warning message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[33mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :output => output,
-          :color  => true, 
-        }).warn('message', { :new_line => false })
-      end    
-    end
-    
-    #---
-    
-    describe "#error" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        error  = double('error')
-        error.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).error('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored error message" do
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :error   => error,
-          :printer => :puts,
-          :color   => false, 
-        }).error('message')
-      end
-      
-      #---
-      
-      it "prints a colored error message" do
-        error = double('error')
-        error.should_receive(:print).with(/^\e\[31mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :error => error,
-          :color => true, 
-        }).error('message', { :new_line => false })
-      end 
-    end
-    
-    #---
-    
-    describe "#success" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).success('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored success message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).success('message')
-      end
-      
-      #---
-      
-      it "prints a colored success message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[32mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :output => output,
-          :color  => true, 
-        }).success('message', { :new_line => false })
-      end  
-    end
-  
-    #---------------------------------------------------------------------------
-    # Utilities
-    
-    describe "#format_message" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        message = Util::Interface.new({ 
-          :ui_delegate => Util::Interface.new('delegate')
-        }).format_message(:info, 'message', { :prefix => true })
-        
-        message.should == '[delegate] message'
-      end
-    
-      #-------------------------------------------------------------------------
-      # Prefix specifications
-      
-      it "returns without a prefix because no resource" do
-        message = Util::Interface.new.format_message(:info, 'message', { :prefix => true })
-        message.should == 'message'
-      end
-      
-      #---
-      
-      it "returns without a prefix because prefix is false" do
-        message = Util::Interface.new('component').format_message(:info, 'message', { :prefix => false })
-        message.should == 'message'
-      end
-      
-      #---
-            
-      it "returns without a prefix because no prefix option given" do
-        message = Util::Interface.new('component').format_message(:info, 'message')
-        message.should == 'message'
-      end
-      
-      #---
-            
-      it "returns with a prefix if resource and prefix option given" do
-        message = Util::Interface.new('component').format_message(:info, 'message', { :prefix => true })
-        message.should == '[component] message'
-      end
-      
-      #-------------------------------------------------------------------------
-      # Color specifications
-      
-      it "formats a error message in red if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:error, 'message')
-        message.should match(/^\e\[31mmessage\e\[0m$/)
-      end
-      
-      #---
-      
-      it "formats a warning message in yellow if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:warn, 'message')
-        message.should match(/^\e\[33mmessage\e\[0m$/)
-      end
-      
-      #---
-      
-      it "formats a success message in green if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:success, 'message')
-        message.should match(/^\e\[32mmessage\e\[0m$/)
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    
-    describe "#safe_puts" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Instance configuration
-      
-      it "prints an empty string unless message given" do
-        output  = double('output')
-        output.should_receive(:puts).with('')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts()
-      end
-      
-      #---
-      
-      it "prints to different output channels if they are given" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Interface.new({
-          :output  => output1,
-          :printer => :puts,
-        })
-        test.safe_puts('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        test.output = output2
-        test.safe_puts('message')
-      end
-      
-      #---
-      
-      it "prints with puts if puts printer option given" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message')
-      end
-      
-      #---
-      
-      it "prints with print if print printer option given" do
-        output = double('output')
-        output.should_receive(:print).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :print,
-        }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Method configuration
-      
-      it "can override the instance output channel" do
-        output1 = double('output1')
-        output1.should_not_receive(:puts).with('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :output  => output1,
-          :printer => :puts,
-        }).safe_puts('message', { :channel => output2 })  
-      end
-      
-      #---
-      
-      it "can override the instance printer handler" do
-        output = double('output')
-        output.should_not_receive(:puts).with('message')
-        output.should_receive(:print).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message', { :printer => :print })
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    
-    describe "#check_delegate" do
-      
-      it "returns false if no delegate exists" do
-        Util::Interface.new.check_delegate('safe_puts').should be_false
-      end
-      it "returns true if a delegate exists and it implements given method" do
-        test = Util::Interface.new({ :ui_delegate => Util::Interface.new })
-        test.check_delegate('safe_puts').should be_true
-        test.check_delegate('nonexistent').should be_false
-      end
-    end  
-  end
-end