nucleon 0.1.0 → 0.1.1

data/lib/core/plugin/template.rb

@@ -0,0 +1,80 @@
+
+module Nucleon
+module Plugin
+class Template < Base
+
+  #-----------------------------------------------------------------------------
+  # Template plugin interface
+
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def process(value)
+    case value
+    when String, Symbol
+      return nil        if Util::Data.undef?(value)
+      return 'false'    if value == false
+      return 'true'     if value == true      
+      return value.to_s if value.is_a?(Symbol)
+      
+    when Hash
+      results = {}
+      value.each do |key, item|
+        result = process(item)
+        unless result.nil?
+          results[key] = result  
+        end
+        value = results
+      end
+      
+    when Array
+      results = []
+      value.each_with_index do |item, index|
+        result = process(item)
+        unless result.nil?
+          results << result  
+        end        
+      end
+      value = results
+    end
+    return value
+  end
+    
+  #---
+  
+  def render(data)
+    normalize   = get(:normalize_template, true)
+    interpolate = get(:interpolate_template, true)
+    
+    logger.debug("Rendering data: normalize: #{normalize.inspect}; interpolate: #{interpolate.inspect}: #{data.inspect}")
+    
+    if normalize
+      data = Config.normalize(data, nil, config)
+      logger.debug("Pre-rendering data normalization: #{data.inspect}")
+    end
+    
+    if normalize && interpolate
+      data = Util::Data.interpolate(data, data, export)
+      logger.debug("Pre-rendering data interpolation: #{data.inspect}")
+    end    
+    return render_processed(process(data))
+  end
+  
+  #---
+  
+  def render_processed(data)
+    logger.debug("Rendering #{plugin_provider} data: #{data.inspect}")
+    
+    output = ''
+    output = yield(output) if block_given?
+    
+    logger.debug("Completed rendering of #{plugin_provider} data: #{output}")
+    return output
+  end
+end
+end
+end

data/lib/core/plugin/translator.rb

@@ -0,0 +1,38 @@
+
+module Nucleon
+module Plugin
+class Translator < Base
+
+  #-----------------------------------------------------------------------------
+  # Translator plugin interface
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def parse(raw)
+    logger.debug("Parsing raw data: #{raw}")
+    
+    properties = {}
+    properties = yield(properties) if block_given?
+    
+    logger.debug("Completed parsing data: #{properties.inspect}")
+    return properties
+  end
+  
+  #---
+  
+  def generate(properties)
+    logger.debug("Generating output data: #{properties.inspect}")
+    
+    output = ''
+    output = yield(output) if block_given?
+    
+    logger.debug("Completed generating data: #{output}")
+    return output
+  end
+end
+end
+end

data/lib/core/util/cli.rb

@@ -0,0 +1,353 @@
+
+module Nucleon
+module Util
+module CLI
+         
+  #-----------------------------------------------------------------------------
+  # Utilities
+        
+  def self.message(name, default = nil)
+    if default.nil?
+      default = :none
+    end
+    return I18n.t(name.to_s, :default_value => default.to_s)
+  end
+      
+  #---
+      
+  def self.encode(data)
+    Base64.encode64(Util::Data.to_json(data, false))
+  end
+      
+  def self.decode(encoded_string)
+    Util::Data.symbol_map(Util::Data.parse_json(Base64.decode64(encoded_string)))  
+  end
+        
+  #-------------------------------------------------------------------------
+  # Parser
+       
+  class Parser
+        
+    attr_accessor :parser
+    attr_accessor :options
+    attr_accessor :arguments
+    attr_accessor :processed
+        
+    #---
+        
+    def initialize(args, banner = '', help = '')
+          
+      @parser = OptionParser.new
+          
+      self.options   = {}
+      self.arguments = {}
+      self.processed = false
+          
+      @arg_settings  = []
+          
+      self.banner  = banner
+      self.help    = help
+          
+      yield(self) if block_given?
+          
+      parse_command(args)
+    end
+        
+    #---
+        
+    def self.split(args, banner, separator = '')
+      main_args   = nil
+      sub_command = nil
+      sub_args    = []
+
+      args.each_index do |index|
+        if !args[index].start_with?('-')
+          main_args   = args[0, index]
+          sub_command = args[index]
+          sub_args    = args[index + 1, args.length - index + 1]
+          break
+        end
+      end
+
+      main_args = args.dup if main_args.nil?
+      results   = [ Parser.new(main_args, banner, separator) ]
+          
+      if sub_command
+        results << [ sub_command, sub_args ]
+      end
+
+      return results.flatten
+    end
+        
+    #---
+        
+    def banner=banner
+      parser.banner = banner  
+    end
+        
+    #---
+        
+    def help
+      return parser.help
+    end
+        
+    def help=help
+      if help.is_a?(Array)
+        help.each do |line|
+          parser.separator line  
+        end                       
+      else
+        parser.separator help
+      end
+    end
+        
+    #---
+        
+    def parse_command(args)
+      args  = args.dup
+      error = false
+          
+      self.processed = false
+          
+      option_str(:log_level, nil, 
+        '--log_level STR', 
+        'nucleon.core.util.cli.options.log_level'
+      )
+      option_str(:encoded_params, false, 
+        '--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
+      end
+          
+      parser.parse!(args)
+                    
+      Nucleon.log_level = options[:log_level] if options[:log_level]
+      parse_encoded
+         
+      remaining_args = args.dup
+      arg_messages   = []
+          
+      if arguments.empty?
+        @arg_settings.each_with_index do |settings, index|
+          if index >= args.length
+            value = nil
+          else
+            value = Util::Data.value(args[index])
+          end
+            
+          if !value.nil? && settings.has_key?(:allowed)
+            allowed = settings[:allowed]
+            case allowed
+            when Class
+              if (allowed == Array)
+                value          = remaining_args
+                remaining_args = []
+              end
+              unless value.is_a?(allowed)
+                arg_messages << CLI.message(settings[:message])
+                error = true
+              end
+            when Array
+              unless allowed.include(value)
+                arg_messages << CLI.message(settings[:message])
+                error = true  
+              end
+            end
+          end
+            
+          if value.nil?
+            if settings.has_key?(:default)
+              value = settings[:default]
+            else
+              error = true
+            end
+          end
+            
+          if !value.nil? && settings.has_key?(:block)
+            value = settings[:block].call(value)
+            error = true if value.nil?
+          end
+            
+          break if error
+            
+          remaining_args.shift unless remaining_args.empty?
+          self.arguments[settings[:name]] = value
+        end          
+      end
+          
+      if error
+        if ! arg_messages.empty?
+          parser.warn(CLI.message('nucleon.core.util.cli.parse.error') + "\n\n" + arg_messages.join("\n") + "\n\n" + parser.help)
+        else
+          parser.warn(CLI.message('nucleon.core.util.cli.parse.error') + "\n\n" + parser.help)  
+        end
+      else
+        self.processed = true
+      end
+        
+    rescue OptionParser::InvalidOption => e
+      parser.warn(e.message + "\n\n" + parser.help)
+    end
+        
+    #---
+        
+    def parse_encoded
+      if options[:encoded_params]
+        encoded_properties = CLI.decode(options[:encoded_params])
+            
+        @arg_settings.each do |settings|
+          if encoded_properties.has_key?(settings[:name].to_sym)
+            self.arguments[settings[:name]] = encoded_properties.delete(settings[:name].to_sym)
+          end
+        end
+            
+        encoded_properties.each do |name, value|
+          self.options[name] = value unless options.has_key?(name)
+        end
+      end
+      options.delete(:encoded_params)
+    end
+  
+    #---
+          
+    def option(name, default, option_str, allowed_values, message_id, config = {})
+      config        = Config.ensure(config)
+      name          = name.to_sym
+      options[name] = config.get(name, default)
+          
+      message_name = name.to_s + '_message'
+      message      = CLI.message(message_id, options[name])
+        
+      option_str   = Util::Data.array(option_str)
+         
+      if allowed_values
+        parser.on(*option_str, allowed_values, config.get(message_name.to_sym, message)) do |value|
+          value         = yield(value) if block_given?
+          options[name] = value unless value.nil?
+        end
+      else
+        parser.on(*option_str, config.get(message_name.to_sym, message)) do |value|
+          value         = yield(value) if block_given?
+          options[name] = value unless value.nil?
+        end  
+      end
+    end
+        
+    #---
+        
+    def arg(name, default, allowed_values, message_id, config = {}, &block)
+      config       = Config.ensure(config)
+      name         = name.to_sym
+          
+      message_name = name.to_s + '_message'
+      message      = CLI.message(message_id, arguments[name])
+        
+      settings     = { 
+        :name    => name,
+        :default => config.get(name, default),
+        :message => config.get(message_name.to_sym, message) 
+      }
+      settings[:allowed] = allowed_values if allowed_values
+      settings[:block]   = block if block
+          
+      settings.delete(:default) if settings[:default].nil?
+          
+      @arg_settings << settings  
+    end
+        
+    #---
+        
+    def option_bool(name, default, option_str, message_id, config = {})
+      option(name, default, option_str, nil, message_id, config) do |value|
+        value = Util::Data.value(value)
+        if value == true || value == false
+          block_given? ? yield(value) : value
+        else
+          nil
+        end 
+      end  
+    end
+        
+    #---
+        
+    def arg_bool(name, default, message_id, config = {})
+      arg(name, default, nil, message_id, config) do |value|
+        value = Util::Data.value(value)
+        if value == true || value == false
+          block_given? ? yield(value) : value
+        else
+          nil
+        end 
+      end  
+    end
+        
+    #---
+        
+    def option_int(name, default, option_str, message_id, config = {})
+      option(name, default, option_str, Integer, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end 
+    end
+        
+    #---
+        
+    def arg_int(name, default, message_id, config = {})
+      arg(name, default, Integer, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end 
+    end
+        
+    #---
+        
+    def option_float(name, default, option_str, message_id, config = {})
+      option(name, default, option_str, Float, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+        
+    #---
+        
+    def arg_float(name, default, message_id, config = {})
+      arg(name, default, Float, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+          
+    #---
+        
+    def option_str(name, default, option_str, message_id, config = {})
+      option(name, default, option_str, nil, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+         
+    #---
+        
+    def arg_str(name, default, message_id, config = {})
+      arg(name, default, nil, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+         
+    #---
+        
+    def option_array(name, default, option_str, message_id, config = {})
+      option(name, default, option_str, Array, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+         
+    #---
+        
+    def arg_array(name, default, message_id, config = {})
+      arg(name, default, Array, message_id, config) do |value|
+        block_given? ? yield(value) : value 
+      end  
+    end
+  end    
+end
+end
+end

data/lib/core/util/console.rb

@@ -0,0 +1,237 @@
+
+module Nucleon
+module Util
+class Console
+  
+  @@console_lock = Mutex.new
+  @@quiet        = false
+  
+  #---
+
+  COLORS = {
+    :clear  => "\e[0m",
+    :red    => "\e[31m",
+    :green  => "\e[32m",
+    :yellow => "\e[33m"
+  }
+
+  COLOR_MAP = {
+    :warn    => COLORS[:yellow],
+    :error   => COLORS[:red],
+    :success => COLORS[:green]
+  }
+
+  #-----------------------------------------------------------------------------
+  # Constructor
+  
+  def initialize(options = {})
+    if options.is_a?(String)
+      options = { :resource => options }
+    end
+    config = Config.ensure(options)
+    
+    @resource = config.get(:resource, '')
+    
+    @color   = config.get(:color, true)    
+    @printer = config.get(:printer, :puts)
+    
+    @input  = config.get(:input, $stdin)
+    @output = config.get(:output, $stdout)
+    @error  = config.get(:error, $stderr)
+    
+    @delegate = config.get(:console_delegate, nil)
+  end
+
+  #---
+  
+  def inspect
+    "#<#{self.class}: #{@resource}>"
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  attr_accessor :resource, :color, :input, :output, :error, :delegate
+  
+  #---
+  
+  def self.quiet=quiet
+    @@quiet = quiet
+  end
+  
+  #-----------------------------------------------------------------------------
+  # UI functionality
+
+  def say(type, message, options = {})
+    return if @@quiet && ! options[:quiet_override]
+    return @delegate.say(type, message, options) if check_delegate('say')
+    
+    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)
+    
+    render = lambda do 
+      safe_puts(format_message(type, message, options),
+                :channel => channel, :printer => printer)  
+    end
+    
+    if options[:sync]
+      @@console_lock.synchronize do
+        render.call
+      end
+    else
+      render.call
+    end
+  end
+  
+  #---
+
+  def ask(message, options = {})
+    return @delegate.ask(message, options) if check_delegate('ask')
+
+    options[:new_line] = false if ! options.has_key?(:new_line)
+    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)
+      
+      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
+    else
+      return collect.call  
+    end
+  end
+  
+  #---
+  
+  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
+      
+      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 })
+    
+        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
+      end
+      password
+    end
+    
+    if options[:sync]
+      @@console_lock.synchronize do
+        return collect.call
+      end
+    else
+      return collect.call  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def info(message, *args)
+    return @delegate.info(message, *args) if check_delegate('info')
+    say(:info, message, *args)
+  end
+  
+  #---
+  
+  def warn(message, *args)
+    return @delegate.warn(message, *args) if check_delegate('warn')
+    say(:warn, message, *args)
+  end
+  
+  #---
+  
+  def error(message, *args)
+    return @delegate.error(message, *args) if check_delegate('error')
+    say(:error, message, *args)
+  end
+  
+  #---
+  
+  def success(message, *args)
+    return @delegate.success(message, *args) if check_delegate('success')
+    say(:success, message, *args)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def format_message(type, message, options = {})
+    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}]"
+    end
+    message = "#{prefix} #{message}".lstrip.gsub(/\n+$/, '')
+    
+    if @color
+      if options.has_key?(:color)
+        color = COLORS[options[:color]]
+        message = "#{color}#{message}#{COLORS[:clear]}"
+      else
+        message = "#{COLOR_MAP[type]}#{message}#{COLORS[:clear]}" if COLOR_MAP[type]
+      end
+    end
+    return message
+  end
+
+  #---
+  
+  def safe_puts(message = nil, options = {})
+    return @delegate.safe_puts(message, options) if check_delegate('safe_puts')
+    
+    message ||= ""
+    options = {
+      :channel => @output,
+      :printer => @printer,
+    }.merge(options)
+
+    begin
+      options[:channel].send(options[:printer], message)
+    rescue Errno::EPIPE
+      return
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def check_delegate(method)
+    return ( @delegate && @delegate.respond_to?(method.to_s) )
+  end
+end
+end
+end