Module: Ace::Assign::Atoms::NumberGenerator

Defined in:
lib/ace/assign/atoms/number_generator.rb

Overview

Pure functions for generating step numbers.

Follows the numbering convention:

  • Main steps: 010, 020, 030 (10-step gaps for injection room)

  • Sub-steps: 010.01, 010.02 (2-digit padding)

  • Sub-sub-steps: 010.01.01 (3 levels max)

  • Dynamic injection: 041 after 040

Constant Summary collapse

DEFAULT_INCREMENT =

Default increment between main steps

10
DEFAULT_START =

Default starting number

10

Class Method Summary collapse

Class Method Details

.from_index(index, increment: DEFAULT_INCREMENT) ⇒ String

Format a number from index (0-based) to step number

Parameters:

  • index (Integer) —

    Zero-based index

  • increment (Integer) (defaults to: DEFAULT_INCREMENT) —

    Step increment

Returns:

  • (String) —

    Step number



104
105
106
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 104

def self.from_index(index, increment: DEFAULT_INCREMENT)
  format("%03d", (index + 1) * increment)
end

.next_after(base, existing = []) ⇒ String

Generate the next number after a given step (for dynamic injection)

Parameters:

  • base (String) —

    Base step number (e.g., “040”)

  • existing (Array<String>) (defaults to: []) —

    Existing step numbers

Returns:

  • (String) —

    Next available number (e.g., “041”)



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 42

def self.next_after(base, existing = [])
  # Extract main part
  main_part = base.split(".").first.to_i

  # Find existing numbers in the range base+1 to base+9
  range_numbers = existing.map { |n| n.split(".").first.to_i }
    .select { |n| n > main_part && n < main_part + 10 }

  # Find next available
  next_num = main_part + 1
  while range_numbers.include?(next_num)
    next_num += 1
  end

  format("%03d", next_num)
end

.next_main(last, increment: DEFAULT_INCREMENT) ⇒ String

Generate the next main step number

Parameters:

  • last (String, nil) —

    Last main step number (e.g., “040”)

  • increment (Integer) (defaults to: DEFAULT_INCREMENT) —

    Step increment (default: 10)

Returns:

  • (String) —

    Next main step number (e.g., “050”)



25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 25

def self.next_main(last, increment: DEFAULT_INCREMENT)
  return format("%03d", DEFAULT_START) if last.nil?

  # Extract the main number (before any dots)
  main_part = last.split(".").first
  current = main_part.to_i

  # Round up to next increment
  next_num = ((current / increment) + 1) * increment
  format("%03d", next_num)
end

.parse(number) ⇒ Hash

Parse a step number into its components

Parameters:

  • number (String) —

    Step number (e.g., “030.01.02”)

Returns:

  • (Hash) —

    Parsed components



81
82
83
84
85
86
87
88
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 81

def self.parse(number)
  parts = number.split(".").map(&:to_i)
  {
    main: parts.first,
    parts: parts,
    depth: parts.size
  }
end

.sub_subtask(parent, sequence) ⇒ String

Generate a sub-sub-step number

Parameters:

  • parent (String) —

    Parent sub-step number (e.g., “030.01”)

  • sequence (Integer) —

    Sub-sub-step sequence

Returns:

  • (String) —

    Sub-sub-step number (e.g., “030.01.01”)



73
74
75
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 73

def self.sub_subtask(parent, sequence)
  "#{parent}.#{format("%02d", sequence)}"
end

.subtask(parent, sequence) ⇒ String

Generate a sub-step number

Parameters:

  • parent (String) —

    Parent step number (e.g., “030”)

  • sequence (Integer) —

    Sub-step sequence (1, 2, 3…)

Returns:

  • (String) —

    Sub-step number (e.g., “030.01”)



64
65
66
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 64

def self.subtask(parent, sequence)
  "#{parent}.#{format("%02d", sequence)}"
end

.subtask_of?(number, parent) ⇒ Boolean

Check if a number is a sub-step of another

Parameters:

  • number (String) —

    Step number to check

  • parent (String) —

    Potential parent number

Returns:

  • (Boolean) —

    True if number is a sub-step of parent



95
96
97
 
# File 'lib/ace/assign/atoms/number_generator.rb', line 95

def self.subtask_of?(number, parent)
  number.start_with?("#{parent}.")
end