corl 0.4.0 → 0.4.1

data/lib/corl_core/plugin/template.rb

@@ -1,80 +0,0 @@
-
-module CORL
-module Plugin
-class Template < Base
-
-  #-----------------------------------------------------------------------------
-  # Template plugin interface
-
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-
-  #-----------------------------------------------------------------------------
-  # Operations
-  
-  def 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 render(data)
-    normalize   = get(:normalize_template, true)
-    interpolate = get(:interpolate_template, true)
-    
-    logger.debug("Rendering data: normalize: #{normalize.inspect}; interpolate: #{interpolate.inspect}: #{data.inspect}")
-    
-    if normalize
-      data = Config.normalize(data, nil, config)
-      logger.debug("Pre-rendering data normalization: #{data.inspect}")
-    end
-    
-    if normalize && interpolate
-      data = Util::Data.interpolate(data, data, export)
-      logger.debug("Pre-rendering data interpolation: #{data.inspect}")
-    end    
-    return render_processed(process(data))
-  end
-  
-  #---
-  
-  def render_processed(data)
-    logger.debug("Rendering #{plugin_provider} data: #{data.inspect}")
-    
-    output = ''
-    output = yield(output) if block_given?
-    
-    logger.debug("Completed rendering of #{plugin_provider} data: #{output}")
-    return output
-  end
-end
-end
-end

data/lib/corl_core/plugin/translator.rb

@@ -1,38 +0,0 @@
-
-module CORL
-module Plugin
-class Translator < Base
-
-  #-----------------------------------------------------------------------------
-  # Translator plugin interface
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-
-  #-----------------------------------------------------------------------------
-  # Operations
-  
-  def parse(raw)
-    logger.debug("Parsing raw data: #{raw}")
-    
-    properties = {}
-    properties = yield(properties) if block_given?
-    
-    logger.debug("Completed parsing data: #{properties.inspect}")
-    return properties
-  end
-  
-  #---
-  
-  def generate(properties)
-    logger.debug("Generating output data: #{properties.inspect}")
-    
-    output = ''
-    output = yield(output) if block_given?
-    
-    logger.debug("Completed generating data: #{output}")
-    return output
-  end
-end
-end
-end

data/lib/corl_core/util/cli.rb

@@ -1,352 +0,0 @@
-module CORL
-  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
-      
-      #---
-      
-      def self.encode(data)
-        Base64.encode64(Util::Data.to_json(data, false))
-      end
-      
-      def self.decode(encoded_string)
-        Util::Data.symbol_map(Util::Data.parse_json(Base64.decode64(encoded_string)))  
-      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
-          return parser.help
-        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
-          
-          option_str(:log_level, nil, 
-            '--log_level STR', 
-            'corl.core.util.cli.options.log_level'
-          )
-          option_str(:encoded_params, false, 
-            '--encoded STR', 
-            'corl.core.util.cli.options.encoded'
-          )
-          parser.on_tail('-h', '--help', CLI.message('corl.core.util.cli.options.help')) do
-            options[:help] = true
-            return
-          end
-          
-          parser.parse!(args)
-                    
-          CORL.log_level = options[:log_level] if options[:log_level]
-          parse_encoded
-          
-          remaining_args = args.dup
-          arg_messages   = []
-          
-          if arguments.empty?
-            @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
-                  if (allowed == Array)
-                    value          = remaining_args
-                    remaining_args = []
-                  end
-                  unless value.is_a?(allowed)
-                    arg_messages << CLI.message(settings[:message])
-                    error = true
-                  end
-                when Array
-                  unless allowed.include(value)
-                    arg_messages << 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
-            
-              remaining_args.shift unless remaining_args.empty?
-              self.arguments[settings[:name]] = value
-            end          
-          end
-          
-          if error
-            if ! arg_messages.empty?
-              parser.warn(CLI.message('corl.core.util.cli.parse.error') + "\n\n" + arg_messages.join("\n") + "\n\n" + parser.help)
-            else
-              parser.warn(CLI.message('corl.core.util.cli.parse.error') + "\n\n" + parser.help)  
-            end
-          else
-            self.processed = true
-          end
-        
-        rescue OptionParser::InvalidOption => e
-          parser.warn(e.message + "\n\n" + parser.help)
-        end
-        
-        #---
-        
-        def parse_encoded
-          if options[:encoded_params]
-            encoded_properties = CLI.decode(options[:encoded_params])
-            
-            @arg_settings.each do |settings|
-              if encoded_properties.has_key?(settings[:name].to_sym)
-                self.arguments[settings[:name]] = encoded_properties.delete(settings[:name].to_sym)
-              end
-            end
-            
-            encoded_properties.each do |name, value|
-              self.options[name] = value unless options.has_key?(name)
-            end
-          end
-          options.delete(:encoded_params)
-        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
-          
-          settings.delete(:default) if settings[:default].nil?
-          
-          @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