coral_core 0.2.23 → 0.2.24

data/lib/coral_core/template.rb

@@ -0,0 +1,92 @@
+
+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

data/lib/coral_core/template/environment.rb

@@ -0,0 +1,72 @@
+
+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

@@ -0,0 +1,13 @@
+
+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

@@ -0,0 +1,13 @@
+
+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

@@ -0,0 +1,13 @@
+
+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/util/data.rb

@@ -0,0 +1,219 @@
+
+module Coral
+module Util
+class Data
+  
+  #-----------------------------------------------------------------------------
+  # Type checking
+  
+  def self.undef?(value)
+    if value.nil? || 
+      (value.is_a?(Symbol) && value == :undef || value == :undefined) || 
+      (value.is_a?(String) && value.match(/^\s*(undef|UNDEF|Undef|nil|NIL|Nil)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.true?(value)
+    if value == true || 
+      (value.is_a?(String) && value.match(/^\s*(true|TRUE|True)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.false?(value)
+    if value == false || 
+      (value.is_a?(String) && value.match(/^\s*(false|FALSE|False)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.empty?(value)
+    if undef?(value) || false?(value) || (value.respond_to?('empty?') && value.empty?)
+      return true
+    end
+    return false
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Translation
+  
+  def self.to_json(data)
+    output = ''
+    begin
+      output = data.to_json
+      
+    rescue Exception
+    end
+    return output
+  end
+  
+  #---
+  
+  def self.to_yaml(data)
+    output = ''
+    begin
+      require 'yaml'
+      output = YAML.dump(data)
+      
+    rescue Exception
+    end
+    return output
+  end
+  
+  #---
+  
+  def self.value(value)
+    case value
+    when String
+      if undef?(value)
+        value = nil
+      elsif true?(value)
+        value = true
+      elsif false?(value)
+        value = false
+      end
+    
+    when Array
+      value.each_with_index do |item, index|
+        value[index] = value(item)
+      end
+    
+    when Hash
+      value.each do |key, data|
+        value[key] = value(data)
+      end
+    end
+    return value  
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def self.merge(data, force = true)
+    value = data
+    
+    # Special case because this method is called from within Config.new so we 
+    # can not use Config.ensure, as that would cause an infinite loop.
+    force = force.is_a?(Coral::Config) ? force.get(:force, true) : force
+    
+    if data.is_a?(Array)
+      value = data.shift.clone
+      
+      data.each do |item|
+        item = item.clone
+        
+        case value
+        when Hash
+          begin
+            require 'deep_merge'
+            value = force ? value.deep_merge!(item) : value.deep_merge(item)
+            
+          rescue LoadError
+            if item.is_a?(Hash) # Non recursive top level by default.
+              value = value.merge(item)              
+            elsif force
+              value = item
+            end
+          end  
+        when Array
+          if item.is_a?(Array)
+            value = value.concat(item).uniq
+          elsif force
+            value = item
+          end
+                
+        when String, Symbol
+          value = item if item.is_a?(String) || item.is_a?(Symbol) || force 
+        end
+      end  
+    end
+    
+    return value
+  end
+
+  #---
+  
+  def self.interpolate(value, scope, options = {})    
+    
+    pattern = ( options.has_key?(:pattern) ? options[:pattern] : '\$(\{)?([a-zA-Z0-9\_\-]+)(\})?' )
+    group   = ( options.has_key?(:var_group) ? options[:var_group] : 2 )
+    flags   = ( options.has_key?(:flags) ? options[:flags] : '' )
+    
+    if scope.is_a?(Hash)
+      regexp = Regexp.new(pattern, flags.split(''))
+    
+      replace = lambda do |item|
+        matches = item.match(regexp)
+        result  = nil
+        
+        #dbg(item, 'item')
+        #dbg(matches, 'matches')
+        
+        unless matches.nil?
+          replacement = scope.search(matches[group], options)
+          result      = item.gsub(matches[0], replacement) unless replacement.nil?
+        end
+        return result
+      end
+      
+      case value
+      when String
+        #dbg(value, 'interpolate (string) -> init')
+        while (temp = replace.call(value))
+          #dbg(temp, 'interpolate (string) -> replacement')
+          value = temp
+        end
+        
+      when Hash
+        #dbg(value, 'interpolate (hash) -> init')
+        value.each do |key, data|
+          #dbg(data, "interpolate (#{key}) -> data")
+          value[key] = interpolate(data, scope, options)
+        end
+      end
+    end
+    #dbg(value, 'interpolate -> result')
+    return value  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.prefix(prefix, data)
+    result = nil
+    
+    unless prefix.is_a?(String) && ! empty?(prefix)
+      prefix = ''
+    end
+    
+    case data
+    when String, Symbol
+      result = ( prefix.empty? ? data.to_s : prefix + '_' + data.to_s )
+      
+    when Array
+      result = []
+      data.each do |value|
+        result << prefix(prefix, value)
+      end
+      
+    when Hash
+      result = {}
+      data.each do |key, value|
+        result[prefix(prefix, key)] = value  
+      end      
+    end
+    return result
+  end
+end
+end
+end

data/lib/coral_core/util/disk.rb

@@ -0,0 +1,92 @@
+
+module Coral
+module Util
+class Disk
+  
+  #-----------------------------------------------------------------------------
+  # Properties
+ 
+  @@files = {}
+  
+  @@separator   = false
+  @@description = ''
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.open(file_name, options = {}, reset = false)
+    mode          = options[:mode].to_s
+    
+    @@separator   = ( options[:separator] ? options[:separator] : false )
+    @@description = ( options[:description] ? options[:description] : '' )
+    
+    if @@files.has_key?(file_name) && ! reset
+      reset = true if ! mode.empty? && mode != @@files[file_name][:mode]
+    end
+    
+    if ! @@files.has_key?(file_name) || ! @@files[file_name][:file] || reset
+      @@files[file_name][:file].close if @@files[file_name] && @@files[file_name][:file]
+      unless mode.empty? || ( mode == 'r' && ! File.exists?(file_name) )
+        @@files[file_name] = {
+          :file => File.open(file_name, mode),
+          :mode => mode,
+        }
+      end
+    end
+    return nil unless @@files[file_name]
+    return @@files[file_name][:file]
+  end
+  
+  #---
+  
+  def self.read(file_name, options = {})
+    options[:mode] = ( options[:mode] ? options[:mode] : 'r' )
+    file           = open(file_name, options)
+    
+    if file
+      return file.read
+    end
+    return nil
+  end
+  
+  #---
+  
+  def self.write(file_name, data, options = {})
+    options[:mode] = ( options[:mode] ? options[:mode] : 'w' )
+    file           = open(file_name, options)
+    
+    if file
+      return file.write(data)
+    end
+    return nil
+  end
+  
+  #---
+  
+  def self.log(data, options = {})
+    reset = ( options[:file_name] || options[:mode] )
+    file  = open(( options[:file_name] ? options[:file_name] : 'log.txt' ), options, reset)    
+    if file      
+      file.write("--------------------------------------\n") if @@separator
+      file.write("#{@@description}\n") if @@description       
+      file.write("#{data}\n")
+    end
+  end
+  
+  #---
+  
+  def self.close(file_names = [])
+    file_names = @@files.keys unless file_names && ! file_names.empty?
+    
+    unless file_names.is_a?(Array)
+      file_names = [ file_names ]
+    end
+    
+    file_names.each do |file_name|
+      @@files[file_name][:file].close if @@files[file_name] && @@files[file_name][:file]
+      @@files.delete(file_name)
+    end
+  end
+end
+end
+end