origen 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25b15e270740c0844ea3310d0b8b7dba5ea4e449
-  data.tar.gz: e1c78978a03c9f992ab549db6e53bc02364b4b4e
+  metadata.gz: 64c45eb89cc8ad305b8cf99ada8741d36a745c1b
+  data.tar.gz: 343beb79e30953b72ea3f048a7676e065538817d
 SHA512:
-  metadata.gz: ec73502e12c6e34fd2b15f5c32e9464d1b1a4e1397040af6858516c3f14343fa9b2e8f7d93be8fc041d30819ce19bce47911e0ed1017ccd43481d425960eb5b1
-  data.tar.gz: 6edf23f23cbfac8c770408d45478343e81ae7399d7387525a20ce3380786805da3403b27f92e04ddc663cc13061444ee6f2335d6f2b613eca082ea1d8afa33cc
+  metadata.gz: 25d2cd159aa19e7c50b4cb8982aa4b7fd777da7e312545ec12917bc6a642afafc0a549368d8265bca7934a52b36899f5f865a67556e6a748c783166e8780105f
+  data.tar.gz: f599582cd7e4048a7d2169365cb783d129f342027a866e46e260c90e9d19ababbdc9f8b19cad64b81c1c9399c6e8a93933e0675c750741a015a5380a88916633

data/bin/origen

@@ -9,6 +9,10 @@ end
 
 ORIGEN_MIN_GCC_VERSION = "4.6.3"
 
+# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
+# by the site_config lookup.
+$_origen_invocation_pwd ||= Pathname.pwd
+
 load File.expand_path('../../lib/origen/operating_systems.rb', __FILE__)
 load File.expand_path('../../lib/origen/site_config.rb', __FILE__)
 
@@ -184,17 +188,30 @@ else
   require "origen"
 end
 
-# If this script has been invoked from within an Origen application then open
-# up all commands, if not then only allow the command to create a new Origen
-# application.
-# Note that the Origen core workspace is now a fully fledged Origen application in
-# its own right.
 begin
+  # If this script has been invoked from within an Origen application then open
+  # up all commands, if not then only allow the command to create a new Origen
+  # application.
   if origen_root
     require "origen/commands"
   else
     require "origen/commands_global"
   end
+rescue Exception => e
+  unless e.is_a?(SystemExit) && e.status == 0
+    puts
+    puts e.message
+    if Origen.app_loaded?
+      # Only print out the application stack trace by default, if verbose logging is
+      # enabled then output the full thing
+      e.backtrace.each do |line|
+        path = Pathname.new(line)
+        puts line if !path.absolute? || Origen.log.level == :verbose
+      end
+    else
+      puts e.backtrace
+    end
+  end
 ensure
   if Origen.app_loaded?
     Origen.app.listeners_for(:on_origen_shutdown).each do |listener|

data/config/version.rb

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

data/lib/origen.rb

@@ -1,5 +1,8 @@
 require 'English'
 require 'pathname'
+# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
+# by the site_config lookup.
+$_origen_invocation_pwd ||= Pathname.pwd
 require 'fileutils'
 require 'origen/site_config'
 require 'origen/operating_systems'
@@ -46,6 +49,7 @@ module Origen
   autoload :CodeGenerators, 'origen/code_generators'
   autoload :Encodings, 'origen/encodings'
   autoload :Log,       'origen/log'
+  autoload :Chips,     'origen/chips'
 
   APP_CONFIG = File.join('config', 'application.rb')
 
@@ -435,6 +439,8 @@ module Origen
           Origen.import_manager.require!
           Origen.remote_manager.require!
         end
+        boot = File.join(root, 'config', 'boot.rb')
+        require boot if File.exist?(boot)
         env = File.join(root, 'config', 'environment.rb')
         require env if File.exist?(env)
         dev = File.join(root, 'config', 'development.rb')
@@ -587,8 +593,6 @@ module Origen
     # Returns the current top-level (DUT) object if one has been defined (by
     # instantiating an object that includes Origen::TopLevel).
     def top_level
-      # TODO: This is called a lot and should probably be cached and expired
-      # on before_target_load
       application.top_level
     end
 

data/lib/origen/application.rb

@@ -95,7 +95,11 @@ module Origen
       RakeLoader.new.load_tasks
     end
 
-    # Returns
+    # Returns a revision controller instance (e.g. Origen::RevisionControl::Git) which has
+    # been configured to point to the local workspace and the remote repository
+    # as defined by Origen.app.config.rc_url. If the revision control URL has not been
+    # defined, or it does not resolve to a recognized revision control system, then this
+    # method will return nil.
     def revision_controller
       if current?
         if config.rc_url
@@ -109,8 +113,7 @@ module Origen
               local:  root,
               remote: config.rc_url
             )
-          else
-            fail "The revision control type could not be worked out from the value config.rc_url: #{config.rc_url}"
+
           end
         else
           @revision_controller ||= RevisionControl::DesignSync.new(
@@ -207,7 +210,10 @@ module Origen
 
     # Returns the current top-level object (the DUT)
     def top_level
-      toplevel_listeners.first
+      @top_level ||= begin
+        t = toplevel_listeners.first
+        t.controller ? t.controller : t if t
+      end
     end
 
     def listeners_for(*args)
@@ -219,7 +225,7 @@ module Origen
       }.merge(options)
       listeners = callback_listeners
       if Origen.top_level
-        listeners -= [Origen.top_level]
+        listeners -= [Origen.top_level.model]
         if options[:top_level]
           if options[:top_level] == :last
             listeners = listeners + [Origen.top_level]
@@ -228,7 +234,13 @@ module Origen
           end
         end
       end
-      listeners = listeners.select { |l| l.respond_to?(callback) }
+      listeners = listeners.select { |l| l.respond_to?(callback) }.map do |l|
+        if l.try(:is_an_origen_model?)
+          l.respond_to_directly?(callback) ? l : l.controller
+        else
+          l
+        end
+      end
       if max && listeners.size > max
         fail "You can only define a #{callback} callback #{max > 1 ? (max.to_s + 'times') : 'once'}, however you have declared it #{listeners.size} times for instances of: #{listeners.map(&:class)}"
       end
@@ -636,7 +648,11 @@ module Origen
           Origen.target.set_signature(@target_load_options)
           $dut = nil
           load environment.file if environment.file
-          load target.file!
+          if target.proc
+            target.proc.call
+          else
+            load target.file!
+          end
         ensure
           $_target_options = nil
         end
@@ -712,6 +728,7 @@ module Origen
     end
 
     def clear_dynamic_resources(type = :transient)
+      @top_level = nil
       if type == :transient
         @transient_resources = nil
       else

data/lib/origen/application/target.rb

@@ -16,6 +16,12 @@ module Origen
       SAVE_FILE = "#{DIR}/.default"      # :nodoc:
       DEFAULT_FILE = "#{DIR}/default.rb" # :nodoc:
 
+      # Not a clean unload, but allows objects to be re-instantiated for testing
+      # @api private
+      def unload!
+        Origen.app.unload_target!
+      end
+
       # Implement a target loop based on the supplied options.
       # The options can contain the keys :target or :targets or neither.
       #
@@ -159,7 +165,18 @@ module Origen
       # attribute of the application.
       #
       # Calling this method does not affect the default target setting in the workspace.
+      #
+      # The target can also be set to a proc to be called instead, this is really
+      # intended to be used for testing purposes:
+      #    Origen.target.temporary = -> { $dut = SomeLocalClass.new }
       def temporary=(name)
+        if name.is_a?(Proc)
+          self.file = nil
+          @proc = name
+          return
+        else
+          @proc = nil
+        end
         tgts = resolve_mapping(name)
         targets = tgts.is_a?(Array) ? tgts : find(tgts)
         if targets.size == 0
@@ -189,6 +206,10 @@ module Origen
       alias_method :switch, :temporary=
       alias_method :switch_to, :temporary=
 
+      def proc
+        @proc
+      end
+
       # Returns a signature for the current target, can be used to track target
       # changes in cases where the name is not unique - i.e. when using a
       # configurable target

data/lib/origen/chips.rb

@@ -0,0 +1,281 @@
+module Origen
+  module Chips
+    autoload :Chip, 'origen/chips/chip.rb'
+    autoload :Design_Entry, 'origen/chips/design_entry.rb'
+    autoload :Doc_Entry, 'origen/chips/doc_entry.rb'
+    autoload :RSS_Note, 'origen/chips/note.rb'
+
+    attr_accessor :_chips, :_designs, :_docs, :_notes
+
+    SPEC_TYPES = [:dc, :ac, :temperature, :supply]
+
+    NOTE_TYPES = [:spec, :doc, :mode, :feature, :sighting]
+
+    SpecTableAttr = Struct.new(:table_text, :show, :padding)
+
+    # A regular Array but print specs to the console via their ID for brevity and
+    # consistency with other APIs (e.g. $dut.regs  # => [:reg1, :reg2])
+    class ChipArray < Array
+      def inspect
+        map(&:name).inspect
+      end
+    end
+
+    # Returns a hash of hash containing all specs/modes
+    # If no spec is specified then all specs are returned via inspect
+    # If a spec is specified, a spec object will be returned if found
+    # in the current mode.  If a mode option is passed and no spec
+    # is passed it will filter the specs inspect display by the mode
+    # and visa-versa
+    def chips(s = nil, options = {})
+      options = {
+        group:       nil,
+        family:      nil,
+        performance: nil,
+        part:        nil,
+        chip:        nil
+      }.update(options || {})
+      _chips
+      if s.nil?
+        return show_chips(options)
+      elsif s.is_a? Hash
+        options.update(s)
+        return show_chips(options)
+      else
+        options[:chip] = s
+        return show_chips(options)
+      end
+    end
+
+    # Define and instantiate a Spec object
+    def chip(name, description, selector = {}, options = {}, &block)
+      # return chips(name, group) unless block_given?
+      _chips
+      name = name_audit(name)
+      group = selector[:group]
+      family = selector[:family]
+      performance = selector[:performance]
+      previous_parts = selector[:previous_parts]
+      power = selector[:power]
+      chip_holder = Chip.new(name, description, previous_parts, power, options)
+      if has_chip?(name, group: group, family: family, performance: performance, creating_chip: true)
+        fail "Chip already exists for chip: #{name}, group: #{group}, family: #{family} for object #{self}"
+      end
+      @_chips[group][family][performance][name] = chip_holder
+    end
+
+    # Returns Boolean based on whether the calling object has any defined specs
+    # If the mode option is selected then the search is narrowed
+    def has_chips?(options = {})
+      _chips
+      options = {
+        group:         nil,
+        family:        nil,
+        performance:   nil,
+        chip:          nil,
+        creating_chip: false
+      }.update(options)
+      if @_chips.nil? || @_chips == {}
+        return false
+      else
+        return !!show_chips(options)
+      end
+    end
+
+    # Check if the current IP has a spec
+    def has_chip?(s, options = {})
+      _chips
+      options = {
+        group:         nil,
+        family:        nil,
+        performance:   nil,
+        chip:          nil,
+        creating_spec: false
+      }.update(options)
+      options[:chip] = s
+      !!show_chips(options)
+    end
+
+    # Define and instantiate a Note object
+    def note(id, type, feature)
+      _notes
+      @_notes[id][type] = RSS_Note.new(id, type, feature)
+    end
+
+    def doc(date, type, revision, description, options = {})
+      _docs
+      @_docs[type][revision] = Doc_Entry.new(date, type, revision, description, options)
+    end
+
+    def design(date, type, revision, description, options = {})
+      _designs
+      @_designs[type][revision] = Design_Entry.new(date, type, revision, description, options)
+    end
+
+    # Returns a Note object from the notes hash
+    def notes(options = {})
+      options = {
+        id:   nil,
+        type: nil
+      }.update(options)
+      notes_found = Hash.new do |h, k|
+        h[k] = {}
+      end
+      _notes.filter(options[:id]).each do |id, hash|
+        hash.filter(options[:type]).each do |type, note|
+          notes_found[id][type] = note
+        end
+      end
+      if notes_found.empty?
+        return nil
+      elsif notes_found.size == 1
+        notes_found.values.first.values.first
+      else
+        return notes_found
+      end
+    end
+
+    def docs(options = {})
+      options = {
+        type: nil,
+        rev:  nil
+      }.update(options)
+      docs_to_be_shown = []
+      filter_hash(_docs, options[:type]).each do |type, hash|
+        filter_hash(hash, options[:rev]).each do |revision, hash_|
+          docs_to_be_shown << hash_
+        end
+      end
+      docs_to_be_shown
+    end
+
+    def designs(options = {})
+      options = {
+        type: nil,
+        rev:  nil
+      }.update(options)
+      designs_to_be_shown = []
+      filter_hash(_designs, options[:type]).each do |type, hash|
+        filter_hash(hash, options[:rev]).each do |revision, hash_|
+          designs_to_be_shown << hash_
+        end
+      end
+      designs_to_be_shown
+    end
+
+    # Delete all specs
+    def delete_all_chips
+      @_chips = nil
+    end
+
+    # Delete all notes
+    def delete_all_notes
+      @_notes = nil
+    end
+
+    # Delete all doc
+    def delete_all_docs
+      @_docs = nil
+    end
+
+    def delete_all_designs
+      @_designs = nil
+    end
+
+    private
+
+    def _chips
+      # 4D hash with group, family, and performance
+      @_chips ||= Hash.new do |h, k|
+        h[k] = Hash.new do |hh, kk|
+          hh[kk] = Hash.new do |hhh, kkk|
+            hhh[kkk] = {}
+          end
+        end
+      end
+    end
+
+    # Two-dimensional hash with note id and type as the keys
+    def _notes
+      @_notes ||= Hash.new do |h, k|
+        h[k] = {}
+      end
+    end
+
+    # Document Type and Revision Number :: 2-D Hash
+    def _docs
+      @_docs ||= Hash.new do |h, k|
+        h[k] = {}
+      end
+    end
+
+    # Document Type and Revision Number :: 2-D Hash
+    def _designs
+      @_designs ||= Hash.new do |h, k|
+        h[k] = {}
+      end
+    end
+
+    # Return a hash based on the filter provided
+    def filter_hash(hash, filter)
+      fail 'Hash argument is not a Hash!' unless hash.is_a? Hash
+      filtered_hash = {}
+      select_logic = case filter
+        when String then 'k[Regexp.new(filter)]'
+        when (Fixnum || Integer || Float || Numeric) then "k[Regexp.new('#{filter}')]"
+        when Regexp then 'k[filter]'
+        when Symbol then
+          'k == filter'
+        when NilClass then true # Return all specs if a filter is set to nil (i.e. user doesn't care about this filter)
+        else true
+      end
+      # rubocop:disable UnusedBlockArgument
+      filtered_hash = hash.select do |k, v|
+        [TrueClass, FalseClass].include?(select_logic.class) ? select_logic : eval(select_logic)
+      end
+      filtered_hash
+    end
+
+    # Filters the 4D hash to find specs for all user visible API
+    def show_chips(options = {})
+      options = {
+        group:             nil,
+        family:            nil,
+        performance:       nil,
+        part:              nil,
+        chips_to_be_shown: ChipArray.new,
+        creating_chip:     false
+      }.update(options)
+      chips_to_be_shown = options[:chips_to_be_shown]
+      filter_hash(_chips, options[:group]).each do |_group, hash|
+        filter_hash(hash, options[:family]).each do |_family, hash_|
+          filter_hash(hash_, options[:performance]).each do |_performance, hash__|
+            filter_hash(hash__, options[:part]).each do |_part, chip|
+              chips_to_be_shown << chip
+            end
+          end
+        end
+      end
+      # If no specs were found must check the possibility another search
+      # should be started with mode set to :local or :global
+      if chips_to_be_shown.empty?
+        # Don't want to re-call this method if the callee is trying to create a spec and just wants to know
+        # if there is a spec with the exact same options
+        if options[:creating_chip] == false
+          # Doesn't make sense to recall the method however if the mode is already set to :global or :local
+          options[:chips_to_be_shown] = chips_to_be_shown
+          Origen.log.debug "re-calling show_chips with options #{options}"
+          return show_chips(options)
+        end
+        Origen.log.debug "Returning no chips for options #{options}"
+        return nil
+      elsif chips_to_be_shown.size == 1
+        Origen.log.debug "returning one spec #{chips_to_be_shown.first.part_name}"
+        return chips_to_be_shown.first
+      else
+        Origen.log.debug "returning an array of specs during initial search: #{chips_to_be_shown}"
+        return chips_to_be_shown
+      end
+    end
+  end
+end

data/lib/origen/chips/chip.rb

@@ -0,0 +1,167 @@
+module Origen
+  module Chips
+    class Chip
+      # Part Name for the SoC, usually this will be the ID
+      attr_accessor :part_name
+
+      # Description for the Part, will be used as part of the RSS feed
+      attr_accessor :description
+
+      # Previous Roadmap Parts.  This will allow for a backwards viewable list so that
+      # previous parts can have an upgrade path
+      attr_accessor :previous_parts
+
+      # Power Number
+      attr_accessor :power
+
+      # L2 Ram Size
+      attr_accessor :l2_ram
+
+      # L3 Ram Size
+      attr_accessor :l3_ram
+
+      # Package for the Part
+      attr_accessor :package_type
+
+      # Speed for the Cores
+      attr_accessor :core_speed
+
+      attr_accessor :_designs, :_docs, :_notes
+
+      def initialize(part_name, description, previous_parts, power, options = {})
+        @part_name = part_name
+        @description = description
+        @previous_parts = previous_parts
+        @power = power
+        @l2_ram = options[:l2_ram]
+        @l3_ram = options[:l3_ram]
+        @package_type = options[:package_type]
+        @core_speed = options[:core_speed]
+      end
+
+      # Define and instantiate a Note object
+      def note(id, type, feature)
+        _notes
+        @_notes[id][type] = RSS_Note.new(id, type, feature)
+      end
+
+      def doc(date, type, revision, description, options = {})
+        _docs
+        @_docs[type][revision] = Doc_Entry.new(date, type, revision, description, options)
+      end
+
+      def design(date, type, revision, description, options = {})
+        _designs
+        @_designs[type][revision] = Design_Entry.new(date, type, revision, description, options)
+      end
+
+      # Returns a Note object from the notes hash
+      def notes(options = {})
+        options = {
+          id:   nil,
+          type: nil
+        }.update(options)
+        notes_found = Hash.new do |h, k|
+          h[k] = {}
+        end
+        _notes.filter(options[:id]).each do |id, hash|
+          hash.filter(options[:type]).each do |type, note|
+            notes_found[id][type] = note
+          end
+        end
+        if notes_found.empty?
+          return nil
+        elsif notes_found.size == 1
+          notes_found.values.first.values.first
+        else
+          return notes_found
+        end
+      end
+
+      def docs(options = {})
+        options = {
+          type: nil,
+          rev:  nil
+        }.update(options)
+        docs_to_be_shown = []
+        filter_hash(_docs, options[:type]).each do |type, hash|
+          filter_hash(hash, options[:rev]).each do |revision, hash_|
+            docs_to_be_shown << hash_
+          end
+        end
+        docs_to_be_shown
+      end
+
+      def designs(options = {})
+        options = {
+          type: nil,
+          rev:  nil
+        }.update(options)
+        designs_to_be_shown = []
+        filter_hash(_designs, options[:type]).each do |type, hash|
+          filter_hash(hash, options[:rev]).each do |revision, hash_|
+            designs_to_be_shown << hash_
+          end
+        end
+        designs_to_be_shown
+      end
+
+      # Delete all notes
+      def delete_all_notes
+        @_notes = nil
+      end
+
+      # Delete all doc
+      def delete_all_docs
+        @_docs = nil
+      end
+
+      def delete_all_designs
+        @_designs = nil
+      end
+
+      private
+
+      # Two-dimensional hash with note id and type as the keys
+      def _notes
+        @_notes ||= Hash.new do |h, k|
+          h[k] = {}
+        end
+      end
+
+      # Document Type and Revision Number :: 2-D Hash
+      def _docs
+        @_docs ||= Hash.new do |h, k|
+          h[k] = {}
+        end
+      end
+
+      # Document Type and Revision Number :: 2-D Hash
+      def _designs
+        @_designs ||= Hash.new do |h, k|
+          h[k] = {}
+        end
+      end
+
+      # Return a hash based on the filter provided
+      def filter_hash(hash, filter)
+        fail 'Hash argument is not a Hash!' unless hash.is_a? Hash
+        filtered_hash = {}
+        select_logic = case filter
+          when String then 'k[Regexp.new(filter)]'
+          when (Fixnum || Integer || Float || Numeric) then "k[Regexp.new('#{filter}')]"
+          when Regexp then 'k[filter]'
+          when Symbol then
+            'k == filter'
+          when NilClass then true # Return all specs if a filter is set to nil (i.e. user doesn't care about this filter)
+          else true
+        end
+        # rubocop:disable UnusedBlockArgument
+        filtered_hash = hash.select do |k, v|
+          [TrueClass, FalseClass].include?(select_logic.class) ? select_logic : eval(select_logic)
+        end
+        filtered_hash
+      end
+    end
+  end
+end

data/lib/origen/chips/design_entry.rb

@@ -0,0 +1,36 @@
+module Origen
+  module Chips
+    class Design_Entry
+      # date that the document was released
+      attr_accessor :date
+
+      # document type, e.g. Reference Manual, One Pager, Data Sheet
+      attr_accessor :type
+
+      # revision
+      attr_accessor :revision
+
+      # nda
+      attr_accessor :nda
+
+      # released status
+      attr_accessor :release
+
+      # location
+      attr_accessor :location
+
+      # description of the item
+      attr_accessor :description
+
+      def initialize(date, type, revision, description, options = {})
+        @date = date
+        @type = type
+        @revision = revision
+        @description = description
+        @nda = options[:nda]
+        @release = options[:release]
+        @location = options[:location]
+      end
+    end
+  end
+end

data/lib/origen/chips/doc_entry.rb

@@ -0,0 +1,36 @@
+module Origen
+  module Chips
+    class Doc_Entry
+      # date that the document was released
+      attr_accessor :date
+
+      # document type, e.g. Reference Manual, One Pager, Data Sheet
+      attr_accessor :type
+
+      # revision
+      attr_accessor :revision
+
+      # nda
+      attr_accessor :nda
+
+      # released status
+      attr_accessor :release
+
+      # location
+      attr_accessor :location
+
+      # description
+      attr_accessor :description
+
+      def initialize(date, type, revision, description, options = {})
+        @date = date
+        @type = type
+        @revision = revision
+        @description = description
+        @nda = options[:nda]
+        @release = options[:release]
+        @location = options[:location]
+      end
+    end
+  end
+end

data/lib/origen/chips/note.rb

@@ -0,0 +1,14 @@
+module Origen
+  module Chips
+    # This class is used to store spec note information used to document IP
+    class RSS_Note
+      attr_accessor :id, :type, :feature
+
+      def initialize(id, type, feature)
+        @id = id
+        @type = type
+        @feature = feature
+      end
+    end
+  end
+end

data/lib/origen/controller.rb

@@ -53,6 +53,7 @@ module Origen
       end
     end
 
+    # Returns the controller's model
     def model
       @model ||= begin
         if self.class.path_to_model
@@ -61,12 +62,22 @@ module Origen
       end
     end
 
+    # 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.
+    def controller
+      self
+    end
+
     def respond_to?(*args)
-      if model
-        super(*args) || model.respond_to?(*args)
-      else
-        super(*args)
-      end
+      super || !!(!@respond_directly && model && model.respond_to_directly?(*args))
+    end
+
+    def respond_to_directly?(*args)
+      @respond_directly = true
+      result = respond_to?(*args)
+      @respond_directly = false
+      result
     end
 
     # Used to proxy all method and attribute requests not implemented on the controller

data/lib/origen/generator/job.rb

@@ -120,9 +120,7 @@ module Origen
               Origen.app.stats.failed_patterns += 1
             end
           else
-            puts e.message
-            puts e.backtrace
-            exit 1
+            raise
           end
         end
       end

data/lib/origen/generator/pattern.rb

@@ -224,28 +224,30 @@ module Origen
         c2 '*' * 75
         c2 'ENVIRONMENT:'
         c2 '  Application'
-        if Origen.app.rc.git?
-          c2 "    Source:    #{Origen.config.rc_url}"
-        else
-          c2 "    Vault:     #{Origen.config.vault}"
+        if Origen.app.rc
+          if Origen.app.rc.git?
+            c2 "    Source:    #{Origen.config.rc_url}"
+          else
+            c2 "    Vault:     #{Origen.config.vault}"
+          end
         end
         c2 "    Version:   #{Origen.app.version}"
         c2 "    Workspace: #{Origen.root}"
-        if Origen.app.rc.git?
+        if Origen.app.rc && Origen.app.rc.git?
           begin
-            status = "#{Origen.app.rc.current_branch}(#{Origen.app.rc.current_commit})"
-            status += ' (+local edits)' unless Origen.app.rc.local_modifications.empty?
+            @branch ||= Origen.app.rc.current_branch
+            @commit ||= Origen.app.rc.current_commit
+            status = "#{@branch}(#{@commit})"
+            @pattern_local_mods = !Origen.app.rc.local_modifications.empty? unless @pattern_local_mods_fetched
+            @pattern_local_mods_fetched = true
+            status += ' (+local edits)' if @pattern_local_mods
             c2 "    Branch:    #{status}"
           rescue
             # No problem, we did our best
           end
         end
         c2 '  Origen'
-        if Origen.app.rc.git?
-          c2 '    Source:    https://github.com/Origen-SDK/origen'
-        else
-          c2 "    Vault:     #{Origen.config.vault}"
-        end
+        c2 '    Source:    https://github.com/Origen-SDK/origen'
         c2 "    Version:   #{Origen.version}"
         c2 "    Workspace: #{Origen.top}"
         unless Origen.plugins.empty?

data/lib/origen/model.rb

@@ -27,6 +27,17 @@ module Origen
       end
     end
 
+    def is_an_origen_model?
+      true
+    end
+
+    # 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.
+    def model
+      self
+    end
+
     def log
       Origen.log
     end
@@ -81,8 +92,7 @@ module Origen
     def _resolve_controller_class
       klass = self.class
       while klass != Object
-        model_class = klass.to_s.split('::').last
-        controller_class = "#{model_class}Controller"
+        controller_class = "#{klass}Controller"
         if eval("defined? #{controller_class}")
           return eval(controller_class)
         elsif eval("defined? ::#{controller_class}")
@@ -248,6 +258,17 @@ module Origen
       end
     end
 
+    def respond_to?(*args)
+      super || !!(!@respond_directly && controller && controller.respond_to_directly?(*args))
+    end
+
+    def respond_to_directly?(*args)
+      @respond_directly = true
+      result = respond_to?(*args)
+      @respond_directly = false
+      result
+    end
+
     private
 
     def _modes

data/lib/origen/site_config.rb

@@ -39,7 +39,12 @@ module Origen
 
     def configs
       @configs ||= begin
-        path = Pathname.pwd
+        # This global is set when Origen is first required, it generally means that what is considered
+        # to be the pwd for the purposes of looking for a site_config file is the place from where the
+        # user invoked Origen. Otherwise if the running app switches the PWD it can lead to confusing
+        # behavior - this was a particular problem when testing the new app generator which switches the
+        # pwd to /tmp to build the new app
+        path = $_origen_invocation_pwd
         configs = []
         # Add any site_configs from where we are currently running from, i.e. the application
         # directory area

data/lib/origen/specs.rb

@@ -207,6 +207,7 @@ module Origen
           end
         end
       end
+      exhibits_to_be_shown
     end
 
     def doc_resources(options = {})

data/lib/origen/specs/note.rb

@@ -2,7 +2,7 @@ module Origen
   module Specs
     # This class is used to store spec note information used to document IP
     class Note
-      attr_accessor :id, :type, :mode, :audience, :text, :markup
+      attr_accessor :id, :type, :mode, :audience, :text, :markup, :internal_comment
 
       def initialize(id, type, options = {})
         @id = id
@@ -11,6 +11,7 @@ module Origen
         @audience = options[:audience]
         @text = options[:text]
         @markup = options[:markup]
+        @internal_comment = options[:internal_comment]
       end
     end
   end

data/lib/origen/sub_blocks.rb

@@ -11,6 +11,13 @@ module Origen
         # address API, but will accept any of these
         @reg_base_address = options.delete(: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)
+            @reg_base_address = @reg_base_address[options[:_instance]]
+          elsif options[:base_address_step]
+            @reg_base_address = @reg_base_address + (options[:_instance] * options[:base_address_step])
+          end
+        end
         @domain_names = [options.delete(:domain) || options.delete(:domains)].flatten.compact
         @domain_specified = !@domain_names.empty?
         @path = options.delete(:path)
@@ -187,8 +194,12 @@ module Origen
     include Path
 
     # Returns a hash containing all immediate children of the given sub-block
-    def sub_blocks
-      @sub_blocks ||= {}.with_indifferent_access
+    def sub_blocks(*args)
+      if args.empty?
+        @sub_blocks ||= {}.with_indifferent_access
+      else
+        sub_block(*args)
+      end
     end
     alias_method :children, :sub_blocks
 
@@ -223,46 +234,64 @@ module Origen
     end
 
     def sub_block(name, options = {})
-      class_name = options.delete(:class_name)
-      if class_name
-        begin
-          klass = eval("::#{namespace}::#{class_name}")
-        rescue
+      if i = options.delete(:instances)
+        a = []
+        options[:_instance] = i
+        i.times do |j|
+          o = options.dup
+          o[:_instance] = j
+          a << sub_block("#{name}#{j}", o)
+        end
+        define_singleton_method "#{name}s" do
+          a
+        end
+        a
+      else
+        class_name = options.delete(:class_name)
+        if class_name
           begin
-            klass = eval(class_name)
+            klass = eval("::#{namespace}::#{class_name}")
           rescue
             begin
-              klass = eval("#{self.class}::#{class_name}")
+              klass = eval(class_name)
             rescue
-              puts "Could not find class: #{class_name}"
-              raise 'Unknown sub block class!'
+              begin
+                klass = eval("#{self.class}::#{class_name}")
+              rescue
+                puts "Could not find class: #{class_name}"
+                raise 'Unknown sub block class!'
+              end
             end
           end
+        else
+          klass = Origen::SubBlock
         end
-      else
-        klass = Origen::SubBlock
-      end
-      unless klass.respond_to?(:includes_origen_model)
-        puts 'Any class which is to be instantiated as a sub_block must include Origen::Model,'
-        puts "add this to #{klass}:"
-        puts ''
-        puts '  include Origen::Model'
-        puts ''
-        fail 'Sub block does not include Origen::Model!'
-      end
-      block = klass.new(options.merge(parent: self))
-      block.name = name
-      sub_blocks[name] = block
-      if respond_to?(name)
-        # puts "Tried to create a sub-block named #{name} in #{self.class}, but it already has a method with this name!"
-        # puts "To avoid confusion rename one of them and try again!"
-        # raise "Non-unique sub-block name!"
-      else
-        define_singleton_method name do
-          sub_blocks[name]
+        unless klass.respond_to?(:includes_origen_model)
+          puts 'Any class which is to be instantiated as a sub_block must include Origen::Model,'
+          puts "add this to #{klass}:"
+          puts ''
+          puts '  include Origen::Model'
+          puts ''
+          fail 'Sub block does not include Origen::Model!'
+        end
+        block = klass.new(options.merge(parent: self))
+        block.name = name
+        if sub_blocks[name]
+          fail "You have already defined a sub-block named #{name} within class #{self.class}"
+        else
+          sub_blocks[name] = block
+          if respond_to?(name)
+            # puts "Tried to create a sub-block named #{name} in #{self.class}, but it already has a method with this name!"
+            # puts "To avoid confusion rename one of them and try again!"
+            # raise "Non-unique sub-block name!"
+          else
+            define_singleton_method name do
+              sub_blocks[name]
+            end
+          end
         end
+        block
       end
-      block
     end
 
     def namespace

data/lib/origen/users.rb

@@ -8,9 +8,10 @@ module Origen
       # Had to do some shenanigans here due to Origen.root not being available
       # when this file is included, only load the users from the app once a user
       # method is first called
-      return @app_users if @app_users
-      require File.join(Origen.root, 'config', 'users')
-      @app_users = users
+      # return @app_users if @app_users
+      # require File.join(Origen.root, 'config', 'users')
+      # @app_users = users
+      []
     end
 
     # Returns a user object representing the current user, will return a default

data/lib/origen/users/user.rb

@@ -66,7 +66,7 @@ module Origen
       end
 
       def name
-        @name || name_from_rc || @id
+        @name ||= name_from_rc || @id
       end
 
       def name_from_rc
@@ -74,7 +74,7 @@ module Origen
       end
 
       def email
-        @email || email_from_rc || begin
+        @email ||= email_from_rc || begin
           if Origen.site_config.email_domain
             "#{id}@#{Origen.site_config.email_domain}"
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-06 00:00:00.000000000 Z
+date: 2015-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -390,17 +390,14 @@ extra_rdoc_files: []
 files:
 - bin/origen
 - config/application.rb
+- config/boot.rb
 - config/commands.rb
-- config/development.rb
-- config/environment.rb
-- config/rgen.policy
 - config/rubocop/easy.yml
 - config/rubocop/easy_disabled.yml
 - config/rubocop/easy_enabled.yml
 - config/rubocop/strict.yml
 - config/rubocop/strict_disabled.yml
 - config/rubocop/strict_enabled.yml
-- config/users.rb
 - config/version.rb
 - helpers/url.rb
 - lib/c99/doc_interface.rb
@@ -431,6 +428,11 @@ files:
 - lib/origen/callbacks.rb
 - lib/origen/chip_mode.rb
 - lib/origen/chip_package.rb
+- lib/origen/chips.rb
+- lib/origen/chips/chip.rb
+- lib/origen/chips/design_entry.rb
+- lib/origen/chips/doc_entry.rb
+- lib/origen/chips/note.rb
 - lib/origen/client.rb
 - lib/origen/code_generators.rb
 - lib/origen/code_generators/actions.rb
@@ -720,7 +722,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Semiconductor Developer's Kit

data/config/rgen.policy

@@ -1,7 +0,0 @@
-fs-ruby-/2.1.5-p273
-ds-designsync-/v6r2013x
-fs-pi-/2012.3.3
-gcc-/4.7.3
-libxml2-/2.9.0
-TWW-pkgconfig-/0.25
-OSS-git-/2.3.2

data/config/users.rb

@@ -1,20 +0,0 @@
-# This file defines the users associated with your project, it is basically the
-# mailing list for release notes.
-# This module must define a method named "users" which returns an array of user
-# objects.
-# You can split your users into "admin" and "user" groups, the main difference
-# between the two is that admin users will get all tag emails, users will get
-# emails on external/official releases only.
-# Users are also prohibited from running the tag_project script, but this is
-# really just to prevent a casual user from executing it inadvertently and it is
-# not intended to be a serious security gate.
-module Origen
-  module Users
-    def users
-      @users ||= [
-        # Admins
-        User.new('Stephen McGinty', 'stephen.f.mcginty@gmail.com', :admin),
-      ]
-    end
-  end
-end