corl 0.4.0 → 0.4.1

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

@@ -1,58 +0,0 @@
-
-module CORL
-module Mixin
-module Action
-module Commit
-        
-  #-----------------------------------------------------------------------------
-  # Options
-        
-  def commit_options(parser, optional = true)
-    if optional
-      parser.option_bool(:commit, false, 
-        '--commit', 
-        'corl.core.mixins.commit.options.commit'
-      )
-    else
-      parser.options[:commit] = true
-    end
-         
-    parser.option_bool(:allow_empty, false,
-      '--empty', 
-      'corl.core.mixins.commit.options.empty'
-    )
-    parser.option_bool(:propogate, false,
-      '--propogate', 
-      'corl.core.mixins.commit.options.propogate'
-    )          
-    parser.option_str(:message, '',
-      '--message COMMIT_MESSAGE',  
-      'corl.core.mixins.commit.options.message'
-    )
-    parser.option_str(:author, nil,
-      '--author COMMIT_AUTHOR',  
-      'corl.core.mixins.commit.options.author'
-    )         
-  end
-        
-  #-----------------------------------------------------------------------------
-  # Operations
-        
-  def commit(project, files = '.')
-    success = true
-          
-    if project && settings[:commit]
-      success = project.commit(files, extended_config(:commit, {
-        :allow_empty => settings[:allow_empty],
-        :message     => settings[:message],
-        :author      => settings[:author],
-        :propogate   => settings[:propogate]
-      }))
-    end
-    success
-  end
-end
-end
-end
-end
-

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

@@ -1,53 +0,0 @@
-
-module CORL
-module Mixin
-module Action
-module Project
-        
-  #-----------------------------------------------------------------------------
-  # Options
-        
-  def project_options(parser, ref_override = false, rev_override = false)
-    parser.option_str(:project_provider, 'git', 
-      '--proj-provider PROVIDER', 
-      'corl.core.mixins.project.options.provider'
-    )
-    if ref_override
-      parser.option_str(:reference, nil,
-        '--reference PROJECT_REF', 
-        'corl.core.mixins.project.options.reference'
-      )
-    end
-    if rev_override
-      parser.option_str(:revision, nil,
-        '--revision PROJECT_REV',  
-        'corl.core.mixins.project.options.revision'
-      )
-    end
-  end
-        
-  #-----------------------------------------------------------------------------
-  # Operations
-        
-  def project_load(root_dir, update = false)
-        
-    # 1. Set a default project provider (reference can override)
-    # 2. Get project from root directory
-    # 3. Initialize project if not yet initialized
-    # 4. Set remote if needed
-    # 5. Checkout revision if needed
-    # 6. Pull down updates if requested
-          
-    return CORL.project(extended_config(:project, {
-      :provider  => settings[:project_provider],
-      :directory => root_dir,
-      :url       => settings[:reference],
-      :revision  => settings[:revision],
-      :pull      => update
-    }))
-  end       
-end
-end
-end
-end
-

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

@@ -1,52 +0,0 @@
-
-module CORL
-module Mixin
-module Action
-module Push
-        
-  #-----------------------------------------------------------------------------
-  # Options
-        
-  def push_options(parser, optional = true)
-    if optional
-      parser.option_bool(:push, false, 
-        '--push', 
-        'corl.core.mixins.push.options.push'
-      )
-    else
-      parser.options[:push] = true
-    end
-          
-    parser.option_bool(:propogate, false,
-      '--propogate', 
-      'corl.core.mixins.push.options.propogate'
-    )          
-    parser.option_str(:remote, :edit,
-      '--remote PROJECT_REMOTE',  
-      'corl.core.mixins.push.options.remote'
-    )
-    parser.option_str(:revision, :master,
-      '--revision PROJECT_REVISION',  
-      'corl.core.mixins.push.options.revision'
-    )         
-  end
-        
-  #-----------------------------------------------------------------------------
-  # Operations
-        
-  def push(project, remote = :edit)
-    success = true
-          
-    if project && settings[:push]
-      success = project.push(settings[:remote], extended_config(:push, {
-        :revision  => settings[:revision],
-        :propogate => settings[:propogate]
-      }))
-    end
-    success
-  end
-end
-end
-end
-end
-

data/lib/corl_core/mixin/config/collection.rb

@@ -1,53 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::ConfigCollection
-#
-
-module CORL
-module Mixin
-module ConfigCollection
-
-  #-----------------------------------------------------------------------------
-  # Configuration collection interface
-  
-  def all_properties
-    return Config::Collection.all
-  end
-  
-  #---
-  
-  def get_property(name)
-    return Config::Collection.get(name)
-  end
-  
-  #---
-  
-  def set_property(name, value)
-    Config::Collection.set(name, value)
-    return self  
-  end
-  
-  #---
-  
-  def delete_property(name)
-    Config::Collection.delete(name)
-    return self
-  end
-  
-  #---
-  
-  def clear_properties
-    Config::Collection.clear
-    return self  
-  end
-  
-  #---
-  
-  def save_properties
-    Config::Collection.save
-    return self
-  end
-end
-end
-end

data/lib/corl_core/mixin/config/ops.rb

@@ -1,53 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::ConfigOps
-#
-
-module CORL
-module Mixin
-module ConfigOps
-
-  #-----------------------------------------------------------------------------
-  # Parsing
-      
-  def parse(statement, options = {})
-    config = Config.ensure(options)
-    
-    # statement =  common->php::apache::memory_limit = 32M
-    # statement =  identity -> test -> users::user[admin][shell]
-    # statement =  nodes->development->dev.loc->facts[server_location]
-    # statement =  corl->nodes[vagrant][dev.loc][vm][private_network]=172.5.5.10
-    # statement =  corl->settings[debug][puppet][options] = ["--debug"]
-    
-    reference, new_value = statement.split(/\=/)
-    new_value            = new_value.join('=').strip if new_value && new_value.is_a?(Array)
-    
-    config_elements = reference.gsub(/\s+/, '').split(/\-\>/)
-    property        = config_elements.pop
-    config_file     = config_elements.pop
-    
-    if config_directory = config.get(:directory, nil)
-      config_path = File.join(project.directory, config_directory, *config_elements)
-    else
-      config_path = File.join(project.directory, *config_elements)
-    end
-    
-    return nil unless property && config_file
-    
-    config_file = "#{config_file}." + config.get(:ext, 'json')
-    property    = property.gsub(/\]$/, '').split(/\]?\[/)
-    data        = open(config_path, config_file, config)
-       
-    return { 
-      :path          => config_path, 
-      :file          => config_file, 
-      :property      => property,
-      :conf          => data,
-      :current_value => (data ? data.get(property) : nil), 
-      :new_value     => eval(new_value) 
-    }    
-  end
-end
-end
-end

data/lib/corl_core/mixin/config/options.rb

@@ -1,39 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::ConfigOptions
-#
-
-module CORL
-module Mixin
-module ConfigOptions
-  
-  #-----------------------------------------------------------------------------
-  # Configuration options interface
-  
-  def contexts(contexts = [], hierarchy = [])
-    return Config::Options.contexts(contexts, hierarchy)  
-  end
-  
-  #---
-  
-  def get_options(contexts, force = true)
-    return Config::Options.get(contexts, force)  
-  end
-  
-  #---
-  
-  def set_options(contexts, options, force = true)
-    Config::Options.set(contexts, options, force)
-    return self  
-  end
-  
-  #---
-  
-  def clear_options(contexts)
-    Config::Options.clear(contexts)
-    return self  
-  end
-end
-end
-end

data/lib/corl_core/mixin/macro/object_interface.rb

@@ -1,361 +0,0 @@
-
-# Should be included via extend
-#
-# extend Mixin::Macro::ObjectInterface
-#
-
-module CORL
-module Mixin
-module Macro
-module ObjectInterface
-  
-  # requires Mixin::SubConfig
-  # requires Mixin::Settings
-
-  #-----------------------------------------------------------------------------
-  # Object collections
-  
-  @@object_types = {}
-
-  #---
-  
-  def object_collection(_type, _method_options = {})
-    _method_config = Config.ensure(_method_options)
-    
-    _plural      = _method_config.init(:plural, "#{_type}s").get(:plural)
-    
-    unless _ensure_proc = _method_config.get(:ensure_proc, false)
-      _ensure_proc = Proc.new {|name, options = {}| options }
-    end
-    _delete_proc = _method_config.get(:delete_proc)
-    _search_proc = _method_config.get(:search_proc)
-    
-    @@object_types[_type] = _method_config
-    
-    logger.debug("Creating new object collection #{_type} with: #{_method_config.inspect}")
-    
-    #---------------------------------------------------------------------------
-    
-    object_utilities
-     
-    #---------------------------------------------------------------------------
-    
-    logger.debug("Defining object interface method: #{_type}_config")
-    
-    define_method "#{_type}_config" do |name = nil|
-      Config.new( name ? get([ _plural, name ], {}) : get(_plural, {}) )
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: #{_type}_setting")
-    
-    define_method "#{_type}_setting" do |name, property, default = nil, format = false|
-      get([ _plural, name, property ], default, format)
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: #{_plural}")
-    
-    define_method "#{_plural}" do |reset = false|
-      send("init_#{_plural}") if reset || _get(_plural, {}).empty?
-      _get(_plural, {})
-    end
-    
-    #---
-    
-    logger.debug("Defining object interface method: init_#{_plural}")
-  
-    define_method "init_#{_plural}" do
-      data = hash(_search_proc.call) if _search_proc
-      data = get_hash(_plural) unless data
-      
-      logger.debug("Initializing object data: #{data.inspect}")
-      
-      symbol_map(data).each do |name, options|
-        if name != :settings
-          options[:object_container] = myself
-          
-          logger.debug("Initializing object: #{name}")
-          
-          obj = _ensure_proc.call(name, options)
-          _set([ _plural, name ], obj)
-        end
-      end
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: set_#{_plural}")
-
-    define_method "set_#{_plural}" do |data = {}|
-      data = Config.ensure(data).export
-    
-      send("clear_#{_plural}")
-      set(_plural, data)
-      
-      logger.debug("Setting #{_plural}")
-    
-      data.each do |name, options|
-        options[:object_container] = myself
-        
-        logger.debug("Setting #{_type} #{name}: #{options.inspect}")
-        
-        obj = _ensure_proc.call(name, options)
-        _set([ _plural, name ], obj)
-      end
-    end
-
-    #---
-    
-    logger.debug("Defining object interface method: #{_type}")
-    
-    define_method "#{_type}" do |name, reset = false|
-      if reset || _get([ _plural, name ], nil).nil?        
-        options = get([ _plural, name ], nil)
-         
-        unless options.nil?
-          options[:object_container] = myself
-          
-          logger.debug("Initializing object: #{name}")
-          
-          obj = _ensure_proc.call(name, options)
-          _set([ _plural, name ], obj)
-        end
-      end
-      _get([ _plural, name ])
-    end
-    
-    #---
-    
-    logger.debug("Defining object interface method: set_#{_type}")
-
-    define_method "set_#{_type}" do |name, options = {}|
-      options = Config.ensure(options).export
-      
-      set([ _plural, name ], options)
-    
-      options[:object_container] = myself
-      
-      logger.debug("Setting #{_type} #{_name}: #{options.inspect}")
-      
-      obj = _ensure_proc.call(name, options) 
-      _set([ _plural, name ], obj)
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: set_#{_type}_setting")
-  
-    define_method "set_#{_type}_setting" do |name, property, value = nil|
-      logger.debug("Setting #{name} property #{property} to #{value.inspect}")
-      set([ _plural, name, property ], value)
-    end
-    
-    #---
-    
-    logger.debug("Defining object interface method: delete_#{_type}")
-
-    define_method "delete_#{_type}" do |name|
-      obj = send(_type, name)
-      
-      logger.debug("Deleting #{_type} #{name}")
-    
-      delete([ _plural, name ])
-      _delete([ _plural, name ])
-    
-      _delete_proc.call(obj) if _delete_proc && ! obj.nil?
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: delete_#{_type}_setting")
-  
-    define_method "delete_#{_type}_setting" do |name, property|
-      logger.debug("Deleting #{name} property: #{property}")
-      
-      delete([ _plural, name, property ])
-    end
-  
-    #---
-    
-    logger.debug("Defining object interface method: clear_#{_plural}")
-  
-    define_method "clear_#{_plural}" do
-      get(_plural).keys.each do |name|
-        logger.debug("Clearing #{_type} #{name}")
-        
-        send("delete_#{_type}", name)
-      end
-    end    
-        
-    #---------------------------------------------------------------------------
-    
-    logger.debug("Defining object interface method: search_#{_type}")
-  
-    define_method "search_#{_type}" do |name, keys, default = '', format = false|
-      obj_config = send("#{_type}_config", name)
-      search_object(obj_config, keys, default, format)
-    end
-  end
-
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def object_utilities
-    
-    unless respond_to? :each_object_type
-      logger.debug("Defining object utility method: each_object_type")
-      
-      define_method :each_object_type do |object_types = nil, filter_proc = nil, &code|
-        object_types = @@object_types.keys unless object_types
-        object_types = [ object_types ] unless object_types.is_a?(Array)
-      
-        object_types.each do |type|
-          logger.debug("Processing object type: #{type}")
-          
-          unless filter_proc && ! filter_proc.call(type, @@object_types[type])
-            plural = @@object_types[type][:plural]
-            
-            logger.debug("Passing: #{@@object_types[type].inspect}")
-            code.call(type, plural, @@object_types[type])
-          end
-        end  
-      end
-    end
-    
-    #---
-    
-    unless respond_to? :each_object
-      logger.debug("Defining object utility method: each_object")
-      
-      define_method :each_object do |object_types = nil, &code|
-        each_object_type(object_types) do |type, plural, options|
-          logger.debug("Processing object type #{type}/#{plural} with: #{options.inspect}")
-          
-          send(plural).each do |name, obj|
-            logger.debug("Processing object: #{name}")
-            code.call(type, name, obj)  
-          end 
-        end  
-      end
-    end
-           
-    #---
-    
-    unless respond_to? :init_objects
-      logger.debug("Defining object utility method: init_objects")
-      
-      define_method :init_objects do |object_types = nil, filter_proc = nil|
-        logger.debug("Initializing object collection")
-        
-        each_object_type(object_types, filter_proc) do |type, plural, options|
-          send("init_#{plural}")  
-        end   
-      end
-    end
-    
-    #---
-    
-    unless respond_to? :clear_objects
-      logger.debug("Defining object utility method: clear_objects")
-      
-      define_method :clear_objects do |object_types = nil, filter_proc = nil|
-        logger.debug("Clearing object collection")
-        
-        each_object_type(object_types, filter_proc) do |type, plural, options|
-          send("clear_#{plural}")  
-        end
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-  
-    unless respond_to? :search_object
-      logger.debug("Defining object utility method: search_object")
-        
-      define_method :search_object do |obj_config, keys, default = '', format = false|
-        obj_config = Marshal.load(Marshal.dump(obj_config))
-        value      = obj_config.get(keys)
-        
-        logger.debug("Searching object properties: #{obj_config.inspect}")
-        
-        if ! value || value.is_a?(Hash)
-          settings = {}
-    
-          keys = [ keys ] unless keys.is_a?(Array)
-          temp = keys.dup
-          
-          logger.debug("Searching object keys: #{keys.inspect}")
-          
-          logger.debug("Searching specialized settings")      
-          until temp.empty? do
-            if obj_settings = obj_config.delete([ temp, :settings ])
-              array(obj_settings).each do |group_name|
-                if group_settings = Marshal.load(Marshal.dump(settings(group_name)))
-                  settings = Util::Data.merge([ group_settings.dup, settings ], true)  
-                end
-              end            
-            end
-            temp.pop
-          end
-    
-          logger.debug("Specialized settings found: #{settings.inspect}") 
-          logger.debug("Searching general settings") 
-      
-          if obj_settings = obj_config.delete(:settings)
-            array(obj_settings).each do |group_name|
-              if group_settings = Marshal.load(Marshal.dump(settings(group_name)))
-                settings = Util::Data.merge([ group_settings, settings ], true)  
-              end
-            end            
-          end 
-          
-          logger.debug("Final settings found: #{settings.inspect}")  
-        
-          unless settings.empty?
-            final_config = Config.new(Util::Data.merge([ settings, obj_config.export ], true))
-            value        = final_config.get(keys)
-            
-            logger.debug("Final configuration: #{final_config.export.inspect}")
-          end
-          
-          value = default if Util::Data.undef?(value)
-        end
-        
-        logger.debug("Final value found (format: #{format.inspect}): #{value.inspect}")
-        filter(value, format)
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    # Configuration loading saving
-    
-    unless respond_to? :load
-      logger.debug("Defining object utility method: load")
-      
-      define_method :load do |options = {}|
-        logger.debug("Loading configuration if possible") 
-        if config.respond_to?(:load)
-          clear_objects  
-          config.load(options)
-        end
-      end
-    end
-    
-    #---
-    
-    unless respond_to? :save
-      logger.debug("Defining object utility method: save")
-      
-      define_method :save do |options = {}|
-        logger.debug("Saving configuration if possible") 
-        config.save(options) if config.respond_to?(:save)
-      end
-    end    
-  end
-end
-end
-end
-end