origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/origen_ext/generator/resources.rb

@@ -1,21 +1,21 @@
-# This shim is temporary to help NXP transition to Origen from
-# our original internal version (RGen)
-if defined? RGen::ORIGENTRANSITION
-  require 'rgen/generator/resources'
-else
-  require 'origen/generator/resources'
-end
-module Origen
-  class Generator
-    class Resources
-      alias_method :orig_create, :create
-
-      # Patching to make resources_mode apply much earlier
-      def create(options = {}, &block)
-        OrigenTesters::Interface.with_resources_mode do
-          orig_create(options, &block)
-        end
-      end
-    end
-  end
-end
+# This shim is temporary to help NXP transition to Origen from
+# our original internal version (RGen)
+if defined? RGen::ORIGENTRANSITION
+  require 'rgen/generator/resources'
+else
+  require 'origen/generator/resources'
+end
+module Origen
+  class Generator
+    class Resources
+      alias_method :orig_create, :create
+
+      # Patching to make resources_mode apply much earlier
+      def create(options = {}, &block)
+        OrigenTesters::Interface.with_resources_mode do
+          orig_create(options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/origen_ext/pins/pin.rb

@@ -1,78 +1,78 @@
-# This code is used to extend Origen Core's pin class with additional functionality
-
-require 'origen/pins/pin'
-
-module Origen
-  module Pins
-    class Pin
-      # Returns the channel number for the pin on a given tester site (default = 0), based on a given tester channel
-      # map (default_channelmap).  Optionally user can specify site or channelmap.
-      def channel(options = {})
-        options = {
-          chanmapname: $tester.default_channelmap,  # Default is to use default_channelmap
-          site:        0 # Default is to use site 0.
-        }.merge(options)
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-
-        channelinfo = Struct.new(:channel, :chanmapname, :site)
-        channelinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), options[:chanmapname], options[:site])
-      end
-
-      # Returns the instrument type for the pin on a given tester site (default = 0), based on a given tester channel
-      # map (default_channelmap) and a given tester configuration (default_testerconfig).
-      # Optionally user can specify site, channelmap, or testerconfig.
-      def instrument_type(options = {})
-        options = {
-          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
-          site:             0, # Default is to use site 0.
-          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
-        }.merge(options)
-
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-        unless $tester.testerconfig[options[:testerconfigname]]
-          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
-        end
-
-        instrumentinfo = Struct.new(:instrument, :chanmapname, :site, :testerconfigname)
-        instrumentinfo.new($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
-      end
-
-      # Returns ATE Hardware information for the pin (channel # and instrument type) on a given tester site
-      # (default = 0), based on a given tester channelmap (default_channelmap) and a given tester
-      # configuration (default_testerconfig).  # Optionally user can specify site, channelmap, or testerconfig.
-      def ate_hardware(options = {})
-        options = {
-          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
-          site:             0, # Default is to use site 0.
-          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
-        }.merge(options)
-
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-        unless $tester.testerconfig[options[:testerconfigname]]
-          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
-        end
-        if Origen.top_level.power_pin_groups.keys.include?(name)  # Power Pin Groups do not need :ppmu, but need :supply
-          instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :supply)
-          @channel = $tester.get_tester_channel(options[:chanmapname], name, options[:site])
-          @instrument = $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i) + $tester.is_vhdvs_hc(options[:chanmapname], name, options[:site]).to_s + $tester.is_hexvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.is_vhdvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.merged_channels(options[:chanmapname], name, options[:site]).to_s
-          @supply = $tester.ate_hardware(@instrument).supply
-          instrumentinfo.new(@channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @supply)
-        else
-          if $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i == 24
-            instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname)
-            instrumentinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
-          else
-            instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :ppmu)
-            instrumentinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname], $tester.ate_hardware($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i)).ppmu)
-          end
-        end
-      end
-    end
-  end
-end
+# This code is used to extend Origen Core's pin class with additional functionality
+
+require 'origen/pins/pin'
+
+module Origen
+  module Pins
+    class Pin
+      # Returns the channel number for the pin on a given tester site (default = 0), based on a given tester channel
+      # map (default_channelmap).  Optionally user can specify site or channelmap.
+      def channel(options = {})
+        options = {
+          chanmapname: $tester.default_channelmap,  # Default is to use default_channelmap
+          site:        0 # Default is to use site 0.
+        }.merge(options)
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+
+        channelinfo = Struct.new(:channel, :chanmapname, :site)
+        channelinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), options[:chanmapname], options[:site])
+      end
+
+      # Returns the instrument type for the pin on a given tester site (default = 0), based on a given tester channel
+      # map (default_channelmap) and a given tester configuration (default_testerconfig).
+      # Optionally user can specify site, channelmap, or testerconfig.
+      def instrument_type(options = {})
+        options = {
+          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
+          site:             0, # Default is to use site 0.
+          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
+        }.merge(options)
+
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+        unless $tester.testerconfig[options[:testerconfigname]]
+          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
+        end
+
+        instrumentinfo = Struct.new(:instrument, :chanmapname, :site, :testerconfigname)
+        instrumentinfo.new($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
+      end
+
+      # Returns ATE Hardware information for the pin (channel # and instrument type) on a given tester site
+      # (default = 0), based on a given tester channelmap (default_channelmap) and a given tester
+      # configuration (default_testerconfig).  # Optionally user can specify site, channelmap, or testerconfig.
+      def ate_hardware(options = {})
+        options = {
+          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
+          site:             0, # Default is to use site 0.
+          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
+        }.merge(options)
+
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+        unless $tester.testerconfig[options[:testerconfigname]]
+          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
+        end
+        if Origen.top_level.power_pin_groups.keys.include?(name)  # Power Pin Groups do not need :ppmu, but need :supply
+          instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :supply)
+          @channel = $tester.get_tester_channel(options[:chanmapname], name, options[:site])
+          @instrument = $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i) + $tester.is_vhdvs_hc(options[:chanmapname], name, options[:site]).to_s + $tester.is_hexvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.is_vhdvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.merged_channels(options[:chanmapname], name, options[:site]).to_s
+          @supply = $tester.ate_hardware(@instrument).supply
+          instrumentinfo.new(@channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @supply)
+        else
+          if $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i == 24
+            instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname)
+            instrumentinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
+          else
+            instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :ppmu)
+            instrumentinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname], $tester.ate_hardware($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i)).ppmu)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/origen_ext/pins/pin_collection.rb

@@ -1,84 +1,84 @@
-# This code is used to extend Origen Core's pin_collection class with additional functionality
-
-require 'origen/pins/pin_collection'
-
-module Origen
-  module Pins
-    class PinCollection
-      # Returns the channel number for the pin_collection on a given tester site (default = 0), based on a given tester channel
-      # map (default_channelmap).  Optionally user can specify site or channelmap.
-      def channel(options = {})
-        options = {
-          chanmapname: $tester.default_channelmap,  # Default is to use default_channelmap
-          site:        0 # Default is to use site 0.
-        }.merge(options)
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-
-        channelinfo = Struct.new(:channel, :chanmapname, :site)
-        channelinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), options[:chanmapname], options[:site])
-      end
-
-      # Returns the instrument type for the pin_collection on a given tester site (default = 0), based on a given tester channel
-      # map (default_channelmap) and a given tester configuration (default_testerconfig).
-      # Optionally user can specify site, channelmap, or testerconfig.
-      def instrument_type(options = {})
-        options = {
-          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
-          site:             0, # Default is to use site 0.
-          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
-        }.merge(options)
-
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-        unless $tester.testerconfig[options[:testerconfigname]]
-          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
-        end
-
-        instrumentinfo = Struct.new(:instrument, :chanmapname, :site, :testerconfigname)
-        instrumentinfo.new($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
-      end
-
-      # Returns ATE Hardware information for the pin_collection (channel # and instrument type) on a given tester site
-      # (default = 0), based on a given tester channelmap (default_channelmap) and a given tester
-      # configuration (default_testerconfig).  # Optionally user can specify site, channelmap, or testerconfig.
-      def ate_hardware(options = {})
-        options = {
-          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
-          site:             0, # Default is to use site 0.
-          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
-        }.merge(options)
-
-        unless $tester.channelmap[options[:chanmapname]]
-          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
-        end
-        unless $tester.testerconfig[options[:testerconfigname]]
-          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
-        end
-
-        if Origen.top_level.power_pin_groups.keys.include?(name)  # Power Pin Groups do not need :ppmu, but need :supply
-          instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :supply)
-          @channel = $tester.get_tester_channel(options[:chanmapname], name, options[:site])
-          @instrument = $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i) + $tester.is_vhdvs_hc(options[:chanmapname], name, options[:site]).to_s + $tester.is_hexvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.is_vhdvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.merged_channels(options[:chanmapname], name, options[:site]).to_s
-          @supply = $tester.ate_hardware(@instrument).supply
-          instrumentinfo.new(@channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @supply)
-        else  # Collecting information of individual members and put in arrays
-          instrumentinfo = Struct.new(:members, :channel, :instrument, :chanmapname, :site, :testerconfigname, :ppmu)
-          @members = []
-          @channel = []
-          @instrument = []
-          @ppmu = []
-          Origen.top_level.pin_groups(name).map(&:id).each do |pinname|
-            @members << Origen.top_level.pins(pinname).name
-            @channel << $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site])
-            @instrument << $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site]).split('.')[0].to_i)
-            @ppmu << $tester.ate_hardware($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site]).split('.')[0].to_i)).ppmu
-          end
-          instrumentinfo.new(@members, @channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @ppmu)
-        end
-      end
-    end
-  end
-end
+# This code is used to extend Origen Core's pin_collection class with additional functionality
+
+require 'origen/pins/pin_collection'
+
+module Origen
+  module Pins
+    class PinCollection
+      # Returns the channel number for the pin_collection on a given tester site (default = 0), based on a given tester channel
+      # map (default_channelmap).  Optionally user can specify site or channelmap.
+      def channel(options = {})
+        options = {
+          chanmapname: $tester.default_channelmap,  # Default is to use default_channelmap
+          site:        0 # Default is to use site 0.
+        }.merge(options)
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+
+        channelinfo = Struct.new(:channel, :chanmapname, :site)
+        channelinfo.new($tester.get_tester_channel(options[:chanmapname], name, options[:site]), options[:chanmapname], options[:site])
+      end
+
+      # Returns the instrument type for the pin_collection on a given tester site (default = 0), based on a given tester channel
+      # map (default_channelmap) and a given tester configuration (default_testerconfig).
+      # Optionally user can specify site, channelmap, or testerconfig.
+      def instrument_type(options = {})
+        options = {
+          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
+          site:             0, # Default is to use site 0.
+          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
+        }.merge(options)
+
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+        unless $tester.testerconfig[options[:testerconfigname]]
+          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
+        end
+
+        instrumentinfo = Struct.new(:instrument, :chanmapname, :site, :testerconfigname)
+        instrumentinfo.new($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i), options[:chanmapname], options[:site], options[:testerconfigname])
+      end
+
+      # Returns ATE Hardware information for the pin_collection (channel # and instrument type) on a given tester site
+      # (default = 0), based on a given tester channelmap (default_channelmap) and a given tester
+      # configuration (default_testerconfig).  # Optionally user can specify site, channelmap, or testerconfig.
+      def ate_hardware(options = {})
+        options = {
+          chanmapname:      $tester.default_channelmap,  # Default is to use default_channelmap
+          site:             0, # Default is to use site 0.
+          testerconfigname: $tester.default_testerconfig  # Default is to use default_testerconfig
+        }.merge(options)
+
+        unless $tester.channelmap[options[:chanmapname]]
+          fail "You must first import the tester channel map (e.g. $tester.channelmap = \"probe_x32\") before calling pin.channel"
+        end
+        unless $tester.testerconfig[options[:testerconfigname]]
+          fail "You must first import the tester configuration (e.g. $tester.testerconfig = \"UflexConfigA\") before calling pin.instrument_type"
+        end
+
+        if Origen.top_level.power_pin_groups.keys.include?(name)  # Power Pin Groups do not need :ppmu, but need :supply
+          instrumentinfo = Struct.new(:channel, :instrument, :chanmapname, :site, :testerconfigname, :supply)
+          @channel = $tester.get_tester_channel(options[:chanmapname], name, options[:site])
+          @instrument = $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], name, options[:site]).split('.')[0].to_i) + $tester.is_vhdvs_hc(options[:chanmapname], name, options[:site]).to_s + $tester.is_hexvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.is_vhdvs_plus(options[:testerconfigname], @channel.split('.')[0].to_i).to_s + $tester.merged_channels(options[:chanmapname], name, options[:site]).to_s
+          @supply = $tester.ate_hardware(@instrument).supply
+          instrumentinfo.new(@channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @supply)
+        else  # Collecting information of individual members and put in arrays
+          instrumentinfo = Struct.new(:members, :channel, :instrument, :chanmapname, :site, :testerconfigname, :ppmu)
+          @members = []
+          @channel = []
+          @instrument = []
+          @ppmu = []
+          Origen.top_level.pin_groups(name).map(&:id).each do |pinname|
+            @members << Origen.top_level.pins(pinname).name
+            @channel << $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site])
+            @instrument << $tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site]).split('.')[0].to_i)
+            @ppmu << $tester.ate_hardware($tester.get_tester_instrument(options[:testerconfigname], $tester.get_tester_channel(options[:chanmapname], Origen.top_level.pins(pinname).name, options[:site]).split('.')[0].to_i)).ppmu
+          end
+          instrumentinfo.new(@members, @channel, @instrument, options[:chanmapname], options[:site], options[:testerconfigname], @ppmu)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/parser.rb

@@ -1,22 +1,22 @@
-module OrigenTesters
-  module Parser
-    autoload :SearchableArray, 'origen_testers/parser/searchable_array'
-    autoload :SearchableHash,  'origen_testers/parser/searchable_hash'
-    autoload :DescriptionLookup,  'origen_testers/parser/description_lookup'
-
-    def parse(*args, &block)
-      parser.parse(*args, &block)
-    end
-
-    # Returns a SearchableArray containing all tests parsed from flows, this is intended to
-    # be the main API for accessing parsed test program attributes and should be a consistent
-    # method that is implemented accross all tester models.
-    #
-    # Direct access to the underlying structure (which will be specific to the tester model)
-    # can be achieved through the parser method, which returns an instance of J750::Parser
-    #   $tester.parser.test_instances
-    def tests
-      parser.flow_items
-    end
-  end
-end
+module OrigenTesters
+  module Parser
+    autoload :SearchableArray, 'origen_testers/parser/searchable_array'
+    autoload :SearchableHash,  'origen_testers/parser/searchable_hash'
+    autoload :DescriptionLookup,  'origen_testers/parser/description_lookup'
+
+    def parse(*args, &block)
+      parser.parse(*args, &block)
+    end
+
+    # Returns a SearchableArray containing all tests parsed from flows, this is intended to
+    # be the main API for accessing parsed test program attributes and should be a consistent
+    # method that is implemented accross all tester models.
+    #
+    # Direct access to the underlying structure (which will be specific to the tester model)
+    # can be achieved through the parser method, which returns an instance of J750::Parser
+    #   $tester.parser.test_instances
+    def tests
+      parser.flow_items
+    end
+  end
+end

data/lib/origen_testers/parser/description_lookup.rb

@@ -1,62 +1,62 @@
-module OrigenTesters
-  module Parser
-    class DescriptionLookup
-      def initialize
-        @store = { flow: {}, test: {}, usage: {} }
-      end
-
-      def for_flow(name, options = {})
-        k = flow_key(name)
-        @store[:flow][k] || []
-      end
-
-      def for_test_definition(name, options = {})
-        n = name_key(name)
-        @store[:test][n] || []
-      end
-
-      def for_test_usage(name, flow, options = {})
-        k = flow_key(flow)
-        n = name_key(name)
-        @store[:usage][k] ||= {}
-        @store[:usage][k][n] || []
-      end
-
-      def add_for_flow(flow, description, options = {})
-        k = flow_key(flow)
-        @store[:flow][k] ||= []
-        [description].flatten.each do |d|
-          @store[:flow][k] << d
-        end
-      end
-
-      def add_for_test_definition(test, description, option = {})
-        n = name_key(test)
-        @store[:test][n] ||= []
-        [description].flatten.each do |d|
-          @store[:test][n] << d
-        end
-      end
-
-      def add_for_test_usage(test, flow, description, option = {})
-        k = flow_key(flow)
-        n = name_key(test)
-        @store[:usage][k] ||= {}
-        @store[:usage][k][n] ||= []
-        [description].flatten.each do |d|
-          @store[:usage][k][n] << d
-        end
-      end
-
-      private
-
-      def flow_key(flow)
-        Pathname.new(flow).basename('.*').to_s
-      end
-
-      def name_key(name)
-        name.to_s.downcase
-      end
-    end
-  end
-end
+module OrigenTesters
+  module Parser
+    class DescriptionLookup
+      def initialize
+        @store = { flow: {}, test: {}, usage: {} }
+      end
+
+      def for_flow(name, options = {})
+        k = flow_key(name)
+        @store[:flow][k] || []
+      end
+
+      def for_test_definition(name, options = {})
+        n = name_key(name)
+        @store[:test][n] || []
+      end
+
+      def for_test_usage(name, flow, options = {})
+        k = flow_key(flow)
+        n = name_key(name)
+        @store[:usage][k] ||= {}
+        @store[:usage][k][n] || []
+      end
+
+      def add_for_flow(flow, description, options = {})
+        k = flow_key(flow)
+        @store[:flow][k] ||= []
+        [description].flatten.each do |d|
+          @store[:flow][k] << d
+        end
+      end
+
+      def add_for_test_definition(test, description, option = {})
+        n = name_key(test)
+        @store[:test][n] ||= []
+        [description].flatten.each do |d|
+          @store[:test][n] << d
+        end
+      end
+
+      def add_for_test_usage(test, flow, description, option = {})
+        k = flow_key(flow)
+        n = name_key(test)
+        @store[:usage][k] ||= {}
+        @store[:usage][k][n] ||= []
+        [description].flatten.each do |d|
+          @store[:usage][k][n] << d
+        end
+      end
+
+      private
+
+      def flow_key(flow)
+        Pathname.new(flow).basename('.*').to_s
+      end
+
+      def name_key(name)
+        name.to_s.downcase
+      end
+    end
+  end
+end