nucleon 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c8807425d4796bbacc3ab9b91273fce43c75dad
-  data.tar.gz: acc2ebd35998fb5d9beab4c83bca35a67e6cadc5
+  metadata.gz: 00f9bc86d6b7cc661e86f2f8d68122deeba3c4b8
+  data.tar.gz: f2e4efb4452af26d9a01f61ef7403e0b20cfe176
 SHA512:
-  metadata.gz: 66642c1e07a8c2387fb6bc761dc1986019d56ae1ecb0267745343be0df59cec44c9e6c39f5d6cdf20b7f4f11d7e917acde82e8098845ac156bba70cf3ec59cb6
-  data.tar.gz: 9e887f1c8b8f9df44e6d2b64eeb4b98ed3b25574e52889170870764e274b30529120db7c3b4256bcb7ec785d32f4b17a929a0ec69e2bf4f62bcbab9baee7abf5
+  metadata.gz: d9d8f921ecd37fec93616291b3c209296ee4411e11d87a83e51b193c934d42d65abc47cd96e4b633bc5bd615131c77a33935d9987fa6de704ba3a885e28461f5
+  data.tar.gz: cd68ddf0980de41c10ba359af9a43fbb929217c8ed12b3e7b4c10595f9b23101072e7f7d0f171b5665c30bc7173344245e283e332858e0306ec76e94bdc2c26a

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/core/config.rb

@@ -129,7 +129,7 @@ class Config
       data[key] = {} unless has_key
       
       if data[key].is_a?(Hash)
-        existing = modify(data[key], keys, value)
+        existing = modify(data[key], keys, value, delete_nil)
       else
         existing[:value] = nil 
       end  

data/lib/core/core.rb

@@ -14,8 +14,8 @@ class Core < Config
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
   
-  def initialize(data = {}, defaults = {}, force = true, set_initialized = true)
-    super(data, defaults, force)   
+  def initialize(data = {}, defaults = {}, force = true, set_initialized = true, basic_merge = true)
+    super(data, defaults, force, basic_merge)   
     
     @class_color = Util::Data.ensure_value(delete(:class_color, :cyan), :cyan)
     @class_label = self.class.to_s.downcase.gsub(/^nucleon::/, '')

data/lib/core/environment.rb

@@ -81,6 +81,7 @@ class Environment
       data = {
         :namespace        => namespace,
         :type             => plugin_type,
+        :base_path        => base_path,
         :file             => file,
         :provider         => plugin_info[:provider],        
         :directory        => plugin_info[:directory],        
@@ -160,21 +161,23 @@ class Environment
     namespace   = namespace.to_sym
     plugin_type = sanitize_id(plugin_type)
     provider    = sanitize_id(provider)
-       
+           
     unless plugin_type_defined?(namespace, plugin_type)
       return nil
     end
         
     if type_info = loaded_plugin(namespace, plugin_type, provider)
-      ids              = Util::Data.array(type_info[:class].register_ids).flatten
-      instance_options = Config.new(options).export
-      instance_options = Util::Data.subset(instance_options, ids, true)      
-      instance_name    = "#{provider}_" + Nucleon.sha1(instance_options)
+      ids             = Util::Data.array(type_info[:class].register_ids).flatten
+      instance_config = Config.new(options)
+      ensure_new      = instance_config.delete(:new, false)
       
+      instance_options = Util::Data.subset(instance_config.export, ids, true)      
+      instance_name    = "#{provider}_" + Nucleon.sha1(instance_options)
+            
       @active_info[namespace] = {} unless @active_info.has_key?(namespace)        
       @active_info[namespace][plugin_type] = {} unless @active_info[namespace].has_key?(plugin_type)
       
-      unless instance_name && @active_info[namespace][plugin_type].has_key?(instance_name)
+      if ensure_new || ! ( instance_name && @active_info[namespace][plugin_type].has_key?(instance_name) )
         type_info[:instance_name] = instance_name
         
         options = code.call(type_info, options) if code

data/lib/core/facade.rb

@@ -236,8 +236,8 @@ module Facade
   #-----------------------------------------------------------------------------
   # Core plugin interface
   
-  def reload(core = false, &code)
-    Manager.connection.reload(core, &code)  
+  def reload(core = false, loaded = [], &code)
+    Manager.connection.reload(core, loaded, &code)  
   end
   
   #---

data/lib/core/gems.rb

@@ -28,12 +28,12 @@ module Gems
   
   #---
   
-  def self.register(reset = false)
+  def self.register(reset = false, loaded = [])
     if reset || Util::Data.empty?(@@gems)
       logger.info("Registering external gem defined Nucleon plugins at #{Time.now}")
       
       each_gem do |spec|
-        register_gem(spec)
+        register_gem(spec, loaded)
       end
     end
     @@gems
@@ -41,7 +41,7 @@ module Gems
   
   #---
   
-  def self.register_gem(spec)
+  def self.register_gem(spec, loaded = [])
     name      = spec.name.to_sym
     base_path = File.join(spec.full_gem_path, 'lib')
     
@@ -57,9 +57,16 @@ module Gems
       Manager.connection.register(base_path) do |data|
         namespace   = data[:namespace]
         plugin_path = data[:directory]
-      
-        logger.info("Registering gem #{name} at #{plugin_path} at #{Time.now}") unless @@gems.has_key?(name)
-      
+        
+        unless @@gems.has_key?(name)
+          logger.info("Registering gem #{name} at #{plugin_path} at #{Time.now}")
+          
+          unless loaded.include?(name)          
+            loader = File.join(base_path, "#{name}.rb")
+            require loader if File.exists?(loader)
+          end
+        end 
+        
         @@gems[name] = { 
           :spec       => spec, 
           :base_path  => base_path, 

data/lib/core/manager.rb

@@ -111,7 +111,7 @@ class Manager
   #-----------------------------------------------------------------------------
   # Plugin registration / initialization
   
-  def reload(core = false, &code)
+  def reload(core = false, loaded = [], &code)
     logger.info("Loading Nucleon plugins at #{Time.now}")
     
     if core
@@ -131,13 +131,13 @@ class Manager
     # Allow block level namespace and type registration
     code.call(:define, myself) if code
                               
-    load_plugins(core, &code)                                  
+    load_plugins(core, loaded, &code)                                  
     logger.info("Finished loading Nucleon plugins at #{Time.now}")    
   end
   
   #---
   
-  def load_plugins(core = false, &code)
+  def load_plugins(core = false, loaded = [], &code)
     if core    
       # Register core plugins
       logger.info("Initializing core plugins at #{Time.now}")
@@ -145,7 +145,7 @@ class Manager
     end
     
     # Register external Gem defined plugins
-    Gems.register(true)
+    Gems.register(true, Util::Data.array(loaded))
     
     # Register any other extension plugins
     exec(:register_plugins)
@@ -242,13 +242,15 @@ class Manager
     options    = translate_type(type_info, options)    
     config     = Config.ensure(options)
     name       = config.get(:name, nil)
-    ensure_new = config.delete(:new, false)
+    ensure_new = config.get(:new, false)
     
     if name
       logger.debug("Looking up existing instance of #{name}")
       
       if existing_instance = get(namespace, plugin_type, name)
         unless ensure_new
+          config.delete(:new)
+          
           config.export.each do |property_name, value|
             unless [ :name, :meta ].include?(property_name)
               existing_instance[property_name] = value  
@@ -274,6 +276,11 @@ class Manager
     provider = config.delete(:provider, provider)
     provider = default_provider unless provider
     
+    provider = value(:manager_plugin_provider, provider, Util::Data.merge([ config.export, { 
+      :namespace => namespace, 
+      :type      => plugin_type 
+    }]))
+    
     load_base(namespace, plugin_type, provider, config)
   end
   

data/lib/core/mixin/action/commit.rb

@@ -10,24 +10,30 @@ module Commit
   def commit_config(optional = true)
     
     if optional
-      register :commit, :bool, :false, 'nucleon.core.mixin.action.commit.options.commit'
+      register_bool :commit, :false, 'nucleon.core.mixin.action.commit.options.commit'
     else
       settings[:commit] = true
     end
     
-    register :allow_empty, :bool, false, 'nucleon.core.mixin.action.commit.options.allow_empty'
-    register :propogate_commit, :bool, false, 'nucleon.core.mixin.action.commit.options.propogate_commit'
+    register_bool :allow_empty, true, 'nucleon.mixin.core.action.commit.options.allow_empty'
+    register_bool :propogate_commit, false, 'nucleon.core.mixin.action.commit.options.propogate_commit'
     
-    register :message, :str, '', 'nucleon.core.mixin.action.commit.options.message'
+    register_str :message, '', 'nucleon.core.mixin.action.commit.options.message'
     
-    register :author, :str, nil, 'nucleon.core.mixin.action.commit.options.author' do |value|
+    register_str :author, nil, 'nucleon.core.mixin.action.commit.options.author' do |value|
       if value.nil? || value.strip =~ /^[A-Za-z\s]+<\s*[^@]+@[^>]+\s*>$/
         next true
       end
-      warn('corl.core.mixins.action.commit.errors.author', { :value => value })
+      warn('corl.core.mixin.action.commit.errors.author', { :value => value })
       false
     end
   end
+  
+  #---
+  
+  def commit_ignore
+    [ :commit, :allow_empty, :propogate_commit, :message, :author ]
+  end
         
   #-----------------------------------------------------------------------------
   # Operations

data/lib/core/mixin/action/project.rb

@@ -8,34 +8,21 @@ module Project
   # Settings
         
   def project_config
-    project_plugins = Nucleon.loaded_plugins(:nucleon, :project)
-    
-    register :project_provider, :str, :git, 'nucleon.core.mixin.action.project.options.project_provider' do |value|
-      value = value.to_sym
-      
-      unless project_plugins.keys.include?(value)
-        warn('nucleon.core.mixin.action.project.errors.project_provider', { :value => value, :choices => project_plugins.keys.join(", ") })
-        next false
-      end
-      true
-    end
-    register :project_reference, :str, nil, 'nucleon.core.mixin.action.project.options.project_reference' do |value|
-      success = true
-      if info = Nucleon.plugin_class(:nucleon, :project).translate_reference(value)
-        if ! project_plugins.keys.include?(info[:provider].to_sym)
-          warn('nucleon.core.mixin.action.project.errors.project_reference', { 
-            :value     => value, 
-            :provider  => info[:provider],  
-            :reference => info[:reference],
-            :url       => info[:url],
-            :revision  => info[:revision] 
-          })
-          success = false
-        end
-      end
-      success
-    end
-    register :project_revision, :str, :master, 'nucleon.core.mixin.action.project.options.project_revision'
+    register_project_provider :project_provider, nil, [ 
+      'nucleon.core.mixin.action.project.options.project_provider', 
+      'nucleon.core.mixin.action.project.errors.project_provider' 
+    ]
+    register_project :project_reference, nil, [ 
+      'nucleon.core.mixin.action.project.options.project_reference', 
+      'nucleon.core.mixin.action.project.errors.project_reference' 
+    ]
+    register_str :project_revision, :master, 'nucleon.core.mixin.action.project.options.project_revision'
+  end
+  
+  #---
+  
+  def project_ignore
+    [ :project_provider, :project_reference, :project_revision ]
   end
         
   #-----------------------------------------------------------------------------

data/lib/core/mixin/action/push.rb

@@ -10,15 +10,23 @@ module Push
   def push_config(optional = true)
     
     if optional
-      register :push, :bool, false, 'nucleon.core.mixin.action.push.options.push'
+      register_bool :push, false, 'nucleon.core.mixin.action.push.options.push'
     else
       settings[:push] = true
     end
     
-    register :remote, :str, :edit, 'nucleon.core.mixin.action.push.options.remote'
-    register :revision, :str, :master, 'nucleon.core.mixin.action.push.options.revision'
+    register_bool :pull, true, 'nucleon.core.mixin.action.push.options.pull'
     
-    register :propogate_push, :bool, false, 'nucleon.core.mixin.action.push.options.propogate_push'
+    register_bool :propogate_push, false, 'nucleon.core.mixin.action.push.options.propogate_push'
+    
+    register_str :remote, :edit, 'nucleon.core.mixin.action.push.options.remote'
+    register_str :revision, :master, 'nucleon.core.mixin.action.push.options.revision'    
+  end
+  
+  #---
+  
+  def push_ignore
+    [ :push, :pull, :propogate_push, :remote, :revision ]
   end
         
   #-----------------------------------------------------------------------------
@@ -30,7 +38,8 @@ module Push
     if project && settings[:push]
       success = project.push(settings[:remote], extended_config(:push, {
         :revision  => settings[:revision],
-        :propogate => settings[:propogate_push]
+        :propogate => settings[:propogate_push],
+        :no_pull   => ! settings[:pull]
       }))
     end
     success

data/lib/core/mixin/action/registration.rb

@@ -5,77 +5,326 @@ module Action
 module Registration
         
   #-----------------------------------------------------------------------------
-  # Options
+  # Registration definitions
+  
+  def register_bool(name, default = false, locale = nil, &code)
+    register(name, :bool, default, locale, &code)
+  end
+  
+  #---
+  
+  def register_int(name, default = nil, locale = nil, &code)
+    register(name, :int, default, locale, &code)
+  end
+  
+  #---
+  
+  def register_float(name, default = nil, locale = nil, &code)
+    register(name, :float, default, locale, &code)
+  end
+  
+  #---
+  
+  def register_str(name, default = '', locale = nil, &code)
+    register(name, :str, default, locale, &code)
+  end
+  
+  #---
+  
+  def register_array(name, default = [], locale = nil, &code)
+    register(name, :array, default, locale, &code)
+  end
+  
+  #---
     
-  def register_file(name, default = nil)
+  def register_file(name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :str, default do |value|
-      validate_file(value)
+    register_str(name, default, locale) do |value|
+      success = validate_file(value)
+      success = code.call(value, success) if code
+      success
     end
   end
   
   #---
-    
-  def register_directory(name, default = nil)
+  
+  def register_files(name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :str, default do |value|
-      validate_directory(value)
-    end
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_array(name, default, option_locale) do |values|
+      success = validate_files(values, validation_locale)
+      success = code.call(values, success) if code
+      success
+    end  
   end
   
   #---
     
-  def register_project(name, default = nil)
+  def register_directory(name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :str, default do |value|
-      validate_plugins(:nucleon, :project, name, value)
+    register_str(name, default, locale) do |value|
+      success = validate_directory(value)
+      success = code.call(value, success) if code
+      success
     end
   end
   
   #---
+  
+  def register_directories(name, default = nil, locale = nil, &code)
+    name = name.to_sym
     
-  def register_projects(name, default = nil)
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_array(name, default, option_locale) do |values|
+      success = validate_directories(values, validation_locale)
+      success = code.call(values, success) if code
+      success
+    end  
+  end
+  
+  #---
+  
+  def register_plugin_type(namespace, name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :array, default do |values|
-      validate_plugins(:nucleon, :project, name, values)
-    end
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_str(name, default, option_locale) do |value|
+      success = validate_plugin_types(namespace, name, value, validation_locale)
+      success = code.call(value, success) if code
+      success
+    end  
   end
   
   #---
+  
+  def register_plugin_types(namespace, name, default = nil, locale = nil, &code)
+    name = name.to_sym
     
-  def register_translator(name, default = nil)
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_array(name, default, option_locale) do |values|
+      success = validate_plugin_types(namespace, name, values, validation_locale)
+      success = code.call(values, success) if code
+      success
+    end  
+  end
+  
+  #---
+  
+  def register_plugin_provider(namespace, type, name, default = nil, locale = nil, &code)
+    name = name.to_sym    
+    
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_str(name, default, option_locale) do |value|
+      success = validate_plugin_providers(namespace, type, name, value, validation_locale)
+      success = code.call(value, success) if code
+      success
+    end  
+  end
+  
+  #---
+  
+  def register_plugin_providers(namespace, type, name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :str, default do |value|
-      validate_plugins(:nucleon, :translator, name, value)
-    end
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_array(name, default, option_locale) do |values|
+      success = validate_plugin_providers(namespace, type, name, values, validation_locale)
+      success = code.call(values, success) if code
+      success
+    end  
   end
   
   #---
+  
+  def register_plugin(namespace, type, name, default = nil, locale = nil, &code)
+    name = name.to_sym
     
-  def register_translators(name, default = nil)
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_str(name, default, option_locale) do |value|
+      success = validate_plugins(namespace, type, name, value, validation_locale)
+      success = code.call(value, success) if code
+      success
+    end  
+  end
+  
+  #---
+  
+  def register_plugins(namespace, type, name, default = nil, locale = nil, &code)
     name = name.to_sym
     
-    register name, :array, default do |values|
-      validate_plugins(:nucleon, :translator, name, values)
-    end
+    option_locale, validation_locale = split_locales(locale)
+    
+    register_array(name, default, option_locale) do |values|
+      success = validate_plugins(namespace, type, name, values, validation_locale)
+      success = code.call(values, success) if code
+      success
+    end  
+  end
+  
+  #---
+    
+  def register_project_provider(name, default = nil, locale = nil, &code)
+    register_plugin_provider(:nucleon, :project, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_project_providers(name, default = nil, locale = nil, &code)
+    register_plugin_providers(:nucleon, :project, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_project(name, default = nil, locale = nil, &code)
+    register_plugin(:nucleon, :project, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_projects(name, default = nil, locale = nil, &code)
+    register_plugins(:nucleon, :project, name.to_sym, default, locale, &code)    
+  end
+  
+  #---
+    
+  def register_translator_provider(name, default = nil, locale = nil, &code)
+    register_plugin_provider(:nucleon, :translator, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_translator_providers(name, default = nil, locale = nil, &code)
+    register_plugin_providers(:nucleon, :translator, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_translator(name, default = nil, locale = nil, &code)
+    register_plugin(:nucleon, :translator, name.to_sym, default, locale, &code)
+  end
+  
+  #---
+    
+  def register_translators(name, default = nil, locale = nil, &code)
+    register_plugins(:nucleon, :translators, name.to_sym, default, locale, &code) 
   end
   
   #-----------------------------------------------------------------------------
   # Validators
   
-  def validate_file(file_name)
-    file_name.nil? || File.exists?(file_name)  
+  def validate_file(file_name, locale = nil)
+    success = file_name.nil? || File.exists?(file_name)
+    warn(locale, { :file => file_name }) unless success
+    success  
   end
   
   #---
   
-  def validate_directory(dir_name)
-    dir_name.nil? || File.directory?(dir_name)
+  def validate_files(file_names, locale = nil)
+    success = true
+    
+    array(file_names).each do |file_name|
+      test    = validate_file(file_name, locale)
+      success = false unless test
+    end
+    success  
+  end
+  
+  #---
+  
+  def validate_directory(dir_name, locale = nil)
+    success = dir_name.nil? || File.directory?(dir_name)
+    warn(locale, { :directory => dir_name }) unless success
+    success 
+  end
+  
+  #---
+  
+  def validate_directories(dir_names, locale = nil)
+    success = true
+    
+    array(dir_names).each do |dir_name|
+      test    = validate_directory(dir_name, locale)
+      success = false unless test
+    end
+    success  
+  end
+  
+  #---
+    
+  def validate_plugin_types(namespace, name, values, locale = nil)
+    loaded_plugin_types = Nucleon.loaded_plugins(namespace).keys
+    success             = true
+    locale              = "validation.#{name}" unless locale
+    
+    array(values).each do |value|
+      if ! loaded_plugin_types.include?(value.to_sym)
+        warn(locale, { :value => value, :choices => loaded_plugin_types.join(", ") })
+        success = false
+      end
+    end      
+    success  
+  end
+  
+  #---
+  
+  def validate_plugin_providers(namespace, type, name, values, locale = nil)
+    loaded_plugin_providers = Nucleon.loaded_plugins(namespace, type).keys
+    success                 = true
+    locale                  = "validation.#{name}" unless locale
+    
+    array(values).each do |value|
+      if ! loaded_plugin_providers.include?(value.to_sym)
+        warn(locale, { :value => value, :choices => loaded_plugin_providers.join(", ") })
+        success = false
+      end
+    end      
+    success  
+  end
+  
+  #---
+  
+  def validate_plugins(namespace, type, name, values, locale = nil)
+    plugin_class   = Nucleon.plugin_class(namespace, type)
+    loaded_plugins = Nucleon.loaded_plugins(namespace, type)
+    success        = true    
+    locale         = "validation.#{name}" unless locale
+        
+    array(values).each do |value|
+      if info = plugin_class.translate_reference(value)
+        if ! loaded_plugins.keys.include?(info[:provider].to_sym)
+          warn(locale, Util::Data.merge([ info, { :value => value, :choices => loaded_plugins.keys.join(", ") } ]))
+          success = false
+        end
+      end
+    end      
+    success
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def split_locales(locale)
+    option_locale     = nil
+    validation_locale = nil
+    
+    if locale.is_a?(Array)
+      option_locale     = locale[0]
+      validation_locale = locale[1] if locale.size > 1
+    else
+      option_locale     = locale
+    end
+    [ option_locale, validation_locale ]
   end
 end
 end