eac_tools 0.100.0 → 0.101.1

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

@@ -1,25 +0,0 @@
-# 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

@@ -1,99 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,77 +0,0 @@
-# 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

@@ -1,4 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

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

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

@@ -1,9 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,64 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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

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

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

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-
-class Module
-  def erb_template(subpath, binding_obj)
-    ::ERB.new(template.child(subpath).path.read).result(binding_obj)
-  end
-end

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_templates/modules/base'
-
-class Module
-  def template
-    @template ||= ::EacTemplates::Modules::Base.new(self)
-  end
-end

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

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils'
-EacRubyUtils.require_sub __FILE__