Class: ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable

Inherits:
Base
  • Object
show all
Defined in:
lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb

Direct Known Subclasses

Array, Enumerator, Hash, Set

Instance Attribute Summary

Attributes inherited from Base

#modifiers, #object, #organizer, #propagated_result

Instance Method Summary collapse

Methods inherited from Base

#evaluate_by, #initialize, #result

Methods included from ConvenientService::Support::AbstractMethod

abstract_method

Instance Method Details

#all?(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #all?(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



69
70
71
72
73
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 69

def all?(*args, &iteration_block)
  with_processing_return_value_as_boolean(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.all?(*args, &step_aware_iteration_block)
  end
end

#any?(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #any?(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



86
87
88
89
90
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 86

def any?(*args, &iteration_block)
  with_processing_return_value_as_boolean(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.any?(*args, &step_aware_iteration_block)
  end
end

#chain(*enums) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



98
99
100
101
102
103
104
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 98

def chain(*enums)
  casted_enums = enums.map { |collection| cast_step_aware_enumerable(collection) }.map(&:enumerable)

  with_processing_return_value_as_chain_enumerator(arguments(*casted_enums)) do |*enums|
    enumerable.chain(*enums)
  end
end

#chunk(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc)

Returns:



112
113
114
115
116
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 112

def chunk(&iteration_block)
  with_processing_return_value_as_enumerator_generator(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.chunk(&step_aware_iteration_block)
  end
end

#chunk_while(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc)

Returns:



124
125
126
127
128
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 124

def chunk_while(&iteration_block)
  with_processing_return_value_as_enumerator_generator(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.chunk_while(&step_aware_iteration_block)
  end
end

#collect(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 136

def collect(&iteration_block)
  if iteration_block
    with_processing_return_value_as_array(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.collect(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.collect
    end
  end
end

#collect_concat(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 154

def collect_concat(&iteration_block)
  if iteration_block
    with_processing_return_value_as_array(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.collect_concat(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(&iteration_block)) do
      enumerable.collect_concat
    end
  end
end

#compact ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Returns:



172
173
174
175
176
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 172

def compact
  with_processing_return_value_as_enumerable do
    enumerable.compact
  end
end

#count ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #count(item) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #count(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



193
194
195
196
197
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 193

def count(*args, &iteration_block)
  with_processing_return_value_as_object(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.count(*args, &step_aware_iteration_block)
  end
end

#cycle(n = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 206

def cycle(n = nil, &iteration_block)
  if iteration_block
    with_processing_return_value_as_object(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
      enumerable.cycle(n, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(n)) do |n|
      enumerable.cycle(n)
    end
  end
end

#default_data_key ⇒ Symbol

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Symbol) 


27
28
29
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 27

def default_data_key
  :values
end

#default_evaluate_by ⇒ nil

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (nil) 


36
37
38
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 36

def default_evaluate_by
  enumerable.is_a?(::Enumerator) ? :to_a : nil
end

#detect(ifnone = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • ifnone (Proc, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 225

def detect(ifnone = nil, &iteration_block)
  if iteration_block
    with_processing_return_value_as_object_or_nil(arguments(ifnone, &iteration_block)) do |ifnone, &step_aware_iteration_block|
      enumerable.detect(ifnone, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(ifnone)) do |ifnone|
      enumerable.detect(ifnone)
    end
  end
end

#drop(n) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer)

Returns:



243
244
245
246
247
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 243

def drop(n)
  with_processing_return_value_as_enumerable(arguments(n)) do |n|
    enumerable.drop(n)
  end
end

#drop_while(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 255

def drop_while(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.drop_while(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.drop_while
    end
  end
end

#each(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable

Parameters:

  • iteration_block (Proc, nil)

Returns:



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 46

def each(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.each(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.each
    end
  end
end

#each_cons(n, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer)
  • iteration_block (Proc, nil)

Returns:



274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 274

def each_cons(n, &iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
      enumerable.each_cons(n, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(n)) do |n|
      enumerable.each_cons(n)
    end
  end
end

#each_entry(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 292

def each_entry(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.each_entry(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.each_entry
    end
  end
end

#each_slice(n, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer)
  • iteration_block (Proc, nil)

Returns:



311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 311

def each_slice(n, &iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
      enumerable.each_slice(n, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(n)) do |n|
      enumerable.each_slice(n)
    end
  end
end

#each_with_index(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 329

def each_with_index(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.each_with_index(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.each_with_index
    end
  end
end

#each_with_object(obj, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • obj (Object) —

    Can be any type.

  • iteration_block (Proc, nil)

Returns:



348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 348

def each_with_object(obj, &iteration_block)
  if iteration_block
    with_processing_return_value_as_object(arguments(obj, &iteration_block)) do |obj, &step_aware_iteration_block|
      enumerable.each_with_object(obj, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(obj)) do |obj|
      enumerable.each_with_object(obj)
    end
  end
end

#entries ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Returns:



365
366
367
368
369
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 365

def entries
  with_processing_return_value_as_enumerable do
    enumerable.entries
  end
end

#filter(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 377

def filter(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.filter(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.filter
    end
  end
end

#filter_map(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



395
396
397
398
399
400
401
402
403
404
405
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 395

def filter_map(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.filter_map(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.filter_map
    end
  end
end

#find(ifnone = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • ifnone (Proc, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



414
415
416
417
418
419
420
421
422
423
424
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 414

def find(ifnone = nil, &iteration_block)
  if iteration_block
    with_processing_return_value_as_object_or_nil(arguments(ifnone, &iteration_block)) do |ifnone, &step_aware_iteration_block|
      enumerable.find(ifnone, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(ifnone)) do |ifnone|
      enumerable.find(ifnone)
    end
  end
end

#find_all(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



432
433
434
435
436
437
438
439
440
441
442
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 432

def find_all(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.find_all(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(&iteration_block)) do
      enumerable.find_all
    end
  end
end

#find_index(*args, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



451
452
453
454
455
456
457
458
459
460
461
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 451

def find_index(*args, &iteration_block)
  if iteration_block || args.any?
    with_processing_return_value_as_object_or_nil(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
      enumerable.find_index(*args, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.find_index
    end
  end
end

#first(n = nil) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)

Returns:



469
470
471
472
473
474
475
476
477
478
479
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 469

def first(n = nil)
  if n
    with_processing_return_value_as_enumerable(arguments(n)) do |n|
      enumerable.first(n)
    end
  else
    with_processing_return_value_as_object_or_nil do
      enumerable.first
    end
  end
end

#flat_map(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 487

def flat_map(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.flat_map(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator(arguments(&iteration_block)) do
      enumerable.flat_map
    end
  end
end

#grep(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #grep(pattern, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



511
512
513
514
515
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 511

def grep(*args, &iteration_block)
  with_processing_return_value_as_enumerable(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.grep(*args, &step_aware_iteration_block)
  end
end

#grep_v(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #grep_v(pattern, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



529
530
531
532
533
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 529

def grep_v(*args, &iteration_block)
  with_processing_return_value_as_enumerable(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.grep_v(*args, &step_aware_iteration_block)
  end
end

#group_by(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



541
542
543
544
545
546
547
548
549
550
551
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 541

def group_by(&iteration_block)
  if iteration_block
    with_processing_return_value_as_hash(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.group_by(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.group_by
    end
  end
end

#include?(obj) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • obj (Object) —

    Can be any type.

Returns:



559
560
561
562
563
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 559

def include?(obj)
  with_processing_return_value_as_boolean(arguments(obj)) do |obj|
    enumerable.include?(obj)
  end
end

#inject(*args, **kwargs, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



573
574
575
576
577
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 573

def inject(*args, &iteration_block)
  with_processing_return_value_as_object(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.inject(*args, &step_aware_iteration_block)
  end
end

#lazy ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Returns:



599
600
601
602
603
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 599

def lazy
  with_processing_return_value_as_lazy_enumerator do
    enumerable.lazy
  end
end

#map(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



611
612
613
614
615
616
617
618
619
620
621
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 611

def map(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.map(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.map
    end
  end
end

#max(n = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



630
631
632
633
634
635
636
637
638
639
640
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 630

def max(n = nil, &iteration_block)
  if n
    with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
      enumerable.max(n, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_object_or_nil(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.max(&step_aware_iteration_block)
    end
  end
end

#max_by(n = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 649

def max_by(n = nil, &iteration_block)
  if iteration_block
    if n
      with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
        enumerable.max_by(n, &step_aware_iteration_block)
      end
    else
      with_processing_return_value_as_object_or_nil(arguments(&iteration_block)) do |&step_aware_iteration_block|
        enumerable.max_by(&step_aware_iteration_block)
      end
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.max_by
    end
  end
end

#member?(obj) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • obj (Object) —

    Can be any type.

Returns:



673
674
675
676
677
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 673

def member?(obj)
  with_processing_return_value_as_boolean(arguments(obj)) do |obj|
    enumerable.member?(obj)
  end
end

#min(n = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



686
687
688
689
690
691
692
693
694
695
696
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 686

def min(n = nil, &iteration_block)
  if n
    with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
      enumerable.min(n, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_object_or_nil(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.min(&step_aware_iteration_block)
    end
  end
end

#min_by(n = nil, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil) (defaults to: nil)
  • iteration_block (Proc, nil)

Returns:



705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 705

def min_by(n = nil, &iteration_block)
  if iteration_block
    if n
      with_processing_return_value_as_enumerable(arguments(n, &iteration_block)) do |n, &step_aware_iteration_block|
        enumerable.min_by(n, &step_aware_iteration_block)
      end
    else
      with_processing_return_value_as_object_or_nil(arguments(&iteration_block)) do |&step_aware_iteration_block|
        enumerable.min_by(&step_aware_iteration_block)
      end
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.min_by
    end
  end
end

#minmax(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



729
730
731
732
733
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 729

def minmax(&iteration_block)
  with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.minmax(&step_aware_iteration_block)
  end
end

#minmax_by(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



741
742
743
744
745
746
747
748
749
750
751
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 741

def minmax_by(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.minmax_by(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.minmax_by
    end
  end
end

#none?(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #none?(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



764
765
766
767
768
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 764

def none?(*args, &iteration_block)
  with_processing_return_value_as_boolean(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.none?(*args, &step_aware_iteration_block)
  end
end

#one?(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #one?(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



781
782
783
784
785
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 781

def one?(*args, &iteration_block)
  with_processing_return_value_as_boolean(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.one?(*args, &step_aware_iteration_block)
  end
end

#partition(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



793
794
795
796
797
798
799
800
801
802
803
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 793

def partition(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.partition(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.partition
    end
  end
end

#reduce(*args, **kwargs, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



813
814
815
816
817
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 813

def reduce(*args, &iteration_block)
  with_processing_return_value_as_object(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.reduce(*args, &step_aware_iteration_block)
  end
end

#reject(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



840
841
842
843
844
845
846
847
848
849
850
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 840

def reject(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.reject(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.reject
    end
  end
end

#reverse_each(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



858
859
860
861
862
863
864
865
866
867
868
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 858

def reverse_each(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.reverse_each(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.reverse_each
    end
  end
end

#select(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



876
877
878
879
880
881
882
883
884
885
886
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 876

def select(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.select(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.select
    end
  end
end

#select_exactly(n, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerable, ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Enumerator

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • n (Integer)
  • iteration_block (Proc, nil)

Returns:



1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1115

def select_exactly(n, &iteration_block)
  if iteration_block
    with_processing_return_value_as_exactly_enumerable(n, arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.select(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_exactly_enumerator(n) do |n|
      to_enum(:_select_exactly, n)
    end
  end
end

#slice_after(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #slice_after(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



899
900
901
902
903
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 899

def slice_after(*args, &iteration_block)
  with_processing_return_value_as_enumerator_generator(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.slice_after(*args, &step_aware_iteration_block)
  end
end

#slice_before(pattern) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #slice_before(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



916
917
918
919
920
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 916

def slice_before(*args, &iteration_block)
  with_processing_return_value_as_enumerator_generator(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.slice_before(*args, &step_aware_iteration_block)
  end
end

#slice_when(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc)

Returns:



928
929
930
931
932
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 928

def slice_when(&iteration_block)
  with_processing_return_value_as_enumerator_generator(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.slice_when(&step_aware_iteration_block)
  end
end

#sort(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



940
941
942
943
944
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 940

def sort(&iteration_block)
  with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.sort(&step_aware_iteration_block)
  end
end

#sort_by(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



952
953
954
955
956
957
958
959
960
961
962
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 952

def sort_by(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.sort_by(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.sort_by
    end
  end
end

#sum ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #sum(init) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #sum(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base #sum(init, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Overloads:



983
984
985
986
987
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 983

def sum(init = 0, &iteration_block)
  with_processing_return_value_as_object(arguments(init, &iteration_block)) do |init, &step_aware_iteration_block|
    enumerable.sum(init, &step_aware_iteration_block)
  end
end

#take(n) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • n (Integer, nil)

Returns:



995
996
997
998
999
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 995

def take(n)
  with_processing_return_value_as_enumerable(arguments(n)) do |n|
    enumerable.take(n)
  end
end

#take_while(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1007

def take_while(&iteration_block)
  if iteration_block
    with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
      enumerable.take_while(&step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerator do
      enumerable.take_while
    end
  end
end

#tally ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Returns:



1024
1025
1026
1027
1028
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1024

def tally
  with_processing_return_value_as_hash do
    enumerable.tally
  end
end

#to_a(*args, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



1040
1041
1042
1043
1044
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1040

def to_a(*args, &iteration_block)
  with_processing_return_value_as_array(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.to_a(*args, &step_aware_iteration_block)
  end
end

#to_h(*args, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



1056
1057
1058
1059
1060
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1056

def to_h(*args, &iteration_block)
  with_processing_return_value_as_hash(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.to_h(*args, &step_aware_iteration_block)
  end
end

#to_set(*args, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

Returns:



1069
1070
1071
1072
1073
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1069

def to_set(*args, &iteration_block)
  with_processing_return_value_as_set(arguments(*args, &iteration_block)) do |*args, &step_aware_iteration_block|
    enumerable.to_set(*args, &step_aware_iteration_block)
  end
end

#uniq(&iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • iteration_block (Proc, nil)

Returns:



1081
1082
1083
1084
1085
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1081

def uniq(&iteration_block)
  with_processing_return_value_as_enumerable(arguments(&iteration_block)) do |&step_aware_iteration_block|
    enumerable.uniq(&step_aware_iteration_block)
  end
end

#zip(*other_enums, &iteration_block) ⇒ ConvenientService::Service::Plugins::CanHaveStepAwareEnumerables::Entities::StepAwareEnumerables::Base

Parameters:

  • other_enums (Array<Object>)
  • iteration_block (Proc, nil)

Returns:



1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
 
# File 'lib/convenient_service/service/plugins/can_have_step_aware_enumerables/entities/step_aware_enumerables/enumerable.rb', line 1094

def zip(*other_enums, &iteration_block)
  casted_other_enums = other_enums.map { |collection| cast_step_aware_enumerable(collection) }.map(&:enumerable)

  if iteration_block
    with_processing_return_value_as_object(arguments(*casted_other_enums, &iteration_block)) do |*other_enums, &step_aware_iteration_block|
      enumerable.zip(*other_enums, &step_aware_iteration_block)
    end
  else
    with_processing_return_value_as_enumerable(arguments(*casted_other_enums)) do |*other_enums|
      enumerable.zip(*other_enums)
    end
  end
end