nucleon 0.1.1 → 0.1.2

data/lib/core/gems.rb

@@ -52,28 +52,31 @@ module Gems
   #---
   
   def self.register_gem(spec)
-    name      = spec.name
+    name      = spec.name.to_sym
     base_path = File.join(spec.full_gem_path, 'lib')
     
-    Manager.connection.register(base_path) do |data|      
-      namespace   = data[:namespace]
-      plugin_path = data[:directory]
+    if name == :nucleon
+      logger.debug("Setting Nucleon core gemspec")
+      @@core       = spec      
+      @@gems[name] = { 
+        :spec       => spec, 
+        :base_path  => base_path, 
+        :namespaces => [ :nucleon ] 
+      } 
+    else
+      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}")
+        logger.info("Registering gem #{name} at #{plugin_path} at #{Time.now}")
       
-      unless @@gems.has_key?(name)
         @@gems[name] = { 
           :spec       => spec, 
           :base_path  => base_path, 
           :namespaces => [] 
         }
-      end 
-      @@gems[name][:namespaces] << namespace unless @@gems[name][:namespaces].include?(namespace)
-      
-      if name == 'nucleon'
-        logger.debug("Setting Nucleon core gemspec")
-        @@core = spec
-      end  
+        @@gems[name][:namespaces] << namespace unless @@gems[name][:namespaces].include?(namespace)
+      end
     end
   end
 end

data/lib/core/manager.rb

@@ -51,12 +51,18 @@ class Manager
   
   #---
   
+  def myself
+    Actor.current
+  end
+  
+  #---
+  
   def namespaces
     @namespaces.keys
   end
   
-  def define_namespace(*namespaces)
-    namespaces.each do |namespace|
+  def define_namespace(*names)
+    names.each do |namespace|
       @namespaces[namespace.to_sym] = true
     end  
   end
@@ -123,24 +129,28 @@ class Manager
   
   #---
   
-  def reload
-    current_time     = Time.now    
-    Celluloid.logger = logger
-      
-    logger.info("Initializing the Nucleon plugin system at #{current_time}")
+  def reload(core = false, &code)
+    logger.info("Loading Nucleon plugins at #{Time.now}")
+    
+    if core       
+      Celluloid.logger = logger    
     
-    define_namespace :nucleon
+      define_namespace :nucleon
+    
+      define_type :extension     => nil,     # Core
+                  :action        => :update, # Core
+                  :project       => :git,    # Core
+                  :command       => :bash,   # Core
+                  :event         => :regex,  # Utility
+                  :template      => :json,   # Utility
+                  :translator    => :json    # Utility
+    end
     
-    define_type :extension     => nil,     # Core
-                :action        => :update, # Core
-                :project       => :git,    # Core
-                :command       => :bash,   # Core
-                :event         => :regex,  # Utility
-                :template      => :json,   # Utility
-                :translator    => :json    # Utility
-                           
-    load_plugins(true)                                  
-    logger.info("Finished initializing Nucleon plugin system at #{Time.now}")    
+    # Allow block level namespace and type registration
+    code.call(:define, myself) if code
+                              
+    load_plugins(core, &code)                                  
+    logger.info("Finished loading Nucleon plugins at #{Time.now}")    
   end
   
   #---
@@ -160,30 +170,33 @@ class Manager
   
   #---
   
-  def load_plugins(reset_gems = false)    
-    # Register core plugins
-    logger.info("Initializing core plugins at #{Time.now}")
-    register(File.join(File.dirname(__FILE__), '..'))
-          
+  def load_plugins(core = false, &code)
+    if core    
+      # Register core plugins
+      logger.info("Initializing core plugins at #{Time.now}")
+      register(File.join(File.dirname(__FILE__), '..'))
+    end
+    
     # Register external Gem defined plugins
-    Gems.register(reset_gems)
+    Gems.register(true)
     
     # Register any other extension plugins
     exec(:register_plugins)
+    
+    # Catch any block level requests before autoloading
+    code.call(:load, myself) if code
         
     # Autoload all registered plugins
     autoload
   end
+  protected :load_plugins
   
   #---
   
   def register(base_path, &code)
     namespaces.each do |namespace|
       namespace_path = File.join(base_path, namespace.to_s)
-      
-      if File.directory?(namespace_path)
-        register_namespace(namespace, namespace_path, &code)  
-      end
+      register_namespace(namespace, namespace_path, &code)
     end
   end
   
@@ -217,7 +230,7 @@ class Manager
       logger.info("Registering #{base_directory} at #{Time.now}")
       
       Dir.glob(File.join(base_directory, '*.rb')).each do |file|
-        add_build_info(namespace, plugin_type, file)
+        add_build_info(namespace, plugin_type, file, &code)
       end
     end
   end
@@ -243,7 +256,7 @@ class Manager
         :provider  => provider,        
         :directory => directory,
         :file      => file
-      }      
+      }
       code.call(data) if code
       
       logger.debug("Plugin #{type} loaded: #{data.inspect}")
@@ -276,22 +289,14 @@ class Manager
   
   #---
   
-  def load(type, provider = nil, options = {})
-    config = Config.ensure(options)
-    name   = config.get(:name, nil)
-    
+  def load_base(type, provider, options = {})
     logger.info("Fetching plugin #{type} provider #{provider} at #{Time.now}")
+        
+    config = Config.ensure(translate_type(type, options))
+    name   = config.get(:name, nil)
+       
     logger.debug("Plugin options: #{config.export.inspect}")
     
-    default_provider = type_default(type)
-    
-    if options.is_a?(Hash) || options.is_a?(Nucleon::Config)      
-      config   = Config.ensure(translate_type(type, options))           
-      provider = config.get(:provider, provider)
-      options  = config.export
-    end
-    provider = default_provider unless provider
-    
     if name
       logger.debug("Looking up existing instance of #{name}")
       
@@ -300,7 +305,20 @@ class Manager
     end
     
     return existing_instance if existing_instance
-    create(type, provider, config.export)  
+    create(type, provider, options)   
+  end
+  
+  #---
+  
+  def load(type, provider = nil, options = {})
+    default_provider = type_default(type)
+    
+    # Allow options to override provider
+    config   = Config.ensure(options)
+    provider = config.get(:provider, provider)
+    provider = default_provider unless provider
+    
+    load_base(type, provider, config)
   end
   
   #---
@@ -309,7 +327,7 @@ class Manager
     logger.info("Fetching multiple plugins of #{type} at #{Time.now}")
     
     group = ( build_hash ? {} : [] )
-    klass = base_plugin_class(type)   
+    klass = plugin_class(type)   
     data  = klass.build_info(type, data) if klass.respond_to?(:build_info)
     
     logger.debug("Translated plugin data: #{data.inspect}")
@@ -522,10 +540,10 @@ class Manager
   # Utilities
   
   def translate_type(type, options)
-    klass = base_plugin_class(type)
+    klass = plugin_class(type)
     logger.debug("Executing option translation for: #{klass.inspect}")          
     
-    options = klass.send(:translate, options) if klass.respond_to?(method)
+    options = klass.send(:translate, options) if klass.respond_to?(:translate)
     options
   end
   
@@ -535,7 +553,7 @@ class Manager
     klass = provider_class(namespace, type, provider)
     logger.debug("Executing option translation for: #{klass.inspect}")
               
-    options = klass.send(:translate, options) if klass.respond_to?(method)
+    options = klass.send(:translate, options) if klass.respond_to?(:translate)
     options
   end
   
@@ -579,16 +597,14 @@ class Manager
   
   #---
   
-  def base_plugin_class(type)
+  def plugin_class(type)
     class_const([ :nucleon, :plugin, type ]) 
   end
-  protected :base_plugin_class
   
   #---
   
   def provider_class(namespace, type, provider)
     class_const([ namespace, type, provider ])  
   end
-  protected :provider_class  
 end
 end

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

@@ -5,34 +5,28 @@ module Action
 module Commit
         
   #-----------------------------------------------------------------------------
-  # Options
+  # Settings
         
-  def commit_options(parser, optional = true)
+  def commit_config(optional = true)
+    
     if optional
-      parser.option_bool(:commit, false, 
-        '--commit', 
-        'nucleon.core.mixins.commit.options.commit'
-      )
+      register :commit, :bool, :false, 'nucleon.core.mixin.action.commit.options.commit'
     else
-      parser.options[:commit] = true
+      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 :message, :str, '', 'nucleon.core.mixin.action.commit.options.message'
+    
+    register :author, :str, 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 })
+      false
     end
-         
-    parser.option_bool(:allow_empty, false,
-      '--empty', 
-      'nucleon.core.mixins.commit.options.empty'
-    )
-    parser.option_bool(:propogate, false,
-      '--propogate', 
-      'nucleon.core.mixins.commit.options.propogate'
-    )          
-    parser.option_str(:message, '',
-      '--message COMMIT_MESSAGE',  
-      'nucleon.core.mixins.commit.options.message'
-    )
-    parser.option_str(:author, nil,
-      '--author COMMIT_AUTHOR',  
-      'nucleon.core.mixins.commit.options.author'
-    )         
   end
         
   #-----------------------------------------------------------------------------
@@ -46,7 +40,7 @@ module Commit
         :allow_empty => settings[:allow_empty],
         :message     => settings[:message],
         :author      => settings[:author],
-        :propogate   => settings[:propogate]
+        :propogate   => settings[:propogate_commit]
       }))
     end
     success

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

@@ -5,25 +5,37 @@ module Action
 module Project
         
   #-----------------------------------------------------------------------------
-  # Options
+  # Settings
         
-  def project_options(parser, ref_override = false, rev_override = false)
-    parser.option_str(:project_provider, 'git', 
-      '--proj-provider PROVIDER', 
-      'nucleon.core.mixins.project.options.provider'
-    )
-    if ref_override
-      parser.option_str(:reference, nil,
-        '--reference PROJECT_REF', 
-        'nucleon.core.mixins.project.options.reference'
-      )
+  def project_config
+    project_plugins = CORL.loaded_plugins(: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
-    if rev_override
-      parser.option_str(:revision, nil,
-        '--revision PROJECT_REV',  
-        'nucleon.core.mixins.project.options.revision'
-      )
+    register :project_reference, :str, nil, 'nucleon.core.mixin.action.project.options.project_reference' do |value|
+      success = true
+      if info = CORL.plugin_class(: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 :revision, :str, :master
   end
         
   #-----------------------------------------------------------------------------

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

@@ -5,30 +5,20 @@ module Action
 module Push
         
   #-----------------------------------------------------------------------------
-  # Options
+  # Settings
         
-  def push_options(parser, optional = true)
+  def push_config(optional = true)
+    
     if optional
-      parser.option_bool(:push, false, 
-        '--push', 
-        'nucleon.core.mixins.push.options.push'
-      )
+      register :push, :bool, false, 'nucleon.core.mixin.action.push.options.push'
     else
-      parser.options[:push] = true
+      settings[:push] = true
     end
-          
-    parser.option_bool(:propogate, false,
-      '--propogate', 
-      'nucleon.core.mixins.push.options.propogate'
-    )          
-    parser.option_str(:remote, :edit,
-      '--remote PROJECT_REMOTE',  
-      'nucleon.core.mixins.push.options.remote'
-    )
-    parser.option_str(:revision, :master,
-      '--revision PROJECT_REVISION',  
-      'nucleon.core.mixins.push.options.revision'
-    )         
+    
+    register :remote, :str, :edit, 'nucleon.core.mixin.action.push.options.remote'
+    register :revision, :str, :master, 'nucleon.core.mixin.action.push.options.revision'
+    
+    register :propogate_push, :bool, false, 'nucleon.core.mixin.action.push.options.propogate_push'
   end
         
   #-----------------------------------------------------------------------------
@@ -40,7 +30,7 @@ module Push
     if project && settings[:push]
       success = project.push(settings[:remote], extended_config(:push, {
         :revision  => settings[:revision],
-        :propogate => settings[:propogate]
+        :propogate => settings[:propogate_push]
       }))
     end
     success

data/lib/core/plugin/action.rb

@@ -7,12 +7,12 @@ class Action < Base
   # Default option interface
   
   class Option
-    def initialize(provider, name, type, default, locale = nil, &validator)
+    def initialize(namespace, provider, name, type, default, locale = nil, &validator)
       @provider  = provider
       @name      = name
       @type      = type
       @default   = default
-      @locale    = locale.nil? ? "nucleon.actions.#{provider}.options.#{name}" : locale
+      @locale    = locale.nil? ? "#{namespace}.actions.#{provider}.options.#{name}" : locale
       @validator = validator if validator
     end
     
@@ -67,8 +67,8 @@ class Action < Base
     exec_safe(provider, { :settings => Config.ensure(options), :quiet => quiet })
   end
   
-  def self.exec_cli(provider, args, quiet = false)
-    results = exec_safe(provider, { :args => args, :quiet => quiet })
+  def self.exec_cli(provider, args, quiet = false, name = :nucleon)
+    results = exec_safe(provider, { :args => args, :quiet => quiet, :executable => name })
     results[:status]
   end
   
@@ -114,6 +114,12 @@ class Action < Base
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
   
+  def namespace
+    :nucleon
+  end
+  
+  #---
+   
   def config
     get(:config)
   end
@@ -136,11 +142,11 @@ class Action < Base
     name = name.to_sym
         
     if block_given?
-      option = Option.new(plugin_provider, name, type, default, locale) do |value, success|
+      option = Option.new(namespace, plugin_provider, name, type, default, locale) do |value, success|
         yield(value, success)
       end
     else
-      option = Option.new(plugin_provider, name, type, default, locale)
+      option = Option.new(namespace, plugin_provider, name, type, default, locale)
     end
     
     config[name]   = option
@@ -170,10 +176,10 @@ class Action < Base
   
   #---
     
-  def configure(executable_name = 'nucleon')
+  def configure
     yield if block_given?
     
-    usage = "#{executable_name} #{plugin_provider} "    
+    usage = "#{plugin_provider} "    
     arguments.each do |arg|
       arg_config = config[arg.to_sym]
       
@@ -232,7 +238,8 @@ class Action < Base
         logger.debug("Parse successful: #{export.inspect}")
         
       elsif @parser.options[:help] && ! quiet?
-        puts I18n.t('nucleon.core.exec.help.usage') + ': ' + help + "\n"
+        executable = delete(:executable, '')
+        puts I18n.t('nucleon.core.exec.help.usage') + ": #{executable} " + help + "\n"
         
       else
         if @parser.options[:help]
@@ -290,13 +297,13 @@ class Action < Base
   
   #---
   
-  def validate
+  def validate(*args)
     # TODO: Add extension hooks and logging
     
     # Validate all of the configurations
     success = true
     config.export.each do |name, option|
-      success = false unless option.validate(settings[name])
+      success = false unless option.validate(settings[name], *args)
     end
     if success
       # Check for missing arguments (in case of internal execution mode)
@@ -312,7 +319,7 @@ class Action < Base
   
   #---
    
-  def execute
+  def execute(skip_validate = false, skip_hooks = false)
     logger.info("Executing action #{plugin_provider}")
     
     myself.status = code.success
@@ -320,8 +327,13 @@ class Action < Base
     
     if processed?      
       begin
-        yield if block_given? && extension_check(:exec_init)
-        myself.status = extension_set(:exec_exit)
+        if skip_validate || validate
+          yield if block_given? && ( skip_hooks || extension_check(:exec_init) )
+          myself.status = extension_set(:exec_exit) unless skip_hooks
+        else
+          puts "\n" + I18n.t('corl.core.exec.help.usage') + ': ' + help + "\n" unless quiet?
+          myself.status = code.validation_failed 
+        end
       ensure
         cleanup
       end