eco-helpers 3.0.37 → 3.1.2

data/lib/eco/api/common/session/logger/cache.rb

@@ -1,101 +1,99 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class Logger
-          class Cache
-            LEVELS   = %w[UNKNOWN FATAL ERROR WARN INFO DEBUG].freeze
-            CHANNELS = Logger::CHANNELS.map(&:to_s).map(&:upcase).freeze
-
-            def initialize
-              reset
-            end
-
-            def level(level)
-              cache[to_level(level)] ||= []
-            end
-
-            def add(level, datetime, message, formatted)
-              Logger::Log.new(level, datetime, message, formatted).tap do |log|
-                self.level(level).push(log)
-              end
-            end
-
-            def cache
-              @cache ||= {}
-            end
-
-            def reset(level: nil, start_time: nil, end_time: nil)
-              where(start_time, end_time) do |cond|
-                to_levels(level).map do |lev|
-                  self.level(lev).reject(&cond)
-                end
-              end
-              self
-            end
-
-            def logs(level: nil, start_time: nil, end_time: nil)
-              where(start_time, end_time) do |cond|
-                to_levels(level).map do |lev|
-                  self.level(lev).select(&cond)
-                end.flatten
-              end.sort
-            end
-
-            private
-
-            def where(start_time, end_time)
-              tstart    = to_datetime(start_time)
-              tend      = to_datetime(end_time)
-              condition = proc do |log|
-                next true unless tstart || tend
-
-                log.after?(tstart) && log.before?(tend)
-              end
-
-              yield(condition)
-            end
-
-            def to_datetime(value)
-              return unless value
-
-              Time.parse(value)
-            end
-
-            def to_levels(value)
-              levels = [value].flatten.map {|v| to_level(v)}.compact
-              return levels unless levels.empty?
-
-              valid_levels
-            end
-
-            def to_level(value)
-              nil_or_upcase(value).tap do |out|
-                valid_level!(out)
-              end
-            end
-
-            def valid_level!(str)
-              return true unless str
-              return true if valid_levels.any? {|lev| str == lev}
-
-              msg = "Unknown level #{str}. Should be one of #{LEVELS}"
-              raise ArgumentError, msg
-            end
-
-            def nil_or_upcase(value)
-              value = value.to_s.upcase if value
-              return yield(value) if block_given?
-
-              value
-            end
-
-            def valid_levels
-              @valid_levels ||= self.class::LEVELS | self.class::CHANNELS
-            end
-          end
+class Eco::API::Common::Session::Logger
+  class Cache
+    LEVELS   = %w[UNKNOWN FATAL ERROR WARN INFO DEBUG].freeze
+    CHANNELS = Eco::API::Common::Session::Logger::CHANNELS.
+      map(&:to_s).map(&:upcase).freeze
+
+    def initialize
+      reset
+    end
+
+    def level(level)
+      cache[to_level(level)] ||= []
+    end
+
+    def add(level, datetime, message, formatted)
+      Eco::API::Common::Session::Logger::Log.new(
+        level,
+        datetime,
+        message,
+        formatted
+      ).tap do |log|
+        self.level(level).push(log)
+      end
+    end
+
+    def cache
+      @cache ||= {}
+    end
+
+    def reset(level: nil, start_time: nil, end_time: nil)
+      where(start_time, end_time) do |cond|
+        to_levels(level).map do |lev|
+          self.level(lev).reject(&cond)
         end
       end
+      self
+    end
+
+    def logs(level: nil, start_time: nil, end_time: nil)
+      where(start_time, end_time) do |cond|
+        to_levels(level).map do |lev|
+          self.level(lev).select(&cond)
+        end.flatten
+      end.sort
+    end
+
+    private
+
+    def where(start_time, end_time)
+      tstart    = to_datetime(start_time)
+      tend      = to_datetime(end_time)
+      condition = proc do |log|
+        next true unless tstart || tend
+
+        log.after?(tstart) && log.before?(tend)
+      end
+
+      yield(condition)
+    end
+
+    def to_datetime(value)
+      return unless value
+
+      Time.parse(value)
+    end
+
+    def to_levels(value)
+      levels = [value].flatten.map {|v| to_level(v)}.compact
+      return levels unless levels.empty?
+
+      valid_levels
+    end
+
+    def to_level(value)
+      nil_or_upcase(value).tap do |out|
+        valid_level!(out)
+      end
+    end
+
+    def valid_level!(str)
+      return true unless str
+      return true if valid_levels.any? {|lev| str == lev}
+
+      msg = "Unknown level #{str}. Should be one of #{LEVELS}"
+      raise ArgumentError, msg
+    end
+
+    def nil_or_upcase(value)
+      value = value.to_s.upcase if value
+      return yield(value) if block_given?
+
+      value
+    end
+
+    def valid_levels
+      @valid_levels ||= self.class::LEVELS | self.class::CHANNELS
     end
   end
 end

data/lib/eco/api/common/session/logger/channels.rb

@@ -1,43 +1,35 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class Logger
-          module Channels
-            CHANNELS = %i[general].freeze
+class Eco::API::Common::Session::Logger
+  module Channels
+    CHANNELS = %i[general].freeze
 
-            class << self
-              def included(base)
-                super
+    class << self
+      def included(base)
+        super
 
-                base.extend ClassMethods
-              end
-            end
-
-            module ClassMethods
-              def channels!(&def_block)
-                str = 'Block with channel implementation expected. None given.'
-                raise ArgumentError, str unless block_given?
-
-                channels.each do |channel|
-                  meth = channel.to_s.downcase.to_sym
+        base.extend ClassMethods
+      end
+    end
 
-                  define_method(meth) do |msg = nil, &block|
-                    # `block` instead of `&block`
-                    instance_exec(meth, msg, block, &def_block)
-                  end
-                end
-              end
+    module ClassMethods
+      def channels!(&def_block)
+        str = 'Block with channel implementation expected. None given.'
+        raise ArgumentError, str unless block_given?
 
-              private
+        channels.each do |channel|
+          meth = channel.to_s.downcase.to_sym
 
-              def channels
-                self::CHANNELS
-              end
-            end
+          define_method(meth) do |msg = nil, &block|
+            # `block` instead of `&block`
+            instance_exec(meth, msg, block, &def_block)
           end
         end
       end
+
+      private
+
+      def channels
+        self::CHANNELS
+      end
     end
   end
 end

data/lib/eco/api/common/session/logger/log.rb

@@ -1,49 +1,41 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class Logger
-          class Log
-            attr_accessor :level, :datetime, :message, :formatted
-
-            def initialize(level, datetime, message, formatted)
-              @level     = level
-              @datetime  = datetime
-              @message   = message
-              @formatted = formatted
-            end
-
-            def to_s
-              formatted
-            end
-
-            def <=>(other)
-              datetime <=> other.datetime
-            end
-
-            def before?(value)
-              return true unless value
-
-              datetime <= to_datetime(value)
-            end
-
-            def after?(value)
-              return true unless value
-
-              datetime >= to_datetime(value)
-            end
-
-            private
-
-            def to_datetime(value)
-              return value if value.is_a?(Time)
-              return       unless value
-
-              Time.parse(value)
-            end
-          end
-        end
-      end
+class Eco::API::Common::Session::Logger
+  class Log
+    attr_accessor :level, :datetime, :message, :formatted
+
+    def initialize(level, datetime, message, formatted)
+      @level     = level
+      @datetime  = datetime
+      @message   = message
+      @formatted = formatted
+    end
+
+    def to_s
+      formatted
+    end
+
+    def <=>(other)
+      datetime <=> other.datetime
+    end
+
+    def before?(value)
+      return true unless value
+
+      datetime <= to_datetime(value)
+    end
+
+    def after?(value)
+      return true unless value
+
+      datetime >= to_datetime(value)
+    end
+
+    private
+
+    def to_datetime(value)
+      return value if value.is_a?(Time)
+      return       unless value
+
+      Time.parse(value)
     end
   end
 end

data/lib/eco/api/common/session/logger.rb

@@ -1,74 +1,70 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class Logger < Eco::Language::BasicLogger
-          TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'.freeze
-
-          require_relative 'logger/channels'
-          include Channels
-
-          channels! do |channel, message = nil, block|
-            format_proc(console: true) do |severity, datetime, msg, formatted_msg|
-              cache.add(severity, datetime, msg, formatted_msg)
-            end.call(channel, Time.now, 'prog_name', message || block.call)
-          end
+module Eco::API::Common::Session
+  class Logger < Eco::Language::BasicLogger
+    TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'.freeze
 
-          attr_reader :cache
+    require_relative 'logger/channels'
+    include Channels
 
-          def initialize(file_level: ::Logger::DEBUG, log_file: nil, enviro: nil, **kargs)
-            super(**kargs)
+    channels! do |channel, message = nil, block|
+      format_proc(console: true) do |severity, datetime, msg, formatted_msg|
+        cache.add(severity, datetime, msg, formatted_msg)
+      end.call(channel, Time.now, 'prog_name', message || block.call)
+    end
 
-            msg = "Required Environment object (enviro:). Given: #{enviro.class}"
-            raise ArgumentError, msg if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+    attr_reader :cache
 
-            @enviro = enviro
-            @cache  = Logger::Cache.new
+    def initialize(file_level: ::Logger::DEBUG, log_file: nil, enviro: nil, **kargs)
+      super(**kargs)
 
-            if (log_file = fetch_log_file(log_file))
-              loggers[:file] = ::Logger.new(log_file).tap do |logger|
-                logger.formatter = format_proc(console: false) do |severity, datetime, msg, formatted_msg|
-                  cache.add(severity, datetime, msg, formatted_msg)
-                end
+      msg = "Required Environment object (enviro:). Given: #{enviro.class}"
+      raise ArgumentError, msg if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
 
-                logger.level = file_level
-              end
-            end
+      @enviro = enviro
+      @cache  = Eco::API::Common::Session::Logger::Cache.new
 
-            if_config(:timestamp_console) { |value| self.timestamp  = value }
-            if_config(:console_level)     { |value| self.level      = value }
-            if_config(:file_level)        { |value| self.file_level = value }
+      if (log_file = fetch_log_file(log_file))
+        loggers[:file] = ::Logger.new(log_file).tap do |logger|
+          logger.formatter = format_proc(
+            console: false
+          ) do |severity, datetime, msg, formatted_msg|
+            cache.add(severity, datetime, msg, formatted_msg)
           end
 
-          def file_level=(value)
-            loggers[:file]&.level = value
-          end
+          logger.level = file_level
+        end
+      end
 
-          private
+      if_config(:timestamp_console) { |value| self.timestamp  = value }
+      if_config(:console_level)     { |value| self.level      = value }
+      if_config(:file_level)        { |value| self.file_level = value }
+    end
 
-          def config(attr)
-            return unless (cnf = @enviro&.config&.logger)
+    def file_level=(value)
+      loggers[:file]&.level = value
+    end
 
-            cnf.send(attr) if cnf.respond_to?(attr)
-          end
+    private
 
-          def if_config(attr)
-            return if (value = config(attr)).nil?
+    def config(attr)
+      return unless (cnf = @enviro&.config&.logger)
 
-            yield(value) if block_given?
-            value
-          end
+      cnf.send(attr) if cnf.respond_to?(attr)
+    end
 
-          def fetch_log_file(log_file)
-            if log_file ||= config(:file)
-              log_file = @enviro.file_manager.dir.file(log_file) if @enviro
-              FileManager.create_directory(log_file, includes_file: true)
-            end
+    def if_config(attr)
+      return if (value = config(attr)).nil?
 
-            log_file
-          end
-        end
+      yield(value) if block_given?
+      value
+    end
+
+    def fetch_log_file(log_file)
+      if log_file ||= config(:file)
+        log_file = @enviro.file_manager.dir.file(log_file) if @enviro
+        FileUtils.mkdir_p(File.dirname(log_file))
       end
+
+      log_file
     end
   end
 end

data/lib/eco/api/common/session/mailer/aws_provider.rb

@@ -1,84 +1,77 @@
 # rubocop:disable Naming/MethodParameterName
-module Eco
-  module API
-    module Common
-      module Session
-        class Mailer
-          class AwsProvider < ProviderBase
-            def send_mail(subject:, body:, to: nil, cc: nil, bcc: nil)
-              ses.send_email(
-                destination: fetch_destination(to: to, cc: cc, bcc: bcc),
-                source:      fetch_from,
-                message:     {
-                  subject: {
-                    charset: 'UTF-8',
-                    data:    subject
-                  },
-                  body:    {
-                    # NOTE: (html) will let you send html instead
-                    # you can use both at once if you like
-                    text: {
-                      charset: 'UTF-8',
-                      data:    body
-                    }
-                  }
-                }
-              )
-            end
+class Eco::API::Common::Session::Mailer
+  class AwsProvider < ProviderBase
+    def send_mail(subject:, body:, to: nil, cc: nil, bcc: nil)
+      ses.send_email(
+        destination: fetch_destination(to: to, cc: cc, bcc: bcc),
+        source:      fetch_from,
+        message:     {
+          subject: {
+            charset: 'UTF-8',
+            data:    subject
+          },
+          body:    {
+            # NOTE: (html) will let you send html instead
+            # you can use both at once if you like
+            text: {
+              charset: 'UTF-8',
+              data:    body
+            }
+          }
+        }
+      )
+    end
 
-            # @return [Boolean] whether or not the mailer is configured for usage.
-            def configured?
-              fetch_access_key_id && fetch_secret_access_key && fetch_region
-            end
+    # @return [Boolean] whether or not the mailer is configured for usage.
+    def configured?
+      fetch_access_key_id && fetch_secret_access_key && fetch_region
+    end
 
-            private
+    private
 
-            def credentials
-              @credentials ||= {
-                id:  'AWS_ACCESS_KEY_ID',
-                key: 'AWS_SECRET_ACCESS_KEY'
-              }
-            end
+    def credentials
+      @credentials ||= super.merge({
+        id:     'AWS_ACCESS_KEY_ID',
+        key:    'AWS_SECRET_ACCESS_KEY',
+        region: 'AWS_REGION'
+      })
+    end
 
-            def ses
-              require 'aws-sdk-ses'
-              @ses ||= Aws::SES::Client.new(
-                access_key_id:     fetch_access_key_id,
-                secret_access_key: fetch_secret_access_key,
-                region:            fetch_region
-              )
-            rescue StandardError => err
-              log(:error) {
-                "Trying to send an email with wrong email configuration: #{err}"
-              }
-            end
+    def ses
+      require 'aws-sdk-ses'
+      @ses ||= Aws::SES::Client.new(
+        access_key_id:     fetch_access_key_id,
+        secret_access_key: fetch_secret_access_key,
+        region:            fetch_region
+      )
+    rescue StandardError => err
+      log(:error) {
+        "Trying to send an email with wrong email configuration: #{err}"
+      }
+    end
 
-            def fetch_destination(to: nil, cc: nil, bcc: nil)
-              {
-                to_addresses: [fetch_to(to)].flatten.compact.uniq
-              }.tap do |dest|
-                cc  = [cc].flatten.compact.uniq
-                bcc = [bcc].flatten.compact.uniq
+    def fetch_destination(to: nil, cc: nil, bcc: nil)
+      {
+        to_addresses: [fetch_to(to)].flatten.compact.uniq
+      }.tap do |dest|
+        cc  = [cc].flatten.compact.uniq
+        bcc = [bcc].flatten.compact.uniq
 
-                dest.merge!(cc_addresses: cc)   unless cc.empty?
-                dest.merge!(bcc_addresses: bcc) unless bcc.empty?
-              end
-            end
+        dest.merge!(cc_addresses: cc)   unless cc.empty?
+        dest.merge!(bcc_addresses: bcc) unless bcc.empty?
+      end
+    end
 
-            def fetch_region
-              config.mailer.region || ENV['AWS_REGION']
-            end
+    def fetch_region
+      config.mailer.region || env_credential(:region)
+    end
 
-            def fetch_server
-              config.mailer.server
-            end
+    def fetch_server
+      config.mailer.server
+    end
 
-            def fetch_message_id_domain
-              config.mailer.message_id_domain
-            end
-          end
-        end
-      end
+    def fetch_message_id_domain
+      config.mailer.message_id_domain
     end
   end
 end