coral_core 0.2.19 → 0.2.21

data/lib/coral_core/repository.rb

@@ -1,164 +0,0 @@
-
-module Coral
-class Repository < Core
-    
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def initialize(options = {})
-    config = Config.ensure(options)
-    
-    super(config)
-    
-    @name       = config.get(:name, '')
-    @directory  = config.get(:directory, '')
-    @submodule  = config.get(:submodule, '')
-    @remote_dir = config.get(:remote_dir, '')
-    
-    ensure_git(true) 
-  end
-    
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  attr_accessor :name, :remote_dir
-  attr_reader :directory, :submodule, :git
-
-  #---
-   
-  def ensure_git(reset = false)
-    if reset || ! @git
-      if @directory.empty?
-        @git = nil
-      else
-        directory = @directory
-        unless Util::Data.empty?(@submodule)
-          directory = File.join(@directory, @submodule) 
-        end
-        @git = Git.open(directory, {
-          :log => logger,
-        })
-      end
-    end
-    return self
-  end
-  
-  #---
-    
-  def set_repository(directory = '', submodule = '')
-    @directory = string(directory)
-    @submodule = string(submodule)
-    ensure_git(true)
-    return self
-  end
-      
-  #-----------------------------------------------------------------------------
-    
-  def set_remote(name, hosts, options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      hosts = array(hosts)
-      
-      delete_remote(name)
-      return self if hosts.empty?
-      
-      if @remote_dir && ! config.get(:repo, false)
-        config[:repo] = @remote_dir
-      end
-      
-      git.add_remote(name, Git.url(hosts.shift, config[:repo], options))
-      
-      if ! hosts.empty?
-        remote = git.remote(name)
-        
-        config[:add] = true
-      
-        hosts.each do |host|
-          git_url = Git.url(host, config[:repo], config.options)
-          remote.set_url(git_url, config.options)
-        end
-      end
-    end
-    return self
-  end
-  
-  #---
-  
-  def delete_remote(name)
-    if can_persist?
-      remote = git.remote(name)
-      if remote && remote.url && ! remote.url.empty?
-        remote.remove
-      end
-    end
-    return self  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Git operations
-  
-  def commit(files = '.', options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      time    = Time.new.strftime("%Y-%m-%d %H:%M:%S")
-      user    = ENV['USER']
-      message = config.get(:message, 'Saving state')
-      
-      config[:author]      = config.get(:author, '')
-      config[:allow_empty] = config.get(:allow_empty, false)
-      
-      unless user && ! user.empty?
-        user = 'UNKNOWN'
-      end
-    
-      array(files).each do |file|
-        git.add(file)                      # Get all added and updated files
-        git.add(file, { :update => true }) # Get all deleted files
-      end
-        
-      git.commit("#{time} by <#{user}> - #{message}", config.options)                
-    end
-    return self      
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def push!(remote = 'origin', options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      branch = config.get(:branch, 'master')
-      tags   = config.get(:tags, false)
-    
-      return Coral::Command.new({
-        :command => :git,
-        :data => { 'git-dir=' => git.repo.to_s },
-        :subcommand => {
-          :command => :push,
-          :flags => ( tags ? :tags : '' ),
-          :args => [ remote, branch ]
-        }
-      }).exec!(config) do |line|
-        block_given? ? yield(line) : true
-      end
-    end
-  end
-  
-  #---
-  
-  def push(remote = 'origin', options = {})
-    return push!(remote, options)
-  end  
-     
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def can_persist?
-    ensure_git
-    return true if @git
-    return false
-  end
-end
-end

data/lib/coral_core/resource.rb

@@ -1,243 +0,0 @@
-
-module Coral
-module Resource
-  
-  #-----------------------------------------------------------------------------
-  # Resource groups
-  
-  @@resource_groups = {}
-  
-  #---
-  
-  def self.groups
-    return @@resource_groups
-  end
-  
-  #---
-  
-  def self.clear_groups
-    @@resource_groups = {}
-  end
-  
-  #---
-  
-  def self.add_members(group_name, resource_names)
-    @@resource_groups[group_name] = [] unless @@resource_groups[group_name].is_a?(Array)
-    
-    unless resource_names.is_a?(Array)
-      resource_names = [ resource_names ]
-    end
-    
-    resource_names.each do |name|
-      unless @@resource_groups[group_name].include?(name)
-        @@resource_groups[group_name] << name
-      end
-    end
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Resource operations
-  
-  def self.normalize(type_name, resources, options)
-    clear_groups
-    
-    config    = Config.ensure(options)
-    resources = Util::Data.value(resources)
-    
-    #dbg(resources, 'normalize -> init')
-    
-    unless Util::Data.empty?(resources)
-      resources.keys.each do |name|
-        #dbg(name, 'normalize -> name')
-        if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)        
-          resources.delete(name)
-        else
-          normalize = true
-          
-          namevar = namevar(type_name, name)
-          if resources[name].has_key?(namevar)
-            value = resources[name][namevar]
-            if Util::Data.empty?(value)
-              #dbg(value, "delete #{name}")
-              resources.delete(name)
-              normalize = false
-              
-            elsif value.is_a?(Array)
-              value.each do |item|
-                item_name = "#{name}_#{item}".gsub(/\-/, '_')
-                
-                new_resource = resources[name].clone
-                new_resource[namevar] = item
-                
-                resources[item_name] = render(new_resource, config)
-                add_members(name, item_name)
-              end
-              resources.delete(name)
-              normalize = false
-            end  
-          end
-          
-          #dbg(resources, 'normalize -> resources')
-          
-          if normalize
-            resources[name] = render(resources[name], config)
-          end
-        end
-      end
-    end
-    return resources
-  end
-  
-  #---
-  
-  def self.render(resource, options = {})
-    resource = Core.string_map(resource.clone)
-    config   = Config.ensure(options)
-    
-    resource.keys.each do |name|
-      if match = name.match(/^(.+)_template$/)
-        target = match.captures[0]
-        
-        #dbg(name, 'name')
-        #dbg(target, 'target')
-        
-        config.set(:normalize_template, config.get("normalize_#{target}", true))
-        config.set(:interpolate_template, config.get("interpolate_#{target}", true))
-        
-        resource[target] = Template.render(resource[name], resource[target], config)
-        resource.delete(name)         
-      end
-    end
-    
-    #dbg(resource, 'render exit')
-    return resource
-  end
-  
-  #---
-  
-  def self.translate(type_name, resources, options = {})
-    config    = Config.ensure(options)
-    resources = Util::Data.value(resources)
-    results   = {}
-        
-    #dbg(resources, 'resources -> translate')
-    
-    prefix = config.get(:resource_prefix, '')
-    
-    name_map = {}
-    resources.keys.each do |name|
-      name_map[name] = true
-    end
-    config[:resource_names] = name_map
-    
-    resources.each do |name, data|
-      #dbg(name, 'name')
-      #dbg(data, 'data')
-      
-      resource = resources[name]
-      resource['before']    = translate_resource_refs(type_name, data['before'], config) if data.has_key?('before')
-      resource['notify']    = translate_resource_refs(type_name, data['notify'], config) if data.has_key?('notify')
-      resource['require']   = translate_resource_refs(type_name, data['require'], config) if data.has_key?('require')       
-      resource['subscribe'] = translate_resource_refs(type_name, data['subscribe'], config) if data.has_key?('subscribe')
-      
-      unless prefix.empty?
-        name = "#{prefix}_#{name}"
-      end
-      results[name] = resource
-    end
-    return results
-  end
-  
-  #---
-  
-  def self.translate_resource_refs(type_name, resource_refs, options = {})
-    return :undef if Util::Data.undef?(resource_refs)
-    
-    config         = Config.ensure(options)
-    resource_names = config.get(:resource_names, {})
-    title_prefix   = config.get(:title_prefix, '')
-    
-    title_pattern  = config.get(:title_pattern, '^\s*([^\[\]]+)\s*$')
-    title_group    = config.get(:title_var_group, 1)
-    title_flags    = config.get(:title_flags, '')
-    title_regexp   = Regexp.new(title_pattern, title_flags.split(''))
-    
-    allow_single   = config.get(:allow_single_return, true)    
-    
-    type_name      = type_name.sub(/^\@?\@/, '')
-    values         = []
-        
-    case resource_refs
-    when String
-      if resource_refs.empty?
-        return :undef 
-      else
-        resource_refs = resource_refs.split(/\s*,\s*/)
-      end
-        
-    when Puppet::Resource
-      resource_refs = [ resource_refs ]  
-    end
-    
-    resource_refs.collect! do |value|
-      if value.is_a?(Puppet::Resource) || ! value.match(title_regexp)
-        value
-          
-      elsif resource_names.has_key?(value)
-        if ! title_prefix.empty?
-          "#{title_prefix}_#{value}"
-        else
-          value
-        end
-        
-      elsif groups.has_key?(value) && ! groups[value].empty?
-        results = []
-        groups[value].each do |resource_name|
-          unless title_prefix.empty?
-            resource_name = "#{title_prefix}_#{resource_name}"
-          end
-          results << resource_name        
-        end
-        results
-        
-      else
-        nil
-      end           
-    end
-    
-    resource_refs.flatten.each do |ref|
-      #dbg(ref, 'reference -> init')
-      unless ref.nil?        
-        unless ref.is_a?(Puppet::Resource)
-          ref = ref.match(title_regexp) ? Puppet::Resource.new(type_name, ref) : Puppet::Resource.new(ref)
-        end
-        #dbg(ref, 'reference -> final')       
-        values << ref unless ref.nil?
-      end
-    end
-    return values[0] if allow_single && values.length == 1
-    return values
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.type_name(value) # Basically borrowed from Puppet (damn private methods!)
-    return :main if value == :main
-    return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
-    return value.to_s.split("::").collect { |s| s.capitalize }.join("::")
-  end
-  
-  #---
-  
-  def self.namevar(type_name, resource_name) # Basically borrowed from Puppet (damn private methods!)
-    resource = Puppet::Resource.new(type_name.sub(/^\@?\@/, ''), resource_name)
-    
-    if resource.builtin_type? and type = resource.resource_type and type.key_attributes.length == 1
-      return type.key_attributes.first.to_s
-    else
-      return 'name'
-    end
-  end
-end
-end

data/lib/coral_core/template/environment.rb

@@ -1,72 +0,0 @@
-
-module Coral
-module Template
-class Environment < Base
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render(input)
-    output = ''
-    
-    case input
-    when Hash
-      input.each do |name, value|
-        output << render_assignment(name, value)
-      end
-    end              
-    return output      
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def render_assignment(name, value)
-    name  = render_name(name)
-    value = render_value(value)
-    
-    export      = get(:export, true)
-    export_text = export ? get(:export_text, 'export ') : ''
-    operator    = get(:operator, '=')
-    
-    return "#{export_text}#{name}#{operator}#{value}\n"  
-  end
-  
-  #---
-  
-  def render_name(name)
-    prefix     = get(:name_prefix, '')
-    prefix_sep = prefix.empty? ? '' : get(:name_prefix_sep, '_')
-    
-    suffix     = get(:name_suffix, '')
-    suffix_sep = suffix.empty? ? '' : get(:name_suffix_sep, '')
-    
-    unless prefix.empty?
-      name = "#{prefix}#{prefix_sep}#{name}#{suffix_sep}#{suffix}"
-    end
-    return name
-  end
-  
-  #---
-  
-  def render_value(value)
-    sep          = get(:value_sep, ' ')
-    quote        = get(:quote, true)
-    
-    array_prefix = get(:array_prefix, '(')
-    array_suffix = get(:array_suffix, ')')
-    
-    case value
-    when Array
-      values = []
-      value.each do |item|
-        values << quote ? "'#{item}'" : "#{item}"  
-      end
-      value = "#{array_prefix}#{values.join(sep)}#{array_suffix}"
-            
-    when String
-      value = quote ? "'#{value}'" : "#{value}" 
-    end
-    return value
-  end
-end
-end
-end

data/lib/coral_core/template/json.rb

@@ -1,13 +0,0 @@
-
-module Coral
-module Template
-class JSON < Base
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render(input)
-    return Util::Data.to_json(input)    
-  end
-end
-end
-end

data/lib/coral_core/template/wrapper.rb

@@ -1,13 +0,0 @@
-
-module Coral
-module Template
-class Wrapper < Base
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render(input)
-    return get(:template_prefix, '') + input.to_s + get(:template_suffix, '')
-  end
-end
-end
-end

data/lib/coral_core/template/yaml.rb

@@ -1,13 +0,0 @@
-
-module Coral
-module Template
-class JSON < Base
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render(input)
-    return Util::Data.to_yaml(input)    
-  end
-end
-end
-end

data/lib/coral_core/template.rb

@@ -1,92 +0,0 @@
-
-module Coral
-module Template
-  
-  #-----------------------------------------------------------------------------
-  # General template utilities
-  
-  def self.instance(class_name, options = {}, defaults = {}, force = true)
-    return Template::const_get(class_name).new(options, defaults, force)
-  end
-  
-  #---
-  
-  def self.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 self.render(class_name, data, options = {})
-    config = Config.ensure(options)
-    
-    normalize   = config.get(:normalize_template, true)
-    interpolate = config.get(:interpolate_template, true)
-    
-    #dbg(class_name, 'template engine name')
-    #dbg(data, 'template data -> init')
-    
-    if normalize
-      data = Config.normalize(data, nil, config)
-      #dbg(data, 'template data -> post normalization')
-    end
-    
-    if normalize && interpolate
-      data = Util::Data.interpolate(data, data, config.options)
-      #dbg(data, 'template data -> post interpolation')
-    end
-    
-    engine = instance(class_name, config, {}, config.get(:force, true))
-    #dbg(engine, 'template engine')
-    
-    output = engine.render(process(data))
-    #dbg(output, 'template output')
-    
-    return output
-  end
-
-  #-----------------------------------------------------------------------------
-  # Base template
-  
-class Base < Config
-  # All template classes should extend Base
-  
-  def intialize(options = {}, defaults = {}, force = true)
-    super(options, defaults, force)
-  end
-  
-  #---
-  
-  def render(input)
-    return ''  # Implement in sub classes!! 
-  end
-end
-end
-end