eac_ruby_utils 0.47.0 → 0.48.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: cdfe776f80d9f9d2326f040cc996e8b2dc5a08aaf7cb8eccf0a3ebb3b6d2ab4d
4
- data.tar.gz: 4b0b779ca185c887ee7204050428060a115d12392f1807017a2dd16beec934ae
3
+ metadata.gz: 16853127a3903c811f7a5c6c2be3ebbe3da92a92264e2c52ef94ead623e34399
4
+ data.tar.gz: a1fab6ef432f51fabe7f4680f63e8117268a3f8b704c89891690f95d7faba60d
5
5
  SHA512:
6
- metadata.gz: 9eace3e6ff7bdab20d791e9d7e5bfe81f9f8bd6ca93fb815bb77d63d30a0c2d1604ee4e3bfecbe892b179dc7c557ee9b1554a26281ba003326c12fc50c2f9ce3
7
- data.tar.gz: 5ea6a75da16e45cf51e4610dbe7f0fd51ec4ccc7a7e52f96f0f5590be168d5fa6d7a1d95e95e890e10c36736b33dc2323b2549f5e8c1caf21c4af47a27e59ba5
6
+ metadata.gz: 365db8b5fecb7af045b74ad800723ddb95bd125c54885ab7da440db75d8ea7e0d779071dd63afeb6480c4af5d88bd86e180bb65ba5d399d9eac0deb8a9c01319
7
+ data.tar.gz: 13de4c8a8ef0beebeb1e157be399945ea2e93575c0f85ce7600e37e24905b6f0fc98a232d63d29a558892d3da1df62236f329212d0df66f00d24d6580ef5b5ec
@@ -0,0 +1,19 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'active_support/core_ext/object/blank'
4
+ require 'singleton'
5
+
6
+ module EacRubyUtils
7
+ # A blank string which returns +false+ for +blank?+ method.
8
+ class BlankNotBlank < String
9
+ include ::Singleton
10
+
11
+ def initialize
12
+ super('')
13
+ end
14
+
15
+ def blank?
16
+ false
17
+ end
18
+ end
19
+ end
@@ -0,0 +1,43 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'eac_ruby_utils/blank_not_blank'
4
+ require 'eac_ruby_utils/core_ext'
5
+ require 'eac_ruby_utils/paths_hash'
6
+
7
+ module EacRubyUtils
8
+ class Configs
9
+ class Base
10
+ enable_simple_cache
11
+
12
+ common_constructor :data, default: [{}] do
13
+ self.data = ::EacRubyUtils::PathsHash.new(data)
14
+ end
15
+
16
+ def []=(entry_key, entry_value)
17
+ write(entry_key, entry_value)
18
+ end
19
+
20
+ def [](entry_key)
21
+ read(entry_key)
22
+ end
23
+
24
+ def clear
25
+ replace({})
26
+ end
27
+
28
+ def read(entry_key)
29
+ return nil unless data.key?(entry_key)
30
+
31
+ data.fetch(entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
32
+ end
33
+
34
+ def replace(new_data)
35
+ self.data = ::EacRubyUtils::PathsHash.new(new_data)
36
+ end
37
+
38
+ def write(entry_key, entry_value)
39
+ data[entry_key] = entry_value
40
+ end
41
+ end
42
+ end
43
+ end
@@ -1,27 +1,18 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- require 'active_support/core_ext/string'
3
+ require 'eac_ruby_utils/configs/base'
4
4
  require 'yaml'
5
- require 'eac_ruby_utils/patches/hash/sym_keys_hash'
6
- require 'eac_ruby_utils/paths_hash'
7
- require 'eac_ruby_utils/simple_cache'
8
5
 
9
6
  module EacRubyUtils
10
7
  class Configs
11
- class File
12
- include ::EacRubyUtils::SimpleCache
13
-
8
+ class File < ::EacRubyUtils::Configs::Base
14
9
  attr_reader :path, :options
15
10
 
16
11
  # Valid options: [:autosave]
17
12
  def initialize(path, options = {})
18
13
  @path = path
19
14
  @options = options.to_sym_keys_hash.freeze
20
- load
21
- end
22
-
23
- def clear
24
- self.data = ::EacRubyUtils::PathsHash.new({})
15
+ super(raw_data_from_file)
25
16
  end
26
17
 
27
18
  def save
@@ -30,37 +21,27 @@ module EacRubyUtils
30
21
  end
31
22
 
32
23
  def load
33
- self.data = if ::File.exist?(path) && ::File.size(path).positive?
34
- ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
35
- else
36
- {}
37
- end
38
- end
39
-
40
- def []=(entry_key, entry_value)
41
- write(entry_key, entry_value)
24
+ replace(raw_data_from_file)
42
25
  end
43
26
 
44
27
  def write(entry_key, entry_value)
45
- data[entry_key] = entry_value
28
+ super
46
29
  save if autosave?
47
30
  end
48
31
 
49
- def [](entry_key)
50
- read(entry_key)
51
- end
52
-
53
- def read(entry_key)
54
- data[entry_key]
55
- end
56
-
57
32
  def autosave?
58
33
  options[:autosave] ? true : false
59
34
  end
60
35
 
61
36
  private
62
37
 
63
- attr_accessor :data
38
+ def raw_data_from_file
39
+ if ::File.exist?(path) && ::File.size(path).positive?
40
+ ::YAML.load_file(path)
41
+ else
42
+ {}
43
+ end
44
+ end
64
45
  end
65
46
  end
66
47
  end
@@ -66,7 +66,10 @@ module EacRubyUtils
66
66
  protected
67
67
 
68
68
  def envvar_read_entry(entry_key)
69
- ENV[self.class.entry_key_to_envvar_name(entry_key)]
69
+ env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
70
+ return nil unless ENV.key?(env_entry_key)
71
+
72
+ ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
70
73
  end
71
74
 
72
75
  def read_entry_from_console(entry_key, options)
@@ -1,21 +1,25 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- require 'active_support/core_ext/object'
4
- require 'eac_ruby_utils/patches/object/asserts'
3
+ require 'eac_ruby_utils/core_ext'
5
4
 
6
5
  module EacRubyUtils
7
6
  class PathsHash
7
+ require_sub __FILE__
8
+
8
9
  class << self
9
10
  def parse_entry_key(entry_key)
10
11
  r = entry_key.to_s.strip
11
- raise EntryKeyError, 'Entry key cannot start or end with dot' if
12
+ raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
12
13
  r.start_with?('.') || r.end_with?('.')
13
14
 
14
15
  r = r.split('.').map(&:strip)
15
- raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
16
+ if r.empty?
17
+ raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
18
+ end
16
19
  return r.map(&:to_sym) unless r.any?(&:blank?)
17
20
 
18
- raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
21
+ raise ::EacRubyUtils::PathsHash::EntryKeyError,
22
+ "Entry key \"#{entry_key}\" has at least one blank part"
19
23
  end
20
24
  end
21
25
 
@@ -26,68 +30,27 @@ module EacRubyUtils
26
30
  end
27
31
 
28
32
  def [](entry_key)
29
- root.read_entry(self.class.parse_entry_key(entry_key), [])
33
+ root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
30
34
  end
31
35
 
32
36
  def []=(entry_key, entry_value)
33
- root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
37
+ root.write_entry(
38
+ ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
39
+ )
34
40
  end
35
41
 
36
- delegate :to_h, to: :root
37
-
38
- private
39
-
40
- attr_reader :data
41
-
42
- class EntryKeyError < StandardError
42
+ def fetch(entry_key)
43
+ root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
43
44
  end
44
45
 
45
- class Node
46
- def initialize(source_hash)
47
- source_hash.assert_argument(Hash, 'source_hash')
48
- @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
49
- end
50
-
51
- def to_h
52
- data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
53
- end
54
-
55
- def read_entry(path, current)
56
- validate_path(path, current)
57
- node_key = path.shift
58
- node = data[node_key]
59
- return (node.is_a?(Node) ? node.to_h : node) if path.empty?
60
- return nil if node.blank?
61
- return node.read_entry(path, current + [node_key]) if node.is_a?(Node)
62
-
63
- raise(EntryKeyError,
64
- "Path #{current.join(',')} is not a Node and path continues (#{current + path})")
65
- end
66
-
67
- def write_entry(path, value, current)
68
- validate_path(path, current)
69
- node_key = path.shift
70
- write_entry_value(path, node_key, value, current)
71
- end
72
-
73
- private
46
+ def key?(entry_key)
47
+ root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
48
+ end
74
49
 
75
- def write_entry_value(path, node_key, value, current)
76
- if path.empty?
77
- data[node_key] = value.is_a?(Hash) ? Node.new(value) : value
78
- else
79
- data[node_key] = Node.new({}) unless data[node_key].is_a?(Node)
80
- data[node_key].write_entry(path, value, current + [node_key])
81
- end
82
- end
50
+ delegate :to_h, to: :root
83
51
 
84
- def validate_path(path, current)
85
- path.assert_argument(Array, 'path')
86
- current.assert_argument(Array, 'current')
87
- raise EntryKeyError, 'Path is empty' if path.empty?
88
- end
52
+ private
89
53
 
90
- attr_reader :data
91
- end
54
+ attr_reader :data
92
55
  end
93
56
  end
@@ -0,0 +1,8 @@
1
+ # frozen_string_literal: true
2
+
3
+ module EacRubyUtils
4
+ class PathsHash
5
+ class EntryKeyError < StandardError
6
+ end
7
+ end
8
+ end
@@ -0,0 +1,67 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'eac_ruby_utils/core_ext'
4
+ require 'eac_ruby_utils/paths_hash/entry_key_error'
5
+
6
+ module EacRubyUtils
7
+ class PathsHash
8
+ class Node
9
+ PATH_SEARCH_UNENDED_ERROR_MESSAGE = 'Path search is not a Node and is not ended'
10
+
11
+ def initialize(source_hash)
12
+ source_hash.assert_argument(Hash, 'source_hash')
13
+ @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
14
+ end
15
+
16
+ def entry?(path_search)
17
+ return false unless data.key?(path_search.cursor)
18
+ return true if path_search.ended?
19
+ return data.fetch(path_search.cursor).entry?(path_search.succeeding) if
20
+ data.fetch(path_search.cursor).is_a?(Node)
21
+
22
+ false # Paths continue and there is not available nodes
23
+ end
24
+
25
+ def fetch(path_search)
26
+ if data.key?(path_search.cursor)
27
+ node = data.fetch(path_search.cursor)
28
+ return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
29
+ return nil if node.blank?
30
+ return node.fetch(path_search.succeeding) if node.is_a?(Node)
31
+ end
32
+
33
+ path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
34
+ end
35
+
36
+ def to_h
37
+ data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
38
+ end
39
+
40
+ def read_entry(path_search)
41
+ node = data[path_search.cursor]
42
+ return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
43
+ return nil if node.blank?
44
+ return node.read_entry(path_search.succeeding) if node.is_a?(Node)
45
+
46
+ path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
47
+ end
48
+
49
+ def write_entry(path_search, value)
50
+ if path_search.ended?
51
+ data[path_search.cursor] = value.is_a?(Hash) ? self.class.new(value) : value
52
+ else
53
+ assert_data_node(path_search.cursor).write_entry(path_search.succeeding, value)
54
+ end
55
+ end
56
+
57
+ private
58
+
59
+ attr_reader :data
60
+
61
+ def assert_data_node(key)
62
+ data[key] = self.class.new({}) unless data[key].is_a?(Node)
63
+ data[key]
64
+ end
65
+ end
66
+ end
67
+ end
@@ -0,0 +1,39 @@
1
+ # frozen_string_literal: true
2
+
3
+ module EacRubyUtils
4
+ class PathsHash
5
+ class PathSearch
6
+ class << self
7
+ def parse_entry_key(string)
8
+ new(::EacRubyUtils::PathsHash.parse_entry_key(string), [])
9
+ end
10
+ end
11
+
12
+ common_constructor :current, :previous do
13
+ self.current = current.assert_argument(Array, 'current').freeze
14
+ self.previous = previous.assert_argument(Array, 'previous')
15
+ raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Current is empty' if current.empty?
16
+ end
17
+
18
+ def cursor
19
+ current.first
20
+ end
21
+
22
+ def ended?
23
+ current.count <= 1
24
+ end
25
+
26
+ def raise_error(message)
27
+ raise ::EacRubyUtils::PathsHash::EntryKeyError, "#{message} (#{self})"
28
+ end
29
+
30
+ def succeeding
31
+ self.class.new(current[1..-1], previous + [cursor])
32
+ end
33
+
34
+ def to_s
35
+ "#{self.class}[Current: #{current}, Previous: #{previous}]"
36
+ end
37
+ end
38
+ end
39
+ end
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module EacRubyUtils
4
- VERSION = '0.47.0'
4
+ VERSION = '0.48.0'
5
5
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: eac_ruby_utils
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.47.0
4
+ version: 0.48.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Esquilo Azul Company
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2020-10-14 00:00:00.000000000 Z
11
+ date: 2020-10-20 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: activesupport
@@ -109,11 +109,13 @@ files:
109
109
  - README.rdoc
110
110
  - lib/eac_ruby_utils.rb
111
111
  - lib/eac_ruby_utils/arguments_consumer.rb
112
+ - lib/eac_ruby_utils/blank_not_blank.rb
112
113
  - lib/eac_ruby_utils/boolean.rb
113
114
  - lib/eac_ruby_utils/by_reference.rb
114
115
  - lib/eac_ruby_utils/common_concern.rb
115
116
  - lib/eac_ruby_utils/common_constructor.rb
116
117
  - lib/eac_ruby_utils/configs.rb
118
+ - lib/eac_ruby_utils/configs/base.rb
117
119
  - lib/eac_ruby_utils/configs/file.rb
118
120
  - lib/eac_ruby_utils/console.rb
119
121
  - lib/eac_ruby_utils/console/configs.rb
@@ -206,6 +208,9 @@ files:
206
208
  - lib/eac_ruby_utils/patches/time/default_time_zone_set.rb
207
209
  - lib/eac_ruby_utils/patches/time/local_time_zone.rb
208
210
  - lib/eac_ruby_utils/paths_hash.rb
211
+ - lib/eac_ruby_utils/paths_hash/entry_key_error.rb
212
+ - lib/eac_ruby_utils/paths_hash/node.rb
213
+ - lib/eac_ruby_utils/paths_hash/path_search.rb
209
214
  - lib/eac_ruby_utils/require_sub.rb
210
215
  - lib/eac_ruby_utils/rspec.rb
211
216
  - lib/eac_ruby_utils/rspec/conditional.rb