origen 0.33.3 → 0.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df84c7214237f807371534766be022afc95ba8fe
-  data.tar.gz: 98751baf8dc8fa699ed55fada8c0b347a9b5a07d
+  metadata.gz: c0607d958ddc8e398df2a7272ac4adf9655c6e78
+  data.tar.gz: dfe13eb62b19e431b6cd3de07afb48aa4fddf1af
 SHA512:
-  metadata.gz: dc012d1ca8883e85b04019b3e09355864169da0eb166049053b708abc758c3fab872eeb205aa53d492c36cbd05cc875753b641d5828ebfe21e488e89646aae31
-  data.tar.gz: a206be55eab62f8babecfb3394e0871db316addea6549c4a5d32a7e1743358f5c4bc76f7d54b119e6a531880c142cc96bd186a1aadf2fef4e5b8b23d8fb80c89
+  metadata.gz: 0298c4113fc30bd3e4911710092853158bfe14a37f6a077312df8936f669ca5f1ed52e3b40c2d87388b628cd1a87eaa4fe78764f240da4e56f5f07c50020006d
+  data.tar.gz: e2bb350fc891d8fea28d82e72b47cf462c9f94468cdccb19e8c477cf09bdfcaf78e33644a03004a6e84c89dd96c9a1aa3d00c8b042b6e86c90874a95108e677f

data/config/application.rb

@@ -43,8 +43,8 @@ class OrigenCoreApplication < Origen::Application
   
   config.pattern_prefix = "nvm"
 
-  config.pattern_header do
-    cc "This is a dummy pattern created by the Origen test environment"
+  config.application_pattern_header do |options|
+    "This is a dummy pattern created by the Origen test environment"
   end
 
   # Add any directories or files not intended to be under change management control
@@ -109,6 +109,16 @@ class OrigenCoreApplication < Origen::Application
     end
   end
 
+  def after_web_compile(options)
+    Origen.app.plugins.each do |plugin|
+      if plugin.config.shared && plugin.config.shared[:origen_guides]
+        Origen.app.runner.launch action: :compile,
+                                 files:  File.join(plugin.root, plugin.config.shared[:origen_guides]),
+                                 output: File.join('web', 'content', 'guides')
+      end
+    end
+  end
+
   # Ensure that all tests pass before allowing a release to continue
   def validate_release
     if !system("origen specs") || !system("origen examples")

data/config/commands.rb

@@ -16,7 +16,79 @@ when "tags"
 
 when "specs"
   require "rspec"
-  exit RSpec::Core::Runner.run(['spec'])
+
+  options = {}
+  opt_parser = OptionParser.new do |opts|
+    opts.banner = [
+      'Run the specs unit tests',
+      'Usage: origen specs [filename_substrings...] [options]',
+      "Note: all files must reside in #{Origen.app.root}/specs for filename substrings",
+      "E.g.: origen specs site_config #=> runs only specs in filenames matching 'site_config'"
+    ].join("\n")
+    opts.on('-h', '--help', 'Show this help message') do |h|
+      puts opt_parser
+      exit!
+    end
+  end
+  opt_parser.parse! ARGV
+
+  # Search for the filenames given. 
+  spec_files = ARGV.map do |file|
+    f = Pathname.new(file)
+    dir = Origen.app.root.join('spec')
+
+    # Find any files that match the name. Include all these files.
+    # Note that this will map a string to an array, so we'll flatten the array later.
+    # Also, we'll only search for .rb files in spec. Append that to the glob if no file ext is provided.
+    if f.exist? && f.extname == '.rb'
+      # This is a hard-coded path. Don't glob this, just make sure its witin the spec directory.
+      File.expand_path(f)
+    elsif f.extname == '.rb'
+      # Search includes the extension, so don't add it.
+      # (limited to .rb files)
+      Dir.glob(dir.join("**/*#{f}"))
+    else
+      # Search for matching ruby files.
+      # (limited to .rb files)
+      Dir.glob(dir.join("**/*#{f}*.rb"))
+    end
+  end
+  spec_files.flatten!
+
+  if ARGV.empty?
+    # No filename substrings given. Run all *_spec files in spec/ directory
+    spec_files = ['spec']
+  elsif spec_files.empty? && !ARGV.empty?
+    # The spec files to run is empty, but file substring were given.
+    # Report that no files were found and exit.
+    Origen.app!.fail!(message: "No matching spec files could be found at #{Origen.app.root}/spec for patterns: #{ARGV.join(', ')}")
+  else
+    # Filename substrings were given and matching files were found. List the files just for user awareness.
+    Origen.log.info "Found matching specs files for patterns: #{ARGV.join(', ')}"
+    spec_files.each { |f| Origen.log.info(f) }
+  end
+
+  current_mode = Origen.mode.instance_variable_get(:@current_mode)
+  Origen.mode = :debug
+  Origen.app.session.origen_core[:mode] = Origen.mode.to_s
+  begin
+    status = RSpec::Core::Runner.run(spec_files)
+  rescue SystemExit => e
+    Origen.log.error "Unexpected SystemExit reached. Reporting failure status..."
+    status = 1
+  end
+  Origen.mode = current_mode
+  Origen.app.session.origen_core[:mode] = Origen.mode.to_s
+  
+  # One kind of confusing thing is that Specs can still print the 'pass'/'success' verbiage even when it actually failed.
+  # This is due to rspec itself catching the errors, so there's no exception to catch from outside Rspec.
+  # Most likely the user will see red and see that nothing was actually run, but print a reassuring message from Origen saying that the specs actually failed,
+  # despite what Rspec's verbiage says.
+  if status == 1
+    Origen.log.error "Some errors occurred outside of the examples: received exit status 1 (failure). Please review RSpec output for details."
+  end
+
+  exit(status)
 
 when "examples", "test"  
   Origen.load_application

data/config/version.rb

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

data/lib/origen.rb

@@ -660,6 +660,12 @@ unless defined? RGen::ORIGENTRANSITION
         @running_remotely = val
       end
 
+      # Returns true if Origen is running interactively. That is, the command was 'origen i'
+      def running_interactively?
+        !!@running_interactively
+      end
+      alias_method :interactive?, :running_interactively?
+
       # Returns true if Origen is running with the -d or --debug switches enabled
       def debug?
         @debug || false
@@ -671,7 +677,7 @@ unless defined? RGen::ORIGENTRANSITION
       end
 
       def debugger_enabled?
-        @debug
+        debug?
       end
 
       def development?

data/lib/origen/application.rb

@@ -900,6 +900,53 @@ END
       @target_instantiated
     end
 
+    # Prepends the application name to the fail message and throws a RuntimeError exception.
+    # Very similar to the plain <code>fail</code> method with the addition of prepending the application name.
+    # Prepended message: 'Fail in app.name: '
+    # If no message if provided, message is set to 'Fail in app.name'
+    # @param message [String] Message to print with the exception. If the message option is nil, a default message will be used instead.
+    # @param exception_class [Class] Custom Exception class to throw. May require the full namespace, e.g. <code>Origen::OrigenError</code> instead of just <code>OrigenError</code>.
+    # @raise [RuntimeError, exception_class] Option exception_class is raised, defaulting to <code>RuntimeError</code>.
+    def fail(message: nil, exception_class: RuntimeError)
+      message.nil? ? message = "Fail in #{name}" : message = "Fail in #{name}: #{message}"
+      e = exception_class.new(message)
+
+      # If the caller is Origen.app.fail!, remove this caller from the backtrace, leaving where Origen.app.fail! was called.
+      # As an aside, if there's an exception raised in Origen.app.fail!, then that would actually raise a Kernel.fail, so there's no concern with masking
+      # out a problem with Origen.app.fail! by doing this.
+      if caller[0] =~ (/lib\/origen\/application.rb:\d+:in `fail!'/)
+        e.set_backtrace(caller[1..-1])
+      else
+        e.set_backtrace(caller)
+      end
+      Kernel.fail(e)
+    end
+
+    # Similar to Origen.app.fail, but will instead print the message using Origen.log.error and exit the current process (using <code>exit 1</code>)
+    # UNLESS --debug is used. In those cases, <code>exit</code> will not be used and instead this will behave the same as {Origen::Application#fail}.
+    # Purpose here is to allow fail! for normal usage, but provide more details as to where fail! was used when running in debug.
+    # @param message [String] Message to print with the exception. If the message option is nil, a default message will be used instead.
+    # @param exception_class [Class] Custom Exception class to throw. May require the full namespace.
+    # @param exit_status [Integer] Exit status to use when exiting the application.
+    # @raise [RuntimeError, SystemExit, exception_class] When debug is disabled, <code>SystemExit</code> will be raised.
+    #   When debug is enabled, exception_class will be raised, defaulting to <code>RuntimeError</code>.
+    def fail!(message: nil, exception_class: RuntimeError, exit_status: 1)
+      if Origen.debug?
+        # rubocop:disable Style/RedundantSelf
+        self.fail(message: message, exception_class: exception_class)
+        # rubocop:enable Style/RedundantSelf
+      else
+        begin
+          # rubocop:disable Style/RedundantSelf
+          self.fail(message: message, exception_class: exception_class)
+          # rubocop:enable Style/RedundantSelf
+        rescue exception_class => e
+          Origen.log.error(e.message)
+          exit exit_status
+        end
+      end
+    end
+
     # This method is called just after an application inherits from Origen::Application,
     # allowing the developer to load classes in lib and use them during application
     # configuration.

data/lib/origen/application/configuration.rb

@@ -29,7 +29,8 @@ module Origen
       # below for more details on this.
       ATTRS_THAT_DEPEND_ON_TARGET = [
         :output_directory, :reference_directory, :pattern_postfix, :pattern_prefix,
-        :pattern_header, :release_directory, :pattern_name_translator, :pattern_directory, :pattern_output_directory,
+        :pattern_header, :current_plugin_pattern_header, :application_pattern_header, :shared_pattern_header,
+        :release_directory, :pattern_name_translator, :pattern_directory, :pattern_output_directory,
         :proceed_with_pattern, :test_program_output_directory, :test_program_source_directory,
         :test_program_template_directory, :referenced_pattern_list, :program_prefix, :web_directory,
         :web_domain
@@ -51,6 +52,10 @@ module Origen
         :test_program_template_directory, :referenced_pattern_list
       ]
 
+      ATTRS_THAT_ARE_SET_TO_A_BLOCK = [
+        :current_plugin_pattern_header, :application_pattern_header, :shared_pattern_header, #:pattern_footer
+      ]
+
       def log_deprecations
         # unless imports.empty?
         #  Origen.deprecate "App #{app.name} uses config.imports this will be removed in Origen V3 and a Gemfile/.gemspec should be used instead"
@@ -146,7 +151,9 @@ module Origen
                   fail "You have attempted to access Origen.config.#{name} before instantiating the target"
                 end
               end
-              var.call
+
+              # Some config variables should be left as a block/proc object. If this is one of those, just return the var.
+              ATTRS_THAT_ARE_SET_TO_A_BLOCK.include?(name) ? var : var.call
             else
               var
             end

data/lib/origen/commands/interactive.rb

@@ -52,6 +52,8 @@ Usage: origen i [options]
   Origen.target.temporary = options[:target] if options[:target]
   Origen.app.load_target!
   Origen.app.runner.prepare_directories # Ensure tmp et all exist
+
+  Origen.instance_variable_set(:@running_interactively, true)
   listeners_for(:interactive_startup).each(&:interactive_startup)
 
   begin

data/lib/origen/commands/web.rb

@@ -50,6 +50,7 @@ The following options are available:
     opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
     opts.on('--no-serve', "Don't serve the website after compiling without the remote option") { options[:no_serve] = true }
     opts.on('-c', '--comment COMMENT', String, 'Supply a commit comment when deploying to Git') { |o| options[:comment] = o }
+
     # Apply any application option extensions to the OptionParser
     Origen::CommandHelpers.extend_options(opts, app_options, options)
     opts.separator ''
@@ -73,14 +74,10 @@ The following options are available:
 
   def self._start_server
     # Get the current host
-    host = `hostname`.strip.downcase
-    if Origen.running_on_windows?
-      domain = 'fsl.freescale.net'
-    else
-      domain = `dnsdomainname`.strip
-    end
-    # Get a free port
     require 'socket'
+    host = Socket.gethostbyname(Socket.gethostname).first.downcase
+
+    # Get a free port
     port = 8000 # preferred port
     begin
       server = TCPServer.new('127.0.0.1', port)
@@ -92,11 +89,7 @@ The following options are available:
     server.close
     # Start the server
     puts ''
-    if host.include? domain
-      puts "Point your browser to this address:  http://#{host}:#{port}"
-    else
-      puts "Point your browser to this address:  http://#{host}#{domain.empty? ? '' : '.' + domain}:#{port}"
-    end
+    puts "Point your browser to this address:  http://#{host}:#{port}"
     puts ''
     puts 'To shut down the server use CTRL-C'
     puts ''

data/lib/origen/generator/pattern.rb

@@ -201,21 +201,22 @@ module Origen
 
       def header
         Origen.tester.pre_header if Origen.tester.doc?
-        c2 '*' * 75
+        inject_separator
         if $desc
           c2 'DESCRIPTION:'
           $desc.split(/\n/).each { |line| cc line }
-          c2 '*' * 75
+          inject_separator
         end
         c2 'GENERATED:'
         c2 "  Time:    #{Origen.launch_time}"
         c2 "  By:      #{Origen.current_user.name}"
+        c2 "  Mode:    #{Origen.mode}"
         l = "  Command: origen g #{job.requested_pattern} -t #{Origen.target.file.basename}"
         if Origen.environment && Origen.environment.file
           l += " -e #{Origen.environment.file.basename}"
         end
         c2(l)
-        c2 '*' * 75
+        inject_separator
         c2 'ENVIRONMENT:'
         c2 '  Application'
         if Origen.app.rc
@@ -251,13 +252,102 @@ module Origen
             c2 "    #{plugin.name}:".ljust(30) + plugin.version
           end
         end
-        c2 '*' * 75
+        inject_separator
+
+        unless Origen.app.plugins.empty?
+          # Plugins can use config.shared_pattern_header to inject plugin-specific comments into the patterns header
+          header_printed = false
+          Origen.app.plugins.sort_by { |p| p.name.to_s }.each do |plugin|
+            unless plugin.config.shared_pattern_header.nil?
+              unless header_printed
+                c2 'Header Comments From Shared Plugins:'
+                header_printed = true
+              end
+              inject_pattern_header(
+                config_loc:      plugin,
+                scope:           :shared_pattern_header,
+                message:         "Header Comments From Shared Plugin: #{plugin.name}:",
+                message_spacing: 2,
+                line_spacing:    4,
+                no_separator:    true
+              )
+            end
+          end
+          inject_separator if header_printed
+        end
+
+        if Origen.app.plugins.current && !Origen.app.plugins.current.config.send(:current_plugin_pattern_header).nil?
+          # The top level plugin (if one is set) can further inject plugin-specific comment into the header.
+          # These will only appear if the plugin is the top-level plugin though.
+          inject_pattern_header(
+            config_loc: Origen.app.plugins.current,
+            scope:      :current_plugin_pattern_header,
+            message:    "Header Comments From The Current Plugin: #{Origen.app.plugins.current.name}:"
+          )
+        end
+
+        unless Origen.app.config.send(:application_pattern_header).nil?
+          inject_pattern_header(
+            config_loc: Origen.app,
+            scope:      :application_pattern_header,
+            message:    "Header Comments From Application: #{Origen.app.name}:"
+          )
+        end
+
         if Origen.config.pattern_header
-          c2 '*' * 75
+          Origen.log.deprecated 'Origen.config.pattern_header is deprecated.'
+          Origen.log.deprecated 'Please use config.shared_pattern_header, config.application_pattern_header, or config.current_plugin_pattern_header instead.'
+          inject_separator
         end
         Origen.tester.close_text_block if Origen.tester.doc?
       end
 
+      def inject_separator(options = {})
+        separator_length = options[:size] || 75
+        c2('*' * separator_length)
+      end
+
+      def inject_pattern_header(config_loc:, scope:, message:, **options)
+        message_spacing = options[:message_spacing] || 0
+        line_spacing = options[:line_spacing] || 2
+        no_separator = options[:no_separator] || false
+
+        # Print a warning if any of the pattern header configs have an arity greater than 1.
+        # Anything over 1 won't be used and may cause confusion.
+        if config_loc.config.send(scope).arity > 1
+          Origen.log.warning "Configuration in #{config_loc.name} has attribute ##{scope} whose block has an arity > 1"
+          Origen.log.warning 'Calls to this attribute from Origen are only given an options hash parameter. Any other arguments are extraneous'
+        end
+
+        # Inject the header based on these guidelines:
+        # 1. if pattern_header is nil, ignore all. Don't print he message, don't do anything.
+        # 2. if pattern header is a block, print the message, then call the block. This allows the user to format everything themselves.
+        #    i.e., use of cc, ss, etc. is allowed here, at the expense of the user being responsible for the formatting.
+        # 3. if a string, print the message and format the string as 'cc'
+        # 4. if an array, print the message and format the array as a subsequent 'cc' calls.
+        injection = config_loc.config.send(scope).call({})
+        if injection.nil?
+          # Do nothing. It is assumed in this acase that the pattern header has not comments to add at this scope.
+          return
+        elsif injection.is_a?(String)
+          c2(' ' * message_spacing + message)
+          c2(' ' * line_spacing + injection.to_s)
+          inject_separator(options) unless no_separator
+        elsif injection.is_a?(Array)
+          c2(' ' * message_spacing + message)
+          injection.each do |line|
+            c2(' ' * line_spacing + line.to_s)
+          end
+          inject_separator(options) unless no_separator
+        elsif injection.respond_to?(:call)
+          c2(' ' * message_spacing + message)
+          injection.call
+          inject_separator(options) unless no_separator
+        else
+          Origen.app.fail!(message: "Unexpected object class returned by config.pattern_header from #{config_loc.name}: #{injection.class}", exception_class: TypeError)
+        end
+      end
+
       def pattern_open(options = {})
         options = {
           call_startup_callbacks: true

data/lib/origen/pins/pin.rb

@@ -8,9 +8,9 @@ module Origen
       # it would cause a double cycle in the org file if also captured at the pin
       ORG_FILE_INTERCEPTED_METHODS = [
         :suspend, :resume, :repeat_previous=,
-        :drive_hi, :drive_hi, :drive_very_hi, :drive_lo, :drive_lo, :drive_mem, :expect_mem,
-        :assert_hi, :expect_hi, :compare_hi, :assert_lo, :expect_lo, :compare_lo, :dont_care,
-        :drive, :assert, :compare, :expect, :assert_midband, :compare_midband, :expect_midband,
+        :drive_hi, :write_hi, :drive_very_hi, :drive_lo, :write_lo, :drive_mem, :expect_mem,
+        :assert_hi, :expect_hi, :compare_hi, :read_hi, :assert_lo, :expect_lo, :compare_lo, :read_lo, :dont_care,
+        :drive, :write, :assert, :compare, :expect, :read, :assert_midband, :compare_midband, :expect_midband, :read_midband,
         :toggle, :capture, :store
       ]
 
@@ -698,11 +698,13 @@ module Origen
         set_state(:drive)
         set_value(1)
       end
+      alias_method :write_hi, :drive_hi
 
       def drive_hi!
         drive_hi
         cycle
       end
+      alias_method :write_hi!, :drive_hi!
 
       # Set the pin to drive a high voltage on future cycles (if the tester supports it).
       # For example on a J750 high-voltage channel the pin state would be set to "2"
@@ -721,11 +723,13 @@ module Origen
         set_state(:drive)
         set_value(0)
       end
+      alias_method :write_lo, :drive_lo
 
       def drive_lo!
         drive_lo
         cycle
       end
+      alias_method :write_lo!, :drive_lo!
 
       def drive_mem
         set_state(:drive_mem)
@@ -752,6 +756,7 @@ module Origen
       end
       alias_method :expect_hi, :assert_hi
       alias_method :compare_hi, :assert_hi
+      alias_method :read_hi, :assert_hi
 
       def assert_hi!
         assert_hi
@@ -759,6 +764,7 @@ module Origen
       end
       alias_method :expect_hi!, :assert_hi!
       alias_method :compare_hi!, :assert_hi!
+      alias_method :read_hi!, :assert_hi!
 
       # Set the pin to expect a 0 on future cycles
       def assert_lo(_options = {})
@@ -775,6 +781,7 @@ module Origen
       end
       alias_method :expect_lo, :assert_lo
       alias_method :compare_lo, :assert_lo
+      alias_method :read_lo, :assert_lo
 
       def assert_lo!
         assert_lo
@@ -782,6 +789,7 @@ module Origen
       end
       alias_method :expect_lo!, :assert_lo!
       alias_method :compare_lo!, :assert_lo!
+      alias_method :read_lo!, :assert_lo!
 
       # Set the pin to X on future cycles
       def dont_care
@@ -803,11 +811,13 @@ module Origen
         set_state(:drive)
         set_value(value)
       end
+      alias_method :write, :drive
 
       def drive!(value)
         drive(value)
         cycle
       end
+      alias_method :write!, :drive!
 
       # Pass in 0 or 1 to have the pin expect_lo or expect_hi respectively.
       # This is useful when programatically setting the pin state.
@@ -821,6 +831,7 @@ module Origen
       end
       alias_method :compare, :assert
       alias_method :expect, :assert
+      alias_method :read, :assert
 
       def assert!(*args)
         assert(*args)
@@ -828,12 +839,14 @@ module Origen
       end
       alias_method :compare!, :assert!
       alias_method :expect!, :assert!
+      alias_method :read!, :assert!
 
       def assert_midband
         set_state(:compare_midband)
       end
       alias_method :compare_midband, :assert_midband
       alias_method :expect_midband, :assert_midband
+      alias_method :read_midband, :assert_midband
 
       def assert_midband!
         assert_midband
@@ -841,6 +854,7 @@ module Origen
       end
       alias_method :compare_midband!, :assert_midband!
       alias_method :expect_midband!, :assert_midband!
+      alias_method :read_midband!, :assert_midband!
 
       # Returns the state of invert
       def inverted?

data/lib/origen/pins/pin_collection.rb

@@ -8,9 +8,9 @@ module Origen
       include OrgFile::Interceptable
 
       ORG_FILE_INTERCEPTED_METHODS = [
-        :drive, :drive_hi, :drive_lo, :drive_very_hi, :drive_mem, :expect_mem, :toggle,
-        :repeat_previous=, :capture, :assert, :compare, :expect,
-        :assert_hi, :expect_hi, :compare_hi, :assert_lo, :expect_lo, :compare_lo,
+        :drive, :write, :drive_hi, :write_hi, :drive_lo, :write_lo, :drive_very_hi, :drive_mem, :expect_mem, :toggle,
+        :repeat_previous=, :capture, :assert, :read, :compare, :expect,
+        :assert_hi, :expect_hi, :compare_hi, :read_hi, :assert_lo, :expect_lo, :compare_lo, :read_lo,
         :dont_care
       ]
 
@@ -234,33 +234,39 @@ module Origen
         end
         myself
       end
+      alias_method :write, :drive
 
       def drive!(val)
         drive(val)
         cycle
       end
+      alias_method :write!, :drive!
 
       # Set all pins in pin group to drive 1's on future cycles
       def drive_hi
         each(&:drive_hi)
         myself
       end
+      alias_method :write_hi, :drive_hi
 
       def drive_hi!
         drive_hi
         cycle
       end
+      alias_method :write_hi!, :drive_hi!
 
       # Set all pins in pin group to drive 0's on future cycles
       def drive_lo
         each(&:drive_lo)
         myself
       end
+      alias_method :write_lo, :drive_lo
 
       def drive_lo!
         drive_lo
         cycle
       end
+      alias_method :write_lo!, :drive_lo!
 
       # Set all pins in the pin group to drive a high voltage on future cycles (if the tester supports it).
       # For example on a J750 high-voltage channel the pin state would be set to "2"
@@ -377,6 +383,7 @@ module Origen
       end
       alias_method :compare, :assert
       alias_method :expect, :assert
+      alias_method :read, :assert
 
       def assert!(*args)
         assert(*args)
@@ -384,6 +391,7 @@ module Origen
       end
       alias_method :compare!, :assert!
       alias_method :expect!, :assert!
+      alias_method :read!, :assert!
 
       # Set all pins in the pin group to expect 1's on future cycles
       def assert_hi(options = {})
@@ -392,6 +400,7 @@ module Origen
       end
       alias_method :expect_hi, :assert_hi
       alias_method :compare_hi, :assert_hi
+      alias_method :read_hi, :assert_hi
 
       def assert_hi!
         assert_hi
@@ -399,6 +408,7 @@ module Origen
       end
       alias_method :expect_hi!, :assert_hi!
       alias_method :compare_hi!, :assert_hi!
+      alias_method :read_hi!, :assert_hi!
 
       # Set all pins in the pin group to expect 0's on future cycles
       def assert_lo(options = {})
@@ -407,6 +417,7 @@ module Origen
       end
       alias_method :expect_lo, :assert_lo
       alias_method :compare_lo, :assert_lo
+      alias_method :read_lo, :assert_lo
 
       def assert_lo!
         assert_lo
@@ -414,6 +425,7 @@ module Origen
       end
       alias_method :expect_lo!, :assert_lo!
       alias_method :compare_lo!, :assert_lo!
+      alias_method :read_lo!, :assert_lo!
 
       # Set all pins in the pin group to X on future cycles
       def dont_care

data/lib/origen/registers.rb

@@ -139,7 +139,7 @@ module Origen
         @owner = owner
         @name = name
         @attributes = attributes
-        @feature = attributes[:feature] if attributes.key?(:feature)
+        @feature = attributes[:_feature] if attributes.key?(:_feature)
       end
 
       # Make this appear like a reg to any application code
@@ -313,12 +313,12 @@ module Origen
       local_vars = {}
 
       Reg::REG_LEVEL_ATTRIBUTES.each do |attribute, meta|
-        aliases = [attribute]
+        aliases = [attribute[1..-1].to_sym]
         aliases += meta[:aliases] if meta[:aliases]
-        aliases.each { |_a| local_vars[attribute] = bit_info.delete(attribute) if bit_info.key?(attribute) }
+        aliases.each { |_a| local_vars[attribute] = bit_info.delete(_a) if bit_info.key?(_a) }
       end
 
-      local_vars[:reset] ||= :memory if local_vars[:memory]
+      local_vars[:_reset] ||= :memory if local_vars[:_memory]
       @min_reg_address ||= address
       @max_reg_address ||= address
       # Must set an initial value, otherwise max_address_reg_size will be nil if a sub_block contains only

data/lib/origen/registers/reg.rb

@@ -14,13 +14,13 @@ module Origen
       # to all of its contained bits unless a specific bit has its own definition of the same
       # attribute
       REG_LEVEL_ATTRIBUTES = {
-        feature:   {},
-        reset:     { aliases: [:res] },
-        memory:    {},
-        path:      { aliases: [:hdl_path] },
-        abs_path:  { aliases: [:absolute_path] },
-        access:    {},
-        bit_order: {}
+        _feature:   {},
+        _reset:     { aliases: [:res] },
+        _memory:    {},
+        _path:      { aliases: [:hdl_path] },
+        _abs_path:  { aliases: [:absolute_path] },
+        _access:    {},
+        _bit_order: {}
       }
 
       # Returns the object that own the register.
@@ -69,7 +69,13 @@ module Origen
         @init_as_writable = options.delete(:init_as_writable)
         @define_file = options.delete(:define_file)
         REG_LEVEL_ATTRIBUTES.each do |attribute, _meta|
-          instance_variable_set("@#{attribute}", options.delete(attribute))
+          if options[attribute[1..-1].to_sym]
+            # If register creation is coming directly from Reg.new, instead of Placeholder,
+            #   it may not have attributes with '_' prefix
+            instance_variable_set("@#{attribute[1..-1]}", options.delete(attribute[1..-1].to_sym))
+          else
+            instance_variable_set("@#{attribute[1..-1]}", options.delete(attribute))
+          end
         end
         @description_from_api = {}
         description = options.delete(:description)

data/lib/origen/revision_control/design_sync.rb

@@ -317,6 +317,7 @@ module Origen
               unless line =~ /^Logging/ || line == '' ||
                      line =~ /V(\d+\.\d+-\d+|\d.\d+)/ || # Screen out something like "V5.1-1205" or "V6R2010"
                      line =~ /^3DEXPERIENCER\d+x$/ || # Screen out something like '3DEXPERIENCER2016x'
+                     line =~ /^3DEXPERIENCE R\d+x$/ || # Screen out something like '3DEXPERIENCE R2017x'
                      line.strip.empty?
                 output << line.strip
               end

data/lib/origen/site_config.rb

@@ -39,18 +39,25 @@ module Origen
     end
 
     def eval_path(path, options = {})
-      # Expand the first path. This will take care of replacing any leading ~/ with the home directory.
-      if path.start_with?('\\')
-        path[0] = ''
-      else
-        path = File.expand_path(path)
-      end
+      # Any leading ~ should be expanded with whatever ~/ points to. This needs to be done now because later ~ will be replaced with just the username.
+      path = path.sub(/^~/, File.expand_path('~/'))
 
       # Gsub the remaining ~ that aren't escaped.
       # If it was escaped, eat the escape character
       path.gsub!(/(?<!\\|\A)~/, "#{Etc.getlogin}")
       path.gsub!(/\\(?=~)/, '')
 
+      # Now, expand the entire path for any other OS-specific symbols.
+      # One note, if we still have a leading '~', that means it was escaped at the beginning. So, what we'll do for this is let it expand
+      # then replace the leading File.expand_path('~/') with just '~', pretty much the opposite of path.sub(/^~/, File.expand_path('~/'))
+      # Note, we can't just take it out, expand, then add it back  because expanding the path on Windows will expand to
+      # C:\, or D:\ or whatever, so need to do this 'expand, then unexpand' method.
+      if path.start_with?('~')
+        path = File.expand_path(path).sub(/^#{Regexp.quote(File.expand_path('~/'))}/, '~')
+      else
+        path = File.expand_path(path)
+      end
+
       append = find_val('append_dot_origen')
       append = '.origen' if append == true || append.nil?
 

data/lib/origen/utility/collector.rb

@@ -1,15 +1,30 @@
 module Origen
   module Utility
     class Collector
+      # Returns the collector's hash. This is the same as calling {#to_h}
       attr_reader :_hash_
+
+      # Queries the current merge_method.
       attr_reader :merge_method
 
       # Need to keep a seperate methods list so we know what's been added by method missing instead of what's
       # been added either by the hash or by method missing.
       # Only overwriting a value in the block should cause an error. Overriding a value from the hash depends on
       # the merge method's setting.
+
+      # List of the currently seen method names.
       attr_reader :_methods_
 
+      # Creates a new Collector object and creates a Hash out of the methods names and values in the given block.
+      # @see http://origen-sdk.org/origen/guides/misc/utilities/#Collector
+      # @example Create a collector to transform a block into a Hash
+      #  Origen::Utility::Collector.new { |c| c.my_param 'My Parameter'}.to_h #=> {my_param: 'My Parameter'}
+      # @yield [self] Passes the collector to the given block.
+      # @param options [Hash] Customization options.
+      # @option options [Hash] :hash Input, or starting, values that are set in the output hash prior to calling the given block.
+      # @option options [Symbol] :merge_method (:keep_hash) Indicates how arguments that exist in both the input hash and in the block should be handled.
+      #   Accpeted values are :keep_hash, :keep_block, :fail.
+      # @raise [Origen::OrigenError] Raised when an unknown merge method is used.
       def initialize(options = {}, &block)
         @merge_method = options[:merge_method] || :keep_hash
         @fail_on_empty_args = options[:fail_on_empty_args]
@@ -25,18 +40,32 @@ module Origen
         end
       end
 
-      # Legacy store method.
+      # Retrieve the collector's hash.
+      # @deprecated Use Ruby-centric {#to_hash} instead.
+      # @return [Hash] Hash representation of the collector.
       def store
         Origen.log.deprecate 'Collector::store method was used. Please use the Ruby-centric Collector::to_h or Collector::to_hash method instead' \
                              " Called from: #{caller[0]}"
         @_hash_
       end
 
+      # Returns the collector, as a Hash.
+      # @return [Hash] Hash representation of the collector.
       def to_hash
         @_hash_
       end
       alias_method :to_h, :to_hash
 
+      # Using the method name, creates a key in the Collector with argument given to the method.
+      # @see http://origen-sdk.org/origen/guides/misc/utilities/#Collector
+      # @note If no args are given, the method key is set to <code>nil</code>.
+      # @raise [ArgumentError] Raised when a method attempts to use both arguments and a block in the same line.
+      #   E.g.: <code>collector.my_param 'my_param' { 'MyParam' }</code>
+      # @raise [ArgumentError] Raised when a method attempts to use multiple input values.
+      #   E.g.: <code>collector.my_param 'my_param', 'MyParam'</code>
+      # @raise [Origen::OrigenError] Raised when a method is set more than once. I.e., overriding values are not allowed.
+      #   E.g.: <code>collector.my_param 'my_param'; collector.my_param 'MyParam'</code>
+      # @raise [Origen::OrigenError] Raised when the input hash and the block attempt to set the same method name and the merge method is set to <code>:fail</code>.
       def method_missing(method, *args, &_block)
         key = method.to_s.sub('=', '').to_sym
 

data/templates/nanoc/config.yaml

@@ -58,6 +58,9 @@ data_sources:
     # it will become /about.html/ instead.
     allow_periods_in_identifiers: false
 
+    # Force utf-8 encoding scheme.
+    encoding: utf-8
+
 # Configuration for the watch command, which watches a site for changes and
 # recompiles if necessary.
 watcher:

data/templates/nanoc/lib/search_filter.rb

@@ -8,6 +8,7 @@ class SearchFilter < Nanoc::Filter
   def run(content, params={})
     doc = Nokogiri::HTML(content)
     url = assigns[:item_rep].path
+    encoding = params[:encoding] || 'UTF-8'
     #first_image = doc.xpath('//img/@src').to_a[0]
     document = {
       # See this next time you need to fix this: https://gist.github.com/LeCoupa/8c305ec8c713aad07b14
@@ -19,7 +20,7 @@ class SearchFilter < Nanoc::Filter
     }
 
     if File.exist?(search_file)
-      documents = JSON.parse(File.read(search_file))
+      documents = JSON.parse(File.read(search_file, encoding: encoding))
     else
       documents = {}
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.33.3
+  version: 0.34.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-20 00:00:00.000000000 Z
+date: 2018-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: 3.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: 3.7.0
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -644,7 +644,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 2.4.5.5
 signing_key: 
 specification_version: 4
 summary: The Semiconductor Developer's Kit