nucleon 0.1.19 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1235f5a25a31be0dc6c8291d2b81a2acf7f53a8
-  data.tar.gz: 12b4bfce18a0dee640ee3192def3394c8ce404fe
+  metadata.gz: 538f4bb7721e53ea65e86fcd9dabe27a3def5f67
+  data.tar.gz: 4fa312d8415f9db8d1b29537c95749358252a598
 SHA512:
-  metadata.gz: 23d165b074de631f79469f11ba947ccead4fd1cfce9b6219edec419db9abf9506167c498044a9bd2e606b2c5c6c08195eb94a6afe47641f29010caf4336ebd81
-  data.tar.gz: 90e7d32a20a4d4fd697733e9c6a5194572836e1281d18f8927935649671438beec83c31d43d4cfdfc566ee4223eee15341a6ee4ecb3f0c399888fc7154db8187
+  metadata.gz: afe85d0df90e8f5114d1d929e9806c01077ea5bbb293c4cef5aa886dc8a678e8a29baf653de081306a1873f9702f0da1d99f7776976b603600b3c4e283b1fb11
+  data.tar.gz: cd73b96970c6fc5ce2e29e1965bccd66b32c26d051f542c707de49bd0f99063bcd0c0f83d56eb7528cb794d5f62d4dfb57e4ec899db76ae8b1a8c936d66eef86

data/Gemfile

@@ -3,6 +3,7 @@ source "http://rubygems.org"
 gem "log4r", "~> 1.1"
 gem "i18n", "~> 0.6"
 gem "netrc", "~> 0.7"
+gem "highline", "~> 1.6"
 
 gem "deep_merge", "~> 1.0"
 gem "multi_json", "~> 1.7"

data/Gemfile.lock

@@ -106,6 +106,7 @@ DEPENDENCIES
   celluloid (~> 0.15)
   childprocess (~> 0.5)
   deep_merge (~> 1.0)
+  highline (~> 1.6)
   i18n (~> 0.6)
   jeweler (~> 2.0)
   log4r (~> 1.1)

data/TODO.rdoc

@@ -1,13 +1,10 @@
 == Nucleon tasks to complete before 1.0 release
 
-* Namespace implementation
-* Meta (composite) actions
 * Execution plans
 * Error handling improvements
 * Full code documentation
 * Full coverage unit tests (starting with core Nucleon unit testing library)
 * Performance improvements
-* Ensure fault tolerance for Actor managers
 * Deeper GitHub API integration in project provider
 * UI console color profiles
 * Localization improvements

data/VERSION

@@ -1 +1 @@
-0.1.19
+0.2.0

data/bin/nucleon

@@ -1,3 +1,22 @@
 #!/usr/bin/env ruby
+
+Signal.trap("INT") { exit 1 }
+
+#---
+
 require 'nucleon'
+
+# Set version info
+
+module Nucleon; module Util; module CLI
+class Parser
+  def version
+    version = Nucleon.VERSION
+    "Nucleon: #{version}  (Apache License, Version 2.0)  --  https://github.com/coralnexus/nucleon/tree/v#{version}"  
+  end
+end
+end; end; end
+
+# Execute
+
 exit(Nucleon.executable(ARGV, :nucleon))

data/lib/core/config.rb

@@ -44,7 +44,7 @@ class Config
     @properties = {}
     
     if defaults.is_a?(Hash) && ! defaults.empty?
-      defaults = symbol_map(defaults)
+      defaults = symbol_map(defaults.clone)
     end
     
     case data
@@ -53,7 +53,7 @@ class Config
     when Hash
       @properties = {}
       if data.is_a?(Hash)
-        @properties = Util::Data.merge([ defaults, symbol_map(data) ], force)
+        @properties = Util::Data.merge([ defaults, symbol_map(data.clone) ], force)
       end  
     end
   end
@@ -83,8 +83,11 @@ class Config
   def fetch(data, keys, default = nil, format = false)
     if keys.is_a?(String) || keys.is_a?(Symbol)
       keys = [ keys ]
-    end    
-    key = keys.shift.to_sym
+    end
+    
+    keys = keys.flatten.compact    
+    key  = keys.shift.to_sym
+    
     if data.has_key?(key)
       value = data[key]
       
@@ -105,6 +108,7 @@ class Config
       keys = [ keys ]
     end
     
+    keys     = keys.flatten.compact
     key      = keys.shift.to_sym
     has_key  = data.has_key?(key)
     existing = { 
@@ -203,7 +207,7 @@ class Config
     
     case properties
     when Hash
-      data = [ @properties, symbol_map(properties) ]
+      data = [ @properties, symbol_map(properties.clone) ]
       data = data.reverse if import_type != :override
       
       @properties = Util::Data.merge(data, config)
@@ -217,7 +221,7 @@ class Config
       @properties = Util::Data.merge(data, config)
      
     when Array
-      properties.each do |item|
+      properties.clone.each do |item|
         import_base(item, config)
       end
     end
@@ -242,7 +246,7 @@ class Config
   #---
   
   def export
-    return @properties
+    return @properties.clone
   end
   
   #-----------------------------------------------------------------------------

data/lib/core/environment.rb

@@ -0,0 +1,338 @@
+
+module Nucleon
+class Environment
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize
+    @plugin_types = {}
+    
+    @load_info    = {}    
+    @active_info  = {}
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Plugin type accessor / modifiers
+  
+  def namespaces
+    @plugin_types.keys
+  end
+  
+  #---
+  
+  def plugin_types(namespace)
+    namespace = namespace.to_sym
+    
+    return [] unless @plugin_types.has_key?(namespace)
+    @plugin_types[namespace].keys
+  end
+  
+  #---
+  
+  def define_plugin_type(namespace, plugin_type, default_provider = nil)
+    namespace = namespace.to_sym
+    
+    @plugin_types[namespace] = {} unless @plugin_types.has_key?(namespace)
+    @plugin_types[namespace][sanitize_id(plugin_type)] = default_provider
+  end
+  
+  #---
+  
+  def define_plugin_types(namespace, type_info)
+    if type_info.is_a?(Hash)
+      type_info.each do |plugin_type, default_provider|
+        define_plugin_type(namespace, plugin_type, default_provider)
+      end
+    end
+  end
+  
+  #---
+  
+  def plugin_type_defined?(namespace, plugin_type)
+    namespace = namespace.to_sym
+    
+    return false unless @plugin_types.has_key?(namespace)
+    @plugin_types[namespace].has_key?(sanitize_id(plugin_type))
+  end
+  
+  #---
+  
+  def plugin_type_default(namespace, plugin_type)
+    namespace = namespace.to_sym
+    
+    return nil unless @plugin_types.has_key?(namespace)
+    @plugin_types[namespace][sanitize_id(plugin_type)]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Loaded plugin accessor / modifiers
+  
+  def define_plugin(namespace, plugin_type, base_path, file, &code)
+    namespace   = namespace.to_sym
+    plugin_type = sanitize_id(plugin_type)
+    
+    @load_info[namespace]              = {} unless @load_info.has_key?(namespace)
+    @load_info[namespace][plugin_type] = {} unless @load_info[namespace].has_key?(plugin_type)
+    
+    plugin_info = parse_plugin_info(namespace, plugin_type, base_path, file)
+    
+    unless @load_info[namespace][plugin_type].has_key?(plugin_info[:provider])
+      data = {
+        :namespace        => namespace,
+        :type             => plugin_type,
+        :file             => file,
+        :provider         => plugin_info[:provider],        
+        :directory        => plugin_info[:directory],        
+        :class_components => plugin_info[:class_components]
+      }
+      code.call(data) if code
+      
+      @load_info[namespace][plugin_type][plugin_info[:provider]] = data
+    end
+  end
+  
+  #---
+  
+  def loaded_plugin(namespace, plugin_type, provider)
+    namespace   = namespace.to_sym
+    plugin_type = sanitize_id(plugin_type)
+    provider    = sanitize_id(provider)
+    info        = nil
+    
+    if @load_info.has_key?(namespace) && 
+      @load_info[namespace].has_key?(plugin_type) && 
+      @load_info[namespace][plugin_type].has_key?(provider) 
+      
+      info = @load_info[namespace][plugin_type][provider]
+    end
+    info
+  end
+  
+  #---
+  
+  def loaded_plugins(namespace = nil, plugin_type = nil, provider = nil, default = {})
+    namespace   = namespace.to_sym if namespace
+    plugin_type = sanitize_id(plugin_type) if plugin_type
+    provider    = sanitize_id(provider) if provider
+    results     = default
+    
+    if namespace && @load_info.has_key?(namespace)
+      if plugin_type && @load_info[namespace].has_key?(plugin_type)
+        if provider && @load_info[namespace][plugin_type].has_key?(provider)
+          results = @load_info[namespace][plugin_type][provider]  
+        elsif ! provider
+          results = @load_info[namespace][plugin_type]
+        end
+      elsif ! plugin_type
+        results = @load_info[namespace]      
+      end
+    elsif ! namespace
+      results = @load_info
+    end
+    results
+  end
+  
+  #---
+  
+  def plugin_has_type?(namespace, plugin_type)
+    namespace = namespace.to_sym
+    
+    return false unless @load_info.has_key?(namespace)
+    @load_info[namespace].has_key?(sanitize_id(plugin_type))
+  end
+  
+  #---
+  
+  def plugin_has_provider?(namespace, plugin_type, provider)
+    namespace   = namespace.to_sym
+    plugin_type = sanitize_id(plugin_type)
+    provider    = sanitize_id(provider)
+    
+    return false unless @load_info.has_key?(namespace) && @load_info[namespace].has_key?(plugin_type)
+    @load_info[namespace][plugin_type].has_key?(provider)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Active plugin accessor / modifiers
+  
+  def create_plugin(namespace, plugin_type, provider, options = {}, &code)
+    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)
+      
+      @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)
+        type_info[:instance_name] = instance_name
+        
+        options = code.call(type_info, options) if code
+        plugin  = type_info[:class].new(namespace, plugin_type, provider, options)
+        
+        @active_info[namespace][plugin_type][instance_name] = plugin 
+      end
+      return @active_info[namespace][plugin_type][instance_name]
+    end  
+    nil  
+  end
+  
+  #---
+  
+  def get_plugin(namespace, plugin_type, plugin_name)
+    namespace   = namespace.to_sym
+    plugin_type = sanitize_id(plugin_type)
+    
+    if @active_info.has_key?(namespace) && @active_info[namespace].has_key?(plugin_type)
+      @active_info[namespace][plugin_type].each do |instance_name, plugin|
+        if plugin.plugin_name.to_s == plugin_name.to_s
+          return plugin
+        end
+      end
+    end
+    nil  
+  end
+  
+  #---
+  
+  def remove_plugin(namespace, plugin_type, instance_name, &code)
+    namespace   = namespace.to_sym
+    plugin_type = sanitize_id(plugin_type)
+    
+    if @active_info.has_key?(namespace) && @active_info[namespace].has_key?(plugin_type)
+      plugin = @active_info[namespace][plugin_type]
+      @active_info[namespace][plugin_type].delete(instance_name)
+      code.call(plugin) if code      
+    end
+  end
+  
+  #---
+  
+  def active_plugins(namespace = nil, plugin_type = nil, provider = nil)
+    namespace   = namespace.to_sym if namespace
+    plugin_type = sanitize_id(plugin_type) if plugin_type
+    provider    = sanitize_id(provider) if provider
+    results     = {}
+    
+    if namespace && @active_info.has_key?(namespace)
+      if plugin_type && @active_info[namespace].has_key?(plugin_type)
+        if provider && ! @active_info[namespace][plugin_type].keys.empty?
+          @active_info[namespace][plugin_type].each do |instance_name, plugin|
+            plugin                 = @active_info[namespace][plugin_type][instance_name]
+            results[instance_name] = plugin if plugin.plugin_provider == provider
+          end
+        elsif ! provider
+          results = @active_info[namespace][plugin_type]
+        end
+      elsif ! plugin_type
+        results = @active_info[namespace]
+      end
+    elsif ! namespace
+      results = @active_info  
+    end    
+    results
+  end 
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def class_name(name, separator = '::', want_array = FALSE)
+    components = []
+    
+    case name
+    when String, Symbol
+      components = name.to_s.split(separator)
+    when Array
+      components = name 
+    end
+    
+    components.collect! do |value|
+      value    = value.to_s.strip      
+      value[0] = value.capitalize[0] if value =~ /^[a-z]/ 
+      value
+    end
+    
+    if want_array
+      return components
+    end    
+    components.join(separator)
+  end
+  
+  #---
+  
+  def class_const(name, separator = '::')
+    components = class_name(name, separator, TRUE)
+    constant   = Object
+    
+    components.each do |component|
+      constant = constant.const_defined?(component) ? 
+                  constant.const_get(component) : 
+                  constant.const_missing(component)
+    end
+    constant
+  end
+  
+  #---
+  
+  def sanitize_id(id_component)
+    id_component.to_s.gsub(/([a-z0-9])(?:\-|\_)?([A-Z])/, '\1_\2').downcase.to_sym
+  end
+  protected :sanitize_id
+  
+  #---
+  
+  def sanitize_class(class_component)
+    class_component.to_s.split('_').collect {|elem| elem.slice(0,1).capitalize + elem.slice(1..-1) }.join('')  
+  end
+  protected :sanitize_class
+  
+  #---
+  
+  def plugin_class(namespace, plugin_type)
+    class_const([ sanitize_class(namespace), :plugin, sanitize_class(plugin_type) ]) 
+  end
+  
+  #---
+  
+  def parse_plugin_info(namespace, plugin_type, base_path, file)
+    dir_components   = base_path.split(File::SEPARATOR)    
+    file_components  = file.split(File::SEPARATOR)  
+    
+    file_name        = file_components.pop.sub(/\.rb/, '')
+    directory        = file_components.join(File::SEPARATOR)
+    
+    file_class       = sanitize_class(file_name)
+    group_components = file_components - dir_components
+    
+    class_components = [ sanitize_class(namespace), sanitize_class(plugin_type) ]
+      
+    if ! group_components.empty? 
+      group_name       = group_components.collect {|elem| elem.downcase  }.join('_')
+      provider         = [ group_name, file_name ].join('_')
+      
+      group_components = group_components.collect {|elem| sanitize_class(elem) }
+      class_components = [ class_components, group_components, file_class ].flatten
+    else
+      provider         = file_name
+      class_components = [ class_components, file_class ].flatten
+    end
+    
+    { 
+      :directory        => directory, 
+      :provider         => sanitize_id(provider), 
+      :class_components => class_components
+    }    
+  end
+  protected :parse_plugin_info
+end
+end