origen 0.34.3 → 0.52.0

data/lib/origen/application.rb

@@ -50,6 +50,8 @@ module Origen
               Origen.register_application(app)
             end
             app.add_lib_to_load_path!
+            # Also blow this cache as a new app has just been added
+            @apps_by_namespace = nil
           end
         end
       end
@@ -62,6 +64,33 @@ module Origen
         super || instance.respond_to?(*args)
       end
 
+      # Returns the application instance (i.e. main app or the plugin) that owns the given class/module
+      # (literal, string or symbol representation is accepted) or object instance.
+      # Returns nil if no matching Origen application can be found.
+      #
+      #     Origen::Application.from_namespace(MyApp)                       # => <my_app instance>
+      #     Origen::Application.from_namespace(MyApp::MyClass)              # => <my_app instance>
+      #     Origen::Application.from_namespace('MyApp::MyClass')            # => <my_app instance>
+      #     Origen::Application.from_namespace(<my_app::my_class instance>) # => <my_app instance>
+      def from_namespace(item)
+        unless item.is_a?(String)
+          if item.is_a?(Module) || item.is_a?(Class) || item.is_a?(Symbol)
+            item = item.to_s
+          else # Assume to be an object instance in this case
+            item = item.class.to_s
+          end
+        end
+        namespace = item.split('::').first
+        @apps_by_namespace ||= {}
+        @apps_by_namespace[namespace] ||= begin
+          return Origen.app if Origen.app.namespace == namespace
+          Origen.app.plugins.each do |plugin|
+            return plugin if plugin.namespace == namespace
+          end
+          nil
+        end
+      end
+
       protected
 
       def method_missing(*args, &block)
@@ -104,6 +133,58 @@ module Origen
       end
     end
 
+    # @api private
+    #
+    # Returns a lookup table for all block definitions (app/blocks) that the app contains
+    def blocks_files
+      @blocks_files ||= begin
+        files = {}
+        block_dir = Pathname.new(File.join(root, 'app', 'blocks'))
+        if block_dir.exist?
+          block_dir.children.each do |item|
+            if item.directory?
+              _add_block_files(files, block_dir, item)
+            end
+          end
+        end
+        files
+      end
+    end
+
+    # @api private
+    def _add_block_files(files, block_dir, current_dir, sub_block = false)
+      fields = current_dir.relative_path_from(block_dir).to_s.split('/')
+      fields.delete('derivatives')
+      fields.delete('sub_blocks')
+      path = fields.join('/')
+      files[path] ||= {}
+      files[path][:_sub_block] = true if sub_block
+      Dir.glob(current_dir.join('*.rb')).each do |file|
+        file = Pathname.new(file)
+        type = file.basename('.rb').to_s.to_sym
+        unless type == :model || type == :controller
+          files[path][type] ||= []
+          files[path][type] << file.to_s
+        end
+      end
+      derivatives = current_dir.join('derivatives')
+      if derivatives.exist?
+        derivatives.children.each do |item|
+          if item.directory?
+            _add_block_files(files, block_dir, item)
+          end
+        end
+      end
+      sub_blocks = current_dir.join('sub_blocks')
+      if sub_blocks.exist?
+        sub_blocks.children.each do |item|
+          if item.directory?
+            _add_block_files(files, block_dir, item, true)
+          end
+        end
+      end
+    end
+
     def current_job
       current_jobs.last
     end
@@ -766,6 +847,7 @@ END
         force_debug: false
       }.merge(options)
       @on_create_called = false
+      @target_loading = true
       if options[:reload]
         @target_load_count = 0
       else
@@ -814,7 +896,7 @@ END
       end
       listeners_for(:after_load_target).each(&:after_load_target)
       Origen.app.plugins.validate_production_status
-      # @target_instantiated = true
+      @target_loading = false
     end
 
     # Returns true if the on_create callback has already been called during a target load
@@ -900,6 +982,10 @@ END
       @target_instantiated
     end
 
+    def target_loading?
+      @target_loading || false
+    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: '
@@ -956,7 +1042,7 @@ END
     #     config.i18n.backend = MyBackend
     #   end
     def add_lib_to_load_path! #:nodoc:
-      [root.join('lib'), root.join('vendor', 'lib')].each do |path|
+      [root.join('lib'), root.join('vendor', 'lib'), root.join('app', 'lib')].each do |path|
         $LOAD_PATH.unshift(path.to_s) if File.exist?(path) && !$LOAD_PATH.include?(path.to_s)
       end
     end

data/lib/origen/application/deployer.rb

@@ -224,7 +224,9 @@ module Origen
       end
 
       def create_web_server_dir
-        if File.exist?("#{Origen.root}/templates/web")
+        templates_web_dir = 'app/templates/web'
+        templates_web_dir = 'templates/web' unless File.exist?("#{Origen.root}/#{templates_web_dir}")
+        if File.exist?("#{Origen.root}/#{templates_web_dir}")
           dir = web_server_dir
           FileUtils.rm_rf dir if File.exist?(dir)
           FileUtils.mkdir_p dir

data/lib/origen/application/release.rb

@@ -328,9 +328,9 @@ Your workspace has local modifications that are preventing the requested action
       # Sets the version number in the file store
       def write_version(version)
         if version.semantic?
-          Origen::CodeGenerators.invoke 'semver', [], config: { change: version }
+          Origen::CodeGenerators.invoke_internal 'semver', [], config: { change: version }
         else
-          Origen::CodeGenerators.invoke 'timever', [], config: { change: version }
+          Origen::CodeGenerators.invoke_internal 'timever', [], config: { change: version }
         end
         system 'origen -v' # Invoke Origen under the new version, this updates Gemfile.lock
       end

data/lib/origen/application/runner.rb

@@ -46,7 +46,9 @@ module Origen
             Origen.log.info 'Monitor status of remote jobs via:'
             Origen.log.info '  origen l'
           else
-            Origen.log.info '*' * 70 unless options[:quiet]
+            unless tester && tester.try(:sim?)
+              Origen.log.info '*' * 70 unless options[:quiet]
+            end
             Origen.app.listeners_for(:before_generate).each do |listener|
               if listener.class.instance_method(:before_generate).arity == 0
                 listener.before_generate
@@ -82,29 +84,35 @@ module Origen
                   Origen.app.listeners_for(:program_generated).each(&:program_generated)
                 else
                   temporary_plugin_from_options = options[:current_plugin]
-                  expand_lists_and_directories(options[:files], options).each do |file|
-                    if temporary_plugin_from_options
-                      Origen.app.plugins.temporary = temporary_plugin_from_options
-                    end
-                    case options[:action]
-                    when :compile
-                      Origen.generator.compile_file_or_directory(file, options)
-                    when :merge
-                      Origen.generator.merge_file_or_directory(file, options)
-                    when :import_test_time
-                      Origen.time.import_test_time(file, options)
-                    when :import_test_flow
-                      Origen.time.import_test_flow(file, options)
-                    else
-                      Origen.generator.generate_pattern(file, options)
-                    end
+                  if options[:action] == :pattern && options[:sequence]
+                    patterns = expand_lists_and_directories(options[:files], options.merge(preserve_duplicates: true))
+                    Origen.generator.generate_pattern(patterns, options)
                     Origen.app.plugins.temporary = nil if temporary_plugin_from_options
+                  else
+                    expand_lists_and_directories(options[:files], options).each do |file|
+                      if temporary_plugin_from_options
+                        Origen.app.plugins.temporary = temporary_plugin_from_options
+                      end
+                      case options[:action]
+                      when :compile
+                        Origen.generator.compile_file_or_directory(file, options)
+                      when :merge
+                        Origen.generator.merge_file_or_directory(file, options)
+                      when :import_test_time
+                        Origen.time.import_test_time(file, options)
+                      when :import_test_flow
+                        Origen.time.import_test_flow(file, options)
+                      else
+                        Origen.generator.generate_pattern(file, options)
+                      end
+                      Origen.app.plugins.temporary = nil if temporary_plugin_from_options
+                    end
                   end
                 end
               end
             end
 
-            unless options[:quiet]
+            unless options[:quiet] || (tester && tester.try(:sim?))
               Origen.log.info '*' * 70
               stats.print_summary unless options[:action] == :merge
             end
@@ -255,8 +263,15 @@ module Origen
           if Origen.mode.production? && Origen.app.rc
             unless Origen.app.rc.local_modifications.empty?
               puts <<-EOT
-    Your workspace has local modifications that are preventing the requested action
-      - run 'origen rc mods' to see them.
+    Your workspace is running in production mode and it has local modifications which are preventing
+    the requested action, run the following command to see what files have been modified:
+
+      origen rc mods
+
+    If you are currently developing this application and are not ready to check everything in yet,
+    then run the following command to switch your workspace to debug/development mode:
+
+      origen m debug
               EOT
               exit 1
             end

data/lib/origen/boot.rb

@@ -0,0 +1,302 @@
+$VERBOSE = nil  # Don't care about world writable dir warnings and the like
+
+require 'pathname'
+require 'fileutils'
+
+class OrigenBootError < StandardError
+end
+
+# 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
+
+# This will be referenced later in ruby_version_check, the origen used to launch
+# the process is different than the one that actually runs under bundler
+$origen_launch_root = Pathname.new(File.dirname(__FILE__)).parent
+
+# Override any influence from $LANG in the users environment
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+ENV['LC_ALL'] = nil
+ENV['LANG'] = nil
+ENV['LANG'] = 'en_US.UTF-8'
+
+load File.expand_path('../operating_systems.rb', __FILE__)
+
+# Are we inside an Origen application workspace?
+# If ORIGEN_ROOT is defined it means that we were launched within an app from the new style Origen binstub,
+# so all is well
+if defined?(ORIGEN_ROOT)
+  origen_root = ORIGEN_ROOT
+else
+  app_config = File.join('config', 'application.rb')
+  if File.exist?(app_config)
+    origen_root = Dir.pwd
+  else
+    path = Pathname.new(Dir.pwd)
+    until path.root? || origen_root
+      if File.exist?(File.join(path, app_config))
+        origen_root = path.to_s
+      else
+        path = path.parent
+      end
+    end
+  end
+  # If we are in an app and we have not been invoked through a Bundler binstub, then check if one exists and
+  # if so re-launch through it, otherwise create one and then re-launch through that
+  if origen_root && !ENV['BUNDLE_BIN_PATH']
+    binstub = File.join(origen_root, 'lbin', 'origen')
+    unless File.exist?(binstub)
+      require_relative 'boot/app'
+      Origen::Boot.create_origen_binstub(origen_root)
+    end
+    exec Gem.ruby, binstub, *ARGV
+  end
+end
+
+# Defer loading these until we have re-launched above to save time
+load File.expand_path('../site_config.rb', __FILE__)
+load File.expand_path('../loader.rb', __FILE__)
+
+warnings = nil
+
+########################################################################################################################
+########################################################################################################################
+## If running inside an application workspace
+########################################################################################################################
+########################################################################################################################
+if origen_root
+  require_relative 'boot/app'
+
+  if ARGV.first == 'setup'
+    Origen::Boot.setup(origen_root)
+    puts
+    puts 'Your application has been setup successfully'
+    exit 0
+  else
+    warnings = Origen::Boot.app!(origen_root)
+    boot_app = true
+  end
+
+########################################################################################################################
+########################################################################################################################
+## If running outside an application and a user or central tool Origen bundle is to be used
+##
+## Note that there is a lot of duplication of the above code, however this is a copy of the original code
+## to boot up outside an app when a tool Origen bundle is present. It has been maintained separately to
+## ensure that the changes to how an application boots up do not affect the global tool installation functionality.
+########################################################################################################################
+########################################################################################################################
+elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
+  # Force everyone to have a consistent way of installing gems with bundler.
+  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
+  # Have two options here: if user_install_enable is true, use user_install_dir. Otherwise, use the tool_repo_install_dir
+  install_dir = Origen.site_config.user_install_enable ? File.expand_path(Origen.site_config.user_install_dir) : File.expand_path(Origen.site_config.tool_repo_install_dir)
+  unless Dir.exist?(install_dir)
+    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
+    include Origen::Utility::InputCapture
+
+    puts "Root directory '#{install_dir}' does not exist. Would you like to create it?"
+    if get_text(confirm: :return_boolean)
+      FileUtils.mkdir(install_dir)
+    else
+      puts 'Exiting with creating Origen install'
+      exit!
+    end
+  end
+
+  gemfile = File.join(install_dir, 'Gemfile')
+  unless File.exist?(gemfile)
+    # Create a default Gemfile that can be further customized by the user.
+    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
+    Dir.chdir(install_dir) do
+      `bundle init`
+    end
+    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
+    File.open(gemfile, 'a') do |f|
+      f << "gem 'origen'\n"
+    end
+  end
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+  ENV['BUNDLE_BIN'] = File.join(install_dir, 'lbin')
+
+  origen_exec = File.join(ENV['BUNDLE_BIN'], 'origen')
+
+  # If the user/tool bundle already exists but we have not been invoked through that, abort this thread
+  # and re-launch under the required bundler environment
+  if File.exist?(origen_exec) && !ENV['BUNDLE_BIN_PATH'] && File.exist?(ENV['BUNDLE_PATH'])
+    exec Gem.ruby, origen_exec, *ARGV
+    exit 0
+  else
+    boot_app = false
+  end
+
+  if File.exist?(ENV['BUNDLE_GEMFILE'])
+    # Overriding bundler here so that bundle install can be automated as required
+    require 'bundler/shared_helpers'
+    if Bundler::SharedHelpers.in_bundle?
+      require 'bundler'
+      if STDOUT.tty?
+        begin
+          fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+          Bundler.setup
+          fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+        rescue Gem::LoadError, Bundler::BundlerError, OrigenBootError => e
+          cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
+          # puts cmd
+          puts 'Installing required gems...'
+          puts
+          `chmod o-w #{install_dir}` # Stops some annoying world writable warnings during install
+          `chmod o-w #{install_dir}/bin` if File.exist?("#{install_dir}/bin")
+          `chmod o-w #{install_dir}/.bin` if File.exist?("#{install_dir}/.bin")
+          result = false
+
+          Bundler.with_clean_env do
+            if Origen.os.unix?
+              if Origen.site_config.gem_build_switches
+                Origen.site_config.gem_build_switches.each do |switches|
+                  `bundle config build.#{switches}`
+                end
+              end
+            end
+            result = system(cmd)
+          end
+          `chmod o-w #{ENV['BUNDLE_BIN']}`
+          # Make .bat versions of all executables, Bundler should really be doing this when running
+          # on windows
+          if Origen.os.windows?
+            bat_present = File.exist? "#{install_dir}/lbin/origen.bat"
+            Dir.glob("#{install_dir}/lbin/*").each do |bin|
+              unless bin =~ /.bat$/
+                bat = "#{bin}.bat"
+                unless File.exist?(bat)
+                  File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+                end
+              end
+            end
+            if !bat_present && !result
+              puts 'Some Windows specific updates to your workspace were required, please re-run the last command'
+              exit 0
+            end
+          end
+          if result
+            exec "origen #{ARGV.join(' ')}"
+            exit 0
+          else
+            puts
+            puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
+            puts "For example if you have just changed the version of origen_core run 'bundle update origen_core'."
+            exit 1
+          end
+        end
+      else
+        Bundler.setup
+      end
+    end
+    require 'bundler/setup'
+    require 'origen'
+  else
+    $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+    require 'origen'
+  end
+
+########################################################################################################################
+########################################################################################################################
+## We are running outside of an app and no-special global Origen tool setup is present
+########################################################################################################################
+########################################################################################################################
+else
+  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+  require 'origen'
+end
+
+########################################################################################################################
+########################################################################################################################
+
+begin
+  # Now that the runtime Origen version is loaded, we need to re-load the site config.
+  # This is because the version of the site_config that was originally loaded above has instantiated
+  # a site_config object, whereas earlier versions of Origen (which could now be loaded), instantiated
+  # a simple hash instead.
+  # Reloading now will ensure consistency between the site config object and the version of
+  # Origen that is now live.
+  Origen.instance_variable_set(:@site_config, nil)
+  load 'origen/site_config.rb'
+  require 'colored'
+  # Emit all broadcast messages before executing all commands
+  if Origen.site_config.broadcast_info
+    puts
+    Array(Origen.site_config.broadcast_info).each { |line| puts line }
+    puts
+  end
+  if Origen.site_config.broadcast_warning
+    puts
+    Array(Origen.site_config.broadcast_warning).each { |line| puts line.yellow }
+    puts
+  end
+  if Origen.site_config.broadcast_danger
+    puts
+    Array(Origen.site_config.broadcast_danger).each { |line| puts line.red }
+    puts
+  end
+  if Origen.site_config.broadcast_success
+    puts
+    Array(Origen.site_config.broadcast_success).each { |line| puts line.green }
+    puts
+  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.
+  if origen_root && boot_app
+    puts warnings if warnings && Origen.version >= '0.40.0'
+    require 'origen/commands'
+  else
+    require 'origen/commands_global'
+  end
+rescue Exception => e
+  # A formatted stack dump will not be printed if the application ends via 'exit 0' or 'exit 1'. In that
+  # case the application code is responsible for printing a helpful error message.
+  # This will intercept all other exits, e.g. via 'fail "Something has done wrong"', and split the stack
+  # dump to separate all in-application references from Origen core/plugin references.
+  if e.is_a?(SystemExit)
+    exit e.status
+  else
+    puts
+    if Origen.app_loaded?
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+
+      puts
+      puts 'APPLICATION CALL STACK'
+      puts '----------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      # 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)
+        if path.absolute?
+          if line =~ /^#{Origen.root}/ && line !~ /^#{Origen.root}\/lbin/
+            puts line
+          end
+        else
+          puts line unless line =~ /^.\/lbin/
+        end
+      end
+    else
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+    end
+    exit 1
+  end
+ensure
+  if Origen.app_loaded?
+    Origen.app.listeners_for(:on_origen_shutdown).each(&:on_origen_shutdown)
+    Origen.app.runner.shutdown
+  end
+end