origen 0.44.0 → 0.50.0

data/lib/origen/loader.rb

@@ -0,0 +1,377 @@
+module Origen
+  # This module is responsible for enhancing how Ruby requires and loads files to support loading of
+  # classes and modules from an application's app dir without having to require them.
+  #
+  # It also implements the <model>.load_block method that loads files from app/blocks.
+  module Loader
+    # @api private
+    #
+    # Unload all constants (classes and modules) that have been auto-loaded since this was last called
+    def self.unload
+      # puts "******** LOADED CONSTS@ #{@loaded_consts}"
+      path = []
+      (@consts_hierarchy || {}).each do |name, children|
+        _unload(path, name, children)
+      end
+      @consts_hierarchy = {}
+      @loaded_consts = {}
+      (Origen.app.plugins + [Origen.app]).each do |app|
+        app.instance_variable_set(:@blocks_files, nil)
+      end
+      nil
+    end
+
+    # @api private
+    def self._unload(path, name, children)
+      path << name
+      children.each do |name, children|
+        _unload(path, name, children)
+      end
+      const = path.join('::')
+      if @loaded_consts[const]
+        path[0...-1].join('::').constantize.send :remove_const, path.last
+        # puts "******** Unloading: #{const}"
+      end
+      path.pop
+    end
+
+    # @api private
+    def self.record_const(name)
+      @consts_hierarchy ||= {}
+      @loaded_consts ||= {}
+      @loaded_consts[name] = true
+      pointer = nil
+      name.split('::').each do |name|
+        if pointer
+          pointer[name] ||= {}
+          pointer = pointer[name]
+        else
+          @consts_hierarchy[name] ||= {}
+          pointer = @consts_hierarchy[name]
+        end
+      end
+    end
+
+    # @api private
+    def self.load_attributes(file, model)
+      if model.respond_to?(:is_an_origen_model?)
+        attributes = model.attributes.dup
+      else
+        attributes = {}
+      end
+      vars = model.instance_variables
+      if load_block_file(file, model)
+        # Update the value of any pre-existing attribute that could have just changed
+        attributes.each do |a, v|
+          attributes[a] = model.instance_variable_get("@#{a}")
+        end
+        # And add any new ones that were encountered for the first time
+        (model.instance_variables - vars).each do |var|
+          val = model.instance_variable_get(var)
+          attribute = var.to_s.sub('@', '')
+          attributes[attribute.to_sym] = val
+          unless model.respond_to?(attribute)
+            model.define_singleton_method(attribute) do
+              instance_variable_get(var)
+            end
+          end
+          if val == true || val == false
+            attribute += '?'
+            unless model.respond_to?(attribute)
+              model.define_singleton_method(attribute) do
+                instance_variable_get(var)
+              end
+            end
+          end
+        end
+        if model.respond_to?(:is_an_origen_model?)
+          attributes.freeze
+          model.instance_variable_set(:@attributes, attributes)
+        end
+        true
+      end
+    end
+
+    # @api private
+    def self.load_block_file(file, model)
+      e = File.exist?(file.to_s)
+      model.instance_eval(file.read, file.to_s) if e
+      true
+    end
+
+    # @api private
+    def self.with_parameters_transaction(type)
+      if type == :parameters
+        Origen::Parameters.transaction do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    # If a block definition exists for the given model, then this will load it and apply it to
+    # the model.
+    # Returns true if a model is found and loaded, otherwise nil.
+    def self.load_block(model, options = {})
+      model = model.model  # Ensure we have a handle on the model and not its controller
+      loaded = nil
+      if app = options[:app] || model.app
+        if options[:path]
+          full_paths = Array(options[:path])
+        else
+          full_paths = model.class.to_s.split('::')
+          full_paths.shift  # Throw away the app namespace
+          full_paths = [full_paths.join('/')]
+        end
+        full_paths.each do |full_path|
+          paths = full_path.to_s.split('/')
+          key = ''
+          only = Array(options[:only]) if options[:only]
+          except = Array(options[:except]) if options[:except]
+          path = paths.map(&:underscore).join('/')
+          # If the path refers to a nested sub-block then don't load the full hierarchy since they
+          # don't support inheritance or derivatives, modify the paths array so that only the sub-block
+          # level will be loaded and nothing else.
+          paths = [path] if app.blocks_files[path] && app.blocks_files[path][:_sub_block]
+          # These will be loaded first, followed by the rest in an undefined order.
+          # Attributes and parameters are first so that they may be referenced in the other files.
+          # Sub-blocks was added early due to a corner case issue that could be encountered if the pins or
+          # regs imported an Origen exported file that defined a module with the same name as a sub-block
+          # class, in that case the sub-block class would not be auto-loaded.
+          load_first = [:attributes, :parameters, :sub_blocks]
+
+          load_first.each do |type|
+            unless (only && !only.include?(type)) || (except && except.include?(type))
+              with_parameters_transaction(type) do
+                paths.each_with_index do |path, i|
+                  key = i == 0 ? path.underscore : "#{key}/#{path.underscore}"
+                  if app.blocks_files[key] && app.blocks_files[key][type]
+                    app.blocks_files[key][type].each do |f|
+                      if type == :attributes
+                        success = load_attributes(f, model)
+                      else
+                        success = load_block_file(f, model)
+                      end
+                      loaded ||= success
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Now load the rest
+          paths.each_with_index do |path, i|
+            key = i == 0 ? path.underscore : "#{key}/#{path.underscore}"
+            if app.blocks_files[key]
+              app.blocks_files[key].each do |type, files|
+                unless type == :_sub_block || load_first.include?(type) || (only && !only.include?(type)) || (except && except.include?(type))
+                  files.each { |f| success = load_block_file(f, model); loaded ||= success }
+                end
+              end
+            end
+          end
+        end
+      end
+      loaded
+    end
+
+    # This is inspired by Rails' ActiveSupport::Dependencies module.
+    module ModuleConstMissing
+      def self.append_features(base)
+        base.class_eval do
+          # Emulate #exclude via an ivar
+          return if defined?(@_const_missing) && @_const_missing
+          @_const_missing = instance_method(:const_missing)
+          remove_method(:const_missing)
+        end
+        super
+      end
+
+      def self.exclude_from(base)
+        base.class_eval do
+          define_method :const_missing, @_const_missing
+          @_const_missing = nil
+        end
+      end
+
+      # @api private
+      # Substitutes a single occurrence of 'derivatives' in the given dirs array, starting
+      # from the end of it and replacing it with the given new value.
+      # Returns true if a substitution is made, else false.
+      def _sub_derivatives_from_end(new_val, dirs)
+        subbed = false
+        size = dirs.size - 1
+        dirs.reverse_each.with_index do |val, i|
+          if val == 'derivatives'
+            dirs[size - i] = new_val
+            subbed = true
+            break
+          end
+        end
+        dirs if subbed
+      end
+
+      # Allows classes and modules to be defined in app/blocks and app/lib without needing to
+      # require them and in the case of app/blocks to use a custom directory structure.
+      #
+      # The first time a reference is made to a class or module name it will trigger this hook,
+      # and we then work out what the file name should be and require it.
+      def const_missing(name)
+        if Origen.in_app_workspace?
+          if self == Object
+            name = name.to_s
+          else
+            name = "#{self}::#{name}"
+          end
+          return nil if @_checking_name == name
+          names = name.split('::')
+          namespace = names.shift
+          if app = Origen::Application.from_namespace(namespace)
+            # First we are going to check for a match in the app/blocks directory, this needs to be handled
+            # specially since it follows a non-std structure, e.g. use of derivatives/ and sub_blocks/ folders
+            # for organization without having them as part of the class name-spacing
+            altname = nil
+            dirs = [app.root, 'app', 'blocks']
+            names.each_with_index do |name, i|
+              dirs << 'derivatives' unless i == 0
+              dirs << name.underscore
+            end
+
+            # Is this a reference to a model?
+            if File.exist?(f = File.join(*dirs, 'model.rb'))
+              model = _load_const(f, name)
+              # Also load the model's controller if it exists
+              if File.exist?(f = File.join(*dirs, 'controller.rb'))
+                controller = _load_const(f, name + 'Controller')
+              end
+              return model
+            end
+
+            # Is this a reference to a controller?
+            if dirs.last.to_s =~ /_controller$/
+              controller_reference = true
+              dirs << dirs.pop.sub(/_controller$/, '')
+              if File.exist?(f = File.join(*dirs, 'controller.rb'))
+                return _load_const(f, name)
+              end
+            end
+
+            # Is this a reference to a sub-block model or controller that is nested within a block?
+            dirs_ = dirs.dup
+            while dirs_ = _sub_derivatives_from_end('sub_blocks', dirs_)
+              if controller_reference
+                if File.exist?(f = File.join(*dirs_, 'controller.rb'))
+                  return _load_const(f, name)
+                end
+              elsif File.exist?(f = File.join(*dirs_, 'model.rb'))
+                model = _load_const(f, name)
+                # Also load the model's controller if it exists
+                if File.exist?(f = File.join(*dirs_, 'controller.rb'))
+                  controller = _load_const(f, name + 'Controller')
+                end
+                return model
+              end
+            end
+
+            # Is this a reference to a module that has been added to a model or controller?
+            # In this case dirs contains something like:
+            #    [..., "my_model", "derivatives", "my_module"]
+            #    [..., "my_model_controller", "derivatives", "my_module"]
+            # So let's try by transforming these into:
+            #    [..., "my_model", "model"] + "my_module.rb"
+            #    [..., "my_model", "controller"] + "my_module.rb"
+            filename = dirs.pop + '.rb'
+            dirs.pop # Lose 'derivatives'
+            if dirs.last.to_s =~ /_controller$/
+              dirs << dirs.pop.sub(/_controller$/, '')
+              dirs << 'controller'
+            else
+              dirs << 'model'
+            end
+            if File.exist?(f = File.join(*dirs, filename))
+              return _load_const(f, name)
+            end
+
+            # Now that we have established that it is not a reference to a block (which has a non-std code
+            # organization structure), we can now check for a match in the app/lib directory following std
+            # Ruby code organization conventions
+            until names.empty?
+              path = File.join(*names.map(&:underscore)) + '.rb'
+
+              f = File.join(app.root, 'app', 'lib', namespace.underscore, path)
+              if File.exist?(f)
+                model = _load_const(f, name, altname)
+                # Try and reference the controller to load it too, though don't raise an error if it
+                # doesn't exist
+                @@pre_loading_controller = true
+                eval "#{altname || name}Controller"
+                return model
+              # If a folder exists that is named after this constant, then assume it is an otherwise
+              # undeclared namespace module and declare it now
+              elsif File.exist?(f.sub('.rb', ''))
+                return const_set path.sub('.rb', '').camelcase, Module.new
+              end
+
+              # Don't waste time looking up the namespace hierarchy for the controller, if it exists it
+              # should be within the exact same namespace as the model
+              return nil if defined?(@@pre_loading_controller) && @@pre_loading_controller
+
+              # Remove the highest level namespace and then search again in the parent namespace
+              if discarded_namespace = names.delete_at(-2)
+                altname ||= name
+                altname = altname.sub("#{discarded_namespace}::", '')
+              else
+                names.pop
+              end
+            end
+
+            _raise_uninitialized_constant_error(name)
+          else
+            _raise_uninitialized_constant_error(name)
+          end
+        else
+          _raise_uninitialized_constant_error(name)
+        end
+      ensure
+        @@pre_loading_controller = false
+      end
+
+      # @api_private
+      def _load_const(file, name, altname = nil)
+        load file
+        if defined?(@@pre_loading_controller)
+          return if @@pre_loading_controller
+        end
+        @_checking_name = altname || name
+        const = eval(altname || name)
+        @_checking_name = nil
+        if const
+          Origen::Loader.record_const(altname || name)
+          return const
+        end
+        msg ||= "uninitialized constant #{name} (expected it to be defined in: #{file})"
+        _raise_uninitialized_constant_error(name, msg)
+      end
+
+      # @api private
+      def _raise_uninitialized_constant_error(name, msg = nil)
+        msg ||= "uninitialized constant #{name}"
+        name_error = NameError.new(msg, name)
+        name_error.set_backtrace(caller.reject { |l| l =~ /^#{__FILE__}/ })
+        fail name_error
+      end
+    end
+
+    def self.enable_origen_load_extensions!
+      Module.class_eval { include ModuleConstMissing }
+    end
+
+    def self.disable_origen_load_extensions!
+      ModuleConstMissing.exclude_from(Module)
+    end
+  end
+end
+
+Origen::Loader.enable_origen_load_extensions!

data/lib/origen/model.rb

@@ -43,6 +43,12 @@ module Origen
       end
     end
 
+    # Returns a frozen hash containing any attributes that were
+    # derived from a block definition
+    def attributes
+      @attributes ||= {}.freeze
+    end
+
     def inspect
       if controller
         "<Model/Controller: #{self.class}:#{object_id}/#{controller.class}:#{controller.object_id}>"
@@ -63,7 +69,7 @@ module Origen
 
     # Returns true if the model is the current DUT/top-level model
     def is_top_level?
-      Origen.top_level == self
+      respond_to?(:includes_origen_top_level?)
     end
     alias_method :is_dut?, :is_top_level?
     alias_method :top_level?, :is_top_level?
@@ -75,6 +81,21 @@ module Origen
       self
     end
 
+    # Returns the application instance that defines the model, often the current app but it could
+    # also be one of the plugins.
+    # Returns nil if the application cannot be resolved, usually because the model's class has
+    # not been correctly namespaced.
+    def app
+      @app ||= Origen::Application.from_namespace(self.class.to_s)
+    end
+
+    # Load the block definitions from the given path to the model.
+    # Returns true if a block is found and loaded, otherwise nil.
+    def load_block(path, options = {})
+      options[:path] = path
+      Origen::Loader.load_block(self, options)
+    end
+
     def ==(obj)
       if obj.is_a?(Origen::SubBlocks::Placeholder)
         obj = obj.materialize

data/lib/origen/model_initializer.rb

@@ -46,7 +46,10 @@ module Origen
         else
           x.send(:initialize, *args, &block)
         end
-        x.send(:_initialized) if x.respond_to?(:is_an_origen_model?)
+        if x.respond_to?(:is_an_origen_model?)
+          x.send(:_initialized)
+          Origen::Loader.load_block(x)
+        end
         if x.respond_to?(:register_callback_listener)
           Origen.after_app_loaded do |app|
             x.register_callback_listener
@@ -55,6 +58,7 @@ module Origen
         # Do this before wrapping, otherwise the respond to method in the controller will
         # be looking for the model to be instantiated when it is not fully done yet
         is_top_level = x.respond_to?(:includes_origen_top_level?)
+
         if x.respond_to?(:wrap_in_controller)
           x = x.wrap_in_controller
         end

data/lib/origen/parameters/set.rb

@@ -21,7 +21,7 @@ module Origen
         @defining = true
         yield self, parent
         @defining = false
-        finalize
+        finalize unless Origen::Parameters.transaction_open
       end
 
       # Returns the current parameter context
@@ -114,6 +114,7 @@ module Origen
       end
 
       def defining?
+        return true if Origen::Parameters.transaction_open
         if top_level?
           @defining
         else

data/lib/origen/parameters.rb

@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'set'
 module Origen
   module Parameters
     extend ActiveSupport::Concern
@@ -8,6 +9,75 @@ module Origen
 
     attr_accessor :current
 
+    # @api private
+    #
+    # Any define_params blocks contained within the given block will be allowed to be re-opened later
+    # in the block to override existing parameter settings or to add new ones.
+    #
+    # This is not allowed normally since already-defined child parameter sets could have referenced the
+    # original parameter and they would not reflect the final value after re-opening the parent parameter
+    # set.
+    #
+    # By defining the parameters within this block, Origen will keep track of relationships between parameter
+    # sets and any time a parent is changed the definitions of existing children will be re-executed to ensure
+    # that they reflect the new values.
+    #
+    # This is initially intended to support the concept of a app/parameters/application.rb being
+    # used to define baseline parameter sets, and then target-specific files can then override them.
+    def self.transaction
+      start_transaction
+      yield
+      stop_transaction
+    end
+
+    # @api private
+    def self.start_transaction
+      @transaction_data = {}
+      @transaction_open = true
+      @transaction_counter ||= 0
+      @transaction_counter += 1
+    end
+
+    # @api private
+    def self.stop_transaction
+      @transaction_counter -= 1
+      if @transaction_counter == 0
+        # Now finalize (freeze) all parameter sets we have just defined, this was deferred at define time due
+        # to running within a transaction
+        @transaction_data.each do |model, parameter_sets|
+          parameter_sets.keys.each do |name|
+            model._parameter_sets[name].finalize
+          end
+        end
+        @transaction_data = nil
+        @transaction_open = false
+      end
+    end
+
+    # @api private
+    def self.transaction_data
+      @transaction_data
+    end
+
+    # @api private
+    def self.transaction_open
+      @transaction_open
+    end
+
+    # @api private
+    def self.transaction_redefine
+      @transaction_redefine
+    end
+
+    # @api private
+    def self.redefine(model, name)
+      @transaction_redefine = true
+      model._parameter_sets.delete(name)
+      @transaction_data[model][name][:definitions].each { |options, block| model.define_params(name, options, &block) }
+      @transaction_data[model][name][:children].each { |model, name| redefine(model, name) }
+      @transaction_redefine = false
+    end
+
     module ClassMethods
       def parameters_context(obj = nil)
         if obj
@@ -25,19 +95,41 @@ module Origen
       end
     end
 
+    # @api private
+    def define_params_transaction
+      Origen::Parameters.transaction_data
+    end
+
     def define_params(name, options = {}, &block)
-      if _parameter_sets[name]
+      name = name.to_sym
+      if _parameter_sets[name] && !Origen::Parameters.transaction_open
         fail "Parameter set '#{name}' cannot be re-opened once originally defined!"
       else
-        _parameter_sets[name] = Set.new(top_level: true, owner: self)
+        if Origen::Parameters.transaction_open && !Origen::Parameters.transaction_redefine
+          define_params_transaction[self] ||= {}
+          define_params_transaction[self][name] ||= { children: ::Set[], definitions: [] }
+          define_params_transaction[self][name][:definitions] << [options.dup, block]
+          redefine_children = define_params_transaction[self][name][:children] if _parameter_sets[name]
+        end
+        if _parameter_sets[name]
+          defaults_already_set = true
+        else
+          _parameter_sets[name] = Origen::Parameters::Set.new(top_level: true, owner: self)
+        end
         if options[:inherit]
           kontext = _validate_parameter_set_name(options[:inherit])
           parent = kontext[:obj]._parameter_sets[kontext[:context]]
-          _parameter_sets[name].copy_defaults_from(parent)
+          if Origen::Parameters.transaction_open && !Origen::Parameters.transaction_redefine
+            define_params_transaction[kontext[:obj]][kontext[:context]][:children] << [self, name]
+          end
+          _parameter_sets[name].copy_defaults_from(parent) unless defaults_already_set
           _parameter_sets[name].define(parent, &block)
         else
           _parameter_sets[name].define(&block)
         end
+        if redefine_children
+          redefine_children.each { |model, set_name| Origen::Parameters.redefine(model, set_name) }
+        end
       end
     end
     alias_method :define_parameters, :define_params

data/lib/origen/sub_blocks.rb

@@ -407,6 +407,11 @@ module Origen
 
       # Make this appear like a sub-block to any application code
       def is_a?(klass)
+        # Because sub_blocks are stored in a hash.with_indifferent_access, the value is tested
+        # against being a Hash or Array when it is added to the hash. This prevents the class being
+        # looking up and loaded by the autoload system straight away, especially if the sub-block
+        # has been specified to lazy load
+        return false if klass == Hash || klass == Array
         klass == self.klass || klass == Placeholder
       end
 
@@ -424,13 +429,16 @@ module Origen
       end
 
       def materialize
+        block = nil
         file = attributes.delete(:file)
+        load_block = attributes.delete(:load_block)
         dir = attributes.delete(:dir) || owner.send(:export_dir)
         block = owner.send(:instantiate_sub_block, name, klass, attributes)
         if file
           require File.join(dir, file)
           block.extend owner.send(:export_module_names_from_path, file).join('::').constantize
         end
+        block.load_block(load_block) if load_block
         block.owner = owner
         block
       end
@@ -464,17 +472,17 @@ module Origen
         @klass ||= begin
           class_name = attributes.delete(:class_name)
           if class_name
-            if eval("defined? ::#{owner.namespace}::#{class_name}")
+            begin
               klass = eval("::#{owner.namespace}::#{class_name}")
-            else
-              if eval("defined? #{class_name}")
+            rescue NameError
+              begin
                 klass = eval(class_name)
-              else
-                if eval("defined? #{owner.class}::#{class_name}")
+              rescue NameError
+                begin
                   klass = eval("#{owner.class}::#{class_name}")
-                else
+                rescue NameError
                   puts "Could not find class: #{class_name}"
-                  fail 'Unknown sub block class!'
+                  raise 'Unknown sub block class!'
                 end
               end
             end
@@ -502,6 +510,12 @@ module Origen
   class SubBlock
     include Origen::Model
 
+    # Since no application defined this sub-block class, consider its parent's app to be
+    # the owning application
+    def app
+      parent.app
+    end
+
     # Used to create attribute accessors on the fly.
     #
     # On first call of a missing method a method is generated to avoid the missing lookup

data/lib/origen/top_level.rb

@@ -24,6 +24,17 @@ module Origen
       include Origen::Model
     end
 
+    # Unloads all modules class defined by the application and reloads the target, use
+    # this in the console to pick up changes made to files since you opened it.
+    # It will only work if your application uses Origen auto-loading from the app/dir,
+    # any files that you have manually required will not be re-loaded and may generally
+    # cause problems with the use of this method.
+    def reload!
+      Loader.unload
+      Origen.app.reload_target!
+      true
+    end
+
     # Top-level timing manager/API, returns an instance of Origen::Pins::Timing
     def timing
       @timing ||= Pins::Timing.new

data/lib/origen.rb

@@ -13,6 +13,7 @@ unless defined? RGen::ORIGENTRANSITION
   $_origen_invocation_pwd ||= Pathname.pwd
   require 'fileutils'
   # Force these to re-load since they could have been loaded from an earlier version of Origen during boot
+  load 'origen/loader.rb'
   load 'origen/site_config.rb'
   load 'origen/operating_systems.rb'
   require 'origen/core_ext'
@@ -25,7 +26,7 @@ unless defined? RGen::ORIGENTRANSITION
   require 'origen/remote_manager'
   require 'origen/utility'
   require 'origen/logger_methods'
-  require 'option_parser/optparse'
+  require 'origen/core_ext/option_parser/optparse'
   require 'bundler'
   require 'origen/undefined'
   require 'origen/componentable'
@@ -290,6 +291,7 @@ unless defined? RGen::ORIGENTRANSITION
 
       # Returns true if Origen is running in an application workspace
       def in_app_workspace?
+        return @in_app_workspace if defined? @in_app_workspace
         @in_app_workspace ||= begin
           path = Pathname.new(Dir.pwd)
           until path.root? || File.exist?(File.join(path, APP_CONFIG))