coral_core 0.2.19 → 0.2.21

data/lib/coral_core/util/data.rb

@@ -1,219 +0,0 @@
-
-module Coral
-module Util
-class Data
-  
-  #-----------------------------------------------------------------------------
-  # Type checking
-  
-  def self.undef?(value)
-    if value.nil? || 
-      (value.is_a?(Symbol) && value == :undef || value == :undefined) || 
-      (value.is_a?(String) && value.match(/^\s*(undef|UNDEF|Undef|nil|NIL|Nil)\s*$/))
-      return true
-    end
-    return false  
-  end
-  
-  #---
-  
-  def self.true?(value)
-    if value == true || 
-      (value.is_a?(String) && value.match(/^\s*(true|TRUE|True)\s*$/))
-      return true
-    end
-    return false  
-  end
-  
-  #---
-  
-  def self.false?(value)
-    if value == false || 
-      (value.is_a?(String) && value.match(/^\s*(false|FALSE|False)\s*$/))
-      return true
-    end
-    return false  
-  end
-  
-  #---
-  
-  def self.empty?(value)
-    if undef?(value) || false?(value) || (value.respond_to?('empty?') && value.empty?)
-      return true
-    end
-    return false
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Translation
-  
-  def self.to_json(data)
-    output = ''
-    begin
-      output = data.to_json
-      
-    rescue Exception
-    end
-    return output
-  end
-  
-  #---
-  
-  def self.to_yaml(data)
-    output = ''
-    begin
-      require 'yaml'
-      output = YAML.dump(data)
-      
-    rescue Exception
-    end
-    return output
-  end
-  
-  #---
-  
-  def self.value(value)
-    case value
-    when String
-      if undef?(value)
-        value = nil
-      elsif true?(value)
-        value = true
-      elsif false?(value)
-        value = false
-      end
-    
-    when Array
-      value.each_with_index do |item, index|
-        value[index] = value(item)
-      end
-    
-    when Hash
-      value.each do |key, data|
-        value[key] = value(data)
-      end
-    end
-    return value  
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Operations
-  
-  def self.merge(data, force = true)
-    value = data
-    
-    # Special case because this method is called from within Config.new so we 
-    # can not use Config.ensure, as that would cause an infinite loop.
-    force = force.is_a?(Coral::Config) ? force.get(:force, true) : force
-    
-    if data.is_a?(Array)
-      value = data.shift.clone
-      
-      data.each do |item|
-        item = item.clone
-        
-        case value
-        when Hash
-          begin
-            require 'deep_merge'
-            value = force ? value.deep_merge!(item) : value.deep_merge(item)
-            
-          rescue LoadError
-            if item.is_a?(Hash) # Non recursive top level by default.
-              value = value.merge(item)              
-            elsif force
-              value = item
-            end
-          end  
-        when Array
-          if item.is_a?(Array)
-            value = value.concat(item).uniq
-          elsif force
-            value = item
-          end
-                
-        when String, Symbol
-          value = item if item.is_a?(String) || item.is_a?(Symbol) || force 
-        end
-      end  
-    end
-    
-    return value
-  end
-
-  #---
-  
-  def self.interpolate(value, scope, options = {})    
-    
-    pattern = ( options.has_key?(:pattern) ? options[:pattern] : '\$(\{)?([a-zA-Z0-9\_\-]+)(\})?' )
-    group   = ( options.has_key?(:var_group) ? options[:var_group] : 2 )
-    flags   = ( options.has_key?(:flags) ? options[:flags] : '' )
-    
-    if scope.is_a?(Hash)
-      regexp = Regexp.new(pattern, flags.split(''))
-    
-      replace = lambda do |item|
-        matches = item.match(regexp)
-        result  = nil
-        
-        #dbg(item, 'item')
-        #dbg(matches, 'matches')
-        
-        unless matches.nil?
-          replacement = scope.search(matches[group], options)
-          result      = item.gsub(matches[0], replacement) unless replacement.nil?
-        end
-        return result
-      end
-      
-      case value
-      when String
-        #dbg(value, 'interpolate (string) -> init')
-        while (temp = replace.call(value))
-          #dbg(temp, 'interpolate (string) -> replacement')
-          value = temp
-        end
-        
-      when Hash
-        #dbg(value, 'interpolate (hash) -> init')
-        value.each do |key, data|
-          #dbg(data, "interpolate (#{key}) -> data")
-          value[key] = interpolate(data, scope, options)
-        end
-      end
-    end
-    #dbg(value, 'interpolate -> result')
-    return value  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.prefix(prefix, data)
-    result = nil
-    
-    unless prefix.is_a?(String) && ! empty?(prefix)
-      prefix = ''
-    end
-    
-    case data
-    when String, Symbol
-      result = ( prefix.empty? ? data.to_s : prefix + '_' + data.to_s )
-      
-    when Array
-      result = []
-      data.each do |value|
-        result << prefix(prefix, value)
-      end
-      
-    when Hash
-      result = {}
-      data.each do |key, value|
-        result[prefix(prefix, key)] = value  
-      end      
-    end
-    return result
-  end
-end
-end
-end

data/lib/coral_core/util/disk.rb

@@ -1,92 +0,0 @@
-
-module Coral
-module Util
-class Disk
-  
-  #-----------------------------------------------------------------------------
-  # Properties
- 
-  @@files = {}
-  
-  @@separator   = false
-  @@description = ''
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  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
-      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/base.rb

@@ -1,58 +0,0 @@
-
-module Git
-
-#*******************************************************************************
-# Errors
-  
-class GitDirectoryError < StandardError 
-end
-
-#*******************************************************************************
-# Base Git definition
-
-class Base
- 
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def initialize(options = {})
-    if working_dir = options[:working_directory]
-      options[:repository] ||= File.join(working_dir, '.git')
-      
-      if File.file?(options[:repository])
-        File.read(options[:repository]).each_line do |line|
-          matches = line.match(/^\s*gitdir:\s*(.+)\s*/)
-          if matches.length && matches[1]
-            options[:repository] = matches[1]
-            break
-          end
-        end        
-      end
-      
-      if File.directory?(options[:repository])
-        options[:index] ||= File.join(options[:repository], 'index')
-      else
-        raise GitDirectoryError.new("Git repository directory #{options[:repository]} not found for #{working_dir}")
-      end
-    end
-    
-    if options[:log]
-      @logger = options[:log]
-      @logger.info("Starting Git")
-    else
-      @logger = nil
-    end
-     
-    @working_directory = options[:working_directory] ? Git::WorkingDirectory.new(options[:working_directory]) : nil
-    @repository        = options[:repository] ? Git::Repository.new(options[:repository]) : nil 
-    @index             = options[:index] ? Git::Index.new(options[:index], false) : nil
-  end
-    
-  #-----------------------------------------------------------------------------
-  # Commit extensions
-
-  def add(path = '.', opts = {})
-    self.lib.add(path, opts)
-  end
-end
-end

data/lib/coral_core/util/git/lib.rb

@@ -1,82 +0,0 @@
-
-module Git
-class Lib
-
-  #-----------------------------------------------------------------------------
-  # Commit extensions
-  
-  def add(path = '.', opts = {})
-    arr_opts = []
-    arr_opts << '-u' if opts[:update]
-    if path.is_a?(Array)
-      arr_opts += path
-    else
-      arr_opts << path
-    end
-    command('add', arr_opts)
-  end
-  
-  #---
-  
-  def commit(message, opts = {})
-    arr_opts = ['-m', message]
-    arr_opts << "--author=\'#{opts[:author]}\'" unless opts[:author] && opts[:author].empty?
-    arr_opts << '-a' if opts[:add_all]
-    arr_opts << '--allow-empty' if opts[:allow_empty]      
-    command('commit', arr_opts)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Remote extensions
-  
-  def remote_add(name, url, opts = {})
-    arr_opts = ['add']
-    arr_opts << '-f' if opts[:with_fetch]
-    arr_opts << name
-    arr_opts << url
-      
-    command('remote', arr_opts)
-  end
-  
-  #---
-
-  def remote_set_url(name, url, opts = {})
-    arr_opts = ['set-url']
-      
-    if opts[:add]
-      arr_opts << '--add' if opts[:add]
-    end
-      
-    if opts[:delete]
-      arr_opts << '--delete' if opts[:delete]
-    end
-      
-    if opts[:push]
-      arr_opts << '--push' if opts[:push]
-    end
-        
-    arr_opts << name
-    arr_opts << url
-      
-    command('remote', arr_opts)
-  end
-  
-  #---
-      
-  def remote_remove(name)
-    command('remote', ['rm', name])
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def escape(s)
-    escaped = s.to_s.gsub('"', '\'')
-    if escaped =~ /^\-+/
-      escaped  
-    else
-      %Q{"#{escaped}"}
-    end
-  end
-end
-end

data/lib/coral_core/util/git/remote.rb

@@ -1,12 +0,0 @@
-
-module Git
-class Remote
-  
-  #-----------------------------------------------------------------------------
-  # Remote endpoints
-
-  def set_url(url, opts = {})
-    @base.lib.remote_set_url(@name, url, opts)  
-  end
-end
-end

data/lib/coral_core/util/git.rb

@@ -1,15 +0,0 @@
-
-require 'git'
-
-module Git
-
-  #-----------------------------------------------------------------------------
-  # Utilities
-
-  def self.url(host, repo, options = {})
-    options[:user] = ( options[:user] ? options[:user] : 'git' )
-    options[:auth] = ( options[:auth] ? options[:auth] : true )
-    
-    return options[:user] + ( options[:auth] ? '@' : '://' ) + host + ( options[:auth] ? ':' : '/' ) + repo
-  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