origen 0.34.3 → 0.52.0

data/lib/origen/boot/api.rb

@@ -0,0 +1,13 @@
+# Helper methods here and in the required files can be used by Origen during the bootup process.
+# (e.g., in site config ERB files)
+# This can be expanded as needed to provide more helpers.
+module Origen
+  # NOTE: Gems are not allowed to be required here, only Ruby stlibs
+  require 'socket'
+  require_relative '../operating_systems'
+
+  # Platform independent means of retrieving the hostname
+  def self.hostname
+    Socket.gethostbyname(Socket.gethostname).first.downcase
+  end
+end

data/lib/origen/boot/app.rb

@@ -0,0 +1,284 @@
+require 'fileutils'
+module Origen
+  # Provides methods for setting up, booting and
+  # archiving an Origen application
+  module Boot
+    # Gem executables that Origen depends on [bin name, gem name]
+    BIN_DEPS = [%w(rspec rspec-core), %w(nanoc nanoc), %w(yard yard),
+                %w(rubocop rubocop), %w(rake rake)]
+
+    BUNDLER_WARNING = '
+From Origen 0.40.0 onwards, a new way of launching Origen is supported and
+you are seeing this message because your application is still setup to run
+the old way.
+
+The main difference is that Origen is now launched via an Origen-owned binstub
+(./lbin/origen) rather than a Bundler-owned binstub. This means that Origen can
+no longer be prevented from running due to a Bundler configuration issue within
+your workspace and it should mean that Origen invocation becomes more reliable.
+
+It is recommended that you follow these instructions to upgrade your application
+to the new system.
+
+If have already done this and you are seeing this message again, then Bundler has
+overwritten the binstub at ./lbin/origen and you should perform the upgrade again.
+
+To upgrade, run the following command:
+
+ origen setup
+
+If you ever run the `bundle` or `bundle install` commands manually, never use
+the --binstubs option or it will roll you back to the old system.
+
+Under the new system, you should check the `./lbin` directory into your source
+control system, so remove it from your `.gitignore` (or equivalent) and check
+it in.
+
+When you install a new gem whose executable you want to use in your app,
+generate a binstub for it via the following command:
+
+  origen new binstub some-gem-name
+
+______________________________________________________________________________________
+
+'
+
+    BUNDLER_SETUP = %q(
+  if Origen.site_config.gem_manage_bundler
+    FileUtils.mkdir_p(File.join(origen_root, '.bundle'))
+    File.open(File.join(origen_root, '.bundle', 'config'), 'w') do |f|
+      f.puts '# Origen is managing this file, any local edits will be overwritten'
+      f.puts '# IT SHOULD NOT BE CHECKED INTO REVISION CONTROL!'
+      f.puts '---'
+      f.puts 'BUNDLE_BIN: false'
+      # If gems have been installed to the app, always use them
+      bundle_path = File.join(origen_root, 'vendor', 'gems')
+      if File.exist?(bundle_path)
+        # Only keep the gems we actually need when installing to the application, but
+        # don't do this when installing outside since other apps might use them
+        f.puts 'BUNDLE_CLEAN: true'
+      else
+        bundle_path = File.expand_path(Origen.site_config.gem_install_dir)
+      end
+      f.puts "BUNDLE_PATH: \"#{bundle_path}\""
+      Array(Origen.site_config.gem_build_switches).each do |build_switches|
+        switches = build_switches.strip.split(' ')
+        gem = switches.shift
+        f.puts "BUNDLE_BUILD__#{gem.upcase}: \"#{switches.join(' ')}\""
+      end
+    end
+  end
+)
+
+    UPDATER_WARNING = '
+The bin/fix_my_workspace script is not compatible with the new way that Origen is
+launched and you should remove it from your application.
+
+Do this by deleting bin/fix_my_workspace and also remove the origen_updater gem from
+your application.
+
+The command `origen setup` can be used in place of fix_my_workspace under the
+new system, however the new system should be more robust and such workspace repairs
+should no longer be required.
+
+______________________________________________________________________________________
+
+'
+
+    BINSTUB =
+"#!/usr/bin/env ruby
+#
+# This file was generated by Origen.
+#
+
+require 'rubygems'
+
+origen_lib = File.expand_path('../../lib/origen', Gem.bin_path('origen', 'origen'))
+boot = File.join(origen_lib, 'boot.rb')
+ORIGEN_ROOT = File.expand_path('..', __dir__)
+origen_root = ORIGEN_ROOT
+
+# If the Origen version supports the new boot system then use it
+if File.exist?(boot)
+  load boot
+
+# Otherwise fall back to an (improved) old-style invocation via Bundler
+else
+  require 'pathname'
+  require 'fileutils'
+  $_origen_invocation_pwd = Pathname.pwd
+  require File.join(origen_lib, 'site_config')
+" + BUNDLER_SETUP + %q(
+  bundle_binstub = File.expand_path('../bundle', __FILE__)
+
+  if File.file?(bundle_binstub)
+    if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+      load(bundle_binstub)
+    else
+      abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+  Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+    end
+  end
+  require 'bundler/setup'
+
+  load Gem.bin_path('origen', 'origen')
+end
+)
+    class << self
+      # Boot the application at the given root
+      def app!(origen_root)
+        # This will be used to collect warnings about the user's application environment, however showing them
+        # will be deferred until it has been determined that the application is using Origen >= 0.40.0 - i.e. we
+        # don't want to start complaining to the user about existing apps until they have intentionally upgraded
+        # their Origen version.
+        warnings = []
+
+        exec_remote = ARGV.include?('--exec_remote') ? true : false
+        lbin_dir = File.join(origen_root, 'lbin')
+        origen_binstub = File.join(lbin_dir, 'origen')
+
+        unless exec_remote
+          if !File.exist?(origen_binstub) ||
+             (File.exist?(origen_binstub) && File.read(origen_binstub) !~ /This file was generated by Origen/)
+            warnings << BUNDLER_WARNING
+          elsif File.exist?(File.join(origen_root, 'bin', 'fix_my_workspace'))
+            warnings << UPDATER_WARNING
+          end
+
+          setup_bundler(origen_root)
+        end
+
+        boot_app = true
+
+        Dir.chdir origen_root do
+          # Overriding bundler here so that bundle install can be automated as required, otherwise if just call
+          # require 'bundler/setup' then it will exit in the event of errors
+          require 'bundler'
+          begin
+            Bundler.setup
+          rescue Gem::LoadError, Bundler::BundlerError => e
+            puts e
+            puts
+            if exec_remote
+              puts 'App failed to boot, run it locally so that this can be resolved before re-submitting to the LSF'
+              exit 1
+            end
+            puts 'Attempting to resolve this...'
+            puts
+
+            passed = false
+
+            Bundler.with_clean_env do
+              cmd = 'bundle install'
+              cmd += ' --local' if File.exist?('.origen_archive')
+              passed = system(cmd)
+            end
+
+            if passed
+              Bundler.with_clean_env do
+                exec "origen #{ARGV.join(' ')}"
+              end
+              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 run 'bundle update origen'."
+              exit 1
+            end
+          end
+        end
+        unless exec_remote
+          # The application's bundle is safely loaded, do a final check to make sure that Origen's
+          # required bin dependencies have binstubs
+          if BIN_DEPS.any? { |bin, gem| !File.exist?(File.join(lbin_dir, bin)) }
+            system "bundle binstubs #{BIN_DEPS.map { |bin, gem| gem }.join(' ')} --path #{lbin_dir} --force"
+          end
+        end
+        require 'origen'
+        warnings
+      end
+
+      def setup(origen_root)
+        create_origen_binstub(origen_root)
+        bundle_path = setup_bundler(origen_root)
+        unless File.exist?(File.join(origen_root, '.origen_archive'))
+          copy_system_gems(origen_root, bundle_path)
+        end
+      end
+
+      def create_origen_binstub(origen_root)
+        lbin_dir = File.join(origen_root, 'lbin')
+
+        FileUtils.mkdir_p(lbin_dir)
+        File.open(File.join(lbin_dir, 'origen'), 'w') do |f|
+          f.puts BINSTUB
+        end
+        FileUtils.chmod('+x', File.join(lbin_dir, 'origen'))
+
+        if Origen.os.windows?
+          Dir.glob("#{origen_root}/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
+        end
+      end
+
+      def setup_bundler(origen_root)
+        bundle_path = nil
+        eval BUNDLER_SETUP  # Will update bundle_path
+        bundle_path
+      end
+
+      def copy_system_gems(origen_root, bundle_path)
+        if Origen.site_config.gem_use_from_system
+          local_gem_dir = "#{bundle_path}/ruby/#{Pathname.new(Gem.dir).basename}"
+          gem_dir = Pathname.new(Gem.dir)
+
+          Origen.site_config.gem_use_from_system.each do |gem, version|
+            begin
+              # This will raise an error if the system doesn't have this gem installed, that
+              # will be rescued below
+              spec = Gem::Specification.find_by_name(gem, version)
+
+              # If the spec has returned a handle to a system installed gem. If this script has been invoked through
+              # Bundler then it could point to some other gem dir. The only time this should occur is when switching
+              # from the old system to the new system, but can't work out how to fix it so just disabling in that case.
+              if spec.gem_dir =~ /#{gem_dir}/
+
+                local_dir = File.join(local_gem_dir, Pathname.new(spec.gem_dir).relative_path_from(gem_dir))
+                FileUtils.mkdir_p local_dir
+                FileUtils.cp_r("#{spec.gem_dir}/.", local_dir)
+
+                local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.cache_file).relative_path_from(gem_dir)))
+                FileUtils.mkdir_p local_file.dirname
+                FileUtils.cp(spec.cache_file, local_file)
+
+                if spec.extension_dir && File.exist?(spec.extension_dir)
+                  local_dir = File.join(local_gem_dir, Pathname.new(spec.extension_dir).relative_path_from(gem_dir))
+                  FileUtils.mkdir_p local_dir
+                  FileUtils.cp_r("#{spec.extension_dir}/.", local_dir)
+                end
+
+                local_file = Pathname.new(File.join(local_gem_dir, Pathname.new(spec.spec_file).relative_path_from(gem_dir)))
+                FileUtils.mkdir_p local_file.dirname
+                FileUtils.cp(spec.spec_file, local_file)
+
+                puts "Copied #{gem} #{version} from the system into #{bundle_path}"
+
+              end
+
+            rescue Exception # Gem::LoadError  # Rescue everything here, this is a try-our-best operation, better to
+              # continue and try and install the gem if this fails rather than crash
+              # This just means that one of the gems that should be copied from the system
+              # was not actually installed in the system, so nothing we can do about that here
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/code_generators.rb

@@ -29,13 +29,25 @@ module Origen
     def self.load_generators
       return if @generators_loaded
       # Load Origen's generators
-      Dir.glob("#{Origen.top}/lib/origen/code_generators/**/*.rb").sort.each do |file|
-        require file
-      end
-      # Load generators from plugins, TBD what the rules will be here
+      require_relative 'code_generators/block_common'
+      require_relative 'code_generators/dut'
+      require_relative 'code_generators/block'
+      require_relative 'code_generators/feature'
+      require_relative 'code_generators/model'
+      require_relative 'code_generators/klass'
+      require_relative 'code_generators/module'
+      # Load generators from plugins, TBD what the API will be here
       @generators_loaded = true
     end
 
+    # Loaded separately so as not to pollute the generated list of generators available to users
+    def self.load_internal_generators
+      return if @internal_generators_loaded
+      require_relative 'code_generators/semver'
+      require_relative 'code_generators/timever'
+      @internal_generators_loaded = true
+    end
+
     # Receives a namespace, arguments and the behavior to invoke the generator.
     # It's used as the default entry point for generate, destroy and update
     # commands.
@@ -47,6 +59,13 @@ module Origen
       end
     end
 
+    # Like invoke, but will also make internal-use only generators available
+    # commands.
+    def self.invoke_internal(name, args = ARGV, config = {})
+      load_internal_generators
+      invoke(name, args, config)
+    end
+
     def self.find_by_name(name)
       names = name.split(':')
       case names.size
@@ -61,20 +80,20 @@ module Origen
         end
         return gen if gen
       end
-      puts "Couldn't find a feature generator named: #{name}"
+      puts "Couldn't find a code generator named: #{name}"
       puts
-      puts 'This is the list of available features:'
+      puts 'This is the list of available generators:'
       puts
       print_generators
       puts
     end
 
     # Show help message with available generators.
-    def self.help(command = 'add')
+    def self.help(command = 'new')
       puts <<-END
-Add pre-built features and code snippets.
+Add pre-built features and code snippets to your application.
 
-This command will add pre-built code to your application to implement a given feature. In some
+This command will generate code for your application to implement a given feature. In some
 cases this will be a complete feature and in others it will provide a starting point for you
 to further customize.
 
@@ -88,7 +107,7 @@ END
       puts '  -s, [--skip]     # Skip files that already exist'
       puts '  -q, [--quiet]    # Suppress status output'
       puts
-      puts "The available features are listed below, run 'origen add <feature> -h' for more info."
+      puts "The available features are listed below, run 'origen new <feature> -h' for more info."
       puts
 
       print_generators
@@ -101,6 +120,7 @@ END
         puts name
       end
       plugin_generators.each do |namespace, generators|
+        next if namespace.to_s == 'origen_app_generators'
         puts
         generators.each do |_name, gen|
           puts "#{namespace}:#{gen}"

data/lib/origen/code_generators/actions.rb

@@ -1,13 +1,18 @@
 require 'open-uri'
-require 'rbconfig'
+require 'set'
 
 module Origen
   module CodeGenerators
+    # Common helpers available to all Origen code generators.
+    # Some of these have been copied from Rails and don't make a lot of sense in an Origen context,
+    # however they are being kept around for now as they serve as good examples of how to write
+    # generator helpers.
     module Actions
       def initialize(*args) # :nodoc:
         if args.last.is_a?(Hash)
           @config = args.last.delete(:config) || {}
         end
+        @required_acronyms = Set.new
         super
         @in_group = nil
       end
@@ -16,13 +21,77 @@ module Origen
         @config
       end
 
+      def underscored_app_namespace
+        Origen.app.namespace.to_s.underscore
+      end
+
+      # Equivalent to calling name.camelcase, but this will identify the need to register any acronyms
+      # necessary to ensure the camelcased name can be translated back to the original name by the
+      # underscore method.
+      # The required acronyms will be saved to an instance variable, @required_acronyms, and calling
+      # the add_acronyms will add the code to register them to the current application.
+      def camelcase(name)
+        name = name.to_s
+        name.split('_').each do |n|
+          # Numbers won't be recognized as a split point when going back to underscore, so need to
+          # register this field beginning with a number as an acronym
+          @required_acronyms << n if n =~ /^\d/
+        end
+        name.camelcase
+      end
+
+      def add_acronyms
+        unless @required_acronyms.empty?
+          top_level_file = File.join('app', 'lib', "#{underscored_app_namespace}.rb")
+          if File.exist?(top_level_file)
+            require_origen = "require 'origen'\n"
+            prepend_to_file top_level_file, require_origen
+            comment = "# The following acronyms are required to ensure that auto-loading works\n# properly with some of this application's class names\n"
+            insert_into_file top_level_file, comment, after: require_origen
+            @required_acronyms.each do |acronym|
+              insert_into_file top_level_file, "Origen.register_acronym '#{acronym}'\n", after: comment
+            end
+          end
+        end
+      end
+
+      # Adds an autoload statement for the given resource name into +app/lib/my_app_name.rb+
+      #
+      # An array of namespaces can optionally be supplied in the arguments. The name and namespaces
+      # should all be lower cased and underscored.
+      #
+      #   add_autoload "my_model", namespaces: ["my_namespace", "my_other_namespace"]
+      def add_autoload(name, options = {})
+        namespaces = Array(options[:namespaces])
+        # Remove the app namespace if present, we will add the autoload inside the top-level module block
+        namespaces.shift if namespaces.first == app_namespace
+        top_level_file = File.join('app', 'lib', "#{underscored_app_namespace}.rb")
+        if namespaces.empty?
+          line = "  autoload :#{camelcase(name)}, '#{underscored_app_namespace}/#{name}'\n"
+          insert_into_file top_level_file, line, after: /module #{Origen.app.namespace}\n/
+        else
+          contents = File.read(top_level_file)
+          regex = "module #{Origen.app.namespace}\s*(#.*)?\n"
+          indent = ''
+          namespaces.each do |namespace|
+            indent += '  '
+            new_regex = regex + "(\n|.)*^\s*module #{camelcase(namespace)}\s*(#.*)?\n"
+            unless contents =~ Regexp.new(new_regex)
+              lines = "#{indent}module #{camelcase(namespace)}\n"
+              lines << "#{indent}end\n"
+              insert_into_file top_level_file, lines, after: Regexp.new(regex), force: true
+            end
+            regex = new_regex
+          end
+          line = "#{indent}  autoload :#{camelcase(name)}, '#{underscored_app_namespace}/#{namespaces.join('/')}/#{name}'\n"
+          insert_into_file top_level_file, line, after: Regexp.new(regex)
+        end
+      end
+
       # Removes (comments out) the specified configuration setting from +config/application.rb+
       #
       #   comment_config :semantically_version
-      def comment_config(*args)
-        options = args.extract_options!
-        name = args.first.to_s
-
+      def comment_config(name, options = {})
         # Set the message to be shown in logs
         log :comment, name
 
@@ -31,10 +100,7 @@ module Origen
       end
 
       # Adds an entry into +config/application.rb+
-      def add_config(*args)
-        options = args.extract_options!
-        name, value = args
-
+      def add_config(name, value, options = {})
         # Set the message to be shown in logs
         message = name.to_s
         if value ||= options.delete(:value)
@@ -53,10 +119,7 @@ module Origen
       #   gem "rspec", group: :test
       #   gem "technoweenie-restful-authentication", lib: "restful-authentication", source: "http://gems.github.com/"
       #   gem "rails", "3.0", git: "git://github.com/rails/rails"
-      def gem(*args)
-        options = args.extract_options!
-        name, version = args
-
+      def gem(name, version, options = {})
         # Set the message to be shown in logs. Uses the git repo if one is given,
         # otherwise use name (version).
         parts, message = [quote(name)], name
@@ -129,7 +192,7 @@ module Origen
         data = yield if !data && block_given?
 
         in_root do
-          if options[:env].nil?
+          if options[:env].nil?.map(&:camelcase).join('::')
             inject_into_file 'config/application.rb', "\n    #{data}", after: sentinel, verbose: false
           else
             Array(options[:env]).each do |env|
@@ -200,18 +263,6 @@ module Origen
         in_root { run_ruby_script("bin/rails generate #{what} #{argument}", verbose: false) }
       end
 
-      # Runs the supplied rake task
-      #
-      #   rake("db:migrate")
-      #   rake("db:migrate", env: "production")
-      #   rake("gems:install", sudo: true)
-      def rake(command, options = {})
-        log :rake, command
-        env  = options[:env] || ENV['RAILS_ENV'] || 'development'
-        sudo = options[:sudo] && RbConfig::CONFIG['host_os'] !~ /mswin|mingw/ ? 'sudo ' : ''
-        in_root { run("#{sudo}#{extify(:rake)} #{command} RAILS_ENV=#{env}", verbose: false) }
-      end
-
       # Reads the given file at the source root and prints it in the console.
       #
       #   readme "README"
@@ -219,6 +270,168 @@ module Origen
         log File.read(find_in_source_paths(path))
       end
 
+      # Should probably move to its own file, these are general helpers rather than actions
+      module Helpers
+        # Returns the depth of the given file, where depth is the number of modules and classes it contains
+        def internal_depth(file)
+          depth = 0
+          File.readlines(file).each do |line|
+            if line =~ /^\s*(end|def)/
+              return depth
+            elsif line =~ /^\s*(module|class)/
+              depth += 1
+            end
+          end
+        end
+
+        # Only executes the given block if the given file does not already define the given method, where the
+        # block would normally go on to insert the method.
+        #
+        # See the ensure_define_sub_blocks method in the sub_blocks.rb generator for a usage example.
+        def unless_has_method(filepath, name)
+          unless File.read(filepath) =~ /^\s*def #{name}(\(|\s|\n)/
+            yield
+          end
+        end
+
+        # Executes the given block unless the given string is lower cased and underscored and doesn't start
+        # with a number of contain any special characters
+        def unless_valid_underscored_identifier(str)
+          if str =~ /[^0-9a-z_]/ || str =~ /^[0-9]/
+            yield
+          end
+        end
+
+        def validate_resource_path(name)
+          name.split('/').each do |n|
+            unless_valid_underscored_identifier(n) do
+              Origen.log.error "All parts of a resource name must be lower-cased, underscored and start with letter, '#{n}' is invalid"
+              exit 1
+            end
+          end
+          name
+        end
+        alias_method :validate_resource_name, :validate_resource_path
+
+        # Converts a path to a resource identifier, by performing the following operations on the given path:
+        #   1) Convert any absolute paths to relative
+        #   2) Removes any leading blocks/, lib/ or application namespaces
+        #   3) Remove any derivatives directories from the path
+        #   3) Removes any trailing .rb
+        #
+        # Examples:
+        #
+        #   /my/code/my_app/app/blocks/dut/derivatives/falcon   => dut/falcon
+        #   app/lib/my_app/eagle.rb                            => eagle
+        def resource_path(path)
+          path = Pathname.new(path).expand_path.relative_path_from(Pathname.pwd).to_s
+          path = path.sub('.rb', '')
+          path = path.split('/')
+          from_block_dir_path = false
+          path.shift if path.first == 'app'
+          path.shift if path.first == 'lib'
+          if path.first == 'blocks'
+            path.shift
+            from_block_dir_path = true
+          end
+          path.shift if path.first == underscored_app_namespace
+          if path.include?('derivatives')
+            path.delete('derivatives')
+            from_block_dir_path = true
+          end
+          if from_block_dir_path
+            path.delete('sub_blocks')
+            path.pop if path.last == 'model'
+            if path.last == 'controller'
+              path.pop
+              path << "#{path.pop}_controller"
+            end
+          end
+          path.join('/')
+        end
+
+        # Returns a Pathname to the blocks directory that should contain the given class name. No checking is
+        # done of the name and it is assumed that it is a valid class name including the application namespace.
+        def class_name_to_blocks_dir(name)
+          name = name.split('::')
+          name.shift  # Drop the application name
+          dir = Origen.root.join('app', 'blocks')
+          name.each_with_index do |n, i|
+            if i == 0
+              dir = dir.join(n.underscore)
+            else
+              dir = dir.join('derivatives', n.underscore)
+            end
+          end
+          dir
+        end
+
+        # Returns a Pathname to the lib directory file that should contain the given class name. No checking is
+        # done of the name and it is assumed that it is a valid class name including the application namespace.
+        def class_name_to_lib_file(name)
+          name = name.split('::')
+          dir = Origen.root.join('app', 'lib')
+          name.each_with_index do |n, i|
+            dir = dir.join(i == name.size - 1 ? "#{n.underscore}.rb" : n.underscore)
+          end
+          dir
+        end
+
+        def resource_path_to_blocks_dir(path)
+          name = resource_path(path).split('/')   # Ensure this is clean, don't care about performance here
+          dir = Origen.root.join('app', 'blocks')
+          name.each_with_index do |n, i|
+            if i == 0
+              dir = dir.join(n.underscore)
+            else
+              if dir.join('sub_blocks', n.underscore).exist?
+                dir = dir.join('sub_blocks', n.underscore)
+              else
+                dir = dir.join('derivatives', n.underscore)
+              end
+            end
+          end
+          dir
+        end
+
+        def resource_path_to_lib_file(path)
+          name = resource_path(path).split('/')   # Ensure this is clean, don't care about performance here
+          dir = Origen.root.join('app', 'lib', underscored_app_namespace)
+          name.each_with_index do |n, i|
+            dir = dir.join(i == name.size - 1 ? "#{n.underscore}.rb" : n.underscore)
+          end
+          dir
+        end
+
+        def resource_path_to_class(path)
+          name = resource_path(path).split('/')   # Ensure this is clean, don't care about performance here
+          name.unshift(underscored_app_namespace)
+          name.map { |n| camelcase(n) }.join('::')
+        end
+
+        # Adds :class and :module identifiers to an array of namespaces
+        #
+        #   ["my_app", "models", "bist"] => [[:module, "my_app"], [:module, "models"], [:class, "bist"]]
+        #
+        def add_type_to_namespaces(namespaces)
+          identifier = nil
+          namespaces.map do |namespace|
+            if identifier
+              identifier += "::#{camelcase(namespace)}"
+            else
+              identifier = camelcase(namespace)
+            end
+            begin
+              const = identifier.constantize
+              [const.is_a?(Class) ? :class : :module, namespace]
+            rescue NameError
+              [:module, namespace]
+            end
+          end
+        end
+      end
+      include Helpers
+
       protected
 
       # Define log for backwards compatibility. If just one argument is sent,
@@ -233,17 +446,14 @@ module Origen
         end
       end
 
-      # Add an extension to the given name based on the platform.
-      def extify(name)
-        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-          "#{name}.bat"
-        else
-          name
+      def in_root
+        Dir.chdir(Origen.root) do
+          yield
         end
       end
 
-      # Surround string with single quotes if there is no quotes.
-      # Otherwise fall back to double quotes
+      # Surround string with single quotes if there are no quotes,
+      # otherwise fall back to double quotes
       def quote(value)
         return value.inspect unless value.is_a? String