eac_ruby_utils 0.62.0 → 0.66.0

data/lib/eac_ruby_utils/configs/base.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/blank_not_blank'
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/paths_hash'
-
-module EacRubyUtils
-  class Configs
-    class Base
-      enable_simple_cache
-
-      common_constructor :data, default: [{}] do
-        self.data = ::EacRubyUtils::PathsHash.new(data)
-      end
-
-      def []=(entry_key, entry_value)
-        write(entry_key, entry_value)
-      end
-
-      def [](entry_key)
-        read(entry_key)
-      end
-
-      def clear
-        replace({})
-      end
-
-      def read(entry_key)
-        return nil unless data.key?(entry_key)
-
-        data.fetch(entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-      end
-
-      def replace(new_data)
-        self.data = ::EacRubyUtils::PathsHash.new(new_data)
-      end
-
-      def write(entry_key, entry_value)
-        data[entry_key] = entry_value
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/configs/file.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/configs/base'
-require 'yaml'
-
-module EacRubyUtils
-  class Configs
-    class File < ::EacRubyUtils::Configs::Base
-      attr_reader :path, :options
-
-      # Valid options: [:autosave]
-      def initialize(path, options = {})
-        @path = path
-        @options = options.to_sym_keys_hash.freeze
-        super(raw_data_from_file)
-      end
-
-      def save
-        ::FileUtils.mkdir_p(::File.dirname(path))
-        ::File.write(path, data.to_h.to_yaml)
-      end
-
-      def load
-        replace(raw_data_from_file)
-      end
-
-      def write(entry_key, entry_value)
-        super
-        save if autosave?
-      end
-
-      def autosave?
-        options[:autosave] ? true : false
-      end
-
-      private
-
-      def raw_data_from_file
-        if ::File.exist?(path) && ::File.size(path).positive?
-          ::YAML.load_file(path)
-        else
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs'
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_ruby_utils/console/speaker'

data/lib/eac_ruby_utils/console/configs.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      require_sub __FILE__
-      enable_console_speaker
-
-      class << self
-        def entry_key_to_envvar_name(entry_key)
-          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
-        end
-      end
-
-      attr_reader :configs
-
-      def initialize(configs_key, options = {})
-        options.assert_argument(::Hash, 'options')
-        @configs = ::EacRubyUtils::Configs.new(configs_key, options.merge(autosave: true))
-      end
-
-      def read_password(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
-      end
-
-      def read_entry(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
-      end
-
-      def store_passwords?
-        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/configs/entry_reader.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/read_entry_options'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class EntryReader
-        enable_console_speaker
-
-        class << self
-          def entry_key_to_envvar_name(entry_key)
-            path = if entry_key.is_a?(::Array)
-                     entry_key
-                   else
-                     ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                   end
-            path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-                .gsub(/_{2,}/, '_').upcase
-          end
-        end
-
-        common_constructor :console_configs, :entry_key, :options do
-          self.options = ::EacRubyUtils::Console::Configs::ReadEntryOptions.new(options)
-        end
-
-        def read
-          %w[envvars storage console].each do |suffix|
-            value = send("read_from_#{suffix}")
-            return value if value.present?
-          end
-          return nil unless options[:required]
-
-          raise "No value found for entry \"#{entry_key}\""
-        end
-
-        def read_from_storage
-          console_configs.configs.read_entry(entry_key)
-        end
-
-        def read_from_envvars
-          return if options[:noenv]
-
-          env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-          return unless ENV.key?(env_entry_key)
-
-          ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-        end
-
-        def read_from_console
-          return if options[:noinput]
-
-          options[:before_input].if_present(&:call)
-          entry_value = looped_entry_value_from_input
-          console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
-          entry_value
-        end
-
-        private
-
-        def looped_entry_value_from_input
-          loop do
-            entry_value = entry_value_from_input(entry_key, options)
-            next if entry_value.blank?
-            next if options[:validator] && !options[:validator].call(entry_value)
-
-            return entry_value
-          end
-        end
-
-        def entry_value_from_input(entry_key, options)
-          entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                      options.request_input_options)
-          warn('Entered value is blank') if entry_value.blank?
-          entry_value
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/configs/password_entry_reader.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class PasswordEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs, entry_key, options = {})
-          super(console_configs, entry_key, options.merge(noecho: true,
-                                                          store: console_configs.store_passwords?))
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/configs/read_entry_options.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class ReadEntryOptions
-        enable_simple_cache
-        common_constructor :options do
-          self.options = options.to_h.symbolize_keys
-                                .assert_valid_keys(DEFAULT_VALUES.keys).freeze
-        end
-
-        DEFAULT_VALUES = {
-          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, store: true, validator: nil
-        }.freeze
-
-        delegate :to_h, to: :options
-
-        def [](key)
-          values.fetch(key.to_sym)
-        end
-
-        def request_input_options
-          values.slice(:bool, :list, :noecho)
-        end
-
-        private
-
-        def values_uncached
-          consumer = options.to_options_consumer
-          r = {}
-          DEFAULT_VALUES.each do |key, default_value|
-            value = consumer.consume(key)
-            value = default_value if value.nil?
-            r[key] = value
-          end
-          consumer.validate
-          r
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/configs/store_passwords_entry_reader.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class StorePasswordsEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs)
-          super(console_configs, ENTRY_KEY,
-            before_input: -> { banner },
-            validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-          )
-        end
-
-        def banner
-          infom 'Do you wanna to store passwords?'
-          infom 'Warning: the passwords will be store in clear text in ' \
-            "\"#{console_configs.configs.storage_path}\""
-          infom 'Enter "yes" or "no"'
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/docopt_runner.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/hash/slice'
-require 'docopt'
-require 'eac_ruby_utils/contextualizable'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-Dir["#{__dir__}/#{::File.basename(__FILE__, '.*')}/_*.rb"].sort.each do |partial|
-  require partial
-end
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      include ::EacRubyUtils::Contextualizable
-
-      class << self
-        def create(settings = {})
-          new(settings)
-        end
-      end
-
-      attr_reader :settings
-
-      def initialize(settings = {})
-        @settings = settings.with_indifferent_access.freeze
-        check_subcommands
-      end
-
-      def options
-        @options ||= Docopt.docopt(target_doc, docopt_options)
-      end
-
-      def parent
-        settings[:parent]
-      end
-
-      protected
-
-      def docopt_options
-        settings.slice(:version, :argv, :help, :options_first).to_sym_keys_hash
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/docopt_runner/_class_methods.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      DOCOPT_ERROR_EXIT_CODE = 0xC0
-
-      class << self
-        def run(options = {})
-          create(options).send(:run)
-        rescue Docopt::Exit => e
-          STDERR.write(e.message + "\n")
-          ::Kernel.exit(DOCOPT_ERROR_EXIT_CODE) # rubocop:disable Rails/Exit
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/docopt_runner/_doc.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      PROGRAM_MACRO = '__PROGRAM__'
-
-      def source_doc
-        setting_value(:doc)
-      end
-
-      def target_doc
-        source_doc.gsub(PROGRAM_MACRO, target_program_name).strip + "\n"
-      end
-
-      def source_program_name
-        setting_value(:program_name, false)
-      end
-
-      def target_program_name
-        [source_program_name, ENV['PROGRAM_NAME'], $PROGRAM_NAME].find(&:present?)
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/docopt_runner/_settings.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/settings_provider'
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      include ::EacRubyUtils::SettingsProvider
-
-      attr_reader :settings
-
-      private
-
-      def setting_value(key, required = true)
-        super(key, required: required, order: %w[method settings_object constant])
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/docopt_runner/_subcommands.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'shellwords'
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      SUBCOMMAND_ARG = '<subcommand>'
-      SUBCOMMAND_ARGS_ARG = '<subcommand-args>'
-      SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
-
-      def subcommands?
-        source_doc.include?(SUBCOMMANDS_MACRO)
-      end
-
-      def check_subcommands
-        return unless subcommands?
-
-        singleton_class.include(SubcommandsSupport)
-        check_subcommands_arg
-        return if singleton_class.method_defined?(:run)
-
-        singleton_class.send(:alias_method, :run, :run_with_subcommand)
-      end
-
-      module SubcommandsSupport
-        EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
-
-        def check_subcommands_arg
-          if subcommand_arg_as_list?
-            singleton_class.include(SubcommandsSupport::SubcommandArgAsList)
-          else
-            singleton_class.include(SubcommandsSupport::SubcommandArgAsArg)
-          end
-        end
-
-        def run_with_subcommand
-          if subcommand_name
-            check_valid_subcommand
-            subcommand_run
-          else
-            run_without_subcommand
-          end
-        end
-
-        def subcommand
-          @subcommand ||= subcommand_class_name(subcommand_name).constantize.create(
-            argv: subcommand_args,
-            program_name: subcommand_program,
-            parent: self
-          )
-        end
-
-        def subcommand_run
-          if !subcommand.is_a?(::EacRubyUtils::Console::DocoptRunner) &&
-             subcommand.respond_to?(:run_run)
-            subcommand.run_run
-          else
-            subcommand.run
-          end
-        end
-
-        def target_doc
-          super.gsub(SUBCOMMANDS_MACRO,
-                     "#{target_doc_subcommand_arg} [#{SUBCOMMAND_ARGS_ARG}...]") +
-            "\n" + subcommands_target_doc
-        end
-
-        def docopt_options
-          super.merge(options_first: true)
-        end
-
-        def subcommand_class_name(subcommand)
-          "#{self.class.name}::#{subcommand.underscore.camelize}"
-        end
-
-        def subcommand_arg_as_list?
-          setting_value(:subcommand_arg_as_list, false) || false
-        end
-
-        def subcommand_args
-          options.fetch(SUBCOMMAND_ARGS_ARG)
-        end
-
-        def subcommand_program
-          subcommand_name
-        end
-
-        def available_subcommands
-          r = ::Set.new(setting_value(:subcommands, false) || auto_available_subcommands)
-          if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
-            r += send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
-          end
-          r.sort
-        end
-
-        def auto_available_subcommands
-          self.class.constants
-              .map { |name| self.class.const_get(name) }
-              .select { |c| c.instance_of? Class }
-              .select { |c| c < ::EacRubyUtils::Console::DocoptRunner }
-              .map { |c| c.name.demodulize.underscore.dasherize }
-        end
-
-        def run_without_subcommand
-          "Method #{__method__} should be overrided in #{self.class.name}"
-        end
-
-        protected
-
-        def check_valid_subcommand
-          return if available_subcommands.include?(subcommand_name)
-
-          raise ::Docopt::Exit, "\"#{subcommand_name}\" is not a valid subcommand" \
-            " (Valid: #{available_subcommands.join(', ')})"
-        end
-
-        module SubcommandArgAsArg
-          def target_doc_subcommand_arg
-            SUBCOMMAND_ARG
-          end
-
-          def subcommand_name
-            options.fetch(SUBCOMMAND_ARG)
-          end
-
-          def subcommands_target_doc
-            available_subcommands.inject("Subcommands:\n") do |a, e|
-              a + "  #{e}\n"
-            end
-          end
-        end
-
-        module SubcommandArgAsList
-          def target_doc_subcommand_arg
-            '(' + available_subcommands.join('|') + ')'
-          end
-
-          def subcommand_name
-            available_subcommands.each do |subcommand|
-              return subcommand if options.fetch(subcommand)
-            end
-            nil
-          end
-
-          def subcommands_target_doc
-            "\n"
-          end
-        end
-      end
-    end
-  end
-end