nucleon 0.1.0 → 0.1.1

data/lib/core/config.rb

@@ -0,0 +1,342 @@
+
+module Nucleon
+class Config
+  
+  #-----------------------------------------------------------------------------
+  # Global interface
+
+  extend Mixin::ConfigOptions
+  extend Mixin::ConfigCollection
+  
+  #-----------------------------------------------------------------------------
+  # Instance generators
+  
+  def self.ensure(config)
+    case config
+    when Nucleon::Config
+      return config
+    when Hash
+      return new(config) 
+    end
+    return new
+  end
+  
+  #---
+  
+  def self.init(options, contexts = [], hierarchy = [], defaults = {})
+    contexts = contexts(contexts, hierarchy)
+    config   = new(get_options(contexts), defaults)
+    config.import(options) unless Util::Data.empty?(options)
+    return config
+  end
+  
+  #---
+  
+  def self.init_flat(options, contexts = [], defaults = {})
+    return init(options, contexts, [], defaults)
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+   
+  def initialize(data = {}, defaults = {}, force = true)
+    @force      = force
+    @properties = {}
+    
+    if defaults.is_a?(Hash) && ! defaults.empty?
+      defaults = symbol_map(defaults)
+    end
+    
+    case data
+    when Nucleon::Config
+      @properties = Util::Data.merge([ defaults, data.export ], force)
+    when Hash
+      @properties = {}
+      if data.is_a?(Hash)
+        @properties = Util::Data.merge([ defaults, symbol_map(data) ], force)
+      end  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def empty?
+    @properties.empty?
+  end
+  
+  #---
+  
+  def has_key?(keys)
+    get(keys) ? true : false
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def keys
+    @properties.keys
+  end
+  
+  #---
+    
+  def fetch(data, keys, default = nil, format = 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 filter(value, format)
+      else
+        return fetch(data[key], keys, default, format)  
+      end
+    end
+    return filter(default, format)
+  end
+  protected :fetch
+  
+  #---
+  
+  def modify(data, keys, value = nil) 
+    if keys.is_a?(String) || keys.is_a?(Symbol)
+      keys = [ keys ]
+    end
+        
+    key      = keys.shift.to_sym
+    has_key  = data.has_key?(key)
+    existing = { 
+      :key   => key, 
+      :value => ( has_key ? data[key] : nil ) 
+    }
+    
+    if keys.empty?      
+      existing[:value] = data[key] if has_key
+      
+      if value.nil?
+        data.delete(key) if has_key
+      else
+        data[key] = value
+      end
+    else      
+      data[key] = {} unless has_key
+      existing  = modify(data[key], keys, value)  
+    end
+    
+    return existing
+  end
+  protected :modify
+  
+  #---
+  
+  def get(keys, default = nil, format = false)
+    return fetch(@properties, array(keys).flatten, default, format)
+  end
+
+  #---
+ 
+  def [](name, default = nil, format = false)
+    get(name, default, format)
+  end
+  
+  #---
+  
+  def get_array(keys, default = [])
+    return get(keys, default, :array)
+  end
+  
+  #---
+  
+  def get_hash(keys, default = {})
+    return get(keys, default, :hash)
+  end
+  
+  #---
+  
+  def init(keys, default = nil)
+    return set(keys, get(keys, default))
+  end
+
+  #---
+  
+  def set(keys, value)
+    modify(@properties, array(keys).flatten, value)
+    return self
+  end
+  
+  #---
+  
+  def []=(name, value)
+    set(name, value)
+  end
+   
+  #---
+  
+  def delete(keys, default = nil)
+    existing = modify(@properties, array(keys).flatten, nil)
+    return existing[:value] if existing[:value]
+    return default
+  end
+  
+  #---
+  
+  def clear
+    @properties = {}
+    return self
+  end
+
+  #-----------------------------------------------------------------------------
+  # Import / Export
+ 
+  def import_base(properties, options = {})
+    config      = Config.new(options, { :force => @force }).set(:context, :hash)    
+    import_type = config.get(:import_type, :override)
+    
+    properties  = properties.export if properties.is_a?(Nucleon::Config)
+    
+    case properties
+    when Hash
+      data = [ @properties, symbol_map(properties) ]
+      data = data.reverse if import_type != :override
+      
+      @properties = Util::Data.merge(data, config)
+    
+    when String, Symbol
+      properties = self.class.lookup(properties.to_s, {}, config)
+      
+      data = [ @properties, symbol_map(properties) ]
+      data = data.reverse if import_type != :override
+    
+      @properties = Util::Data.merge(data, config)
+     
+    when Array
+      properties.each do |item|
+        import_base(item, config)
+      end
+    end
+    
+    return self
+  end
+  protected :import_base
+  
+  #---
+  
+  def import(properties, options = {})
+    return import_base(properties, options)
+  end
+  
+  #---
+  
+  def defaults(defaults, options = {})
+    config = Config.new(options).set(:import_type, :default)
+    return import_base(defaults, config)
+  end
+
+  #---
+  
+  def export
+    return @properties
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def self.symbol_map(data)
+    return Util::Data.symbol_map(data)
+  end
+  
+  #---
+  
+  def symbol_map(data)
+    return self.class.symbol_map(data)
+  end
+  
+  #---
+  
+  def self.string_map(data)
+    return Util::Data.string_map(data)
+  end
+  
+  #---
+  
+  def string_map(data)
+    return self.class.string_map(data)
+  end
+  
+  #-----------------------------------------------------------------------------
+      
+  def self.filter(data, method = false)
+    return Util::Data.filter(data, method)
+  end
+  
+  #---
+  
+  def filter(data, method = false)
+    return self.class.filter(data, method)
+  end
+    
+  #-----------------------------------------------------------------------------
+          
+  def self.array(data, default = [], split_string = false)
+    return Util::Data.array(data, default, split_string)
+  end
+  
+  #---
+  
+  def array(data, default = [], split_string = false)
+    return self.class.array(data, default, split_string)
+  end
+    
+  #---
+        
+  def self.hash(data, default = {})
+    data = data.export if data.is_a?(Nucleon::Config)
+    return Util::Data.hash(data, default)
+  end
+  
+  #---
+  
+  def hash(data, default = {})
+    return self.class.hash(data, default)
+  end
+    
+  #---
+         
+  def self.string(data, default = '')
+    return Util::Data.string(data, default)
+  end
+  
+  #---
+  
+  def string(data, default = '')
+    return self.class.string(data, default)
+  end
+    
+  #---
+         
+  def self.symbol(data, default = :undefined)
+    return Util::Data.symbol(data, default)
+  end
+  
+  #---
+  
+  def symbol(data, default = :undefined)
+    return self.class.symbol(data, default)
+  end
+     
+  #---
+    
+  def self.test(data)
+    return Util::Data.test(data)
+  end
+  
+  #---
+  
+  def test(data)
+    return self.class.test(data)
+  end  
+end
+end

data/lib/core/core.rb

@@ -0,0 +1,54 @@
+
+module Nucleon
+class Core < Config
+  
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@logger = Util::Logger.new('core')
+  @@ui     = Util::Console.new('core')
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(data = {}, defaults = {}, force = true)
+    super(data, defaults, force)   
+    
+    class_label = self.class.to_s.downcase.gsub(/^nucleon::/, '')
+    
+    @logger = Util::Logger.new(delete(:logger, class_label))
+    @ui     = Util::Console.new(Config.new(export).defaults({ :resource => class_label }))
+    
+    logger.debug('Initialized instance logger and interface')
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessor / Modifiers
+  
+  attr_accessor :logger, :ui
+  
+  #---
+  
+  def self.logger
+    return @@logger
+  end
+  
+  #---
+  
+  def self.ui
+    return @@ui
+  end
+  
+  #-----------------------------------------------------------------------------
+  # General utilities
+  
+  def ui_group(resource)
+    ui_resource = ui.resource
+    ui.resource = resource
+    yield
+    
+  ensure
+    ui.resource = ui_resource  
+  end 
+end
+end

data/lib/core/errors.rb

@@ -0,0 +1,84 @@
+
+module Nucleon
+module Errors
+  
+  #-----------------------------------------------------------------------------
+  # Base error (based on VagrantError)
+  
+  class NucleonError < StandardError
+    
+    #---------------------------------------------------------------------------
+    # Error constructor / destructor
+    
+    def initialize(*args)
+      key     = args.shift if args.first.is_a?(Symbol)
+      message = args.shift if args.first.is_a?(Hash)
+      message ||= {}
+      
+      @extra_data = message.dup
+      
+      message[:key]       ||= error_key
+      message[:namespace] ||= error_namespace
+      message[:key]       = key if key
+
+      if message[:key]
+        message = translate_error(message)
+      else
+        message = error_message
+      end
+
+      super(message)
+    end
+
+    #---------------------------------------------------------------------------
+    # Property accessor / modifiers
+    
+    attr_accessor :extra_data
+    
+    #---
+
+    def self.error_key(key = nil, namespace = nil)
+      define_method(:error_key) { key }
+      error_namespace(namespace) if namespace
+    end
+    def error_key; nil; end # Default
+    
+    #---
+
+    def self.error_message(message)
+      define_method(:error_message) { message }
+    end
+    def error_message; "No error message"; end # Default
+    
+    #---
+
+    def self.error_namespace(namespace)
+      define_method(:error_namespace) { namespace }
+    end
+    def error_namespace; "nucleon.errors"; end # Default
+    
+    #---
+    
+    def self.status_code(code)
+      define_method(:status_code) { code }
+    end
+    def status_code; 1; end # Default
+    
+    #---------------------------------------------------------------------------
+    # Utilities
+
+    def translate_error(options)
+      return nil unless options[:key]
+      I18n.t("#{options[:namespace]}.#{options[:key]}", options)
+    end
+    protected :translate_error
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Specialized errors
+
+  class BatchError < NucleonError
+    error_key(:batch_error)
+  end
+end
+end