coral_core 0.2.30 → 0.4.0

data/lib/coral_core/config/options.rb

@@ -1,70 +0,0 @@
-
-module Coral
-class Config
-class Options
-  
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  @@options = {}
-  
-  #---
-  
-  def self.contexts(contexts = [], hierarchy = [])
-    contexts = [ 'all', contexts ].flatten
-    
-    unless hierarchy.is_a?(Array)
-      hierarchy = ( ! Util::Data.empty?(hierarchy) ? [ hierarchy ].flatten : [] )
-    end
-    
-    hierarchy.each do |group|  
-      group_contexts = Util::Data.prefix(group, contexts)
-      contexts       = [ contexts, group_contexts ].flatten
-    end
-    
-    return contexts
-  end
-  
-  #---
-  
-  def self.get(contexts, force = true)
-    options = {}
-    
-    unless contexts.is_a?(Array)
-      contexts = ( ! Util::Data.empty?(contexts) ? [ contexts ].flatten : [] )
-    end
-    contexts.each do |name|
-      name = name.to_sym
-      if @@options.has_key?(name)
-        options = Util::Data.merge([ options, @@options[name] ], force)
-      end
-    end
-    return options
-  end
-  
-  #---
-  
-  def self.set(contexts, options, force = true)
-    unless contexts.is_a?(Array)
-      contexts = ( ! Util::Data.empty?(contexts) ? [ contexts ].flatten : [] )
-    end
-    contexts.each do |name|
-      name = name.to_sym    
-      current_options = ( @@options.has_key?(name) ? @@options[name] : {} )
-      @@options[name] = Util::Data.merge([ current_options, Config.symbol_map(options) ], force)
-    end  
-  end
-  
-  #---
-  
-  def self.clear(contexts)
-    unless contexts.is_a?(Array)
-      contexts = [ contexts ]
-    end
-    contexts.each do |name|
-      @@options.delete(name.to_sym)
-    end
-  end
-end
-end
-end

data/lib/coral_core/config/project.rb

@@ -1,225 +0,0 @@
-
-module Coral
-class Config
-class Project < Config
-  
-  include Mixin::SubConfig
-
-  #-----------------------------------------------------------------------------
-  
-  def initialize(data = {}, defaults = {}, force = true)
-    super(data, defaults, force)
-    
-    init_subconfig(true)
-    
-    unless _get(:project)
-      _set(:project, Repository.open(_delete(:directory, Dir.pwd), {
-        :origin    => _delete(:origin),
-        :revision  => _delete(:revision)
-      }))
-    end
-    
-    _init(:autoload, true)
-    _init(:autosave, true)
-    _init(:autocommit, true)
-    _init(:commit_message, 'Saving state')
-    
-    self.config_file = _get(:config_file, '')
-  end
-  
-  #---
-  
-  def self.finalize(file_name)
-    proc do
-      Util::Disk.close(file_name)
-    end
-  end
-  
-  #---
-  
-  #def inspect
-  #  "#<#{self.class}: #{@absolute_config_file}>"
-  #end
-     
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def can_persist?
-    success = project.can_persist?
-    success = false if Util::Data.empty?(@absolute_config_file)
-    return success
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  def autoload(default = false)
-    return _get(:autoload, default)
-  end
-  
-  #---
-  
-  def autoload=autoload
-    _set(:autoload, test(autoload))
-  end
-   
-  #---
-  
-  def autosave(default = false)
-    return _get(:autosave, default)
-  end
-  
-  #---
-  
-  def autosave=autosave
-    _set(:autosave, test(autosave))
-  end
-   
-  #---
-  
-  def autocommit(default = false)
-    return _get(:autocommit, default)
-  end
-  
-  #---
-  
-  def autocommit=autocommit
-    _set(:autocommit, test(autocommit))
-  end
-   
-  #---
-  
-  def commit_message(default = false)
-    return _get(:commit_message, default)
-  end
-  
-  #---
-  
-  def commit_message=commit_message
-    _set(:commit_message, string(commit_message))
-  end
-  
-  #---
-  
-  def project(default = nil)
-    return _get(:project, default)
-  end
-  
-  #---
-  
-  def config_file(default = nil)
-    return _get(:config_file, default)
-  end
-  
-  #---
-  
-  def config_file=file
-    unless Util::Data.empty?(file)
-      _set(:config_file, Util::Disk.filename(file))
-    end    
-    set_absolute_config_file
-  end
-
-  #---
- 
-  def set_absolute_config_file
-    if Util::Data.empty?(project.directory) || Util::Data.empty?(config_file)
-      @absolute_config_file = ''
-    else 
-      @absolute_config_file = File.join(project.directory, config_file)
-      ObjectSpace.define_finalizer(self, self.class.finalize(@absolute_config_file))
-    end
-    load if autoload
-    return self
-  end
-  protected :set_absolute_config_file
-  
-  #---
-  
-  def set_location(directory)
-    if directory && directory.is_a?(Coral::Repository)
-      project.set_location(directory.directory)
-    elsif directory && directory.is_a?(String) || directory.is_a?(Symbol)
-      project.set_location(directory.to_s)
-    end
-    set_absolute_config_file if directory
-  end
-  
-  #-----------------------------------------------------------------------------
-    
-  def set(keys, value = '', options = {})
-    super(keys, value)
-    save(options) if autosave
-    return self
-  end
-   
-  #---
-   
-  def delete(keys, options = {})
-    super(keys)
-    save(options) if autosave
-    return self
-  end
-  
-  #---
-  
-  def clear(options = {})
-    super
-    save(options) if autosave
-    return self
-  end
-
-  #-----------------------------------------------------------------------------
-  # Import / Export
-  
-  def import(properties, options = {})
-    super(properties, options)
-    save(options) if autosave
-    return self
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Configuration loading / saving
-    
-  def load(options = {})
-    local_config = Config.ensure(options)
-    
-    if can_persist? && File.exists?(@absolute_config_file)
-      raw = Util::Disk.read(@absolute_config_file)    
-      if raw && ! raw.empty?
-        config.clear if local_config.get(:override, false)
-        config.import(Util::Data.parse_json(raw), local_config)
-      end
-    end
-    return self
-  end
-   
-  #---
-    
-  def save(options = {})
-    local_config = Config.ensure(options)
-    
-    if can_persist?
-      rendering = Util::Data.to_json(config.export, local_config.get(:pretty, true))
-      if rendering && ! rendering.empty?
-        Util::Disk.write(@absolute_config_file, rendering)
-        project.commit(@absolute_config_file, local_config) if autocommit
-      end
-    end
-    return self
-  end
-  
-  #---
-  
-  def rm(options = {})
-    local_config = Config.ensure(options)
-    
-    if can_persist?
-      config.clear
-      File.delete(@absolute_config_file)
-      project.commit(@absolute_config_file, local_config) if autocommit
-    end  
-  end
-end
-end
-end

data/lib/coral_core/config.rb

@@ -1,329 +0,0 @@
-
-module Coral
-class Config
-  
-  #-----------------------------------------------------------------------------
-  # Global interface
-
-  extend Mixin::ConfigOptions
-  extend Mixin::ConfigCollection
-  extend Mixin::Lookup
-  extend Mixin::ConfigOps
-  
-  #-----------------------------------------------------------------------------
-  # Instance generators
-  
-  def self.ensure(config)
-    case config
-    when Coral::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 Coral::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
-  
-  #---
-  
-  #def inspect
-  #  "#<#{self.class}: >"
-  #end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-    
-  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)
-    
-    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 = 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 = 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?(Coral::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