coral_core 0.2.30 → 0.4.0

data/lib/coral_core.rb

@@ -1,375 +0,0 @@
-
-#*******************************************************************************
-# Coral Core Library
-#
-# This provides core data elements and utilities used in the Coral gems.
-#
-# Author::    Adrian Webb (mailto:adrian.webb@coraltech.net)
-# 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 coral_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 coral_require(base_dir, name)
-    name = name.to_s
-    
-    require File.join(base_dir, "#{name}.rb")  
-    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
-
-#-------------------------------------------------------------------------------
-# Top level properties 
-
-lib_dir      = File.dirname(__FILE__)
-core_dir     = File.join(lib_dir, 'coral_core')
-mixin_dir    = File.join(core_dir, 'mixin')
-macro_dir    = File.join(mixin_dir, 'macro')
-event_dir    = File.join(core_dir, 'event')
-template_dir = File.join(core_dir, 'template')
-util_dir     = File.join(core_dir, 'util')
-mod_dir      = File.join(core_dir, 'mod')
- 
-#-------------------------------------------------------------------------------
-# Coral requirements
-
-git_location = coral_locate('git')
-
-$:.unshift(lib_dir) unless $:.include?(lib_dir) || $:.include?(File.expand_path(lib_dir))
-
-#---
-  
-require 'rubygems'
-
-require 'i18n'
-require 'log4r'
-require 'deep_merge'
-require 'yaml'
-require 'multi_json'
-require 'digest/sha1'
-
-require 'puppet'
-require 'fog'
-
-#---
-
-# TODO: Make this dynamically settable
-
-I18n.load_path << File.expand_path(File.join('..', 'locales', 'en.yml'), lib_dir)
-
-#---
-
-if git_location
-  require 'grit'
-  coral_require(util_dir, :git)
-end
-
-#---
-
-# 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(macro_dir, '*.rb')).each do |file|
-  require file
-end
-
-#---
-
-coral_require(util_dir, :data)
-coral_require(core_dir, :config)
-coral_require(util_dir, :interface) 
-coral_require(core_dir, :core) 
-
-# Include core utilities
-[ :cli, :disk, :process, :shell ].each do |name| 
-  coral_require(util_dir, name)
-end
-
-# Include core systems
-[ :event, :template, :repository, :resource, :plugin_base, :plugin ].each do |name|
-  coral_require(core_dir, name)
-end
-
-#*******************************************************************************
-# Coral Core Library
-#
-# This provides core data elements and utilities used in the Coral gems.
-#
-# Author::    Adrian Webb (mailto:adrian.webb@coraltech.net)
-# License::   GPLv3
-module Coral
-  
-  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
-  
-  #---
-  
-  @@config_file = 'coral.json'
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.ui
-    return Core.ui
-  end
-  
-  #---
-  
-  def self.logger
-    return Core.logger
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.config_file=file_name
-    @@config_file = file_name
-  end
-  
-  #---
-  
-  def self.config_file
-    return @@config_file
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Initialization
-  
-  @@initialized = false
-  
-  def self.initialize
-    unless @@initialized
-      Config.set_property('time', Time.now.to_i)
-      
-      begin
-        # Include Coral plugins
-        Puppet::Node::Environment.new.modules.each do |mod|
-          lib_path = File.join(mod.path, 'lib', 'coral')
-          Plugin.register(lib_path)
-        end
-      rescue
-      end
-      
-      Plugin.initialize
-            
-      @@initialized = true
-    end    
-  end
-  
-  #---
-  
-  def self.initialized?
-    return @@initialized
-  end
-    
-  #-----------------------------------------------------------------------------
-  # Plugins
-  
-  def self.plugin(type, provider, options = {})
-    default_provider = Plugin.type_default(type)
-    
-    if options.is_a?(Hash) || options.is_a?(Coral::Config)
-      config   = Config.ensure(options)
-      provider = config.get(:provider, provider)
-      name     = config.get(:name, ( provider ? provider : default_provider ))
-      options  = config.export
-    end
-    provider          = default_provider unless provider # Sanity checking (see plugins)
-    existing_instance = Plugin.get_instance(type, name) if name
-    
-    return existing_instance if existing_instance
-    return Plugin.create_instance(type, provider, options)
-  end
-  
-  #---
-  
-  def self.plugins(type, data, build_hash = false, keep_array = false)
-    group = ( build_hash ? {} : [] )
-    klass = class_const([ :coral, :plugin, type ])    
-    data  = klass.build_info(type, data) if klass.respond_to?(:build_info)
-    
-    data.each do |options|
-      if plugin = plugin(type, options[:provider], options)
-        if build_hash
-          group[plugin.name] = plugin
-        else
-          group << plugin
-        end
-      end
-    end
-    return group.shift if ! build_hash && group.length == 1 && ! keep_array
-    return group  
-  end
-  
-  #---
-  
-  def self.get_plugin(type, name)
-    return Plugin.get_instance(type, name)
-  end
-  
-  #---
-  
-  def self.remove_plugin(plugin)
-    return Plugin.remove_instance(plugin)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Core plugin type facade
-   
-  def self.network(name, options = {}, provider = nil)
-    plugin      = plugin(:network, provider, options)
-    plugin.name = name
-    return plugin
-  end
-  
-  #---
-  
-  def self.networks(data, build_hash = false, keep_array = false)
-    return plugins(:network, data, build_hash, keep_array)
-  end
-   
-  #---
-  
-  def self.node(name, options = {}, provider = nil)
-    plugin      = plugin(:node, provider, options)
-    plugin.name = name
-    return plugin
-  end
-  
-  #---
-  
-  def self.nodes(data, build_hash = false, keep_array = false)
-    return plugins(:node, data, build_hash, keep_array)
-  end
-   
-  #---
-  
-  def self.machine(options = {}, provider = nil)
-    plugin = plugin(:machine, provider, options)
-    return plugin
-  end
-  
-  #---
-  
-  def self.machines(data, build_hash = false, keep_array = false)
-    return plugins(:machine, data, build_hash, keep_array)
-  end
-  
-  #---
-  
-  def self.command(options, provider = nil)
-    return plugin(:command, provider, options)
-  end
-  
-  #---
-  
-  def self.commands(data, build_hash = false, keep_array = false)
-    return plugins(:command, data, build_hash, keep_array)
-  end
-     
-  #-----------------------------------------------------------------------------
-  # External execution
-   
-  def self.run
-    begin
-      initialize
-      yield
-      
-    rescue Exception => error
-      ui.warn(error.inspect)
-      ui.warn(Util::Data.to_yaml(error.backtrace))
-      raise
-    end
-  end
-    
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.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.to_s.strip.capitalize  
-    end
-    
-    if want_array
-      return components
-    end    
-    return components.join(separator)
-  end
-  
-  #---
-  
-  def self.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
-    
-    return constant
-  end
-  
-  #---
-  
-  def self.sha1(data)
-    return Digest::SHA1.hexdigest(Util::Data.to_json(data, false))
-  end  
-end
-
-#-------------------------------------------------------------------------------
-# Coral initialization
-
-Coral.initialize

data/locales/en.yml

@@ -1,8 +0,0 @@
-en:
-  coral:
-    core:
-      util:
-        cli:
-          options:
-            help: |-
-              Display help information for this command

data/spec/coral_core/interface_spec.rb

@@ -1,489 +0,0 @@
-
-require 'spec_helper'
-
-module Coral
-
-  describe Util::Interface do
-
-    #---------------------------------------------------------------------------
-    # UI functionality
-    
-    describe "#say" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).say(:info, 'message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Output formats
-
-      it "prints a message with default options" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ :output => output1 }).say(:info, 'message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('[component] message')
-        
-        Util::Interface.new({
-          :resource => 'component', 
-          :output   => output2, 
-        }).say(:info, 'message')      
-      end
-      
-      #---
-      
-      it "prints a message with and without newlines included" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Interface.new({ :output => output1 })
-        test.say(:info, 'message', { :new_line => true })
-        
-        output2 = double('output2')
-        output2.should_receive(:print).with('message')
-        
-        test = Util::Interface.new({ :output => output2 })
-        test.say(:info, 'message', { :new_line => false })      
-      end
-      
-      #---
-      
-      it "routes message to output and error channels based on type given" do       
-        [:info, :warn, :success].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message')
-        
-          Util::Interface.new({
-            :output  => output,
-            :printer => :puts,
-            :color   => false,
-          }).say(type, 'message')
-        end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        }).say(:error, 'message')   
-      end
-      
-      #---
-      
-      it "routes message to output and error channels based on channel given" do
-        [:info, :warn, :success].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message')
-        
-          Util::Interface.new({
-            :output  => output,
-            :printer => :puts,
-          }).say(:info, 'message', { :channel => type })        
-        end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        }).say(:info, 'message', { :channel => :error })
-      end  
-    end
-    
-    #---
-    
-    describe "#ask" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method"
-      
-      #-------------------------------------------------------------------------
-      # Input
-      
-      it "displays a prompt and returns user feedback"
-    end
-    
-    #---
-    
-    describe "#info" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).info('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored information message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts, 
-        }).info('message')
-      end    
-    end
-    
-    #---
-    
-    describe "#warn" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).warn('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored warning message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).warn('message')
-      end
-      
-      #---
-      
-      it "prints a colored warning message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[33mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :output => output,
-          :color  => true, 
-        }).warn('message', { :new_line => false })
-      end    
-    end
-    
-    #---
-    
-    describe "#error" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        error  = double('error')
-        error.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).error('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored error message" do
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :error   => error,
-          :printer => :puts,
-          :color   => false, 
-        }).error('message')
-      end
-      
-      #---
-      
-      it "prints a colored error message" do
-        error = double('error')
-        error.should_receive(:print).with(/^\e\[31mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :error => error,
-          :color => true, 
-        }).error('message', { :new_line => false })
-      end 
-    end
-    
-    #---
-    
-    describe "#success" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).success('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "prints an uncolored success message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).success('message')
-      end
-      
-      #---
-      
-      it "prints a colored success message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[32mmessage\e\[0m$/)
-        
-        Util::Interface.new({ 
-          :output => output,
-          :color  => true, 
-        }).success('message', { :new_line => false })
-      end  
-    end
-  
-    #---------------------------------------------------------------------------
-    # Utilities
-    
-    describe "#format_message" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        message = Util::Interface.new({ 
-          :ui_delegate => Util::Interface.new('delegate')
-        }).format_message(:info, 'message', { :prefix => true })
-        
-        message.should == '[delegate] message'
-      end
-    
-      #-------------------------------------------------------------------------
-      # Prefix specifications
-      
-      it "returns without a prefix because no resource" do
-        message = Util::Interface.new.format_message(:info, 'message', { :prefix => true })
-        message.should == 'message'
-      end
-      
-      #---
-      
-      it "returns without a prefix because prefix is false" do
-        message = Util::Interface.new('component').format_message(:info, 'message', { :prefix => false })
-        message.should == 'message'
-      end
-      
-      #---
-            
-      it "returns without a prefix because no prefix option given" do
-        message = Util::Interface.new('component').format_message(:info, 'message')
-        message.should == 'message'
-      end
-      
-      #---
-            
-      it "returns with a prefix if resource and prefix option given" do
-        message = Util::Interface.new('component').format_message(:info, 'message', { :prefix => true })
-        message.should == '[component] message'
-      end
-      
-      #-------------------------------------------------------------------------
-      # Color specifications
-      
-      it "formats a error message in red if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:error, 'message')
-        message.should match(/^\e\[31mmessage\e\[0m$/)
-      end
-      
-      #---
-      
-      it "formats a warning message in yellow if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:warn, 'message')
-        message.should match(/^\e\[33mmessage\e\[0m$/)
-      end
-      
-      #---
-      
-      it "formats a success message in green if color enabled" do
-        message = Util::Interface.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:success, 'message')
-        message.should match(/^\e\[32mmessage\e\[0m$/)
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    
-    describe "#safe_puts" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Interface.new({ :ui_delegate => ui }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Instance configuration
-      
-      it "prints an empty string unless message given" do
-        output  = double('output')
-        output.should_receive(:puts).with('')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts()
-      end
-      
-      #---
-      
-      it "prints to different output channels if they are given" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Interface.new({
-          :output  => output1,
-          :printer => :puts,
-        })
-        test.safe_puts('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        test.output = output2
-        test.safe_puts('message')
-      end
-      
-      #---
-      
-      it "prints with puts if puts printer option given" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message')
-      end
-      
-      #---
-      
-      it "prints with print if print printer option given" do
-        output = double('output')
-        output.should_receive(:print).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :print,
-        }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Method configuration
-      
-      it "can override the instance output channel" do
-        output1 = double('output1')
-        output1.should_not_receive(:puts).with('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        Util::Interface.new({
-          :output  => output1,
-          :printer => :puts,
-        }).safe_puts('message', { :channel => output2 })  
-      end
-      
-      #---
-      
-      it "can override the instance printer handler" do
-        output = double('output')
-        output.should_not_receive(:puts).with('message')
-        output.should_receive(:print).with('message')
-        
-        Util::Interface.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message', { :printer => :print })
-      end
-    end
-    
-    #---------------------------------------------------------------------------
-    
-    describe "#check_delegate" do
-      
-      it "returns false if no delegate exists" do
-        Util::Interface.new.check_delegate('safe_puts').should be_false
-      end
-      it "returns true if a delegate exists and it implements given method" do
-        test = Util::Interface.new({ :ui_delegate => Util::Interface.new })
-        test.check_delegate('safe_puts').should be_true
-        test.check_delegate('nonexistent').should be_false
-      end
-    end  
-  end
-end