ensure_it 0.1.1 → 0.1.2

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.
@@ -5,85 +5,156 @@ module EnsureIt
5
5
  BIN_REGEXP = /\A0b[01]+\z/
6
6
 
7
7
  patch Object do
8
- def ensure_integer(**opts)
9
- opts.key?(:wrong) ? opts[:wrong] : nil
8
+ def ensure_integer(default: nil, **opts)
9
+ default
10
10
  end
11
11
 
12
- def ensure_integer!(**opts)
13
- opts[:message] ||= '#{subject} should be an integer or be able' \
14
- ' to convert to it'
15
- EnsureIt.raise_error(:ensure_integer!, **opts)
12
+ def ensure_integer!(default: nil, **opts)
13
+ EnsureIt.raise_error(
14
+ :ensure_integer!,
15
+ **EnsureIt::ensure_integer_error_options(**opts)
16
+ )
16
17
  end
17
18
  end
18
19
 
19
20
  patch String do
20
- using EnsureIt if ENSURE_IT_REFINES
21
-
22
- def ensure_integer(**opts)
23
- case self
21
+ def ensure_integer(default: nil, values: nil, **opts)
22
+ value = case self
24
23
  when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
25
24
  when INT_REGEXP then self.to_i
26
25
  when HEX_REGEXP then self[2..-1].to_i(16)
27
26
  when BIN_REGEXP then self[2..-1].to_i(2)
28
- else nil
27
+ else return default
28
+ end
29
+ if values.nil? || values.is_a?(Array) || values.include?(self)
30
+ value
31
+ else
32
+ default
29
33
  end
30
34
  end
31
35
 
32
- def ensure_integer!(**opts)
33
- ensure_integer(**opts) || super(**opts)
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
+ )
34
55
  end
35
56
  end
36
57
 
37
58
  patch Integer do
38
- def ensure_integer(**opts)
39
- self
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
65
+ end
66
+
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
+ )
40
75
  end
41
- alias_method :ensure_integer!, :ensure_integer
42
76
  end
43
77
 
44
78
  patch Float do
45
- def ensure_integer(**opts)
46
- round
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
83
+ end
84
+
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
+ )
47
93
  end
48
- alias_method :ensure_integer!, :ensure_integer
49
94
  end
50
95
 
51
96
  patch Rational do
52
- def ensure_integer(**opts)
53
- round
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
101
+ end
102
+
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
+ )
54
111
  end
55
- alias_method :ensure_integer!, :ensure_integer
56
112
  end
57
113
 
58
114
  patch TrueClass do
59
- using EnsureIt if ENSURE_IT_REFINES
60
-
61
- def ensure_integer(**opts)
62
- if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
63
- opts[:boolean] == true ? 1 : opts[:boolean]
115
+ def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
116
+ if boolean == true || boolean.is_a?(Integer)
117
+ value = boolean == true ? 1 : boolean
118
+ values.is_a?(Array) && !values.include?(value) ? default : value
64
119
  else
65
- nil
120
+ default
66
121
  end
67
122
  end
68
123
 
69
- def ensure_integer!(**opts)
70
- if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
71
- opts[:boolean] == true ? 1 : opts[:boolean]
72
- else
73
- super(**opts)
124
+ def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
125
+ if boolean == true || boolean.is_a?(Integer)
126
+ value = boolean == true ? 1 : boolean
127
+ return value unless values.is_a?(Array) && !values.include?(value)
74
128
  end
129
+ EnsureIt.raise_error(
130
+ :ensure_integer!,
131
+ **EnsureIt::ensure_integer_error_options(**opts)
132
+ )
75
133
  end
76
134
  end
77
135
 
78
136
  patch FalseClass do
79
- using EnsureIt if ENSURE_IT_REFINES
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))
140
+ default
141
+ end
80
142
 
81
- def ensure_integer(**opts)
82
- opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : nil
143
+ 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
+ )
83
150
  end
151
+ end
84
152
 
85
- def ensure_integer!(**opts)
86
- opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : super(**opts)
153
+ def self.ensure_integer_error_options(**opts)
154
+ unless opts.key?(:message)
155
+ opts[:message] = '#{subject} should be an integer or be able' \
156
+ ' to convert to it'
87
157
  end
158
+ opts
88
159
  end
89
160
  end
@@ -1,43 +1,92 @@
1
1
  module EnsureIt
2
2
  patch Object do
3
- def ensure_string(**opts)
4
- opts.key?(:wrong) ? opts[:wrong] : nil
3
+ def ensure_string(default: nil, **opts)
4
+ default
5
5
  end
6
6
 
7
- def ensure_string!(**opts)
8
- opts[:message] ||=
9
- if opts[:numbers] == true
10
- '#{subject} should be a String, Symbol, Numeric or Rational'
11
- else
12
- '#{subject} should be a String or a Symbol'
13
- end
14
- EnsureIt.raise_error(:ensure_string!, **opts)
7
+ def ensure_string!(default: nil, **opts)
8
+ EnsureIt.raise_error(
9
+ :ensure_string!,
10
+ **EnsureIt.ensure_string_error_options(**opts)
11
+ )
15
12
  end
16
13
  end
17
14
 
18
15
  patch String do
19
- def ensure_string(**opts)
20
- self
16
+ def ensure_string(default: nil, values: nil, **opts)
17
+ if values.nil? || values.is_a?(Array) && values.include?(self)
18
+ self
19
+ else
20
+ default
21
+ end
22
+ end
23
+
24
+ def ensure_string!(default: nil, values: nil, **opts)
25
+ if values.nil? || values.is_a?(Array) && values.include?(self)
26
+ return self
27
+ end
28
+ EnsureIt.raise_error(
29
+ :ensure_string!,
30
+ **EnsureIt.ensure_string_error_options(**opts)
31
+ )
21
32
  end
22
- alias_method :ensure_string!, :ensure_string
23
33
  end
24
34
 
25
35
  patch Symbol do
26
- def ensure_string(**opts)
27
- to_s
36
+ def ensure_string(default: nil, values: nil, **opts)
37
+ if values.nil?
38
+ to_s
39
+ elsif values.is_a?(Array)
40
+ value = to_s
41
+ values.include?(value) ? value : default
42
+ else
43
+ default
44
+ end
45
+ end
46
+
47
+ def ensure_string!(default: nil, values: nil, **opts)
48
+ return to_s if values.nil?
49
+ if values.is_a?(Array)
50
+ value = to_s
51
+ return value if values.include?(value)
52
+ end
53
+ EnsureIt.raise_error(
54
+ :ensure_string!,
55
+ **EnsureIt.ensure_string_error_options(**opts)
56
+ )
28
57
  end
29
- alias_method :ensure_string!, :ensure_string
30
58
  end
31
59
 
32
60
  patch Numeric do
33
- using EnsureIt if ENSURE_IT_REFINES
61
+ using EnsureIt if ENSURE_IT_REFINED
34
62
 
35
- def ensure_string(**opts)
36
- opts[:numbers] == true ? to_s : nil
63
+ def ensure_string(default: nil, values: nil, numbers: false, **opts)
64
+ return default if numbers != true
65
+ value = to_s
66
+ values.is_a?(Array) && !values.include?(value) ? default : value
37
67
  end
38
68
 
39
- def ensure_string!(**opts)
40
- opts[:numbers] == true ? to_s : super(**opts)
69
+ def ensure_string!(default: nil, values: nil, numbers: false, **opts)
70
+ if numbers == true
71
+ value = to_s
72
+ return value if !values.is_a?(Array) || values.include?(value)
73
+ end
74
+ EnsureIt.raise_error(
75
+ :ensure_string!,
76
+ **EnsureIt.ensure_string_error_options(**opts)
77
+ )
78
+ end
79
+ end
80
+
81
+ def self.ensure_string_error_options(**opts)
82
+ unless opts.key?(opts[:message])
83
+ opts[:message] =
84
+ if opts[:numbers] == true
85
+ '#{subject} should be a String, Symbol, Numeric or Rational'
86
+ else
87
+ '#{subject} should be a String or a Symbol'
88
+ end
41
89
  end
90
+ opts
42
91
  end
43
92
  end
@@ -1,26 +1,71 @@
1
1
  module EnsureIt
2
2
  patch Object do
3
- def ensure_symbol(**opts)
4
- opts.key?(:wrong) ? opts[:wrong] : nil
3
+ def ensure_symbol(default: nil, **opts)
4
+ default
5
5
  end
6
6
 
7
- def ensure_symbol!(**opts)
8
- opts[:message] ||= '#{subject} should be a Symbol or a String'
9
- EnsureIt.raise_error(:ensure_symbol!, **opts)
7
+ def ensure_symbol!(default: nil, **opts)
8
+ EnsureIt.raise_error(
9
+ :ensure_symbol!,
10
+ **EnsureIt.ensure_symbol_error_options(**opts)
11
+ )
10
12
  end
11
13
  end
12
14
 
13
15
  patch String do
14
- def ensure_symbol(**opts)
15
- to_sym
16
+ def ensure_symbol(default: nil, values: nil, **opts)
17
+ if values.nil?
18
+ to_sym
19
+ elsif values.is_a?(Array)
20
+ value = to_sym
21
+ values.include?(value) ? value : default
22
+ else
23
+ default
24
+ end
25
+ end
26
+
27
+ def ensure_symbol!(default: nil, values: nil, **opts)
28
+ return to_sym if values.nil?
29
+ if values.is_a?(Array)
30
+ value = to_sym
31
+ return value if values.include?(value)
32
+ end
33
+ EnsureIt.raise_error(
34
+ :ensure_symbol!,
35
+ **EnsureIt.ensure_symbol_error_options(**opts)
36
+ )
16
37
  end
17
- alias_method :ensure_symbol!, :ensure_symbol
18
38
  end
19
39
 
20
40
  patch Symbol do
21
- def ensure_symbol(**opts)
22
- self
41
+ def ensure_symbol(default: nil, values: nil, **opts)
42
+ if values.nil? || values.is_a?(Array) && values.include?(self)
43
+ self
44
+ else
45
+ default
46
+ end
47
+ end
48
+
49
+ def ensure_symbol!(default: nil, values: nil, **opts)
50
+ if values.nil? || values.is_a?(Array) && values.include?(self)
51
+ return self
52
+ end
53
+ EnsureIt.raise_error(
54
+ :ensure_symbol!,
55
+ **EnsureIt.ensure_symbol_error_options(**opts)
56
+ )
57
+ end
58
+ end
59
+
60
+ def self.ensure_symbol_error_options(**opts)
61
+ unless opts.key?(opts[:message])
62
+ opts[:message] = '#{subject} should be' +
63
+ if opts[:values].is_a?(Array)
64
+ " one of #{opts[:values]}"
65
+ else
66
+ ' a Symbol or a String'
67
+ end
23
68
  end
24
- alias_method :ensure_symbol!, :ensure_symbol
69
+ opts
25
70
  end
26
71
  end
@@ -62,19 +62,20 @@ module EnsureIt
62
62
  def self.raise_error(method_name, message: nil, error: Error, **opts)
63
63
  error = Error unless error <= Exception
64
64
  error_msg = ErrorMessage.new(method_name, message, caller[1..-1])
65
- if opts.key?(:smart) && opts[:smart] != true ||
66
- EnsureIt.config.errors != :smart
67
- raise error, error_msg.message, error_msg.backtrace
65
+ # save message in backtrace in variables to not call getter
66
+ # methods of error_msg instance in raise call
67
+ error_message = error_msg.message
68
+ error_backtrace = error_msg.backtrace
69
+ if opts[:smart] == true || EnsureIt.config.errors == :smart
70
+ inspect_source(error_msg, **opts)
71
+ activate_smart_errors(error_msg, **opts)
68
72
  end
69
- raise_smart_error(error_msg, error, **opts)
73
+ raise error, error_message, error_backtrace
70
74
  end
71
75
 
72
- def self.raise_smart_error(error, error_class, **opts)
73
- inspect_source(error, **opts)
76
+ def self.activate_smart_errors(error, **opts)
74
77
  tp_count = 0
75
78
  error_obj = nil
76
- error_message = error.message
77
- error_backtrace = error.backtrace
78
79
  #
79
80
  # first trace point is to capture raise object before exitting
80
81
  # from :ensure_* method
@@ -88,30 +89,24 @@ module EnsureIt
88
89
  else
89
90
  # skip returns from :raise_smart_error and :raise_error
90
91
  tp_count += 1
91
- if tp_count > 1
92
- # at this moment we are at end of 'ensure_' method
92
+ if tp_count > 2
93
93
  first_tp.disable
94
- TracePoint.trace(:return) do |second_tp|
95
- # skip return from :ensure_* method
96
- tp_count += 1
97
- if tp_count > 3
98
- # now we are in caller context
99
- second_tp.disable
100
- unless error_obj.nil?
101
- # inspect caller code
102
- inspect_code(second_tp, error, **opts)
103
- # patch error message
104
- error_obj.extend(Module.new do
105
- @@ensure_it_message = error.message
106
- def message; @@ensure_it_message; end
107
- end)
108
- end
94
+ # at this moment we are at the end of 'ensure_' method
95
+ # skip last code line in :ensure_* method
96
+ TracePoint.trace(:return, :line) do |second_tp|
97
+ # now we are in caller context
98
+ second_tp.disable
99
+ unless error_obj.nil?
100
+ # inspect caller code
101
+ inspect_code(second_tp, error, **opts)
102
+ # patch error message
103
+ msg = error.message
104
+ error_obj.define_singleton_method(:message) { msg }
109
105
  end
110
106
  end
111
107
  end
112
108
  end
113
109
  end
114
- raise error_class, error_message, error_backtrace
115
110
  end
116
111
 
117
112
  def self.inspect_source(error, **opts)
@@ -168,6 +163,6 @@ module EnsureIt
168
163
  line
169
164
  end
170
165
 
171
- private_class_method :raise_smart_error, :inspect_source, :inspect_code,
166
+ private_class_method :activate_smart_errors, :inspect_source, :inspect_code,
172
167
  :read_line_number
173
168
  end
@@ -1,5 +1,5 @@
1
1
  module EnsureIt
2
- if ENSURE_IT_REFINES
2
+ if ENSURE_IT_REFINED
3
3
  def self.patch(target, &block)
4
4
  module_eval do
5
5
  refine target do
@@ -1,3 +1,3 @@
1
1
  module EnsureIt
2
- VERSION = '0.1.1'
2
+ VERSION = '0.1.2'
3
3
  end
data/lib/ensure_it.rb CHANGED
@@ -2,7 +2,7 @@ if RUBY_VERSION < '2.0.0'
2
2
  fail %q{EnsureIt: library doesn't support ruby < 2.0.0}
3
3
  end
4
4
 
5
- defined?(ENSURE_IT_REFINES) || ENSURE_IT_REFINES = false
5
+ defined?(ENSURE_IT_REFINED) || ENSURE_IT_REFINED = false
6
6
 
7
7
  require File.join %w(ensure_it version)
8
8
  require File.join %w(ensure_it config)
@@ -1,7 +1,7 @@
1
1
  if RUBY_VERSION >= '2.1'
2
- ENSURE_IT_REFINES = true
2
+ ENSURE_IT_REFINED = true
3
3
  else
4
- ENSURE_IT_REFINES = false
4
+ ENSURE_IT_REFINED = false
5
5
  warn 'EsureIt: refines supported only for ruby >= 2.1'
6
6
  end
7
7