eac_tools 0.117.3 → 0.117.4

data/sub/eac_templates/lib/eac_templates/modules/ancestor/file.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Ancestor
+      class File < ::EacTemplates::Abstract::File
+        include ::EacTemplates::Modules::Ancestor::FsObject
+
+        TEMPLATE_EXTNAME_PATTERN =
+          /#{::Regexp.quote(::EacTemplates::Variables::FsObject::TEMPLATE_EXTNAME)}\z/
+
+        class << self
+          def parse_basename(basename)
+            basename.if_present do |v|
+              v.to_pathname
+                .to_path
+                .gsub(TEMPLATE_EXTNAME_PATTERN, '')
+                .to_pathname
+            end
+          end
+        end
+
+        # @return [Boolean]
+        def found?
+          source_object.found? || template?
+        end
+
+        # @return [Pathname]
+        def path
+          template? ? template_source_object.path : source_object.path
+        end
+
+        # @return [Pathname]
+        def basename
+          self.class.parse_basename(super)
+        end
+
+        # @return [Boolean]
+        def template?
+          template_source_object.found?
+        end
+
+        protected
+
+        # @return [EacTemplates::Sources::File]
+        def template_source_object_uncached
+          owner.source_set.send(type, template_source_object_path_for_search)
+        end
+
+        # @return [Pathname]
+        def template_source_object_path_for_search
+          path_for_search.basename_sub do |b|
+            "#{b}#{::EacTemplates::Variables::FsObject::TEMPLATE_EXTNAME}"
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/ancestor/fs_object.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Ancestor
+      module FsObject
+        # @return [Pathname]
+        delegate :path_for_search, to: :owner
+
+        # @return [String]
+        def to_s
+          "#{self.class.name}[#{path_for_search}]"
+        end
+
+        private
+
+        def source_object_uncached
+          owner.source_set.send(type, path_for_search)
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/ancestor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Ancestor
+      include ::EacTemplates::Abstract::WithDirectoryFileMethods
+
+      NO_NAME_NAME = '__undefined__'
+
+      class << self
+        # @param a_module [Module]
+        # @return [Pathname]
+        def path_for_search(a_module)
+          a_module.name.if_present(NO_NAME_NAME, &:underscore).to_pathname
+        end
+      end
+
+      common_constructor :base, :ancestor
+      delegate :subpath, :source_set, to: :base
+      delegate(*::EacTemplates::InterfaceMethods::ALL + [:children_basenames], to: :sub_fs_object)
+
+      def ancestor_path_for_search
+        self.class.path_for_search(ancestor)
+      end
+
+      # @return [Pathname]
+      def path_for_search
+        r = ancestor_path_for_search
+        subpath.if_present(r) { |v| r.join(v) }
+      end
+
+      require_sub __FILE__
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/base/directory.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Base
+      class Directory < ::EacTemplates::Abstract::Directory
+        include ::EacTemplates::Modules::Base::FsObject
+
+        delegate(*(EacTemplates::InterfaceMethods::DIRECTORY - %i[apply child children]),
+                 to: :self_ancestor)
+
+        # @param variables_source [Object]
+        # @param target_path [Pathname]
+        def apply(variables_source, target_path)
+          target_path = target_path.to_pathname
+          target_path.mkpath
+          children.each do |child|
+            child_apply(child, variables_source, target_path.join(child.basename))
+          end
+        end
+
+        # @!method build_child(child_basename, child_type)
+        #   @param child_basename [Pathname]
+        #   @param child_type [Symbol]
+        #   @return [EacTemplates::Modules::Base]
+        delegate :build_child, to: :owner
+
+        # @return [Hash<Pathname, Symbol>]
+        def children_basenames
+          owner.ancestors.select(&:directory?).each_with_object({}) do |e, a|
+            ancestor_children_names(e, a)
+          end
+        end
+
+        # @return [Boolean]
+        def found?
+          children.any?
+        end
+
+        protected
+
+        # @param ancestor []
+        # @param result [Hash<Pathname, Symbol>]
+        # @return [void]
+        def ancestor_children_names(ancestor, result)
+          ancestor.children_basenames.each do |path, type|
+            result[path] = type
+          end
+        end
+
+        # @param child [EacTemplates::Modules::Base]
+        # # @param variables_source [Object]
+        # @param target_path [Pathname]
+        def child_apply(child, variables_source, target_path)
+          if child.directory?
+            child.apply(variables_source, target_path)
+          elsif child.file_template?
+            child.apply_to_file(variables_source, target_path)
+          elsif child.file?
+            ::FileUtils.cp(child.path, target_path)
+          else
+            ibr
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/base/file.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Base
+      class File < ::EacTemplates::Abstract::File
+        include ::EacTemplates::Modules::Base::FsObject
+
+        delegate(*EacTemplates::InterfaceMethods::FILE + [:template?], to: :ancestor_found)
+
+        def basename
+          ancestor_found.if_present(&:basename)
+        end
+
+        def found?
+          ancestor_found.present?
+        end
+
+        private
+
+        def ancestor_found_uncached
+          owner.ancestors.lazy.map(&:file).select(&:found?).first
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/base/fs_object.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Base
+      module FsObject
+        def self_ancestor
+          owner.self_ancestor.send(type)
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/modules/base.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Modules
+    class Base
+      include ::EacTemplates::Abstract::WithDirectoryFileMethods
+
+      enable_listable
+      enable_simple_cache
+      lists.add_symbol :option, :source_set, :subpath
+      common_constructor :the_module, :options, default: [{}] do
+        self.options = self.class.lists.option.hash_keys_validate!(options)
+      end
+      delegate(*::EacTemplates::InterfaceMethods::ONLY_DIRECTORY, to: :directory)
+      delegate(*::EacTemplates::InterfaceMethods::ONLY_FILE, to: :file)
+      delegate(*::EacTemplates::InterfaceMethods::COMMON, :basename, :path_for_search,
+               :source_object, :type, to: :sub_fs_object)
+
+      # @param child_basename [Pathname]
+      # @param child_type [Symbol]
+      # @return [EacTemplates::Modules::Base]
+      def build_child(child_basename, child_type)
+        r = ::EacTemplates::Modules::Base.new(
+          the_module, subpath: child_subpath(child_basename), source_set: source_set
+        )
+        return r.validate_type(child_type) if r.found?
+
+        raise ::EacTemplates::Errors::NotFound,
+              "No child for #{self} found with basename \"#{child_basename}\""
+      end
+
+      # @return [Boolean]
+      def found?
+        file.found? || directory.found?
+      end
+
+      # @return [EacTemplates::SourceSet]
+      def source_set
+        options[OPTION_SOURCE_SET] || ::EacTemplates::Sources::Set.default
+      end
+
+      # @return [Pathname, nil]
+      def subpath
+        options[OPTION_SUBPATH].if_present(&:to_pathname)
+      end
+
+      # @return [String]
+      def to_s
+        "#{self.class}[#{the_module.name}#\"#{subpath}\"]"
+      end
+
+      # @param required_type [Symbol]
+      # @return [self]
+      # @raise [EacTemplates::Errors::TypeMismatch]
+      def validate_type(required_type)
+        return self if valid_type?(required_type)
+
+        raise ::EacTemplates::Errors::TypeMismatch, "A #{required_type} type was expected, but a " \
+                                                    "#{type} was builded"
+      end
+
+      private
+
+      # @return [Enumerable<EacTemplates::Modules::Ancestor>]
+      def ancestors_uncached
+        the_module.ancestors.map { |a| ::EacTemplates::Modules::Ancestor.new(self, a) }
+      end
+
+      # @return [EacTemplates::Modules::Ancestor]
+      def self_ancestor_uncached
+        ancestors.find { |a| a.ancestor == the_module } || ibr
+      end
+
+      # @return [Boolean]
+      def valid_type?(required_type)
+        file_types = %i[file file_template]
+        if file_types.include?(required_type)
+          file_types.include?(type)
+        else
+          type == required_type
+        end
+      end
+
+      require_sub __FILE__
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/module/eac_template.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Module
+  # @return [EacTemplates::Modules::Base]
+  def eac_template
+    @eac_template ||= ::EacTemplates::Modules::Base.new(self)
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/module/erb_template.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+class Module
+  # @param subpath [Pathname]
+  # @param binding_obj [Object]
+  # @return [ERB]
+  def erb_template(subpath, binding_obj)
+    ::ERB.new(eac_template.child(subpath).path.read).result(binding_obj)
+  end
+end

data/sub/eac_templates/lib/eac_templates/patches/object/eac_template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Object
+  # @!method eac_template
+  #   @return (see Module#eac_template)
+  delegate :eac_template, to: :class
+end

data/sub/eac_templates/lib/eac_templates/patches/object/erb_template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Object
+  def erb_template(subpath, binding_obj = nil)
+    self.class.erb_template(subpath, binding_obj || binding)
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/directory.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    class Directory < ::EacTemplates::Abstract::Directory
+      include ::EacTemplates::Sources::FsObject
+
+      # @return [Hash<Pathname, Symbol>]
+      def children_basenames
+        r = {}
+        real_paths.each do |real_path|
+          real_path.children.each do |child|
+            next if r.key?(child.basename)
+
+            r[child.basename] = real_path_type(child)
+          end
+        end
+        r
+      end
+
+      # @return [Pathname]
+      def real_path_type(path)
+        if path.file?
+          :file
+        elsif path.directory?
+          :directory
+        else
+          raise "Path \"#{path}\" is not a file nor a directory"
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/file.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    class File < ::EacTemplates::Abstract::File
+      include ::EacTemplates::Sources::FsObject
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/from_all_gems.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+EacTemplates::Sources::FromGem.include_all

data/sub/eac_templates/lib/eac_templates/sources/from_gem.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    class FromGem
+      class << self
+        def include_all(searcher = nil)
+          ::Gem::Specification.each { |gemspec| new(gemspec, searcher).include }
+        end
+      end
+
+      TEMPLATES_DIR_SUBPATH = 'template'
+
+      common_constructor :gemspec, :searcher, default: [nil] do
+        self.searcher ||= ::EacTemplates::Sources::Set.default
+      end
+
+      # @return [Boolean]
+      delegate :exist?, to: :path
+
+      # @return [Pathname]
+      def include
+        return nil unless exist?
+
+        searcher.included_paths << path
+        path
+      end
+
+      # @return [Pathname]
+      def path
+        gemspec.gem_dir.to_pathname.join(TEMPLATES_DIR_SUBPATH)
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/fs_object.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    module FsObject
+      PATH_FOR_SEARCH_PREFIX = ::Pathname.new('')
+
+      common_concern do
+        enable_abstract_methods
+        enable_simple_cache
+      end
+
+      # @return [Boolean]
+      def found?
+        real_paths.any?
+      end
+
+      # @return [Pathname]
+      def path
+        real_paths.first
+      end
+
+      # @return [Pathname]
+      def path_for_search_prefix
+        PATH_FOR_SEARCH_PREFIX
+      end
+
+      # @return [String]
+      def to_s
+        "#{self.class.name}[#{path_for_search}]"
+      end
+
+      protected
+
+      # @return [Array<Pathname>]
+      def real_paths_uncached
+        source_set.included_paths.lazy.map { |source_single| source_single_search(source_single) }
+          .reject(&:nil?) # rubocop:disable Style/CollectionCompact
+      end
+
+      # @param path [Pathname]
+      # @return [Boolean]
+      def select_path?(path)
+        !path.nil? && path.send("#{type}?")
+      end
+
+      # @param source_single [EacTemplates::Sources::Single]
+      # @return [Pathname, nil]
+      def source_single_search(source_single)
+        r = source_single.search(path_for_search)
+        select_path?(r) ? r : nil
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/internal_set.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    class InternalSet < ::Set
+      # @param single [EacTemplates::Sources::Single]
+      # @return [self]
+      def add(single)
+        super(::EacTemplates::Sources::Single.assert(single))
+      end
+
+      # @param single [EacTemplates::Sources::Single]
+      # @return [self]
+      def <<(single)
+        add(single)
+      end
+
+      # @return [String]
+      def to_s
+        "#{self.class.name}[#{join(', ')}]"
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/set.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module EacTemplates
+  module Sources
+    class Set
+      class << self
+        def default
+          @default ||= new
+        end
+      end
+
+      # @param subpath [Pathname]
+      # @return [EacTemplates::Sources::Directory]
+      def directory(subpath)
+        ::EacTemplates::Sources::Directory.by_subpath(self, nil, subpath, source_set: self)
+      end
+
+      # @param subpath [Pathname]
+      # @return [EacTemplates::Sources::Directory]
+      def file(subpath)
+        ::EacTemplates::Sources::File.by_subpath(self, nil, subpath, source_set: self)
+      end
+
+      def template(subpath, required = true) # rubocop:disable Style/OptionalBooleanParameter
+        found_file = file(subpath)
+        return found_file if found_file.found?
+
+        found_directory = directory(subpath)
+        return found_directory if found_directory.found?
+
+        return nil unless required
+
+        raise_template_not_found(subpath)
+      end
+
+      # @return [EacTemplates::Sources::InternalSet]
+      def included_paths
+        @included_paths ||= ::EacTemplates::Sources::InternalSet.new
+      end
+
+      # @return [String]
+      def to_s
+        "#{self.class.name}[#{included_paths}]"
+      end
+
+      private
+
+      def raise_template_not_found(subpath)
+        raise ::EacTemplates::Errors::NotFound,
+              'Template not found for subpath ' \
+              "\"#{subpath}\" (Included paths: #{included_paths.to_a.join(::File::PATH_SEPARATOR)})"
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/sources/single.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Sources
+    class Single
+      class << self
+        # @param object [EacTemplates::Sources::Single, Pathname]
+        # @return [EacTemplates::Sources::Single]
+        def assert(object)
+          return object if object.is_a?(self)
+
+          new(object.to_pathname)
+        end
+      end
+
+      common_constructor :path do
+        self.path = path.to_pathname.expand_path
+      end
+
+      # @return [Pathname, nil]
+      def search(subpath)
+        r = path.join(subpath)
+        r.exist? ? r : nil
+      end
+
+      # @return [String]
+      def to_s
+        "#{self.class.name}[#{path}]"
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variables/content.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Variables
+    class Content
+      VARIABLE_DELIMITER = ::Regexp.quote('%%')
+      VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9._]*)#{VARIABLE_DELIMITER}/i
+
+      class << self
+        # @param path [Pathname]
+        # @return [EacTemplates::Variables::Content]
+        def from_file(path)
+          new(path.to_pathname.read)
+        end
+      end
+
+      enable_simple_cache
+      common_constructor :content
+
+      # +variables_provider+ A [Hash] or object which responds to +read_entry(entry_name)+.
+      def apply(variables_source)
+        variables_provider = ::EacTemplates::Variables::Providers.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).to_set do |name|
+          sanitize_variable_name(name)
+        end
+      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
+end