nucleon 0.1.1 → 0.1.2

data/lib/core/plugin/base.rb

@@ -167,7 +167,9 @@ class Base < Core
   #---
   
   def extended_config(type, options = {})
-    Nucleon.config(type, Config.ensure(options).import({ :plugin => myself }))
+    config = Nucleon.config(type, Config.ensure(options).import({ :plugin => myself }))
+    config.delete(:plugin)
+    config
   end
   
   #---
@@ -179,7 +181,7 @@ class Base < Core
   #---
   
   def extension_set(hook, value, options = {})
-    Nucleon.set(hook_method(hook), value, Config.ensure(options).import({ :plugin => myself }))
+    Nucleon.value(hook_method(hook), value, Config.ensure(options).import({ :plugin => myself }))
   end
   
   #---
@@ -266,7 +268,7 @@ class Base < Core
 
   def self.translate(data)
     logger.debug("Translating data to internal plugin structure: #{data.inspect}")
-    return ( data.is_a?(Hash) ? symbol_map(data) : {} )
+    return ( data.is_a?(Hash) ? symbol_map(data) : data )
   end
   
   #---
@@ -302,7 +304,7 @@ class Base < Core
   
   def admin_exec(return_result = true, &code)
     if Nucleon.admin?
-      safe_exec(return_result, &code) if block_given?
+      safe_exec(return_result, &code)
     else
       ui.warn("The #{plugin_provider} action must be run as a machine administrator")
       myself.status = code.access_denied    

data/lib/core/util/cli.rb

@@ -35,7 +35,7 @@ module CLI
         
     #---
         
-    def initialize(args, banner = '', help = '')
+    def initialize(args, banner = '', help = '', split_help = false)
           
       @parser = OptionParser.new
           
@@ -50,7 +50,7 @@ module CLI
           
       yield(self) if block_given?
           
-      parse_command(args)
+      parse_command(args, split_help)
     end
         
     #---
@@ -70,7 +70,7 @@ module CLI
       end
 
       main_args = args.dup if main_args.nil?
-      results   = [ Parser.new(main_args, banner, separator) ]
+      results   = [ Parser.new(main_args, banner, separator, true) ]
           
       if sub_command
         results << [ sub_command, sub_args ]
@@ -103,7 +103,7 @@ module CLI
         
     #---
         
-    def parse_command(args)
+    def parse_command(args, split_help = false)
       args  = args.dup
       error = false
           
@@ -117,14 +117,26 @@ module CLI
         '--encoded STR', 
         'nucleon.core.util.cli.options.encoded'
       )
-      parser.on_tail('-h', '--help', CLI.message('nucleon.core.util.cli.options.help')) do
-        options[:help] = true
-        return
+      if split_help
+        parser.on_tail('-h', CLI.message('nucleon.core.util.cli.options.short_help')) do
+          options[:help] = true
+        end
+        parser.on_tail('--help', CLI.message('nucleon.core.util.cli.options.extended_help')) do
+          options[:help]          = true
+          options[:extended_help] = true
+        end
+      else
+        parser.on_tail('-h', '--help', CLI.message('nucleon.core.util.cli.options.short_help')) do
+          options[:help] = true
+        end  
       end
           
       parser.parse!(args)
-                    
+      
+      # Now we can act on options given              
       Nucleon.log_level = options[:log_level] if options[:log_level]
+      return if options[:help]
+      
       parse_encoded
          
       remaining_args = args.dup

data/lib/core/util/data.rb

@@ -300,9 +300,6 @@ class Data
         matches = item.match(regexp)
         result  = nil
         
-        #dbg(item, 'item')
-        #dbg(matches, 'matches')
-        
         unless matches.nil?
           replacement = scope.search(matches[group], options)
           result      = item.gsub(matches[0], replacement) unless replacement.nil?
@@ -312,21 +309,16 @@ class Data
       
       case value
       when String
-        #dbg(value, 'interpolate (string) -> init')
         while (temp = replace.call(value))
-          #dbg(temp, 'interpolate (string) -> replacement')
           value = temp
         end
         
       when Hash
-        #dbg(value, 'interpolate (hash) -> init')
         value.each do |key, data|
-          #dbg(data, "interpolate (#{key}) -> data")
           value[key] = interpolate(data, scope, options)
         end
       end
     end
-    #dbg(value, 'interpolate -> result')
     return value  
   end
   

data/lib/nucleon.rb

@@ -9,167 +9,9 @@
 # Author::    Adrian Webb (mailto:adrian.webb@coralnexus.com)
 # License::   GPLv3
 
-#-------------------------------------------------------------------------------
-# Global namespace
-
-module Kernel
-   
-  def dbg(data, label = '')
-    # Invocations of this function should NOT be committed to the project
-    require 'pp'
-    
-    puts '>>----------------------'
-    unless label.empty?
-      puts label
-      puts '---'
-    end
-    pp data
-    puts '<<'
-  end
-  
-  #---  
-    
-  def nucleon_locate(command)
-    command = command.to_s
-    exts    = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-      exts.each do |ext|
-        exe = File.join(path, "#{command}#{ext}")
-        return exe if File.executable?(exe)
-      end
-    end
-    return nil
-  end
-    
-  #---
-  
-  def nucleon_require(base_dir, name)
-    name = name.to_s
-    top_level_file = File.join(base_dir, "#{name}.rb")
-    
-    require top_level_file if File.exists?(top_level_file) 
-     
-    directory = File.join(base_dir, name)
-      
-    if File.directory?(directory)
-      Dir.glob(File.join(directory, '**', '*.rb')).each do |sub_file|
-        require sub_file
-      end
-    end  
-  end
-end
-
-#-------------------------------------------------------------------------------
-# Load paths 
-
-lib_dir          = File.dirname(__FILE__)
-core_dir         = File.join(lib_dir, 'core')
-mixin_dir        = File.join(core_dir, 'mixin')
-mixin_config_dir = File.join(mixin_dir, 'config')
-mixin_action_dir = File.join(mixin_dir, 'action')
-macro_dir        = File.join(mixin_dir, 'macro')
-util_dir         = File.join(core_dir, 'util')
-mod_dir          = File.join(core_dir, 'mod')
-plugin_dir       = File.join(core_dir, 'plugin')
-  
-#-------------------------------------------------------------------------------
-# Coral requirements
-
-$:.unshift(lib_dir) unless $:.include?(lib_dir) || $:.include?(File.expand_path(lib_dir))
-
-#---
-  
-require 'rubygems'
-
-require 'optparse'
-require 'pp'
-require 'i18n'
-require 'log4r'
-require 'log4r/configurator'
-require 'deep_merge'
-
-require 'digest/sha1'
-require 'base64'
-
-require 'yaml'
-require 'multi_json'
-
-require 'thread' # Eventually depreciated
-require 'celluloid'
-require 'celluloid/autostart'
-
-#---
-
-# TODO: Make this dynamically settable
-
-I18n.enforce_available_locales = false
-I18n.load_path << File.expand_path(File.join('..', 'locales', 'en.yml'), lib_dir)
-
-#---
-
-if nucleon_locate('git')
-  require 'grit'
-  nucleon_require(util_dir, :git)
-end
-
-#---
-
-# Make sure logger is at the top of our load order priorities
-nucleon_require(util_dir, :logger)
-
-#---
-
-# Object modifications (100% pure monkey patches)
-Dir.glob(File.join(mod_dir, '*.rb')).each do |file|
-  require file
-end
-
-#---
-
-# Mixins for classes
-Dir.glob(File.join(mixin_dir, '*.rb')).each do |file|
-  require file
-end
-Dir.glob(File.join(mixin_config_dir, '*.rb')).each do |file|
-  require file
-end
-Dir.glob(File.join(mixin_action_dir, '*.rb')).each do |file|
-  require file
-end
-Dir.glob(File.join(macro_dir, '*.rb')).each do |file|
-  require file
-end
-
-#---
-
-# Include bootstrap classes
-nucleon_require(core_dir, :errors)
-nucleon_require(core_dir, :codes)
-nucleon_require(util_dir, :data)
-nucleon_require(core_dir, :config)
-nucleon_require(util_dir, :console) 
-nucleon_require(core_dir, :core) 
-
-#---
-
-# Include core utilities
-[ :liquid, 
-  :cli, 
-  :disk, 
-  :package, 
-  :shell
-].each do |name| 
-  nucleon_require(util_dir, name)
-end
-
-# Include plugin system
-nucleon_require(core_dir, :facade)
-nucleon_require(core_dir, :gems)
-nucleon_require(core_dir, :manager)
-nucleon_require(plugin_dir, :base)
-nucleon_require(core_dir, :plugin)
+require File.join(File.dirname(__FILE__), "nucleon_base.rb")
 
 #-------------------------------------------------------------------------------
-# Nucleon initialization
+# Core initialization
 
-Nucleon.reload
+Nucleon.reload(true)

data/lib/nucleon/action/add.rb

@@ -1,67 +1,61 @@
 
 module Nucleon
 module Action
-class Add < Plugin::Action
+class Add < Nucleon.plugin_class(:action)
   
   include Mixin::Action::Project
   include Mixin::Action::Push
  
   #-----------------------------------------------------------------------------
-  # Add action interface
+  # Settings
   
-  def normalize
-    super('nucleon add <subproject/path> <subproject:::reference>')    
-    
-    codes :project_failure => 20,
-          :add_failure     => 21,
-          :push_failure    => 22
+  def configure
+    super do    
+      codes :project_failure,
+            :add_failure,
+            :push_failure
+            
+      register :sub_path, :str, nil
+      register :editable, :bool, false
+      
+      project_config
+      push_config
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :sub_path, :project_reference ]
   end
 
   #-----------------------------------------------------------------------------
   # Action operations
    
-  def parse(parser)
-    parser.arg_str(:sub_path, nil, 
-      'nucleon.core.actions.add.options.sub_path'
-    )
-    parser.arg_str(:sub_reference, nil, 
-      'nucleon.core.actions.add.options.sub_reference'
-    )
-    parser.option_bool(:editable, false, 
-      '--editable', 
-      'nucleon.core.actions.add.options.editable'
-    )
-    project_options(parser, true, true)
-    push_options(parser, true)  
-  end
-  
-  #---
-   
   def execute
-    super do |node, network, status|
-      info('nucleon.core.actions.add.start')
+    super do
+      info('nucleon.actions.add.start')
       
       if project = project_load(Dir.pwd, false)
-        sub_info = project.translate_reference(settings[:sub_reference], settings[:editable])
+        sub_info = project.translate_reference(settings[:project_reference], settings[:editable])
         sub_path = settings[:sub_path]
           
         if sub_info
           sub_url      = sub_info[:url]
           sub_revision = sub_info[:revision]
         else
-          sub_url      = settings[:sub_reference]
+          sub_url      = settings[:project_reference]
           sub_revision = nil
         end
           
         if project.add_subproject(sub_path, sub_url, sub_revision)
-          status = code.push_failure unless push(project)
+          myself.status = code.push_failure unless push(project)
         else
-          status = code.add_failure
+          myself.status = code.add_failure
         end
       else
-        status = code.project_failure               
-      end        
-      status
+        myself.status = code.project_failure               
+      end
     end
   end
 end

data/lib/nucleon/action/create.rb

@@ -1,50 +1,45 @@
 
 module Nucleon
 module Action
-class Create < Plugin::Action
- 
-  #-----------------------------------------------------------------------------
-  # Create action interface
+class Create < Nucleon.plugin_class(:action)
   
-  def normalize
-    super('nucleon create [ <project:::reference> ]')    
-    
-    codes :project_failure => 20
-  end
+  include Mixin::Action::Project
  
   #-----------------------------------------------------------------------------
-  # Action operations
+  # Settings
   
-  def parse(parser)
-    parser.option_str(:path, Dir.pwd, 
-      '--path PROJECT_DIR', 
-      'nucleon.core.actions.create.options.path'
-    )
-    parser.option_str(:revision, :master, 
-      '--revision REVISION/BRANCH', 
-      'nucleon.core.actions.create.options.revision'
-    )
-    parser.arg_str(:reference, 
-      'github:::coralnexus/puppet-cloud-template', 
-      'nucleon.core.actions.create.options.reference'
-    )
+  def configure
+    super do    
+      codes :project_failure
+      
+      register :path, :str, Dir.pwd
+      
+      project_config
+    end
   end
   
   #---
+  
+  def arguments
+    [ :project_reference ]
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Operations
    
   def execute
-    super do |node, network, status|
-      info('nucleon.core.actions.create.start')
+    super do |node, network|
+      info('nucleon.actions.create.start')
       
       project = Nucleon.project(extended_config(:project, {
         :create    => true,
         :directory => settings[:path],
-        :url       => settings[:reference],
+        :url       => settings[:project_reference],
         :revision  => settings[:revision],
         :pull      => true
-      }))
+      }), settings[:project_provider])
       
-      project ? status : code.project_failure
+      myself.status = code.project_failure unless project
     end
   end
 end