nucleon 0.1.0 → 0.1.1

data/lib/core/mixin/macro/plugin_interface.rb

@@ -0,0 +1,380 @@
+
+# Should be included via extend
+#
+# extend Mixin::Macro::PluginInterface
+#
+
+nucleon_require(File.dirname(__FILE__), :object_interface)
+
+#---
+
+module Nucleon
+module Mixin
+module Macro
+module PluginInterface
+  
+  include Macro::ObjectInterface
+  
+  #-----------------------------------------------------------------------------
+  # Plugin collections
+  
+  def plugin_collection(_type, _method_options = {})
+    _method_config = Config.ensure(_method_options)
+    _method_config.set(:plugin, true)
+    
+    _plural          = _method_config.init(:plural, "#{_type}s").get(:plural)
+    _search_proc     = _method_config.get(:search_proc)
+    _single_instance = _method_config.get(:single_instance, false)
+    _plugin_type     = _method_config.get(:plugin_type, _type)
+    
+    @@object_types[_type] = _method_config
+    
+    logger.debug("Creating new plugin collection #{_type} with: #{_method_config.inspect}")
+    
+    #---------------------------------------------------------------------------
+    
+    object_utilities
+      
+    #---
+    
+    unless respond_to? :each_plugin
+      logger.debug("Defining plugin interface method: each_plugin")
+      
+      define_method :each_plugin do |plugin_types = nil, providers = nil, &code|
+        providers = [ providers ] if providers && ! providers.is_a?(Array)
+        
+        filter_proc = Proc.new {|type, config| config[:plugin] }
+        each_object_type(plugin_types, filter_proc) do |type, plural, options|
+          logger.debug("Processing plugin type #{type}/#{plural} with: #{options.inspect}")
+          
+          send(plural).each do |provider, plugins|
+            logger.debug("Processing plugin provider: #{provider}")
+            
+            unless providers && ! providers.include?(provider)
+              if plugins.is_a?(Hash)
+                plugins.each do |name, plugin|
+                  logger.debug("Processing plugin: #{name}")
+                  code.call(type, provider, name, plugin)  
+                end
+              else
+                logger.debug("Processing plugin: #{plugin.name}")
+                code.call(type, provider, plugin.name, plugin)
+              end
+            end
+          end 
+        end  
+      end
+    end
+    
+    #---
+    
+    logger.debug("Defining plugin interface method: each_#{_type}")
+    
+    define_method "each_#{_type}" do |providers = nil, &code|
+      each_plugin(_type, providers) do |type, provider, name, plugin|
+        code.call(provider, name, plugin)    
+      end
+    end
+    
+    #---------------------------------------------------------------------------
+    
+    logger.debug("Defining plugin interface method: #{_plural}")
+    
+    define_method "#{_plural}" do |provider = nil, reset = false|
+      keys = ( provider ? [ _plural, provider ] : _plural )
+      send("init_#{_plural}", provider) if reset || _get(keys, {}).empty?
+      _get(keys, {})
+    end
+    
+    #---
+    
+    logger.debug("Defining plugin interface method: init_#{_plural}")
+  
+    define_method "init_#{_plural}" do |providers = nil|
+      data = hash(_search_proc.call) if _search_proc
+      data = get_hash(_plural) unless data
+      
+      providers = [ providers ] if providers && ! providers.is_a?(Array)
+      
+      logger.debug("Initializing #{_plugin_type} plugin data: #{data.inspect}")
+      logger.debug("Providers: #{providers.inspect}")
+            
+      symbol_map(data).each do |provider, instance_settings|
+        if ! providers || providers.include?(provider)
+          if _single_instance
+            logger.debug("Initializing single instance plugin: #{instance_settings.inspect}")
+            
+            plugin = Nucleon.plugin(_plugin_type, provider, Config.ensure(instance_settings).import({ :meta => { :parent => myself } }))
+          
+            _set([ _plural, provider ], plugin)
+          else
+            instance_settings.each do |name, options|
+              if name != :settings
+                logger.debug("Initializing plugin #{_plugin_type} #{name}: #{options.inspect}")
+                
+                options[:name] = name
+                plugin         = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+                
+                _set([ _plural, provider, name ], plugin)
+              end
+            end
+          end
+        end
+      end
+    end
+  
+    #---
+    
+    logger.debug("Defining plugin interface method: set_#{_plural}")
+
+    define_method "set_#{_plural}" do |data = {}|
+      data = Config.ensure(data).export
+    
+      send("clear_#{_plural}")
+      set(_plural, data)
+      
+      logger.debug("Setting #{_plural}")
+    
+      data.each do |provider, instance_settings|
+        if _single_instance
+          logger.debug("Setting single #{_plugin_type} #{provider}: #{instance_settings.inspect}")
+          
+          plugin = Nucleon.plugin(_plugin_type, provider, Config.ensure(instance_settings).import({ :meta => { :parent => myself } }))              
+          
+          _set([ _plural, provider ], plugin)  
+        else
+          instance_settings.each do |name, options|
+            logger.debug("Setting #{_plugin_type} #{provider} #{name}: #{options.inspect}")
+            
+            options[:name] = name
+            plugin         = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+            
+            _set([ _plural, provider, name ], plugin)  
+          end
+        end
+      end
+    end
+    
+    #---
+    
+    logger.debug("Defining plugin interface method: clear_#{_plural}")
+    
+    define_method "clear_#{_plural}" do
+      get(_plural).keys.each do |provider|
+        logger.debug("Clearing #{_type} #{provider}")
+        
+        if _single_instance
+          send("delete_#{_type}", provider)
+        else
+          get_hash([ _plural, provider ]).keys.each do |name|
+            send("delete_#{_type}", provider, name)
+          end
+        end
+      end
+    end
+
+    #---------------------------------------------------------------------------
+    
+    if _single_instance
+      logger.debug("Defining single instance plugin interface method: #{_type}_config")
+      
+      define_method "#{_type}_config" do |provider = nil|
+        keys = [ _plural ]
+        keys << provider unless provider.nil?
+        Config.new(get(keys, {}))
+      end
+      
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: #{_type}_setting")
+      
+      define_method "#{_type}_setting" do |provider, property, default = nil, format = false|
+        get([ _plural, provider, property ], default, format)
+      end
+      
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: #{_type}")
+      
+      define_method "#{_type}" do |provider, reset = false|
+        if reset || _get([ _plural, provider ], nil).nil?        
+          options = get([ _plural, provider ], nil)
+         
+          unless options.nil?
+            plugin = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+        
+            logger.debug("Initializing plugin #{_plugin_type} #{provider}: #{options.inspect}")
+        
+            _set([ _plural, provider ], plugin)
+          end
+        end
+        _get([ _plural, provider ])
+      end
+      
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: set_#{_type}")
+      
+      define_method "set_#{_type}" do |provider, options = {}|
+        options = Config.ensure(options).export
+      
+        set([ _plural, provider ], options)
+    
+        plugin = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+        
+        logger.debug("Setting single #{_plugin_type} #{provider}: #{options.inspect}")
+        
+        _set([ _plural, provider ], plugin)
+        plugin
+      end
+          
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: set_#{_type}_setting")
+
+      define_method "set_#{_type}_setting" do |provider, property, value = nil|
+        logger.debug("Setting single #{provider} property #{property} to #{value.inspect}")
+        set([ _plural, provider, property ], value)
+      end
+    
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: delete_#{_type}")
+
+      define_method "delete_#{_type}" do |provider|
+        plugin = send(_type, provider)
+        
+        logger.debug("Deleting single #{_type} #{provider}")
+    
+        delete([ _plural, provider ])
+        _delete([ _plural, provider ])
+    
+        Nucleon.remove_plugin(plugin) unless plugin.nil?
+      end
+  
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: delete_#{_type}_setting")
+  
+      define_method "delete_#{_type}_setting" do |provider, property|
+        logger.debug("Deleting single #{provider} property: #{property}")
+        delete([ _plural, provider, property ])
+      end
+      
+      #---
+      
+      logger.debug("Defining single instance plugin interface method: search_#{_type}")
+      
+      define_method "search_#{_type}" do |provider, keys, default = '', format = false|
+        plugin_config = send("#{_type}_config", provider)
+        logger.debug("Searching single #{_type} #{provider}: #{plugin_config.inspect}")
+        
+        search_object(plugin_config, keys, default, format)      
+      end
+      
+    #---------------------------------------------------------------------------
+    else
+      logger.debug("Defining multi instance plugin interface method: #{_type}_config")
+      
+      define_method "#{_type}_config" do |provider = nil, name = nil|
+        keys = [ _plural ]
+        keys << provider unless provider.nil?
+        keys << name unless name.nil?
+        Config.new(get(keys, {}))
+      end
+      
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: #{_type}_setting")
+      
+      define_method "#{_type}_setting" do |provider, name, property, default = nil, format = false|
+        get([ _plural, provider, name, property ], default, format)
+      end
+      
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: #{_type}")
+      
+      define_method "#{_type}" do |provider, name|
+        if reset || _get([ _plural, provider, name ], nil).nil?        
+          options = get([ _plural, provider, name ], nil)
+         
+          unless options.nil?
+            options[:name] = name
+            plugin         = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+        
+            logger.debug("Initializing plugin #{_plugin_type} #{provider}: #{options.inspect}")
+        
+            _set([ _plural, provider, name ], plugin)
+          end
+        end
+        _get([ _plural, provider, name ])
+      end
+      
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: set_#{_type}")
+      
+      define_method "set_#{_type}" do |provider, name, options = {}|
+        options = Config.ensure(options).export
+      
+        set([ _plural, provider, name ], options)
+    
+        options[:name] = name
+        plugin         = Nucleon.plugin(_plugin_type, provider, Config.ensure(options).import({ :meta => { :parent => myself } }))
+        
+        logger.debug("Setting #{_plugin_type} #{provider} #{name}: #{options.inspect}")
+        
+        _set([ _plural, provider, name ], plugin)
+        plugin
+      end
+          
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: set_#{_type}_setting")
+
+      define_method "set_#{_type}_setting" do |provider, name, property, value = nil|
+        logger.debug("Setting #{provider} #{name} property #{property} to #{value.inspect}")
+        set([ _plural, provider, name, property ], value)
+      end
+    
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: delete_#{_type}")
+
+      define_method "delete_#{_type}" do |provider, name|
+        plugin = send(_type, provider, name)
+        
+        logger.debug("Deleting #{_type} #{provider} #{name}")
+    
+        delete([ _plural, provider, name ])
+        _delete([ _plural, provider, name ])
+    
+        Nucleon.remove_plugin(plugin) unless plugin.nil?
+      end
+  
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: delete_#{_type}_setting")
+  
+      define_method "delete_#{_type}_setting" do |provider, name, property|
+        logger.debug("Deleting #{provider} #{name} property: #{property}")
+        delete([ _plural, provider, name, property ])
+      end
+      
+      #---
+      
+      logger.debug("Defining multi instance plugin interface method: search_#{_type}")
+      
+      define_method "search_#{_type}" do |provider, name, keys, default = '', format = false|
+        plugin_config = send("#{_type}_config", provider, name)
+        logger.debug("Searching #{_type} #{provider} #{name}: #{plugin_config.inspect}")
+        
+        search_object(plugin_config, keys, default, format)      
+      end
+    end  
+  end
+end
+end
+end
+end

data/lib/core/mixin/settings.rb

@@ -0,0 +1,46 @@
+
+# Should be included via include
+#
+# include Mixin::Settings
+#
+
+module Nucleon
+module Mixin
+module Settings
+  
+  def settings(name)
+    return get_hash([ :settings, name ])
+  end
+    
+  #---
+
+  def set_settings(name, settings = {})
+    return set([ :settings, name ], settings)
+  end
+    
+  #---
+
+  def delete_settings(name)
+    return delete([ :settings, name ])
+  end
+    
+  #---
+   
+  def setting(name, key, default = '', format = false)
+    return get([ :settings, name, key ], default, format)
+  end
+     
+  #---
+
+  def set_setting(name, key, value = '')
+    return set([ :settings, name, key ], value)
+  end
+     
+  #---
+
+  def delete_setting(name, key)
+    return delete([ :settings, name, key ])
+  end
+end
+end
+end

data/lib/core/mixin/sub_config.rb

@@ -0,0 +1,148 @@
+
+# Should be included via include
+#
+# include Mixin::SubConfig
+#
+
+module Nucleon
+module Mixin
+module SubConfig
+  
+  #-----------------------------------------------------------------------------
+  # Initialization
+  
+  def init_subconfig(reset = false)
+    return if @subconfig_initialized && ! reset
+    
+    unless @config
+      @config = Config.new
+    end
+    
+    @subconfig_initialized = true
+  end
+  protected :init_subconfig
+  
+  #-----------------------------------------------------------------------------
+  # Propety accessors / modifiers
+  
+  def config
+    return @config
+  end
+  
+  #---
+  
+  def config=config
+    @config = config
+  end
+    
+  #-----------------------------------------------------------------------------
+
+  def _get(keys, default = nil, format = false)
+    return fetch(@properties, array(keys).flatten, default, format)
+  end
+  protected :_get
+  
+  #---
+  
+  def get(keys, default = nil, format = false)
+    init_subconfig
+    return config.get(keys, default, format)
+  end
+  
+  #---
+  
+  def _init(keys, default = nil)
+    return _set(keys, _get(keys, default))
+  end
+  protected :_init
+
+  #---
+ 
+  def _set(keys, value = '')
+    modify(@properties, array(keys).flatten, value)
+  end
+  protected :_set
+  
+  #---
+    
+  def set(keys, value = '')
+    init_subconfig
+    config.set(keys, value)
+  end
+  
+  #---
+ 
+  def _delete(keys, default = nil)
+    existing = modify(@properties, array(keys).flatten, nil)
+    return existing[:value] if existing[:value]
+    return default 
+  end
+  protected :_delete
+  
+  #---
+   
+  def delete(keys, default = nil)
+    init_subconfig
+    config.delete(keys, default)
+  end
+ 
+  #---
+ 
+  def _clear
+    @properties = {}
+  end
+  protected :_clear
+  
+  #---
+  
+  def clear
+    init_subconfig
+    config.clear
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def _import(properties, options = {})
+    return import_base(properties, options)
+  end
+  protected :_import
+  
+  #---
+  
+  def import(properties, options = {})
+    init_subconfig
+    config.import(properties, options)
+  end
+  
+  #---
+  
+  def _defaults(defaults, options = {})
+    config = new(options).set(:import_type, :default)
+    return import_base(defaults, config)
+  end
+  protected :_defaults
+  
+  #---
+  
+  def defaults(defaults, options = {})
+    init_subconfig
+    config.defaults(defaults, options)
+  end
+  
+  #---
+  
+  def _export
+    return @properties
+  end
+  protected :_export
+  
+  #---
+  
+  def export
+    init_subconfig
+    return config.export
+  end
+end
+end
+end

data/lib/core/mod/hash.rb

@@ -0,0 +1,29 @@
+
+#-------------------------------------------------------------------------------
+# Hash data type alterations
+
+class Hash
+  def search(search_key, options = {})
+    config = Nucleon::Config.ensure(options)
+    value  = nil
+    
+    recurse       = config.get(:recurse, false)
+    recurse_level = config.get(:recurse_level, -1)
+        
+    self.each do |key, data|
+      if key == search_key
+        value = data
+        
+      elsif data.is_a?(Hash) && 
+        recurse && (recurse_level == -1 || recurse_level > 0)
+        
+        recurse_level -= 1 unless recurse_level == -1
+        value = value.search(search_key, 
+          Nucleon::Config.new(config).set(:recurse_level, recurse_level)
+        )
+      end
+      break unless value.nil?
+    end
+    return value
+  end
+end