coral_core 0.2.30 → 0.4.0

data/lib/coral_core/util/cli.rb

@@ -1,293 +0,0 @@
-module Coral
-  module Util
-    module CLI
-         
-      #-------------------------------------------------------------------------
-      # Utilities
-        
-      def self.message(name, default = nil)
-        if default.nil?
-          default = :none
-        end
-        return I18n.t(name.to_s, :default_value => default.to_s)
-      end  
-         
-      #-------------------------------------------------------------------------
-      # Parser
-       
-      class Parser
-        
-        attr_accessor :parser
-        attr_accessor :options
-        attr_accessor :arguments
-        attr_accessor :processed
-        
-        #---
-        
-        def initialize(args, banner = '', help = '')
-          
-          @parser        = OptionParser.new
-          
-          self.options   = {}
-          self.arguments = {}
-          self.processed = false
-          
-          @arg_settings  = []
-          
-          self.banner  = banner
-          self.help    = help
-          
-          yield(self) if block_given?
-          
-          parse_command(args)
-        end
-        
-        #---
-        
-        def self.split(args, banner, separator = '')
-          main_args   = nil
-          sub_command = nil
-          sub_args    = []
-
-          args.each_index do |index|
-            if !args[index].start_with?('-')
-              main_args   = args[0, index]
-              sub_command = args[index]
-              sub_args    = args[index + 1, args.length - index + 1]
-              break
-            end
-          end
-
-          main_args = args.dup if main_args.nil?
-          results   = [ Parser.new(main_args, banner, separator) ]
-          
-          if sub_command
-            results << [ sub_command, sub_args ]
-          end
-
-          return results.flatten
-        end
-        
-        #---
-        
-        def banner=banner
-          parser.banner = banner  
-        end
-        
-        #---
-        
-        def help=help
-          if help.is_a?(Array)
-            help.each do |line|
-              parser.separator line  
-            end                       
-          else
-            parser.separator help
-          end  
-        end
-        
-        #---
-        
-        def parse_command(args)
-          args  = args.dup
-          error = false
-          
-          self.processed = false
-          
-          parser.on_tail('-h', '--help', CLI.message('coral.core.util.cli.options.help')) do
-            puts parser.help.chomp
-            options[:help] = true
-            return
-          end
-          
-          parser.parse!(args)
-          
-          @arg_settings.each_with_index do |settings, index|
-            if index >= args.length
-              value = nil
-            else
-              value = Util::Data.value(args[index])  
-            end
-            
-            if !value.nil? && settings.has_key?(:allowed)
-              allowed = settings[:allowed]
-              case allowed
-              when Class
-                unless value.is_a?(allowed)
-                  Coral.ui.error(CLI.message(settings[:message]))
-                  error = true
-                end
-              when Array
-                unless allowed.include(value)
-                  Coral.ui.error(CLI.message(settings[:message]))
-                  error = true  
-                end
-              end
-            end
-            
-            if value.nil?
-              if settings.has_key?(:default)
-                value = settings[:default]
-              else
-                error = true
-              end
-            end
-            
-            if !value.nil? && settings.has_key?(:block)
-              value = settings[:block].call(value)
-              error = true if value.nil?
-            end
-            
-            break if error
-            self.arguments[settings[:name]] = value
-          end          
-          
-          if error
-            Coral.ui.error(CLI.message('coral.util.cli.parse.error'))
-            puts parser.help.chomp
-          else
-            self.processed = true
-          end
-        
-        rescue OptionParser::InvalidOption
-          raise Errors::CLIInvalidOptions, :help => parser.help.chomp  
-        end
-        
-        #---
-                
-        def option(name, default, option_str, allowed_values, message_id, config = {})
-          config        = Config.ensure(config)
-          name          = name.to_sym
-          options[name] = config.get(name, default)
-          
-          message_name = name.to_s + '_message'
-          message      = CLI.message(message_id, options[name])
-        
-          option_str   = Util::Data.array(option_str)
-          
-          if allowed_values
-            parser.on(*option_str, allowed_values, config.get(message_name.to_sym, message)) do |value|
-              value         = yield(value) if block_given?
-              options[name] = value unless value.nil?
-            end
-          else
-            parser.on(*option_str, config.get(message_name.to_sym, message)) do |value|
-              value         = yield(value) if block_given?
-              options[name] = value unless value.nil?
-            end  
-          end
-        end
-        
-        #---
-        
-        def arg(name, default, allowed_values, message_id, config = {}, &block)
-          config       = Config.ensure(config)
-          name         = name.to_sym
-          
-          message_name = name.to_s + '_message'
-          message      = CLI.message(message_id, arguments[name])
-        
-          settings     = { 
-            :name    => name,
-            :default => config.get(name, default),
-            :message => config.get(message_name.to_sym, message) 
-          }
-          settings[:allowed] = allowed_values if allowed_values
-          settings[:block]   = block if block
-          
-          @arg_settings << settings  
-        end
-        
-        #---
-        
-        def option_bool(name, default, option_str, message_id, config = {})
-          option(name, default, option_str, nil, message_id, config) do |value|
-            value = Util::Data.value(value)
-            if value == true || value == false
-              block_given? ? yield(value) : value
-            else
-              nil
-            end 
-          end  
-        end
-        
-        #---
-        
-        def arg_bool(name, default, message_id, config = {})
-          arg(name, default, nil, message_id, config) do |value|
-            value = Util::Data.value(value)
-            if value == true || value == false
-              block_given? ? yield(value) : value
-            else
-              nil
-            end 
-          end  
-        end
-        
-        #---
-        
-        def option_int(name, default, option_str, message_id, config = {})
-          option(name, default, option_str, Integer, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end 
-        end
-        
-        #---
-        
-        def arg_int(name, default, message_id, config = {})
-          arg(name, default, Integer, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end 
-        end
-        
-        #---
-        
-        def option_float(name, default, option_str, message_id, config = {})
-          option(name, default, option_str, Float, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end
-        
-        #---
-        
-        def arg_float(name, default, message_id, config = {})
-          arg(name, default, Float, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end
-          
-        #---
-        
-        def option_str(name, default, option_str, message_id, config = {})
-          option(name, default, option_str, nil, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end
-         
-        #---
-        
-        def arg_str(name, default, message_id, config = {})
-          arg(name, default, nil, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end
-         
-        #---
-        
-        def option_array(name, default, option_str, message_id, config = {})
-          option(name, default, option_str, Array, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end
-         
-        #---
-        
-        def arg_array(name, default, message_id, config = {})
-          arg(name, default, Array, message_id, config) do |value|
-            block_given? ? yield(value) : value 
-          end  
-        end 
-      end    
-    end
-  end
-end

data/lib/coral_core/util/data.rb

@@ -1,389 +0,0 @@
-
-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
-  
-  #---
-  
-  def self.exists?(data, keys, check_empty = false)
-    keys = [ keys ] unless keys.is_a?(Array)
-    keys.each do |key|
-      return false unless data.is_a?(Hash) && data.has_key?(key)
-      return false if check_empty && empty?(data[key])
-      data = data[key]
-    end
-    return true
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Translation
-
-  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 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 self.parse_json(json_text)
-    output = ''
-    begin
-      output = MultiJson.load(json_text)
-      
-    rescue Exception
-    end
-    return output
-  end
-    
-  #---
-  
-  def self.to_json(data, pretty = true)
-    output = ''
-    begin
-      output = MultiJson.dump(data, :pretty => pretty)
-      
-    rescue Exception
-    end
-    return output
-  end
-  
-  #---
-  
-  def self.parse_yaml(yaml_text)
-    output = ''
-    begin
-      output = YAML.load(yaml_text)
-      
-    rescue Exception
-    end
-    return output  
-  end
-  
-  #---
-  
-  def self.to_yaml(data)
-    output = ''
-    begin
-      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
-  
-  #---
-      
-  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 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 self.hash(data, default = {})
-    result = default    
-    if data
-      case data
-      when Hash
-        result = data
-      else
-        result = {}
-      end
-    end
-    return result
-  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 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 self.test(data)
-    return false if Util::Data.empty?(data)
-    return true
-  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 = undef?(data[0]) ? nil : data.shift.clone
-      
-      data.each do |item|
-        item = undef?(item) ? nil : 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
-                
-        else
-          value = item if force || item.is_a?(String) || item.is_a?(Symbol)
-        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
-  
-  #---
-  
-  def self.ensure(test, success_value = nil, failure_value = nil)
-    success_value = (success_value ? success_value : test)
-    failure_value = (failure_value ? failure_value : nil)
-      
-    if empty?(test)
-      value = failure_value
-    else
-      value = success_value
-    end
-    return value
-  end
-  
-  #---
-  
-  def self.ensure_value(value, failure_value = nil)
-    return self.ensure(value, nil, failure_value)
-  end
-end
-end
-end