eco-helpers 3.0.37 → 3.1.1

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

@@ -1,73 +1,67 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class Environment
-          attr_reader :config, :session
-          attr_reader :file_manager, :logger
+module Eco::API::Common::Session
+  class Environment
+    attr_reader :config, :session
+    attr_reader :file_manager, :logger
 
-          alias_method :fm, :file_manager
+    alias_method :fm, :file_manager
 
-          #@param init [Eco::API::Common::Session::Environment] object to ini the session environment
-          #@param session [Eco::API::Session, nil] the current session
-          def initialize(init = {}, session:)
-            init = init.conf if init.is_a?(Environment)
+    #@param init [Eco::API::Common::Session::Environment] object to ini the session environment
+    #@param session [Eco::API::Session, nil] the current session
+    def initialize(init = {}, session:)
+      init = init.conf if init.is_a?(Environment)
 
-            msg = "Expected object Eco::API::Session::Config or Environment. Given: #{init}"
-            raise msg unless init.is_a?(Eco::API::Session::Config)
+      msg = "Expected object Eco::API::Session::Config or Environment. Given: #{init}"
+      raise msg unless init.is_a?(Eco::API::Session::Config)
 
-            invalid_session = session && !session.is_a?(Eco::API::Session)
-            raise "Expected an Eco::API::Session object. Given: #{session}" if invalid_session
+      invalid_session = session && !session.is_a?(Eco::API::Session)
+      raise "Expected an Eco::API::Session object. Given: #{session}" if invalid_session
 
-            @config       = init
-            @session      = session
-            @file_manager = Eco::API::Common::Session::FileManager.new(enviro: self)
-            @logger       = Eco::API::Common::Session::Logger.new(enviro: self)
-          end
+      @config       = init
+      @session      = session
+      @file_manager = Eco::API::Common::Session::FileManager.new(enviro: self)
+      @logger       = Eco::API::Common::Session::Logger.new(enviro: self)
+    end
 
-          def mailer
-            return nil unless mailer?
-            @mailer ||= Eco::API::Common::Session::Mailer.new(enviro: self)
-          end
+    def mailer
+      return nil unless mailer?
+      @mailer ||= Eco::API::Common::Session::Mailer.new(enviro: self)
+    end
 
-          def mailer?
-            config.mailer.configured?
-          end
+    def mailer?
+      config.mailer.configured?
+    end
 
-          def sftp
-            return nil unless sftp?
-            @sftp ||= Eco::API::Common::Session::SFTP.new(enviro: self)
-          end
+    def sftp
+      return nil unless sftp?
+      @sftp ||= Eco::API::Common::Session::SFTP.new(enviro: self)
+    end
 
-          def sftp?
-            config.sftp.configured?
-          end
+    def sftp?
+      config.sftp.configured?
+    end
 
-          def s3uploader
-            return nil unless s3uploader?
-            @s3uploader ||= Eco::API::Common::Session::S3Uploader.new(enviro: self)
-          end
+    def s3uploader
+      return nil unless s3uploader?
+      @s3uploader ||= Eco::API::Common::Session::S3Uploader.new(enviro: self)
+    end
 
-          def s3uploader?
-            config.s3storage.configured?
-          end
+    def s3uploader?
+      config.s3storage.configured?
+    end
 
-          def api(version: nil)
-            config.api(logger, version: version)
-          end
+    def api(version: nil)
+      config.api(logger, version: version)
+    end
 
-          def api?(version:)
-            config.apis.active_api.version_available?(version)
-          end
+    def api?(version:)
+      config.apis.active_api.version_available?(version)
+    end
 
-          # Shortcut to logger.
-          def log(level, &block)
-            return unless logger.respond_to?(:level)
+    # Shortcut to logger.
+    def log(level, &block)
+      return unless logger.respond_to?(:level)
 
-            logger&.send(level, &block)
-          end
-        end
-      end
+      logger&.send(level, &block)
     end
   end
 end

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

@@ -1,140 +1,137 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class FileManager
-          include Eco::Data::Files
-          include Eco::Language::AuxiliarLogger
-
-          attr_reader :dir, :dir_path
-          attr_accessor :timestamp_pattern
-
-          def initialize(init = {}, enviro: nil)
-            @enviro = enviro
-            init    = @enviro.config if @enviro && init.empty?
-
-            @timestamp_pattern = init.files.timestamp_pattern || DEFAULT_TIMESTAMP_PATTERN
-            self.dir_path      = init.working_directory || Dir.pwd
-          end
-
-          def dir_path=(value)
-            @dir      = Eco::Data::Files::Directory.new(value)
-            @dir_path = @dir.create
-          rescue StandardError => err
-            log(:error) {
-              "could not create or make any sense of directory '#{value}': #{err}"
-            }
-          end
-
-          def logger
-            @enviro&.logger || super
-          end
-
-          #####    FILE   #####
-          def file(filename, should_exist: false)
-            dir.file(filename, should_exist: should_exist)
-          end
-
-          def newest(filename)
-            dir.newest_file(file: filename)
-          end
-
-          def file_content(filename, mode: nil)
-            file = dir.file(filename, should_exist: true)
-
-            unless file
-              log(:error) {
-                "Can't read from file '#{filename}' because it does not exist."
-              }
-              return nil
-            end
-
-            log(:debug) { "Reading from file '#{file}'" }
-            mode ? File.read(file, mode: mode) : File.read(file)
-          end
-
-          def load_json(filename)
-            file = dir.file(filename, should_exist: true)
-
-            unless file
-              log(:error) {
-                "Can't read from file '#{filename}' because it does not exist."
-              }
-              return nil
-            end
-
-            fd = File.open(file)
-            JSON.load fd # rubocop:disable Security/JSONLoad
-          rescue JSON::ParserError => e
-            pp "Parsing error on file #{file}"
-            raise e
-          ensure
-            fd&.close
-          end
-
-          def touch(filename, modifier = :no_stamp, mode: :string)
-            save("", filename, modifier, mode: mode)
-          end
-
-          def save_json(data, filename, modifier = :no_stamp)
-            return save(data.to_json, filename, modifier) unless data.is_a?(Array)
-
-            file = filename_for(filename, modifier)
-            FileManager.create_directory(
-              FileManager.file_fullpath(file)
-            )
-
-            log(:debug) { "Writting to file '#{file}'" }
-
-            mode = mode == :binary ? 'wb' : 'w'
-
-            File.open(file, mode) do |fd|
-              first = true
-
-              fd << '['
-              data.each do |elem|
-                fd << "," unless first
-                first = false
-
-                fd << elem.to_json
-              end
-              fd << ']'
-            end
-
-            file
-          end
-
-          def save(content, filename, modifier = :no_stamp, mode: :string)
-            file = filename_for(filename, modifier)
-            FileManager.create_directory(
-              FileManager.file_fullpath(file)
-            )
-
-            log(:debug) { "Writting to file '#{file}'" }
-
-            mode = mode == :binary ? 'wb' : 'w'
-            File.open(file, mode) { |fd| fd << content }
-            file
-          end
-
-          # if the file does not exist, it creates it
-          def append(content, filename, mode: :string)
-            file = dir.file(filename)
-
-            log(:debug) { "Appending to file '#{file}'" }
-
-            mode = mode == :binary ? 'ab' : 'a'
-            File.open(file, mode) { |fd| fd << "#{content}\n" }
-            file
-          end
-
-          def filename_for(filename, modifier = :no_stamp)
-            file = dir.file(filename)
-            file = FileManager.timestamp_file(file) if modifier == :timestamp
-            file
-          end
+module Eco::API::Common::Session
+  class FileManager
+    include Eco::Data::Files
+    include Eco::Language::AuxiliarLogger
+
+    attr_reader :dir, :dir_path
+    attr_accessor :timestamp_pattern
+
+    def initialize(init = {}, enviro: nil)
+      @enviro = enviro
+      init    = @enviro.config if @enviro && init.empty?
+
+      @timestamp_pattern   = init.files.timestamp_pattern
+      @timestamp_pattern ||= Eco::Data::Files::Timestamp::DEFAULT_TIMESTAMP
+      self.dir_path        = init.working_directory || Dir.pwd
+    end
+
+    def dir_path=(value)
+      @dir = Eco::Data::Files::Directory.new(value)
+      dir.create(exception: true)
+
+      @dir_path = dir.full_path
+    rescue StandardError => err
+      log(:error) {
+        "could not create or make any sense of directory '#{value}': #{err}"
+      }
+    end
+
+    def logger
+      return @enviro.logger if @enviro
+      super                 if defined?(super)
+    end
+
+    #####    FILE   #####
+
+    # @return [String] resolved filename path (relative or absolute)
+    def file(filename, should_exist: false)
+      dir.file(filename, should_exist: should_exist)
+    end
+
+    # @return [String] newest file by last modified date.
+    def newest(filename)
+      dir.newest_file(file: filename)
+    end
+
+    def file_content(filename, mode: nil)
+      file = dir.file(filename, should_exist: true)
+
+      unless file
+        log(:error) {
+          "Can't read from file '#{filename}' because it does not exist."
+        }
+        return nil
+      end
+
+      log(:debug) { "Reading from file '#{file}'" }
+      mode ? File.read(file, mode: mode) : File.read(file)
+    end
+
+    def load_json(filename)
+      file = dir.file(filename, should_exist: true)
+
+      unless file
+        log(:error) {
+          "Can't read from file '#{filename}' because it does not exist."
+        }
+        return nil
+      end
+
+      fd = File.open(file)
+      JSON.load fd # rubocop:disable Security/JSONLoad
+    rescue JSON::ParserError => e
+      pp "Parsing error on file #{file}"
+      raise e
+    ensure
+      fd&.close
+    end
+
+    def touch(filename, modifier = :no_stamp, mode: :string)
+      save('', filename, modifier, mode: mode)
+    end
+
+    def save_json(data, filename, modifier = :no_stamp)
+      return save(data.to_json, filename, modifier) unless data.is_a?(Array)
+
+      file = filename_for(filename, modifier)
+      FileUtils.mkdir_p(File.dirname(file))
+
+      log(:debug) { "Writting to file '#{file}'" }
+
+      mode = mode == :binary ? 'wb' : 'w'
+
+      File.open(file, mode) do |fd|
+        first = true
+
+        fd << '['
+        data.each do |elem|
+          fd << "," unless first
+          first = false
+
+          fd << elem.to_json
         end
+        fd << ']'
       end
+
+      file
+    end
+
+    def save(content, filename, modifier = :no_stamp, mode: :string)
+      file = filename_for(filename, modifier)
+      FileUtils.mkdir_p(File.dirname(file))
+
+      log(:debug) { "Writting to file '#{file}'" }
+
+      mode = mode == :binary ? 'wb' : 'w'
+      File.open(file, mode) { |fd| fd << content }
+      file
+    end
+
+    # if the file does not exist, it creates it
+    def append(content, filename, mode: :string)
+      file = dir.file(filename)
+
+      log(:debug) { "Appending to file '#{file}'" }
+
+      mode = mode == :binary ? 'ab' : 'a'
+      File.open(file, mode) { |fd| fd << "#{content}\n" }
+      file
+    end
+
+    def filename_for(filename, modifier = :no_stamp)
+      file = dir.file(filename)
+      file = FileManager.timestamp_file(file) if modifier == :timestamp
+      file
     end
   end
 end

data/lib/eco/api/common/session/helpers/prompt_user.rb

@@ -1,38 +1,31 @@
-module Eco
-  module API
-    module Common
-      module Session
-        module Helpers
-          module PromptUser
-            # Prompts user for input with option for default on timeout.
-            def prompt_user(question, default:, explanation: '', timeout: nil)
-              require 'timeout'
-              response =
-                if config.run_mode_remote?
-                  default
-                else
-                  puts explanation
-                  print "#{question} "
+module Eco::API::Common::Session::Helpers
+  module PromptUser
+    # Prompts user for input with option for default on timeout.
+    def prompt_user(question, default:, explanation: '', timeout: nil)
+      require 'timeout'
 
-                  if timeout
-                    begin
-                      Timeout::timeout(timeout) { STDIN.gets.chop }
-                    rescue Timeout::Error
-                      print default
-                      puts "\n"
-                      default
-                    end
-                  else
-                    STDIN.gets.chop
-                  end
-                end
-              return response unless block_given?
+      response =
+        if config.run_mode_remote?
+          default
+        else
+          puts explanation
+          print "#{question} "
 
-              yield(response)
+          if timeout
+            begin
+              Timeout.timeout(timeout) { $stdin.gets.chop }
+            rescue Timeout::Error
+              print default
+              puts "\n"
+              default
             end
+          else
+            $stdin.gets.chop
           end
         end
-      end
+      return response unless block_given?
+
+      yield(response)
     end
   end
 end

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

@@ -1,21 +1,16 @@
-require_relative 'helpers/prompt_user'
 
-module Eco
-  module API
-    module Common
-      module Session
-        module Helpers
-          class << self
-            def included(base)
-              base.send(:include, InstanceMethods)
-            end
-          end
+module Eco::API::Common::Session
+  module Helpers
+    require_relative 'helpers/prompt_user'
 
-          module InstanceMethods
-            include Helpers::PromptUser
-          end
-        end
+    class << self
+      def included(base)
+        base.send(:include, InstanceMethods)
       end
     end
+
+    module InstanceMethods
+      include Helpers::PromptUser
+    end
   end
 end

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

@@ -1,101 +1,94 @@
-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