test_ids 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e75b85981fb273db9e57af616ed8077d13f0c6d8
+  data.tar.gz: 1a1c23efe34764a6db9def529358430eeb7d8e29
+SHA512:
+  metadata.gz: 444daec69e397bf06c6f0bd5982d956c1caf30b2bf2be07b0a37d4ec492a472285657775e8098194d63ccd767a2194ca5fbfc635ca39a885ffcf7589f41ebbfa
+  data.tar.gz: b98facddf7e176d90ddebb503221356c563102f63e2d5a48048be6a2118b5acf7a9349f7ac87d581421d98ce5c95d2b006a67a45c3fd23281ffa6cd1c7f38e63

data/config/application.rb

@@ -0,0 +1,103 @@
+require 'origen'
+class TestIdsApplication < Origen::Application
+
+  # See http://origen-sdk.org/origen/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  # These attributes should never be changed, the duplication here will be resolved in future
+  # by condensing these attributes that do similar things
+  self.name       = "test_ids"
+  self.namespace  = "TestIds"
+  config.name     = "test_ids"
+  config.initials = "TestIds"
+  # Change this to point to the revision control repository for this plugin
+  config.rc_url   = "ssh://git@github.com:Origen-SDK/test_ids.git"
+  config.release_externally = true
+
+  # To enable deployment of your documentation to a web server (via the 'origen web'
+  # command) fill in these attributes.
+  config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/test_ids"
+  config.web_domain = "http://origen-sdk.org/test_ids"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  # See: http://origen-sdk.org/origen/latest/guides/utilities/lint/
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    run_on_tag: true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    auto_correct: true, 
+    # Limit the testing for large legacy applications
+    #level: :easy,
+    # Run on these directories/files by default
+    #files: ["lib", "config/application.rb"],
+  }
+
+  config.semantically_version = true
+
+  # An example of how to set application specific LSF parameters
+  #config.lsf.project = "msg.te"
+  
+  # An example of how to specify a prefix to add to all generated patterns
+  #config.pattern_prefix = "nvm"
+
+  # An example of how to add header comments to all generated patterns
+  #config.pattern_header do
+  #  cc "This is a pattern created by the example origen application"
+  #end
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory. 
+  #config.output_directory do
+  #  "#{Origen.root}/output/#{$dut.class}"
+  #end
+
+  # Similarly for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  #config.reference_directory do
+  #  "#{Origen.root}/.ref/#{$dut.class}"
+  #end
+ 
+  # This will automatically deploy your documentation after every tag
+  def after_release_email(tag, note, type, selector, options)
+    command = "origen web compile --remote --api"
+    Dir.chdir Origen.root do
+      system command
+    end
+  end
+
+  # Ensure that all tests pass before allowing a release to continue
+  def validate_release
+    if !system("origen specs") || !system("origen examples")
+      puts "Sorry but you can't release with failing tests, please fix them and try again."
+      exit 1
+    else
+      puts "All tests passing, proceeding with release process!"
+    end
+  end
+
+  # To enabled source-less pattern generation create a class (for example PatternDispatcher)
+  # to generate the pattern. This should return false if the requested pattern has been
+  # dispatched, otherwise Origen will proceed with looking up a pattern source as normal.
+  #def before_pattern_lookup(requested_pattern)
+  #  PatternDispatcher.new.dispatch_or_return(requested_pattern)
+  #end
+
+  # If you use pattern iterators you may come across the case where you request a pattern
+  # like this:
+  #   origen g example_pat_b0.atp
+  #
+  # However it cannot be found by Origen since the pattern name is actually example_pat_bx.atp
+  # In the case where the pattern cannot be found Origen will pass the name to this translator
+  # if it exists, and here you can make any substitutions to help Origen find the file you 
+  # want. In this example any instances of _b\d, where \d means a number, are replaced by
+  # _bx.
+  #config.pattern_name_translator do |name|
+  #  name.gsub(/_b\d/, "_bx")
+  #end
+
+end

data/config/boot.rb

@@ -0,0 +1,24 @@
+# This file is used to boot your plugin when it is running in standalone mode
+# from its own workspace - i.e. when the plugin is being developed.
+#
+# It will not be loaded when the plugin is imported by a 3rd party app - in that
+# case only lib/test_ids.rb is loaded.
+#
+# Therefore this file can be used to load anything extra that you need to boot
+# the development environment for this app. For example, this is typically used
+# to load some additional test classes to use your plugin APIs so that they can
+# be tested and/or interacted with in the console.
+require "test_ids"
+
+module TestIdsDev
+  # Example of how to explicitly require a file
+  # require "test_ids_dev/my_file"
+    
+  # Load all files in the lib/test_ids_dev directory.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required first, then
+  # explicitly require it up above and then let this take care of the rest.
+  Dir.glob("#{File.dirname(__FILE__)}/../lib/test_ids_dev/**/*.rb").sort.each do |file|
+    require file
+  end
+end

data/config/commands.rb

@@ -0,0 +1,71 @@
+# This file should be used to extend the origen with application specific commands
+
+# Map any command aliases here, for example to allow 'origen ex' to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "ex" => "execute",
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+# Now branch to the specific task code
+case @command
+
+# Here is an example of how to implement a command, the logic can go straight
+# in here or you can require an external file if preferred.
+when "my_command"
+  puts "Doing something..."
+  #require "commands/my_command"    # Would load file lib/commands/my_command.rb
+  # You must always exit upon successfully capturing a command to prevent 
+  # control flowing back to Origen
+  exit 0
+
+# Example of how to make a command to run unit tests, this simply invokes RSpec on
+# the spec directory
+when "specs"
+  require "rspec"
+  exit RSpec::Core::Runner.run(['spec'])
+
+# Example of how to make a command to run diff-based tests
+when "examples", "test"
+  Origen.load_application
+  status = 0
+
+  # Program generator integration test
+  ARGV = %w(program/prb1.rb -t default -e default -r approved)
+  load "#{Origen.top}/lib/origen/commands/program.rb"
+
+  if Origen.app.stats.changed_files == 0 &&
+     Origen.app.stats.new_files == 0 &&
+     Origen.app.stats.changed_patterns == 0 &&
+     Origen.app.stats.new_patterns == 0
+
+    Origen.app.stats.report_pass
+  else
+    Origen.app.stats.report_fail
+    status = 1
+  end
+  puts
+  if @command == "test"
+    Origen.app.unload_target!
+    require "rspec"
+    result = RSpec::Core::Runner.run(['spec'])
+    status = status == 1 ? 1 : result
+  end
+  exit status  # Exit with a 1 on the event of a failure per std unix result codes
+
+# Always leave an else clause to allow control to fall back through to the
+# Origen command handler.
+else
+  # You probably want to also add the your commands to the help shown via
+  # origen -h, you can do this be assigning the required text to @application_commands
+  # before handing control back to Origen. Un-comment the example below to get started.
+  @application_commands = <<-EOT
+ specs        Run the specs (tests), -c will enable coverage
+ examples     Run the examples (tests), -c will enable coverage
+ test         Run both specs and examples, -c will enable coverage
+  EOT
+
+end 

data/config/version.rb

@@ -0,0 +1,8 @@
+module TestIds
+  MAJOR = 0
+  MINOR = 2
+  BUGFIX = 0
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/tasks/test_ids.rake

@@ -0,0 +1,6 @@
+# You can define any Rake tasks to support your application here (or in any file
+# ending in .rake in this directory).
+#
+# Rake (Ruby Make) is very useful for creating build scripts, see this short video
+# for a quick introduction:
+# http://railscasts.com/episodes/66-custom-rake-tasks

data/lib/test_ids/allocator.rb

@@ -0,0 +1,359 @@
+module TestIds
+  class Allocator
+    include Origen::Callbacks
+    attr_reader :config
+
+    def initialize
+      @@allocators ||= 0
+      @@allocators += 1
+      if @@allocators > 1 && !TestIds.send(:testing?)
+        fail 'TestIds::Allocators is a singleton, there can be only one'
+      end
+    end
+
+    # Main method to inject generated bin and test numbers, the given
+    # options instance is modified accordingly
+    def allocate(instance, options)
+      @changes_made = true
+      clean(options)
+      @callbacks = []
+      name = extract_test_name(instance, options)
+      name = "#{name}_#{options[:index]}" if options[:index]
+      store['tests'][name] ||= {}
+      t = store['tests'][name]
+      # If the user has supplied any of these, that number should be used
+      # and reserved so that it is not automatically generated later
+      if options[:bin]
+        t['bin'] = options[:bin]
+        store['manually_assigned']['bin'][options[:bin].to_s] = true
+      # Regenerate the bin if the original allocation has since been applied
+      # manually elsewhere
+      elsif store['manually_assigned']['bin'][t['bin'].to_s]
+        t['bin'] = nil
+        # Also regenerate these as they could be a function of the bin
+        t['softbin'] = nil if config.softbins.function?
+        t['number'] = nil if config.numbers.function?
+      end
+      if options[:softbin]
+        t['softbin'] = options[:softbin]
+        store['manually_assigned']['softbin'][options[:softbin].to_s] = true
+      elsif store['manually_assigned']['softbin'][t['softbin'].to_s]
+        t['softbin'] = nil
+        # Also regenerate the number as it could be a function of the softbin
+        t['number'] = nil if config.numbers.function?
+      end
+      if options[:number]
+        t['number'] = options[:number]
+        store['manually_assigned']['number'][options[:number].to_s] = true
+      elsif store['manually_assigned']['number'][t['number'].to_s]
+        t['number'] = nil
+      end
+      # Otherwise generate the missing ones
+      t['bin'] ||= allocate_bin
+      t['softbin'] ||= allocate_softbin(t['bin'])
+      t['number'] ||= allocate_number(t['bin'], t['softbin'])
+      # Record that there has been a reference to the final numbers
+      time = Time.now.to_f
+      store['references']['bin'][t['bin'].to_s] = time if t['bin']
+      store['references']['softbin'][t['softbin'].to_s] = time if t['softbin']
+      store['references']['number'][t['number'].to_s] = time if t['number']
+      # Update the supplied options hash that will be forwarded to the
+      # program generator
+      options[:bin] = t['bin']
+      options[:softbin] = t['softbin']
+      options[:number] = t['number']
+      options
+    end
+
+    def config
+      TestIds.config
+    end
+
+    def store
+      @store ||= begin
+        s = JSON.load(File.read(file)) if file && File.exist?(file)
+        if s
+          @last_bin = s['pointers']['bin']
+          @last_softbin = s['pointers']['softbin']
+          @last_number = s['pointers']['number']
+          s
+        else
+          { 'tests'             => {},
+            'manually_assigned' => { 'bin' => {}, 'softbin' => {}, 'number' => {} },
+            'pointers'          => { 'bin' => nil, 'softbin' => nil, 'number' => nil },
+            'references'        => { 'bin' => {}, 'softbin' => {}, 'number' => {} }
+          }
+        end
+      end
+    end
+
+    # Saves the current allocator state to the repository
+    def save
+      if file
+        p = Pathname.new(file)
+        FileUtils.mkdir_p(p.dirname)
+        File.open(p, 'w') { |f| f.puts JSON.pretty_generate(store) }
+      end
+    end
+
+    def on_origen_shutdown
+      unless TestIds.send(:testing?)
+        if config.repo && @changes_made && config.on_completion != :discard
+          save
+          git.publish if publish?
+        end
+      end
+    end
+
+    # Returns a path to the file that will be used to store the allocated bins/numbers.
+    # If config.repo has not been set it returns nil.
+    def file
+      if config.repo
+        @file ||= begin
+          if git?
+            dir = "#{Origen.app.imports_directory}/test_ids/#{Pathname.new(config.repo).basename}"
+            FileUtils.mkdir_p(dir)
+            "#{dir}/store.json"
+          else
+            config.repo
+          end
+        end
+      end
+    end
+
+    def git
+      @git ||= Git.new(local: Pathname.new(file).dirname, remote: config.repo, no_pull: publish?)
+    end
+
+    def prepare
+      if git?
+        git # Pulls the latest repo
+        git.get_lock if publish?
+      end
+    end
+
+    private
+
+    def publish?
+      git? && config.on_completion == :publish
+    end
+
+    def git?
+      if config.repo
+        !!(config.repo =~ /git/i)
+      end
+    end
+
+    # Returns the next available bin in the pool, if they have all been given out
+    # the one that hasn't been used for the longest time will be given out
+    def allocate_bin
+      return nil if config.bins.empty?
+      if store['pointers']['bin'] == 'done'
+        reclaim_bin
+      else
+        b = config.bins.include.next(@last_bin)
+        @last_bin = nil
+        while b && (store['manually_assigned']['bin'][b.to_s] || config.bins.exclude.include?(b))
+          b = config.bins.include.next
+        end
+        # When no bin is returned it means we have used them all, all future generation
+        # now switches to reclaim mode
+        if b
+          store['pointers']['bin'] = b
+        else
+          store['pointers']['bin'] = 'done'
+          reclaim_bin
+        end
+      end
+    end
+
+    def reclaim_bin
+      store['references']['bin'] = store['references']['bin'].sort_by { |k, v| v }.to_h
+      store['references']['bin'].first[0].to_i
+    end
+
+    def allocate_softbin(bin)
+      return nil if config.softbins.empty?
+      if config.softbins.algorithm
+        algo = config.softbins.algorithm.to_s.downcase
+        if algo.to_s =~ /^[b\dx]+$/
+          number = algo.to_s
+          bin = bin.to_s
+          if number =~ /(b+)/
+            max_bin_size = Regexp.last_match(1).size
+            if bin.size > max_bin_size
+              fail "Bin number (#{bin}) overflows the test number algorithm (#{algo})"
+            end
+            number = number.sub(/b+/, bin.rjust(max_bin_size, '0'))
+          end
+          if number =~ /(x+)/
+            max_counter_size = Regexp.last_match(1).size
+            refs = store['references']['softbin']
+            i = 0
+            possible = []
+            proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
+            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'))
+              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
+            number = proposal
+          end
+        else
+          fail "Unknown softbin algorithm: #{algo}"
+        end
+        number.to_i
+      elsif callback = config.softbins.callback
+        callback.call(bin)
+      else
+        if store['pointers']['softbin'] == 'done'
+          reclaim_softbin
+        else
+          b = config.softbins.include.next(@last_softbin)
+          @last_softbin = nil
+          while b && (store['manually_assigned']['softbin'][b.to_s] || config.softbins.exclude.include?(b))
+            b = config.softbins.include.next
+          end
+          # When no softbin is returned it means we have used them all, all future generation
+          # now switches to reclaim mode
+          if b
+            store['pointers']['softbin'] = b
+          else
+            store['pointers']['softbin'] = 'done'
+            reclaim_softbin
+          end
+        end
+      end
+    end
+
+    def reclaim_softbin
+      store['references']['softbin'] = store['references']['softbin'].sort_by { |k, v| v }.to_h
+      store['references']['softbin'].first[0].to_i
+    end
+
+    def allocate_number(bin, softbin)
+      return nil if config.numbers.empty?
+      if config.numbers.algorithm
+        algo = config.numbers.algorithm.to_s.downcase
+        if algo.to_s =~ /^[bs\dx]+$/
+          number = algo.to_s
+          bin = bin.to_s
+          if number =~ /(b+)/
+            max_bin_size = Regexp.last_match(1).size
+            if bin.size > max_bin_size
+              fail "Bin number (#{bin}) overflows the test number algorithm (#{algo})"
+            end
+            number = number.sub(/b+/, bin.rjust(max_bin_size, '0'))
+          end
+          softbin = softbin.to_s
+          if number =~ /(s+)/
+            max_softbin_size = Regexp.last_match(1).size
+            if softbin.size > max_softbin_size
+              fail "Softbin number (#{softbin}) overflows the test number algorithm (#{algo})"
+            end
+            number = number.sub(/s+/, softbin.rjust(max_bin_size, '0'))
+          end
+          if number =~ /(x+)/
+            max_counter_size = Regexp.last_match(1).size
+            refs = store['references']['number']
+            i = 0
+            possible = []
+            proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
+            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'))
+              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
+            number = proposal
+          end
+          number.to_i
+        else
+          fail "Unknown test number algorithm: #{algo}"
+        end
+      elsif callback = config.numbers.callback
+        callback.call(bin, softbin)
+      else
+        if store['pointers']['number'] == 'done'
+          reclaim_number
+        else
+          b = config.numbers.include.next(@last_number)
+          @last_number = nil
+          while b && (store['manually_assigned']['number'][b.to_s] || config.numbers.exclude.include?(b))
+            b = config.numbers.include.next
+          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']['number'] = b
+          else
+            store['pointers']['number'] = 'done'
+            reclaim_number
+          end
+        end
+      end
+    end
+
+    def reclaim_number
+      store['references']['number'] = store['references']['number'].sort_by { |k, v| v }.to_h
+      store['references']['number'].first[0].to_i
+    end
+
+    def extract_test_name(instance, options)
+      name = options[:name]
+      unless name
+        if instance.is_a?(String)
+          name = instance
+        elsif instance.is_a?(Symbol)
+          name = instance.to_s
+        elsif instance.is_a?(Hash)
+          h = instance.with_indifferent_access
+          name = h[:name] || h[:tname] || h[:testname] || h[:test_name]
+        elsif instance.respond_to?(:name)
+          name = instance.name
+        else
+          fail "Could not get the test name from #{instance}"
+        end
+      end
+      name.to_s.downcase
+    end
+
+    # Cleans the given options hash by consolidating any bin/test numbers
+    # to the following option keys:
+    #
+    # * :bin
+    # * :softbin
+    # * :number
+    # * :name
+    # * :index
+    def clean(options)
+      options[:softbin] ||= options.delete(:sbin) || options.delete(:soft_bin)
+      options[:number] ||= options.delete(:test_number) || options.delete(:tnum) ||
+                           options.delete(:testnumber)
+      options[:name] ||= options.delete(:tname) || options.delete(:testname) ||
+                         options.delete(:test_name)
+      options[:index] ||= options.delete(:ix)
+    end
+  end
+end

data/lib/test_ids/bin_array.rb

@@ -0,0 +1,117 @@
+module TestIds
+  class BinArray
+    def initialize
+      @store = []
+    end
+
+    def <<(val)
+      @store += Array(val)
+      @store = @store.sort do |a, b|
+        a = a.min if a.is_a?(Range)
+        b = b.min if b.is_a?(Range)
+        a <=> b
+      end
+      nil
+    end
+
+    def empty?
+      @store.empty?
+    end
+
+    def freeze
+      @store.freeze
+    end
+
+    # Returns true if the array contains the given bin number
+    def include?(bin)
+      @store.any? do |v|
+        v == bin || (v.is_a?(Range) && bin >= v.min && bin <= v.max)
+      end
+    end
+
+    # Returns the next bin in the array, starting from the first and remembering the last bin
+    # when called the next time.
+    # A bin can optionally be supplied in which case the internal pointer will be reset and the
+    # next bin that occurs after the given number will be returned.
+    def next(after = nil)
+      if after
+        # Need to work out the pointer here as it is probably out of sync with the
+        # last value now
+        @pointer = nil
+        i = 0
+        until @pointer
+          v = @store[i]
+          if v
+            if after == v || (v.is_a?(Range) && after >= v.min && after <= v.max)
+              @pointer = i
+              @next = after
+            elsif after < min_val(v)
+              @pointer = previous_pointer(i)
+              @next = min_val(v) - 1
+            end
+          else
+            # Gone past the end of the array
+            @pointer = @store.size - 1
+            @next = min_val(@store[0]) - 1
+          end
+          i += 1
+        end
+      end
+      if @next
+        @pointer ||= 0
+        if @store[@pointer].is_a?(Range) && @next != @store[@pointer].max
+          @next += 1
+        else
+          @pointer += 1
+          # Return nil when we get to the end of the array
+          if @pointer == @store.size
+            @pointer -= 1
+            return nil
+          end
+          @next = @store[@pointer]
+          @next = @next.min if @next.is_a?(Range)
+        end
+      else
+        v = @store.first
+        if v.is_a?(Range)
+          @next = v.min
+        else
+          @next = v
+        end
+      end
+      @next
+    end
+
+    def min
+      v = @store.first
+      if v.is_a?(Range)
+        v.min
+      else
+        v
+      end
+    end
+
+    def max
+      v = @store.last
+      if v.is_a?(Range)
+        v.max
+      else
+        v
+      end
+    end
+
+    private
+
+    def previous_pointer(i)
+      i == 0 ? @store.size - 1 : i - 1
+    end
+
+    def min_val(v)
+      v.is_a?(Range) ? v.min : v
+    end
+
+    def max_val(v)
+      v.is_a?(Range) ? v.max : v
+    end
+  end
+end

data/lib/test_ids/configuration.rb

@@ -0,0 +1,106 @@
+module TestIds
+  class Configuration
+    class Item
+      attr_accessor :include, :exclude, :algorithm
+
+      def initialize
+        @include = BinArray.new
+        @exclude = BinArray.new
+      end
+
+      def callback(&block)
+        if block_given?
+          @callback = block
+        else
+          @callback
+        end
+      end
+
+      def empty?
+        include.empty? && exclude.empty? && !algorithm && !callback
+      end
+
+      def function?
+        !!algorithm || !!callback
+      end
+
+      def freeze
+        @include.freeze
+        @exclude.freeze
+        super
+      end
+    end
+
+    attr_accessor :repo
+    attr_reader :on_completion
+
+    def on_completion
+      @on_completion || :publish
+    end
+
+    def on_completion=(val)
+      unless %w(publish save discard).include?(val.to_s)
+        fail 'on_completion must be set to one of: :publish, :save, :discard'
+      end
+      @on_completion = val.to_sym
+    end
+
+    def bins
+      @bins ||= Item.new
+    end
+
+    def softbins
+      @softbins ||= Item.new
+      if block_given?
+        @softbins.callback(&block)
+      end
+      @softbins
+    end
+
+    # An alias for config.softbins.algorithm=
+    def softbins=(val)
+      softbins.algorithm = val
+    end
+
+    def numbers(&block)
+      @numbers ||= Item.new
+      if block_given?
+        @numbers.callback(&block)
+      end
+      @numbers
+    end
+
+    # An alias for config.numbers.algorithm=
+    def numbers=(val)
+      numbers.algorithm = val
+    end
+
+    def validate!
+      unless validated?
+        if bins.algorithm
+          fail 'The TestIds bins configuration cannot be set to an algorithm, only a range set by bins.include and bins.exclude is permitted'
+        end
+        if bins.callback
+          fail 'The TestIds bins configuration cannot be set by a callback, only a range set by bins.include and bins.exclude is permitted'
+        end
+        @validated = true
+        freeze
+      end
+    end
+
+    def empty?
+      bins.empty? && softbins.empty? && numbers.empty?
+    end
+
+    def validated?
+      @validated
+    end
+
+    def freeze
+      bins.freeze
+      softbins.freeze
+      numbers.freeze
+      super
+    end
+  end
+end

data/lib/test_ids/git.rb

@@ -0,0 +1,116 @@
+require 'json'
+require 'git'
+module TestIds
+  # The Git driver is responsible for committing and fetching the
+  # store from the central Git repository.
+  #
+  # All operations are automatically pushed immediately to the central repository
+  # and a lock will be taken out whenever a program generation operation is done in
+  # production mode to prevent the need to merge with other users.
+  #
+  # An instance of this class is instantiated as TestIds.git
+  class Git
+    attr_reader :repo, :local
+
+    def initialize(options)
+      unless File.exist?("#{options[:local]}/.git")
+        FileUtils.rm_rf(options[:local]) if File.exist?(options[:local])
+        FileUtils.mkdir_p(options[:local])
+        Dir.chdir options[:local] do
+          `git clone #{options[:remote]} .`
+          if !File.exist?('store.json') || !File.exist?('lock.json')
+            # Should really try to use the Git driver for this
+            exec 'touch store.json lock.json'
+            exec 'git add store.json lock.json'
+            exec 'git commit -m "Initial commit"'
+            exec 'git push'
+          end
+        end
+      end
+      @local = options[:local]
+      @repo = ::Git.open(options[:local])
+      @repo.reset_hard
+      @repo.pull unless options[:no_pull]
+    end
+
+    def exec(cmd)
+      r = system(cmd)
+      unless r
+        fail "Something went wrong running command: #{cmd}"
+      end
+    end
+
+    def publish
+      write('store.json')
+      release_lock
+      repo.commit('Publishing latest store')
+      repo.push('origin')
+    end
+
+    # Writes the data to the given file and pushes to the remote repo
+    def write(path, data = nil)
+      f = File.join(local, path)
+      File.write(f, data) if data
+      repo.add(f)
+    end
+
+    def get_lock
+      until available_to_lock?
+        puts "Waiting for lock, currently locked by #{lock_user} (the lock will expire in less than #{lock_minutes_remaining} #{'minute'.pluralize(lock_minutes_remaining)} if not released before that)"
+        sleep 5
+      end
+      data = {
+        'user'    => User.current.name,
+        'expires' => (Time.now + minutes(5)).to_f
+      }
+      write('lock.json', JSON.pretty_generate(data))
+      repo.commit('Obtaining lock')
+      repo.push('origin')
+    end
+
+    def release_lock
+      data = {
+        'user'    => nil,
+        'expires' => nil
+      }
+      write('lock.json', JSON.pretty_generate(data))
+    end
+
+    def with_lock
+      get_lock
+      yield
+    ensure
+      release_lock
+    end
+
+    def available_to_lock?
+      repo.pull
+      if lock_content && lock_user && lock_user != User.current.name
+        Time.now.to_f > lock_expires
+      else
+        true
+      end
+    end
+
+    def lock_minutes_remaining
+      ((lock_expires - Time.now.to_f) / 60).ceil
+    end
+
+    def lock_expires
+      lock_content['expires']
+    end
+
+    def lock_user
+      lock_content['user']
+    end
+
+    def lock_content
+      f = File.join(local, 'lock.json')
+      JSON.load(File.read(f)) if File.exist?(f)
+    end
+
+    def minutes(number)
+      number * 60
+    end
+  end
+end

data/lib/test_ids/origen_testers/flow.rb

@@ -0,0 +1,14 @@
+require 'origen_testers/flow'
+module OrigenTesters
+  module Flow
+    # Override the flow.test method to inject our generated bin and
+    # test numbers
+    alias_method :_orig_test, :test
+    def test(instance, options = {})
+      unless TestIds.config.empty?
+        TestIds.allocator.allocate(instance, options)
+      end
+      _orig_test(instance, options)
+    end
+  end
+end

data/lib/test_ids.rb

@@ -0,0 +1,76 @@
+require 'origen'
+require_relative '../config/application.rb'
+require 'origen_testers'
+
+module TestIds
+  # THIS FILE SHOULD ONLY BE USED TO LOAD RUNTIME DEPENDENCIES
+  # If this plugin has any development dependencies (e.g. dummy DUT or other models that are only used
+  # for testing), then these should be loaded from config/boot.rb
+
+  # Example of how to explicitly require a file
+  # require "test_ids/my_file"
+
+  # Load all files in the lib/test_ids directory.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required first, then
+  # explicitly require it up above and then let this take care of the rest.
+  Dir.glob("#{File.dirname(__FILE__)}/test_ids/**/*.rb").sort.each do |file|
+    require file
+  end
+
+  class <<self
+    def store
+      unless @configuration
+        fail 'The test ID generator has to be configured before you can start using it'
+      end
+      @store ||= Store.new
+    end
+
+    def allocator
+      unless @configuration
+        fail 'The test ID generator has to be configured before you can start using it'
+      end
+      @allocator ||= Allocator.new
+    end
+
+    def configuration
+      if block_given?
+        configure do |config|
+          yield config
+        end
+      else
+        @configuration ||
+          fail('You have to create the configuration first before you can access it')
+      end
+    end
+    alias_method :config, :configuration
+
+    def configure
+      if @configuration
+        fail "You can't modify an existing test IDs configuration"
+      end
+      @configuration = Configuration.new
+      yield @configuration
+      @configuration.validate!
+      allocator.prepare
+    end
+
+    private
+
+    # For testing, clears all instances including the configuration
+    def reset
+      @git = nil
+      @store = nil
+      @allocator = nil
+      @configuration = nil
+    end
+
+    def testing=(val)
+      @testing = val
+    end
+
+    def testing?
+      !!@testing
+    end
+  end
+end

data/lib/test_ids_dev/dut.rb

@@ -0,0 +1,7 @@
+module TestIdsDev
+  class DUT
+    include Origen::TopLevel
+
+    attr_accessor :test_ids
+  end
+end

data/lib/test_ids_dev/interface.rb

@@ -0,0 +1,26 @@
+module TestIdsDev
+  class Interface
+    include OrigenTesters::ProgramGenerators
+
+    def initialize(options = {})
+      case dut.test_ids
+      when 1
+        TestIds.configure do |config|
+          # Example of testing remote repo
+          # config.repo = 'ssh://git@sw-stash.freescale.net/~r49409/test_ids_repo.git'
+          config.bins.include << 3
+          config.bins.include << (10..20)
+          config.bins.exclude << 15
+          config.softbins = :bbbxx
+          config.numbers do |bin, softbin|
+            softbin * 100
+          end
+        end
+      end
+    end
+
+    def func(name, options = {})
+      flow.test(name, options)
+    end
+  end
+end

data/program/prb1.rb

@@ -0,0 +1,6 @@
+Flow.create do
+
+  func :t1
+  func :t2
+  func :t3
+end

data/templates/web/index.md.erb

@@ -0,0 +1,11 @@
+% render "layouts/basic.html" do
+
+%# HTML tags can be embedded in mark down files if you want to do specific custom
+%# formatting like this, but in most cases that is not required.
+<h1><%= Origen.app.namespace %> <span style="font-size: 14px">(<%= Origen.app.version %>)</span></h1>
+
+% lines = File.readlines("#{Origen.root}/README.md")
+% lines.shift  # Lose the heading, we have our own here
+<%= lines.join('') %>
+
+% end

data/templates/web/layouts/_basic.html.erb

@@ -0,0 +1,15 @@
+---
+title: <%= options[:title] || Origen.config.name %>
+---
+<%= render "partials/navbar.html", tab: options[:tab] %>
+
+<div class="row">
+%# The markdown attribute is important if you are going to include content written
+%# in markdown, without this is will be included verbatim
+  <div class="span12" markdown="1">
+<%= yield %>    
+
+<%= disqus_comments %>
+
+</div>
+</div>

data/templates/web/partials/_navbar.html.erb

@@ -0,0 +1,21 @@
+<nav class="navbar navbar-inverse navbar-fixed-top">
+  <div class="container">
+    <div class="navbar-header">
+      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+        <span class="sr-only">Toggle navigation</span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+      <a class="navbar-brand" href="<%= path "/" %>">Home</a>
+    </div>
+    <div id="navbar" class="collapse navbar-collapse">
+      <ul class="nav navbar-nav">
+        <li class="<%= options[:tab] == :api ? 'active' : '' %>"><a href="<%= path "/api/" %>">API</a></li>
+        <li><a href="https://github.com/Origen-SDK/test_ids">Github</a></li>
+        <li class="<%= options[:tab] == :release ? 'active' : '' %>"><a href="<%= path "/release_notes" %>">Release Notes</a></li>
+      </ul>
+      <%= import "origen/web/logo.html" %>
+    </div><!--/.nav-collapse -->
+  </div>
+</nav>

data/templates/web/release_notes.md.erb

@@ -0,0 +1,5 @@
+% render "layouts/basic.html", tab: :release do
+
+<%= render "#{Origen.root}/doc/history" %>
+
+% end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: test_ids
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Stephen McGinty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: origen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.25
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.25
+- !ruby/object:Gem::Dependency
+  name: origen_testers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- stephen.mcginty@nxp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/application.rb
+- config/boot.rb
+- config/commands.rb
+- config/version.rb
+- lib/tasks/test_ids.rake
+- lib/test_ids.rb
+- lib/test_ids/allocator.rb
+- lib/test_ids/bin_array.rb
+- lib/test_ids/configuration.rb
+- lib/test_ids/git.rb
+- lib/test_ids/origen_testers/flow.rb
+- lib/test_ids_dev/dut.rb
+- lib/test_ids_dev/interface.rb
+- program/prb1.rb
+- templates/web/index.md.erb
+- templates/web/layouts/_basic.html.erb
+- templates/web/partials/_navbar.html.erb
+- templates/web/release_notes.md.erb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Origen plugin to assign and track test program bins and test numbers
+test_files: []