eac_ruby_utils 0.45.2 → 0.49.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '057846094b1a92346c2fe13e8ba0d6c7925c07a3391a92e67d2075c10a7c14c0'
-  data.tar.gz: 5fb02a73570910b32ca15f47b68f60cbc0f190549faf30dad121221fd49b504f
+  metadata.gz: 950ee0e703e04a530326ce6df19fa23a921061a3cc046d1ec880e1c078fd30fa
+  data.tar.gz: 3e81efb81e7fc9e8e5d23f1e5228eb6767be645a5ed1abefcb1d5551c39dc4b0
 SHA512:
-  metadata.gz: a50d5476451a0b2ad4a8f07b1949beb03e203d84a90f213485c8e8e822e31980f1c7f08407f16c7743de70f2f6386523caeab966954342e561cd0ee0712cd4d3
-  data.tar.gz: 53fdf67bfc39e3e044c561f64ccadbef9ed4da485d35877348a8a1d1f5b261ba3ab33aa069d828c00c172564fd1eed240a726255edf84b834fe37a87c572c0fc
+  metadata.gz: a05690c1726e671c20b7a85e1c0ac44387c085ff2cba3d7381a7ffab7850f056a014f301d2360c8610cd266879ac368af0f27a4c7738ae9a53306442316bbed6
+  data.tar.gz: 256ad147935d38435623279add15c7ae78de97357864cc0d065aaed9b3e2095a4ded3a63ca51ac70c966900f8dff2acc07d887656140cfa65068f5ced27b5eef

data/lib/eac_ruby_utils/blank_not_blank.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'singleton'
+
+module EacRubyUtils
+  # A blank string which returns +false+ for +blank?+ method.
+  class BlankNotBlank < String
+    include ::Singleton
+
+    def initialize
+      super('')
+    end
+
+    def blank?
+      false
+    end
+  end
+end

data/lib/eac_ruby_utils/configs/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/blank_not_blank'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/paths_hash'
+
+module EacRubyUtils
+  class Configs
+    class Base
+      enable_simple_cache
+
+      common_constructor :data, default: [{}] do
+        self.data = ::EacRubyUtils::PathsHash.new(data)
+      end
+
+      def []=(entry_key, entry_value)
+        write(entry_key, entry_value)
+      end
+
+      def [](entry_key)
+        read(entry_key)
+      end
+
+      def clear
+        replace({})
+      end
+
+      def read(entry_key)
+        return nil unless data.key?(entry_key)
+
+        data.fetch(entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
+      end
+
+      def replace(new_data)
+        self.data = ::EacRubyUtils::PathsHash.new(new_data)
+      end
+
+      def write(entry_key, entry_value)
+        data[entry_key] = entry_value
+      end
+    end
+  end
+end

data/lib/eac_ruby_utils/configs/file.rb

@@ -1,27 +1,18 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string'
+require 'eac_ruby_utils/configs/base'
 require 'yaml'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-require 'eac_ruby_utils/paths_hash'
-require 'eac_ruby_utils/simple_cache'
 
 module EacRubyUtils
   class Configs
-    class File
-      include ::EacRubyUtils::SimpleCache
-
+    class File < ::EacRubyUtils::Configs::Base
       attr_reader :path, :options
 
       # Valid options: [:autosave]
       def initialize(path, options = {})
         @path = path
         @options = options.to_sym_keys_hash.freeze
-        load
-      end
-
-      def clear
-        self.data = ::EacRubyUtils::PathsHash.new({})
+        super(raw_data_from_file)
       end
 
       def save
@@ -30,37 +21,27 @@ module EacRubyUtils
       end
 
       def load
-        self.data = if ::File.exist?(path) && ::File.size(path).positive?
-                      ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
-                    else
-                      {}
-                    end
-      end
-
-      def []=(entry_key, entry_value)
-        write(entry_key, entry_value)
+        replace(raw_data_from_file)
       end
 
       def write(entry_key, entry_value)
-        data[entry_key] = entry_value
+        super
         save if autosave?
       end
 
-      def [](entry_key)
-        read(entry_key)
-      end
-
-      def read(entry_key)
-        data[entry_key]
-      end
-
       def autosave?
         options[:autosave] ? true : false
       end
 
       private
 
-      attr_accessor :data
+      def raw_data_from_file
+        if ::File.exist?(path) && ::File.size(path).positive?
+          ::YAML.load_file(path)
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/eac_ruby_utils/console/configs.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/common_constructor'
 require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/console/speaker'
-require 'eac_ruby_utils/options_consumer'
-require 'eac_ruby_utils/patches/object/asserts'
-require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   module Console
     class Configs
-      include ::EacRubyUtils::Console::Speaker
+      require_sub __FILE__
+      enable_console_speaker
 
       class << self
         def entry_key_to_envvar_name(entry_key)
@@ -34,7 +31,7 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = options.merge(noecho: true)
+        options = ReadEntryOptions.new(options.merge(noecho: true))
         if store_passwords?
           read_entry(entry_key, options)
         else
@@ -66,7 +63,10 @@ module EacRubyUtils
       protected
 
       def envvar_read_entry(entry_key)
-        ENV[self.class.entry_key_to_envvar_name(entry_key)]
+        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
+        return nil unless ENV.key?(env_entry_key)
+
+        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
       end
 
       def read_entry_from_console(entry_key, options)
@@ -98,38 +98,6 @@ module EacRubyUtils
         warn('Entered value is blank') if entry_value.blank?
         entry_value
       end
-
-      class ReadEntryOptions
-        include ::EacRubyUtils::SimpleCache
-        ::EacRubyUtils::CommonConstructor.new(:options).setup_class(self)
-
-        DEFAULT_VALUES = {
-          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, validator: nil
-        }.freeze
-
-        def [](key)
-          values.fetch(key.to_sym)
-        end
-
-        def request_input_options
-          values.slice(:bool, :list, :noecho)
-        end
-
-        private
-
-        def values_uncached
-          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
-          r = {}
-          DEFAULT_VALUES.each do |key, default_value|
-            value = consumer.consume(key)
-            value = default_value if value.nil?
-            r[key] = value
-          end
-          consumer.validate
-          r
-        end
-      end
     end
   end
 end

data/lib/eac_ruby_utils/console/configs/read_entry_options.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class ReadEntryOptions
+        enable_simple_cache
+        common_constructor :options
+
+        DEFAULT_VALUES = {
+          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+          required: true, validator: nil
+        }.freeze
+
+        def [](key)
+          values.fetch(key.to_sym)
+        end
+
+        def request_input_options
+          values.slice(:bool, :list, :noecho)
+        end
+
+        private
+
+        def values_uncached
+          consumer = options.to_options_consumer
+          r = {}
+          DEFAULT_VALUES.each do |key, default_value|
+            value = consumer.consume(key)
+            value = default_value if value.nil?
+            r[key] = value
+          end
+          consumer.validate
+          r
+        end
+      end
+    end
+  end
+end

data/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/lib/eac_ruby_utils/paths_hash.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/object'
-require 'eac_ruby_utils/patches/object/asserts'
+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 EntryKeyError, 'Entry key cannot start or end with dot' if
+        raise ::EacRubyUtils::PathsHash::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?
+        if r.empty?
+          raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
+        end
         return r.map(&:to_sym) unless r.any?(&:blank?)
 
-        raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
+        raise ::EacRubyUtils::PathsHash::EntryKeyError,
+              "Entry key \"#{entry_key}\" has at least one blank part"
       end
     end
 
@@ -26,68 +30,27 @@ module EacRubyUtils
     end
 
     def [](entry_key)
-      root.read_entry(self.class.parse_entry_key(entry_key), [])
+      root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
     def []=(entry_key, entry_value)
-      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+      root.write_entry(
+        ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
+      )
     end
 
-    delegate :to_h, to: :root
-
-    private
-
-    attr_reader :data
-
-    class EntryKeyError < StandardError
+    def fetch(entry_key)
+      root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     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 key?(entry_key)
+      root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
 
-      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
+    delegate :to_h, to: :root
 
-      def validate_path(path, current)
-        path.assert_argument(Array, 'path')
-        current.assert_argument(Array, 'current')
-        raise EntryKeyError, 'Path is empty' if path.empty?
-      end
+    private
 
-      attr_reader :data
-    end
+    attr_reader :data
   end
 end

data/lib/eac_ruby_utils/paths_hash/entry_key_error.rb

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

data/lib/eac_ruby_utils/paths_hash/node.rb

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

@@ -0,0 +1,39 @@
+# 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/ruby/command.rb

@@ -8,7 +8,8 @@ module EacRubyUtils
     # A [EacRubyUtils::Envs::Command] which runs in a clean Ruby environment.
     class Command < ::EacRubyUtils::Envs::Command
       def initialize(bundle_args, extra_options = {})
-        super(::EacRubyUtils::Envs.local, bundle_args, extra_options)
+        host_env = extra_options.delete(:host_env)
+        super(host_env || ::EacRubyUtils::Envs.local, bundle_args, extra_options)
       end
 
       %w[system execute].each do |method_prefix|

data/lib/eac_ruby_utils/simple_cache.rb

@@ -21,8 +21,12 @@ module EacRubyUtils
       end
     end
 
-    def reset_cache
-      @cache_keys = nil
+    def reset_cache(*keys)
+      if keys.any?
+        keys.each { |key| cache_keys.delete(key) }
+      else
+        @cache_keys = nil
+      end
     end
 
     private

data/lib/eac_ruby_utils/struct.rb

@@ -27,6 +27,16 @@ module EacRubyUtils
       property_method?(method_name) || super
     end
 
+    def slice_fetch(*keys)
+      self.class.new(keys.map { |key| [key, fetch(key)] }.to_h)
+    end
+
+    def to_h
+      data.dup
+    end
+
+    delegate :to_s, to: :data
+
     private
 
     attr_accessor :data

data/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.45.2'
+  VERSION = '0.49.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eac_ruby_utils
 version: !ruby/object:Gem::Version
-  version: 0.45.2
+  version: 0.49.1
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-22 00:00:00.000000000 Z
+date: 2020-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -109,14 +109,17 @@ files:
 - README.rdoc
 - lib/eac_ruby_utils.rb
 - lib/eac_ruby_utils/arguments_consumer.rb
+- lib/eac_ruby_utils/blank_not_blank.rb
 - lib/eac_ruby_utils/boolean.rb
 - lib/eac_ruby_utils/by_reference.rb
 - lib/eac_ruby_utils/common_concern.rb
 - lib/eac_ruby_utils/common_constructor.rb
 - lib/eac_ruby_utils/configs.rb
+- lib/eac_ruby_utils/configs/base.rb
 - lib/eac_ruby_utils/configs/file.rb
 - lib/eac_ruby_utils/console.rb
 - lib/eac_ruby_utils/console/configs.rb
+- lib/eac_ruby_utils/console/configs/read_entry_options.rb
 - lib/eac_ruby_utils/console/docopt_runner.rb
 - lib/eac_ruby_utils/console/docopt_runner/_class_methods.rb
 - lib/eac_ruby_utils/console/docopt_runner/_doc.rb
@@ -146,6 +149,7 @@ files:
 - lib/eac_ruby_utils/envs/ssh_env/terminal.rb
 - lib/eac_ruby_utils/filesystem_cache.rb
 - lib/eac_ruby_utils/fs.rb
+- lib/eac_ruby_utils/fs/clearable_directory.rb
 - lib/eac_ruby_utils/fs/extname.rb
 - lib/eac_ruby_utils/fs/temp.rb
 - lib/eac_ruby_utils/fs/temp/directory.rb
@@ -206,6 +210,9 @@ files:
 - lib/eac_ruby_utils/patches/time/default_time_zone_set.rb
 - lib/eac_ruby_utils/patches/time/local_time_zone.rb
 - lib/eac_ruby_utils/paths_hash.rb
+- lib/eac_ruby_utils/paths_hash/entry_key_error.rb
+- lib/eac_ruby_utils/paths_hash/node.rb
+- lib/eac_ruby_utils/paths_hash/path_search.rb
 - lib/eac_ruby_utils/require_sub.rb
 - lib/eac_ruby_utils/rspec.rb
 - lib/eac_ruby_utils/rspec/conditional.rb