eac_tools 0.89.0 → 0.90.0

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/clearable_directory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module EacRubyUtils
+  module Fs
+    class ClearableDirectory < ::Pathname
+      CLEARABLE_BASENAME = '.clearable_directory'
+
+      def clear
+        validate_clearable
+        directory? ? clear_directory : clear_no_directory
+        mkpath
+        ::FileUtils.touch(clearable_note_file.to_path)
+        self
+      end
+
+      def clearable?
+        clearable_negate_message ? true : false
+      end
+
+      def clearable_negate_message
+        return if !exist? || empty?
+        return "Path \"#{self}\" exists, is not empty and is not a directory" unless directory?
+        return if clearable_note_file.exist?
+
+        "Directory \"#{self}\" is not empty and does not have a #{CLEARABLE_BASENAME} file"
+      end
+
+      def clearable_note_file
+        join(CLEARABLE_BASENAME)
+      end
+
+      def validate_clearable
+        message = clearable_negate_message
+        raise message if message
+      end
+
+      private
+
+      def clear_directory
+        children.each do |child|
+          if child.directory?
+            child.rmtree
+          elsif child.file?
+            child.unlink
+          end
+        end
+      end
+
+      def clear_no_directory
+        ::FileUtils.rm_rf(to_path)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/extname.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Fs
+    class << self
+      # A [File.extname] which find multiple extensions (Ex.: .tar.gz).
+      def extname(path, limit = -1)
+        recursive_extension(::File.basename(path), limit)
+      end
+
+      # Shortcut to +extname(2)+.
+      def extname2(path)
+        extname(path, 2)
+      end
+
+      private
+
+      def recursive_extension(basename, limit)
+        return '' if limit.zero?
+
+        m = /\A(.+)(\.[a-z][a-z0-9]*)\z/i.match(basename)
+        if m
+          "#{recursive_extension(m[1], limit - 1)}#{m[2]}"
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/directory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/fs/temp/file'
+
+module EacRubyUtils
+  module Fs
+    module Temp
+      class Directory < ::EacRubyUtils::Fs::Temp::File
+        def initialize(*tempfile_args)
+          super(*tempfile_args)
+          mkpath
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'tempfile'
+
+module EacRubyUtils
+  module Fs
+    module Temp
+      class File < Pathname
+        # Temporary file
+        def initialize(*tempfile_args)
+          file = Tempfile.new(*tempfile_args)
+          path = file.path
+          file.close
+          file.unlink
+          super(path)
+        end
+
+        def remove
+          if directory?
+            rmtree
+          elsif file?
+            unlink
+          end
+        end
+
+        def remove!
+          remove
+          raise "Tried to remove \"#{self}\", but it yet exists" if exist?
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+require 'pathname'
+require 'tempfile'
+
+module EacRubyUtils
+  module Fs
+    # Utilities for temporary files.
+    module Temp
+      class << self
+        ::EacRubyUtils.require_sub __FILE__
+
+        # Shortcut to +EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)+.
+        #
+        # @return [Pathname]
+        def directory(*tempfile_args)
+          ::EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)
+        end
+
+        # Shortcut to +EacRubyUtils::Fs::Temp::File.new(*tempfile_args)+.
+        #
+        # @return [Pathname]
+        def file(*tempfile_args)
+          ::EacRubyUtils::Fs::Temp::File.new(*tempfile_args)
+        end
+
+        # Run a block while a temporary directory pathname is provided. The directory is deleted
+        # when the block is finished.
+        def on_directory(*tempfile_args)
+          temp_dir = directory(*tempfile_args)
+          begin
+            yield(temp_dir)
+          ensure
+            temp_dir.remove
+          end
+        end
+
+        # Run a block while a temporary file pathname is providade. The file is deleted when block
+        # is finished.
+        def on_file(*tempfile_args)
+          temp_file = file(*tempfile_args)
+          begin
+            yield(temp_file)
+          ensure
+            temp_file.remove
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs.rb

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/recursive_builder'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  class GemsRegistry
+    class Gem
+      include ::Comparable
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :registry, :gemspec
+
+      def initialize(registry, gemspec)
+        @registry = registry
+        @gemspec = gemspec
+      end
+
+      def depend_on(gem)
+        dependencies.lazy.map(&:name).include?(gem.gemspec.name)
+      end
+
+      def dependencies
+        @dependencies ||= dependencies_uncached # dependencies_uncached
+      end
+
+      def <=>(other)
+        sd = depend_on(other)
+        od = other.depend_on(self)
+        return 1 if sd && !od
+        return -1 if od && !sd
+
+        gemspec.name <=> other.gemspec.name
+      end
+
+      def found?
+        lib_file_found? && registered_module.is_a?(::Module)
+      end
+
+      def lib_file_found?
+        gemspec.require_paths.any? do |require_path|
+          ::Pathname.new(require_path).expand_path(gemspec.gem_dir).join("#{path_to_require}.rb")
+            .file?
+        end
+      end
+
+      def registered_module
+        return nil unless lib_file_found?
+
+        require path_to_require
+        path_to_require.camelize.constantize
+      end
+
+      # @return [String]
+      def path_to_require
+        "#{gemspec.name.gsub('-', '/')}/#{registry.module_suffix.underscore}"
+      end
+
+      def to_s
+        "#{self.class.name}[#{gemspec.name}]"
+      end
+
+      private
+
+      def dependencies_uncached
+        ::EacRubyUtils::RecursiveBuilder
+          .new(gemspec) { |item| gem_item_dependencies(item) }
+          .result
+      end
+
+      # @return [Array<Gem::Dependency>]
+      def gem_item_dependencies(item)
+        ::Gem::Specification.find_by_name(item.name).dependencies.select(&:runtime?)
+      rescue ::Gem::MissingSpecError
+        []
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'eac_ruby_utils/gems_registry/gem'
+
+module EacRubyUtils
+  # Search in each gem for a class determined by registry and run the method "register" on each
+  # found.
+  #
+  # Example:
+  # * The module suffix is `TheClass`;
+  # * A gem with name "my-lib" is being analyzed
+  # * If a require for "my/lib/the_class" is succesful the class/module `My::Lib::TheClass` will
+  #   be collected.
+  class GemsRegistry
+    attr_reader :module_suffix
+
+    def initialize(module_suffix)
+      @module_suffix = module_suffix
+    end
+
+    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
+    def registered
+      @registered ||= all_gems.select(&:found?).sort
+    end
+
+    private
+
+    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
+    def all_gems
+      ::Gem::Specification.map { |gemspec| ::EacRubyUtils::GemsRegistry::Gem.new(self, gemspec) }
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/inflector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module EacRubyUtils
+  class Inflector
+    class << self
+      VARIABLE_NAME_PATTERN = /[_a-z][_a-z0-9]*/i.freeze
+
+      # Convert a string to a variable format: first character as a lowercase letter or underscore
+      # and other as a lowercase letter, underscore or numbers.
+      # @param string [String] The source string.
+      # @param validate [Boolean] Affect the outcome when the result builded is not in a valid
+      #   variable format. If `true`, it raises a {ArgumentError}. If `false`, return `nil`.
+      # @return [String, nil]
+      # @raise [ArgumentError]
+      def variableize(string, validate = true) # rubocop:disable Style/OptionalBooleanParameter
+        r = ::ActiveSupport::Inflector.transliterate(string).gsub(/[^_a-z0-9]/i, '_')
+              .gsub(/_+/, '_').gsub(/_\z/, '').gsub(/\A_/, '').downcase
+        m = VARIABLE_NAME_PATTERN.match(r)
+        return r if m
+        return nil unless validate
+
+        raise ::ArgumentError, "Invalid variable name \"#{r}\" was generated " \
+                               "from string \"#{string}\""
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/class_methods.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'i18n'
+require_relative 'lists'
+
+module EacRubyUtils
+  module Listable
+    module ClassMethods
+      def lists
+        @lists ||= ::EacRubyUtils::Listable::Lists.new(self)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/instance_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Listable
+    module InstanceMethods
+      LISTABLE_INSTANCE_VALUE_METHODS = %w[label description].freeze
+
+      def method_missing(name, *args, &block)
+        list, method = parse_method(name)
+        list && method ? list.instance_value(self).send(method) : super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        list, method = parse_method(name)
+        list && method ? true : super
+      end
+
+      private
+
+      def parse_method(method)
+        self.class.lists.acts_as_listable_items.each do |item, list|
+          LISTABLE_INSTANCE_VALUE_METHODS.each do |m|
+            return [list, m] if method.to_s == "#{item}_#{m}"
+          end
+        end
+        [nil, nil]
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/integer_list.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class IntegerList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          labels.first.to_h { |k, v| [k.to_i, v.to_s] }
+        else
+          labels.each_with_index.to_h { |v, i| [i + 1, v.to_s] }
+        end
+      end
+
+      def build_value(index, _key)
+        index + 1
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/item.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/common_constructor'
+require 'eac_ruby_utils/inflector'
+
+module EacRubyUtils
+  module Listable
+    class Item
+      common_constructor :list, :value, :key, :translation_required, default: [true]
+
+      def to_s
+        "I: #{list.item}, V: #{value}, K: #{key}"
+      end
+
+      def constant_name
+        ::EacRubyUtils::Inflector.variableize("#{list.item}_#{key}").upcase
+      end
+
+      def label
+        translate('label')
+      end
+
+      def description
+        translate('description')
+      end
+
+      # @return [Array] A two-item array in format `[label, value]`.
+      def to_option
+        [label, value]
+      end
+
+      def translation_required?
+        translation_required
+      end
+
+      private
+
+      def translate(translate_key)
+        full_translate_key = "#{list.i18n_key}.#{key}.#{translate_key}"
+        if !::I18n.exists?(full_translate_key) && !translation_required?
+          ''
+        else
+          ::I18n.t(full_translate_key)
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/listable/item'
+
+module EacRubyUtils
+  module Listable
+    class List
+      BLANK_VALUE = nil
+      BLANK_KEY = :__blank
+
+      attr_reader :item
+
+      def initialize(lists, item, labels)
+        @lists = lists
+        @item = item
+        @values = build_values(labels)
+        apply_constants
+      end
+
+      def blank_value
+        @blank_value ||= ::EacRubyUtils::Listable::Item.new(self, BLANK_VALUE, BLANK_KEY, false)
+      end
+
+      def each_value(&block)
+        values.each(&block)
+      end
+
+      # @return [EacRubyUtils::Listable::Item, nil]
+      def item_by_value(value)
+        @values.values.find { |item| item.value == value }
+      end
+
+      # @return [EacRubyUtils::Listable::Item]
+      def item_by_value!(value)
+        item_by_value(value) || raise(::KeyError, "Value not found: #{value}")
+      end
+
+      def values
+        @values.values.map(&:value)
+      end
+
+      def values_with_blank
+        [blank_value.value] + values
+      end
+
+      def options
+        @values.values.map(&:to_option)
+      end
+
+      def options_with_blank
+        [blank_value.to_option] + options
+      end
+
+      def method_missing(name, *args, &block)
+        list = find_list_by_method(name)
+        list || super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        find_list_by_method(name) || super
+      end
+
+      def hash_keys_validate!(hash, error_class = ::StandardError)
+        hash.each_key { |key| value_validate!(key, error_class) }
+        hash
+      end
+
+      def i18n_key
+        "eac_ruby_utils.listable.#{class_i18n_key}.#{item}"
+      end
+
+      # @return [EacRubyUtils::Listable::Item, nil]
+      def instance_value(instance)
+        v = instance.send(item)
+        return blank_value if v.blank?
+        return @values[v] if @values.key?(v)
+
+        raise "List value unkown: \"#{v}\" (Source: #{@lists.source}, Item: #{item}, Instance: " \
+              "#{instance.to_debug}, Values: #{@values.keys})"
+      end
+
+      def value_valid?(value)
+        values.include?(value)
+      end
+
+      def value_validate!(value, error_class = ::StandardError)
+        return value if value_valid?(value)
+
+        raise(error_class, "Invalid value: \"#{value}\" (Valid: #{values_to_s})")
+      end
+
+      def values_to_s
+        values.map { |v| "\"#{v}\"" }.join(', ')
+      end
+
+      private
+
+      def class_i18n_key
+        @lists.source.name.underscore.to_sym
+      end
+
+      def find_list_by_method(method)
+        @values.each_value do |v|
+          return v if method.to_s == "value_#{v.key}"
+        end
+        nil
+      end
+
+      def constants
+        labels.each_with_index.map { |v, i| ["#{item.upcase}_#{v.upcase}", values[i]] }
+      end
+
+      def apply_constants
+        @values.each_value do |v|
+          @lists.source.const_set(v.constant_name, v.value)
+        end
+      end
+
+      def build_values(labels)
+        vs = {}
+        parse_labels(labels).each do |value, key|
+          v = ::EacRubyUtils::Listable::Item.new(self, value, key)
+          vs[v.value] = v
+        end
+        vs
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/lists.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require_relative 'integer_list'
+require_relative 'string_list'
+require_relative 'symbol_list'
+
+module EacRubyUtils
+  module Listable
+    class Lists
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      %w[integer string symbol].each do |list_type|
+        define_method "add_#{list_type}" do |item, *labels|
+          add(::EacRubyUtils::Listable.const_get("#{list_type}_list".camelize), item, labels)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        list = find_list_by_method(name)
+        list || super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        find_list_by_method(name) || super
+      end
+
+      def acts_as_listable_items
+        @acts_as_listable_items ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      private
+
+      def add(list_class, item, labels)
+        acts_as_listable_items[item] = list_class.new(self, item, labels)
+      end
+
+      def find_list_by_method(method)
+        acts_as_listable_items.each do |item, list|
+          return list if method.to_sym == item.to_sym
+        end
+        nil
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/string_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class StringList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          labels.first.to_h { |k, v| [k.to_s, v.to_s] }
+        else
+          labels.to_h { |v| [v.to_s, v.to_s] }
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/symbol_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class SymbolList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          labels.first.to_h { |k, v| [k.to_sym, v.to_sym] }
+        else
+          labels.to_h { |v| [v.to_sym, v.to_sym] }
+        end
+      end
+    end
+  end
+end