carioca 1.4 → 2.0.3

data/lib/carioca/services/config.rb

@@ -0,0 +1,141 @@
+class Hash
+    # monkey patching
+    def deep_symbolize
+      target = dup
+      target.inject({}) do |memo, (key, value)|
+        value = value.deep_symbolize if value.is_a?(Hash)
+        memo[key.to_sym] = value
+        memo
+      end
+    end
+  
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /(.+)=$/
+        self[$1.to_sym] = args.first
+      else
+        self[name.to_sym]
+      end
+    end
+  
+  end
+  
+
+
+  module Carioca
+    module Services
+        module Config
+
+            class ConfigFile
+                include Carioca::Constants
+                attr_accessor :filename, :data
+                attr_reader :error
+
+                def initialize(filename:)
+                    @filename = filename
+                    @data = {}
+                    @error = ""
+                    open
+ 
+                end 
+
+                def error? 
+                    return !@error.empty? 
+                end
+
+                def create!(force: false)
+                    write_ok = true
+                    write_ok = force if File::exist? @filename
+                    File.open(@filename, 'w') { |file| file.write(@data.to_yaml) } if write_ok
+                end
+
+                def open
+                    if File::exist?(@filename) then
+                        begin 
+                            @data = YAML.load_file(@filename)
+                        rescue Exception => e
+                            @error = e.message
+                            @data = {}
+                        end
+                    end
+                    prepare!
+                end
+
+                private
+                def prepare!
+                    config = Carioca::Registry.config
+                    @data = {} unless @data.class == Hash
+                    @data.delete_if {|key,value| config.config_root != key }
+                    @data[config.config_root] = {} unless @data.include? config.config_root
+                    config.supported_environment.each do |evt|
+                        @data[config.config_root][evt] = {} unless  @data[config.config_root].include? evt  
+                    end
+                    @data[config.config_root][:default] = {} unless  @data[config.config_root].include? :default
+                    create!
+                end
+
+            end
+            class Settings < Hash
+                
+                attr_accessor :config_file
+                attr_accessor :stage
+               
+                include Carioca::Helpers
+     
+                def initialize(config_filename: , stage:, root:)
+                    registry = Carioca::Registry.get
+                    @logger = registry.get_service name: :logger
+                    @i18n = registry.get_service name: :i18n
+                    @debug = Carioca::Registry.config.debug?
+                    @stage = stage
+                    @root = root
+                    @config_file = Carioca::Services::Config::ConfigFile::new filename: config_filename
+                    initconf
+                end
+                
+                def refresh
+                    initconf
+                end
+                
+                
+                
+                private
+                def initconf
+                    newsets = {}
+                    @logger.debug("Carioca->Config") { @i18n.t('config.load.error', message: @config_file.error) } if @config_file.error? and @debug
+                    @content = @config_file.data
+
+                    unless @stage then
+                        newsets = @content
+                    else
+                        self.merge!  @content[@root][:default]
+                        data = @content[@root][@stage]
+                        self.deep_merge! data
+
+                    end
+                    @logger.debug("Carioca->Config") { @i18n.t('config.load.success', from: @config_file.filename) } if @debug
+
+
+                end
+                
+                
+            end
+
+
+            
+            class Factory
+                extend Forwardable
+              
+                attr_accessor :settings
+                def_delegators :@settings, :refresh 
+
+
+                def initialize(**keywords)
+                    @settings = Carioca::Services::Config::Settings.new(**keywords)
+                end
+                
+            end
+        end
+        
+    end
+end
+  

data/lib/carioca/services/debug.rb

@@ -1,71 +1,58 @@
-# coding: utf-8
-# $BUILTIN
-# $NAME debug
-# $SERVICE Carioca::Services::ProxyDebug
-# $RESOURCE debug
-# $DESCRIPTION Proxy class debugger Service for Carioca
-# Copyright Ultragreen (c) 2012
-#---
-# Author : Romain GEORGES
-# type : class definition Ruby
-# obj : Generic Debugs tools library
-#---
-
-
-require 'rubygems'
-require 'methodic'
-
-
 module Carioca
-  module Services
+    module Services
+        class Debugger
 
+            def Debugger.get(service:, trace: Carioca::Registry.config.debugger_tracer)
+                return ProxyDebug::new service: service, trace: trace
+            end
 
-    # Service Debug of Carioca
-    # Proxy Class Debug for devs
-    class ProxyDebug
 
-      # ProxyDebug service constructor (has a class proxy => so a service proxy)
-      # @param [Hash] _options the params
-      # @option _options [String] :service the name of the service you want to proxyfying
-      # @option _options [Hash] :params the params of the proxyfied service
-      def initialize(_options)
-        options = Methodic.get_options(_options)
-        options.specify_classes_of :service => String
-        options.specify_presence_of([:service])
-        options.validate!
-        if options[:params] then
-          @obj = Registry.init.start_service :name  => options[:service], :params => options[:params]
-        else
-          @obj = Registry.init.start_service :name  => options[:service]
         end
-        @log  = Registry.init.get_service :name => 'logger'
-        @mapped_service = options[:service]
-      end
 
-      # method_missing overload to make the class proxy efficient
-      def method_missing(methodname, *args,&block)
-        @log.debug("ProxyDebug") { "BEGIN CALL for mapped service #{@mapped_service} "}
-        @log.debug("ProxyDebug") { "called: #{methodname} " }
-        @log.debug("ProxyDebug") { "args : #{args.join " "}" }
-        if block_given? then
-          @log.debug("ProxyDebug") { "block given" }
-          a = @obj.send(methodname, *args,&block)
-        else
-          a = @obj.send(methodname, *args)
-        end
-        @log.debug("ProxyDebug") { "=> returned: #{a} " }
-        @log.debug("ProxyDebug") { 'END CALL' }
-        return a
-      end
+        class ProxyDebug
+            def initialize(service:, trace:)
+                registry = Carioca::Registry.get
+                @service = registry.get_service name: service
+                @tracers = [:output, :logger]
+                raise "Debugger :trace is not valid : #{trace}, must be in : #{@tracers.to_s}" unless @tracers.include? trace
+                @tracer = registry.get_service name: trace
+                @tracer_type = trace
+            end
+
+            def method_missing(methodname, *args, **keywords,&block)
+                
+                trace message: "BEGIN CALL for service #{@service} "
+                trace message: "Method called: #{methodname} " 
+                trace message: "args : #{args.join " "}" 
+                trace message:  "keywords : #{keywords.to_s}"
+                if block_given? then
+                    trace message: "block given" 
+                    a = @service.send(methodname, *args, **keywords,&block)
+                else
+                    a = @service.send(methodname, *args, **keywords)
+                end
+                trace message: "=> method returned: #{a} " 
+                trace message: 'END CALL' 
+               
+                return a
+            end
+
+            def trace(message: )
+                if @tracer_type == :output then 
+                    save = @tracer.mode
+                    @tracer.mode = :mono 
+                    @tracer.debug message 
+                    @tracer.mode = save
+                else
+                    @tracer.debug("Carioca->ProxyDebug") { message }
+                end
+
+            end
+
+            
 
 
-    end
-  end
-end
+        end
 
-# protection for loading libs
-if $0 == __FILE__ then
-  puts "#{File::basename(__FILE__)}:"
-  puts 'this is a RUBY library file'
-  puts "Copyright (c) Ultragreen"
+    end
 end

data/lib/carioca/services/i18n.rb

@@ -0,0 +1,20 @@
+module Carioca
+    module Services
+        class I18n
+
+            def I18n.get(default_locale: , load_path:, locales_availables: )
+                ::I18n::Backend::Simple.include(::I18n::Backend::Fallbacks)
+                ::I18n.load_path << load_path
+                ::I18n.default_locale = default_locale 
+                 ::I18n.fallbacks = locales_availables
+                return ::I18n
+            end
+
+            def I18n.get_system_locale
+               return ::Locale.candidates.to_s.split('_').first.to_sym 
+            end
+
+
+        end
+    end
+end

data/lib/carioca/services/init.rb

@@ -0,0 +1,2 @@
+# encoding: UTF-8
+Dir[File.dirname(__FILE__) + '/*.rb'].sort.each {|file| require file  unless File.basename(file) == 'init.rb'}

data/lib/carioca/services/output.rb

@@ -0,0 +1,189 @@
+module Carioca
+    module Services
+        module Output
+            
+            module FormatsMapping
+                COLORS = { 
+                    :unknown => :red,
+                    :fatal => :red,
+                    :error => :red,
+                    :ko => :yellow,
+                    :warn => :yellow,
+                    :item => :white,
+                    :arrow => :white,
+                    :sending => :white,
+                    :calling => :white,
+                    :scheduling => :white,
+                    :trigger => :white,
+                    :receive => :white,
+                    :info => :cyan,
+                    :ok => :green,
+                    :success => :green,
+                    :debug => :magenta,
+                    :flat => :white
+                }
+                
+                EMOJI = { 
+                    :unknown => {:value => "\u{1F4A5}", :alt => '[!!]', :text => "(UNKNOWN)"},
+                    :fatal => {:value => "\u{26D4}", :alt => '[!!]', :text => "(FATAL)"},
+                    :error => {:value => "\u{1F6AB}", :alt => '[!]', :text => "(ERROR)"},
+                    :ko => {:value => "\u{1F44E}", :alt => '[-]', :text => "(KO)"},
+                    :warn =>  {:value => "\u{26A0}", :alt => '[/!\]', :text => "(WARNING)"},
+                    :info =>  {:value => "\u{2139}", :alt => '[i]', :text => "(INFO)"},
+                    :item =>  {:value => " \u{1F539}", :alt => '', :text => " *"},
+                    :arrow =>  {:value => "  \u{27A1}", :alt => '', :text => " =>"},
+                    :calling => {:value => "\u{1F4DE}" , :alt => '[C]', :text => "(CALLING)"},
+                    :scheduling => {:value => "\u{23F2}" , :alt => '[S]', :text => "{SCHEDULING})"},
+                    :trigger => {:value => "\u{23F0}", :alt => '[T]', :text => "(TRIGGER)"},
+                    :sending =>  {:value => "\u{1F4E4}", :alt => '[>]', :text => "(SENDING)"},
+                    :receive => {:value => "\u{1F4E5}" , :alt => '[<]', :text => "(RECEIVE)"},
+                    :ok =>  {:value => "\u{1F44D}" , :alt => '[+]', :text => "(OK)"},
+                    :success =>  {:value => "\u{1F4AA}" , :alt => '[+]', :text => "(SUCCESS)"},
+                    :debug => {:value => "\u{1F41B}" , :alt => '[D]', :text => "(DEBUG)"},
+                    :flat => {:value => "", :alt => ""}
+                }
+                LEVELS = [:debug, :info, :warn, :error, :fatal, :unknown ]
+                ALIAS = {
+                    :flat => :info, 
+                    :item => :info, 
+                    :ok => :info, 
+                    :ko => :error, 
+                    :trigger => :info,
+                    :scheduling => :info, 
+                    :arrow => :info, 
+                    :sending => :info, 
+                    :calling => :info,
+                    :receive => :info, 
+                    :success => :info 
+                    
+                }
+            end
+            class Provider 
+                include FormatsMapping
+                
+                attr_accessor :mode, :emoji, :color
+                
+                @@alias = ALIAS.dup
+                @@colors = COLORS.dup
+                @@emoji = EMOJI.dup
+                
+                MODE = [:mono, :dual]
+                
+                LEVELS.each do |method|
+                    define_method(method) do |message, session = '', source = 'Carioca->Output'|
+                        self.display(level: method, message:  message, session: session, source: source)
+                    end
+                end
+                @@alias.keys.each do |method|
+                    define_method(method) do |message, session = '',source = 'Carioca->Output'|
+                        self.display( level: method, message: message, session: session, source: source)
+                    end
+                end
+                
+                def map_color(color: , analias: )
+                    raise "Color must be a Symbol" unless color.class == Symbol
+                    raise "Missing alias : #{analias}" unless LEVELS.include? analias
+                    @@alias[analias] = color
+                end
+                
+                def map_emoji(emoji: , analias: )
+                    raise "Emoji must be a String" unless color.class == String
+                    raise "Missing alias : #{analias}" unless LEVELS.include? analias
+                    @@alias[analias] = emoji
+                end
+                
+                
+                def add_alias(newalias:, level:)
+                    raise "Alias must be a Symbol" unless newalias.class == Symbol
+                    raise "Bad Level : #{level}" unless LEVELS.include? level
+                    self.class.define_method(newalias) do |message, session = ''|
+                        self.display({ level: newalias, message: message, session: session})
+                    end
+                end
+                
+                
+                # constructor
+                def initialize(level: :debug, mode: :mono , emoji: true, colors: true)
+                    registry = Carioca::Registry.get
+                    @logger = registry.get_service name: :logger
+                    @i18n = registry.get_service name: :i18n
+                    @debug = Carioca::Registry.config.debug?
+                    self.level = level
+                    @mode = mode
+                    @emoji = (check_unicode_term)? emoji : false
+                    @color = colors
+                    set = []; set.push mode; set.push :emoji if @emoji ; set.push :colors if @color
+                    @logger.debug("Carioca->Output") { @i18n.t('output.load.context', confset: set.to_s ) } if  @debug
+                    raise "Unknown output mode : #{@mode}" unless MODE.include? @mode
+                end
+                
+                # build a session number
+                # @return [String] Session number
+                def get_session
+                    return "#{Time.now.to_i.to_s}#{rand(999)}"
+                end
+                
+                # getter for the current level
+                # @return [Symbol] level
+                def level
+                    return @active_levels.first
+                end
+                
+                # virtual setter for level, set the current level
+                # @raise a badLevel in case of bad level
+                # @param [Symbol] level
+                def level=(level)
+                    raise "Bad Level : #{level}" unless LEVELS.include? level
+                    @active_levels = LEVELS.dup
+                    @active_levels.shift(LEVELS.index(level))
+                end
+                
+                # check if unicode must be used with term ENV
+                # @return [Boolean]
+                def check_unicode_term
+                    return false unless ENV.include? "TERM"
+                    if ENV.values_at("LC_ALL","LC_CTYPE","LANG").compact.first.include?("UTF-8") and ENV.values_at('TERM').first.include? "xterm" then
+                    return true
+                    else
+                    return false
+                    end
+                end
+
+                
+                # abstract method for log wrapper
+                # @param [Hash] params
+                # @option params [Symbol] :level, a valid level in LEVELS or ALIAS
+                # @option params [String] :message text
+                def display(level: , message: , session:, source:)
+                    save = message.dup
+                    target_level = (@@alias.keys.include? level)?  @@alias[level] : level
+                    if @active_levels.include? target_level then
+                        if @color then 
+                            pastel = ::Pastel.new
+                            message = pastel.send @@colors[level], message
+                        end
+                        if @@emoji.include? level
+                            pattern = (@emoji)? @@emoji[level][:value] : @@emoji[level][:alt]
+                            pattern = "#{pattern} #{@@emoji[level][:text]}" if @@emoji[level].include? :text and !@emoji
+                            message  = pattern + " " + message unless pattern.empty?
+                        end
+                        if @mode == :dual
+                            
+                            pattern = @@emoji[level][:alt]
+                            unless LEVELS.include? level
+                                save  =  "#{@@emoji[level][:text]} #{save}" if @@emoji[level].include? :text
+                            end 
+                            block = Proc::new {save}
+                            @logger.send target_level, source, &block
+                        end
+                        puts message
+                    end
+                end
+                
+            end
+            
+            
+        end
+    end
+end
+

data/lib/carioca/validator.rb

@@ -0,0 +1,49 @@
+module Carioca
+    module Services
+        class Validator
+
+            attr_reader :definition
+
+            include Carioca::Constants
+
+            def initialize(definition: , service: )
+                @definition = definition
+                @service = service
+            end 
+
+            def validate!
+                validate_mandatories
+                validate_full_and_type
+                validate_not_builtins
+                fill_content
+            end
+
+            private
+            def validate_not_builtins
+
+                raise "Builtins reserved name #{@service.to_s}" if BUILTINS.keys.include? @service
+            end
+
+            def validate_mandatories
+                SERVICES_MANDATORY_SPECS.keys.each do |spec|
+                    raise "Key : :#{spec} is mandatory in a service definition" unless @definition.include? spec
+                end
+            end
+
+            def validate_full_and_type
+                @definition.each do |spec,value|
+                    raise "Key : :#{spec} is not allowed in a service definition" unless SERVICES_FULL_LIST_SPECS.include? spec
+                    raise "key : #{spec} must be a : #{SERVICES_FULL_LIST_SPECS[spec].to_s}" unless value.class == SERVICES_FULL_LIST_SPECS[spec]
+                    if SERVICES_SPECS_DETAIL.include? spec then
+                        raise "key : #{spec} must be in : #{SERVICES_SPECS_DETAIL[spec].to_s}" unless SERVICES_SPECS_DETAIL[spec].include? value
+                    end
+                end
+            end
+
+            def fill_content
+                @definition[:description] = @service.to_s unless @definition.include? :description
+            end
+
+        end
+    end
+end