origen 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24fa93bb3395c5d472af5111b4cf2c7424ddb8fb
-  data.tar.gz: 2115fdaa3ad10e8c5bad07e0693c1aea2f9484d6
+  metadata.gz: 437a40756e6194c3308c3044388d48c4c0b0c31c
+  data.tar.gz: d9341d81f27c7bbbf014fe26844d67f53bc1facf
 SHA512:
-  metadata.gz: 8e2ced12f38f092dfbcc1ff1da469aca527de65decc950050d9b482b4059d1c5613ed8fb627c509519f6275f0c43db4c21d9c20c34012345654ef1006a45d2df
-  data.tar.gz: 36270d0d55c0f772399a9afbf8380bdc535aa8ad0c047734ab032df1913101c82bb48845e2c56129e757b99c5782e31eca15f7583269a062ff9cc4fa9e8187b0
+  metadata.gz: 8ce734ee2bd0f466c05c38c7a9205ac7bfbee4165780bfdca9c57f4eb3390b49819882a43e0c24f512f4b65c866a2edf5c057b6c6eb4015d7bea48c1cbbfa3a5
+  data.tar.gz: 967eafac1a53b990d7b8b5f689278f27527ece71e76cfd6db63faecd7d8b4dbce5a8c87c96c037c1451925267b52d5216179f1108d06183c9dd21ad65188f996

data/config/version.rb

@@ -1,6 +1,6 @@
 module Origen
   MAJOR = 0
-  MINOR = 30
+  MINOR = 31
   BUGFIX = 0
   DEV = nil
 

data/lib/origen.rb

@@ -27,6 +27,7 @@ unless defined? RGen::ORIGENTRANSITION
   require 'option_parser/optparse'
   require 'bundler'
   require 'origen/undefined'
+  require 'origen/componentable'
 
   module Origen
     autoload :Features,          'origen/features'
@@ -789,4 +790,6 @@ unless defined? RGen::ORIGENTRANSITION
   # outside the scope of an Origen command
   require 'origen/global_methods'
   include Origen::GlobalMethods
+
+  require 'origen/components'
 end

data/lib/origen/application.rb

@@ -795,7 +795,18 @@ END
         end
         @target_instantiated = true
         Origen.mode = :debug if options[:force_debug]
-        listeners_for(:on_create).each(&:on_create)
+        listeners_for(:on_create).each do |obj|
+          unless obj.is_a?(Origen::SubBlocks::Placeholder)
+            if obj.try(:is_a_model_and_controller?)
+              m = obj.model
+              c = obj.controller
+              m.on_create if m.respond_to_directly?(:on_create)
+              c.on_create if c.respond_to_directly?(:on_create)
+            else
+              obj.on_create
+            end
+          end
+        end
         @on_create_called = true
         # Keep this within the load_event to ensure any objects that are further instantiated objects
         # will be associated with (and cleared out upon reload of) the current target

data/lib/origen/componentable.rb

@@ -0,0 +1,649 @@
+module Origen
+  # Protologism taking after Enumerable, stating that this object can
+  # behave like an Origen Component
+  module Componentable
+    # Custom Componentable Errors
+
+    # Raised whenever a component name tries to be added but it already exists
+    class NameInUseError < StandardError
+    end
+
+    # Raised whenever a component name is used for something but does not exist.
+    class NameDoesNotExistError < StandardError
+    end
+
+    # Raised for everything else.
+    class Error < StandardError
+    end
+
+    # In order for Origen to bootstrap using a generic callback, we'll work a bit backwards.
+    # When this module is included by an 'includer', it will give
+    def self.included(othermod)
+      add_included_callback(othermod)
+    end
+
+    # These are split in case the included module actually has an :included method defined and the user wants
+    # to bootstrap setting up the add_included_callback manually.
+    # Note that someone making a module to house a Componentable class is very unlikely to do this, but it could
+    # still happen.
+    def self.add_included_callback(othermod)
+      othermod.define_singleton_method(:origen_model_init) do |klass, options = {}|
+        Origen::Componentable.init_parent_class(klass, self)
+      end
+    end
+
+    # When Origen's model initializer is included, all Componentable objects will be automatically booted.
+    def self.origen_model_init(klass, options = {})
+      Origen::Componentable.init_includer_class(klass)
+    end
+
+    # Initializes the class that included Componentable (the 'includer').
+    # All of the singleton methods will be added per Ruby, but the includer still needs to be booted by:
+    #  1) Creating and initializing the instance attribute (_componentable_container)
+    #  2) Defining a method to get the container directly.
+    #     For example, the Component class will automatically have a :components method that references the
+    #     _componentable_container.
+    def self.init_includer_class(klass_instance)
+      klass_instance.instance_variable_set(:@_componentable_container, {}.with_indifferent_access)
+      klass_instance.class.class_eval do
+        attr_reader :_componentable_container
+
+        define_method Origen::Componentable.componentable_names(klass_instance)[:plural] do
+          @_componentable_container
+        end
+      end
+    end
+
+    def self.parent_class_evaled?(parent_class, includer_singleton_name)
+      evaled = parent_class.instance_variable_get("@_#{includer_singleton_name}_evaled")
+      if evaled.nil?
+        # Check that this class isn't inheriting from another class that uses Componentable things.
+        # If so, the API is inherited and is fine, so set the evaled value for that class to true.
+        parent_class.ancestors.each do |ancestor|
+          if ancestor.instance_variable_get("@_#{includer_singleton_name}_evaled")
+            parent_class.instance_variable_set("@_#{includer_singleton_name}_evaled", true)
+            evaled = true
+            break
+          end
+        end
+      end
+      evaled
+    end
+
+    def self.init_parent_class(parent_class, includer_class)
+      # includer_single_name = begin
+      #  if includer_class.name.include?('::')
+      #    name = includer_class.name.split('::').last.underscore
+      #  else
+      #    name = includer_class.name.underscore
+      #  end
+      # end
+      # includer_plural_name = Origen::Componentable.componentable_names(includer_class)[:plural]
+
+      names = Componentable.componentable_names(includer_class)
+      includer_single_name = names[:singleton]
+      includer_plural_name = names[:plural]
+
+      unless parent_class.is_a?(Class)
+        inc = parent_class.instance_variable_set("@_#{includer_single_name}".to_sym, includer_class.new)
+        inc.parent = parent_class
+        parent_class = parent_class.class
+      end
+
+      # If the includer's singleton name is taken (i.e., the parent already has a method <includer_single_name>),
+      # raise an error since the 'proper' way to interact with the includer directly is from this method.
+      if !Origen::Componentable.parent_class_evaled?(parent_class, includer_single_name) && parent_class.method_defined?(includer_single_name.to_sym)
+        fail Origen::Componentable::Error, "Class #{parent_class.name} provides a method :#{includer_single_name} already. Cannot include Componentable class #{includer_class.name} in this object!"
+      end
+
+      # for everything that's not the singleton name method or the @_<singleton_name> instance variable, having the method
+      # already exists is a warning, not an error.
+      methods_to_add = [
+        includer_plural_name.to_sym,
+
+        # Add methods
+        "add_#{includer_single_name}".to_sym,
+        "add_#{includer_plural_name}".to_sym,
+
+        # Listing/Querying methods
+        "list_#{includer_plural_name}".to_sym,
+        "#{includer_plural_name}_of_class".to_sym,
+        "#{includer_plural_name}_instances_of".to_sym,
+        "#{includer_plural_name}_of_type".to_sym,
+        "#{includer_single_name}?".to_sym,
+        "has_#{includer_single_name}?".to_sym,
+
+        # Enumeration methods
+        "each_#{includer_single_name}".to_sym,
+        "all_#{includer_plural_name}".to_sym,
+        "select_#{includer_plural_name}".to_sym,
+        "select_#{includer_single_name}".to_sym,
+
+        # Copying/Moving methods
+        "copy_#{includer_single_name}".to_sym,
+        "copy_#{includer_plural_name}".to_sym,
+        "move_#{includer_single_name}".to_sym,
+        "move_#{includer_plural_name}".to_sym,
+
+        # Deleting individual item methods
+        "delete_#{includer_single_name}".to_sym,
+        "delete_#{includer_plural_name}".to_sym,
+        "remove_#{includer_single_name}".to_sym,
+        "remove_#{includer_plural_name}".to_sym,
+        "delete_#{includer_single_name}!".to_sym,
+        "delete_#{includer_plural_name}!".to_sym,
+        "remove_#{includer_single_name}!".to_sym,
+        "remove_#{includer_plural_name}!".to_sym,
+
+        # Deleting all items methods
+        "delete_all_#{includer_plural_name}".to_sym,
+        "clear_#{includer_plural_name}".to_sym,
+        "remove_all_#{includer_plural_name}".to_sym
+      ]
+      unless Origen::Componentable.parent_class_evaled?(parent_class, includer_single_name)
+        methods_to_add.each do |m|
+          if parent_class.method_defined?(m)
+            Origen.log.warning "Componentable: Parent class #{parent_class.name} already defines a method #{m}. This method will not be used by Componentable"
+          end
+        end
+        parent_class.instance_variable_set("@_#{includer_single_name}_evaled".to_sym, true)
+      end
+
+      parent_class.class_eval do
+        # Note that all of these just trace back to the root method.
+
+        # Define the root method (singleton-named method)
+        # If any arguments are given, it behaves as an :add method.
+        # Otherwise, it returns the underlying object itself.
+        define_method includer_single_name.to_sym do |*args, &block|
+          if args.size == 0
+            # No arguments, so just return the class instance
+            instance_variable_get("@_#{includer_single_name}".to_sym)
+          else
+            # Arguments were provided, so treating this as an :add attempt
+            instance_variable_get("@_#{includer_single_name}".to_sym).add(*args, &block)
+          end
+        end
+
+        # Define the plural-named method.
+        # If arguments are given, then it behaves as an :add attempt, with or without a block.
+        # If a block is given without any arguments, it will behave as an :each operation and call the block.
+        # if no arguments are given, it will return the underlying HASH (not the object).
+        #   This allows for plural_name[name] to
+        define_method "#{includer_plural_name}".to_sym do |*args, &block|
+          if block && args.size == 0
+            instance_variable_get("@_#{includer_single_name}".to_sym).each(&block)
+          elsif args.size == 0
+            instance_variable_get("@_#{includer_single_name}".to_sym)._componentable_container
+          else
+            instance_variable_get("@_#{includer_single_name}".to_sym).add(*args, &block)
+          end
+        end
+
+        # define the various 'add' methods
+        # what we'll actually do is just define one method then alias all the others together.
+        # Currently, this includes:
+        #   <includer_plural_name>, add_<includer_single_name>, add_
+        define_method "add_#{includer_single_name}".to_sym do |name, options = {}, &block|
+          instance_variable_get("@_#{includer_single_name}".to_sym).add(name, options, &block)
+        end
+        alias_method "add_#{includer_plural_name}".to_sym, "add_#{includer_single_name}".to_sym
+
+        # define listing and getting methods
+        define_method "list_#{includer_plural_name}".to_sym do
+          instance_variable_get("@_#{includer_single_name}".to_sym).list
+        end
+
+        # define the querying object types
+        define_method "#{includer_plural_name}_of_class".to_sym do |klass, options = {}|
+          instance_variable_get("@_#{includer_single_name}".to_sym).instances_of(klass, options)
+        end
+        alias_method "#{includer_plural_name}_instances_of".to_sym, "#{includer_plural_name}_of_class".to_sym
+        alias_method "#{includer_plural_name}_of_type".to_sym, "#{includer_plural_name}_of_class".to_sym
+
+        # define the querying instance existance
+        define_method "#{includer_single_name}?".to_sym do |name|
+          instance_variable_get("@_#{includer_single_name}".to_sym).has?(name)
+        end
+        alias_method "has_#{includer_single_name}?".to_sym, "#{includer_single_name}?".to_sym
+
+        # define some of commonly used enumerate methods
+        define_method "each_#{includer_single_name}".to_sym do |&block|
+          instance_variable_get("@_#{includer_single_name}".to_sym).each(&block)
+        end
+        alias_method "all_#{includer_plural_name}".to_sym, "each_#{includer_single_name}".to_sym
+
+        define_method "select_#{includer_plural_name}".to_sym do |&block|
+          instance_variable_get("@_#{includer_single_name}".to_sym).select(&block)
+        end
+        alias_method "select_#{includer_single_name}".to_sym, "select_#{includer_plural_name}".to_sym
+
+        # define the copying/moving methods
+        define_method "copy_#{includer_single_name}".to_sym do |to_copy, to_location, options = {}|
+          instance_variable_get("@_#{includer_single_name}".to_sym).copy(to_copy, to_location, options)
+        end
+        alias_method "copy_#{includer_plural_name}".to_sym, "copy_#{includer_single_name}".to_sym
+
+        define_method "move_#{includer_single_name}".to_sym do |to_move, to_location|
+          instance_variable_get("@_#{includer_single_name}".to_sym).move(to_move, to_location)
+        end
+        alias_method "move_#{includer_plural_name}".to_sym, "move_#{includer_single_name}".to_sym
+
+        # define the deleting single instance methods
+        define_method "delete_#{includer_single_name}".to_sym do |name|
+          instance_variable_get("@_#{includer_single_name}".to_sym).delete(name)
+        end
+        alias_method "delete_#{includer_plural_name}".to_sym, "delete_#{includer_single_name}".to_sym
+        alias_method "remove_#{includer_single_name}".to_sym, "delete_#{includer_single_name}".to_sym
+        alias_method "remove_#{includer_plural_name}".to_sym, "delete_#{includer_single_name}".to_sym
+
+        define_method "delete_#{includer_single_name}!".to_sym do |name|
+          instance_variable_get("@_#{includer_single_name}".to_sym).delete!(name)
+        end
+        alias_method "delete_#{includer_plural_name}!".to_sym, "delete_#{includer_single_name}!".to_sym
+        alias_method "remove_#{includer_single_name}!".to_sym, "delete_#{includer_single_name}!".to_sym
+        alias_method "remove_#{includer_plural_name}!".to_sym, "delete_#{includer_single_name}!".to_sym
+
+        # define the deleting all instances methods
+        define_method "delete_all_#{includer_plural_name}".to_sym do
+          instance_variable_get("@_#{includer_single_name}".to_sym).delete_all
+        end
+        alias_method "clear_#{includer_plural_name}".to_sym, "delete_all_#{includer_plural_name}".to_sym
+        alias_method "remove_all_#{includer_plural_name}".to_sym, "delete_all_#{includer_plural_name}".to_sym
+      end
+    end
+
+    # All of these are generic names and the instantiation. When included, Componentable will add aliases to these
+    # methods onto the includer's parent. For example:
+    #   <includer>.has? becomes $dut.has_<include>?
+    #   <includer>.delete(name_to_delete) becomes $dut.delete_<includer>(name_to_delete)
+    #   etc. etc.
+    # def self.parent_or_owner(includer)
+    #  return includer.parent if includer.parent
+    #  return includer.owner if includer.owner
+    #  nil
+    # end
+
+    # Gets the plural name of the class.
+    def _plural_name
+      @plural_name || begin
+        @plural_name = Origen::Componentable.componentable_names(self)[:plural]
+        @singleton_name = Origen::Componentable.componentable_names(self)[:singleton]
+      end
+    end
+
+    # Gets the singleton name of the class.
+    def _singleton_name
+      @singleton_name || begin
+        @plural_name = Origen::Componentable.componentable_names(self)[:plural]
+        @singleton_name = Origen::Componentable.componentable_names(self)[:singleton]
+      end
+    end
+
+    # Gets the parent of the includer class.
+    def parent
+      @parent
+    end
+
+    # Sets the parent of the includer class
+    def parent=(p)
+      @parent = p
+    end
+
+    def self.componentable_names(klass)
+      unless klass.is_a?(Class)
+        # If we were given an instance of a class, get its actual class.
+        klass = klass.class
+      end
+      names = {}
+
+      # Evaluate the singleton name. This will be the class name or the class constant
+      #  COMPONENTABLE_SINGLETON_NAME, if it's defined.
+      # The only corner case here is if the class is anonymous, then a COMPONENTABLE_SINGLETON_NAME is required.
+      if klass.const_defined?(:COMPONENTABLE_SINGLETON_NAME)
+        names[:singleton] = klass.const_get(:COMPONENTABLE_SINGLETON_NAME).downcase.to_sym
+      else
+        # Check if this is an anonymous class. If so, complain that COMPONENTABLE_SINGLETON_NAME is required
+        if !klass.respond_to?(:name) || klass.name.nil? # || klass.name.start_with?('#<Class:')
+          if klass.const_defined?(:COMPONENTABLE_PLURAL_NAME)
+            # Have a more specific error saying the plural name was found but isn't sufficient.
+            fail Origen::Componentable::Error, 'Anonymous classes that include the Componentable module must define COMPONENTABLE_SINGLETON_NAME, even if COMPONENTABLE_PLURAL_NAME is defined'
+          else
+            fail Origen::Componentable::Error, 'Anonymous classes that include the Componentable module must define COMPONENTABLE_SINGLETON_NAME'
+          end
+        else
+          if klass.name.include?('::')
+            names[:singleton] = klass.name.split('::').last.underscore.to_sym
+          else
+            names[:singleton] = klass.name.underscore.to_sym
+          end
+        end
+      end
+
+      if klass.const_defined?(:COMPONENTABLE_PLURAL_NAME)
+        name = klass.const_get(:COMPONENTABLE_PLURAL_NAME).downcase.to_sym
+
+        # do a quick check to make sure that the plural name and singleton name aren't set to the same thing
+        if name == names[:singleton]
+          fail Origen::Componentable::Error, "Componentable including class cannot define both COMPONENTABLE_SINGLETON_NAME and COMPONENTABLE_PLURAL_NAME to '#{name}'"
+        end
+      else
+        name = names[:singleton].to_s
+
+        # Only deal with a few cases here, I'm not interested in figuring out every
+        # english rule to pluralize everything. Examples:
+        #   deer => deers (not deer, though technically I think deers is actually a word, but an odd one)
+        #   goose => gooses (not geese)
+        #   dwarf => dwarfs (not dwarves)
+        # If the user is concerned about this, they can supply their own
+        # name pluralizing their class name directly.
+        if name.match(/is$/)
+          #   analysis => analyses
+          name.gsub!(/is$/, 'es')
+        elsif name.match(/[sxz]$|sh$|ch$/)
+          # if the names ends with s, h, ch, sh, x, z: append 'es'. Examples:
+          #   bus => buses
+          #   stress => stresses
+          #   box => boxes
+          #   branch => branches
+          #   brush => brushes
+          #   tax => taxes
+          #   buzz => buzzes
+          name += 'es'
+        elsif name.match(/on$/)
+          #   criterion => criteria
+          name.gsub!(/on$/, 'a')
+        else
+          # just append a single 's'. Examples:
+          #   component => components
+          #   sub_block => sub_blocks
+          #   tool => tools
+          name += 's'
+        end
+        name = name.to_sym
+      end
+      names[:plural] = name
+
+      names
+    end
+
+    def add(name, options = {}, &block)
+      instances = _split_by_instances(name, options, &block)
+      return_instances = []
+      instances.each do |n, opts|
+        return_instances << _add(n, opts)
+      end
+
+      return_instances.size == 1 ? return_instances.first : return_instances
+    end
+
+    def _split_by_instances(name, options = {}, &block)
+      if !options[:instances].nil? && options[:instances] > 1
+        instances = {}
+        options[:instances].times do |i|
+          opts = {}
+
+          # merge the given options with any that are overriden with the block.
+          if block_given?
+            collector = Origen::Utility::Collector.new
+            yield collector
+            options.merge!(collector.store)
+          end
+
+          # go through the options one by one now and make sure that each element is either an array to be split
+          # by the instances, or is a single object. If not one of these two, complain.
+          options.each do |key, val|
+            if val.is_a?(Array)
+              if val.size == 1
+                # An array with a single element. This is fine. Just take that single element as the contents.
+                # Note: this is a workaround for the corner case of wanting to pass in an array as an option
+                # with a size that doesn't match the number of instances.
+                opts[key] = val.first
+              elsif val.size != options[:instances]
+                # The number of elements in the option doesn't match the number of instances, and it greater than
+                # a single element.
+                fail Origen::Componentable::Error, "Error when adding #{name}: size of given option :#{key} (#{val.size}) does not match the number of instances specified (#{options[:instances]})"
+              else
+                # use the index number to grab the correct value for this instance
+                opts[key] = val[i]
+              end
+            else
+              opts[key] = val
+            end
+          end
+
+          # set the instance's name and add it and its options to the list to be added
+          instances["#{name}#{i}".to_sym] = opts
+        end
+        instances
+      else
+        if block_given?
+          collector = Origen::Utility::Collector.new
+          yield collector
+          options.merge!(collector.store)
+        end
+        { name => options }
+      end
+    end
+
+    # Adds a new item to the componentable container.
+    # @note All options added will be passed to the subclasses instantiation.
+    # @note The options is only valid for the stock :add method.
+    # @note Any extra options provided are still passed to the subclasses instantiation.
+    # @param name [Symbol] Name to reference the new component object.
+    # @param options [Hash] Customizations for both the add method and for the class's instantiation.
+    # @option options [Class, String] class_name The class to instaniate the component at :name as.
+    # @return [ComponentableObject] The instantiated class at :name
+    # @raise [Origen::Componentable::NameInUseError] Raised if :name already points to a component.
+    def _add(name, options = {}, &block)
+      # Add the name and parent to the options if they aren't already given
+      # If the parent isn't available on the includer class, it will remain nil.
+      options = {
+        name:   name,
+        parent: parent
+      }.merge(options)
+
+      if block_given?
+        collector = Origen::Utility::Collector.new
+        yield collector
+        options.merge!(collector.store)
+      end
+
+      # Instantiate the class. This will place the object in the @_componentable_container at the indicated name
+      _instantiate_class(name, options)
+
+      # Create an accessor for the new item, if indicated to do so.
+      _push_accessor(name, options)
+
+      @_componentable_container[name]
+    end
+
+    def _instantiate_class(name, options)
+      if @_componentable_container.key?(name)
+        fail Origen::Componentable::NameInUseError, "#{_singleton_name} name :#{name} is already in use."
+      end
+
+      if options[:class_name]
+        class_name = options.delete(:class_name)
+
+        unless Object.const_defined?(class_name.to_s)
+          fail Origen::Componentable::NameDoesNotExistError, "class_name option '#{class_name}' cannot be found"
+        end
+
+        # Instantiate the given class
+        if class_name.is_a?(String)
+          @_componentable_container[name] = eval(class_name).new(options)
+        else
+          @_componentable_container[name] = class_name.new(options)
+        end
+      else
+        # Instantiate a standard Component if no class given
+        @_componentable_container[name] = Origen::Component::Default.new(options)
+      end
+      @_componentable_container[name]
+    end
+
+    def _push_accessor(name, options)
+      if parent
+        def push_accessor(name)
+          if parent.respond_to?(name.to_sym)
+            Origen.log.warn("Componentable: #{_singleton_name} is trying to add an accessor for item :#{name} to parent #{parent.class.name} but that method already exist! No accessor will be added.")
+          else
+            parent.send(:eval, "define_singleton_method :#{name.to_sym} do; #{_singleton_name}[:#{name}]; end")
+          end
+        end
+
+        if self.class.const_defined?(:COMPONENTABLE_ADDS_ACCESSORS) && self.class.const_get(:COMPONENTABLE_ADDS_ACCESSORS)
+          if parent.respond_to?(:disable_componentable_accessors)
+            if parent.method(:disable_componentable_accessors).arity >= 1
+              unless parent.disable_componentable_accessors(self.class)
+                push_accessor(name)
+              end
+            else
+              unless parent.disable_componentable_accessors
+                push_accessor(name)
+              end
+            end
+          else
+            push_accessor(name)
+          end
+        end
+      end
+    end
+
+    # List the items in the componentable container
+    # @return [Array<Symbol>] Componentable container item names.
+    def list
+      @_componentable_container.keys
+    end
+
+    # Checks if a component exist in the componentable container.
+    # @param name [Symbol] Name to query existance of.
+    # @return [true, false] True if :name exists, False otherwise.
+    def has?(name)
+      @_componentable_container.include?(name)
+    end
+
+    def [](name)
+      @_componentable_container[name]
+    end
+
+    # Copies the component at :to_copy to :to_location. Default is to deep copy (i.e. clone)
+    # the to_copy, resulting in two independent components.
+    # @param to_copy [Symbol] Name of the component to copy.
+    # @param to_location [Symbol] Name to copy to.
+    # @param options [Hash] Customization options.
+    # @option options [true, false] :deep_copy (true) Indicates whether to deep copy (clone) the component or just copy the a reference to the component.
+    # @option options [true, false] :override (false) Indicates if the object at :to_location should be overridden if it already exists.
+    # @returns [Symbol] The new object (or reference to) at :to_location.
+    # @raise [Origen::Componentable::NameInUseError] Raised if :to_location is already in use and the :override option is not specified.
+    # @raise [Origen::Componentable::NameDoesNotExistsError] Raised if :to_copy name does not exists.
+    def copy(to_copy, to_location, options = {})
+      deep_copy = options.key?(:deep_copy) ? options[:deep_copy] : true
+      overwrite = options[:overwrite] || false
+
+      if @_componentable_container.key?(to_location) && !overwrite
+        # The copy location already exists and override was not specified
+        fail Origen::Componentable::NameInUseError, "#{_singleton_name} name :#{to_location} is already in use"
+      end
+
+      unless @_componentable_container.key?(to_copy)
+        # The to copy name doesn't exist
+        fail Origen::Componentable::NameDoesNotExistError, "#{_singleton_name} name :#{to_copy} does not exist"
+      end
+
+      if deep_copy
+        @_componentable_container[to_location] = @_componentable_container[to_copy].clone
+      else
+        @_componentable_container[to_location] = @_componentable_container[to_copy]
+      end
+    end
+
+    # Moves a component object from one name to another.
+    # @param to_move [Symbol] Component name to move elsewhere.
+    # @param new_name [Symbol] New name to give to the component from :to_move.
+    # @return [Symbol] The component moved.
+    # @raise [Origen::Componentable::NameInUseError] Raised if :new_name is already in use and the :override option is not specified.
+    # @raise [Origen::Componentable::NameDoesNotExistsError] Raised if :to_move name does not exists.
+    def move(to_move, new_name, options = {})
+      overwrite = options[:overwrite] || false
+
+      if @_componentable_container.key?(new_name) && !overwrite
+        # The move location already exists and override was not specified
+        fail Origen::Componentable::NameInUseError, "#{_singleton_name} name :#{new_name} is already in use"
+      end
+
+      unless @_componentable_container.key?(to_move)
+        # The to_move name doesn't exist
+        fail Origen::Componentable::NameDoesNotExistError, "#{_singleton_name} name :#{to_move} does not exist"
+      end
+
+      to_move_object = @_componentable_container.delete(to_move)
+      @_componentable_container[new_name] = to_move_object
+    end
+
+    # Deletes a component from the componentable container
+    # @param name [Symbol] Name of component to delete
+    # @return [Hash(Symbol, <ComponentableItem>)]  containing the name of the component deleted and its component.
+    # @raise [Origen::Componentable::NameDoesNotExistsError] Raised if :to_copy name does not exists.
+    def delete(to_delete)
+      obj = delete!(to_delete)
+      fail Origen::Componentable::NameDoesNotExistError, "#{_singleton_name} name :#{to_delete} does not exist" if obj.nil?
+      obj
+    end
+    alias_method :remove, :delete
+
+    # Same as the :delete method but raises an error if :name doesn't exists.
+    # @param name [Symbol] Name oof the component to delete.
+    # @return [Hash(Symbol, <ComponentableItem>), nil] Hash containing the name of the component deleted and its component. Nil if the name doesn't exist.
+    def delete!(to_delete)
+      need_to_undef = parent && parent.respond_to?(to_delete) && parent.send(to_delete).eql?(@_componentable_container[to_delete])
+
+      obj = @_componentable_container.delete(to_delete)
+
+      if need_to_undef
+        parent.instance_eval "undef #{to_delete}"
+      end
+
+      obj
+    end
+    alias_method :remove!, :delete!
+
+    # Deletes all of the components in the container.
+    # @return [Hash(Symbol, <ComponentableItem>)] Hash containing all of the deleted items.
+    def delete_all
+      # delete individual objects one by one, making sure to delete all accessors as well
+      returns = {}
+      @_componentable_container.each do |key, val|
+        delete!(key)
+        returns[key] = val
+      end
+      returns
+    end
+    alias_method :clear, :delete_all
+    alias_method :remove_all, :delete_all
+
+    # Locates all names whose object is a :class_name object.
+    # @param class_name [Class, Instance of Class] Class to search componentable container for. This can either be the class name, or can be an instance of the class to search for.
+    # @return [Array <Strings>] An array listing all of the names in the componentable container which are a :class_name.
+    def instances_of(class_name, options = {})
+      unless class_name.is_a?(Class)
+        # class_name is actually an instance of the class to search for, not the class itself.
+        class_name = class_name.class
+      end
+      @_componentable_container.select do |name, component|
+        component.is_a?(class_name)
+      end.keys
+    end
+
+    # Implementation for an each method
+    def each(&block)
+      @_componentable_container.each(&block)
+    end
+
+    # Implementation for a select method
+    def select(&block)
+      @_componentable_container.select(&block)
+    end
+  end
+end

data/lib/origen/components.rb

@@ -0,0 +1,34 @@
+module Origen
+  # API for dealing with instantiating and keeping track of components or
+  # 'component-like object' (e.g. sub blocks).
+  # This API can be included as a mixin and extended further extended by the includer
+  # to get the top-level component behavior while providing more refined usage at the same time.
+  module Component
+    # Componentable Component class. This is the general purpose container to just 'add a thing'
+    class Component
+      include Origen::Componentable
+
+      COMPONENTABLE_ADDS_ACCESSORS = true
+
+      # Kind of ironic really, but since we're auto-including this when Origen::Model is included,
+      # we can't include Origen::Model here or else we'll get a circular dependency.
+      # Note that the parent will still initialize correctly, but we need to initialize Components manually.
+      # I.e, the parent will get methods :component, :add_components, :components, etc., but the Component object
+      # won't be initialized so everything will fail.
+      def initialize
+        Origen::Componentable.init_includer_class(self)
+      end
+    end
+
+    # Default class instantiate if the class_name is not provided
+    class Default
+      include Origen::Model
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+    end
+  end
+end

data/lib/origen/controller.rb

@@ -78,6 +78,20 @@ module Origen
       end
     end
 
+    # When compared to another object, a controller will consider itself equal if either the controller
+    # or its model match the given object
+    def ==(obj, options = {})
+      if obj.is_a?(Origen::SubBlocks::Placeholder)
+        obj = obj.materialize
+      end
+      if options[:called_from_model]
+        super(obj)
+      else
+        super(obj) || model == obj
+      end
+    end
+    alias_method :equal?, :==
+
     # Means that when dealing with a controller/model pair, you can
     # always call obj.model and obj.controller to get the one you want,
     # regardless of the one you currently have.

data/lib/origen/model.rb

@@ -12,6 +12,7 @@ module Origen
     included do
       attr_writer :ip_name
       attr_accessor :version
+      attr_accessor :parent
       attr_reader :controller
 
       include Origen::ModelInitializer
@@ -32,6 +33,7 @@ module Origen
       include Origen::PowerDomains
       include Origen::Clocks
       include Origen::Model::Exporter
+      include Origen::Component
     end
 
     module ClassMethods
@@ -52,6 +54,12 @@ module Origen
       true
     end
 
+    # Returns true if the instance is an Origen::Model that is wrapped
+    # in a controller
+    def is_a_model_and_controller?
+      !!controller
+    end
+
     # Returns true if the model is the current DUT/top-level model
     def is_top_level?
       Origen.top_level == self
@@ -66,6 +74,18 @@ module Origen
       self
     end
 
+    def ==(obj)
+      if obj.is_a?(Origen::SubBlocks::Placeholder)
+        obj = obj.materialize
+      end
+      if controller
+        super(obj) || controller.send(:==, obj, called_from_model: true)
+      else
+        super(obj)
+      end
+    end
+    alias_method :equal?, :==
+
     def log
       Origen.log
     end
@@ -121,10 +141,13 @@ module Origen
       klass = self.class
       while klass != Object
         controller_class = "#{klass}Controller"
-        if eval("defined? #{controller_class}")
-          return eval(controller_class)
-        elsif eval("defined? ::#{controller_class}")
-          return eval("::#{controller_class}")
+        unless controller_class.start_with?('#<Class')
+          # klass is an anonymous class. Can't support automatic resolution with anonymous classes
+          if eval("defined? #{controller_class}")
+            return eval(controller_class)
+          elsif eval("defined? ::#{controller_class}")
+            return eval("::#{controller_class}")
+          end
         end
         klass = klass.superclass
       end

data/lib/origen/model/exporter.rb

@@ -9,12 +9,13 @@ module Origen
           include_timestamp:  true,
           file_path:          nil
         }.merge(options)
+        # file_path is for internal use, don't pass it from the application, use the :dir option if you
+        # want to change where the exported files are
         if options[:file_path]
           file = File.join(options[:file_path], "#{name}.rb")
         else
-          file = export_path(name)
+          file = export_path(name, options)
         end
-        file += '.rb' unless file =~ /.rb$/
         file = Pathname.new(file)
         FileUtils.rm_rf(file.sub_ext('').to_s) if File.exist?(file.sub_ext('').to_s)
         FileUtils.rm_rf(file.to_s) if File.exist?(file.to_s)
@@ -73,9 +74,18 @@ module Origen
       end
 
       def import(name, options = {})
-        path = export_path(name)
-        require path
-        extend "#{Origen.app.namespace.underscore.camelcase}::#{name.to_s.camelcase}".constantize
+        path = export_path(name, options)
+        if File.exist?(path)
+          require path
+          extend "#{Origen.app.namespace.underscore.camelcase}::#{name.to_s.camelcase}".constantize
+          true
+        else
+          if options[:allow_missing]
+            false
+          else
+            fail "The import for #{name} could not be found at #{path}"
+          end
+        end
       end
 
       private
@@ -115,20 +125,20 @@ module Origen
         end
         file.puts '# rubocop:disable all'
         indent = 0
-        export_module_names_from_path(file.path).each do |name|
+        export_module_names_from_path(file.path, options).each do |name|
           file.puts((' ' * indent) + "module #{name}")
           indent += 2
         end
         yield indent
-        export_module_names_from_path(file.path).each do |name|
+        export_module_names_from_path(file.path, options).each do |name|
           indent -= 2
           file.puts((' ' * indent) + 'end')
         end
         file.puts '# rubocop:enable all'
       end
 
-      def export_module_names_from_path(name)
-        name = name.sub("#{export_dir}/", '').sub('.rb', '')
+      def export_module_names_from_path(name, options = {})
+        name = name.sub("#{export_dir(options)}/", '').sub('.rb', '')
         name.split(/[\/\\]/).map do |n|
           if n == ''
             nil
@@ -138,12 +148,16 @@ module Origen
         end.compact
       end
 
-      def export_path(name)
-        File.join(export_dir, Origen.app.namespace.to_s.underscore, name.to_s.underscore)
+      def export_path(name, options = {})
+        if options.key?(:namespace) && !options[:namespace]
+          File.join(export_dir(options), "#{name.to_s.underscore}.rb")
+        else
+          File.join(export_dir(options), (options[:namespace] || Origen.app.namespace).to_s.underscore, "#{name.to_s.underscore}.rb")
+        end
       end
 
-      def export_dir
-        File.join(Origen.root, 'vendor', 'lib', 'models')
+      def export_dir(options = {})
+        options[:dir] || File.join(Origen.root, 'vendor', 'lib', 'models')
       end
 
       def export_pin(id, pin, options = {})
@@ -196,10 +210,19 @@ module Origen
         indent = ' ' * (options[:indent] || 0)
         file = File.join(options[:file_path].sub_ext(''), "#{id}.rb")
         local_file = file.to_s.sub("#{export_dir}/", '')
-        line = indent + "model.sub_block :#{id}, file: '#{local_file}'"
+        line = indent + "model.sub_block :#{id}, file: '#{local_file}', lazy: true"
         unless block.base_address == 0
           line << ", base_address: #{block.base_address.to_hex}"
         end
+        block.custom_attrs.each do |key, value|
+          if value.is_a?(Symbol)
+            line << ", #{key}: :#{value}"
+          elsif value.is_a?(String)
+            line << ", #{key}: '#{value}'"
+          else
+            line << ", #{key}: #{value}"
+          end
+        end
         block.export(id, options.merge(file_path: options[:file_path].sub_ext('').to_s))
         line
       end

data/lib/origen/model_initializer.rb

@@ -21,6 +21,16 @@ module Origen
           parent = options.delete(:parent)
           x.parent = parent if parent
         end
+
+        x.class.included_modules.each do |mod|
+          mod.send(:origen_model_init, x) if mod.respond_to?(:origen_model_init)
+          mod.constants.each do |constant|
+            if mod.const_defined?(constant)
+              mod.const_get(constant).send(:origen_model_init, x) if mod.const_get(constant).respond_to?(:origen_model_init)
+            end
+          end
+        end
+
         options.each do |k, v|
           x.send(:instance_variable_set, "@#{k}", v) if x.respond_to?(k)
         end
@@ -47,10 +57,17 @@ module Origen
         is_top_level = x.respond_to?(:includes_origen_top_level?)
         if x.respond_to?(:wrap_in_controller)
           x = x.wrap_in_controller
-          # If this object has been instantiated after on_create has already been called,
-          # then invoke it now
-          if Origen.application_loaded? && Origen.app.on_create_called?
-            x.controller.on_create if x.controller.respond_to?(:on_create)
+        end
+        # If this object has been instantiated after on_create has already been called,
+        # then invoke it now
+        if Origen.application_loaded? && Origen.app.on_create_called?
+          if x.try(:is_a_model_and_controller)
+            m = x.model
+            c = x.controller
+            m.on_create if m.respond_to_directly?(:on_create)
+            c.on_create if c.respond_to_directly?(:on_create)
+          else
+            x.on_create if x.respond_to?(:on_create)
           end
         end
         if is_top_level

data/lib/origen/org_file/interceptable.rb

@@ -3,10 +3,15 @@ module Origen
     module Interceptable
       def self.included(base)
         base.extend ClassMethods
+      end
 
-        # Defers this executing until the whole class has loaded
-        Origen.after_app_loaded do
-          unless (base.instance_methods - Object.methods).include?(:global_path_to)
+      module ClassMethods
+        def new(*args, &block)
+          o = allocate
+          i = OrgFile::Interceptor.new(o)
+          o.__interceptor__ = i
+          i.send(:initialize, *args, &block)
+          unless o.respond_to?(:global_path_to)
             puts 'When adding the OrgFile::Interceptable module to a class, the class must define an instance method called "global_path_to", like this:'
             puts
             puts '  # Must return a string that contains a global path to access the given object,'
@@ -14,17 +19,8 @@ module Origen
             puts '  def global_path_to'
             puts '    "dut.pins(:#{id})"'
             puts '  end'
-            fail "Incomplete integration of OrgFile::Interceptable in #{base}"
+            fail "Incomplete integration of OrgFile::Interceptable in #{o.class}"
           end
-        end
-      end
-
-      module ClassMethods
-        def new(*args, &block)
-          o = allocate
-          i = OrgFile::Interceptor.new(o)
-          o.__interceptor__ = i
-          i.send(:initialize, *args, &block)
           i
         end
       end

data/lib/origen/registers.rb

@@ -91,7 +91,7 @@ module Origen
       def default_reg_metadata
         Origen::Registers.reg_metadata[:global] ||= {}
         if block_given?
-          collector = Collector.new
+          collector = Origen::Utility::Collector.new
           yield collector
           Origen::Registers.reg_metadata[:global].merge!(collector.store)
         end
@@ -107,7 +107,7 @@ module Origen
       def default_bit_metadata
         Origen::Registers.bit_metadata[:global] ||= {}
         if block_given?
-          collector = Collector.new
+          collector = Origen::Utility::Collector.new
           yield collector
           Origen::Registers.bit_metadata[:global].merge!(collector.store)
         end
@@ -275,18 +275,6 @@ module Origen
       end
     end
 
-    class Collector
-      attr_reader :store
-
-      def initialize
-        @store = {}
-      end
-
-      def method_missing(method, *args, &_block)
-        @store[method.to_s.sub('=', '').to_sym] = args.first
-      end
-    end
-
     # Returns true if the given object is one of the recognized Origen
     # bit containers (bit collection, reg or container).
     def contains_bits?(obj)
@@ -434,7 +422,7 @@ module Origen
     def default_reg_metadata
       Origen::Registers.reg_metadata[self.class] ||= {}
       if block_given?
-        collector = Collector.new
+        collector = Origen::Utility::Collector.new
         yield collector
         Origen::Registers.reg_metadata[self.class].merge!(collector.store)
       end
@@ -445,7 +433,7 @@ module Origen
     def default_bit_metadata
       Origen::Registers.bit_metadata[self.class] ||= {}
       if block_given?
-        collector = Collector.new
+        collector = Origen::Utility::Collector.new
         yield collector
         Origen::Registers.bit_metadata[self.class].merge!(collector.store)
       end

data/lib/origen/sub_blocks.rb

@@ -6,10 +6,16 @@ module Origen
     # @api private
     def init_sub_blocks(*args)
       options = args.find { |a| a.is_a?(Hash) }
+      @custom_attrs = (options ? options.dup : {}).with_indifferent_access
+      # Delete these keys which are either meta data added by Origen or are already covered by
+      # dedicated methods
+      %w(parent name base_address reg_base_address base).each do |key|
+        @custom_attrs.delete(key)
+      end
       if options
         # Using reg_base_address for storage to avoid class with the original Origen base
         # address API, but will accept any of these
-        @reg_base_address = options.delete(:reg_base_address) || options.delete(:reg_base_address) ||
+        @reg_base_address = options.delete(:reg_base_address) ||
                             options.delete(:base_address) || options.delete(:base) || 0
         if options[:_instance]
           if @reg_base_address.is_a?(Array)
@@ -30,6 +36,20 @@ module Origen
       end
     end
 
+    # Returns the default
+    def self.lazy?
+      @lazy || false
+    end
+
+    def self.lazy=(value)
+      @lazy = value
+    end
+
+    # Returns a hash containing all options that were passed to the sub_block definition
+    def custom_attrs
+      @custom_attrs
+    end
+
     module Domains
       def domain(name, options = {})
         domains[name] = Origen::Registers::Domain.new(name, options)
@@ -282,7 +302,12 @@ module Origen
         define_singleton_method name do
           get_sub_block(name)
         end
-        block
+        if options.key?(:lazy)
+          lazy = options[:lazy]
+        else
+          lazy = Origen::SubBlocks.lazy?
+        end
+        lazy ? block : block.materialize
       end
     end
 
@@ -348,12 +373,13 @@ module Origen
       end
 
       def ==(obj)
-        materialize == obj
-      end
-
-      def !=(obj)
-        materialize != obj
+        if obj.is_a?(Placeholder)
+          materialize == obj.materialize
+        else
+          materialize == obj
+        end
       end
+      alias_method :equal?, :==
 
       def freeze
         materialize.freeze

data/lib/origen/utility.rb

@@ -7,6 +7,7 @@ module Origen
     autoload :InputCapture, 'origen/utility/input_capture'
     autoload :BlockArgs, 'origen/utility/block_args'
     autoload :FileDiff,  'origen/utility/file_diff.rb'
+    autoload :Collector, 'origen/utility/collector.rb'
 
     # Creates a hex-like representation of a register read value, where bits within
     # a nibble have different flags set the nibble will be expanded to bits

data/lib/origen/utility/collector.rb

@@ -0,0 +1,15 @@
+module Origen
+  module Utility
+    class Collector
+      attr_reader :store
+
+      def initialize
+        @store = {}
+      end
+
+      def method_missing(method, *args, &_block)
+        @store[method.to_s.sub('=', '').to_sym] = args.first
+      end
+    end
+  end
+end

data/vendor/lib/models/origen/export1.rb

@@ -67,7 +67,7 @@ module Origen
       model.add_ground_pin :gnd3
       model.add_ground_pin_group :gnd, :gnd1, :gnd2, :gnd3
 
-      model.sub_block :block1, file: 'origen/export1/block1.rb'
+      model.sub_block :block1, file: 'origen/export1/block1.rb', lazy: true
 
     end
   end

data/vendor/lib/models/origen/export1/block1.rb

@@ -4,7 +4,7 @@ module Origen
   module Export1
     module Block1
       def self.extended(model)
-        model.sub_block :x, file: 'origen/export1/block1/x.rb', base_address: 0x40000000
+        model.sub_block :x, file: 'origen/export1/block1/x.rb', lazy: true, base_address: 0x40000000
 
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-24 00:00:00.000000000 Z
+date: 2018-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -454,6 +454,8 @@ files:
 - lib/origen/commands/version.rb
 - lib/origen/commands/web.rb
 - lib/origen/commands_global.rb
+- lib/origen/componentable.rb
+- lib/origen/components.rb
 - lib/origen/controller.rb
 - lib/origen/core_ext.rb
 - lib/origen/core_ext/array.rb
@@ -577,6 +579,7 @@ files:
 - lib/origen/users/user.rb
 - lib/origen/utility.rb
 - lib/origen/utility/block_args.rb
+- lib/origen/utility/collector.rb
 - lib/origen/utility/csv_data.rb
 - lib/origen/utility/diff.rb
 - lib/origen/utility/file_diff.rb