nucleon 0.1.0 → 0.1.1

data/lib/core/util/data.rb

@@ -0,0 +1,404 @@
+
+module Nucleon
+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
+  
+  #---
+  
+  def self.exists?(data, keys, check_empty = false)
+    if keys.is_a?(String) || keys.is_a?(Symbol)
+      keys = [ keys ]
+    end    
+    key = keys.shift.to_sym
+    
+    if data.has_key?(key)
+      value = data[key]
+      
+      if keys.empty?
+        return false if check_empty && empty?(value)
+        return true
+      else
+        return exists?(data[key], keys)  
+      end
+    end
+    return false
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Translation
+
+  def self.symbol_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_sym] = symbol_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def self.string_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_s] = string_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def self.parse_json(json_text)
+    return MultiJson.load(json_text)
+  end
+    
+  #---
+  
+  def self.to_json(data, pretty = true)
+    return MultiJson.dump(data, :pretty => pretty)
+  end
+  
+  #---
+  
+  def self.parse_yaml(yaml_text)
+    return YAML.load(yaml_text)
+  end
+  
+  #---
+  
+  def self.to_yaml(data)
+    return YAML.dump(data)
+  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
+  
+  #---
+      
+  def self.filter(data, method = false)
+    if method && method.is_a?(Symbol) && 
+      [ :array, :hash, :string, :symbol, :test ].include?(method.to_sym)
+      return send(method, data)
+    end
+    return data
+  end
+  
+  #---
+          
+  def self.array(data, default = [], split_string = false)
+    result = default    
+    if data
+      case data
+      when Array
+        result = data
+      when String
+        result = [ ( split_string ? data.split(/\s*,\s*/) : data ) ]
+      else
+        result = [ data ]
+      end
+    end
+    return result
+  end
+    
+  #---
+        
+  def self.hash(data, default = {})
+    result = default    
+    if data
+      case data
+      when Hash
+        result = data
+      else
+        result = {}
+      end
+    end
+    return result
+  end
+    
+  #---
+         
+  def self.string(data, default = '')
+    result = default    
+    if data
+      case data
+      when String
+        result = data
+      else
+        result = data.to_s
+      end
+    end
+    return result
+  end
+    
+  #---
+         
+  def self.symbol(data, default = :undefined)
+    result = default    
+    if data
+      case data
+      when Symbol
+        result = data
+      when String
+        result = data.to_sym
+      else
+        result = data.class.to_sym
+      end
+    end
+    return result
+  end
+     
+  #---
+    
+  def self.test(data)
+    return false if Util::Data.empty?(data)
+    return true
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def self.clean(data)
+    data.keys.each do |key|
+      data.delete(key) if data[key].nil?
+    end
+    data
+  end
+  
+  #---
+  
+  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?(Nucleon::Config) ? force.get(:force, true) : force
+    
+    if data.is_a?(Array)
+      value = undef?(data[0]) ? nil : data.shift.clone
+      
+      data.each do |item|
+        item = undef?(item) ? nil : 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
+                
+        else
+          value = item if force || item.is_a?(String) || item.is_a?(Symbol)
+        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
+  
+  #---
+  
+  def self.rm_keys(data, keys)
+    keys = [ keys ] unless keys.is_a?(Array)
+    keys.each do |key|
+      data.delete(key)
+    end
+    data
+  end
+  
+  #---
+  
+  def self.subset(data, keys)
+    keys     = [ keys ] unless keys.is_a?(Array)
+    new_data = {} 
+    keys.each do |key|
+      new_data[key] = data[key] if data.has_key?(key)
+    end
+    new_data 
+  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
+  
+  #---
+  
+  def self.ensure(test, success_value = nil, failure_value = nil)
+    success_value = (success_value ? success_value : test)
+    failure_value = (failure_value ? failure_value : nil)
+      
+    if empty?(test)
+      value = failure_value
+    else
+      value = success_value
+    end
+    return value
+  end
+  
+  #---
+  
+  def self.ensure_value(value, failure_value = nil)
+    return self.ensure(value, nil, failure_value)
+  end
+end
+end
+end

data/lib/core/util/disk.rb

@@ -0,0 +1,114 @@
+
+module Nucleon
+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
+      file.pos = 0 if options[:mode] == 'w'
+      success  = file.write(data)
+      file.flush
+      return success
+    end
+    return nil
+  end
+  
+  #---
+  
+  def self.delete(file_path)
+    return ::File.delete(file_path)
+  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/core/util/git.rb

@@ -0,0 +1,43 @@
+
+module Nucleon
+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 Nucleon.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
+  end
+end
+end
+end

data/lib/core/util/liquid.rb

@@ -0,0 +1,17 @@
+
+module Nucleon
+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/core/util/logger.rb

@@ -0,0 +1,147 @@
+
+module Nucleon
+module Util
+class Logger
+  
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@level   = nil
+  @@loggers = {}
+  
+  #---
+  
+  def self.level
+    @@level  
+  end
+  
+  def self.level=level
+    @@level = set_level(level)
+  end
+  
+  #---
+  
+  def self.loggers
+    @@loggers
+  end
+  
+  #---
+  
+  def self.set_levels(*levels)
+    levels = levels.flatten.collect do |level| 
+      level.to_s.upcase
+    end
+    Log4r::Configurator.custom_levels(*levels)
+  end
+  
+  #---
+  
+  def self.set_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
+  
+  #---
+  
+  def self.add_logger(name, logger)
+    logger.outputters = Log4r::StdoutOutputter.new('console')
+    
+    level = Logger.level.nil? ? 'off' : Logger.level
+    set_level(level, logger)  
+        
+    @@loggers[name] = logger
+  end
+  
+  # Initialize log levels
+  
+  set_levels :debug, :info, :warn, :error, :hook
+    
+  if ENV['NUCLEON_LOG']
+    Logger.level = ENV['NUCLEON_LOG']
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Constructor
+  
+  def initialize(options = {})
+    if options.is_a?(String)
+      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
+  end
+
+  #---
+  
+  def inspect
+    "#<#{self.class}: #{@resource}>"
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  attr_reader :resource
+  
+  #---
+  
+  def logger=logger
+    if logger.is_a?(String)
+      @resource = logger
+      @logger   = Log4r::Logger.new(logger)
+    else
+      @logger = logger
+    end
+    self.class.add_logger(@resource, @logger)  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Log statements
+  
+  def debug(message)
+    @logger.debug(message)
+  end
+  
+  #---
+  
+  def info(message)
+    @logger.info(message)
+  end
+  
+  #---
+  
+  def warn(message)
+    @logger.warn(message)
+  end
+  
+  #---
+  
+  def error(message)
+    @logger.error(message)
+  end
+  
+  #---
+  
+  def hook(message)
+    @logger.hook(message)  
+  end          
+end
+end
+end