corl 0.4.0 → 0.4.1

data/lib/corl/project/github.rb

@@ -1,108 +0,0 @@
-
-corl_require(File.dirname(__FILE__), :git)
-
-#---
-
-module CORL
-module Project
-class Github < Git
- 
-  #-----------------------------------------------------------------------------
-  # Project plugin interface
- 
-  def normalize    
-    if reference = delete(:reference, nil)
-      myself.name = reference
-    else
-      if url = get(:url, nil)
-        myself.name = url
-        set(:url, myself.class.expand_url(url, get(:ssh, false)))
-      end  
-    end    
-    super
-  end
-  
-  #---
-  
-  def set_connection
-    require 'octokit'
-    
-    @client = Octokit::Client.new :netrc => true
-    @client.login
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-  
-  def client
-    set_connection unless @client
-    @client
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Project operations
-  
-  def init_auth
-    super do
-      key_id  = ENV['USER'] + '@' + lookup(:ipaddress)
-      ssh_key = public_key_str
-      
-      if private_key && ssh_key
-        begin
-          deploy_keys = client.deploy_keys(self.name) 
-          github_id   = nil
-          keys_match  = true
-                   
-          deploy_keys.each do |key_resource|
-            if key_resource.title == key_id
-              github_id  = key_resource.id              
-              keys_match = false if key_resource.key != ssh_key
-              break
-            end  
-          end
-          
-          if github_id
-            unless keys_match
-              client.edit_deploy_key(self.name, github_id, { :key => ssh_key })
-              verify_key
-            end
-          else
-            client.add_deploy_key(self.name, key_id, ssh_key)
-            verify_key
-          end
-                  
-        rescue Exception => error
-          logger.error(error.inspect)
-          logger.error(error.message)
-          logger.error(Util::Data.to_yaml(error.backtrace))
-
-          ui.error(error.message, { :prefix => false }) if error.message
-        end
-      end
-    end  
-  end
-     
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.expand_url(path, editable = false)
-    if editable
-      protocol  = 'git@'
-      separator = ':'
-    else
-      protocol  = 'https://'
-      separator = '/'
-    end
-    return "#{protocol}github.com#{separator}" + path + '.git'  
-  end
-  
-  #---
-  
-  def verify_key
-    Util::SSH.init_session('github.com', 'git', 22, private_key)
-    Util::SSH.close('github.com', 'git')
-  end
-  protected :verify_key
-end
-end
-end

data/lib/corl/template/json.rb

@@ -1,16 +0,0 @@
-
-module CORL
-module Template
-class Json < Plugin::Template
-  
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render_processed(data)
-    return super do
-      Util::Data.to_json(data)
-    end
-  end
-end
-end
-end

data/lib/corl/template/wrapper.rb

@@ -1,16 +0,0 @@
-
-module CORL
-module Template
-class Wrapper < Plugin::Template
-  
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render_processed(data)
-    return super do
-      get(:template_prefix, '') + data.to_s + get(:template_suffix, '')
-    end
-  end
-end
-end
-end

data/lib/corl/template/yaml.rb

@@ -1,16 +0,0 @@
-
-module CORL
-module Template
-class Yaml < Plugin::Template
-  
-  #-----------------------------------------------------------------------------
-  # Renderers  
-   
-  def render_processed(data)
-    return super do
-      Util::Data.to_yaml(data)
-    end    
-  end
-end
-end
-end

data/lib/corl/translator/json.rb

@@ -1,27 +0,0 @@
-
-module CORL
-module Translator
-class Json < Plugin::Translator
-   
-  #-----------------------------------------------------------------------------
-  # Translator operations
-   
-  def parse(json_text)
-    return super do |properties|
-      if json_text && ! json_text.empty?
-        properties = Util::Data.parse_json(json_text)
-      end
-      properties
-    end
-  end
-  
-  #---
-  
-  def generate(properties)
-    return super do
-      Util::Data.to_json(properties, get(:pretty, true))
-    end
-  end
-end
-end
-end

data/lib/corl/translator/yaml.rb

@@ -1,27 +0,0 @@
-
-module CORL
-module Translator
-class Yaml < Plugin::Translator
-   
-  #-----------------------------------------------------------------------------
-  # Translator operations
-   
-  def parse(yaml_text)
-    return super do |properties|
-      if yaml_text && ! yaml_text.empty?
-        properties = Util::Data.parse_yaml(yaml_text)
-      end
-      properties
-    end
-  end
-  
-  #---
-  
-  def generate(properties)
-    return super do
-      Util::Data.to_yaml(properties)
-    end
-  end
-end
-end
-end

data/lib/corl_core/codes.rb

@@ -1,107 +0,0 @@
-
-module CORL
-class Codes
-  
-  #-----------------------------------------------------------------------------
-  # Code index
-  
-  @@registry     = {}
-  @@status_index = {}
-  @@next_code    = 0
-  
-  #---
-  
-  def self.registry
-    @@registry
-  end
-  
-  #---
-  
-  def self.index(status_code = nil)
-    if status_code.nil? || ! status_code.integer?
-      @@status_index
-    else
-      status_code = status_code.to_i
-          
-      if @@status_index.has_key?(status_code)
-        @@status_index[status_code]
-      else
-        @@status_index[registry[:unknown_status]]
-      end  
-    end    
-  end
-  
-  #---
-  
-  def self.render_index(status_code = nil)
-    output = "Status index:\n"
-    @@status_index.each do |code, name|
-      name = name.gsub(/_/, ' ').capitalize
-      
-      if ! status_code.nil? && status_code == code
-        output << sprintf(" [ %3i ] - %s\n", code, name)
-      else
-        output << sprintf("   %3i   - %s\n", code, name)
-      end      
-    end
-    output << "\n"
-    output
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Code construction
-  
-  def self.code(name)
-    name = name.to_sym
-    
-    unless registry.has_key?(name)
-      status_code = @@next_code    
-      @@next_code = @@next_code + 1
-    
-      # TODO: Add more information to the index (like a help message)
-      @@registry[name]            = status_code
-      @@status_index[status_code] = name.to_s
-    end
-  end
-  
-  #---
-  
-  def self.codes(*codes)
-    codes.each do |name|
-      code(name)
-    end
-  end
-
-  #-----------------------------------------------------------------------------
-  # Return status codes on demand
-  
-  def [](name)
-    name = name.to_sym
-    
-    if @@registry.has_key?(name)
-      @@registry[name]  
-    else
-      @@registry[:unknown_status]
-    end
-  end
-  
-  #---
- 
-  def method_missing(method, *args, &block)
-    self[method]
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Core status codes
-  
-  code(:success) # This must be added first (needs to be 0)
-  code(:help_wanted)
-  code(:unknown_status)
-  
-  code(:action_unprocessed)
-  code(:batch_error)
-  
-  code(:validation_failed)
-  code(:access_denied) 
-end
-end

data/lib/corl_core/config.rb

@@ -1,337 +0,0 @@
-
-module CORL
-class Config
-  
-  #-----------------------------------------------------------------------------
-  # Global interface
-
-  extend Mixin::ConfigOptions
-  extend Mixin::ConfigCollection
-  extend Mixin::Lookup
-  
-  #-----------------------------------------------------------------------------
-  # Instance generators
-  
-  def self.ensure(config)
-    case config
-    when CORL::Config
-      return config
-    when Hash
-      return new(config) 
-    end
-    return new
-  end
-  
-  #---
-  
-  def self.init(options, contexts = [], hierarchy = [], defaults = {})
-    contexts = contexts(contexts, hierarchy)
-    config   = new(get_options(contexts), defaults)
-    config.import(options) unless Util::Data.empty?(options)
-    return config
-  end
-  
-  #---
-  
-  def self.init_flat(options, contexts = [], defaults = {})
-    return init(options, contexts, [], defaults)
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-   
-  def initialize(data = {}, defaults = {}, force = true)
-    @force      = force
-    @properties = {}
-    
-    if defaults.is_a?(Hash) && ! defaults.empty?
-      defaults = symbol_map(defaults)
-    end
-    
-    case data
-    when CORL::Config
-      @properties = Util::Data.merge([ defaults, data.export ], force)
-    when Hash
-      @properties = {}
-      if data.is_a?(Hash)
-        @properties = Util::Data.merge([ defaults, symbol_map(data) ], force)
-      end  
-    end
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def has_key?(keys)
-    get(keys) ? true : false
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  def keys
-    @properties.keys
-  end
-  
-  #---
-    
-  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
-    
-    if data.has_key?(key)
-      value = data[key]
-      
-      if keys.empty?
-        return filter(value, format)
-      else
-        return fetch(data[key], keys, default, format)  
-      end
-    end
-    return filter(default, format)
-  end
-  protected :fetch
-  
-  #---
-  
-  def modify(data, keys, value = nil) 
-    if keys.is_a?(String) || keys.is_a?(Symbol)
-      keys = [ keys ]
-    end
-        
-    key      = keys.shift.to_sym
-    has_key  = data.has_key?(key)
-    existing = { 
-      :key   => key, 
-      :value => ( has_key ? data[key] : nil ) 
-    }
-    
-    if keys.empty?      
-      existing[:value] = data[key] if has_key
-      
-      if value.nil?
-        data.delete(key) if has_key
-      else
-        data[key] = value
-      end
-    else      
-      data[key] = {} unless has_key
-      existing  = modify(data[key], keys, value)  
-    end
-    
-    return existing
-  end
-  protected :modify
-  
-  #---
-  
-  def get(keys, default = nil, format = false)
-    return fetch(@properties, array(keys).flatten, default, format)
-  end
-
-  #---
- 
-  def [](name, default = nil, format = false)
-    get(name, default, format)
-  end
-  
-  #---
-  
-  def get_array(keys, default = [])
-    return get(keys, default, :array)
-  end
-  
-  #---
-  
-  def get_hash(keys, default = {})
-    return get(keys, default, :hash)
-  end
-  
-  #---
-  
-  def init(keys, default = nil)
-    return set(keys, get(keys, default))
-  end
-
-  #---
-  
-  def set(keys, value)
-    modify(@properties, array(keys).flatten, value)
-    return self
-  end
-  
-  #---
-  
-  def []=(name, value)
-    set(name, value)
-  end
-   
-  #---
-  
-  def delete(keys, default = nil)
-    existing = modify(@properties, array(keys).flatten, nil)
-    return existing[:value] if existing[:value]
-    return default
-  end
-  
-  #---
-  
-  def clear
-    @properties = {}
-    return self
-  end
-
-  #-----------------------------------------------------------------------------
-  # Import / Export
- 
-  def import_base(properties, options = {})
-    config      = Config.new(options, { :force => @force }).set(:context, :hash)    
-    import_type = config.get(:import_type, :override)
-    
-    properties  = properties.export if properties.is_a?(CORL::Config)
-    
-    case properties
-    when Hash
-      data = [ @properties, symbol_map(properties) ]
-      data = data.reverse if import_type != :override
-      
-      @properties = Util::Data.merge(data, config)
-    
-    when String, Symbol
-      properties = self.class.lookup(properties.to_s, {}, config)
-      
-      data = [ @properties, symbol_map(properties) ]
-      data = data.reverse if import_type != :override
-    
-      @properties = Util::Data.merge(data, config)
-     
-    when Array
-      properties.each do |item|
-        import_base(item, config)
-      end
-    end
-    
-    return self
-  end
-  protected :import_base
-  
-  #---
-  
-  def import(properties, options = {})
-    return import_base(properties, options)
-  end
-  
-  #---
-  
-  def defaults(defaults, options = {})
-    config = Config.new(options).set(:import_type, :default)
-    return import_base(defaults, config)
-  end
-
-  #---
-  
-  def export
-    return @properties
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-
-  def self.symbol_map(data)
-    return Util::Data.symbol_map(data)
-  end
-  
-  #---
-  
-  def symbol_map(data)
-    return self.class.symbol_map(data)
-  end
-  
-  #---
-  
-  def self.string_map(data)
-    return Util::Data.string_map(data)
-  end
-  
-  #---
-  
-  def string_map(data)
-    return self.class.string_map(data)
-  end
-  
-  #-----------------------------------------------------------------------------
-      
-  def self.filter(data, method = false)
-    return Util::Data.filter(data, method)
-  end
-  
-  #---
-  
-  def filter(data, method = false)
-    return self.class.filter(data, method)
-  end
-    
-  #-----------------------------------------------------------------------------
-          
-  def self.array(data, default = [], split_string = false)
-    return Util::Data.array(data, default, split_string)
-  end
-  
-  #---
-  
-  def array(data, default = [], split_string = false)
-    return self.class.array(data, default, split_string)
-  end
-    
-  #---
-        
-  def self.hash(data, default = {})
-    data = data.export if data.is_a?(CORL::Config)
-    return Util::Data.hash(data, default)
-  end
-  
-  #---
-  
-  def hash(data, default = {})
-    return self.class.hash(data, default)
-  end
-    
-  #---
-         
-  def self.string(data, default = '')
-    return Util::Data.string(data, default)
-  end
-  
-  #---
-  
-  def string(data, default = '')
-    return self.class.string(data, default)
-  end
-    
-  #---
-         
-  def self.symbol(data, default = :undefined)
-    return Util::Data.symbol(data, default)
-  end
-  
-  #---
-  
-  def symbol(data, default = :undefined)
-    return self.class.symbol(data, default)
-  end
-     
-  #---
-    
-  def self.test(data)
-    return Util::Data.test(data)
-  end
-  
-  #---
-  
-  def test(data)
-    return self.class.test(data)
-  end  
-end
-end