corl 0.4.0 → 0.4.1

data/lib/corl_core/util/git.rb

@@ -1,47 +0,0 @@
-module CORL
-module Util
-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)
-    
-    Grit.debug = true if CORL.log_level == :debug
-    
-    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
-      
-    else
-      self.path = git_dir
-    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
-end

data/lib/corl_core/util/interface.rb

@@ -1,319 +0,0 @@
-
-module CORL
-module Util
-class Interface
-  
-  #-----------------------------------------------------------------------------
-  # Properties
-  
-  @@log_level = nil
-  @@loggers   = {}
-  
-  def self.log_level
-    @@log_level  
-  end
-  
-  def self.log_level=level
-    @@log_level = set_log_level(level)
-  end
-  
-  #---
-  
-  def self.loggers
-    @@loggers
-  end
-  
-  def self.add_log_levels(*levels)
-    levels = levels.flatten.collect do |level| 
-      level.to_s.upcase
-    end
-    Log4r::Configurator.custom_levels(*levels)
-  end
-  
-  def self.add_logger(name, logger)
-    logger.outputters = Log4r::StdoutOutputter.new('console')
-    
-    level = log_level.nil? ? 'off' : log_level
-    set_log_level(level, logger)  
-        
-    @@loggers[name] = logger
-  end
-  
-  def self.set_log_level(level, logger = nil)
-    level_sym   = level.to_s.downcase.to_sym
-    level_id    = level.to_s.upcase
-    
-    if logger.nil?
-      loggers.each do |name, registered_logger|
-        @@loggers[name].level = Log4r.const_get(level_id)
-      end
-    else
-      if logger.levels.include?(level_id)
-        logger.level = Log4r.const_get(level_id)
-      end
-    end
-    level_sym
-  end
-  
-  #---
-  
-  # Initialize log levels
-  
-  add_log_levels :debug, :info, :warn, :error, :hook
-    
-  if ENV['CORL_LOG']
-    Interface.log_level = ENV['CORL_LOG']
-  end
-    
-  #---
-  
-  @@ui_lock = Mutex.new
-  
-  #---
-
-  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 = {})
-    if options.is_a?(String)
-      options = { :resource => options, :logger => options }
-    end
-    config = Config.ensure(options)
-    
-    @resource = config.get(:resource, '')
-    
-    if config.get(:logger, false)
-      self.logger = config[:logger]
-    else
-      self.logger = Log4r::Logger.new(@resource)
-    end     
-    
-    @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_reader :logger
-  attr_accessor :resource, :color, :input, :output, :error, :delegate
-  
-  #---
-  
-  def logger=logger
-    if logger.is_a?(String)
-      @logger = Log4r::Logger.new(logger)
-    else
-      @logger = logger
-    end
-    self.class.add_logger(@resource, @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
-    
-    options[:sync] = true unless options.has_key?(:sync)
-    
-    render = lambda do 
-      safe_puts(format_message(type, message, options),
-                :channel => channel, :printer => printer)  
-    end
-    
-    if options[:sync]
-      @@ui_lock.synchronize do
-        render.call
-      end
-    else
-      render.call
-    end
-  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)
-    options[:echo] = true if ! options.has_key?(:echo)
-    
-    options[:sync] = true unless options.has_key?(:sync)
-    
-    user_input = nil
-    
-    collect = lambda do 
-      say(:info, message, Config.ensure(options).import({ :sync => false }).export)
-      
-      if options[:echo]
-        user_input = @input.gets.chomp
-      else
-        require 'io/console'        
-        user_input = @input.noecho(&:gets).chomp
-      end
-      safe_puts("\n")
-      user_input  
-    end
-
-    if options[:sync]
-      @@ui_lock.synchronize do
-        return collect.call
-      end
-    else
-      return collect.call  
-    end
-  end
-  
-  #---
-  
-  def password(type, options = {})
-    return @delegate.password(type, options) if check_delegate('password')
-    
-    options[:sync] = true unless options.has_key?(:sync)
-    
-    collect = lambda do
-      try_again = true
-      password  = nil
-      
-      while try_again
-        # Get and check a password from the keyboard
-        password              = ask("Enter #{type} password: ", { :echo => false, :sync => false })
-        confirmation_password = ask("Confirm #{type} password: ", { :echo => false, :sync => false })
-    
-        if password != confirmation_password
-          choice    = ask('Passwords do not match!  Try again? (Y|N): ', { :sync => false })
-          try_again = choice.upcase == "Y"
-          password  = nil unless try_again
-        else
-          try_again = false
-        end
-      end
-      password
-    end
-    
-    if options[:sync]
-      @@ui_lock.synchronize do
-        return collect.call
-      end
-    else
-      return collect.call  
-    end
-  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')    
-    return '' if message.to_s.strip.empty?
-    
-    if @resource && ! @resource.empty? && options[:prefix]
-      prefix = "[#{@resource}]"
-    end
-    message = "#{prefix} #{message}".lstrip.gsub(/\n+$/, '')
-    
-    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')
-    
-    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/corl_core/util/liquid.rb

@@ -1,17 +0,0 @@
-
-module CORL
-module Util
-class Liquid
-
-  def initialize(&code)
-    @code = code  
-  end
-  
-  #---
-  
-  def method_missing(method, *args, &block)  
-    @code.call(method, args, block)
-  end   
-end
-end
-end

data/lib/corl_core/util/package.rb

@@ -1,93 +0,0 @@
-
-module CORL
-module Util
-class Package
-  
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def initialize(options = {})
-    if options.is_a?(String)
-      @data = Config.new
-      decode(options)  
-    else
-      @data = Config.ensure(options)
-    end
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  attr_reader :data
- 
-  #-----------------------------------------------------------------------------
-  # Operations
-
-  def encode
-    Base64.encode64(Data.to_json(data.export, false))
-  end
-      
-  def decode(encoded_string)
-    data.import(Data.symbol_map(Data.parse_json(Base64.decode64(encoded_string))))  
-  end
-  
-  #---
-  
-  def add_file(file, target_path = nil, perm = 0600)    
-    target_path = file if target_path.nil?
-    file        = File.expand_path(file)
-    
-    if File.exists?(file)
-      content = Disk.read(file)
-      data.set([ :files, target_path ], { :perm => perm, :content => content }) if content
-    end
-    self
-  end
-  
-  #---
-  
-  def add_files(base_path, file_glob, target_path = nil, perm = 0600)
-    target_path = base_path if target_path.nil?
-    curr_dir    = Dir.pwd
-    
-    Dir.chdir(File.expand_path(base_path))
-    Dir.glob(file_glob.gsub(/^[\/\\]+/, '')) do |file|
-      content = Disk.read(file)
-      
-      if content
-        data.set([ :dir, target_path, file ], { :perm => perm, :content => content })
-      end
-    end
-    Dir.chdir(curr_dir)
-    self      
-  end
-  
-  #---
-  
-  def extract(base_path)
-    success = true
-    
-    data.get_hash(:files).each do |target_path, info|
-      file    = File.join(base_path.to_s, target_path.to_s)
-      perm    = info[:perm]
-      content = info[:content]
-      
-      FileUtils.mkdir_p(File.dirname(file))      
-      success = false unless Disk.write(file, content) && File.chmod(perm, file)
-    end
-    
-    data.get_hash(:dir).each do |target_path, files|
-      files.each do |file, info|
-        file    = File.join(base_path.to_s, target_path.to_s, file.to_s)
-        perm    = info[:perm]
-        content = info[:content]
-        
-        FileUtils.mkdir_p(File.dirname(file))
-        success = false unless Disk.write(file, content) && File.chmod(perm, file)
-      end      
-    end
-    success
-  end
-end
-end
-end