nucleon 0.2.0 → 0.2.1

data/lib/core/plugin/base.rb

@@ -4,12 +4,14 @@ module Plugin
 class Base < Core
   
   def self.register_ids
-    :name
+    [ :plugin_name, :name ]
   end
   
   # All Plugin classes should directly or indirectly extend Base
   
   def initialize(namespace, plugin_type, provider, options)
+    @actor = Nucleon.handle(self)
+    
     config = Util::Data.clean(Config.ensure(options), false)
     name   = Util::Data.ensure_value(config.delete(:plugin_name), config.delete(:name, provider))
     
@@ -56,7 +58,7 @@ class Base < Core
   # Property accessor / modifiers
   
   def myself
-    Nucleon.handle(self)
+    @actor
   end
   alias_method :me, :myself
   
@@ -201,6 +203,19 @@ class Base < Core
     Nucleon.collect(hook_method(hook), Config.ensure(options).import({ :plugin => myself }))
   end
   
+  #-----------------------------------------------------------------------------
+  # Input
+  
+  def ask(message, options = {})
+    ui.ask(message, options)
+  end
+  
+  #---
+  
+  def password(type, options = {})
+    ui.password(type, options)
+  end
+  
   #-----------------------------------------------------------------------------
   # Output
   
@@ -211,38 +226,77 @@ class Base < Core
   
   #---
   
-  def render(display, options = {})
-    ui.info(display.strip, options) unless quiet? || display.strip.empty?
+  def render_message(message, options = {})
+    config = Config.ensure(options)
+    
+    if config.delete(:i18n, true)
+      message = I18n.t(message, Util::Data.merge([ Config.ensure(render_options).export, config.export ], true))  
+    end
+    message  
   end
+  protected :render_message
   
   #---
-        
-  def info(name, options = {})
-    ui.info(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?
+  
+  def render(data, options = {})
+    config = Config.ensure(options)
+    
+    if ! quiet? || config[:silent]
+      translator  = nil
+      translator  = CORL.translator({}, config[:format]) if config[:format]
+      data        = translator.generate(data) if translator
+      
+      ui.dump(data, options) unless data.strip.empty? || config[:silent]
+    end
+    data
   end
   
   #---
-   
-  def alert(display, options = {})
-    ui.warn(display.strip, options) unless quiet? || display.strip.empty?
-  end
         
+  def info(message, options = {})
+    config = Config.ensure(options)
+    
+    unless quiet?
+      message = render_message(message, config)
+      ui.info(message, config.export)
+    end
+    message
+  end
+       
   #---
        
-  def warn(name, options = {})
-    ui.warn(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
+  def warn(message, options = {})
+    config = Config.ensure(options)
+    
+    unless quiet?
+      message = render_message(message, config)
+      ui.warn(message, config.export)
+    end
+    message
   end
         
   #---
         
-  def error(name, options = {})
-    ui.error(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
+  def error(message, options = {})
+    config = Config.ensure(options)
+    
+    unless quiet?
+      message = render_message(message, config)
+      ui.error(message, config.export)
+    end
+    message
   end
         
   #---
         
-  def success(name, options = {})
-    ui.success(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
+  def success(message, options = {})
+    config = Config.ensure(options)
+    
+    unless quiet?
+      message = render_message(message, config)
+      ui.success(message, config.export)
+    end
+    message
   end
   
   #-----------------------------------------------------------------------------
@@ -282,6 +336,33 @@ class Base < Core
   
   #---
   
+  def self.translate_reference(reference, editable = false)
+    # ex: provider:::name
+    if reference && reference.match(/^\s*([a-zA-Z0-9_-]+)(?::::)?(.*)?\s*$/)
+      provider = $1
+      name     = $2
+      
+      logger.debug("Translating plugin reference: #{provider}  #{name}")
+      
+      info = {
+        :provider => provider,
+        :name     => name
+      }
+      
+      logger.debug("Plugin reference info: #{info.inspect}")
+      return info
+    end
+    nil
+  end
+  
+  #---
+  
+  def translate_reference(reference, editable = false)
+    myself.class.translate_reference(reference, editable)
+  end
+  
+  #---
+  
   def self.init_plugin_collection(*external_block_methods)
     logger.debug("Initializing plugin collection interface at #{Time.now}")
     
@@ -306,7 +387,7 @@ class Base < Core
       logger.error(error.inspect)
       logger.error(error.message)
       
-      ui.error(error.message, { :prefix => false }) if error.message
+      error(error.message, { :prefix => false, :i18n => false }) if error.message
     end
     return false
   end
@@ -317,7 +398,7 @@ class Base < Core
     if Nucleon.admin?
       safe_exec(return_result, &block)
     else
-      ui.warn("The #{plugin_provider} action must be run as a machine administrator")
+      warn("The #{plugin_provider} action must be run as a machine administrator", { :i18n => false })
       myself.status = code.access_denied    
     end
   end

data/lib/core/plugin/command.rb

@@ -3,6 +3,10 @@ module Nucleon
 module Plugin
 class Command < Nucleon.plugin_class(:nucleon, :base)
 
+  def self.register_ids
+    [ :command, :args, :flags, :data, :subcommand ]
+  end
+  
   #-----------------------------------------------------------------------------
   # Command plugin interface
   

data/lib/core/util/cache.rb

@@ -24,11 +24,19 @@ class Cache < Core
     @cache_translator = Nucleon.type_default(:nucleon, :translator)
     @cache_filename   = "#{id}.#{translator}"
     @cache_path       = File.join(@cache_root, @cache_filename)
+    
+    load
   end
       
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
   
+  def status
+    @status
+  end
+  
+  #---
+  
   def base_path
     @cache_root
   end
@@ -72,7 +80,7 @@ class Cache < Core
 
   #---
   
-  def set(keys, value)
+  def set(keys, value, delete_nil = false)
     result = super
     save if initialized?
     result
@@ -109,6 +117,7 @@ class Cache < Core
   
   def load
     success = false
+    @status = 255
     
     @@cache_lock.synchronize do  
       logger.info("Loading #{translator} translated cache from #{file}")
@@ -124,6 +133,7 @@ class Cache < Core
         
         import(parse_properties, { :no_save => true }) unless parse_properties.empty?
         success = true
+        @status = Nucleon.code.success
       end
     end  
     success   
@@ -134,6 +144,7 @@ class Cache < Core
   
   def save
     success = false
+    @status = 255
     
     @@cache_lock.synchronize do
       if renderer = CORL.translator({}, translator)
@@ -143,6 +154,7 @@ class Cache < Core
           
         if Disk.write(file, rendering)
           success = true
+          @status = Nucleon.code.success
         end
       end
     end

data/lib/core/util/cli.rb

@@ -22,17 +22,14 @@ module CLI
   def self.decode(encoded_string)
     Util::Data.symbol_map(Util::Data.parse_json(Base64.urlsafe_decode64(encoded_string)))  
   end
-        
+       
   #-------------------------------------------------------------------------
   # Parser
        
   class Parser
         
-    attr_accessor :parser
-    attr_accessor :options
-    attr_accessor :arguments
-    attr_accessor :processed
- 
+    attr_accessor :parser, :options, :arguments, :extra, :processed, :strict
+    
     #---
     
     include Mixin::Colors
@@ -40,12 +37,13 @@ module CLI
     #---
         
     def initialize(args, banner = '', help = '', split_help = false)
-          
       @parser = OptionParser.new
-          
+         
       self.options   = {}
       self.arguments = {}
+      self.extra     = {}
       self.processed = false
+      self.strict    = true      
           
       @arg_settings  = []
           
@@ -53,7 +51,7 @@ module CLI
       self.help    = help
           
       yield(self) if block_given?
-          
+         
       parse_command(args, split_help)
     end
         
@@ -148,10 +146,16 @@ module CLI
           options[:help] = true
         end  
       end
-      parser.parse!(args)
+      
+      if strict
+        parser.parse!(args)
+        extra_args = {}
+      else
+        args, extra_args = parse_known_args(parser, args)
+      end
       
       # Now we can act on options given
-      Util::Console.use_colors = options[:color] unless split_help
+      options[:color] = Util::Console.use_colors
       
       if options[:version]
         puts version
@@ -163,6 +167,8 @@ module CLI
       parse_encoded
       
       Nucleon.log_level = options[:log_level] if options[:log_level]
+      
+      self.extra = normalize_extra_options(extra_args) unless extra_args.empty?
          
       remaining_args = args.dup
       arg_messages   = []
@@ -252,6 +258,66 @@ module CLI
       options.delete(:encoded_params)
     end
   
+    #---
+  
+    def parse_known_args(parser, args)
+      extra_args = []
+      
+      parse_args = lambda do |arg_list|
+        begin
+          original_list = arg_list.clone
+          
+          parser.parse! arg_list
+          args = arg_list
+          
+        rescue OptionParser::InvalidOption => e
+          extra_args += e.args
+          while arg_list[0] && arg_list[0][0] != '-'
+            extra_args << arg_list.shift
+          end
+          parse_args.call original_list - extra_args
+        end
+      end
+      parse_args.call args
+      [ args, extra_args ]
+    end
+    
+    #---
+    
+    def normalize_extra_options(arg_list)
+      options     = {}      
+      last_option = nil
+      
+      Util::Data.array(arg_list).each do |arg|
+        components = arg.split('=')
+        value      = nil      
+        
+        if components.size > 1
+          arg   = components[0]
+          value = components[1]  
+        end
+        
+        if arg[0] == '-'
+          last_option          = arg.sub(/^\-+/, '').to_sym
+          options[last_option] = Util::Data.value(value) if value          
+        else
+          if last_option
+            if options[last_option]
+              options[last_option] = [ options[last_option] ] unless options[last_option].is_a?(Array)
+              options[last_option] << Util::Data.value(arg)
+            else
+              options[last_option] = Util::Data.value(arg)  
+            end  
+          else
+            parser.warn(CLI.message('nucleon.core.util.cli.parse.error') + "\n\n" + parser.help)
+            break  
+          end
+        end        
+      end      
+      options
+    end
+    protected :normalize_extra_options
+   
     #---
           
     def option(name, default, option_str, allowed_values, message_id, config = {})

data/lib/core/util/console.rb

@@ -9,7 +9,6 @@ class Console
   
   #---
   
-  @@console_lock = Nucleon.console_lock
   @@quiet        = false
   @@use_colors   = true
   
@@ -95,22 +94,20 @@ class Console
     defaults = { :new_line => true, :prefix => true }
     options  = defaults.merge(options)
     printer  = options[:new_line] ? :puts : :print
-    channel  = type == :error || options[:channel] == :error ? @error : @output
     
-    options[:sync] = true unless options.has_key?(:sync)
+    puts_options           = { :printer => printer }
+    puts_options[:channel] = options[:channel] if options.has_key?(:channel)
     
-    render = lambda do 
-      safe_puts(format_message(type, message, options),
-                :channel => channel, :printer => printer)  
-    end
+    safe_puts(format_message(type, message, options), puts_options)
+  end
+  
+  #---
+  
+  def dump(data, options = {})
+    return @delegate.dump(data, options) if check_delegate('dump')
     
-    if options[:sync]
-      #@@console_lock.synchronize do
-        render.call
-      #end
-    else
-      render.call
-    end
+    options[:channel] = options.has_key?(:channel) ? options[:channel] : @error
+    safe_puts(data.to_s, options)  
   end
   
   #---
@@ -122,30 +119,18 @@ class Console
     options[:prefix] = false if ! options.has_key?(:prefix)
     options[:echo] = true if ! options.has_key?(:echo)
     
-    options[:sync] = true unless options.has_key?(:sync)
-    
     user_input = nil
     
-    collect = lambda do 
-      say(:info, message, Config.ensure(options).import({ :sync => false, :quiet_override => true }).export)
+    say(:info, message, Config.ensure(options).import({ :quiet_override => true }).export)
       
-      if options[:echo]
-        user_input = @input.gets.chomp
-      else
-        require 'io/console'        
-        user_input = @input.noecho(&:gets).chomp
-      end
-      safe_puts("\n")
-      user_input  
-    end
-
-    if options[:sync]
-      #@@console_lock.synchronize do
-        return collect.call
-      #end
+    if options[:echo]
+      user_input = @input.gets.chomp
     else
-      return collect.call  
+      require 'io/console'        
+      user_input = @input.noecho(&:gets).chomp
     end
+    safe_puts("\n")
+    user_input
   end
   
   #---
@@ -153,35 +138,23 @@ class Console
   def password(type, options = {})
     return @delegate.password(type, options) if check_delegate('password')
     
-    options[:sync] = true unless options.has_key?(:sync)
-    
-    collect = lambda do
-      try_again = true
-      password  = nil
+    try_again = true
+    password  = nil
       
-      while try_again
-        # Get and check a password from the keyboard
-        password              = ask("Enter #{type} password: ", { :echo => false, :sync => false })
-        confirmation_password = ask("Confirm #{type} password: ", { :echo => false, :sync => false })
+    while try_again
+      # Get and check a password from the keyboard
+      password              = ask("Enter #{type} password: ", { :echo => false })
+      confirmation_password = ask("Confirm #{type} password: ", { :echo => false })
     
-        if password != confirmation_password
-          choice    = ask('Passwords do not match!  Try again? (Y|N): ', { :sync => false })
-          try_again = choice.upcase == "Y"
-          password  = nil unless try_again
-        else
-          try_again = false
-        end
+      if password != confirmation_password
+        choice    = ask('Passwords do not match!  Try again? (Y|N): ')
+        try_again = choice.upcase == "Y"
+        password  = nil unless try_again
+      else
+        try_again = false
       end
-      password.strip
-    end
-    
-    if options[:sync]
-      #@@console_lock.synchronize do
-        return collect.call
-      #end
-    else
-      return collect.call  
     end
+    password.strip
   end
   
   #-----------------------------------------------------------------------------
@@ -219,8 +192,13 @@ class Console
     return @delegate.format_message(type, message, options) if check_delegate('format_message')    
     return '' if message.to_s.strip.empty?
     
-    if @resource && ! @resource.empty? && options[:prefix]
-      prefix = "[#{@resource}]"
+    if options[:prefix]
+      if prefix_text = options[:prefix_text]
+        prefix = "[#{prefix_text}]"
+        
+      elsif @resource && ! @resource.empty?
+        prefix = "[#{@resource}]"
+      end
     end
     
     lines         = []
@@ -228,23 +206,28 @@ class Console
     escaped_clear = Regexp.escape(@@colors[:clear])
     
     message.split("\n").each do |line|
-      line = prev_color + line if prev_color
-            
-      lines << "#{prefix} #{line}".sub(/^ +/, '')
+      line = prev_color + line if self.class.use_colors && @color && prev_color
       
-      # Set next previous color
-      if line =~ /#{escaped_clear}$/
-        prev_color = nil  
-      else
-        line_section = line.split(/#{escaped_clear}/).pop
-        prev_colors  = line_section.scan(/\e\[[0-9][0-9]?m/)
-        prev_color   = prev_colors.pop unless prev_colors.empty?
-      end      
+      lines << "#{prefix} #{line}".sub(/^ /, '')
+      
+      if self.class.use_colors && @color
+        # Set next previous color
+        if line =~ /#{escaped_clear}$/
+          prev_color = nil  
+        else
+          line_section = line.split(/#{escaped_clear}/).pop
+          
+          if line_section
+            prev_colors = line_section.scan(/\e\[[0-9][0-9]?m/)
+            prev_color  = prev_colors.pop unless prev_colors.empty?
+          end
+        end
+      end
     end
        
     message = lines.join("\n")
     
-    if @@use_colors && @color
+    if self.class.use_colors && @color
       if options.has_key?(:color)
         message = self.class.colorize(message, options[:color]) 
       else