ehbrs-tools 0.3.0

data/vendor/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)
+          Hash[labels.first.map { |k, v| [k.to_s, v.to_s] }]
+        else
+          Hash[labels.map { |v| [v.to_s, v.to_s] }]
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Listable
+    class Value
+      attr_reader :value, :key
+
+      def initialize(list, value, key)
+        @list = list
+        @value = value
+        @key = key
+      end
+
+      def to_s
+        "I: #{@list.item}, V: #{@value}, K: #{@key}"
+      end
+
+      def constant_name
+        "#{@list.item}_#{@key}".gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_')
+                               .gsub(/(?:\A_|_\z)/, '').upcase
+      end
+
+      def label
+        translate('label')
+      end
+
+      def description
+        translate('description')
+      end
+
+      private
+
+      def translate(translate_key)
+        ::I18n.t("#{@list.i18n_key}.#{@key}.#{translate_key}")
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/on_clean_ruby_environment.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class << self
+    def on_clean_ruby_environment
+      on_clean_envvars('BUNDLE', 'RUBY') { yield }
+    end
+
+    private
+
+    def on_clean_envvars(*start_with_vars)
+      old_values = envvars_starting_with(start_with_vars)
+      old_values.keys.each { |k| ENV.delete(k) }
+      yield
+    ensure
+      old_values&.each { |k, v| ENV[k] = v }
+    end
+
+    def envvars_starting_with(start_with_vars)
+      ENV.select { |k, _v| start_with_vars.any? { |var| k.start_with?(var) } }
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/options_consumer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'ostruct'
+
+module EacRubyUtils
+  class OptionsConsumer
+    DEFAULT_OPTIONS = { validate: true, ostruct: false }.with_indifferent_access.freeze
+
+    def initialize(data)
+      @data = data.with_indifferent_access
+    end
+
+    def consume(key, default_value = nil, &block)
+      return default_value unless data.key?(key)
+
+      value = data.delete(key)
+      value = yield(value) if block
+      value
+    end
+
+    # If last argument is a Hash it is used a options.
+    # Options:
+    # * +validate+: validate after consume.
+    # * +ostruct+: return a [OpenStruct] instead a [Hash].
+    # @return [Hash] (Default) or [OpenStruct].
+    def consume_all(*keys)
+      options = consume_all_extract_options(keys)
+      result = consume_all_build_result(keys, options.fetch(:ostruct))
+      validate if options.fetch(:validate)
+      result
+    end
+
+    def validate
+      return if data.empty?
+
+      raise "Invalid keys: #{data.keys}"
+    end
+
+    def left_data
+      data.dup
+    end
+
+    private
+
+    attr_reader :data
+
+    def consume_all_extract_options(keys)
+      options = DEFAULT_OPTIONS
+      options = options.merge(keys.pop.with_indifferent_access) if keys.last.is_a?(Hash)
+      options
+    end
+
+    def consume_all_build_result(keys, ostruct)
+      if ostruct
+        ::OpenStruct.new(keys.map { |key| [key, consume(key)] }.to_h)
+      else
+        keys.map { |key| consume(key) }
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class << self
+    def patch(target, patch)
+      return if target.included_modules.include?(patch)
+
+      target.send(:include, patch)
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches.rb

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

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/class.rb

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

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/class/common_constructor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+
+class Class
+  def common_constructor(*args)
+    ::EacRubyUtils::CommonConstructor.new(*args).setup_class(self)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{::File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
+  require path
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/options_consumer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/options_consumer'
+
+class Hash
+  # Returns an <tt>EacRubyUtils::OptionsConsumer</tt> out of its receiver.
+  def to_options_consumer
+    ::EacRubyUtils::OptionsConsumer.new(self)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/sym_keys_hash.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Hash
+  def to_sym_keys_hash
+    each_with_object({}) do |(key, value), memo|
+      symbol_key = key.respond_to?(:to_sym) ? key.to_sym : key.to_s.to_sym
+      memo[symbol_key] = value
+    end
+  end
+end

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

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

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

@@ -0,0 +1,10 @@
+# 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/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/listable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/listable'
+
+class Module
+  def enable_listable
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Listable)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/patch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+
+class Module
+  def patch(patch_module)
+    ::Eac::Ruby::Utils.patch(self, patch_module)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/require_sub.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+class Module
+  def require_sub(file_path)
+    ::EacRubyUtils.require_sub(file_path)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/simple_cache.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/simple_cache'
+
+class Module
+  def enable_simple_cache
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::SimpleCache)
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{::File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
+  require path
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/asserts.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Object
+  # Raises a ArgumentError if +self+ is not a +klass+.
+  #
+  # @return +self+
+  def assert_argument(klass, argument_name = 'unknown_argument_name')
+    return self if is_a?(klass)
+
+    raise ::ArgumentError,
+          "Argument \"#{argument_name}\" is not a #{klass}" \
+          "(Actual class: #{self.class}, actual value: #{self})"
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_present.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+class Object
+  # @return +block.call(self)+ if +self+ is present, +default_value+ otherwise.
+  def if_present(default_value = nil)
+    return default_value unless present?
+
+    block_given? ? yield(self) : self
+  end
+end

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

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

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/paths_hash.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+require 'eac_ruby_utils/patches/object/asserts'
+
+module EacRubyUtils
+  class PathsHash
+    class << self
+      def parse_entry_key(entry_key)
+        r = entry_key.to_s.strip
+        raise EntryKeyError, 'Entry key cannot start or end with dot' if
+        r.start_with?('.') || r.end_with?('.')
+
+        r = r.split('.').map(&:strip)
+        raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
+        return r.map(&:to_sym) unless r.any?(&:blank?)
+
+        raise 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(self.class.parse_entry_key(entry_key), [])
+    end
+
+    def []=(entry_key, entry_value)
+      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+    end
+
+    def to_h
+      root.to_h
+    end
+
+    private
+
+    attr_reader :data
+
+    class EntryKeyError < StandardError
+    end
+
+    class Node
+      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 to_h
+        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
+      end
+
+      def read_entry(path, current)
+        validate_path(path, current)
+        node_key = path.shift
+        node = data[node_key]
+        return (node.is_a?(Node) ? node.to_h : node) if path.empty?
+        return nil if node.blank?
+        return node.read_entry(path, current + [node_key]) if node.is_a?(Node)
+
+        raise(EntryKeyError,
+              "Path #{current.join(',')} is not a Node and path continues (#{current + path})")
+      end
+
+      def write_entry(path, value, current)
+        validate_path(path, current)
+        node_key = path.shift
+        write_entry_value(path, node_key, value, current)
+      end
+
+      private
+
+      def write_entry_value(path, node_key, value, current)
+        if path.empty?
+          data[node_key] = value.is_a?(Hash) ? Node.new(value) : value
+        else
+          data[node_key] = Node.new({}) unless data[node_key].is_a?(Node)
+          data[node_key].write_entry(path, value, current + [node_key])
+        end
+      end
+
+      def validate_path(path, current)
+        path.assert_argument(Array, 'path')
+        current.assert_argument(Array, 'current')
+        raise EntryKeyError, 'Path is empty' if path.empty?
+      end
+
+      attr_reader :data
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/require_sub.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class << self
+    def require_sub(file)
+      Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}/*.rb"].sort.each do |path|
+        require path
+      end
+    end
+  end
+end