string_foundation 1.0.0 → 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (61) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +5 -0
  3. data/Gemfile +9 -9
  4. data/Gemfile.lock +19 -19
  5. data/{LICENSE.txt → LICENSE} +1 -1
  6. data/PULL_REQUEST_TEMPLATE.md +14 -0
  7. data/README.md +244 -104
  8. data/Rakefile +3 -3
  9. data/bin/console +1 -0
  10. data/coverage/assets/{0.10.0 → 0.10.2}/application.css +0 -0
  11. data/coverage/assets/{0.10.0 → 0.10.2}/application.js +0 -0
  12. data/coverage/assets/{0.10.0 → 0.10.2}/colorbox/border.png +0 -0
  13. data/coverage/assets/{0.10.0 → 0.10.2}/colorbox/controls.png +0 -0
  14. data/coverage/assets/{0.10.0 → 0.10.2}/colorbox/loading.gif +0 -0
  15. data/coverage/assets/{0.10.0 → 0.10.2}/colorbox/loading_background.png +0 -0
  16. data/coverage/assets/{0.10.0 → 0.10.2}/favicon_green.png +0 -0
  17. data/coverage/assets/{0.10.0 → 0.10.2}/favicon_red.png +0 -0
  18. data/coverage/assets/{0.10.0 → 0.10.2}/favicon_yellow.png +0 -0
  19. data/coverage/assets/{0.10.0 → 0.10.2}/loading.gif +0 -0
  20. data/coverage/assets/{0.10.0 → 0.10.2}/magnify.png +0 -0
  21. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_flat_0_aaaaaa_40x100.png +0 -0
  22. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_flat_75_ffffff_40x100.png +0 -0
  23. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_glass_55_fbf9ee_1x400.png +0 -0
  24. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_glass_65_ffffff_1x400.png +0 -0
  25. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_glass_75_dadada_1x400.png +0 -0
  26. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_glass_75_e6e6e6_1x400.png +0 -0
  27. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_glass_95_fef1ec_1x400.png +0 -0
  28. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-bg_highlight-soft_75_cccccc_1x100.png +0 -0
  29. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-icons_222222_256x240.png +0 -0
  30. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-icons_2e83ff_256x240.png +0 -0
  31. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-icons_454545_256x240.png +0 -0
  32. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-icons_888888_256x240.png +0 -0
  33. data/coverage/assets/{0.10.0 → 0.10.2}/smoothness/images/ui-icons_cd0a0a_256x240.png +0 -0
  34. data/coverage/index.html +5885 -3160
  35. data/lib/string_foundation.rb +4 -2
  36. data/lib/string_foundation/blank.rb +17 -0
  37. data/lib/string_foundation/case.rb +28 -38
  38. data/lib/string_foundation/convert.rb +9 -9
  39. data/lib/string_foundation/convertible.rb +4 -4
  40. data/lib/string_foundation/is.rb +13 -0
  41. data/lib/string_foundation/length.rb +56 -0
  42. data/lib/string_foundation/like.rb +4 -4
  43. data/lib/string_foundation/version.rb +2 -2
  44. data/lib/string_foundation/with.rb +7 -7
  45. data/pkg/string_foundation-1.1.0.gem +0 -0
  46. data/spec/spec_helper.rb +10 -10
  47. data/spec/string_foundation/blank_spec.rb +91 -0
  48. data/spec/string_foundation/case_spec.rb +398 -433
  49. data/spec/string_foundation/convert_spec.rb +98 -98
  50. data/spec/string_foundation/convertible_spec.rb +286 -0
  51. data/spec/string_foundation/is_spec.rb +62 -0
  52. data/spec/string_foundation/length_spec.rb +226 -0
  53. data/spec/string_foundation/like_spec.rb +103 -103
  54. data/spec/string_foundation/version_spec.rb +4 -4
  55. data/spec/string_foundation/with_spec.rb +48 -48
  56. data/spec/support/enhanced_matchers_extension.rb +1 -0
  57. data/string_foundation.gemspec +15 -14
  58. metadata +46 -37
  59. data/circle.yml +0 -14
  60. data/pkg/string_foundation-1.0.0.gem +0 -0
  61. data/spec/string_foundation/convertaile_spec.rb +0 -286
data/spec/string_foundation/case_spec.rb CHANGED
@@ -1,99 +1,99 @@
1
1
  # ==============================================================================
2
- # SPEC - STRING FOUNDATION - CASE
3
- # ==============================================================================
2
+ # SPEC - STRING FOUNDATION - CASE SPEC
4
3
  # frozen_string_literal: true
5
- describe '[ Case Methods ]' do
4
+ # ==============================================================================
5
+ describe "[ Case Methods ]" do
6
6
  # Define shared contexts.
7
7
  # ----------------------------------------------------------------------------
8
- shared_context 'one word' do let(:string) { 'string' } end
9
- shared_context 'lowerCamelCase' do let(:string) { 'weAreBrushdown' } end
10
- shared_context 'UpperCamelCase' do let(:string) { 'WeAreBrushdown' } end
11
- shared_context 'lower_snake_case' do let(:string) { 'we_are_brushdown' } end
12
- shared_context 'Upper_Snake_Case' do let(:string) { 'We_Are_Brushdown' } end
13
- shared_context 'lower-kebab-case' do let(:string) { 'we-are-brushdown' } end
14
- shared_context 'Upper-Kebab-Case' do let(:string) { 'We-Are-Brushdown' } end
15
- shared_context 'lower space case' do let(:string) { 'we are brushdown' } end
16
- shared_context 'Upper Space Case' do let(:string) { 'We Are Brushdown' } end
17
- shared_context 'lower.dot.case' do let(:string) { 'we.are.brushdown' } end
18
- shared_context 'Upper.Dot.Case' do let(:string) { 'We.Are.Brushdown' } end
8
+ shared_context "one word" do let(:string) { "string" } end
9
+ shared_context "lowerCamelCase" do let(:string) { "iAmJagaApple" } end
10
+ shared_context "UpperCamelCase" do let(:string) { "IAmJagaApple" } end
11
+ shared_context "lower_snake_case" do let(:string) { "I_am_jaga_apple" } end
12
+ shared_context "Upper_Snake_Case" do let(:string) { "I_Am_Jaga_Apple" } end
13
+ shared_context "lower-kebab-case" do let(:string) { "i-am-jaga-apple" } end
14
+ shared_context "Upper-Kebab-Case" do let(:string) { "I-Am-Jaga-Apple" } end
15
+ shared_context "lower space case" do let(:string) { "i am jaga apple" } end
16
+ shared_context "Upper Space Case" do let(:string) { "I Am Jaga Apple" } end
17
+ shared_context "lower.dot.case" do let(:string) { "i.am.jaga.apple" } end
18
+ shared_context "Upper.Dot.Case" do let(:string) { "I.Am.Jaga.Apple" } end
19
19
  # ----------------------------------------------------------------------------
20
20
 
21
21
  # ----------------------------------------------------------------------------
22
22
  # Convert to lowerCamelCase
23
23
  # ----------------------------------------------------------------------------
24
- describe 'CONVERT TO lowerCamelCase' do
24
+ describe "CONVERT TO lowerCamelCase ::" do
25
25
  subject { string.to_lcamel }
26
26
 
27
27
  # Define shared examples.
28
28
  # --------------------------------------------------------------------------
29
- shared_examples 'be converted to lowerCamelCase' do
30
- it { is_expected.to eq 'weAreBrushdown' }
29
+ shared_examples "be converted to lowerCamelCase" do
30
+ it { is_expected.to eq("iAmJagaApple") }
31
31
  end
32
32
  # --------------------------------------------------------------------------
33
33
 
34
- context 'When a string has one word,' do
35
- include_context 'one word'
34
+ context "When a string has one word," do
35
+ include_context "one word"
36
36
 
37
- it { is_expected.to eq 'string' }
37
+ it { is_expected.to eq("string") }
38
38
  end
39
39
 
40
- context 'When a string lowerCamelCase,' do
41
- include_context 'lowerCamelCase'
40
+ context "When a string lowerCamelCase," do
41
+ include_context "lowerCamelCase"
42
42
 
43
- it_behaves_like 'be converted to lowerCamelCase'
43
+ it_behaves_like "be converted to lowerCamelCase"
44
44
  end
45
45
 
46
- context 'When a string UpperCamelCase,' do
47
- include_context 'UpperCamelCase'
46
+ context "When a string UpperCamelCase," do
47
+ include_context "UpperCamelCase"
48
48
 
49
- it_behaves_like 'be converted to lowerCamelCase'
49
+ it_behaves_like "be converted to lowerCamelCase"
50
50
  end
51
51
 
52
- context 'When a string lower_snake_case,' do
53
- include_context 'lower_snake_case'
52
+ context "When a string lower_snake_case," do
53
+ include_context "lower_snake_case"
54
54
 
55
- it_behaves_like 'be converted to lowerCamelCase'
55
+ it_behaves_like "be converted to lowerCamelCase"
56
56
  end
57
57
 
58
- context 'When a string Upper_Snake_Case,' do
59
- include_context 'Upper_Snake_Case'
58
+ context "When a string Upper_Snake_Case," do
59
+ include_context "Upper_Snake_Case"
60
60
 
61
- it_behaves_like 'be converted to lowerCamelCase'
61
+ it_behaves_like "be converted to lowerCamelCase"
62
62
  end
63
63
 
64
- context 'When a string lower-kebab-case,' do
65
- include_context 'lower-kebab-case'
64
+ context "When a string lower-kebab-case," do
65
+ include_context "lower-kebab-case"
66
66
 
67
- it_behaves_like 'be converted to lowerCamelCase'
67
+ it_behaves_like "be converted to lowerCamelCase"
68
68
  end
69
69
 
70
- context 'When a string Upper-Kebab-Case,' do
71
- include_context 'Upper-Kebab-Case'
70
+ context "When a string Upper-Kebab-Case," do
71
+ include_context "Upper-Kebab-Case"
72
72
 
73
- it_behaves_like 'be converted to lowerCamelCase'
73
+ it_behaves_like "be converted to lowerCamelCase"
74
74
  end
75
75
 
76
- context 'When a string lower space case,' do
77
- include_context 'lower space case'
76
+ context "When a string lower space case," do
77
+ include_context "lower space case"
78
78
 
79
- it_behaves_like 'be converted to lowerCamelCase'
79
+ it_behaves_like "be converted to lowerCamelCase"
80
80
  end
81
81
 
82
- context 'When a string Upper Space Case,' do
83
- include_context 'Upper Space Case'
82
+ context "When a string Upper Space Case," do
83
+ include_context "Upper Space Case"
84
84
 
85
- it_behaves_like 'be converted to lowerCamelCase'
85
+ it_behaves_like "be converted to lowerCamelCase"
86
86
  end
87
- context 'When a string lower.dot.case,' do
88
- include_context 'lower.dot.case'
87
+ context "When a string lower.dot.case," do
88
+ include_context "lower.dot.case"
89
89
 
90
- it_behaves_like 'be converted to lowerCamelCase'
90
+ it_behaves_like "be converted to lowerCamelCase"
91
91
  end
92
92
 
93
- context 'When a string Upper.Dot.Case,' do
94
- include_context 'Upper.Dot.Case'
93
+ context "When a string Upper.Dot.Case," do
94
+ include_context "Upper.Dot.Case"
95
95
 
96
- it_behaves_like 'be converted to lowerCamelCase'
96
+ it_behaves_like "be converted to lowerCamelCase"
97
97
  end
98
98
  end
99
99
 
@@ -101,79 +101,79 @@ describe '[ Case Methods ]' do
101
101
  # ----------------------------------------------------------------------------
102
102
  # Convert to UpperCamelCase
103
103
  # ----------------------------------------------------------------------------
104
- describe 'CONVERT TO UpperCamelCase' do
104
+ describe "CONVERT TO UpperCamelCase ::" do
105
105
  subject { string.to_ucamel }
106
106
 
107
107
  # Define shared examples.
108
108
  # --------------------------------------------------------------------------
109
- shared_examples 'be converted to UpperCamelCase' do
110
- it { is_expected.to eq 'WeAreBrushdown' }
109
+ shared_examples "be converted to UpperCamelCase" do
110
+ it { is_expected.to eq("IAmJagaApple") }
111
111
  end
112
112
  # --------------------------------------------------------------------------
113
113
 
114
- context 'When a string has one word,' do
115
- include_context 'one word'
114
+ context "When a string has one word," do
115
+ include_context "one word"
116
116
 
117
- it { is_expected.to eq 'String' }
117
+ it { is_expected.to eq("String") }
118
118
  end
119
119
 
120
- context 'When a string lowerCamelCase,' do
121
- include_context 'lowerCamelCase'
120
+ context "When a string lowerCamelCase," do
121
+ include_context "lowerCamelCase"
122
122
 
123
- it_behaves_like 'be converted to UpperCamelCase'
123
+ it_behaves_like "be converted to UpperCamelCase"
124
124
  end
125
125
 
126
- context 'When a string UpperCamelCase,' do
127
- include_context 'UpperCamelCase'
126
+ context "When a string UpperCamelCase," do
127
+ include_context "UpperCamelCase"
128
128
 
129
- it_behaves_like 'be converted to UpperCamelCase'
129
+ it_behaves_like "be converted to UpperCamelCase"
130
130
  end
131
131
 
132
- context 'When a string lower_snake_case,' do
133
- include_context 'lower_snake_case'
132
+ context "When a string lower_snake_case," do
133
+ include_context "lower_snake_case"
134
134
 
135
- it_behaves_like 'be converted to UpperCamelCase'
135
+ it_behaves_like "be converted to UpperCamelCase"
136
136
  end
137
137
 
138
- context 'When a string Upper_Snake_Case,' do
139
- include_context 'Upper_Snake_Case'
138
+ context "When a string Upper_Snake_Case," do
139
+ include_context "Upper_Snake_Case"
140
140
 
141
- it_behaves_like 'be converted to UpperCamelCase'
141
+ it_behaves_like "be converted to UpperCamelCase"
142
142
  end
143
143
 
144
- context 'When a string lower-kebab-case,' do
145
- include_context 'lower-kebab-case'
144
+ context "When a string lower-kebab-case," do
145
+ include_context "lower-kebab-case"
146
146
 
147
- it_behaves_like 'be converted to UpperCamelCase'
147
+ it_behaves_like "be converted to UpperCamelCase"
148
148
  end
149
149
 
150
- context 'When a string Upper-Kebab-Case,' do
151
- include_context 'Upper-Kebab-Case'
150
+ context "When a string Upper-Kebab-Case," do
151
+ include_context "Upper-Kebab-Case"
152
152
 
153
- it_behaves_like 'be converted to UpperCamelCase'
153
+ it_behaves_like "be converted to UpperCamelCase"
154
154
  end
155
155
 
156
- context 'When a string lower space case,' do
157
- include_context 'lower space case'
156
+ context "When a string lower space case," do
157
+ include_context "lower space case"
158
158
 
159
- it_behaves_like 'be converted to UpperCamelCase'
159
+ it_behaves_like "be converted to UpperCamelCase"
160
160
  end
161
161
 
162
- context 'When a string Upper Space Case,' do
163
- include_context 'Upper Space Case'
162
+ context "When a string Upper Space Case," do
163
+ include_context "Upper Space Case"
164
164
 
165
- it_behaves_like 'be converted to UpperCamelCase'
165
+ it_behaves_like "be converted to UpperCamelCase"
166
166
  end
167
- context 'When a string lower.dot.case,' do
168
- include_context 'lower.dot.case'
167
+ context "When a string lower.dot.case," do
168
+ include_context "lower.dot.case"
169
169
 
170
- it_behaves_like 'be converted to UpperCamelCase'
170
+ it_behaves_like "be converted to UpperCamelCase"
171
171
  end
172
172
 
173
- context 'When a string Upper.Dot.Case,' do
174
- include_context 'Upper.Dot.Case'
173
+ context "When a string Upper.Dot.Case," do
174
+ include_context "Upper.Dot.Case"
175
175
 
176
- it_behaves_like 'be converted to UpperCamelCase'
176
+ it_behaves_like "be converted to UpperCamelCase"
177
177
  end
178
178
  end
179
179
 
@@ -181,79 +181,79 @@ describe '[ Case Methods ]' do
181
181
  # ----------------------------------------------------------------------------
182
182
  # Convert to lower_snake_case
183
183
  # ----------------------------------------------------------------------------
184
- describe 'CONVERT TO lower_snake_case' do
184
+ describe "CONVERT TO lower_snake_case ::" do
185
185
  subject { string.to_lsnake }
186
186
 
187
187
  # Define shared examples.
188
188
  # --------------------------------------------------------------------------
189
- shared_examples 'be converted to lower_snake_case' do
190
- it { is_expected.to eq 'we_are_brushdown' }
189
+ shared_examples "be converted to lower_snake_case" do
190
+ it { is_expected.to eq("i_am_jaga_apple") }
191
191
  end
192
192
  # --------------------------------------------------------------------------
193
193
 
194
- context 'When a string has one word,' do
195
- include_context 'one word'
194
+ context "When a string has one word," do
195
+ include_context "one word"
196
196
 
197
- it { is_expected.to eq 'string' }
197
+ it { is_expected.to eq("string") }
198
198
  end
199
199
 
200
- context 'When a string lowerCamelCase,' do
201
- include_context 'lowerCamelCase'
200
+ context "When a string lowerCamelCase," do
201
+ include_context "lowerCamelCase"
202
202
 
203
- it_behaves_like 'be converted to lower_snake_case'
203
+ it_behaves_like "be converted to lower_snake_case"
204
204
  end
205
205
 
206
- context 'When a string UpperCamelCase,' do
207
- include_context 'UpperCamelCase'
206
+ context "When a string UpperCamelCase," do
207
+ include_context "UpperCamelCase"
208
208
 
209
- it_behaves_like 'be converted to lower_snake_case'
209
+ it_behaves_like "be converted to lower_snake_case"
210
210
  end
211
211
 
212
- context 'When a string lower_snake_case,' do
213
- include_context 'lower_snake_case'
212
+ context "When a string lower_snake_case," do
213
+ include_context "lower_snake_case"
214
214
 
215
- it_behaves_like 'be converted to lower_snake_case'
215
+ it_behaves_like "be converted to lower_snake_case"
216
216
  end
217
217
 
218
- context 'When a string Upper_Snake_Case,' do
219
- include_context 'Upper_Snake_Case'
218
+ context "When a string Upper_Snake_Case," do
219
+ include_context "Upper_Snake_Case"
220
220
 
221
- it_behaves_like 'be converted to lower_snake_case'
221
+ it_behaves_like "be converted to lower_snake_case"
222
222
  end
223
223
 
224
- context 'When a string lower-kebab-case,' do
225
- include_context 'lower-kebab-case'
224
+ context "When a string lower-kebab-case," do
225
+ include_context "lower-kebab-case"
226
226
 
227
- it_behaves_like 'be converted to lower_snake_case'
227
+ it_behaves_like "be converted to lower_snake_case"
228
228
  end
229
229
 
230
- context 'When a string Upper-Kebab-Case,' do
231
- include_context 'Upper-Kebab-Case'
230
+ context "When a string Upper-Kebab-Case," do
231
+ include_context "Upper-Kebab-Case"
232
232
 
233
- it_behaves_like 'be converted to lower_snake_case'
233
+ it_behaves_like "be converted to lower_snake_case"
234
234
  end
235
235
 
236
- context 'When a string lower space case,' do
237
- include_context 'lower space case'
236
+ context "When a string lower space case," do
237
+ include_context "lower space case"
238
238
 
239
- it_behaves_like 'be converted to lower_snake_case'
239
+ it_behaves_like "be converted to lower_snake_case"
240
240
  end
241
241
 
242
- context 'When a string Upper Space Case,' do
243
- include_context 'Upper Space Case'
242
+ context "When a string Upper Space Case," do
243
+ include_context "Upper Space Case"
244
244
 
245
- it_behaves_like 'be converted to lower_snake_case'
245
+ it_behaves_like "be converted to lower_snake_case"
246
246
  end
247
- context 'When a string lower.dot.case,' do
248
- include_context 'lower.dot.case'
247
+ context "When a string lower.dot.case," do
248
+ include_context "lower.dot.case"
249
249
 
250
- it_behaves_like 'be converted to lower_snake_case'
250
+ it_behaves_like "be converted to lower_snake_case"
251
251
  end
252
252
 
253
- context 'When a string Upper.Dot.Case,' do
254
- include_context 'Upper.Dot.Case'
253
+ context "When a string Upper.Dot.Case," do
254
+ include_context "Upper.Dot.Case"
255
255
 
256
- it_behaves_like 'be converted to lower_snake_case'
256
+ it_behaves_like "be converted to lower_snake_case"
257
257
  end
258
258
  end
259
259
 
@@ -261,79 +261,79 @@ describe '[ Case Methods ]' do
261
261
  # ----------------------------------------------------------------------------
262
262
  # Convert to Upper_Snake_Case
263
263
  # ----------------------------------------------------------------------------
264
- describe 'CONVERT TO Upper_Snake_Case' do
264
+ describe "CONVERT TO Upper_Snake_Case ::" do
265
265
  subject { string.to_usnake }
266
266
 
267
267
  # Define shared examples.
268
268
  # --------------------------------------------------------------------------
269
- shared_examples 'be converted to Upper_Snake_Case' do
270
- it { is_expected.to eq 'We_Are_Brushdown' }
269
+ shared_examples "be converted to Upper_Snake_Case" do
270
+ it { is_expected.to eq("I_Am_Jaga_Apple") }
271
271
  end
272
272
  # --------------------------------------------------------------------------
273
273
 
274
- context 'When a string has one word,' do
275
- include_context 'one word'
274
+ context "When a string has one word," do
275
+ include_context "one word"
276
276
 
277
- it { is_expected.to eq 'String' }
277
+ it { is_expected.to eq("String") }
278
278
  end
279
279
 
280
- context 'When a string lowerCamelCase,' do
281
- include_context 'lowerCamelCase'
280
+ context "When a string lowerCamelCase," do
281
+ include_context "lowerCamelCase"
282
282
 
283
- it_behaves_like 'be converted to Upper_Snake_Case'
283
+ it_behaves_like "be converted to Upper_Snake_Case"
284
284
  end
285
285
 
286
- context 'When a string UpperCamelCase,' do
287
- include_context 'UpperCamelCase'
286
+ context "When a string UpperCamelCase," do
287
+ include_context "UpperCamelCase"
288
288
 
289
- it_behaves_like 'be converted to Upper_Snake_Case'
289
+ it_behaves_like "be converted to Upper_Snake_Case"
290
290
  end
291
291
 
292
- context 'When a string lower_snake_case,' do
293
- include_context 'lower_snake_case'
292
+ context "When a string lower_snake_case," do
293
+ include_context "lower_snake_case"
294
294
 
295
- it_behaves_like 'be converted to Upper_Snake_Case'
295
+ it_behaves_like "be converted to Upper_Snake_Case"
296
296
  end
297
297
 
298
- context 'When a string Upper_Snake_Case,' do
299
- include_context 'Upper_Snake_Case'
298
+ context "When a string Upper_Snake_Case," do
299
+ include_context "Upper_Snake_Case"
300
300
 
301
- it_behaves_like 'be converted to Upper_Snake_Case'
301
+ it_behaves_like "be converted to Upper_Snake_Case"
302
302
  end
303
303
 
304
- context 'When a string lower-kebab-case,' do
305
- include_context 'lower-kebab-case'
304
+ context "When a string lower-kebab-case," do
305
+ include_context "lower-kebab-case"
306
306
 
307
- it_behaves_like 'be converted to Upper_Snake_Case'
307
+ it_behaves_like "be converted to Upper_Snake_Case"
308
308
  end
309
309
 
310
- context 'When a string Upper-Kebab-Case,' do
311
- include_context 'Upper-Kebab-Case'
310
+ context "When a string Upper-Kebab-Case," do
311
+ include_context "Upper-Kebab-Case"
312
312
 
313
- it_behaves_like 'be converted to Upper_Snake_Case'
313
+ it_behaves_like "be converted to Upper_Snake_Case"
314
314
  end
315
315
 
316
- context 'When a string lower space case,' do
317
- include_context 'lower space case'
316
+ context "When a string lower space case," do
317
+ include_context "lower space case"
318
318
 
319
- it_behaves_like 'be converted to Upper_Snake_Case'
319
+ it_behaves_like "be converted to Upper_Snake_Case"
320
320
  end
321
321
 
322
- context 'When a string Upper Space Case,' do
323
- include_context 'Upper Space Case'
322
+ context "When a string Upper Space Case," do
323
+ include_context "Upper Space Case"
324
324
 
325
- it_behaves_like 'be converted to Upper_Snake_Case'
325
+ it_behaves_like "be converted to Upper_Snake_Case"
326
326
  end
327
- context 'When a string lower.dot.case,' do
328
- include_context 'lower.dot.case'
327
+ context "When a string lower.dot.case," do
328
+ include_context "lower.dot.case"
329
329
 
330
- it_behaves_like 'be converted to Upper_Snake_Case'
330
+ it_behaves_like "be converted to Upper_Snake_Case"
331
331
  end
332
332
 
333
- context 'When a string Upper.Dot.Case,' do
334
- include_context 'Upper.Dot.Case'
333
+ context "When a string Upper.Dot.Case," do
334
+ include_context "Upper.Dot.Case"
335
335
 
336
- it_behaves_like 'be converted to Upper_Snake_Case'
336
+ it_behaves_like "be converted to Upper_Snake_Case"
337
337
  end
338
338
  end
339
339
 
@@ -341,79 +341,79 @@ describe '[ Case Methods ]' do
341
341
  # ----------------------------------------------------------------------------
342
342
  # Convert to lower-kebab-case
343
343
  # ----------------------------------------------------------------------------
344
- describe 'CONVERT TO lower-kebab-case' do
344
+ describe "CONVERT TO lower-kebab-case ::" do
345
345
  subject { string.to_lkebab }
346
346
 
347
347
  # Define shared examples.
348
348
  # --------------------------------------------------------------------------
349
- shared_examples 'be converted to lower-kebab-case' do
350
- it { is_expected.to eq 'we-are-brushdown' }
349
+ shared_examples "be converted to lower-kebab-case" do
350
+ it { is_expected.to eq("i-am-jaga-apple") }
351
351
  end
352
352
  # --------------------------------------------------------------------------
353
353
 
354
- context 'When a string has one word,' do
355
- include_context 'one word'
354
+ context "When a string has one word," do
355
+ include_context "one word"
356
356
 
357
- it { is_expected.to eq 'string' }
357
+ it { is_expected.to eq("string") }
358
358
  end
359
359
 
360
- context 'When a string lowerCamelCase,' do
361
- include_context 'lowerCamelCase'
360
+ context "When a string lowerCamelCase," do
361
+ include_context "lowerCamelCase"
362
362
 
363
- it_behaves_like 'be converted to lower-kebab-case'
363
+ it_behaves_like "be converted to lower-kebab-case"
364
364
  end
365
365
 
366
- context 'When a string UpperCamelCase,' do
367
- include_context 'UpperCamelCase'
366
+ context "When a string UpperCamelCase," do
367
+ include_context "UpperCamelCase"
368
368
 
369
- it_behaves_like 'be converted to lower-kebab-case'
369
+ it_behaves_like "be converted to lower-kebab-case"
370
370
  end
371
371
 
372
- context 'When a string lower_snake_case,' do
373
- include_context 'lower_snake_case'
372
+ context "When a string lower_snake_case," do
373
+ include_context "lower_snake_case"
374
374
 
375
- it_behaves_like 'be converted to lower-kebab-case'
375
+ it_behaves_like "be converted to lower-kebab-case"
376
376
  end
377
377
 
378
- context 'When a string Upper_Snake_Case,' do
379
- include_context 'Upper_Snake_Case'
378
+ context "When a string Upper_Snake_Case," do
379
+ include_context "Upper_Snake_Case"
380
380
 
381
- it_behaves_like 'be converted to lower-kebab-case'
381
+ it_behaves_like "be converted to lower-kebab-case"
382
382
  end
383
383
 
384
- context 'When a string lower-kebab-case,' do
385
- include_context 'lower-kebab-case'
384
+ context "When a string lower-kebab-case," do
385
+ include_context "lower-kebab-case"
386
386
 
387
- it_behaves_like 'be converted to lower-kebab-case'
387
+ it_behaves_like "be converted to lower-kebab-case"
388
388
  end
389
389
 
390
- context 'When a string Upper-Kebab-Case,' do
391
- include_context 'Upper-Kebab-Case'
390
+ context "When a string Upper-Kebab-Case," do
391
+ include_context "Upper-Kebab-Case"
392
392
 
393
- it_behaves_like 'be converted to lower-kebab-case'
393
+ it_behaves_like "be converted to lower-kebab-case"
394
394
  end
395
395
 
396
- context 'When a string lower space case,' do
397
- include_context 'lower space case'
396
+ context "When a string lower space case," do
397
+ include_context "lower space case"
398
398
 
399
- it_behaves_like 'be converted to lower-kebab-case'
399
+ it_behaves_like "be converted to lower-kebab-case"
400
400
  end
401
401
 
402
- context 'When a string Upper Space Case,' do
403
- include_context 'Upper Space Case'
402
+ context "When a string Upper Space Case," do
403
+ include_context "Upper Space Case"
404
404
 
405
- it_behaves_like 'be converted to lower-kebab-case'
405
+ it_behaves_like "be converted to lower-kebab-case"
406
406
  end
407
- context 'When a string lower.dot.case,' do
408
- include_context 'lower.dot.case'
407
+ context "When a string lower.dot.case," do
408
+ include_context "lower.dot.case"
409
409
 
410
- it_behaves_like 'be converted to lower-kebab-case'
410
+ it_behaves_like "be converted to lower-kebab-case"
411
411
  end
412
412
 
413
- context 'When a string Upper.Dot.Case,' do
414
- include_context 'Upper.Dot.Case'
413
+ context "When a string Upper.Dot.Case," do
414
+ include_context "Upper.Dot.Case"
415
415
 
416
- it_behaves_like 'be converted to lower-kebab-case'
416
+ it_behaves_like "be converted to lower-kebab-case"
417
417
  end
418
418
  end
419
419
 
@@ -421,79 +421,79 @@ describe '[ Case Methods ]' do
421
421
  # ----------------------------------------------------------------------------
422
422
  # Convert to Upper-Kebab-Case
423
423
  # ----------------------------------------------------------------------------
424
- describe 'CONVERT TO Upper-Kebab-Case' do
424
+ describe "CONVERT TO Upper-Kebab-Case ::" do
425
425
  subject { string.to_ukebab }
426
426
 
427
427
  # Define shared examples.
428
428
  # --------------------------------------------------------------------------
429
- shared_examples 'be converted to Upper-Kebab-Case' do
430
- it { is_expected.to eq 'We-Are-Brushdown' }
429
+ shared_examples "be converted to Upper-Kebab-Case" do
430
+ it { is_expected.to eq("I-Am-Jaga-Apple") }
431
431
  end
432
432
  # --------------------------------------------------------------------------
433
433
 
434
- context 'When a string has one word,' do
435
- include_context 'one word'
434
+ context "When a string has one word," do
435
+ include_context "one word"
436
436
 
437
- it { is_expected.to eq 'String' }
437
+ it { is_expected.to eq("String") }
438
438
  end
439
439
 
440
- context 'When a string lowerCamelCase,' do
441
- include_context 'lowerCamelCase'
440
+ context "When a string lowerCamelCase," do
441
+ include_context "lowerCamelCase"
442
442
 
443
- it_behaves_like 'be converted to Upper-Kebab-Case'
443
+ it_behaves_like "be converted to Upper-Kebab-Case"
444
444
  end
445
445
 
446
- context 'When a string UpperCamelCase,' do
447
- include_context 'UpperCamelCase'
446
+ context "When a string UpperCamelCase," do
447
+ include_context "UpperCamelCase"
448
448
 
449
- it_behaves_like 'be converted to Upper-Kebab-Case'
449
+ it_behaves_like "be converted to Upper-Kebab-Case"
450
450
  end
451
451
 
452
- context 'When a string lower_snake_case,' do
453
- include_context 'lower_snake_case'
452
+ context "When a string lower_snake_case," do
453
+ include_context "lower_snake_case"
454
454
 
455
- it_behaves_like 'be converted to Upper-Kebab-Case'
455
+ it_behaves_like "be converted to Upper-Kebab-Case"
456
456
  end
457
457
 
458
- context 'When a string Upper_Snake_Case,' do
459
- include_context 'Upper_Snake_Case'
458
+ context "When a string Upper_Snake_Case," do
459
+ include_context "Upper_Snake_Case"
460
460
 
461
- it_behaves_like 'be converted to Upper-Kebab-Case'
461
+ it_behaves_like "be converted to Upper-Kebab-Case"
462
462
  end
463
463
 
464
- context 'When a string lower-kebab-case,' do
465
- include_context 'lower-kebab-case'
464
+ context "When a string lower-kebab-case," do
465
+ include_context "lower-kebab-case"
466
466
 
467
- it_behaves_like 'be converted to Upper-Kebab-Case'
467
+ it_behaves_like "be converted to Upper-Kebab-Case"
468
468
  end
469
469
 
470
- context 'When a string Upper-Kebab-Case,' do
471
- include_context 'Upper-Kebab-Case'
470
+ context "When a string Upper-Kebab-Case," do
471
+ include_context "Upper-Kebab-Case"
472
472
 
473
- it_behaves_like 'be converted to Upper-Kebab-Case'
473
+ it_behaves_like "be converted to Upper-Kebab-Case"
474
474
  end
475
475
 
476
- context 'When a string lower space case,' do
477
- include_context 'lower space case'
476
+ context "When a string lower space case," do
477
+ include_context "lower space case"
478
478
 
479
- it_behaves_like 'be converted to Upper-Kebab-Case'
479
+ it_behaves_like "be converted to Upper-Kebab-Case"
480
480
  end
481
481
 
482
- context 'When a string Upper Space Case,' do
483
- include_context 'Upper Space Case'
482
+ context "When a string Upper Space Case," do
483
+ include_context "Upper Space Case"
484
484
 
485
- it_behaves_like 'be converted to Upper-Kebab-Case'
485
+ it_behaves_like "be converted to Upper-Kebab-Case"
486
486
  end
487
- context 'When a string lower.dot.case,' do
488
- include_context 'lower.dot.case'
487
+ context "When a string lower.dot.case," do
488
+ include_context "lower.dot.case"
489
489
 
490
- it_behaves_like 'be converted to Upper-Kebab-Case'
490
+ it_behaves_like "be converted to Upper-Kebab-Case"
491
491
  end
492
492
 
493
- context 'When a string Upper.Dot.Case,' do
494
- include_context 'Upper.Dot.Case'
493
+ context "When a string Upper.Dot.Case," do
494
+ include_context "Upper.Dot.Case"
495
495
 
496
- it_behaves_like 'be converted to Upper-Kebab-Case'
496
+ it_behaves_like "be converted to Upper-Kebab-Case"
497
497
  end
498
498
  end
499
499
 
@@ -501,79 +501,79 @@ describe '[ Case Methods ]' do
501
501
  # ----------------------------------------------------------------------------
502
502
  # Convert to lower space case
503
503
  # ----------------------------------------------------------------------------
504
- describe 'CONVERT TO lower space case' do
504
+ describe "CONVERT TO lower space case ::" do
505
505
  subject { string.to_lspace }
506
506
 
507
507
  # Define shared examples.
508
508
  # --------------------------------------------------------------------------
509
- shared_examples 'be converted to lower space case' do
510
- it { is_expected.to eq 'we are brushdown' }
509
+ shared_examples "be converted to lower space case" do
510
+ it { is_expected.to eq("i am jaga apple") }
511
511
  end
512
512
  # --------------------------------------------------------------------------
513
513
 
514
- context 'When a string has one word,' do
515
- include_context 'one word'
514
+ context "When a string has one word," do
515
+ include_context "one word"
516
516
 
517
- it { is_expected.to eq 'string' }
517
+ it { is_expected.to eq("string") }
518
518
  end
519
519
 
520
- context 'When a string lowerCamelCase,' do
521
- include_context 'lowerCamelCase'
520
+ context "When a string lowerCamelCase," do
521
+ include_context "lowerCamelCase"
522
522
 
523
- it_behaves_like 'be converted to lower space case'
523
+ it_behaves_like "be converted to lower space case"
524
524
  end
525
525
 
526
- context 'When a string UpperCamelCase,' do
527
- include_context 'UpperCamelCase'
526
+ context "When a string UpperCamelCase," do
527
+ include_context "UpperCamelCase"
528
528
 
529
- it_behaves_like 'be converted to lower space case'
529
+ it_behaves_like "be converted to lower space case"
530
530
  end
531
531
 
532
- context 'When a string lower_snake_case,' do
533
- include_context 'lower_snake_case'
532
+ context "When a string lower_snake_case," do
533
+ include_context "lower_snake_case"
534
534
 
535
- it_behaves_like 'be converted to lower space case'
535
+ it_behaves_like "be converted to lower space case"
536
536
  end
537
537
 
538
- context 'When a string Upper_Snake_Case,' do
539
- include_context 'Upper_Snake_Case'
538
+ context "When a string Upper_Snake_Case," do
539
+ include_context "Upper_Snake_Case"
540
540
 
541
- it_behaves_like 'be converted to lower space case'
541
+ it_behaves_like "be converted to lower space case"
542
542
  end
543
543
 
544
- context 'When a string lower-kebab-case,' do
545
- include_context 'lower-kebab-case'
544
+ context "When a string lower-kebab-case," do
545
+ include_context "lower-kebab-case"
546
546
 
547
- it_behaves_like 'be converted to lower space case'
547
+ it_behaves_like "be converted to lower space case"
548
548
  end
549
549
 
550
- context 'When a string Upper-Kebab-Case,' do
551
- include_context 'Upper-Kebab-Case'
550
+ context "When a string Upper-Kebab-Case," do
551
+ include_context "Upper-Kebab-Case"
552
552
 
553
- it_behaves_like 'be converted to lower space case'
553
+ it_behaves_like "be converted to lower space case"
554
554
  end
555
555
 
556
- context 'When a string lower space case,' do
557
- include_context 'lower space case'
556
+ context "When a string lower space case," do
557
+ include_context "lower space case"
558
558
 
559
- it_behaves_like 'be converted to lower space case'
559
+ it_behaves_like "be converted to lower space case"
560
560
  end
561
561
 
562
- context 'When a string Upper Space Case,' do
563
- include_context 'Upper Space Case'
562
+ context "When a string Upper Space Case," do
563
+ include_context "Upper Space Case"
564
564
 
565
- it_behaves_like 'be converted to lower space case'
565
+ it_behaves_like "be converted to lower space case"
566
566
  end
567
- context 'When a string lower.dot.case,' do
568
- include_context 'lower.dot.case'
567
+ context "When a string lower.dot.case," do
568
+ include_context "lower.dot.case"
569
569
 
570
- it_behaves_like 'be converted to lower space case'
570
+ it_behaves_like "be converted to lower space case"
571
571
  end
572
572
 
573
- context 'When a string Upper.Dot.Case,' do
574
- include_context 'Upper.Dot.Case'
573
+ context "When a string Upper.Dot.Case," do
574
+ include_context "Upper.Dot.Case"
575
575
 
576
- it_behaves_like 'be converted to lower space case'
576
+ it_behaves_like "be converted to lower space case"
577
577
  end
578
578
  end
579
579
 
@@ -581,79 +581,79 @@ describe '[ Case Methods ]' do
581
581
  # ----------------------------------------------------------------------------
582
582
  # Convert to Upper Space Case
583
583
  # ----------------------------------------------------------------------------
584
- describe 'CONVERT TO Upper Space Case' do
584
+ describe "CONVERT TO Upper Space Case ::" do
585
585
  subject { string.to_uspace }
586
586
 
587
587
  # Define shared examples.
588
588
  # --------------------------------------------------------------------------
589
- shared_examples 'be converted to Upper Space Case' do
590
- it { is_expected.to eq 'We Are Brushdown' }
589
+ shared_examples "be converted to Upper Space Case" do
590
+ it { is_expected.to eq("I Am Jaga Apple") }
591
591
  end
592
592
  # --------------------------------------------------------------------------
593
593
 
594
- context 'When a string has one word,' do
595
- include_context 'one word'
594
+ context "When a string has one word," do
595
+ include_context "one word"
596
596
 
597
- it { is_expected.to eq 'String' }
597
+ it { is_expected.to eq("String") }
598
598
  end
599
599
 
600
- context 'When a string lowerCamelCase,' do
601
- include_context 'lowerCamelCase'
600
+ context "When a string lowerCamelCase," do
601
+ include_context "lowerCamelCase"
602
602
 
603
- it_behaves_like 'be converted to Upper Space Case'
603
+ it_behaves_like "be converted to Upper Space Case"
604
604
  end
605
605
 
606
- context 'When a string UpperCamelCase,' do
607
- include_context 'UpperCamelCase'
606
+ context "When a string UpperCamelCase," do
607
+ include_context "UpperCamelCase"
608
608
 
609
- it_behaves_like 'be converted to Upper Space Case'
609
+ it_behaves_like "be converted to Upper Space Case"
610
610
  end
611
611
 
612
- context 'When a string lower_snake_case,' do
613
- include_context 'lower_snake_case'
612
+ context "When a string lower_snake_case," do
613
+ include_context "lower_snake_case"
614
614
 
615
- it_behaves_like 'be converted to Upper Space Case'
615
+ it_behaves_like "be converted to Upper Space Case"
616
616
  end
617
617
 
618
- context 'When a string Upper_Snake_Case,' do
619
- include_context 'Upper_Snake_Case'
618
+ context "When a string Upper_Snake_Case," do
619
+ include_context "Upper_Snake_Case"
620
620
 
621
- it_behaves_like 'be converted to Upper Space Case'
621
+ it_behaves_like "be converted to Upper Space Case"
622
622
  end
623
623
 
624
- context 'When a string lower-kebab-case,' do
625
- include_context 'lower-kebab-case'
624
+ context "When a string lower-kebab-case," do
625
+ include_context "lower-kebab-case"
626
626
 
627
- it_behaves_like 'be converted to Upper Space Case'
627
+ it_behaves_like "be converted to Upper Space Case"
628
628
  end
629
629
 
630
- context 'When a string Upper-Kebab-Case,' do
631
- include_context 'Upper-Kebab-Case'
630
+ context "When a string Upper-Kebab-Case," do
631
+ include_context "Upper-Kebab-Case"
632
632
 
633
- it_behaves_like 'be converted to Upper Space Case'
633
+ it_behaves_like "be converted to Upper Space Case"
634
634
  end
635
635
 
636
- context 'When a string lower space case,' do
637
- include_context 'lower space case'
636
+ context "When a string lower space case," do
637
+ include_context "lower space case"
638
638
 
639
- it_behaves_like 'be converted to Upper Space Case'
639
+ it_behaves_like "be converted to Upper Space Case"
640
640
  end
641
641
 
642
- context 'When a string Upper Space Case,' do
643
- include_context 'Upper Space Case'
642
+ context "When a string Upper Space Case," do
643
+ include_context "Upper Space Case"
644
644
 
645
- it_behaves_like 'be converted to Upper Space Case'
645
+ it_behaves_like "be converted to Upper Space Case"
646
646
  end
647
- context 'When a string lower.dot.case,' do
648
- include_context 'lower.dot.case'
647
+ context "When a string lower.dot.case," do
648
+ include_context "lower.dot.case"
649
649
 
650
- it_behaves_like 'be converted to Upper Space Case'
650
+ it_behaves_like "be converted to Upper Space Case"
651
651
  end
652
652
 
653
- context 'When a string Upper.Dot.Case,' do
654
- include_context 'Upper.Dot.Case'
653
+ context "When a string Upper.Dot.Case," do
654
+ include_context "Upper.Dot.Case"
655
655
 
656
- it_behaves_like 'be converted to Upper Space Case'
656
+ it_behaves_like "be converted to Upper Space Case"
657
657
  end
658
658
  end
659
659
 
@@ -661,240 +661,205 @@ describe '[ Case Methods ]' do
661
661
  # ----------------------------------------------------------------------------
662
662
  # Convert to lower.dot.case
663
663
  # ----------------------------------------------------------------------------
664
- describe 'CONVERT TO lower.dot.case' do
664
+ describe "CONVERT TO lower.dot.case ::" do
665
665
  subject { string.to_ldot }
666
666
 
667
667
  # Define shared examples.
668
668
  # --------------------------------------------------------------------------
669
- shared_examples 'be converted to lower.dot.case' do
670
- it { is_expected.to eq 'we.are.brushdown' }
669
+ shared_examples "be converted to lower.dot.case" do
670
+ it { is_expected.to eq("i.am.jaga.apple") }
671
671
  end
672
672
  # --------------------------------------------------------------------------
673
673
 
674
- context 'When a string has one word,' do
675
- include_context 'one word'
674
+ context "When a string has one word," do
675
+ include_context "one word"
676
676
 
677
- it { is_expected.to eq 'string' }
677
+ it { is_expected.to eq("string") }
678
678
  end
679
679
 
680
- context 'When a string lowerCamelCase,' do
681
- include_context 'lowerCamelCase'
680
+ context "When a string lowerCamelCase," do
681
+ include_context "lowerCamelCase"
682
682
 
683
- it_behaves_like 'be converted to lower.dot.case'
683
+ it_behaves_like "be converted to lower.dot.case"
684
684
  end
685
685
 
686
- context 'When a string UpperCamelCase,' do
687
- include_context 'UpperCamelCase'
686
+ context "When a string UpperCamelCase," do
687
+ include_context "UpperCamelCase"
688
688
 
689
- it_behaves_like 'be converted to lower.dot.case'
689
+ it_behaves_like "be converted to lower.dot.case"
690
690
  end
691
691
 
692
- context 'When a string lower_snake_case,' do
693
- include_context 'lower_snake_case'
692
+ context "When a string lower_snake_case," do
693
+ include_context "lower_snake_case"
694
694
 
695
- it_behaves_like 'be converted to lower.dot.case'
695
+ it_behaves_like "be converted to lower.dot.case"
696
696
  end
697
697
 
698
- context 'When a string Upper_Snake_Case,' do
699
- include_context 'Upper_Snake_Case'
698
+ context "When a string Upper_Snake_Case," do
699
+ include_context "Upper_Snake_Case"
700
700
 
701
- it_behaves_like 'be converted to lower.dot.case'
701
+ it_behaves_like "be converted to lower.dot.case"
702
702
  end
703
703
 
704
- context 'When a string lower-kebab-case,' do
705
- include_context 'lower-kebab-case'
704
+ context "When a string lower-kebab-case," do
705
+ include_context "lower-kebab-case"
706
706
 
707
- it_behaves_like 'be converted to lower.dot.case'
707
+ it_behaves_like "be converted to lower.dot.case"
708
708
  end
709
709
 
710
- context 'When a string Upper-Kebab-Case,' do
711
- include_context 'Upper-Kebab-Case'
710
+ context "When a string Upper-Kebab-Case," do
711
+ include_context "Upper-Kebab-Case"
712
712
 
713
- it_behaves_like 'be converted to lower.dot.case'
713
+ it_behaves_like "be converted to lower.dot.case"
714
714
  end
715
715
 
716
- context 'When a string lower space case,' do
717
- include_context 'lower space case'
716
+ context "When a string lower space case," do
717
+ include_context "lower space case"
718
718
 
719
- it_behaves_like 'be converted to lower.dot.case'
719
+ it_behaves_like "be converted to lower.dot.case"
720
720
  end
721
721
 
722
- context 'When a string Upper Space Case,' do
723
- include_context 'Upper Space Case'
722
+ context "When a string Upper Space Case," do
723
+ include_context "Upper Space Case"
724
724
 
725
- it_behaves_like 'be converted to lower.dot.case'
725
+ it_behaves_like "be converted to lower.dot.case"
726
726
  end
727
- context 'When a string lower.dot.case,' do
728
- include_context 'lower.dot.case'
727
+ context "When a string lower.dot.case," do
728
+ include_context "lower.dot.case"
729
729
 
730
- it_behaves_like 'be converted to lower.dot.case'
730
+ it_behaves_like "be converted to lower.dot.case"
731
731
  end
732
732
 
733
- context 'When a string Upper.Dot.Case,' do
734
- include_context 'Upper.Dot.Case'
733
+ context "When a string Upper.Dot.Case," do
734
+ include_context "Upper.Dot.Case"
735
735
 
736
- it_behaves_like 'be converted to lower.dot.case'
736
+ it_behaves_like "be converted to lower.dot.case"
737
737
  end
738
738
  end
739
739
 
740
740
 
741
+ # ----------------------------------------------------------------------------
742
+ # Private
743
+ # ----------------------------------------------------------------------------
741
744
  # ----------------------------------------------------------------------------
742
745
  # Convert to Upper.Dot.Case
743
746
  # ----------------------------------------------------------------------------
744
- describe 'CONVERT TO Upper.Dot.Case' do
747
+ describe "CONVERT TO Upper.Dot.Case ::" do
745
748
  subject { string.to_udot }
746
749
 
747
750
  # Define shared examples.
748
751
  # --------------------------------------------------------------------------
749
- shared_examples 'be converted to Upper.Dot.Case' do
750
- it { is_expected.to eq 'We.Are.Brushdown' }
752
+ shared_examples "be converted to Upper.Dot.Case" do
753
+ it { is_expected.to eq("I.Am.Jaga.Apple") }
751
754
  end
752
755
  # --------------------------------------------------------------------------
753
756
 
754
- context 'When a string has one word,' do
755
- include_context 'one word'
757
+ context "When a string has one word," do
758
+ include_context "one word"
756
759
 
757
- it { is_expected.to eq 'String' }
760
+ it { is_expected.to eq("String") }
758
761
  end
759
762
 
760
- context 'When a string lowerCamelCase,' do
761
- include_context 'lowerCamelCase'
763
+ context "When a string lowerCamelCase," do
764
+ include_context "lowerCamelCase"
762
765
 
763
- it_behaves_like 'be converted to Upper.Dot.Case'
766
+ it_behaves_like "be converted to Upper.Dot.Case"
764
767
  end
765
768
 
766
- context 'When a string UpperCamelCase,' do
767
- include_context 'UpperCamelCase'
769
+ context "When a string UpperCamelCase," do
770
+ include_context "UpperCamelCase"
768
771
 
769
- it_behaves_like 'be converted to Upper.Dot.Case'
772
+ it_behaves_like "be converted to Upper.Dot.Case"
770
773
  end
771
774
 
772
- context 'When a string lower_snake_case,' do
773
- include_context 'lower_snake_case'
775
+ context "When a string lower_snake_case," do
776
+ include_context "lower_snake_case"
774
777
 
775
- it_behaves_like 'be converted to Upper.Dot.Case'
778
+ it_behaves_like "be converted to Upper.Dot.Case"
776
779
  end
777
780
 
778
- context 'When a string Upper_Snake_Case,' do
779
- include_context 'Upper_Snake_Case'
781
+ context "When a string Upper_Snake_Case," do
782
+ include_context "Upper_Snake_Case"
780
783
 
781
- it_behaves_like 'be converted to Upper.Dot.Case'
784
+ it_behaves_like "be converted to Upper.Dot.Case"
782
785
  end
783
786
 
784
- context 'When a string lower-kebab-case,' do
785
- include_context 'lower-kebab-case'
787
+ context "When a string lower-kebab-case," do
788
+ include_context "lower-kebab-case"
786
789
 
787
- it_behaves_like 'be converted to Upper.Dot.Case'
790
+ it_behaves_like "be converted to Upper.Dot.Case"
788
791
  end
789
792
 
790
- context 'When a string Upper-Kebab-Case,' do
791
- include_context 'Upper-Kebab-Case'
793
+ context "When a string Upper-Kebab-Case," do
794
+ include_context "Upper-Kebab-Case"
792
795
 
793
- it_behaves_like 'be converted to Upper.Dot.Case'
796
+ it_behaves_like "be converted to Upper.Dot.Case"
794
797
  end
795
798
 
796
- context 'When a string lower space case,' do
797
- include_context 'lower space case'
799
+ context "When a string lower space case," do
800
+ include_context "lower space case"
798
801
 
799
- it_behaves_like 'be converted to Upper.Dot.Case'
802
+ it_behaves_like "be converted to Upper.Dot.Case"
800
803
  end
801
804
 
802
- context 'When a string Upper Space Case,' do
803
- include_context 'Upper Space Case'
805
+ context "When a string Upper Space Case," do
806
+ include_context "Upper Space Case"
804
807
 
805
- it_behaves_like 'be converted to Upper.Dot.Case'
808
+ it_behaves_like "be converted to Upper.Dot.Case"
806
809
  end
807
- context 'When a string lower.dot.case,' do
808
- include_context 'lower.dot.case'
810
+ context "When a string lower.dot.case," do
811
+ include_context "lower.dot.case"
809
812
 
810
- it_behaves_like 'be converted to Upper.Dot.Case'
813
+ it_behaves_like "be converted to Upper.Dot.Case"
811
814
  end
812
815
 
813
- context 'When a string Upper.Dot.Case,' do
814
- include_context 'Upper.Dot.Case'
816
+ context "When a string Upper.Dot.Case," do
817
+ include_context "Upper.Dot.Case"
815
818
 
816
- it_behaves_like 'be converted to Upper.Dot.Case'
819
+ it_behaves_like "be converted to Upper.Dot.Case"
817
820
  end
818
821
  end
819
822
 
820
823
 
821
824
  # ----------------------------------------------------------------------------
822
- # Split string according to camel case
825
+ # Split String According to Camel Case
823
826
  # ----------------------------------------------------------------------------
824
- describe 'SPLIT ACCORDING TO CAMEL CASE' do
827
+ describe "SPLIT ACCORDING TO CAMEL CASE ::" do
825
828
  let(:string) { nil }
826
- subject { string.split_camel }
829
+ subject { string.instance_eval { split_camel } }
827
830
 
828
- context 'When string is Upper Camel Case,' do
829
- let!(:string) { 'ThisIsWord' }
830
- it { is_expected.to eq ['This', 'Is', 'Word'] }
831
- end
832
-
833
- context 'When string is Lower Camel Case,' do
834
- let!(:string) { 'thisIsWord' }
835
- it { is_expected.to eq ['this', 'Is', 'Word'] }
831
+ context "When string is Upper Camel Case," do
832
+ let!(:string) { "ThisIsWord" }
833
+ it { is_expected.to eq(["This", "Is", "Word"]) }
836
834
  end
837
835
 
838
- context 'When string is not Camel Case,' do
839
- let!(:string) { 'thisisword' }
840
- it { is_expected.to eq ['thisisword'] }
841
- end
842
- end
843
-
844
-
845
- # ----------------------------------------------------------------------------
846
- # Check is_upper?
847
- # ----------------------------------------------------------------------------
848
- describe 'CHECK is_upper?' do
849
- let(:character) { nil }
850
- subject { character.is_upper? }
851
-
852
- context 'when a character is upper case,' do
853
- let(:character) { 'C' }
854
- it { is_expected.to eq true }
855
- end
856
-
857
- context 'when a character is lower case,' do
858
- let(:character) { 'c' }
859
- it { is_expected.to eq false }
860
- end
861
- end
862
-
863
-
864
- # ----------------------------------------------------------------------------
865
- # Check is_lower?
866
- # ----------------------------------------------------------------------------
867
- describe 'CHECK is_lower?' do
868
- let(:character) { nil }
869
- subject { character.is_lower? }
870
-
871
- context 'when a character is lower case,' do
872
- let(:character) { 'c' }
873
- it { is_expected.to eq true }
836
+ context "When string is Lower Camel Case," do
837
+ let!(:string) { "thisIsWord" }
838
+ it { is_expected.to eq(["this", "Is", "Word"]) }
874
839
  end
875
840
 
876
- context 'when a character is uppser case,' do
877
- let(:character) { 'C' }
878
- it { is_expected.to eq false }
841
+ context "When string is not Camel Case," do
842
+ let!(:string) { "thisisword" }
843
+ it { is_expected.to eq(["thisisword"]) }
879
844
  end
880
845
  end
881
846
 
882
847
 
883
848
  # ----------------------------------------------------------------------------
884
- # Make first character lower case
849
+ # Make First Character Lower Case
885
850
  # ----------------------------------------------------------------------------
886
- describe 'MAKE FIRST CHARACTER LOWER CASE' do
851
+ describe "MAKE FIRST CHARACTER LOWER CASE ::" do
887
852
  let(:string) { nil }
888
- subject { string.make_head_lower }
853
+ subject { string.instance_eval { make_head_lower } }
889
854
 
890
- context 'When first character is Upper Case,' do
891
- let(:string) { 'ThisIsString' }
892
- it { is_expected.to eq 'thisIsString' }
855
+ context "When first character is Upper Case," do
856
+ let(:string) { "ThisIsString" }
857
+ it { is_expected.to eq("thisIsString") }
893
858
  end
894
859
 
895
- context 'When first character is Lower Case,' do
896
- let(:string) { 'thisIsString' }
897
- it { is_expected.to eq 'thisIsString' }
860
+ context "When first character is Lower Case," do
861
+ let(:string) { "thisIsString" }
862
+ it { is_expected.to eq("thisIsString") }
898
863
  end
899
864
  end
900
865