coral_core 0.1.2

data/lib/coral_core/event.rb

@@ -0,0 +1,168 @@
+
+module Coral
+class Event < Core
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.instance!(options = {}, build_hash = false, keep_array = false)
+    group  = ( build_hash ? {} : [] )    
+    events = build_info(options)
+    
+    index = 1
+    events.each do |info|
+      type = info[:type]
+      
+      if type && ! type.empty?
+        event = ( block_given? ? yield(type, info) : create(type, info) )
+                
+        if event
+          if build_hash
+            group[index] = event
+          else
+            group << event
+          end
+        end
+      end
+      index += 1
+    end
+    if ! build_hash && events.length == 1 && ! keep_array
+      return group.shift
+    end
+    return group
+  end
+  
+  #---
+  
+  def self.instance(options = {}, build_hash = false, keep_array = false)
+    return instance!(options, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def initialize(options = {})
+    super(options)
+    
+    @name       = ( options.has_key?(:name) ? options[:name] : '' )
+    @delegate   = ( options.has_key?(:delegate) ? options[:delegate] : nil )  
+    @properties = options
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_accessor :name
+
+  #---
+  
+  def type
+    return string(@properties[:type])
+  end
+  
+  #---
+  
+  def set_properties(data)
+    return @delegate.set_properties(data) if @delegate
+    
+    @properties = hash(data)
+    return self
+  end
+   
+  #---
+ 
+  def property(name, default = '', format = false)
+    name = name.to_sym
+    
+    property = default
+    property = filter(@properties[name], format) if @properties.has_key?(name)
+    return property  
+  end
+ 
+  #---
+  
+  def set_property(name, value)
+    return @delegate.set_property(name, value) if @delegate
+    
+    @properties[name] = value
+    return self
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return type
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Event handling
+   
+  def check(source)
+    return false
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.build_info!(data = {})  
+    events = []
+    
+    if data.is_a?(String)
+      data = data.split(/\s*,\s*/)
+    elsif data.is_a?(Hash)
+      data = [ data ]
+    end
+    
+    if data.is_a?(Array)
+      data.each do |element|
+        event = {}
+        
+        if block_given?
+          event = yield(element)
+        else
+          case element        
+          when String
+            event = split_event_string(element)
+                
+          when Hash          
+            event = element
+          end
+        end
+        
+        unless event.empty?
+          events << event
+        end
+      end
+    end
+    return events
+  end
+  
+  #---
+  
+  def self.build_info(data = {})
+    return build_info!(data)
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.create(type, info)
+    event = nil
+    begin
+      event = Module.const_get("Coral").const_get("#{type.capitalize}Event").new(info)
+    rescue
+    end
+    return event
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.split_event_string(data)
+    info          = {}    
+    components    = data.split(':')
+    info[:type]   = components.shift
+    info[:string] = components.join(':')
+    
+    return info
+  end
+end
+end

data/lib/coral_core/interface.rb

@@ -0,0 +1,179 @@
+
+require "log4r"
+
+module Coral
+class Interface
+  
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@logger = Log4r::Logger.new("coral::interface")
+  
+  #---
+
+  COLORS = {
+    :clear  => "\e[0m",
+    :red    => "\e[31m",
+    :green  => "\e[32m",
+    :yellow => "\e[33m"
+  }
+
+  COLOR_MAP = {
+    :warn    => COLORS[:yellow],
+    :error   => COLORS[:red],
+    :success => COLORS[:green]
+  }
+
+  #-----------------------------------------------------------------------------
+  # Constructor
+  
+  def initialize(options = {})
+    class_name = self.class.to_s.downcase
+    
+    if options.is_a?(String)
+      options = { :resource => options, :logger => options }
+    end
+    
+    if options.has_key?(:logger)
+      if options[:logger].is_a?(String)
+        @logger = Log4r::Logger.new(options[:logger])
+      else
+        @logger = options[:logger] 
+      end
+    else
+      @logger = Log4r::Logger.new("coral::#{class_name}")
+    end
+    
+    @resource  = ( options.has_key?(:resource) ? options[:resource] : '' )
+    @color     = ( options.has_key?(:color) ? options[:color] : true )
+    
+    @printer   = ( options.has_key?(:printer) ? options[:printer] : :puts )
+    
+    @input     = ( options.has_key?(:input) ? options[:input] : $stdin )
+    @output    = ( options.has_key?(:output) ? options[:output] : $stdout )
+    @error     = ( options.has_key?(:error) ? options[:error] : $stderr )
+    
+    @delegate  = ( options.has_key?(:ui_delegate) ? options[:ui_delegate] : nil )    
+  end
+
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  attr_accessor :logger, :resource, :color, :input, :output, :error, :delegate
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.logger
+    return @@logger
+  end
+
+  #-----------------------------------------------------------------------------
+  # UI functionality
+
+  def say(type, message, options = {})
+    return @delegate.say(type, message, options) if check_delegate('say')
+  
+    defaults = { :new_line => true, :prefix => true }
+    options  = defaults.merge(options)
+    printer  = options[:new_line] ? :puts : :print
+    channel  = type == :error || options[:channel] == :error ? @error : @output
+
+    safe_puts(format_message(type, message, options),
+              :channel => channel, :printer => printer)
+  end
+  
+  #---
+
+  def ask(message, options = {})
+    return @delegate.ask(message, options) if check_delegate('ask')
+
+    options[:new_line] = false if ! options.has_key?(:new_line)
+    options[:prefix]   = false if ! options.has_key?(:prefix)
+
+    say(:info, message, options)
+    return @input.gets.chomp
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def info(message, *args)
+    @logger.info("info: #{message}")
+    
+    return @delegate.info(message, *args) if check_delegate('info')
+    say(:info, message, *args)
+  end
+  
+  #---
+  
+  def warn(message, *args)
+    @logger.info("warn: #{message}")
+    
+    return @delegate.warn(message, *args) if check_delegate('warn')
+    say(:warn, message, *args)
+  end
+  
+  #---
+  
+  def error(message, *args)
+    @logger.info("error: #{message}")
+    
+    return @delegate.error(message, *args) if check_delegate('error')
+    say(:error, message, *args)
+  end
+  
+  #---
+  
+  def success(message, *args)
+    @logger.info("success: #{message}")
+    
+    return @delegate.success(message, *args) if check_delegate('success')
+    say(:success, message, *args)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def format_message(type, message, options = {})
+    return @delegate.format_message(type, message, options) if check_delegate('format_message')
+    
+    if @resource && ! @resource.empty? && options[:prefix]
+      prefix = "[#{@resource}]"    
+    end
+    message = "#{prefix} #{message}".strip
+    
+    if @color
+      if options.has_key?(:color)
+        color   = COLORS[options[:color]]
+        message = "#{color}#{message}#{COLORS[:clear]}"
+      else
+        message = "#{COLOR_MAP[type]}#{message}#{COLORS[:clear]}" if COLOR_MAP[type]
+      end
+    end
+    return message
+  end
+
+  #---
+  
+  def safe_puts(message = nil, options = {})
+    return @delegate.safe_puts(message, options) if check_delegate('safe_puts')
+    
+    message ||= ""
+    options   = {
+      :channel => @output,
+      :printer => @printer,
+    }.merge(options)
+
+    begin
+      options[:channel].send(options[:printer], message)
+    rescue Errno::EPIPE
+      return
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def check_delegate(method)
+    return ( @delegate && @delegate.respond_to?(method.to_s) )
+  end
+end
+end

data/lib/coral_core/memory.rb

@@ -0,0 +1,222 @@
+
+require 'json'
+
+module Coral
+class Memory < Repository
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    super(options)
+    
+    @absolute_config_file = ''
+    
+    @properties     = ( options.has_key?(:properties) ? hash(options[:properties]) : {} )
+    @config_file    = ( options.has_key?(:config_file) ? string(options[:config_file]) : '' )
+    @autoload       = ( options.has_key?(:autoload) ? options[:autoload] : true )
+    @autosave       = ( options.has_key?(:autosave) ? options[:autosave] : true )
+    @autocommit     = ( options.has_key?(:autocommit) ? options[:autocommit] : true )
+    @commit_message = ( options.has_key?(:commit_message) ? string(options[:commit_message]) : 'Saving state' )
+      
+    set_absolute_config_file
+    load if @autoload
+  end
+  
+  #---
+  
+  def self.finalize(file_name)
+    proc do
+      Coral::Util::Disk.close(file_name)
+    end
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_accessor :autoload, :autosave, :autocommit, :commit_message
+  attr_reader :config_file, :absolute_config_file
+
+  #---
+ 
+  def set_absolute_config_file
+    if @directory.empty? || @config_file.empty?
+      @absolute_config_file = ''
+    else 
+      @absolute_config_file = ( ! @submodule.empty? ? File.join(@directory, @submodule, @config_file) : File.join(@directory, @config_file) )
+      ObjectSpace.define_finalizer(self, self.class.finalize(@absolute_config_file))
+    end
+    return self
+  end
+ 
+  #---
+  
+  def config_file=config_file
+    @config_file = string(config_file)
+    
+    set_absolute_config_file
+    load if @autoload
+  end
+  
+  #-----------------------------------------------------------------------------
+ 
+  def get(key, default = '', format = false)
+    value = default
+    key   = string(key)
+          
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if @properties.has_key?(key)
+      value = @properties[key]
+    end     
+    return filter(value, format)
+  end
+    
+  #---
+   
+  def set(key, value = '')
+    key = string(key)
+       
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    @properties[key] = value
+    save if @autosave
+    return self
+  end
+    
+  #---
+   
+  def delete(key)
+    key = string(key)
+        
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    @properties.delete(key)
+    save if @autosave
+    return self
+  end
+    
+  #---
+    
+  def get_group(group, name = '', key = nil, default = {}, format = false)
+    info  = get(group, {})
+    value = info
+    
+    if name
+      name = string(name)
+      if info.has_key?(name) && info[name].is_a?(Hash)
+        if key && ! key.empty?
+          key = string(key)
+          if info[name].has_key?(key)
+            value = info[name][key]
+          else
+            value = default
+          end
+        else
+          value = info[name]
+        end          
+      else
+        value = default     
+      end        
+    end
+    return filter(value, format)
+  end
+       
+  #---
+    
+  def set_group(group, name, key = nil, value = {})
+    group = string(group)
+    name  = string(name)
+    
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if ! @properties[group] || ! @properties[group].is_a?(Hash)
+      @properties[group] = {}
+    end      
+      
+    if key && ! key.empty?
+      key = string(key)
+      if ! @properties[group][name] || ! @properties[group][name].is_a?(Hash)
+        @properties[group][name] = {}  
+      end
+      @properties[group][name][key] = value
+        
+    else
+      @properties[group][name] = value  
+    end
+    save if @autosave
+    return self
+  end
+       
+  #---
+    
+  def delete_group(group, name, key = nil)
+    group = string(group)
+    name  = string(name)
+    
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if ! @properties[group] || ! @properties[group].is_a?(Hash)
+      @properties[group] = {}
+    end      
+      
+    if key && ! key.empty?
+      key = string(key)
+      if @properties[group][name] && @properties[group][name].is_a?(Hash)
+        @properties[group][name].delete(key)
+      end
+    else
+      @properties[group].delete(name)  
+    end
+    save if @autosave
+    return self
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return @properties
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Configuration loading / saving
+    
+  def load
+    if can_persist?
+      config = Coral::Util::Disk.read(@absolute_config_file)    
+      if config && ! config.empty?
+        @properties = JSON.parse(config)
+      end
+    end
+    return self
+  end
+    
+  #---
+    
+  def save(options = {})
+    if can_persist?
+      config = JSON.generate(@properties)
+      if config && ! config.empty?
+        Coral::Util::Disk.write(@absolute_config_file, config)
+        commit(@absolute_config_file, options) if @autocommit
+      end
+    end
+    return self
+  end  
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def can_persist?
+    success = super
+    success = false if success && @absolute_config_file.empty?
+    return success
+  end
+end
+end

data/lib/coral_core/repository.rb

@@ -0,0 +1,156 @@
+
+module Coral
+class Repository < Core
+    
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    super(options)
+    
+    @name       = ( options.has_key?(:name) ? string(options[:name]) : '' )
+    @directory  = ( options.has_key?(:directory) ? string(options[:directory]) : '' )
+    @submodule  = ( options.has_key?(:submodule) ? string(options[:submodule]) : '' )
+    @remote_dir = ( options.has_key?(:remote_dir) ? string(options[: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
+        if ! @submodule.empty?
+          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 = {})
+    if can_persist?
+      hosts = array(hosts)
+      
+      delete_remote(name)
+      return self if hosts.empty?
+      
+      if @remote_dir && ! options.has_key?(:repo)
+        options[:repo] = @remote_dir
+      end
+      
+      git.add_remote(name, Git.url(hosts.shift, options[:repo], options))
+      
+      if ! hosts.empty?
+        remote = git.remote(name)
+        
+        options[:add] = true
+      
+        hosts.each do |host|
+          git_url = Git.url(host, options[:repo], options)
+          remote.set_url(git_url, 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 = {})
+    if can_persist?
+      time    = Time.new.strftime("%Y-%m-%d %H:%M:%S")
+      user    = ENV['USER']
+      message = ( options[:message] ? options[:message] : 'Saving state' )
+      
+      options[:author]      = ( ! options[:author].empty? ? options[:author] : '' )
+      options[:allow_empty] = ( options[:allow_empty] ? options[: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}", options)                
+    end
+    return self      
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def push!(remote = 'origin', options = {})
+    if can_persist?
+      branch  = ( options[:branch] && ! options[:branch].empty? ? options[:branch] : 'master' )
+      tags    = ( options[:tags] ? options[: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!(options) 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