avm-tools 0.70.0 → 0.73.0

data/lib/avm/tools/runner/instance/info.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'avm/instances/entry_keys'
+require 'eac_cli/core_ext'
+require 'eac_ruby_utils/console/docopt_runner'
+
+module Avm
+  module Tools
+    class Runner < ::EacRubyUtils::Console::DocoptRunner
+      class Instance < ::EacRubyUtils::Console::DocoptRunner
+        class Info < ::EacRubyUtils::Console::DocoptRunner
+          runner_with
+
+          runner_definition do
+            desc 'Show info about a instance.'
+          end
+
+          def run
+            base_banner
+            entry_keys_banner
+          end
+
+          private
+
+          def base_banner
+            infov 'ID', instance.id
+            infov 'Application ID', instance.application.id
+            infov 'Suffix', instance.suffix
+          end
+
+          def entry_keys_banner
+            ::Avm::Instances::EntryKeys.all.each do |key|
+              infov key, instance.read_entry_optional(key)
+            end
+          end
+
+          def instance
+            context(:instance)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module Tools
-    VERSION = '0.70.0'
+    VERSION = '0.73.0'
   end
 end

data/template/avm/eac_rails_base0/deploy/config/envvars.d/email.yml.template

@@ -0,0 +1,11 @@
+---
+action_mailer_smtp_address: '%%MAILER.SMTP.ADDRESS%%'
+action_mailer_smtp_port: '%%MAILER.SMTP.PORT%%'
+action_mailer_smtp_domain: '%%MAILER.SMTP.DOMAIN%%'
+action_mailer_smtp_username: '%%MAILER.SMTP.USERNAME%%'
+action_mailer_smtp_password: '%%MAILER.SMTP.PASSWORD%%'
+action_mailer_smtp_authentication: '%%MAILER.SMTP.AUTHENTICATION%%'
+action_mailer_smtp_enable_starttls_auto: '%%MAILER.SMTP.STARTTLS_AUTO%%'
+action_mailer_default_options_from: '%%MAILER.FROM%%'
+action_mailer_default_options_reply_to: '%%MAILER.REPLY_TO%%'
+action_mailer_default_url_host: '%%WEB.URL%%'

data/vendor/eac_cli/lib/eac_cli/runner.rb

@@ -45,7 +45,7 @@ module EacCli
     module AfterClassMethods
       def create(*runner_context_args)
         r = new
-        r.runner_context = ::EacCli::Runner::Context.new(*runner_context_args)
+        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
         r
       end
 

data/vendor/eac_cli/lib/eac_cli/runner/context.rb

@@ -5,13 +5,30 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module Runner
     class Context
-      attr_reader :argv, :parent, :program_name
+      attr_reader :argv, :parent, :program_name, :runner
 
-      def initialize(*context_args)
+      def initialize(runner, *context_args)
         options = context_args.extract_options!
         @argv = (context_args[0] || options.delete(:argv) || ARGV).dup.freeze
         @parent = context_args[1] || options.delete(:parent)
         @program_name = options.delete(:program_name)
+        @runner = runner
+      end
+
+      # Call a method in the runner or in one of it ancestors.
+      def call(method_name, *args)
+        return runner.send(method_name, *args) if runner.respond_to?(method_name)
+        return parent_call(method_name, *args) if parent.present?
+
+        raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+      end
+
+      protected
+
+      def parent_call(method_name, *args)
+        return parent.context(method_name, *args) if parent.respond_to?(:context)
+
+        parent.runner_context.call(method_name, *args)
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/runner.rb

@@ -10,6 +10,7 @@ module EacRubyBase0
       include ::EacCli::DefaultRunner
       runner_definition do
         bool_opt '-q', '--quiet', 'Quiet mode.'
+        bool_opt '-I', '--no-input', 'Fail if a input is requested.'
         subcommands
         alt do
           bool_opt '-V', '--version', 'Show version.'
@@ -20,6 +21,7 @@ module EacRubyBase0
     def run
       on_speaker_node do |node|
         node.stderr = ::StringIO.new if options.fetch('--quiet')
+        node.stdin = FailIfRequestInput.new if options.fetch('--no-input')
         if options.fetch('--version')
           show_version
         else
@@ -35,5 +37,15 @@ module EacRubyBase0
     def show_version
       out("#{application_version}\n")
     end
+
+    class FailIfRequestInput
+      enable_console_speaker
+
+      %w[gets noecho].each do |method|
+        define_method(method) do
+          raise "Input method requested (\"#{method}\") and option --no-input is set"
+        end
+      end
+    end
   end
 end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyBase0
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/vendor/eac_ruby_gems_utils/lib/eac_ruby_gems_utils/gem.rb

@@ -11,8 +11,9 @@ module EacRubyGemsUtils
 
     GEMSPEC_EXTNAME = '.gemspec'
 
-    common_constructor :root do
+    common_constructor :root, :host_env, default: [nil] do
       @root = ::Pathname.new(root).expand_path
+      self.host_env ||= ::EacRubyUtils::Envs.local
     end
 
     def to_s

data/vendor/eac_ruby_gems_utils/lib/eac_ruby_gems_utils/gem/command.rb

@@ -11,7 +11,7 @@ module EacRubyGemsUtils
 
       def initialize(gem, command_args, extra_options = {})
         @gem = gem
-        super(command_args, extra_options)
+        super(command_args, extra_options.merge(host_env: gem.host_env))
       end
 
       # Changes current directory to the gem's directory.

data/vendor/eac_ruby_gems_utils/lib/eac_ruby_gems_utils/tests/multiple/decorated_gem.rb

@@ -12,14 +12,12 @@ module EacRubyGemsUtils
           log('running "bundle install"...')
           return if bundle('install').execute.fetch(:exit_code).zero?
 
-          if can_remove_gemfile_lock?
-            log('"bundle install" failed, removing Gemfile.lock and trying again...')
-            gemfile_lock_path.unlink if gemfile_lock_path.exist?
-            bundle('install').execute!
-          else
+          unless can_remove_gemfile_lock?
             raise '"bundle install" failed and the Gemfile.lock is part of gem' \
-              '(Should be changed by developer)'
+                '(Should be changed by developer)'
           end
+
+          prepare_with_removable_gemfile_lock
         end
 
         def tests
@@ -33,6 +31,12 @@ module EacRubyGemsUtils
           infov self, message
         end
 
+        def prepare_with_removable_gemfile_lock
+          log('"bundle install" failed, removing Gemfile.lock and trying again...')
+          gemfile_lock_path.unlink if gemfile_lock_path.exist?
+          bundle('install').execute!
+        end
+
         def can_remove_gemfile_lock?
           !files.include?(gemfile_lock_path.relative_path_from(root))
         end

data/vendor/eac_ruby_gems_utils/lib/eac_ruby_gems_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyGemsUtils
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/blank_not_blank.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'singleton'
+
+module EacRubyUtils
+  # A blank string which returns +false+ for +blank?+ method.
+  class BlankNotBlank < String
+    include ::Singleton
+
+    def initialize
+      super('')
+    end
+
+    def blank?
+      false
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/configs/base.rb

@@ -0,0 +1,43 @@
+# 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/vendor/eac_ruby_utils/lib/eac_ruby_utils/configs/file.rb

@@ -1,27 +1,18 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string'
+require 'eac_ruby_utils/configs/base'
 require 'yaml'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-require 'eac_ruby_utils/paths_hash'
-require 'eac_ruby_utils/simple_cache'
 
 module EacRubyUtils
   class Configs
-    class File
-      include ::EacRubyUtils::SimpleCache
-
+    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
-        load
-      end
-
-      def clear
-        self.data = ::EacRubyUtils::PathsHash.new({})
+        super(raw_data_from_file)
       end
 
       def save
@@ -30,37 +21,27 @@ module EacRubyUtils
       end
 
       def load
-        self.data = if ::File.exist?(path) && ::File.size(path).positive?
-                      ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
-                    else
-                      {}
-                    end
-      end
-
-      def []=(entry_key, entry_value)
-        write(entry_key, entry_value)
+        replace(raw_data_from_file)
       end
 
       def write(entry_key, entry_value)
-        data[entry_key] = entry_value
+        super
         save if autosave?
       end
 
-      def [](entry_key)
-        read(entry_key)
-      end
-
-      def read(entry_key)
-        data[entry_key]
-      end
-
       def autosave?
         options[:autosave] ? true : false
       end
 
       private
 
-      attr_accessor :data
+      def raw_data_from_file
+        if ::File.exist?(path) && ::File.size(path).positive?
+          ::YAML.load_file(path)
+        else
+          {}
+        end
+      end
     end
   end
 end

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

@@ -66,7 +66,10 @@ module EacRubyUtils
       protected
 
       def envvar_read_entry(entry_key)
-        ENV[self.class.entry_key_to_envvar_name(entry_key)]
+        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
+        return nil unless ENV.key?(env_entry_key)
+
+        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
       end
 
       def read_entry_from_console(entry_key, options)

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/paths_hash.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/object'
-require 'eac_ruby_utils/patches/object/asserts'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   class PathsHash
+    require_sub __FILE__
+
     class << self
       def parse_entry_key(entry_key)
         r = entry_key.to_s.strip
-        raise EntryKeyError, 'Entry key cannot start or end with dot' if
+        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
         r.start_with?('.') || r.end_with?('.')
 
         r = r.split('.').map(&:strip)
-        raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
+        if r.empty?
+          raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
+        end
         return r.map(&:to_sym) unless r.any?(&:blank?)
 
-        raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
+        raise ::EacRubyUtils::PathsHash::EntryKeyError,
+              "Entry key \"#{entry_key}\" has at least one blank part"
       end
     end
 
@@ -26,68 +30,27 @@ module EacRubyUtils
     end
 
     def [](entry_key)
-      root.read_entry(self.class.parse_entry_key(entry_key), [])
+      root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
     def []=(entry_key, entry_value)
-      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+      root.write_entry(
+        ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
+      )
     end
 
-    delegate :to_h, to: :root
-
-    private
-
-    attr_reader :data
-
-    class EntryKeyError < StandardError
+    def fetch(entry_key)
+      root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
-    class Node
-      def initialize(source_hash)
-        source_hash.assert_argument(Hash, 'source_hash')
-        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
-      end
-
-      def to_h
-        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
-      end
-
-      def read_entry(path, current)
-        validate_path(path, current)
-        node_key = path.shift
-        node = data[node_key]
-        return (node.is_a?(Node) ? node.to_h : node) if path.empty?
-        return nil if node.blank?
-        return node.read_entry(path, current + [node_key]) if node.is_a?(Node)
-
-        raise(EntryKeyError,
-              "Path #{current.join(',')} is not a Node and path continues (#{current + path})")
-      end
-
-      def write_entry(path, value, current)
-        validate_path(path, current)
-        node_key = path.shift
-        write_entry_value(path, node_key, value, current)
-      end
-
-      private
+    def key?(entry_key)
+      root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
 
-      def write_entry_value(path, node_key, value, current)
-        if path.empty?
-          data[node_key] = value.is_a?(Hash) ? Node.new(value) : value
-        else
-          data[node_key] = Node.new({}) unless data[node_key].is_a?(Node)
-          data[node_key].write_entry(path, value, current + [node_key])
-        end
-      end
+    delegate :to_h, to: :root
 
-      def validate_path(path, current)
-        path.assert_argument(Array, 'path')
-        current.assert_argument(Array, 'current')
-        raise EntryKeyError, 'Path is empty' if path.empty?
-      end
+    private
 
-      attr_reader :data
-    end
+    attr_reader :data
   end
 end