coral_core 0.2.30 → 0.4.0

data/lib/coral_core/util/disk.rb

@@ -1,105 +0,0 @@
-
-module Coral
-module Util
-class Disk
-  
-  #-----------------------------------------------------------------------------
-  # Properties
- 
-  @@files = {}
-  
-  @@separator   = false
-  @@description = ''
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.exists?(file)
-    return File.exists?(File.expand_path(file))  
-  end
-  
-  #---
-  
-  def self.filename(file_name)
-    return ( file_name.is_a?(Array) ? file_name.join(File::SEPARATOR) : file_name.to_s )
-  end
-  
-  #---
-  
-  def self.open(file_name, options = {}, reset = false)
-    mode          = options[:mode].to_s
-    
-    @@separator   = ( options[:separator] ? options[:separator] : false )
-    @@description = ( options[:description] ? options[:description] : '' )
-    
-    if @@files.has_key?(file_name) && ! reset
-      reset = true if ! mode.empty? && mode != @@files[file_name][:mode]
-    end
-    
-    if ! @@files.has_key?(file_name) || ! @@files[file_name][:file] || reset
-      @@files[file_name][:file].close if @@files[file_name] && @@files[file_name][:file]
-      unless mode.empty? || ( mode == 'r' && ! File.exists?(file_name) )
-        @@files[file_name] = {
-          :file => File.open(file_name, mode),
-          :mode => mode,
-        }
-      end
-    end
-    return nil unless @@files[file_name]
-    return @@files[file_name][:file]
-  end
-  
-  #---
-  
-  def self.read(file_name, options = {})
-    options[:mode] = ( options[:mode] ? options[:mode] : 'r' )
-    file           = open(file_name, options)
-    
-    if file
-      file.pos = 0 if options[:mode] == 'r'
-      return file.read
-    end
-    return nil
-  end
-  
-  #---
-  
-  def self.write(file_name, data, options = {})
-    options[:mode] = ( options[:mode] ? options[:mode] : 'w' )
-    file           = open(file_name, options)
-    
-    if file
-      return file.write(data)
-    end
-    return nil
-  end
-  
-  #---
-  
-  def self.log(data, options = {})
-    reset = ( options[:file_name] || options[:mode] )
-    file  = open(( options[:file_name] ? options[:file_name] : 'log.txt' ), options, reset)    
-    if file      
-      file.write("--------------------------------------\n") if @@separator
-      file.write("#{@@description}\n") if @@description       
-      file.write("#{data}\n")
-    end
-  end
-  
-  #---
-  
-  def self.close(file_names = [])
-    file_names = @@files.keys unless file_names && ! file_names.empty?
-    
-    unless file_names.is_a?(Array)
-      file_names = [ file_names ]
-    end
-    
-    file_names.each do |file_name|
-      @@files[file_name][:file].close if @@files[file_name] && @@files[file_name][:file]
-      @@files.delete(file_name)
-    end
-  end
-end
-end
-end

data/lib/coral_core/util/git.rb

@@ -1,40 +0,0 @@
-module Coral
-class Git < ::Grit::Repo
-  
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-
-  def initialize(path, options = {})
-    epath   = File.expand_path(path)
-    git_dir = File.join(epath, '.git')
-    
-    @bare = (options[:is_bare] ? true : false)
-    
-    if File.exist?(git_dir)
-      self.working_dir = epath
-      
-      if File.directory?(git_dir)
-        self.path = git_dir
-      else
-        git_dir = Util::Disk.read(git_dir)
-        unless git_dir.nil?
-          git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
-          self.path = git_dir if File.directory?(git_dir)
-        end
-      end
-      
-    elsif File.directory?(epath) && (options[:is_bare] || (epath =~ /\.git$/ && File.exist?(File.join(epath, 'HEAD'))))
-      self.path = epath
-      @bare = true
-    end
-
-    self.git = ::Grit::Git.new(self.path)
-    self.git.work_tree = epath
-    
-    unless File.directory?(epath) && self.git.exist?
-      FileUtils.mkdir_p(epath) unless File.directory?(epath)
-      self.git.init({ :bare => @bare })
-    end
-  end
-end
-end

data/lib/coral_core/util/interface.rb

@@ -1,190 +0,0 @@
-require 'log4r'
-
-module Coral
-module Util
-class Interface
-  
-  #-----------------------------------------------------------------------------
-  # Properties
-  
-  @@logger = Log4r::Logger.new("coral::interface")
-  
-  #---
-
-  COLORS = {
-    :clear => "\e[0m",
-    :red => "\e[31m",
-    :green => "\e[32m",
-    :yellow => "\e[33m"
-  }
-
-  COLOR_MAP = {
-    :warn => COLORS[:yellow],
-    :error => COLORS[:red],
-    :success => COLORS[:green]
-  }
-
-  #-----------------------------------------------------------------------------
-  # Constructor
-  
-  def initialize(options = {})
-    class_name = self.class.to_s.downcase
-    
-    if options.is_a?(String)
-      options = { :resource => options, :logger => options }
-    end
-    config = Config.ensure(options)
-    
-    if config.get(:logger, false)
-      if config[:logger].is_a?(String)
-        @logger = Log4r::Logger.new(config[:logger])
-      else
-        @logger = config[:logger]
-      end
-    else
-      @logger = Log4r::Logger.new(class_name)
-    end
-    
-    @resource = config.get(:resource, '')
-    @color = config.get(:color, true)
-    
-    @printer = config.get(:printer, :puts)
-    
-    @input = config.get(:input, $stdin)
-    @output = config.get(:output, $stdout)
-    @error = config.get(:error, $stderr)
-    
-    @delegate = config.get(:ui_delegate, nil)
-  end
-
-  #---
-  
-  def inspect
-    "#<#{self.class}: #{@resource}>"
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Accessors / Modifiers
-  
-  attr_accessor :logger, :resource, :color, :input, :output, :error, :delegate
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.logger
-    return @@logger
-  end
-
-  #-----------------------------------------------------------------------------
-  # UI functionality
-
-  def say(type, message, options = {})
-    return @delegate.say(type, message, options) if check_delegate('say')
-  
-    defaults = { :new_line => true, :prefix => true }
-    options = defaults.merge(options)
-    printer = options[:new_line] ? :puts : :print
-    channel = type == :error || options[:channel] == :error ? @error : @output
-
-    safe_puts(format_message(type, message, options),
-              :channel => channel, :printer => printer)
-  end
-  
-  #---
-
-  def ask(message, options = {})
-    return @delegate.ask(message, options) if check_delegate('ask')
-
-    options[:new_line] = false if ! options.has_key?(:new_line)
-    options[:prefix] = false if ! options.has_key?(:prefix)
-
-    say(:info, message, options)
-    return @input.gets.chomp
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def info(message, *args)
-    @logger.info("info: #{message}")
-    
-    return @delegate.info(message, *args) if check_delegate('info')
-    say(:info, message, *args)
-  end
-  
-  #---
-  
-  def warn(message, *args)
-    @logger.info("warn: #{message}")
-    
-    return @delegate.warn(message, *args) if check_delegate('warn')
-    say(:warn, message, *args)
-  end
-  
-  #---
-  
-  def error(message, *args)
-    @logger.info("error: #{message}")
-    
-    return @delegate.error(message, *args) if check_delegate('error')
-    say(:error, message, *args)
-  end
-  
-  #---
-  
-  def success(message, *args)
-    @logger.info("success: #{message}")
-    
-    return @delegate.success(message, *args) if check_delegate('success')
-    say(:success, message, *args)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-
-  def format_message(type, message, options = {})
-    return @delegate.format_message(type, message, options) if check_delegate('format_message')
-    
-    if @resource && ! @resource.empty? && options[:prefix]
-      prefix = "[#{@resource}]"
-    end
-    message = "#{prefix} #{message}".strip
-    
-    if @color
-      if options.has_key?(:color)
-        color = COLORS[options[:color]]
-        message = "#{color}#{message}#{COLORS[:clear]}"
-      else
-        message = "#{COLOR_MAP[type]}#{message}#{COLORS[:clear]}" if COLOR_MAP[type]
-      end
-    end
-    return message
-  end
-
-  #---
-  
-  def safe_puts(message = nil, options = {})
-    return @delegate.safe_puts(message, options) if check_delegate('safe_puts')
-    
-    #dbg(message, 'message')
-    #dbg(options, 'options')
-    
-    message ||= ""
-    options = {
-      :channel => @output,
-      :printer => @printer,
-    }.merge(options)
-
-    begin
-      options[:channel].send(options[:printer], message)
-    rescue Errno::EPIPE
-      return
-    end
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def check_delegate(method)
-    return ( @delegate && @delegate.respond_to?(method.to_s) )
-  end
-end
-end
-end

data/lib/coral_core/util/process.rb

@@ -1,43 +0,0 @@
-
-module Coral
-module Util
-class Process
-  
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def initialize(name, &code)
-    @name = name   
-    @code = code
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  attr_reader :name
-  
-  #---
-  
-  def provider_options
-    return {
-      :parallel => true
-    }
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Actions
-  
-  def action(action_name, options = {})
-    if action_name == :run
-      run(options)  
-    end
-  end
-  
-  #---
-  
-  def run(options = {})
-    @code.call(options)
-  end  
-end
-end
-end

data/lib/coral_core/util/shell.rb

@@ -1,183 +0,0 @@
-
-module Coral
-module Util
-class Shell < Core
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.exec!(command, options = {})
-    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, Coral.ui)
-    
-    conditions   = Coral::Event.instance(config.get(:exit, {}), true)
-    
-    $stdout.sync = true
-    $stderr.sync = true  
-    
-    for i in tries.downto(1)
-      ui.info(">> running: #{command}")
-      
-      begin
-        t1, output_new, output_orig, output_reader = pipe_exec_stream!($stdout, conditions, { 
-          :prefix => info_prefix, 
-          :suffix => info_suffix, 
-        }, 'output') do |line|
-          block_given? ? yield(line) : true
-        end
-      
-        t2, error_new, error_orig, error_reader = pipe_exec_stream!($stderr, conditions, { 
-          :prefix => error_prefix, 
-          :suffix => error_suffix, 
-        }, 'error') do |line|
-          block_given? ? yield(line) : true
-        end
-      
-        system_success = system(command)
-      
-      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
-      ui.info('')
-      
-      success = ( system_success && output_success && error_success )
-                  
-      min -= 1
-      break if success && min <= 0 && conditions.empty?
-    end
-    unless conditions.empty?
-      success = false
-    end
-    
-    return success   
-  end
-  
-  #---
-  
-  def self.exec(command, options = {})
-    return exec!(command, options)
-  end
-  
-  #---
-  
-  def self.pipe_exec_stream!(output, conditions, options, label)
-    original     = output.dup
-    read, write  = IO.pipe
-    
-    match_prefix = ( options[:match_prefix] ? options[:match_prefix] : 'EXIT' )
-            
-    thread = process_stream!(read, original, options, label) do |line|
-      check_conditions!(line, conditions, match_prefix) do
-        block_given? ? yield(line) : true
-      end
-    end
-    
-    thread.abort_on_exception = false
-    
-    output.reopen(write)    
-    return thread, write, original, read
-  end
-  
-  #---
-  
-  def self.close_exec_pipe(thread, output, original, write, label)
-    output.reopen(original)
-     
-    write.close
-    success = thread.value
-    
-    original.close
-    return success
-  end
-  
-  #---
-  
-  def self.check_conditions!(line, conditions, match_prefix = '')
-    prefix = ''
-    
-    unless ! conditions || conditions.empty?
-      conditions.each do |key, event|
-        if event.check(line)
-          prefix = match_prefix
-          conditions.delete(key)
-        end
-      end
-    end
-    
-    result = true
-    if block_given?
-      result = yield
-      
-      unless prefix.empty?
-        case result
-        when Hash
-          result[:prefix] = prefix
-        else
-          result = { :success => result, :prefix => prefix }
-        end
-      end
-    end
-    return result
-  end
-  
-  #---
-  
-  def self.process_stream!(input, output, options, label)
-    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 = yield(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
-end
-end
-end