eac_ruby_utils 0.63.0 → 0.64.0

data/lib/eac_ruby_utils/console/speaker/_class_methods.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/speaker/node'
-
-module EacRubyUtils
-  module Console
-    module Speaker
-      class << self
-        def current_node
-          nodes_stack.last
-        end
-
-        def on_node(&block)
-          push
-          yield(*(block.arity.zero? ? [] : [current_node]))
-        ensure
-          pop
-        end
-
-        def push
-          nodes_stack << ::EacRubyUtils::Console::Speaker::Node.new
-          current_node
-        end
-
-        def pop
-          return nodes_stack.pop if nodes_stack.count > 1
-
-          raise "Cannot remove first node (nodes_stack.count: #{nodes_stack.count})"
-        end
-
-        private
-
-        def nodes_stack
-          @nodes_stack ||= [::EacRubyUtils::Console::Speaker::Node.new]
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/speaker/_constants.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/by_reference'
-
-module EacRubyUtils
-  module Console
-    # https://github.com/fazibear/colorize
-    module Speaker
-      STDERR = ::EacRubyUtils::ByReference.new { $stderr }
-      STDIN = ::EacRubyUtils::ByReference.new { $stdin }
-      STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
-    end
-  end
-end

data/lib/eac_ruby_utils/console/speaker/list.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'ostruct'
-
-module EacRubyUtils
-  module Console
-    module Speaker
-      class List
-        class << self
-          def build(list)
-            return List.new(hash_to_values(list)) if list.is_a?(::Hash)
-            return List.new(array_to_values(list)) if list.is_a?(::Array)
-
-            raise "Invalid list: #{list} (#{list.class})"
-          end
-
-          private
-
-          def hash_to_values(list)
-            list.map { |key, value| ::OpenStruct.new(key: key, label: key, value: value) }
-          end
-
-          def array_to_values(list)
-            list.map { |value| ::OpenStruct.new(key: value, label: value, value: value) }
-          end
-        end
-
-        attr_reader :values
-
-        def initialize(values)
-          @values = values.map do |v|
-            ::OpenStruct.new(key: to_key(v.key), label: to_label(v.label), value: v.value)
-          end
-        end
-
-        def valid_labels
-          values.map(&:label)
-        end
-
-        def valid_value?(value)
-          values.any? { |v| v.key == to_key(value) }
-        end
-
-        def to_key(value)
-          to_label(value).downcase
-        end
-
-        def to_label(value)
-          value.to_s.strip
-        end
-
-        def build_value(value)
-          key = to_key(value)
-          values.each do |v|
-            return v.value if v.key == key
-          end
-          raise "Value not found: \"#{value}\" (#{values})"
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/console/speaker/node.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/object/if_present'
-require 'eac_ruby_utils/console/speaker/_constants'
-
-module EacRubyUtils
-  module Console
-    module Speaker
-      class Node
-        attr_accessor :stdin, :stdout, :stderr, :stderr_line_prefix
-
-        def initialize(parent = nil)
-          self.stdin = parent.if_present(::EacRubyUtils::Console::Speaker::STDIN, &:stdin)
-          self.stdout = parent.if_present(::EacRubyUtils::Console::Speaker::STDOUT, &:stdout)
-          self.stderr = parent.if_present(::EacRubyUtils::Console::Speaker::STDERR, &:stderr)
-          self.stderr_line_prefix = parent.if_present('', &:stderr_line_prefix)
-        end
-
-        def configure
-          yield(self)
-          self
-        end
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/patches/module/console_speaker.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patch'
-require 'eac_ruby_utils/console/speaker'
-
-class Module
-  def enable_console_speaker
-    ::EacRubyUtils.patch(self, ::EacRubyUtils::Console::Speaker)
-  end
-end

data/lib/eac_ruby_utils/patches/module/template.rb

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

data/lib/eac_ruby_utils/patches/object/template.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/module/template'
-
-class Object
-  def template
-    self.class.template
-  end
-end

data/lib/eac_ruby_utils/paths_hash.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  class PathsHash
-    require_sub __FILE__
-
-    class << self
-      def parse_entry_key(entry_key)
-        r = entry_key.to_s.strip
-        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
-        r.start_with?('.') || r.end_with?('.')
-
-        r = r.split('.').map(&:strip)
-        if r.empty?
-          raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
-        end
-        return r.map(&:to_sym) unless r.any?(&:blank?)
-
-        raise ::EacRubyUtils::PathsHash::EntryKeyError,
-              "Entry key \"#{entry_key}\" has at least one blank part"
-      end
-    end
-
-    attr_reader :root
-
-    def initialize(source_hash = {})
-      @root = Node.new(source_hash)
-    end
-
-    def [](entry_key)
-      root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
-    end
-
-    def []=(entry_key, entry_value)
-      root.write_entry(
-        ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
-      )
-    end
-
-    def fetch(entry_key)
-      root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
-    end
-
-    def key?(entry_key)
-      root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
-    end
-
-    delegate :to_h, to: :root
-
-    private
-
-    attr_reader :data
-  end
-end

data/lib/eac_ruby_utils/paths_hash/entry_key_error.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  class PathsHash
-    class EntryKeyError < StandardError
-    end
-  end
-end

data/lib/eac_ruby_utils/paths_hash/node.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/paths_hash/entry_key_error'
-
-module EacRubyUtils
-  class PathsHash
-    class Node
-      PATH_SEARCH_UNENDED_ERROR_MESSAGE = 'Path search is not a Node and is not ended'
-
-      def initialize(source_hash)
-        source_hash.assert_argument(Hash, 'source_hash')
-        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
-      end
-
-      def entry?(path_search)
-        return false unless data.key?(path_search.cursor)
-        return true if path_search.ended?
-        return data.fetch(path_search.cursor).entry?(path_search.succeeding) if
-          data.fetch(path_search.cursor).is_a?(Node)
-
-        false # Paths continue and there is not available nodes
-      end
-
-      def fetch(path_search)
-        if data.key?(path_search.cursor)
-          node = data.fetch(path_search.cursor)
-          return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
-          return nil if node.blank?
-          return node.fetch(path_search.succeeding) if node.is_a?(Node)
-        end
-
-        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
-      end
-
-      def to_h
-        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
-      end
-
-      def read_entry(path_search)
-        node = data[path_search.cursor]
-        return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
-        return nil if node.blank?
-        return node.read_entry(path_search.succeeding) if node.is_a?(Node)
-
-        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
-      end
-
-      def write_entry(path_search, value)
-        if path_search.ended?
-          data[path_search.cursor] = value.is_a?(Hash) ? self.class.new(value) : value
-        else
-          assert_data_node(path_search.cursor).write_entry(path_search.succeeding, value)
-        end
-      end
-
-      private
-
-      attr_reader :data
-
-      def assert_data_node(key)
-        data[key] = self.class.new({}) unless data[key].is_a?(Node)
-        data[key]
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/paths_hash/path_search.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  class PathsHash
-    class PathSearch
-      class << self
-        def parse_entry_key(string)
-          new(::EacRubyUtils::PathsHash.parse_entry_key(string), [])
-        end
-      end
-
-      common_constructor :current, :previous do
-        self.current = current.assert_argument(Array, 'current').freeze
-        self.previous = previous.assert_argument(Array, 'previous')
-        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Current is empty' if current.empty?
-      end
-
-      def cursor
-        current.first
-      end
-
-      def ended?
-        current.count <= 1
-      end
-
-      def raise_error(message)
-        raise ::EacRubyUtils::PathsHash::EntryKeyError, "#{message} (#{self})"
-      end
-
-      def succeeding
-        self.class.new(current[1..-1], previous + [cursor])
-      end
-
-      def to_s
-        "#{self.class}[Current: #{current}, Previous: #{previous}]"
-      end
-    end
-  end
-end

data/lib/eac_ruby_utils/templates.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-module Avm
-  module Templates
-    ::EacRubyUtils.require_sub(__FILE__)
-  end
-end

data/lib/eac_ruby_utils/templates/directory.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/templates/file'
-
-module EacRubyUtils
-  module Templates
-    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 ::EacRubyUtils::Templates::File.new(child_path) if ::File.file?(child_path)
-        return ::EacRubyUtils::Templates::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
-            ::EacRubyUtils::Templates::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
-end