carioca 1.3 → 2.0.2

data/lib/carioca/services/config.rb

@@ -0,0 +1,140 @@
+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
+                    
+                    @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? 
+                    @content = @config_file.data
+
+                    unless @stage then
+                        newsets = @content
+                    else
+                        self.merge!  @content[@root][:default]
+                        data = @content[@root][@stage]
+                        self.deep_merge! data
+
+                    end
+
+
+                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/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,175 @@
+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 = ''|
+                        self.display(level: method, message:  message, session: session)
+                    end
+                end
+                @@alias.keys.each do |method|
+                    define_method(method) do |message, session = ''|
+                        self.display( level: method, message: message, session: session)
+                    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)
+                    self.level = level
+                    @mode = mode
+                    @emoji = emoji
+                    @color = colors
+                    if @mode == :dual then 
+                        registry = Carioca::Registry.get
+                        @logger = registry.get_service name: :logger
+                    end
+                    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
+                
+                
+                # 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:)
+                    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 
+                            @logger.send target_level, save
+                        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