RubyGems - avm-tools - Versions diffs - 0.74.1 → 0.77.0 - Mend

avm-tools 0.74.1 → 0.77.0

Files changed (87) hide show

@@ -2,6 +2,6 @@
 module Avm
   module Tools
-    VERSION = '0.74.1'
+    VERSION = '0.77.0'
   end
 end

data/template/avm/eac_redmine_base0/deploy/config/install.sh.template CHANGED

@@ -12,3 +12,15 @@ fi
 export address_host='%%WEB.AUTHORITY%%'
 export address_path='%%WEB.PATH%%'
 export git_repositories_hierarchical_organisation=false
+# Mail settings
+export smtp_server='%%MAILER.SMTP.ADDRESS%%'
+export smtp_port='%%MAILER.SMTP.PORT%%'
+export smtp_domain='%%MAILER.SMTP.DOMAIN%%'
+export smtp_tls='%%MAILER_SMTP_TLS%%'
+export smtp_enable_starttls_auto='%%MAILER_SMTP_STARTTLS_AUTO%%'
+export smtp_openssl_verify_mode='%%MAILER_SMTP_OPENSSL_VERIFY_MODE%%'
+export smtp_authentication='%%MAILER.SMTP.AUTHENTICATION%%'
+export smtp_username='%%MAILER.SMTP.USERNAME%%'
+export smtp_password='%%MAILER.SMTP.PASSWORD%%'
+export mail_from='%%MAILER.FROM%%'

data/template/avm/{stereotypes/eac_ubuntu_base0 → eac_ubuntu_base0}/docker_image/Dockerfile RENAMED

File without changes

data/template/avm/{stereotypes/eac_wordpress_base0 → eac_wordpress_base0}/deploy/wp-config.php.template RENAMED

File without changes

data/template/avm/eac_writings_base0/deploy/index.html.template ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title>%%title%%</title>
+  </head>
+  <body>
+    <h1>%%title%%</h1>
+    <a href="%%pdf_path%%">PDF</a>
+  </body>
+</html>

data/vendor/eac_cli/eac_cli.gemspec CHANGED

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.files = Dir['{lib}/**/*', 'Gemfile']
-  s.add_dependency 'eac_ruby_utils', '~> 0.45'
+  s.add_dependency 'eac_ruby_utils', '~> 0.50'
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1', '>= 0.1.2'
 end

data/vendor/eac_cli/lib/eac_cli/definition.rb CHANGED

@@ -8,57 +8,66 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     require_sub __FILE__
+    MAIN_ALTERNATIVE_KEY = :main
+    SUBCOMMAND_NAME_ARG = 'subcommand'
+    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
     attr_accessor :description
-    attr_accessor :options_argument
     def initialize
       self.description = '-- NO DESCRIPTION SET --'
-      self.options_argument = true
+      alternatives_set[MAIN_ALTERNATIVE_KEY] = main_alternative
     end
     def alt(&block)
-      r = ::EacCli::Definition.new
+      r = ::EacCli::Definition::Alternative.new
       r.instance_eval(&block)
-      alternatives << r
+      alternatives_set[new_alternative_key] = r
       r
     end
     def alternatives
-      @alternatives ||= []
-    end
-    def arg_opt(short, long, description, option_options = {})
-      options << ::EacCli::Definition::ArgumentOption.new(
-        short, long, description, option_options
-      )
+      alternatives_set.values
     end
-    def bool_opt(short, long, description, option_options = {})
-      options << ::EacCli::Definition::BooleanOption.new(short, long, description, option_options)
+    def alternative(key)
+      alternatives_set.fetch(key)
     end
     def desc(description)
       self.description = description
     end
+    def help_formatter
+      @help_formatter ||= ::EacCli::Definition::HelpFormatter.new(self)
+    end
+    def main_alternative
+      @main_alternative ||= begin
+        r = ::EacCli::Definition::Alternative.new
+        r.options_argument(true)
+        r
+      end
+    end
     def options_arg(options_argument)
       self.options_argument = options_argument
     end
-    def options
-      @options ||= []
+    def options_argument
+      main_alternative.options_argument?
     end
-    def pos_arg(name, arg_options = {})
-      positional << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+    def options_argument=(enable)
+      main_alternative.options_argument(enable)
     end
-    def positional
-      @positional ||= []
-    end
+    delegate :arg_opt, :bool_opt, :options, :pos_arg,
+             :positional, :subcommands, to: :main_alternative
-    def subcommands
-      positional << ::EacCli::Definition::PositionalArgument.new('subcommand', subcommand: true)
+    def subcommands?
+      alternatives.any?(&:subcommands?)
     end
     def options_first(enable = true)
@@ -68,5 +77,23 @@ module EacCli
     def options_first?
       @options_first ? true : false
     end
+    private
+    def alternatives_set
+      @alternatives_set ||= ::ActiveSupport::HashWithIndifferentAccess.new
+    end
+    def new_alternative_key
+      @last_key ||= 0
+      loop do
+        @last_key += 1
+        break @last_key unless alternatives_set.key?(@last_key)
+      end
+    end
+    def pos_set
+      @pos_set ||= []
+    end
   end
 end

data/vendor/eac_cli/lib/eac_cli/definition/alternative.rb ADDED

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require 'eac_cli/definition/argument_option'
+require 'eac_cli/definition/boolean_option'
+require 'eac_cli/definition/positional_argument'
+module EacCli
+  class Definition
+    class Alternative
+      SUBCOMMAND_NAME_ARG = :subcommand
+      SUBCOMMAND_ARGS_ARG = :subcommand_args
+      def arg_opt(short, long, description, option_options = {})
+        options_set << ::EacCli::Definition::ArgumentOption.new(
+          short, long, description, option_options
+        )
+      end
+      def bool_opt(short, long, description, option_options = {})
+        options_set << ::EacCli::Definition::BooleanOption.new(short, long, description,
+                                                               option_options)
+      end
+      def options
+        options_set.to_a
+      end
+      def options_argument?
+        @options_argument ? true : false
+      end
+      def options_argument(enable)
+        @options_argument = enable
+        self
+      end
+      def pos_arg(name, arg_options = {})
+        new_pos_arg = ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+        check_positional_blocked(new_pos_arg)
+        pos_set << new_pos_arg
+      end
+      def positional
+        pos_set.to_a
+      end
+      def positional_arguments_blocked?(new_pos_arg)
+        last = pos_set.last
+        return false unless last
+        return true if subcommands?
+        return true if last.repeat?
+        return true if last.optional? && new_pos_arg.if_present(&:required?)
+        false
+      end
+      def subcommands
+        pos_arg(SUBCOMMAND_NAME_ARG, subcommand: true)
+        pos_set << ::EacCli::Definition::PositionalArgument.new(SUBCOMMAND_ARGS_ARG,
+                                                                optional: true, repeat: true)
+      end
+      def subcommands?
+        pos_set.any?(&:subcommand?)
+      end
+      private
+      def check_positional_blocked(new_pos_arg)
+        raise 'Positional arguments are blocked' if positional_arguments_blocked?(new_pos_arg)
+      end
+      def pos_set
+        @pos_set ||= []
+      end
+      def options_set
+        @options_set ||= []
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/definition/base_option.rb CHANGED

@@ -5,19 +5,35 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class BaseOption
+      DEFAULT_REQUIRED = false
+      enable_listable
+      lists.add_symbol :option, :optional, :usage, :required
       attr_reader :short, :long, :description, :options
       def initialize(short, long, description, options = {})
         @short = short
         @long = long
         @description = description
-        @options = options.with_indifferent_access
+        @options = options.symbolize_keys
+        @options.assert_valid_keys(::EacCli::Definition::BaseOption.lists.option.values)
       end
       def identifier
         long.to_s.variableize.to_sym
       end
+      def required?
+        return true if options.key?(:required) && options.fetch(:required)
+        return false if options.key?(:optional) && options.fetch(:optional)
+        DEFAULT_REQUIRED
+      end
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
+      end
       def show_on_usage?
         options[:usage]
       end

data/vendor/eac_cli/lib/eac_cli/{parser/options_collection.rb → definition/help_formatter.rb} RENAMED

@@ -1,49 +1,30 @@
 # frozen_string_literal: true
 require 'eac_ruby_utils/core_ext'
-require 'optparse'
 module EacCli
-  class Parser
-    class OptionsCollection
+  class Definition
+    class HelpFormatter
       SEP = ' '
       IDENT = SEP * 2
       OPTION_DESC_SEP = IDENT * 2
-      enable_simple_cache
-      common_constructor(:definition, :argv, :collector) { collect }
-      attr_reader :arguments
-      private
-      def collect
-        build_banner
-        build_options
-        @arguments = option_parser.parse(argv)
-      end
-      def option_parser_uncached
-        ::OptionParser.new
-      end
-      def build_banner
-        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
-      end
-      def build_options
-        definition.options.each do |option|
-          build_option(option)
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=VALUE' if option.argument?
+          b
         end
-      end
-      def build_option(option)
-        option_parser.on(
-          *[option_short(option), option_long(option), option.description].reject(&:blank?)
-        ) do |value|
-          collector.collect(option, value)
+        def option_short(option)
+          b = option.short
+          b += 'VALUE' if option.argument?
+          b
         end
       end
+      common_constructor :definition
       def positional_argument(positional)
         if positional.subcommand?
           ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
@@ -55,22 +36,6 @@ module EacCli
         end
       end
-      def option_argument(option)
-        option_long(option)
-      end
-      def option_long(option)
-        b = option.long
-        b += '=VALUE' if option.argument?
-        b
-      end
-      def option_short(option)
-        b = option.short
-        b += 'VALUE' if option.argument?
-        b
-      end
       def section(header, include_header = true)
         b = include_header ? "#{header.humanize}:\n" : ''
         b += send("self_#{header}") + "\n"
@@ -94,12 +59,18 @@ module EacCli
       end
       def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+        definition.options.select(&:show_on_usage?).map do |option|
+          self.class.option_long(option)
+        end
       end
       def self_usage_arguments_positional
         definition.positional.map { |p| positional_argument(p) }
       end
+      def to_banner
+        "#{definition.description}\n\n#{section('usage')}"
+      end
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/definition/positional_argument.rb CHANGED

@@ -5,22 +5,39 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class PositionalArgument
-      common_constructor :name, :options, default: [{}]
+      DEFAULT_REQUIRED = true
+      enable_listable
+      lists.add_symbol :option, :optional, :repeat, :required, :subcommand
+      common_constructor :name, :options, default: [{}] do
+        options.assert_valid_keys(self.class.lists.option.values)
+      end
       def identifier
         name.to_s.variableize.to_sym
       end
       def optional?
-        options[:optional]
+        !required?
       end
       def repeat?
-        options[:repeat]
+        options[OPTION_REPEAT]
+      end
+      def required?
+        return true if options.key?(OPTION_REQUIRED) && options.fetch(OPTION_REQUIRED)
+        return false if options.key?(OPTION_OPTIONAL) && options.fetch(OPTION_OPTIONAL)
+        DEFAULT_REQUIRED
       end
       def subcommand?
-        options[:subcommand]
+        options[OPTION_SUBCOMMAND]
+      end
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb CHANGED

@@ -6,71 +6,49 @@ require 'eac_ruby_utils/console/docopt_runner'
 module EacCli
   module Docopt
     class DocBuilder
+      require_sub __FILE__
       common_constructor :definition
       SEP = ' '
       IDENT = SEP * 2
       OPTION_DESC_SEP = IDENT * 2
-      def positional_argument(positional)
-        if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
-        else
-          r = "<#{positional.name}>"
-          r += '...' if positional.repeat?
-          r = "[#{r}]" if positional.optional?
-          r
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=<value>' if option.argument?
+          b
         end
       end
-      def option_argument(option)
-        option_long(option)
-      end
       def option_definition(option)
-        option.short + SEP + option_long(option) + OPTION_DESC_SEP + option.description
-      end
-      def option_long(option)
-        b = option.long
-        b += '=<value>' if option.argument?
-        b
+        option.short + SEP + self.class.option_long(option) + OPTION_DESC_SEP + option.description
       end
       def section(header, include_header = true)
         b = include_header ? "#{header.humanize}:\n" : ''
         b += send("self_#{header}") + "\n"
         definition.alternatives.each do |alternative|
-          b += self.class.new(alternative).section(header, false)
+          b += IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
         end
         b
       end
-      def self_options
-        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
-      end
-      def self_usage
-        IDENT + self_usage_arguments.join(SEP)
-      end
-      def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
-          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
-          self_usage_arguments_options +
-          self_usage_arguments_positional
-      end
-      def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+      def options_section
+        "Options:\n" +
+          definition.alternatives.flat_map(&:options)
+                    .map { |option| IDENT + option_definition(option) + "\n" }.join
       end
-      def self_usage_arguments_positional
-        definition.positional.map { |p| positional_argument(p) }
+      def usage_section
+        "Usage:\n" +
+          definition.alternatives.map do |alternative|
+            IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
+          end.join
       end
       def to_s
-        "#{definition.description}\n\n#{section('usage')}\n#{section('options')}\n"
+        "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
       end
     end
   end