sc4ry 0.2.0 → 0.2.1

data/lib/sc4ry/config.rb

@@ -1,91 +1,99 @@
-# Sc4ry module 
+# frozen_string_literal: true
+
+# Sc4ry module
 # @note namespace
 module Sc4ry
-    # Sc4ry::Config module
-    # @note namespace
-    module Config
-        # Configuration validator for Sc4ry default and circuits configuration
-        # @private
-        class Validator
+  # Sc4ry::Config module
+  # @note namespace
+  module Config
+    # Configuration validator for Sc4ry default and circuits configuration
+    # @private
+    class Validator
+      # accessor on Circuit definition given for validation
+      attr_reader :input
 
-            # accessor on Circuit definition given for validation
-            attr_reader :input
-            # accessor on circuit initial definition from default config or given in construction by from keyword
-            # @note altered by reference to final result mapping with {#validate!}
-            attr_reader :config
-            
-            def result
-                @config
-            end
-            
-            include Sc4ry::Constants
-            include Sc4ry::Exceptions
-            # Validator constructor 
-            # @param [Hash] definition the config hash to merge and validate
-            # @param [Hash] from config hash merged on origin (default : the Sc4ry base config from Constants )
-            # @return [Validator] a new instance of Validator
-            def initialize(definition: , from: DEFAULT_CONFIG)
-                @config = from
-                @input = definition
-            end
-            
-            # Validation method, alter by reference the config attribut
-            # @raise ConfigError if un unknown key is given in definition to merge. 
-            def validate!
-                unknown_keys = @input.keys.difference @config.keys
-                raise ConfigError::new("Unknown keys in config set : #{unknown_keys.to_s}") unless unknown_keys.empty?
-                validate_formats
-                @config.merge! @input 
-                format_exceptions
-            end
-            
-            private
-            # Validation private sub method 
-            # @raise ConfigError if proposed values haven't the good format and deeply in array
-            def validate_formats
-                @input.each do |spec,value|
-                    raise ConfigError::new("#{spec} value #{DEFAULT_CONFIG_FORMATS[spec][:desc]}") unless DEFAULT_CONFIG_FORMATS[spec][:proc].call(value)
-                    if DEFAULT_CONFIG_FORMATS[spec].include? :list then
-                        value.each do |item|
-                            raise ConfigError::new("#{spec} value must be in #{DEFAULT_CONFIG_FORMATS[spec][:list]}") unless DEFAULT_CONFIG_FORMATS[spec][:list].include? item
-                        end
-                    end
-                end
-            end
-            
-            # adapter for exception key in config String to Constant Class Name if need
-            # @note by reference
-            def format_exceptions
-                @config[:exceptions].map! {|item| item = (item.class == String)? Object.const_get(item) : item  }
-            end
-            
-        end
+      # accessor on circuit initial definition from default config or given in construction by from keyword
+      # @note altered by reference to final result mapping with {#validate!}
+      attr_reader :config
+
+      def result
+        @config
+      end
+
+      include Sc4ry::Constants
+      include Sc4ry::Exceptions
+      # Validator constructor
+      # @param [Hash] definition the config hash to merge and validate
+      # @param [Hash] from config hash merged on origin (default : the Sc4ry base config from Constants )
+      # @return [Validator] a new instance of Validator
+      def initialize(definition:, from: DEFAULT_CONFIG)
+        @config = from
+        @input = definition
+      end
 
-        # Config Data mapper for block yielding methods for configuration 
-        # @note work for/with {Sc4ry::Circuits.configure} and {Sc4ry::Circuits.register} when block given
-        class ConfigMapper
+      # Validation method, alter by reference the config attribut
+      # @raise ConfigError if un unknown key is given in definition to merge.
+      def validate!
+        unknown_keys = @input.keys.difference @config.keys
+        raise ConfigError, "Unknown keys in config set : #{unknown_keys}" unless unknown_keys.empty?
 
-            include Sc4ry::Constants
+        validate_formats
+        @config.merge! @input
+        format_exceptions
+      end
 
-            # config from given definition passed in constructor
-            attr_reader :config
-            
-            # the mapping constructor from a given definition or the default From Sc4ry config (Constant)
-            # @param [Hash] definition a config hash 
-            # @note creating dynamically accessors on config record given in definition
-            def initialize(definition: DEFAULT_CONFIG)
-                @config = definition
-                @config.each do |key,value|
-                    self.define_singleton_method "#{key.to_s}=".to_sym do |val|
-                        key = __method__.to_s.chop.to_sym
-                        @config[key]=val
-                    end
-                    self.define_singleton_method key do 
-                        return @config[__method__]
-                    end
-                end
+      private
+
+      # Validation private sub method
+      # @raise ConfigError if proposed values haven't the good format and deeply in array
+      def validate_formats
+        @input.each do |spec, value|
+          unless DEFAULT_CONFIG_FORMATS[spec][:proc].call(value)
+            raise ConfigError,
+                  "#{spec} value #{DEFAULT_CONFIG_FORMATS[spec][:desc]}"
+          end
+
+          next unless DEFAULT_CONFIG_FORMATS[spec].include? :list
+
+          value.each do |item|
+            unless DEFAULT_CONFIG_FORMATS[spec][:list].include? item
+              raise ConfigError,
+                    "#{spec} value must be in #{DEFAULT_CONFIG_FORMATS[spec][:list]}"
             end
+          end
         end
+      end
+
+      # adapter for exception key in config String to Constant Class Name if need
+      # @note by reference
+      def format_exceptions
+        @config[:exceptions].map! { |item| item.instance_of?(String) ? Object.const_get(item) : item }
+      end
+    end
+
+    # Config Data mapper for block yielding methods for configuration
+    # @note work for/with {Sc4ry::Circuits.configure} and {Sc4ry::Circuits.register} when block given
+    class ConfigMapper
+      include Sc4ry::Constants
 
+      # config from given definition passed in constructor
+      attr_reader :config
+
+      # the mapping constructor from a given definition or the default From Sc4ry config (Constant)
+      # @param [Hash] definition a config hash
+      # @note creating dynamically accessors on config record given in definition
+      def initialize(definition: DEFAULT_CONFIG)
+        @config = definition
+        @config.each do |key, _value|
+          define_singleton_method "#{key}=".to_sym do |val|
+            key = __method__.to_s.chop.to_sym
+            @config[key] = val
+          end
+          define_singleton_method key do
+            return @config[__method__]
+          end
+        end
+      end
     end
-end
+  end
+end

data/lib/sc4ry/constants.rb

@@ -1,51 +1,55 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
-    # Sc4ry::Constants module
-    # @note namespace
-    module Constants
-
-        # notifiers available in Sc4ry natively
-        CURRENT_NOTIFIERS = [:prometheus, :mattermost]
-
-        # the Sc4ry default config entries and values
-        DEFAULT_CONFIG = { 
-            :max_failure_count => 5,
-            :timeout_value => 20,
-            :timeout => false,
-            :max_timeout_count => 5,
-            :max_time => 10,
-            :max_overtime_count => 3,
-            :check_delay => 30,
-            :notifiers => [],
-            :forward_unknown_exceptions => true,
-            :raise_on_opening => false,
-            :exceptions => [StandardError, RuntimeError]
-            }
+  # Sc4ry::Constants module
+  # @note namespace
+  module Constants
+    # notifiers available in Sc4ry natively
+    CURRENT_NOTIFIERS = %i[prometheus mattermost]
 
-        # Default config supported entries with format and Proc checker for {Sc4ry::Config::Validator}
-        DEFAULT_CONFIG_FORMATS = { 
-            :max_failure_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"}, 
-            :timeout_value => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
-            :timeout => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
-            :max_timeout_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
-            :max_time => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
-            :max_overtime_count => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
-            :check_delay => {:proc => Proc::new {|item| item.class == Integer}, :desc => "must be an Integer"},
-            :notifiers => {
-                :proc => Proc::new {|item| 
-                  item.class == Array and item.select {|val|  val.class == Symbol }.size == item.size
-                  }, 
-                :desc => "must be an Array of Symbol",
-                :list => CURRENT_NOTIFIERS},
-            :forward_unknown_exceptions => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
-            :raise_on_opening => {:proc => Proc::new {|item| [true,false].include? item}, :desc => "must be a Boolean"},
-            :exceptions => {
-                :proc => Proc::new {|item| item.class == Array and item.select {|val|  
-                    [Class,String].include? val.class}.size == item.size
-                }, 
-                :desc => "must be an Array of Exception(Class) or String"}
-            }
+    # the Sc4ry default config entries and values
+    DEFAULT_CONFIG = {
+      max_failure_count: 5,
+      timeout_value: 20,
+      timeout: false,
+      max_timeout_count: 5,
+      max_time: 10,
+      max_overtime_count: 3,
+      check_delay: 30,
+      notifiers: [],
+      forward_unknown_exceptions: true,
+      raise_on_opening: false,
+      exceptions: [StandardError, RuntimeError]
+    }
 
-    end
-end
+    # Default config supported entries with format and Proc checker for {Sc4ry::Config::Validator}
+    DEFAULT_CONFIG_FORMATS = {
+      max_failure_count: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      timeout_value: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      timeout: { proc: proc { |item| [true, false].include? item }, desc: 'must be a Boolean' },
+      max_timeout_count: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      max_time: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      max_overtime_count: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      check_delay: { proc: proc { |item| item.instance_of?(Integer) }, desc: 'must be an Integer' },
+      notifiers: {
+        proc: proc do |item|
+                item.instance_of?(Array) and item.select { |val| val.instance_of?(Symbol) }.size == item.size
+              end,
+        desc: 'must be an Array of Symbol',
+        list: CURRENT_NOTIFIERS
+      },
+      forward_unknown_exceptions: { proc: proc { |item| [true, false].include? item }, desc: 'must be a Boolean' },
+      raise_on_opening: { proc: proc { |item| [true, false].include? item }, desc: 'must be a Boolean' },
+      exceptions: {
+        proc: proc do |item|
+                item.instance_of?(Array) and item.select do |val|
+                  [Class, String].include? val.class
+                end.size == item.size
+              end,
+        desc: 'must be an Array of Exception(Class) or String'
+      }
+    }
+  end
+end

data/lib/sc4ry/dependencies.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # rubygems depends
 require 'rest-client'
 require 'prometheus/client'
@@ -6,7 +8,7 @@ require 'redis'
 require 'version'
 
 # Stdlibs depends
-require 'logger' 
+require 'logger'
 require 'timeout'
 require 'forwardable'
 require 'singleton'
@@ -17,7 +19,6 @@ require 'uri'
 require 'json'
 require 'yaml'
 
-
 # Sc4ry internal depends
 require_relative 'helpers'
 require_relative 'exceptions'
@@ -31,4 +32,3 @@ require_relative 'backends/init'
 require_relative 'store'
 require_relative 'run_controller'
 require_relative 'circuits'
-

data/lib/sc4ry/exceptions.rb

@@ -1,50 +1,44 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
+  # Sc4ry::Exceptions module
+  # @note namespace
+  module Exceptions
+    # Exception use in {Sc4ry::Circuits} when running circuit {Sc4ry::Circuits::run}
+    class CircuitBreaked < StandardError
+      def initialize(msg = 'Circuit just opened')
+        super(msg)
+      end
+    end
 
-    # Sc4ry::Exceptions module
-    # @note namespace
-    module Exceptions
-
-        # Exception use in {Sc4ry::Circuits} when running circuit {Sc4ry::Circuits::run} 
-        class CircuitBreaked < StandardError
-            def initialize(msg="Circuit just opened")
-                super(msg)
-              end
-        
-        end
-
-        # Generic Exception use in {Sc4ry::Circuits} 
-        class Sc4ryGenericError < StandardError
-            def initialize(msg="")
-                super(msg)
-              end
-        
-        end
+    # Generic Exception use in {Sc4ry::Circuits}
+    class Sc4ryGenericError < StandardError
+      def initialize(msg = '')
+        super(msg)
+      end
+    end
 
-        # Exception use in {Sc4ry::Store} or/and {Sc4ry::Backend} on data string issues
-        class Sc4ryBackendError < StandardError
-            def initialize(msg="")
-                super(msg)
-              end
-        
-        end
+    # Exception use in {Sc4ry::Store} or/and {Sc4ry::Backend} on data string issues
+    class Sc4ryBackendError < StandardError
+      def initialize(msg = '')
+        super(msg)
+      end
+    end
 
-        # Exception use in {Sc4ry::Notifiers} on notification issues
-        class Sc4ryNotifierError < StandardError
-            def initialize(msg="")
-                super(msg)
-              end
-        
-        end
-        
-        # Exception use in {Sc4ry::Circuits} on config management issues
-        class ConfigError < StandardError
-            def initialize(msg="")
-                super(msg)
-              end
-        
-        end
+    # Exception use in {Sc4ry::Notifiers} on notification issues
+    class Sc4ryNotifierError < StandardError
+      def initialize(msg = '')
+        super(msg)
+      end
+    end
 
+    # Exception use in {Sc4ry::Circuits} on config management issues
+    class ConfigError < StandardError
+      def initialize(msg = '')
+        super(msg)
+      end
     end
-end
+  end
+end

data/lib/sc4ry/exporters/init.rb

@@ -1 +1,3 @@
-Dir[File.dirname(__FILE__) + '/*.rb'].sort.each { |file| require file unless File.basename(file) == 'init.rb' }
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/*.rb"].sort.each { |file| require file unless File.basename(file) == 'init.rb' }

data/lib/sc4ry/helpers.rb

@@ -1,22 +1,22 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
-
-# Sc4ry::Helpers module
-# @note namespace
-   module Helpers
-
+  # Sc4ry::Helpers module
+  # @note namespace
+  module Helpers
     # class method (module) to help logging messages
     # @param [Symbol] target a specific logger, restored old after
     # @param [Symbol] level (default :info) a logging level (see Logger Stdlib)
     # @param [String] message your message
     # @return [Boolean]
-    def Helpers.log(target: nil, level: :info, message:  )
-      save = Sc4ry::Loggers.current 
+    def self.log(message:, target: nil, level: :info)
+      save = Sc4ry::Loggers.current
       Sc4ry::Loggers.current = target if target
-      Sc4ry::Loggers.get.send level, "Sc4ry : #{message}"  
+      Sc4ry::Loggers.get.send level, "Sc4ry : #{message}"
       Sc4ry::Loggers.current = save
-      return true
+      true
     end
 
     # TCP/IP service checker
@@ -25,39 +25,34 @@ module Sc4ry
     # @option options [String] :host hostname
     # @option options [String] :port TCP port
     # @option options [String] :url full URL, priority on :host and :port
-    def Helpers.verify_service(options ={})
-      begin
-        if options[:url] then
-          uri = URI.parse(options[:url])
-          host = uri.host
-          port = uri.port
-        else
-          host = options[:host]
-          port = options[:port]
-        end
-        Timeout::timeout(1) do
-          begin
-            s = TCPSocket.new(host, port)
-            s.close
-            return true
-          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            return false
-          end
-        end
-      rescue Timeout::Error
+    def self.verify_service(options = {})
+      if options[:url]
+        uri = URI.parse(options[:url])
+        host = uri.host
+        port = uri.port
+      else
+        host = options[:host]
+        port = options[:port]
+      end
+      Timeout.timeout(1) do
+        s = TCPSocket.new(host, port)
+        s.close
+        return true
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
         return false
       end
+    rescue Timeout::Error
+      false
     end
 
     # class method (module) to help send notifiesby Sc4ry::Notifiers
     # @param [Hash] options a Notifying structure
     # @return [Boolean]
-    def Helpers.notify(options = {})
+    def self.notify(options = {})
       Sc4ry::Notifiers.list.each do |record|
         notifier = Sc4ry::Notifiers.get name: record
-        notifier[:class].notify(options) if options[:config][:notifiers].include? record 
+        notifier[:class].notify(options) if options[:config][:notifiers].include? record
       end
     end
-
-  end 
-end
+  end
+end

data/lib/sc4ry/logger.rb

@@ -1,66 +1,67 @@
+# frozen_string_literal: true
+
 # Sc4ry module
 # @note namespace
 module Sc4ry
-
   # Sc4ry loggers Factory/provider
   # @note must be accessed by [Sc4ry::Circuits.loggers]
   class Loggers
-    
-    @@loggers = {:stdout => ::Logger.new(STDOUT)}
+    @@loggers = { stdout: ::Logger.new($stdout) }
     @@current = :stdout
-    
+
     # give the list of available loggers (initially internal Sc4ry logger )
     # @return [Array] of [symbol] the list of defined loggers
-    # @note default :stdout => ::Logger(STDOUT) from Ruby Stdlib
+    # @note default :stdout => ::Logger($stdout) from Ruby Stdlib
     # @example usage
     #    include Sc4ry
     #    Circuits.loggers.list_available.each {|logger| puts logger }
-    def Loggers.list_available
-      return @@loggers.keys
+    def self.list_available
+      @@loggers.keys
     end
-    
+
     # return the current logger name (initially :stdtout )
     # @return [symbol] the name of the logger
     # @example usage
     #    include Sc4ry
     #    puts Circuits.loggers.current
-    def Loggers.current
-      return @@current
+    def self.current
+      @@current
     end
-    
+
     # return the current logger Object (initially internal Sc4ry Stdlib Logger on STDOUT )
     # @return [symbol] the name of the logger
     # @example usage
     #    include Sc4ry
     #    Circuits.loggers.get :stdout
-    def Loggers.get
-      return @@loggers[@@current]
+    def self.get
+      @@loggers[@@current]
     end
-    
-    # Set the current logger 
+
+    # Set the current logger
     # @param [Symbol] sym the name of the logger
     # @return [symbol] the name of the logger updated
     # @example usage
     #    include Sc4ry
     #    Circuits.loggers.current = :newlogger
-    def Loggers.current=(sym)
+    def self.current=(sym)
       raise "Logger not define : #{sym}" unless @@loggers.keys.include? sym
+
       @@current = sym
-      return @@current
+      @@current
     end
-    
+
     # register un new logger
     # @param [Symbol] name the name of the new logger
     # @param [Object] instance the new logger object
     # raise Sc4ry::Exceptions::Sc4ryGenericError if name is not a Symbol
     # @example usage
     #    include Sc4ry
-    #    Circuits.loggers.register name: :newlogger, instance: Logger::new('/path/to/my.log') 
-    def Loggers.register(name: , instance: )
-      raise Sc4ry::Exceptions::Sc4ryGenericError, "name: keyword must be a Symbol" unless name.class == Symbol
+    #    Circuits.loggers.register name: :newlogger, instance: Logger::new('/path/to/my.log')
+    def self.register(name:, instance:)
+      raise Sc4ry::Exceptions::Sc4ryGenericError, 'name: keyword must be a Symbol' unless name.instance_of?(Symbol)
+
       @@loggers[name] = instance
-      return name
+      name
     end
-    
   end
 end