avm-tools 0.98.0 → 0.102.0

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/common_concern.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/common_concern'
-require 'eac_ruby_utils/console/speaker'
 
 class Module
   def common_concern(&after_callback)

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/contextualizable'
+
+class Module
+  # Patches module with [EacRubyUtils::Contextualizable].
+  def enable_context
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Contextualizable)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/speaker.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/speaker/sender'
+
+class Module
+  def enable_speaker
+    include ::EacRubyUtils::Speaker::Sender
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/rspec/conditional.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/object/blank'
-require 'eac_ruby_utils/console/speaker'
 
 module EacRubyUtils
   module Rspec
     class Conditional
-      include ::EacRubyUtils::Console::Speaker
-
       def self.default
         @default ||= new
       end
@@ -24,7 +21,7 @@ module EacRubyUtils
         tags.each do |tag, condition|
           message = condition.call
           if message.present?
-            warn("Excluded tag: #{tag}: #{message}")
+            puts("[WARN] Excluded tag: #{tag}: #{message}")
             rspec_config.filter_run_excluding tag
           end
         end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/speaker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/contextualizable'
+
+module EacRubyUtils
+  module Speaker
+    include ::EacRubyUtils::Contextualizable
+
+    class << self
+      # @return [EacRubyUtils::Speaker::Receiver]
+      def current_receiver
+        context.current
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/speaker/receiver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/abstract_methods'
+
+module EacRubyUtils
+  module Speaker
+    module Receiver
+      extend ::EacRubyUtils::AbstractMethods
+
+      def error(_string)
+        raise_abstract_method(__FILE__)
+      end
+
+      def fatal_error(string)
+        error(string)
+        ::Kernel.exit 1 # rubocop:disable Rails/Exit
+      end
+
+      # @see EacRubyUtils::Speaker::Sender.input
+      def input(_question, _options = {})
+        raise_abstract_method(__FILE__)
+      end
+
+      def info(_string)
+        raise_abstract_method(__FILE__)
+      end
+
+      def infom(_string)
+        raise_abstract_method(__FILE__)
+      end
+
+      def infov(*_args)
+        raise_abstract_method(__FILE__)
+      end
+
+      def out(_string = '')
+        raise_abstract_method(__FILE__)
+      end
+
+      def puts(_string = '')
+        raise_abstract_method(__FILE__)
+      end
+
+      def success(_string)
+        raise_abstract_method(__FILE__)
+      end
+
+      def title(_string)
+        raise_abstract_method(__FILE__)
+      end
+
+      def warn(_string)
+        raise_abstract_method(__FILE__)
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/speaker/sender.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Speaker
+    module Sender
+      delegate :error, :fatal_error, :info, :infom, :title, :success, :warn, to: :speaker_receiver
+
+      def infov(*args)
+        speaker_receiver.infov(*args)
+      end
+
+      delegate :out, to: :speaker_receiver
+
+      delegate :puts, to: :speaker_receiver
+
+      # Shortcut to [EacRubyUtils::Speaker.current_receiver].
+      #
+      # @return [EacRubyUtils::Speaker::Receiver]
+      def speaker_receiver
+        ::EacRubyUtils::Speaker.current_receiver
+      end
+
+      # Options:
+      #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
+      #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
+      #   +noecho+ ([Boolean], default: +false+): does not output answer.
+      def input(question, options = {})
+        speaker_receiver.input(question, options)
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.63.0'
+  VERSION = '0.67.0'
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/speaker_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/speaker'
+
+RSpec.describe ::Module do
+  class StubClass # rubocop:disable RSpec/LeakyConstantDeclaration
+    enable_speaker
+  end
+
+  describe '#enable_speaker' do
+    it { expect(StubClass.included_modules).to include(::EacRubyUtils::Speaker::Sender) }
+  end
+end

data/vendor/eac_templates/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/vendor/eac_templates/eac_templates.gemspec

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_templates/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_templates'
+  s.version     = EacTemplates::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'eac_config', '~> 0.3'
+  s.add_dependency 'eac_ruby_utils', '~> 0.64'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
+end

data/vendor/eac_templates/lib/eac_templates.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacTemplates
+  require_sub __FILE__
+end

data/vendor/eac_templates/lib/eac_templates/directory.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'eac_templates/file'
+
+module EacTemplates
+  class Directory
+    TEMPLATE_EXTNAME = '.template'
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path.is_a?(::Pathname) ? path : ::Pathname.new(path.to_s)
+    end
+
+    def apply(variables_source, directory)
+      TemplateNode.new(self, '.', directory, variables_source).apply
+    end
+
+    def child(subpath)
+      child_path = ::File.join(path, subpath)
+      return ::EacTemplates::File.new(child_path) if ::File.file?(child_path)
+      return ::EacTemplates::Directory.new(child_path) if ::File.directory?(child_path)
+
+      raise "Child \"#{subpath}\" from \"#{path}\" not found"
+    end
+
+    def children
+      path.children.map do |path_child|
+        child(path_child.basename.to_path)
+      end
+    end
+
+    private
+
+    def apply_fs_object(source_relative, target)
+      if ::File.directory?(source_absolute(source_relative))
+        apply_directory(source_relative, target)
+      elsif ::File.file?(source_absolute(source_relative))
+      end
+    end
+
+    def source_absolute(source_relative)
+      ::File.expand_path(source_relative, path)
+    end
+
+    class TemplateNode
+      attr_reader :source_directory, :source_relative, :target_root_directory, :variables_source
+
+      def initialize(source_directory, source_relative, target_root_directory, variables_source)
+        @source_directory = source_directory
+        @source_relative = source_relative
+        @target_root_directory = target_root_directory
+        @variables_source = variables_source
+      end
+
+      def apply
+        if file?
+          apply_file
+        elsif directory?
+          apply_directory
+        else
+          raise "Unknown filesystem type: #{source_absolute}"
+        end
+      end
+
+      private
+
+      def apply_directory
+        ::FileUtils.mkdir_p(target_absolute)
+        Dir.entries(source_absolute).each do |entry|
+          child(entry).apply unless %w[. ..].include?(entry)
+        end
+      end
+
+      def apply_file
+        if ::File.extname(source_absolute) == TEMPLATE_EXTNAME
+          ::EacTemplates::File.new(source_absolute).apply_to_file(
+            variables_source, target_absolute
+          )
+        else
+          ::FileUtils.cp(source_absolute, target_absolute)
+        end
+      end
+
+      def child(entry)
+        TemplateNode.new(source_directory, ::File.join(source_relative, entry),
+                         target_root_directory, variables_source)
+      end
+
+      def file?
+        ::File.file?(source_absolute)
+      end
+
+      def directory?
+        ::File.directory?(source_absolute)
+      end
+
+      def source_absolute
+        ::File.expand_path(source_relative, source_directory.path)
+      end
+
+      def target_absolute
+        ::File.expand_path(source_relative, target_root_directory)
+              .gsub(/#{::Regexp.quote(TEMPLATE_EXTNAME)}\z/, '')
+      end
+    end
+  end
+end

data/vendor/eac_templates/lib/eac_templates/file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_templates/variable_providers'
+
+module EacTemplates
+  class File
+    VARIABLE_DELIMITER = ::Regexp.quote('%%')
+    VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9\._]*)#{VARIABLE_DELIMITER}/i.freeze
+
+    enable_simple_cache
+    common_constructor :path do
+      self.path = path.to_pathname
+    end
+
+    # +variables_provider+ A [Hash] or object which responds to +read_entry(entry_name)+.
+    def apply(variables_source)
+      variables_provider = ::EacTemplates::VariableProviders.build(variables_source)
+      variables.inject(content) do |a, e|
+        a.gsub(variable_pattern(e), variables_provider.variable_value(e).to_s)
+      end
+    end
+
+    def apply_to_file(variables_source, output_file_path)
+      output_file_path.to_pathname.write(apply(variables_source))
+    end
+
+    private
+
+    def variables_uncached
+      content.scan(VARIABLE_PATTERN).map(&:first).map do |name|
+        sanitize_variable_name(name)
+      end.to_set
+    end
+
+    def content_uncached
+      path.read
+    end
+
+    def sanitize_variable_name(variable_name)
+      variable_name.to_s.downcase
+    end
+
+    def variable_pattern(name)
+      /#{VARIABLE_DELIMITER}#{::Regexp.quote(name)}#{VARIABLE_DELIMITER}/i
+    end
+  end
+end

data/vendor/eac_templates/lib/eac_templates/patches/module/template.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_templates/searcher'
+
+class Module
+  def template
+    @template ||= ::EacTemplates::Searcher.default.template(name.underscore)
+  end
+end

data/vendor/{eac_ruby_utils/lib/eac_ruby_utils → eac_templates/lib/eac_templates}/patches/object/template.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/patches/module/template'
+require 'eac_templates/patches/module/template'
 
 class Object
   def template

data/vendor/eac_templates/lib/eac_templates/searcher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_templates/directory'
+require 'eac_templates/file'
+
+module EacTemplates
+  class Searcher
+    class << self
+      def default
+        @default ||= new
+      end
+    end
+
+    def template(subpath, required = true)
+      path = template_path(subpath)
+      if path.blank?
+        return nil unless required
+
+        raise_template_not_found(subpath)
+      end
+      return ::EacTemplates::File.new(path) if ::File.file?(path)
+      return ::EacTemplates::Directory.new(path) if ::File.directory?(path)
+
+      raise 'Invalid branching'
+    end
+
+    # @return The absolute path of template if found, +nil+ otherwise.
+    def template_path(subpath)
+      included_paths.each do |included_path|
+        r = search_template_in_included_path(included_path, subpath)
+        return r if r
+      end
+      nil
+    end
+
+    def included_paths
+      @included_paths ||= ::Set.new
+    end
+
+    private
+
+    def raise_template_not_found(subpath)
+      raise "Template not found for subpath \"#{subpath}\"" \
+        " (Included paths: #{included_paths.to_a.join(::File::PATH_SEPARATOR)})"
+    end
+
+    def search_template_in_included_path(included_path, subpath)
+      path = ::File.join(included_path, subpath)
+      ::File.exist?(path) ? path : nil
+    end
+  end
+end