coral_core 0.2.30 → 0.4.0

data/lib/coral_core/mixin/config_options.rb

@@ -1,38 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::ConfigOptions
-#
-
-module Coral
-module Mixin
-module ConfigOptions
-  #-----------------------------------------------------------------------------
-  # Configuration options interface
-  
-  def contexts(contexts = [], hierarchy = [])
-    return Config::Options.contexts(contexts, hierarchy)  
-  end
-  
-  #---
-  
-  def get_options(contexts, force = true)
-    return Config::Options.get(contexts, force)  
-  end
-  
-  #---
-  
-  def set_options(contexts, options, force = true)
-    Config::Options.set(contexts, options, force)
-    return self  
-  end
-  
-  #---
-  
-  def clear_options(contexts)
-    Config::Options.clear(contexts)
-    return self  
-  end
-end
-end
-end

data/lib/coral_core/mixin/lookup.rb

@@ -1,211 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::Lookup
-#
-
-module Coral
-module Mixin
-module Lookup
-  #-----------------------------------------------------------------------------
-  # Hiera configuration
-  
-  @@hiera = nil
-  
-  #---
-  
-  def hiera_config
-    config_file = Puppet.settings[:hiera_config]
-    config      = {}
-
-    if File.exist?(config_file)
-      config = Hiera::Config.load(config_file)
-    else
-      ui.warn("Config file #{config_file} not found, using Hiera defaults")
-    end
-
-    config[:logger] = 'puppet'
-    return config
-  end
-  
-  #---
-
-  def hiera
-    @@hiera = Hiera.new(:config => hiera_config) unless @@hiera
-    return @@hiera
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Configuration lookup interface
-      
-  def initialized?(options = {})
-    config   = Config.ensure(options)
-    
-    begin
-      require 'hiera'
-      puppet_scope = config.get(:puppet_scope, scope)
-    
-      prefix_text = config.get(:prefix_text, '::')  
-      init_fact   = prefix_text + config.get(:init_fact, 'hiera_ready')
-      
-      if Puppet::Parser::Functions.function('hiera') && puppet_scope.respond_to?('[]')
-        return true if Util::Data.true?(puppet_scope[init_fact])
-      end
-      return false
-    
-    rescue Exception # Prevent abortions.
-    end    
-    return false
-  end
-  
-  #---
-    
-  def lookup(properties, default = nil, options = {})
-    config          = Config.ensure(options)
-    value           = nil
-    
-    hiera_scope     = config.get(:hiera_scope, {})
-    context         = config.get(:context, :priority)    
-    override        = config.get(:override, nil)
-    
-    puppet_scope    = config.get(:puppet_scope, scope)
-    
-    base_names      = config.get(:search, nil)
-     
-    search_name     = config.get(:search_name, true)
-    reverse_lookup  = config.get(:reverse_lookup, true)
-    
-    return_property = config.get(:return_property, false)
-    
-    unless properties.is_a?(Array)
-      properties = [ properties ].flatten
-    end
-
-    first_property = nil
-    properties.each do |property|
-      first_property = property unless first_property
-          
-      if initialized?(config)
-        unless hiera_scope.respond_to?('[]')
-          hiera_scope = Hiera::Scope.new(hiera_scope)
-        end
-        value = hiera.lookup(property, nil, hiera_scope, override, context)
-      end 
-    
-      if Util::Data.undef?(value)    
-        log_level = Puppet::Util::Log.level
-        Puppet::Util::Log.level = :err # Don't want failed parameter lookup warnings here.
-      
-        if base_names
-          if base_names.is_a?(String)
-            base_names = [ base_names ]
-          end
-          base_names = base_names.reverse if reverse_lookup
-        
-          base_names.each do |base|
-            value = puppet_scope.lookupvar("::#{base}::#{property}")
-            break unless Util::Data.undef?(value)  
-          end
-        end
-        if Util::Data.undef?(value) && search_name
-          value = puppet_scope.lookupvar("::#{property}")
-        end
-        Puppet::Util::Log.level = log_level
-      end
-    end
-    value = default if Util::Data.undef?(value)
-    value = Util::Data.value(value)
-    
-    if ! @@properties.has_key?(first_property) || ! Util::Data.undef?(value)
-      Config::Collection.set(first_property, value)
-    end
-    return value, first_property if return_property
-    return value
-  end
-    
-  #---
-  
-  def lookup_array(properties, default = [], options = {})
-    config          = Config.ensure(options) 
-    value, property = lookup(properties, nil, config.import({ :return_property => true }))
-    
-    if Util::Data.undef?(value)
-      value = default
-        
-    elsif ! Util::Data.empty?(default)
-      if config.get(:merge, false)
-        value = Util::Data.merge([default, value], config)
-      end
-    end
-    
-    unless value.is_a?(Array)
-      value = ( Util::Data.empty?(value) ? [] : [ value ] )
-    end
-    
-    Config::Collection.set(property, value)
-    return value
-  end
-    
-  #---
-  
-  def lookup_hash(properties, default = {}, options = {})
-    config          = Config.ensure(options) 
-    value, property = lookup(properties, nil, config.import({ :return_property => true }))
-    
-    if Util::Data.undef?(value)
-      value = default
-        
-    elsif ! Util::Data.empty?(default)
-      if config.get(:merge, false)
-        value = Util::Data.merge([default, value], config)
-      end
-    end
-    
-    unless value.is_a?(Hash)
-      value = ( Util::Data.empty?(value) ? {} : { :value => value } )
-    end
-    
-    Config::Collection.set(property, value)
-    return value
-  end
-  
-  #---
-
-  def normalize(data, override = nil, options = {})
-    config  = Config.ensure(options)
-    results = {}
-    
-    unless Util::Data.undef?(override)
-      case data
-      when String, Symbol
-        data = [ data, override ] if data != override
-      when Array
-        data << override unless data.include?(override)
-      when Hash
-        data = [ data, override ]
-      end
-    end
-    
-    case data
-    when String, Symbol
-      results = lookup(data.to_s, {}, config)
-      
-    when Array
-      data.each do |item|
-        if item.is_a?(String) || item.is_a?(Symbol)
-          item = lookup(item.to_s, {}, config)
-        end
-        unless Util::Data.undef?(item)
-          results = Util::Data.merge([ results, item ], config)
-        end
-      end
-  
-    when Hash
-      results = data
-    end
-    
-    return results
-  end
-end
-end
-end

data/lib/coral_core/mixin/macro/object_interface.rb

@@ -1,292 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::Macro::ObjectInterface
-#
-
-module Coral
-module Mixin
-module Macro
-module ObjectInterface
-  
-  # requires Mixin::SubConfig
-  # requires Mixin::Settings
-
-  #-----------------------------------------------------------------------------
-  # Object collections
-  
-  @@object_types = {}
-
-  #---
-  
-  def object_collection(_type, _method_options = {})
-    _method_config = Config.ensure(_method_options)
-    
-    _plural      = _method_config.init(:plural, "#{_type}s").get(:plural)
-    
-    unless _ensure_proc = _method_config.get(:ensure_proc, false)
-      _ensure_proc = Proc.new {|name, options = {}| options }
-    end
-    _delete_proc = _method_config.get(:delete_proc)
-    _search_proc = _method_config.get(:search_proc)
-    
-    @@object_types[_type] = _method_config
-    
-    #---------------------------------------------------------------------------
-    
-    object_utilities
-    
-    #---
-    
-    unless respond_to? :each_object!
-      define_method :each_object! do |object_types = nil|
-        each_object_type!(object_types) do |type, plural, options|
-          send(plural).each do |name, obj|
-            yield(type, name, obj)  
-          end 
-        end  
-      end
-    end
-     
-    #---------------------------------------------------------------------------
-    
-    define_method "#{_type}_config" do |name = nil|
-      Config.new( name ? get([ _plural, name ], {}) : get(_plural, {}) )
-    end
-  
-    #---
-    
-    define_method "#{_type}_setting" do |name, property, default = nil, format = false|
-      get([ _plural, name, property ], default, format)
-    end
-  
-    #---
-    
-    define_method "#{_plural}" do
-      _get(_plural, {})
-    end
-    
-    #---
-  
-    define_method "init_#{_plural}" do
-      data = hash(_search_proc.call) if _search_proc
-      data = get_hash(_plural) unless data
-      
-      symbol_map(data).each do |name, options|
-        if name != :settings
-          options[:object_container] = self
-          
-          obj = _ensure_proc.call(name, options)
-          _set([ _plural, name ], obj)
-        end
-      end
-    end
-  
-    #---
-
-    define_method "set_#{_plural}" do |data = {}|
-      data = Config.ensure(data).export
-    
-      send("clear_#{_plural}")
-      set(_plural, data)
-    
-      data.each do |name, options|
-        options[:object_container] = self
-        
-        obj = _ensure_proc.call(name, options)
-        _set([ _plural, name ], obj)
-      end
-      self
-    end
-
-    #---
-    
-    define_method "#{_type}" do |name|
-      _get([ _plural, name ])
-    end
-    
-    #---
-
-    define_method "set_#{_type}" do |name, options = {}|
-      options = Config.ensure(options).export
-      
-      set([ _plural, name ], options)
-    
-      options[:object_container] = self
-      
-      obj = _ensure_proc.call(name, options) 
-      _set([ _plural, name ], obj)
-      self
-    end
-  
-    #---
-  
-    define_method "set_#{_type}_setting" do |name, property, value = nil|
-      set([ _plural, name, property ], value)
-      self
-    end
-    
-    #---
-
-    define_method "delete_#{_type}" do |name|
-      obj = send(_type, name)
-    
-      delete([ _plural, name ])
-      _delete([ _plural, name ])
-    
-      _delete_proc.call(obj) if _delete_proc
-      self
-    end
-  
-    #---
-  
-    define_method "delete_#{_type}_setting" do |name, property|
-      delete([ _plural, name, property ])
-      self
-    end
-  
-    #---
-  
-    define_method "clear_#{_plural}" do
-      _get(_plural).keys.each do |name|
-        send("delete_#{_type}", name)
-      end
-      self
-    end    
-        
-    #---------------------------------------------------------------------------
-  
-    define_method "search_#{_type}" do |name, keys, default = '', format = false|
-      obj_config = send("#{_type}_config", name)
-      search_object(obj_config, keys, default, format)
-    end
-  end
-
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def object_utilities
-    
-    unless respond_to? :foreach_object_type!
-      define_method :foreach_object_type! do |object_types = nil, filter_proc = nil|
-        object_types = @@object_types.keys unless object_types
-        object_types = [ object_types ] unless object_types.is_a?(Array)
-      
-        object_types.keys.each do |type|
-          unless filter_proc && ! filter_proc.call(type, @@object_types[type])
-            plural = @@object_types[type][:plural]
-            yield(type, plural, @@object_types[type])
-          end
-        end  
-      end
-    end
-           
-    #---
-    
-    unless respond_to? :init_objects
-      define_method :init_objects do |object_types = nil, filter_proc = nil|
-        foreach_object_type!(object_types, filter_proc) do |type, plural, options|
-          send("init_#{plural}")  
-        end   
-      end
-    end
-    
-    #---
-    
-    unless respond_to? :clear_objects
-      define_method :clear_objects do |object_types = nil, filter_proc = nil|
-        foreach_object_type!(object_types, filter_proc) do |type, plural, options|
-          send("clear_#{plural}")  
-        end
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-  
-    unless respond_to? :search_object  
-      define_method :search_object do |obj_config, keys, default = '', format = false|
-        obj_config = Marshal.load(Marshal.dump(obj_config))
-        value      = obj_config.get(keys)
-        
-        #dbg(obj_config, 'search object config')
-        
-        if ! value || value.is_a?(Hash)
-          settings = {}
-    
-          keys = [ keys ] unless keys.is_a?(Array)
-          temp = keys.dup
-          
-          #dbg('specialized settings')
-      
-          until temp.empty? do
-            #dbg(temp, 'temporary settings prefix')
-            if obj_settings = obj_config.delete([ temp, :settings ])
-              #dbg(obj_settings, 'object settings')
-              array(obj_settings).each do |group_name|
-                #dbg(group_name, 'group name')
-                if group_settings = Marshal.load(Marshal.dump(settings(group_name)))
-                  #dbg(group_settings, 'group settings')
-                  settings = Util::Data.merge([ group_settings.dup, settings ], true)  
-                end
-              end            
-            end
-            temp.pop
-          end
-    
-          #dbg(settings, 'specialized settings')
-          
-          #dbg('general settings')
-      
-          if obj_settings = obj_config.delete(:settings)
-            #dbg(obj_settings, 'object settings')
-            array(obj_settings).each do |group_name|
-              #dbg(group_name, 'group name')
-              if group_settings = Marshal.load(Marshal.dump(settings(group_name)))
-                #dbg(group_settings, 'group settings')
-                settings = Util::Data.merge([ group_settings, settings ], true)  
-              end
-            end            
-          end 
-          
-          #dbg(settings, 'general settings')   
-        
-          unless settings.empty?
-            #dbg(obj_config, 'initial object config')
-            final_config = Config.new(Util::Data.merge([ settings, obj_config.export ], true))
-            value        = final_config.get(keys)
-            #dbg(final_config, 'final object config')
-          end
-          
-          value = default if Util::Data.undef?(value)
-        end
-        filter(value, format)
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    # Configuration loading saving
-    
-    unless respond_to? :load
-      define_method :load do |options = {}|
-        if config.respond_to?(:load)
-          clear_objects  
-          config.load(options)    
-          init_objects
-        end
-        self  
-      end
-    end
-    
-    #---
-    
-    unless respond_to? :save
-      define_method :save do |options = {}|
-        config.save(options) if config.respond_to?(:save)
-        self  
-      end
-    end    
-  end
-end
-end
-end
-end