origen 0.0.1 → 0.0.2

data/lib/origen/model_initializer.rb

@@ -0,0 +1,45 @@
+module Origen
+  module ModelInitializer
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # This overrides the new method of any class which includes this
+      # module to force the newly created instance to be registered as
+      # a top-level listener.
+      def new(*args, &block) # :nodoc:
+        options = args.find { |a| a.is_a?(Hash) } || {}
+
+        x = allocate
+        x.send(:init_top_level) if x.respond_to?(:includes_origen_top_level?)
+        x.send(:init_sub_blocks, *args) if x.respond_to?(:init_sub_blocks)
+        if x.respond_to?(:version=)
+          version = options[:version]
+          version ||= args.first if args.first.is_a?(Fixnum)
+          x.version = version
+        end
+        if x.respond_to?(:parent=)
+          parent = options.delete(:parent)
+          x.parent = parent if parent
+        end
+        if x.method(:initialize).arity == 0
+          x.send(:initialize, &block)
+        else
+          x.send(:initialize, *args, &block)
+        end
+        x.register_callback_listener if x.respond_to?(:register_callback_listener)
+        # 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
+        if is_top_level
+          Origen.app.listeners_for(:on_top_level_instantiated, top_level: false).each do |listener|
+            listener.on_top_level_instantiated(x)
+          end
+        end
+        x
+      end
+    end
+  end
+end

data/lib/origen/nvm/block_array.rb

@@ -0,0 +1,72 @@
+module Origen
+  module NVM
+    # A block array is a standard Ruby array that has been enhanced with additional
+    # methods related to the fact that it is intended to hold NVM block objects.
+    #
+    # This for example allows a block select value to be automatically generated for
+    # whatever blocks are contained in the array by calling the bsel method.
+    class BlockArray < ::Array
+      # Return all single blocks wrapped in a block array
+      def [](ix)
+        BlockArray.new << super(ix)
+      end
+
+      # Extract a subset of blocks based on ids
+      #
+      #   $nvm.blocks.find(0,3)
+      #
+      # An elegant way to implement this is via an accessor like this on your top-level
+      # object which owns the blocks:
+      #
+      #   def blocks(*args)
+      #     if args.empty?
+      #       @blocks
+      #     else
+      #       @blocks.find(*args)
+      #     end
+      #   end
+      #   alias :block :blocks
+      #
+      # This provides the following API:
+      #
+      #   $nvm.blocks        # Returns all blocks
+      #   $nvm.block(0)      # Returns block 0 wrapped in a block array
+      #   $nvm.blocks(0, 3)  # Returns blocks 0 and 3 wrapped in a block array
+      def find(*ids)
+        b = BlockArray.new
+        ids.each do |id|
+          b << self[id]
+        end
+        b
+      end
+
+      # def method_missing(method, *args, &blk)
+      #  if self.size == 1
+      #    self.first.send(method, *args, &blk)
+      #  else
+      #    super
+      #  end
+      # end
+
+      # Returns the block select value required to select all contained blocks, the block object
+      # must implement a method called bsel for this to work
+      def bsel
+        reduce(0) { |bsels, block| bsels | block.bsel }
+      end
+      alias_method :block_select, :bsel
+      alias_method :block_select_value, :bsel
+
+      # Returns the sum of the size of all contained blocks in KB, the block object must implement
+      # a method called size_in_kb for this to work
+      def size_in_kb
+        reduce(0) { |sum, block| sum + block.size_in_kb }
+      end
+
+      # Returns the sum of the size of all contained blocks in bytes, the block object must implement
+      # a method called size_in_kb for this to work
+      def size_in_bytes
+        size_in_kb * 1024
+      end
+    end
+  end
+end

data/lib/origen/nvm.rb

@@ -0,0 +1,6 @@
+module Origen
+  # Module containing helpers to support NVM testing
+  module NVM
+    autoload :BlockArray,  'origen/nvm/block_array'
+  end
+end

data/lib/origen/parameters/live.rb

@@ -0,0 +1,22 @@
+module Origen
+  module Parameters
+    require 'delegate'
+    class Live < ::Delegator
+      def initialize(options)
+        @owner = options[:owner]
+        @path = options[:path].split('.')
+        @name = options[:name]
+      end
+
+      def __getobj__
+        p = @owner.params
+        @path.each { |pt| p = p.send(pt) }
+        p.send(@name)
+      end
+
+      def is_a_live_parameter?
+        true
+      end
+    end
+  end
+end

data/lib/origen/parameters/missing.rb

@@ -0,0 +1,28 @@
+module Origen
+  module Parameters
+    # An instance of this class is returned whenever the parameter context is set to
+    # a value for which no parameter set has been defined.
+    #
+    # Sometime this may be valid in the case where the context is actually implemented
+    # by another object which shadows the context.
+    #
+    # The missing allows the user to do params.context to retrieve the value of the
+    # current context, but it will error out with a useful error message if they try
+    # to do anything else (i.e. retrieve a parameter from it)
+    class Missing
+      attr_reader :owner
+
+      def initialize(options = {})
+        @owner = options[:owner]
+      end
+
+      def context
+        owner._parameter_current
+      end
+
+      def method_missing(_method, *_args, &_block)
+        owner.send(:_validate_parameter_set_name, context)
+      end
+    end
+  end
+end

data/lib/origen/parameters/set.rb

@@ -0,0 +1,144 @@
+module Origen
+  module Parameters
+    class Set < Hash
+      attr_accessor :top_level
+      attr_accessor :name
+      attr_accessor :path
+
+      def initialize(options = {})
+        if options[:top_level]
+          @top_level = self
+          @path = ''
+          @owner = options[:owner]
+        end
+      end
+
+      def define(parent = nil, &_block)
+        @defining = true
+        yield self, parent
+        @defining = false
+        finalize
+      end
+
+      # Returns the current parameter context
+      def context
+        owner._parameter_current
+      end
+      alias_method :current_context, :context
+
+      def copy_defaults_from(set)
+        set.each do |name, val|
+          if val.is_a?(Set)
+            self[name] = new_subset(name)
+            self[name].copy_defaults_from(val)
+          else
+            self[name] = val
+          end
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if defining?
+          if args.length == 0
+            self[method] ||= new_subset(method)
+          elsif args.length > 1
+            super
+          else
+            m = method.to_s.sub('=', '').to_sym
+            self[m] = args.first
+          end
+        else
+          if args.length != 0
+            super
+          else
+            val = self[method]
+            if !val
+              super
+            else
+              if val.is_a?(Set)
+                val
+              else
+                if live?
+                  Live.new(owner: owner, path: path, name: method)
+                else
+                  if val.is_a?(Proc)
+                    val.call(*args)
+                  else
+                    val
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def each
+        super do |key, val|
+          if val.is_a?(Proc)
+            yield key, val.call
+          else
+            yield key, val
+          end
+        end
+      end
+
+      def [](key)
+        val = super
+        val.is_a?(Proc) ? val.call : val
+      end
+
+      # Test seems to be some kind of reserved word, that doesn't trigger the method_missing,
+      # so re-defining it here to allow a param group called 'test'
+      def test(*args, &block)
+        method_missing(:test, *args, &block)
+      end
+
+      def defining?
+        if top_level?
+          @defining
+        else
+          top_level.defining?
+        end
+      end
+
+      def owner
+        if top_level?
+          @owner
+        else
+          top_level.owner
+        end
+      end
+
+      def top_level?
+        top_level == self
+      end
+
+      def finalize
+        freeze
+        each { |_name, val| val.finalize if val.is_a? Set }
+      end
+
+      def new_subset(name)
+        set = Set.new
+        set.name = name
+        set.top_level = top_level
+        if path == ''
+          set.path = name.to_s
+        else
+          set.path = "#{path}.#{name}"
+        end
+        set
+      end
+
+      def live?
+        owner._live_parameter_requested?
+      end
+
+      def live
+        owner._request_live_parameter
+        self
+      end
+    end
+  end
+end

data/lib/origen/parameters.rb

@@ -0,0 +1,107 @@
+require 'active_support/concern'
+module Origen
+  module Parameters
+    extend ActiveSupport::Concern
+    autoload :Set, 'origen/parameters/set'
+    autoload :Live, 'origen/parameters/live'
+    autoload :Missing, 'origen/parameters/missing'
+
+    attr_accessor :current
+
+    module ClassMethods
+      def parameters_context(obj = nil)
+        if obj
+          if obj.is_a?(Symbol)
+            valid = [:top, :dut].include?(obj)
+          end
+          valid ||= obj.is_a?(String)
+          unless valid
+            fail 'Invalid parameters context, must be :top or a string path to a model object'
+          end
+          @parameters_context = obj
+        else
+          @parameters_context
+        end
+      end
+    end
+
+    def define_params(name, options = {}, &block)
+      if _parameter_sets[name]
+        fail 'Parameter sets cannot be re-opened once originally defined!'
+      else
+        _parameter_sets[name] = Set.new(top_level: true, owner: self)
+        if options[:inherit]
+          _validate_parameter_set_name(options[:inherit])
+          parent = _parameter_sets[options[:inherit]]
+          _parameter_sets[name].copy_defaults_from(parent)
+          _parameter_sets[name].define(parent, &block)
+        else
+          _parameter_sets[name].define(&block)
+        end
+      end
+    end
+    alias_method :define_parameters, :define_params
+
+    def with_params(name, _options = {})
+      orig = _parameter_current
+      self.params = name
+      yield
+      self.params = orig
+    end
+
+    def params
+      @_live_parameter_requested = false
+      _parameter_sets[_parameter_current] || Missing.new(owner: self)
+    end
+    alias_method :parameters, :params
+
+    def params=(name)
+      # Don't validate on setting this as this object could be used to set
+      # the context on some other object, therefore validate later if someone tries
+      # to access the params on this object
+      # _validate_parameter_set_name(name)
+      @_parameter_current = name
+    end
+    alias_method :parameters=, :params=
+
+    # @api private
+    def _parameter_current
+      if path = self.class.parameters_context
+        case path
+        when :top, :dut
+          Origen.top_level._parameter_current
+        else
+          eval(path)._parameter_current
+        end
+      else
+        @_parameter_current || :default
+      end
+    end
+
+    # @api private
+    def _parameter_sets
+      @_parameter_sets ||= {}
+    end
+
+    # @api private
+    def _request_live_parameter
+      @_live_parameter_requested = true
+    end
+
+    # @api private
+    def _live_parameter_requested?
+      @_live_parameter_requested
+    end
+
+    private
+
+    def _validate_parameter_set_name(name)
+      unless _parameter_sets.key?(name)
+        puts "Unknown parameter set :#{name} requested for #{self.class}, these are the valid sets:"
+        _parameter_sets.keys.each { |k| puts "  :#{k}" }
+        puts ''
+        fail 'Unknown parameter set!'
+      end
+    end
+  end
+end

data/lib/origen/pdm.rb

@@ -0,0 +1,218 @@
+module Origen
+  module PDM
+    autoload :WebService, 'origen/pdm/web_service'
+    autoload :PI, 'origen/pdm/pi'
+    autoload :Tracker, 'origen/pdm/tracker'
+
+    require 'origen/pdm/attributes'
+
+    include Attributes
+
+    # Set true to use the PDM test system rather than the live system.
+    # The test system can be found at: http://designpdmtest.freescale.net/Agile
+    attr_accessor :pdm_use_test_system
+
+    # This should be set to the PDM version number that the current object represents.
+    # For example if the object represents C90TFS_NVM_tester_010, then set this
+    # attribute to 10.
+    #
+    # This attribute is required to be set when including a component in a BOM, otherwise
+    # it is not required to be set when releasing a new version.
+    #
+    # It can also be set to :latest to pick up the latest version number for the component.
+    attr_accessor :pdm_version_number
+
+    # Set this attribute to create a branch point release from the given version. If this
+    # attribute is not set then all releases will simply supercede the last release.
+    attr_accessor :pdm_branch_version_number
+
+    # Set this to specify which version the new release should supercede.
+    # If un-specified the new release will automatically supercede the last version on the
+    # trunk.
+    attr_accessor :pdm_supercedes_version_number
+
+    # Set this attribute to include components in the BOM, it should be set to an array
+    # of objects, each of which must also include the Origen::PDM module and have the
+    # pdm_version_number attribute set.
+    attr_accessor :pdm_bom
+
+    # If you begin automating PDM releases on a component that already exists on PDM, then
+    # you must set this attribute to let Origen know what the latest part number is on PDM.
+    #
+    # For example if the latest component is called C90TFS_NVM_tester_010 at the time of
+    # setting up the component in Origen then set this attribute to 10.
+    #
+    # If the object does not exist on PDM yet then you can leave this blank and Origen will
+    # create and begin tracking the component from the initial version.
+    attr_accessor :pdm_initial_version_number
+
+    attr_accessor :pdm_meta_tags
+
+    def self.update_ticket(tkt)
+      pdm_pi.update_ticket(tkt)
+    end
+
+    def self.pdm_pi(_options = {})
+      @pdm_pi ||= PI.new(use_test_system: true)
+    end
+
+    def pdm_base_url
+      if pdm_use_test_system
+        host = 'http://designpdmtest.freescale.net'
+      else
+        host = 'http://designpdm.freescale.net'
+      end
+    end
+
+    # Returns the url for specific component version on PDM, i.e. if the model represents
+    # pdm component C90TFS_NVM_tester_010 then the link to that component version will be
+    # returned
+    def pdm_url
+      "#{pdm_base_url}/Agile/object/#{pdm_part_type}/#{pdm_part_number}"
+    end
+
+    # Returns the url for component's item group on PDM, i.e. if the model represents
+    # pdm component C90TFS_NVM_tester_010 then the link to C90TFS_NVM_tester will be
+    # returned
+    def pdm_item_group_url
+      "#{pdm_base_url}/Agile/object/Item Group/#{pdm_part_name}"
+    end
+
+    # The PI API, returns an instance of Origen::PDM::PI
+    def pdm_pi
+      @pdm_pi ||= PI.new(use_test_system: pdm_use_test_system)
+    end
+
+    # The PDM Web Service API, returns an instance of Origen::PDM::WebService
+    def pdm_web_service
+      @pdm_web_service ||= WebService.new
+    end
+
+    # When talking to PDM we need to use the 'Part Number' which is comprised
+    # of the part name plus a numeric revision.
+    #
+    # For example 'C90TFS_NVM_tester' is the part name, 'C90TFS_NVM_tester_058' is a
+    # possible part number.
+    def pdm_part_number
+      pdm_part_name + '_%03d' % _pdm_version_number
+    end
+
+    def pdm_branch_part_number
+      if pdm_branch_version_number
+        pdm_part_name + '_%03d' % pdm_branch_version_number
+      end
+    end
+
+    # Returns the latest part number regardless of whether it is on a branch or not
+    def pdm_latest_part_number
+      if pdm_latest_version_number
+        pdm_part_name + '_%03d' % pdm_latest_version_number
+      end
+    end
+
+    # Returns the latest part number that is not on a branch
+    def pdm_latest_trunk_part_number
+      if pdm_latest_trunk_version_number
+        pdm_part_name + '_%03d' % pdm_latest_trunk_version_number
+      end
+    end
+
+    def pdm_supercedes_part_number
+      if pdm_supercedes_version_number
+        pdm_part_name + '_%03d' % pdm_supercedes_version_number
+      end
+    end
+
+    def pdm_bom
+      []
+    end
+
+    def pdm_meta_tags
+      []
+    end
+
+    def _pdm_version_number
+      if pdm_version_number && pdm_version_number != :latest
+        pdm_version_number
+      else
+        pdm_latest_version_number ||
+          fail("You must set the pdm_version_number attribute of #{self.class}")
+      end
+    end
+
+    def pdm_latest_version_number
+      if pdm_tracker.latest_version_number
+        if pdm_initial_version_number &&
+           pdm_initial_version_number > pdm_tracker.latest_version_number
+          pdm_initial_version_number
+        else
+          pdm_tracker.latest_version_number
+        end
+      else
+        pdm_initial_version_number
+      end
+    end
+
+    def pdm_latest_trunk_version_number
+      if pdm_tracker.latest_trunk_version_number
+        if pdm_initial_version_number &&
+           pdm_initial_version_number > pdm_tracker.latest_trunk_version_number
+          pdm_initial_version_number
+        else
+          pdm_tracker.latest_trunk_version_number
+        end
+      else
+        pdm_initial_version_number
+      end
+    end
+
+    def pdm_supercedes_version_number
+      @pdm_supercedes_version_number || pdm_latest_trunk_version_number
+    end
+
+    def pdm_component_binding
+      binding
+    end
+
+    def pdm_tracker
+      @pdm_tracker ||= Tracker.new(component: self)
+    end
+
+    # Pulls the BOM from PDM into an array of hashes with the following keys:
+    #
+    # * :pdm_part_name (e.g. C90TFS_NVM_tester)
+    # * :pdm_version_number  (e.g. 058 (actually returned as 58))
+    # * :pdm_version (e.g. Rel20121002)
+    def pdm_remote_bom
+      pdm_pi.catbom(self)
+    end
+
+    # Release a new component version to PDM
+    def pdm_release!(options = {})
+      options = {
+        release_bom: false
+      }.merge(options)
+      ret = pdm_pi.release!(self)
+      pdm_tracker.release!
+      ret
+    end
+
+    # This method is called before permanently saving a released component in the store,
+    # override it to set instance variables for anything you wish to save.
+    #
+    # Normally it is best to assign the result of any pdm attributes that come from
+    # methods as instance variables so that the current state of the component can
+    # be reconstructed later.
+    def freeze
+    end
+
+    def pdm_prepare_for_store
+      freeze
+      # Clear these so as not to waste effort Marshalling them
+      @pdm_pi = nil
+      @pdm_web_service = nil
+      @pdm_tracker = nil
+      @pi_attributes = nil
+    end
+  end
+end

data/lib/origen/pins/function_proxy.rb

@@ -0,0 +1,36 @@
+module Origen
+  module Pins
+    require 'delegate'
+    require 'origen/pins/pin'
+    # Thin wrapper around pin objects to implement a defined function.
+    #
+    # The pin object stores all attributes associated with the function, this
+    # wrapper simply keeps track of what function a given pin reference refers to
+    class FunctionProxy < ::Delegator
+      def initialize(id, pin)
+        @id = id
+        @pin = pin
+      end
+
+      def __getobj__
+        @pin
+      end
+
+      # Intercept all calls to function-scoped attributes of the pin so
+      # that we can inject the function that we want the attribute value for
+      Pin::FUNCTION_SCOPED_ATTRIBUTES.each do |attribute|
+        define_method attribute do |options = {}|
+          options[:function] = @id
+          @pin.send(attribute, options)
+        end
+      end
+
+      private
+
+      # For debug
+      def _function
+        @id
+      end
+    end
+  end
+end

data/lib/origen/pins/ground_pin.rb

@@ -0,0 +1,6 @@
+module Origen
+  module Pins
+    class GroundPin < Pin
+    end
+  end
+end