eac_tools 0.99.0 → 0.100.0

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches/module/erb_template'
+
+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/patches/object/template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_templates/patches/module/template'
+
+class Object
+  delegate :template, to: :class
+end

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

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

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

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/directory'
+require 'eac_templates/sources/fs_object'
+
+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,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/file'
+require 'eac_templates/sources/fs_object'
+
+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,4 @@
+# frozen_string_literal: true
+
+require 'eac_templates/sources/from_gem'
+EacTemplates::Sources::FromGem.include_all

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_templates/sources/set'
+
+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,58 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/errors/not_found'
+
+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,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/sources/single'
+
+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}[#{map(&:to_s).join(', ')}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_templates/sources/directory'
+require 'eac_templates/sources/file'
+require 'eac_templates/sources/internal_set'
+require 'eac_templates/errors/not_found'
+
+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,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+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/sources.rb

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

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/variables/providers'
+
+module EacTemplates
+  module Variables
+    class Content
+      VARIABLE_DELIMITER = ::Regexp.quote('%%')
+      VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9\._]*)#{VARIABLE_DELIMITER}/i.freeze
+
+      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| # rubocop:disable Style/MapToSet
+          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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_templates/errors/not_found'
+require 'eac_templates/abstract/directory'
+require 'eac_templates/variables/file'
+require 'eac_templates/variables/fs_object'
+
+module EacTemplates
+  module Variables
+    class Directory
+      common_constructor :abstract_directory do
+        self.abstract_directory = ::EacTemplates::Abstract::Directory.assert(abstract_directory)
+      end
+      delegate :path, to: :abstract_directory
+
+      def apply(variables_source, directory)
+        ::EacTemplates::Variables::FsObject.new(self, '.', directory, variables_source).apply
+      end
+
+      def child(subpath)
+        child_path = ::File.join(path, subpath)
+        return ::EacTemplates::Variables::File.new(child_path) if ::File.file?(child_path)
+        return ::EacTemplates::Variables::Directory.new(child_path) if ::File.directory?(child_path)
+
+        raise ::EacTemplates::Errors::NotFound,
+              "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)
+        return unless ::File.directory?(source_absolute(source_relative))
+
+        apply_directory(source_relative, target)
+      end
+
+      def source_absolute(source_relative)
+        ::File.expand_path(source_relative, path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+require 'eac_templates/abstract/file'
+require 'eac_templates/variables/content'
+require 'eac_templates/variables/providers'
+
+module EacTemplates
+  module Variables
+    class File
+      enable_simple_cache
+      common_constructor :abstract_file do
+        self.abstract_file = ::EacTemplates::Abstract::File.assert(abstract_file)
+      end
+      delegate :path, to: :abstract_file
+      delegate :apply, :apply_to_file, :content, :variables, to: :content_applier
+
+      private
+
+      # @return [EacTemplates::Variables::Content]
+      def content_applier_uncached
+        ::EacTemplates::Variables::Content.from_file(path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'eac_templates/variables/file'
+
+module EacTemplates
+  module Variables
+    class FsObject
+      TEMPLATE_EXTNAME = '.template'
+
+      common_constructor :source_directory, :source_relative, :target_root_directory,
+                         :variables_source
+
+      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::Variables::File.new(source_absolute).apply_to_file(
+            variables_source, target_absolute
+          )
+        else
+          ::FileUtils.cp(source_absolute, target_absolute)
+        end
+      end
+
+      def child(entry)
+        self.class.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/sub/eac_templates/lib/eac_templates/variables/not_found_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EacTemplates
+  module Variables
+    class NotFoundError < StandardError; end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variables/providers/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_templates/variables/not_found_error'
+
+module EacTemplates
+  module Variables
+    module Providers
+      class Base
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+        end
+
+        def variable_value(name)
+          return variable_fetch(name) if variable_exist?(name)
+
+          raise ::EacTemplates::Variables::NotFoundError,
+                "Variable \"#{name}\" not found in #{source}"
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variables/providers/config_reader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'eac_config'
+require 'eac_templates/variables/providers/base'
+
+module EacTemplates
+  module Variables
+    module Providers
+      class ConfigReader < ::EacTemplates::Variables::Providers::Base
+        class << self
+          def accept?(variables_source)
+            return false unless variables_source.respond_to?(:entry)
+
+            entry = variables_source.entry(:any_value)
+            entry.respond_to?(:value) && entry.respond_to?(:found?)
+          end
+        end
+
+        def variable_exist?(name)
+          source.entry(name).found?
+        end
+
+        def variable_fetch(name)
+          source.entry(name).value
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variables/providers/entries_reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_templates/variables/providers/base'
+
+module EacTemplates
+  module Variables
+    module Providers
+      class EntriesReader < ::EacTemplates::Variables::Providers::Base
+        class << self
+          def accept?(variables_source)
+            variables_source.respond_to?(:read_entry)
+          end
+        end
+
+        def variable_exist?(_name)
+          true
+        end
+
+        def variable_fetch(name)
+          source.read_entry(name)
+        end
+      end
+    end
+  end
+end

data/sub/eac_templates/lib/eac_templates/variables/providers/generic.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_templates/variables/providers/base'
+
+module EacTemplates
+  module Variables
+    module Providers
+      class Generic < ::EacTemplates::Variables::Providers::Base
+        class << self
+          def accept?(variables_source)
+            variables_source.is_a?(::Object)
+          end
+        end
+
+        def variable_exist?(name)
+          source.respond_to?(name)
+        end
+
+        def variable_fetch(name)
+          source.send(name)
+        end
+      end
+    end
+  end
+end