ensure_it 0.1.3 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,7 +4,7 @@ module EnsureIt
4
4
  default
5
5
  end
6
6
 
7
- def ensure_hash!(*args, default: nil, **opts)
7
+ def ensure_hash!(*args, **opts)
8
8
  opts[:message] ||= '#{subject} should be a Hash'
9
9
  EnsureIt.raise_error(:ensure_hash!, **opts)
10
10
  end
@@ -13,7 +13,7 @@ module EnsureIt
13
13
  patch Hash do
14
14
  using EnsureIt if ENSURE_IT_REFINED
15
15
 
16
- def ensure_hash(*args, **opts)
16
+ def ensure_hash(*args, default: {}, **opts)
17
17
  return self if opts.empty? || opts[:symbolize_keys] != true
18
18
  Hash[map { |k, v| [k.ensure_symbol, v] }.reject { |x| x[0].nil? }]
19
19
  end
@@ -10,7 +10,7 @@ module EnsureIt
10
10
  is_a?(klass) ? self : default
11
11
  end
12
12
 
13
- def ensure_instance_of!(klass, default: nil, **opts)
13
+ def ensure_instance_of!(klass, **opts)
14
14
  unless klass.is_a?(Class)
15
15
  fail(
16
16
  ArgumentError,
@@ -1,156 +1,136 @@
1
1
  module EnsureIt
2
- OCT_REGEXP = /\A0\d+\z/
3
- INT_REGEXP = /\A[+\-]?\d[\d_]*\z/
4
- HEX_REGEXP = /\A0x[0-9a-zA-Z]+\z/
5
- BIN_REGEXP = /\A0b[01]+\z/
6
-
7
2
  patch Object do
8
3
  def ensure_integer(default: nil, **opts)
9
4
  default
10
5
  end
11
6
 
12
- def ensure_integer!(default: nil, **opts)
13
- EnsureIt.raise_error(
14
- :ensure_integer!,
15
- **EnsureIt::ensure_integer_error_options(**opts)
16
- )
7
+ def ensure_integer!(**opts)
8
+ EnsureIt.raise_error(:ensure_integer!,
9
+ **EnsureIt::ensure_integer_error(**opts))
17
10
  end
18
11
  end
19
12
 
20
13
  patch String do
21
- def ensure_integer(default: nil, values: nil, **opts)
22
- value = case self
23
- when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
24
- when INT_REGEXP then self.to_i
25
- when HEX_REGEXP then self[2..-1].to_i(16)
26
- when BIN_REGEXP then self[2..-1].to_i(2)
27
- else return default
28
- end
29
- if values.nil? || values.is_a?(Array) || values.include?(self)
30
- value
31
- else
32
- default
33
- end
14
+ def ensure_integer(default: nil, **opts)
15
+ catch(:wrong) { return EnsureIt.ensure_integer_string(self, **opts) }
16
+ default
34
17
  end
35
18
 
36
- def ensure_integer!(default: nil, values: nil, **opts)
37
- value = case self
38
- when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
39
- when INT_REGEXP then self.to_i
40
- when HEX_REGEXP then self[2..-1].to_i(16)
41
- when BIN_REGEXP then self[2..-1].to_i(2)
42
- else
43
- EnsureIt.raise_error(
44
- :ensure_integer!,
45
- **EnsureIt::ensure_integer_error_options(**opts)
46
- )
47
- end
48
- if values.nil? || values.is_a?(Array) || values.include?(self)
49
- return value
50
- end
51
- EnsureIt.raise_error(
52
- :ensure_integer!,
53
- **EnsureIt::ensure_integer_error_options(**opts)
54
- )
19
+ def ensure_integer!(**opts)
20
+ catch(:wrong) { return EnsureIt.ensure_integer_string(self, **opts) }
21
+ EnsureIt.raise_error(:ensure_integer!,
22
+ **EnsureIt::ensure_integer_error(**opts))
55
23
  end
56
24
  end
57
25
 
58
26
  patch Integer do
59
- def ensure_integer(default: nil, values: nil, **opts)
60
- if values.nil? || values.is_a?(Array) && values.include?(self)
61
- self
62
- else
63
- default
64
- end
27
+ def ensure_integer(default: nil, **opts)
28
+ return self if opts.empty?
29
+ catch(:wrong) { return EnsureIt.ensure_integer(self, **opts) }
30
+ default
65
31
  end
66
32
 
67
- def ensure_integer!(default: nil, values: nil, **opts)
68
- if values.nil? || values.is_a?(Array) && values.include?(self)
69
- return self
70
- end
71
- EnsureIt.raise_error(
72
- :ensure_integer!,
73
- **EnsureIt::ensure_integer_error_options(**opts)
74
- )
33
+ def ensure_integer!(**opts)
34
+ return self if opts.empty?
35
+ catch(:wrong) { return EnsureIt.ensure_integer(self, **opts) }
36
+ EnsureIt.raise_error(:ensure_integer!,
37
+ **EnsureIt::ensure_integer_error(**opts))
75
38
  end
76
39
  end
77
40
 
78
41
  patch Float do
79
- def ensure_integer(default: nil, values: nil, **opts)
80
- return round if values.nil?
81
- value = round
82
- values.is_a?(Array) && values.include?(value) ? value : default
42
+ def ensure_integer(default: nil, **opts)
43
+ return round if opts.empty?
44
+ catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
45
+ default
83
46
  end
84
47
 
85
- def ensure_integer!(default: nil, values: nil, **opts)
86
- return round if values.nil?
87
- value = round
88
- return value if values.is_a?(Array) && values.include?(value)
89
- EnsureIt.raise_error(
90
- :ensure_integer!,
91
- **EnsureIt::ensure_integer_error_options(**opts)
92
- )
48
+ def ensure_integer!(**opts)
49
+ return round if opts.empty?
50
+ catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
51
+ EnsureIt.raise_error(:ensure_integer!,
52
+ **EnsureIt::ensure_integer_error(**opts))
93
53
  end
94
54
  end
95
55
 
96
56
  patch Rational do
97
- def ensure_integer(default: nil, values: nil, **opts)
98
- return round if values.nil?
99
- value = round
100
- values.is_a?(Array) && values.include?(value) ? value : default
57
+ def ensure_integer(default: nil, **opts)
58
+ return round if opts.empty?
59
+ catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
60
+ default
101
61
  end
102
62
 
103
- def ensure_integer!(default: nil, values: nil, **opts)
104
- return round if values.nil?
105
- value = round
106
- return value if values.is_a?(Array) && values.include?(value)
107
- EnsureIt.raise_error(
108
- :ensure_integer!,
109
- **EnsureIt::ensure_integer_error_options(**opts)
110
- )
63
+ def ensure_integer!(**opts)
64
+ return round if opts.empty?
65
+ catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
66
+ EnsureIt.raise_error(:ensure_integer!,
67
+ **EnsureIt::ensure_integer_error(**opts))
111
68
  end
112
69
  end
113
70
 
114
71
  patch TrueClass do
115
- def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
72
+ def ensure_integer(default: nil, boolean: nil, **opts)
116
73
  if boolean == true || boolean.is_a?(Integer)
117
74
  value = boolean == true ? 1 : boolean
118
- values.is_a?(Array) && !values.include?(value) ? default : value
119
- else
120
- default
75
+ return value if opts.empty?
76
+ catch(:wrong) { return EnsureIt.ensure_integer(value, **opts) }
121
77
  end
78
+ default
122
79
  end
123
80
 
124
- def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
81
+ def ensure_integer!(boolean: nil, **opts)
125
82
  if boolean == true || boolean.is_a?(Integer)
126
83
  value = boolean == true ? 1 : boolean
127
- return value unless values.is_a?(Array) && !values.include?(value)
84
+ return value if opts.empty?
85
+ catch(:wrong) { return EnsureIt.ensure_integer(value, **opts) }
128
86
  end
129
- EnsureIt.raise_error(
130
- :ensure_integer!,
131
- **EnsureIt::ensure_integer_error_options(**opts)
132
- )
87
+ EnsureIt.raise_error(:ensure_integer!,
88
+ **EnsureIt::ensure_integer_error(**opts))
133
89
  end
134
90
  end
135
91
 
136
92
  patch FalseClass do
137
- def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
138
- return 0 if (boolean == true || boolean.is_a?(Integer)) &&
139
- (!values.is_a?(Array) || values.include?(0))
93
+ def ensure_integer(default: nil, boolean: nil, **opts)
94
+ if boolean == true || boolean.is_a?(Integer)
95
+ return 0 if opts.empty?
96
+ catch(:wrong) { return EnsureIt.ensure_integer(0, **opts) }
97
+ end
140
98
  default
141
99
  end
142
100
 
143
101
  def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
144
- return 0 if (boolean == true || boolean.is_a?(Integer)) &&
145
- (!values.is_a?(Array) || values.include?(0))
146
- EnsureIt.raise_error(
147
- :ensure_integer!,
148
- **EnsureIt::ensure_integer_error_options(**opts)
149
- )
102
+ if boolean == true || boolean.is_a?(Integer)
103
+ return 0 if opts.empty?
104
+ catch(:wrong) { return EnsureIt.ensure_integer(0, **opts) }
105
+ end
106
+ EnsureIt.raise_error(:ensure_integer!,
107
+ **EnsureIt::ensure_integer_error(**opts))
108
+ end
109
+ end
110
+
111
+ OCT_REGEXP = /\A0\d+\z/
112
+ INT_REGEXP = /\A[+\-]?\d[\d_]*\z/
113
+ HEX_REGEXP = /\A0x[0-9a-zA-Z]+\z/
114
+ BIN_REGEXP = /\A0b[01]+\z/
115
+
116
+ def self.ensure_integer(int, values: nil, **opts)
117
+ throw :wrong if values.is_a?(Array) && !values.include?(int)
118
+ int
119
+ end
120
+
121
+ def self.ensure_integer_string(str, **opts)
122
+ value = case str
123
+ when OCT_REGEXP then opts[:octal] == true ? str.to_i(8) : str.to_i
124
+ when INT_REGEXP then str.to_i
125
+ when HEX_REGEXP then str[2..-1].to_i(16)
126
+ when BIN_REGEXP then str[2..-1].to_i(2)
127
+ else throw :wrong
150
128
  end
129
+ return value if opts.empty?
130
+ return EnsureIt.ensure_integer(value, **opts)
151
131
  end
152
132
 
153
- def self.ensure_integer_error_options(**opts)
133
+ def self.ensure_integer_error(**opts)
154
134
  unless opts.key?(:message)
155
135
  opts[:message] = '#{subject} should be an integer or be able' \
156
136
  ' to convert to it'
@@ -1,90 +1,156 @@
1
+ # @!method ensure_string(opts = {})
2
+ #
3
+ # Ensures that subject is a string. Without options for symbols returns
4
+ # converted to string value, for strings, returns self, for others - value,
5
+ # specified in default option or nil. With `numbers: true` option, also
6
+ # converts numbers to string.
7
+ #
8
+ # With `downcase: true` option downcases value.
9
+ #
10
+ # If `values` option specified, returns default value if converted value
11
+ # is not included in specified array. **Warning:** there are no type checks
12
+ # of array elements, so if you, for example, specify array of integers here,
13
+ # this method will allways return default value.
14
+ #
15
+ # `name_of` option, if specified, should be one of: `:local`,
16
+ # `:instance_variable`, `:class_variable`, `:setter`, `:getter`, `:checker`,
17
+ # `:bang`, `:method`, `:class` or its string equivalents. This option allow you
18
+ # to be ensured that return value is a valid name of local variable,
19
+ # instance variable, class variable, setter method, getter method, checker
20
+ # method (ending with `?`), bang method (ending with `!`), any method or
21
+ # class, respectively to option values above. See examples below for details.
22
+ # If you want to convert underscored downcased notations of classes, use
23
+ # `downcase: true` option. Also, with `name_of: :class`, `exist: true` option
24
+ # can specified to ensures that class exists.
25
+ #
26
+ # @example usage of `name_of` option
27
+ # ```ruby
28
+ # 'some text'.ensure_string(name_of: :local) # => nil
29
+ # 'some_text'.ensure_string(name_of: :local) # => 'some_text'
30
+ #
31
+ # 'some_text'.ensure_string(name_of: :instance_variable) # => '@some_text'
32
+ # '@some_text'.ensure_string(name_of: :instance_variable) # => '@some_text'
33
+ # 'some_text='.ensure_string(name_of: :instance_variable) # => '@some_text'
34
+ #
35
+ # 'some_text'.ensure_string(name_of: :setter) # => 'some_text='
36
+ # 'some_text?'.ensure_string(name_of: :setter) # => 'some_text='
37
+ # 'some_text='.ensure_string(name_of: :setter) # => 'some_text='
38
+ #
39
+ # 'some_text'.ensure_string(name_of: :class) # => nil
40
+ # 'Some::Text'.ensure_string(name_of: :class) # => Some::Text
41
+ # 'some_text'.ensure_string(name_of: :class, downcase: true) # => SomeText
42
+ # 'some/text'.ensure_string(name_of: :class, downcase: true) # => Some::Text
43
+ # 'Some::Text'.ensure_string(name_of: :class, exist: true) # => nil
44
+ # 'Object'.ensure_string(name_of: :class, exist: true) # => 'Object'
45
+ # ```
46
+ #
47
+ # @param [Hash] opts the options
48
+ # @option opts [Object] :default (nil) default value for wrong subject
49
+ # @option opts [Array] :values an array of possible values
50
+ # @option opts [Boolean] :downcase convert string to downcase
51
+ # @option opts [<String, Symbol>] :name_of string should be a name of variable
52
+ # or method
53
+
54
+ # @private
1
55
  module EnsureIt
2
56
  patch Object do
3
57
  def ensure_string(default: nil, **opts)
4
58
  default
5
59
  end
6
60
 
7
- def ensure_string!(default: nil, **opts)
8
- EnsureIt.raise_error(
9
- :ensure_string!,
10
- **EnsureIt.ensure_string_error_options(**opts)
11
- )
61
+ def ensure_string!(**opts)
62
+ EnsureIt.raise_error(:ensure_string!,
63
+ **EnsureIt.ensure_string_error(**opts))
12
64
  end
13
65
  end
14
66
 
15
67
  patch String do
16
- def ensure_string(default: nil, values: nil, downcase: nil, **opts)
17
- value = downcase == true ? self.downcase : self
18
- if values.nil? || values.is_a?(Array) && values.include?(value)
19
- value
20
- else
21
- default
68
+ def ensure_string(default: nil, **opts)
69
+ return self if opts.empty?
70
+ catch :wrong do
71
+ return EnsureIt.ensure_string(self, **opts)
22
72
  end
73
+ default
23
74
  end
24
75
 
25
- def ensure_string!(default: nil, values: nil, downcase: nil, **opts)
26
- value = downcase == true ? self.downcase : self
27
- if values.nil? || values.is_a?(Array) && values.include?(value)
28
- return value
76
+ def ensure_string!(**opts)
77
+ return self if opts.empty?
78
+ catch :wrong do
79
+ return EnsureIt.ensure_string(self, **opts)
29
80
  end
30
- EnsureIt.raise_error(
31
- :ensure_string!,
32
- **EnsureIt.ensure_string_error_options(**opts)
33
- )
81
+ EnsureIt.raise_error(:ensure_string!,
82
+ **EnsureIt.ensure_string_error(**opts))
34
83
  end
35
84
  end
36
85
 
37
86
  patch Symbol do
38
- def ensure_string(default: nil, values: nil, downcase: nil, **opts)
39
- value = downcase == true ? to_s.downcase : to_s
40
- if values.nil? || values.is_a?(Array) && values.include?(value)
41
- value
42
- else
43
- default
87
+ def ensure_string(default: nil, **opts)
88
+ return to_s if opts.empty?
89
+ catch :wrong do
90
+ return EnsureIt.ensure_string(to_s, **opts)
44
91
  end
92
+ default
45
93
  end
46
94
 
47
- def ensure_string!(default: nil, values: nil, downcase: nil, **opts)
48
- value = downcase == true ? to_s.downcase : to_s
49
- if values.nil? || values.is_a?(Array) && values.include?(value)
50
- return value
95
+ def ensure_string!(**opts)
96
+ return to_s if opts.empty?
97
+ catch :wrong do
98
+ return EnsureIt.ensure_string(to_s, **opts)
51
99
  end
52
- EnsureIt.raise_error(
53
- :ensure_string!,
54
- **EnsureIt.ensure_string_error_options(**opts)
55
- )
100
+ EnsureIt.raise_error(:ensure_string!,
101
+ **EnsureIt.ensure_string_error(**opts))
56
102
  end
57
103
  end
58
104
 
59
105
  patch Numeric do
60
106
  using EnsureIt if ENSURE_IT_REFINED
61
107
 
62
- def ensure_string(default: nil, values: nil, numbers: false, **opts)
108
+ def ensure_string(default: nil, numbers: false, **opts)
63
109
  return default if numbers != true
64
- value = to_s
65
- values.is_a?(Array) && !values.include?(value) ? default : value
110
+ catch :wrong do
111
+ return EnsureIt.ensure_string(to_s, **opts)
112
+ end
113
+ default
66
114
  end
67
115
 
68
- def ensure_string!(default: nil, values: nil, numbers: false, **opts)
116
+ def ensure_string!(numbers: false, **opts)
69
117
  if numbers == true
70
- value = to_s
71
- return value if !values.is_a?(Array) || values.include?(value)
118
+ catch :wrong do
119
+ return EnsureIt.ensure_string(to_s, **opts)
120
+ end
72
121
  end
73
122
  EnsureIt.raise_error(
74
123
  :ensure_string!,
75
- **EnsureIt.ensure_string_error_options(**opts)
124
+ **EnsureIt.ensure_string_error(numbers: numbers, **opts)
76
125
  )
77
126
  end
78
127
  end
79
128
 
80
- def self.ensure_string_error_options(**opts)
81
- unless opts.key?(opts[:message])
82
- opts[:message] =
83
- if opts[:numbers] == true
84
- '#{subject} should be a String, Symbol, Numeric or Rational'
85
- else
86
- '#{subject} should be a String or a Symbol'
87
- end
129
+ def self.ensure_string(str, values: nil, downcase: nil, name_of: nil, **opts)
130
+ if name_of.nil?
131
+ value = downcase == true ? str.downcase : str
132
+ else
133
+ value = EnsureIt::StringUtils.ensure_name(
134
+ str, downcase: downcase, name_of: name_of, **opts
135
+ )
136
+ throw :wrong if value.nil?
137
+ end
138
+ throw :wrong if values.is_a?(Array) && !values.include?(value)
139
+ value
140
+ end
141
+
142
+ def self.ensure_string_error(**opts)
143
+ unless opts.key?(:message)
144
+ opts[:message] = '#{subject} should be a String or a Symbol'
145
+ if opts[:numbers] == true
146
+ opts[:message] << ' or a Numeric'
147
+ end
148
+ if opts.key?(:name_of)
149
+ opts[:message] << " and should be a name of #{opts[:name_of]}"
150
+ end
151
+ if opts[:values].is_a?(Array)
152
+ opts[:message] << " and should contained in #{opts[:values]}"
153
+ end
88
154
  end
89
155
  opts
90
156
  end