coral_core 0.2.23 → 0.2.24

data/lib/coral_core/core.rb

@@ -0,0 +1,212 @@
+
+module Coral
+class Core
+  
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@ui = Interface.new("coral")
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    config = Config.ensure(options)
+    
+    @ui = Interface.new(config)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessor / Modifiers
+  
+  attr_accessor :ui
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.ui
+    return @@ui
+  end
+  
+  #---
+  
+  def self.logger
+    return @@ui.logger
+  end
+  
+  #--- 
+   
+  def logger
+    return self.class.logger
+  end
+  
+  #---
+ 
+  def logger=logger
+    self.class.logger = logger
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # General utilities
+
+  def self.symbol_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_sym] = symbol_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def symbol_map(data)
+    return self.class.symbol_map(data)
+  end
+  
+  #---
+  
+  def self.string_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_s] = string_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def string_map(data)
+    return self.class.string_map(data)
+  end
+  
+  #-----------------------------------------------------------------------------
+      
+  def self.filter(data, method = false)
+    if method && method.is_a?(Symbol) && 
+      [ :array, :hash, :string, :symbol, :test ].include?(method.to_sym)
+      return send(method, data)
+    end
+    return data
+  end
+  
+  #---
+  
+  def filter(data, method = false)
+    return self.class.filter(data, method)
+  end
+    
+  #-----------------------------------------------------------------------------
+          
+  def self.array(data, default = [], split_string = false)
+    result = default    
+    if data
+      case data
+      when Array
+        result = data
+      when String
+        result = [ ( split_string ? data.split(/\s*,\s*/) : data ) ]
+      else
+        result = [ data ]
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def array(data, default = [], split_string = false)
+    return self.class.array(data, default, split_string)
+  end
+    
+  #---
+        
+  def self.hash(data, default = {})
+    result = default    
+    if data
+      case data
+      when Hash
+        result = data
+      else
+        result = {}
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def hash(data, default = {})
+    return self.class.hash(data, default)
+  end
+    
+  #---
+         
+  def self.string(data, default = '')
+    result = default    
+    if data
+      case data
+      when String
+        result = data
+      else
+        result = data.to_s
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def string(data, default = '')
+    return self.class.string(data, default)
+  end
+    
+  #---
+         
+  def self.symbol(data, default = :undefined)
+    result = default    
+    if data
+      case data
+      when Symbol
+        result = data
+      when String
+        result = data.to_sym
+      else
+        result = data.class.to_sym
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def symbol(data, default = '')
+    return self.class.symbol(data, default)
+  end
+     
+  #---
+    
+  def self.test(data)
+    return false if Util::Data.empty?(data)
+    return true
+  end
+  
+  #---
+  
+  def test(data)
+    return self.class.test(data)
+  end  
+end
+end

data/lib/coral_core/event.rb

@@ -0,0 +1,170 @@
+
+module Coral
+class Event < Core
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.instance!(data = {}, build_hash = false, keep_array = false)
+    group  = ( build_hash ? {} : [] )    
+    events = build_info(data)
+    
+    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 = {})
+    config = Config.ensure(options)
+    
+    super(config)
+    
+    @name       = config.get(:name, '')
+    @delegate   = config.get(:delegate, nil)  
+    @properties = config.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/event/regexp_event.rb

@@ -0,0 +1,55 @@
+
+module Coral
+class RegexpEvent < Event
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  TYPE = :regexp
+
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    options[:type] = TYPE
+    
+    super(options)
+    
+    if options.has_key?(:string)
+      self.pattern = options[:string]
+    end
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def pattern
+    return property(:pattern, '', :string)
+  end
+  
+  #---
+   
+  def pattern=pattern
+    set_property(:pattern, string(pattern))  
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return "#{type}:#{pattern}"
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Event handling
+  
+  def check(source)
+    if source.match(/#{pattern}/)
+      logger.debug("MATCH! -> #{pattern} matched #{source}") 
+      return true                  
+    end
+    logger.debug("nothing -> #{pattern} - #{source}")
+    return false
+  end
+end
+end

data/lib/coral_core/interface.rb

@@ -0,0 +1,180 @@
+
+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
+    config = Config.ensure(options)
+    
+    if config.get(:logger, false)
+      if config[:logger].is_a?(String)
+        @logger = Log4r::Logger.new(config[:logger])
+      else
+        @logger = config[:logger] 
+      end
+    else
+      @logger = Log4r::Logger.new(class_name)
+    end
+    
+    @resource  = config.get(:resource, '')
+    @color     = config.get(:color, true)
+    
+    @printer   = config.get(:printer, :puts)
+    
+    @input     = config.get(:input, $stdin)
+    @output    = config.get(:output, $stdout)
+    @error     = config.get(:error, $stderr)
+    
+    @delegate  = config.get(: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