eac_tools 0.99.0 → 0.100.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+require 'eac_templates/abstract/fs_object'
+require 'eac_templates/variables/directory'
+
+module EacTemplates
+  module Abstract
+    class Directory < ::EacTemplates::Abstract::FsObject
+      enable_abstract_methods
+      delegate(*::EacTemplates::InterfaceMethods::DIRECTORY - %i[child chidren], to: :applier)
+
+      # @param basename [Pathname]
+      # @return [EacTemplates::Abstract::FsObject]
+      def build_child(child_basename, child_type)
+        child_basename = child_basename.to_pathname
+        child_type = type_list.value_validate!(child_type)
+        category_module.const_get(child_type.to_s.camelize)
+          .new(owner, self, child_basename, options)
+      end
+
+      # @param basename [Pathname]
+      # @return [EacTemplates::Abstract::FsObject]
+      def child(basename)
+        basename = basename.to_pathname
+        children.find { |c| c.basename == basename } ||
+          raise_not_found("No child found with basename \"#{basename}\" in \"#{self}\"")
+      end
+
+      # @return [Enumerable<EacTemplates::Abstract::FsObject>]
+      def children
+        children_basenames.map { |c_basename, c_type| build_child(c_basename, c_type) }
+      end
+
+      # @return [Hash<Pathname, Symbol>]
+      def children_basenames
+        raise_abstract_method __method__
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+require 'eac_templates/abstract/fs_object'
+require 'eac_templates/variables/file'
+
+module EacTemplates
+  module Abstract
+    class File < ::EacTemplates::Abstract::FsObject
+      enable_abstract_methods
+      delegate(*::EacTemplates::InterfaceMethods::FILE - %i[content path], to: :applier)
+
+      # @return [String]
+      def content
+        path.read
+      end
+
+      # @return [Pathname]
+      def path
+        raise_abstract_method __method__
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/fs_object_by_pathname'
+require 'eac_templates/errors/not_found'
+
+module EacTemplates
+  module Abstract
+    class FsObject
+      class << self
+        # @param obj [Object]
+        # @return [EacTemplates::Abstract::FsObject, EacTemplates::Abstracts::FsObjectByPathname]
+        def assert(obj)
+          if obj.is_a?(self)
+            obj
+          else
+            ::EacTemplates::Abstract::FsObjectByPathname.new(obj)
+          end
+        end
+
+        # @param owner [Object]
+        # @param parent_object [Object, nil]
+        # @param subpath [Pathname]
+        # @return [EacTemplates::Abstract::FsObject]
+        def by_subpath(owner, parent_object, subpath, options = {})
+          r = new(owner, parent_object, nil, options)
+          subpath.if_present(::Pathname.new(''), &:to_pathname).each_filename do |basename|
+            parent_object = r
+            r = new(owner, parent_object, basename, options)
+          end
+          r
+        end
+      end
+
+      enable_abstract_methods
+      enable_simple_cache
+      enable_listable
+      lists.add_symbol :option, :source_set
+      lists.add_symbol :type, :directory, :file
+      common_constructor :owner, :parent_object, :basename, :options, default: [{}] do
+        self.basename = basename.present? ? basename.to_pathname : ::Pathname.new('')
+        self.options = ::EacTemplates::Abstract::FsObject.lists.option.hash_keys_validate!(options)
+      end
+
+      # @return [EacTemplates::Variables::Directory, EacTemplates::Variables::File]
+      def applier
+        applier_class.new(self)
+      end
+
+      # @return [Class]
+      def applier_class
+        ::EacTemplates::Variables.const_get(type.to_s.camelize)
+      end
+
+      # @return [Module]
+      def category_module
+        self.class.module_parent
+      end
+
+      # @return [Pathname]
+      def path_for_search
+        if parent_object.present?
+          parent_object.path_for_search.join(basename)
+        else
+          path_for_search_prefix.join(basename)
+        end
+      end
+
+      # @return [Pathname]
+      def path_for_search_prefix
+        raise_abstract_method __method__
+      end
+
+      def raise_not_found(message)
+        raise ::EacTemplates::Errors::NotFound, message
+      end
+
+      # @return [EacTemplates::Sources::Set]
+      def source_set
+        options[OPTION_SOURCE_SET] || ::EacTemplates::Sources::Set.default
+      end
+
+      # @return [Symbol]
+      def type
+        type_list.value_validate!(self.class.name.demodulize.underscore.to_sym)
+      end
+
+      # @return [EacRubyUtils::Listable::SymbolList]
+      def type_list
+        ::EacTemplates::Abstract::FsObject.lists.type
+      end
+
+      def to_s
+        source_set = options.if_key(:source_set, '-', &:included_paths)
+        "#{self.class}[Basename: #{basename}, Source Set: #{source_set}]"
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/abstract/fs_object_by_pathname.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+module EacTemplates
+  module Abstract
+    class FsObjectByPathname
+      common_constructor :path do
+        self.path = path.to_pathname
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/abstract/with_directory_file_methods.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'eac_templates/errors/not_found'
+
+module EacTemplates
+  module Abstract
+    module WithDirectoryFileMethods
+      common_concern do
+        enable_simple_cache
+      end
+
+      def build_fs_object(type)
+        fs_object_class(type).by_subpath(self, nil, subpath, source_set: source_set)
+      end
+
+      # @param child_basename [Pathname
+      # @return [Pathname]
+      def child_subpath(child_basename)
+        subpath.if_present(child_basename) { |v| v.join(child_basename) }.to_pathname
+      end
+
+      # @return [Boolean]
+      def directory?
+        directory.found?
+      end
+
+      # @return [Boolean]
+      def file?
+        file.found?
+      end
+
+      # @return [Boolean]
+      def file_template?
+        file? && file.template?
+      end
+
+      # @return [Boolean]
+      def found?
+        directory? || file?
+      end
+
+      # @param type [Symbol]
+      # @return [Class]
+      def fs_object_class(type)
+        self.class.const_get(type.to_s.camelize)
+      end
+
+      # @return [EacTemplates::Abstract::Directory, EacTemplates::Abstract::File]
+      def sub_fs_object
+        return file if file.found?
+        return directory if directory.found?
+
+        raise ::EacTemplates::Errors::NotFound, "No template found: #{self}"
+      end
+
+      # @return [String]
+      def to_s
+        v = 'NOT_FOUND'
+        v = directory.to_s if directory?
+        v = file.to_s if file?
+        "#{self.class.name}[#{v}]"
+      end
+
+      private
+
+      # @return [EacTemplates::Abstract::Directory]
+      def directory_uncached
+        build_fs_object(:directory)
+      end
+
+      # @return [EacTemplates::Abstract::File]
+      def file_uncached
+        build_fs_object(:file)
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/core_ext.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches'
+require 'eac_templates/sources/from_all_gems'

data/sub/eac_templates/lib/eac_templates/errors/not_found.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Errors
+    class NotFound < ::RuntimeError
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/errors/type_mismatch.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Errors
+    class TypeMismatch < ::RuntimeError
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+module EacTemplates
+  module Errors
+    require_sub __FILE__
+  end
+end

data/sub/eac_templates/lib/eac_templates/interface_methods.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module InterfaceMethods
+    COMMON = %i[apply path].freeze
+    ONLY_DIRECTORY = %i[child children].freeze
+    DIRECTORY = COMMON + ONLY_DIRECTORY
+    ONLY_FILE = %i[apply_to_file content variables].freeze
+    FILE = COMMON + ONLY_FILE
+    ALL = COMMON + ONLY_DIRECTORY + ONLY_FILE
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/directory'
+require 'eac_templates/interface_methods'
+require 'eac_templates/modules/ancestor/fs_object'
+
+module EacTemplates
+  module Modules
+    class Ancestor
+      class Directory < ::EacTemplates::Abstract::Directory
+        include ::EacTemplates::Modules::Ancestor::FsObject
+        delegate :found?, :path, to: :source_object
+
+        # @return [Hash<Pathname, Symbol>]
+        def children_basenames
+          source_object.children_basenames.to_h { |k, v| parse_child_basename(k, v) }
+        end
+
+        protected
+
+        # @param basename [Pathname]
+        # @param type [Symbol]
+        # @return [Array]
+        def parse_child_basename(basename, type)
+          return [basename, type] unless type == :file
+
+          new_basename = ::EacTemplates::Modules::Ancestor::File.parse_basename(basename)
+
+          return [basename, type] if new_basename == basename
+
+          [new_basename, :file_template]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/file'
+require 'eac_templates/interface_methods'
+require 'eac_templates/modules/ancestor/fs_object'
+
+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/.freeze
+
+        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,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+
+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,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+require 'eac_templates/abstract/with_directory_file_methods'
+
+module EacTemplates
+  module Modules
+    class Ancestor
+      include ::EacTemplates::Abstract::WithDirectoryFileMethods
+
+      class << self
+        # @param a_module [Module]
+        # @return [Pathname]
+        def path_for_search(a_module)
+          a_module.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,72 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/directory'
+require 'eac_templates/interface_methods'
+require 'eac_templates/modules/base/fs_object'
+
+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,31 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/file'
+require 'eac_templates/interface_methods'
+require 'eac_templates/modules/base/fs_object'
+
+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,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+
+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,93 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/interface_methods'
+require 'eac_templates/abstract/with_directory_file_methods'
+require 'eac_templates/modules/ancestor'
+require 'eac_templates/sources/set'
+require 'eac_templates/errors/type_mismatch'
+
+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