test_ids 1.2.3 → 1.2.4

data/lib/test_ids/allocator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 module TestIds
   # The allocator is responsible for assigning new numbers and keeping a record of
@@ -54,7 +56,7 @@ module TestIds
         rangehash = {}
       else
         rangehash = store['pointers']['ranges']
-        rangehash = Hash[rangehash.map { |k, v| [k.to_sym, v] }]
+        rangehash = rangehash.transform_keys(&:to_sym)
       end
       orig_options = options.dup
       # Check the database to see if the passed in range has already been included in the database hash
@@ -70,18 +72,15 @@ module TestIds
         # and new value is assigned to the softbin.
         if previous_assigned_value == range[@pointer]
           @pointer += options[:size]
-          assigned_value = range[@pointer]
-        else
-          # Because of the pointer calculations above, I don't think it will ever reach here, has not in my test cases so far!
-          assigned_value = range[@pointer]
         end
+        assigned_value = range[@pointer]
         # Now update the database pointers to point to the lastest assigned softbin for a given range.
-        rangehash.merge!(:"#{range_definition}" => "#{range[@pointer]}")
+        rangehash.merge!("#{range_definition}": (range[@pointer]).to_s)
       else
         # This is the case for a brand new range that has not been passed before
         # We start from the first value as the assigned softbin and update the database to reflect.
         @pointer = 0
-        rangehash.merge!(:"#{range_definition}" => "#{range[@pointer]}")
+        rangehash.merge!("#{range_definition}": (range[@pointer]).to_s)
         assigned_value = range[@pointer]
       end
       unless !assigned_value.nil? && range.include?(assigned_value)
@@ -148,7 +147,7 @@ module TestIds
       nones = []
 
       # Record any :nones that are present for later
-      [:bin, :softbin, :number].each do |type|
+      %i(bin softbin number).each do |type|
         nones << type if options[type] == :none
         config(type).allocator.instance_variable_set('@needs_regenerated', {})
       end
@@ -176,9 +175,12 @@ module TestIds
       store['assigned']['bins'] = store['assigned']['bins'].merge(other_store['assigned']['bins'])
       store['assigned']['softbins'] = store['assigned']['softbins'].merge(other_store['assigned']['softbins'])
       store['assigned']['numbers'] = store['assigned']['numbers'].merge(other_store['assigned']['numbers'])
-      store['manually_assigned']['bins'] = store['manually_assigned']['bins'].merge(other_store['manually_assigned']['bins'])
-      store['manually_assigned']['softbins'] = store['manually_assigned']['softbins'].merge(other_store['manually_assigned']['softbins'])
-      store['manually_assigned']['numbers'] = store['manually_assigned']['numbers'].merge(other_store['manually_assigned']['numbers'])
+      store['manually_assigned']['bins'] =
+        store['manually_assigned']['bins'].merge(other_store['manually_assigned']['bins'])
+      store['manually_assigned']['softbins'] =
+        store['manually_assigned']['softbins'].merge(other_store['manually_assigned']['softbins'])
+      store['manually_assigned']['numbers'] =
+        store['manually_assigned']['numbers'].merge(other_store['manually_assigned']['numbers'])
       store['references']['bins'] = store['references']['bins'].merge(other_store['references']['bins'])
       store['references']['softbins'] = store['references']['softbins'].merge(other_store['references']['softbins'])
       store['references']['numbers'] = store['references']['numbers'].merge(other_store['references']['numbers'])
@@ -189,8 +191,8 @@ module TestIds
         if file && File.exist?(file)
           lines = File.readlines(file)
           # Remove any header comment lines since these are not valid JSON
-          lines.shift while lines.first =~ /^\/\// && !lines.empty?
-          s = JSON.load(lines.join("\n"))
+          lines.shift while lines.first =~ %r{^//} && !lines.empty?
+          s = JSON.parse(lines.join("\n"))
         end
         if s
           unless s['format_revision']
@@ -215,10 +217,14 @@ module TestIds
             s = {
               'format_revision'   => 2,
               'configuration'     => nil,
-              'pointers'          => { 'bins' => s['pointers']['bin'], 'softbins' => s['pointers']['softbin'], 'numbers' => s['pointers']['number'] },
-              'assigned'          => { 'bins' => s['assigned']['bin'], 'softbins' => s['assigned']['softbin'], 'numbers' => s['assigned']['number'] },
-              'manually_assigned' => { 'bins' => s['manually_assigned']['bin'], 'softbins' => s['manually_assigned']['softbin'], 'numbers' => s['manually_assigned']['number'] },
-              'references'        => { 'bins' => s['references']['bin'], 'softbins' => s['references']['softbin'], 'numbers' => s['references']['number'] }
+              'pointers'          => { 'bins' => s['pointers']['bin'], 'softbins' => s['pointers']['softbin'],
+                              'numbers' => s['pointers']['number'] },
+              'assigned'          => { 'bins' => s['assigned']['bin'], 'softbins' => s['assigned']['softbin'],
+                              'numbers' => s['assigned']['number'] },
+              'manually_assigned' => { 'bins' => s['manually_assigned']['bin'],
+                                       'softbins' => s['manually_assigned']['softbin'], 'numbers' => s['manually_assigned']['number'] },
+              'references'        => { 'bins' => s['references']['bin'], 'softbins' => s['references']['softbin'],
+                                'numbers' => s['references']['number'] }
             }
           end
 
@@ -239,20 +245,22 @@ module TestIds
       end
     end
 
-    def repair(options = {})
+    # disable lint check combination loop as we prefer how the output looks like
+    # rubocop:disable Style/CombinableLoops
+    def repair(_options = {})
       #####################################################################
       # Add any numbers that are missing from the references pool if the
       # allocator has moved onto the reclamation phase
       #####################################################################
       { 'bins' => 'bins', 'softbins' => 'softbins', 'numbers' => 'test_numbers' }.each do |type, name|
-        if !config.send(type).function? && store['pointers'][type] == 'done'
-          Origen.log.info "Checking for missing #{name}..."
-          recovered = add_missing_references(config.send, store['references'][type])
-          if recovered == 0
-            Origen.log.info "  All #{name} are already available."
-          else
-            Origen.log.success "  Another #{recovered} #{name} have been made available!"
-          end
+        next unless !config.send(type).function? && store['pointers'][type] == 'done'
+
+        Origen.log.info "Checking for missing #{name}..."
+        recovered = add_missing_references(config.send, store['references'][type])
+        if recovered.zero?
+          Origen.log.info "  All #{name} are already available."
+        else
+          Origen.log.success "  Another #{recovered} #{name} have been made available!"
         end
       end
 
@@ -262,6 +270,7 @@ module TestIds
       #####################################################################
       { 'bins' => 'bins', 'softbins' => 'softbins', 'numbers' => 'test_numbers' }.each do |type, name|
         next if config.send(type).function?
+
         Origen.log.info "Checking all #{name} assignments are valid..."
         also_remove_from = []
         if type == 'bin'
@@ -269,11 +278,12 @@ module TestIds
           also_remove_from << store['assigned']['numbers'] if config.numbers.function?
         elsif type == 'softbin'
           also_remove_from << store['assigned']['numbers'] if config.numbers.function?
-        else
-          also_remove_from << store['assigned']['softbins'] if config.softbins.function?
+        elsif config.softbins.function?
+          also_remove_from << store['assigned']['softbins']
         end
-        removed = remove_invalid_assignments(config.send(type), store['assigned'][type], store['manually_assigned'][type], also_remove_from)
-        if removed == 0
+        removed = remove_invalid_assignments(config.send(type), store['assigned'][type],
+                                             store['manually_assigned'][type], also_remove_from)
+        if removed.zero?
           Origen.log.info "  All #{name} assignments are already valid."
         else
           Origen.log.success "  #{removed} #{name} assignments have been removed!"
@@ -286,15 +296,18 @@ module TestIds
       #####################################################################
       { 'bins' => 'bins', 'softbins' => 'softbins', 'numbers' => 'test_numbers' }.each do |type, name|
         next if config.send(type).function?
+
         Origen.log.info "Checking all #{name} references are valid..."
-        removed = remove_invalid_references(config.send(type), store['references'][type], store['manually_assigned'][type])
-        if removed == 0
+        removed = remove_invalid_references(config.send(type), store['references'][type],
+                                            store['manually_assigned'][type])
+        if removed.zero?
           Origen.log.info "  All #{name} references are already valid."
         else
           Origen.log.success "  #{removed} #{name} references have been removed!"
         end
       end
     end
+    # rubocop:enable Style/CombinableLoops
 
     # Clear the :bins, :softbins and/or :numbers and/or :ranges by setting the options for each item
     def clear(options)
@@ -316,49 +329,49 @@ module TestIds
         store['pointers']['numbers'] = nil
         store['references']['numbers'] = {}
       end
-      if options[:range] || options[:ranges]
-        store['pointers']['ranges'] = nil
-      end
+      return unless options[:range] || options[:ranges]
+
+      store['pointers']['ranges'] = nil
     end
 
     # Saves the current allocator state to the repository
     def save
-      if file
-        # Ensure the current store has been loaded before we try to re-write it, this
-        # is necessary if the program generator has crashed before creating a test
-        store
-        store['configuration'] = config
-        p = Pathname.new(file)
-        FileUtils.mkdir_p(p.dirname)
-        File.open(p, 'w') do |f|
-          f.puts '// The structure of this file is as follows:'
-          f.puts '//'
-          f.puts '//  {'
-          f.puts '//    // A revision number used by TestIDs to identify the format of this file'
-          f.puts "//    'format_revision'   => STORE_FORMAT_REVISION,"
-          f.puts '//'
-          f.puts '//    // Captures the configuration that was used the last time this database was updated.'
-          f.puts "//    'configuration'          => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
-          f.puts '//'
-          f.puts '//    // If some number are still to be allocated, these point to the last number given out.'
-          f.puts '//    // If all numbers have been allocated and we are now on the reclamation phase, the pointer'
-          f.puts '//    // will contain "done".'
-          f.puts "//    'pointers'          => { 'bins' => nil, 'softbins' => nil, 'numbers' => nil, 'ranges' => nil },"
-          f.puts '//'
-          f.puts '//    // This is the record of all numbers which have been previously assigned.'
-          f.puts "//    'assigned'          => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
-          f.puts '//'
-          f.puts '//    // This is a record of any numbers which have been manually assigned.'
-          f.puts "//    'manually_assigned' => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
-          f.puts '//'
-          f.puts '//    // This contains all assigned numbers with a timestamp of when they were last referenced.'
-          f.puts '//    // When numbers need to be reclaimed, they will be taken from the bottom of this list, i.e.'
-          f.puts '//    // the numbers which have not been used for the longest time, e.g. because the test they'
-          f.puts '//    // were assigned to has since been removed.'
-          f.puts "//    'references'        => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} }"
-          f.puts '//  }'
-          f.puts JSON.pretty_generate(store)
-        end
+      return unless file
+
+      # Ensure the current store has been loaded before we try to re-write it, this
+      # is necessary if the program generator has crashed before creating a test
+      store
+      store['configuration'] = config
+      p = Pathname.new(file)
+      FileUtils.mkdir_p(p.dirname)
+      File.open(p, 'w') do |f|
+        f.puts '// The structure of this file is as follows:'
+        f.puts '//'
+        f.puts '//  {'
+        f.puts '//    // A revision number used by TestIDs to identify the format of this file'
+        f.puts "//    'format_revision'   => STORE_FORMAT_REVISION,"
+        f.puts '//'
+        f.puts '//    // Captures the configuration that was used the last time this database was updated.'
+        f.puts "//    'configuration'          => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
+        f.puts '//'
+        f.puts '//    // If some number are still to be allocated, these point to the last number given out.'
+        f.puts '//    // If all numbers have been allocated and we are now on the reclamation phase, the pointer'
+        f.puts '//    // will contain "done".'
+        f.puts "//    'pointers'          => { 'bins' => nil, 'softbins' => nil, 'numbers' => nil, 'ranges' => nil },"
+        f.puts '//'
+        f.puts '//    // This is the record of all numbers which have been previously assigned.'
+        f.puts "//    'assigned'          => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
+        f.puts '//'
+        f.puts '//    // This is a record of any numbers which have been manually assigned.'
+        f.puts "//    'manually_assigned' => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} },"
+        f.puts '//'
+        f.puts '//    // This contains all assigned numbers with a timestamp of when they were last referenced.'
+        f.puts '//    // When numbers need to be reclaimed, they will be taken from the bottom of this list, i.e.'
+        f.puts '//    // the numbers which have not been used for the longest time, e.g. because the test they'
+        f.puts '//    // were assigned to has since been removed.'
+        f.puts "//    'references'        => { 'bins' => {}, 'softbins' => {}, 'numbers' => {} }"
+        f.puts '//  }'
+        f.puts JSON.pretty_generate(store)
       end
     end
 
@@ -385,11 +398,11 @@ module TestIds
 
       # First work out the test ID to be used for each of the numbers, and how many numbers
       # should be reserved
-      if (options[type].is_a?(Symbol) || options[type].is_a?(String)) && options[type] != :none
-        id = options[type].to_s
-      else
-        id = name
-      end
+      id = if (options[type].is_a?(Symbol) || options[type].is_a?(String)) && options[type] != :none
+             options[type].to_s
+           else
+             name
+           end
       id = "#{id}_#{options[:index]}" if options[:index]
       id = "#{id}_#{options[:test_ids_flow_id]}" if config.unique_by_flow?
 
@@ -400,25 +413,21 @@ module TestIds
           store['manually_assigned']["#{type}s"][options[type].to_s] = true
           val['number'] = options[type]
         end
-      else
+      elsif @needs_regenerated[type]
         # Will be set if an upstream dependent type has been marked for regeneration by the code below
-        if @needs_regenerated[type]
-          val['number'] = nil
-          val['size'] = nil
+        val['number'] = nil
+        val['size'] = nil
         # Regenerate the number if the original allocation has since been applied manually elsewhere
-        elsif store['manually_assigned'][type_plural][val['number'].to_s]
-          val['number'] = nil
-          val['size'] = nil
-          # Also regenerate these as they could be a function of the number we just invalidated
-          ([:bin, :softbin, :number] - [type]).each do |t|
-            if config.send("#{t}s").needs?(type)
-              @needs_regenerated[t] = true
-            end
-          end
+      elsif store['manually_assigned'][type_plural][val['number'].to_s]
+        val['number'] = nil
+        val['size'] = nil
+        # Also regenerate these as they could be a function of the number we just invalidated
+        (%i(bin softbin number) - [type]).each do |t|
+          @needs_regenerated[t] = true if config.send("#{t}s").needs?(type)
         end
       end
 
-      if size = options["#{type}_size".to_sym]
+      if (size = options["#{type}_size".to_sym])
         val['size'] = size
       end
 
@@ -433,6 +442,8 @@ module TestIds
       end
 
       # Update the supplied options hash that will be forwarded to the program generator
+      return if type == :bin && options[:bin].is_a?(String)
+
       options[type] = val['number']
       options["#{type}_size".to_sym] = val['size']
     end
@@ -447,7 +458,7 @@ module TestIds
 
     def remove_invalid_references(config_item, references, manually_assigned)
       removed = 0
-      references.each do |num, time|
+      references.each do |num, _time|
         unless config_item.valid?(num.to_i) || manually_assigned[num]
           removed += 1
           references.delete(num)
@@ -460,12 +471,12 @@ module TestIds
       removed = 0
       assigned.each do |id, a|
         a['size'].times do |i|
-          unless config_item.valid?(a['number'] + i) || manually_assigned[(a['number'] + i).to_s]
-            removed += 1
-            assigned.delete(id)
-            also_remove_from.each { |a| a.delete(id) }
-            break
-          end
+          next if config_item.valid?(a['number'] + i) || manually_assigned[(a['number'] + i).to_s]
+
+          removed += 1
+          assigned.delete(id)
+          also_remove_from.each { |a| a.delete(id) }
+          break
         end
       end
       removed
@@ -489,74 +500,70 @@ module TestIds
       conf = config.send(type_plural)
       if conf.algorithm
         algo = conf.algorithm.to_s.downcase
-        if algo.to_s =~ /^[bsn\dx]+$/
-          number = algo.to_s
-          ([:bin, :softbin, :number] - [type]).each do |t|
-            if number =~ /(#{t.to_s[0]}+)/
-              max_size = Regexp.last_match(1).size
-              num = options[t].to_s
-              if num.size > max_size
-                fail "The allocated number, #{num}, overflows the #{t} field in the #{type} algorithm - #{algo}"
-              end
-              number = number.sub(/#{t.to_s[0]}+/, num.rjust(max_size, '0'))
-            end
+        fail "Illegal algorithm: #{algo}" unless algo.to_s =~ /^[bsn\dx]+$/
+
+        number = algo.to_s
+        (%i(bin softbin number) - [type]).each do |t|
+          next unless number =~ /(#{t.to_s[0]}+)/
+
+          max_size = Regexp.last_match(1).size
+          num = options[t].to_s
+          if num.size > max_size
+            fail "The allocated number, #{num}, overflows the #{t} field in the #{type} algorithm - #{algo}"
           end
 
-          if number =~ /(x+)/
-            max_counter_size = Regexp.last_match(1).size
-            refs = store['references'][type_plural]
-            i = 0
-            possible = []
+          number = number.sub(/#{t.to_s[0]}+/, num.rjust(max_size, '0'))
+        end
+
+        if number =~ /(x+)/
+          max_counter_size = Regexp.last_match(1).size
+          refs = store['references'][type_plural]
+          i = 0
+          possible = []
+          proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0')).to_i.to_s
+          possible << proposal
+          while refs[proposal] && i.to_s.size <= max_counter_size
+            i += 1
             proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0')).to_i.to_s
             possible << proposal
-            while refs[proposal] && i.to_s.size <= max_counter_size
-              i += 1
-              proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0')).to_i.to_s
-              possible << proposal
-            end
-            # Overflowed, need to go search for the oldest duplicate now
-            if i.to_s.size > max_counter_size
-              i = 0
-              # Not the most efficient search algorithm, but this should be hit very rarely
-              # and even then only to generate the bin the first time around
-              p = refs.sort_by { |bin, last_used| last_used }.find do |bin, last_used|
-                possible.include?(bin)
-              end
-              proposal = p[0]
+          end
+          # Overflowed, need to go search for the oldest duplicate now
+          if i.to_s.size > max_counter_size
+            i = 0
+            # Not the most efficient search algorithm, but this should be hit very rarely
+            # and even then only to generate the bin the first time around
+            p = refs.sort_by { |_bin, last_used| last_used }.find do |bin, _last_used|
+              possible.include?(bin)
             end
-            number = proposal
+            proposal = p[0]
           end
-        else
-          fail "Illegal algorithm: #{algo}"
+          number = proposal
         end
+
         number.to_i
-      elsif callback = conf.callback
+      elsif (callback = conf.callback)
         callback.call(options)
+      elsif store['pointers'][type_plural] == 'done'
+        reclaim_item(type, options)
       else
-        if store['pointers'][type_plural] == 'done'
-          reclaim_item(type, options)
+        b = conf.include.next(after: instance_variable_get("@last_#{type}"), size: options[:size])
+        instance_variable_set("@last_#{type}", nil)
+        b = conf.include.next(size: options[:size]) while b && (store['manually_assigned'][type_plural][b.to_s] || conf.exclude.include?(b))
+        # When no number is returned it means we have used them all, all future generation
+        # now switches to reclaim mode
+        if b
+          store['pointers'][type_plural] = b + (options[:size] || 1) - 1
+          b
         else
-          b = conf.include.next(after: instance_variable_get("@last_#{type}"), size: options[:size])
-          instance_variable_set("@last_#{type}", nil)
-          while b && (store['manually_assigned'][type_plural][b.to_s] || conf.exclude.include?(b))
-            b = conf.include.next(size: options[:size])
-          end
-          # When no number is returned it means we have used them all, all future generation
-          # now switches to reclaim mode
-          if b
-            store['pointers'][type_plural] = b + (options[:size] || 1) - 1
-            b
-          else
-            store['pointers'][type_plural] = 'done'
-            reclaim_item(type, options)
-          end
+          store['pointers'][type_plural] = 'done'
+          reclaim_item(type, options)
         end
       end
     end
 
     def reclaim_item(type, options)
       type_plural = "#{type}s"
-      store['references'][type_plural] = store['references'][type_plural].sort_by { |k, v| v }.to_h
+      store['references'][type_plural] = store['references'][type_plural].sort_by { |_k, v| v }.to_h
       if options[:size] == 1
         v = store['references'][type_plural].first
         v[0].to_i if v
@@ -599,12 +606,11 @@ module TestIds
             p = i
             s = 1
           end
-          prev = v
         else
           p = i
           s = 1
-          prev = v
         end
+        prev = v
       end
       if s > max_size
         max_size = s

data/lib/test_ids/bin_array.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TestIds
   class BinArray
     def initialize
@@ -74,11 +76,11 @@ module TestIds
         end
       else
         v = @store.first
-        if v.is_a?(Range)
-          @next = v.min
-        else
-          @next = v
-        end
+        @next = if v.is_a?(Range)
+                  v.min
+                else
+                  v
+                end
       end
       if options[:size] && options[:size] > 1
         # Check that all the numbers in the range to be reserved are included in the allocation,
@@ -121,7 +123,7 @@ module TestIds
       nx = @next
       @pointer = nil
       @next = nil
-      while n = self.next
+      while (n = self.next)
         yield n
       end
       @pointer = p
@@ -141,11 +143,10 @@ module TestIds
           self.<<(i)
         elsif i.is_a?(String)
           # JSON does not serialize ranges well, take care of it here
-          if i =~ /^(\d+)\.\.(\d+)$/
-            self.<<((Regexp.last_match(1).to_i)..(Regexp.last_match(2).to_i))
-          else
-            fail "Unknown bin array object type (#{o.class}): #{o}"
-          end
+          fail "Unknown bin array object type (#{o.class}): #{o}" unless i =~ /^(\d+)\.\.(\d+)$/
+
+          self.<<((Regexp.last_match(1).to_i)..(Regexp.last_match(2).to_i))
+
         else
           fail "Unknown bin array object type (#{o.class}): #{o}"
         end
@@ -155,7 +156,7 @@ module TestIds
     private
 
     def previous_pointer(i)
-      i == 0 ? @store.size - 1 : i - 1
+      i.zero? ? @store.size - 1 : i - 1
     end
 
     def min_val(v)

data/lib/test_ids/commands/clear.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 options = {}
@@ -5,27 +7,30 @@ options = {}
 # App options are options that the application can supply to extend this command
 app_options = @application_options || []
 opt_parser = OptionParser.new do |opts|
-  opts.banner = <<-EOT
-Clear all existing bin, softbin or test number allocations in the given TestId database.
+  opts.banner = <<~EOT
+    Clear all existing bin, softbin or test number allocations in the given TestId database.
 
-Usage: origen test_ids:clear [ID] [options]
+    Usage: origen test_ids:clear [ID] [options]
 
-Examples: origen test_ids:clear --bins                      # Clear the bins in the default database
-          origen test_ids:clear wafer_test --numbers        # Clear the test numbers in the wafer_test database
-          origen test_ids:clear --bins --softbin --numbers  # Clear everything in the default database
+    Examples: origen test_ids:clear --bins                      # Clear the bins in the default database
+              origen test_ids:clear wafer_test --numbers        # Clear the test numbers in the wafer_test database
+              origen test_ids:clear --bins --softbin --numbers  # Clear everything in the default database
 
   EOT
-  opts.on('--bins', 'Clear the bin database') {  options[:bins] = true }
+  opts.on('--bins', 'Clear the bin database') { options[:bins] = true }
   opts.on('--softbins', 'Clear the softbin database') {  options[:softbins] = true }
-  opts.on('--numbers', 'Clear the test number database') {  options[:numbers] = true }
-  opts.on('--ranges', 'Clear the ranges database') {  options[:ranges] = true }
+  opts.on('--numbers', 'Clear the test number database') { options[:numbers] = true }
+  opts.on('--ranges', 'Clear the ranges database') { options[:ranges] = true }
   # opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
-  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-d', '--debugger', 'Enable the debugger') { options[:debugger] = true }
   app_options.each do |app_option|
     opts.on(*app_option) {}
   end
   opts.separator ''
-  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+  opts.on('-h', '--help', 'Show this message') do
+    puts opts
+    exit 0
+  end
 end
 
 opt_parser.parse! ARGV

data/lib/test_ids/commands/repair.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 options = {}
@@ -5,21 +7,24 @@ options = {}
 # App options are options that the application can supply to extend this command
 app_options = @application_options || []
 opt_parser = OptionParser.new do |opts|
-  opts.banner = <<-EOT
-Performs maintenance on the given TestId database.
+  opts.banner = <<~EOT
+    Performs maintenance on the given TestId database.
 
-Usage: origen test_ids:repair ID [options]
+    Usage: origen test_ids:repair ID [options]
 
   EOT
   # opts.on('--bins', 'Clear the bin database') {  options[:bins] = true }
   # opts.on('--softbins', 'Clear the softbin database') {  options[:softbins] = true }
   # opts.on('--numbers', 'Clear the test number database') {  options[:numbers] = true }
-  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-d', '--debugger', 'Enable the debugger') { options[:debugger] = true }
   app_options.each do |app_option|
     opts.on(*app_option) {}
   end
   opts.separator ''
-  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+  opts.on('-h', '--help', 'Show this message') do
+    puts opts
+    exit 0
+  end
 end
 
 opt_parser.parse! ARGV