origen 0.0.1 → 0.0.2

data/lib/origen/commands/dispatch.rb

@@ -0,0 +1,22 @@
+  # begin
+  if Origen.command_dispatcher.snapshots_exist?
+    ix = ARGV.index('--snapshot_rev')
+    if ix
+      ARGV.delete_at(ix)
+      version = ARGV[ix]
+      ARGV.delete_at(ix)
+    else
+      version = :latest
+    end
+
+    Origen.command_dispatcher.create_workspace(version) do |workspace|
+      workspace.execute(ARGV)
+    end
+
+  else
+    fail 'Sorry no worker snapshots could be found!'
+  end
+
+# rescue
+#  Origen.command_dispatcher.record_error
+# end

data/lib/origen/commands/environment.rb

@@ -0,0 +1,11 @@
+module Origen
+  env = ARGV.shift
+  if env
+    Origen.environment.default = env
+    puts "Environment now set to: #{Origen.environment.file.basename}"
+  else
+    Origen.environment.describe
+  end
+
+  exit 0
+end

data/lib/origen/commands/fetch.rb

@@ -0,0 +1,63 @@
+require 'optparse'
+require 'fileutils'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-END
+Automatically creates the workspace for the requested origen plugin and populates the latest version from the server.
+
+By default this will always create the workspace at './[PLUGIN_NAME]'
+
+Usage: origen fetch [PLUGIN_NAME] [options]
+END
+  opts.on('-o', '--outputdir', 'User defined destination directory of the plugin workspace') {  options[:debugger] = true }
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+opt_parser.orig_parse! ARGV
+options[:patterns] = ARGV
+
+# Extract user input
+plugin_name = ARGV[0]
+dir = ARGV[1]
+
+# Set valid_name to false by default
+valid_name = false
+
+# If requested plugin is origen_core or origen, then run special case, else search through all available plugins
+if plugin_name.downcase == 'origen_core' || plugin_name.downcase == 'origen'
+  plugin_name = 'origen'
+  valid_name = true
+  rc_url = Origen.client.origen[:vault]
+else
+  Origen.client.plugins.each do |name|
+    if name[:origen_name].downcase == plugin_name.downcase
+      valid_name = true
+      rc_url = name[:vault]
+    end
+  end
+end
+
+# If valid_name not found, then abort
+unless valid_name == true
+  puts "The #{plugin_name} plugin which you have requested has not been found, check make sure you have typed in the name correctly"
+  puts "To see the list of available plugins, please run 'origen plugin list' inside an existing origen workspace"
+  exit 1
+end
+
+# If user didn't specify directory then configure for default directory
+unless dir
+  dir = "./#{plugin_name}"
+  puts "You did not specify a workspace directory for #{plugin_name} plugin, it will therefore be created at"
+  puts "#{dir}"
+end
+
+# Checks to see if the destination directory is empty
+unless Dir["#{dir}/*"].empty?
+  puts 'The requested workspace is not empty, please delete it and try again, or select a different path.'
+  exit 1
+end
+
+# Set up the requested plugin workspace
+rc = Origen::RevisionControl.new remote: rc_url, local: dir
+rc.build

data/lib/origen/commands/generate.rb

@@ -0,0 +1,130 @@
+require 'optparse'
+
+options = {}
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: origen g [space separated patterns or lists] [options]'
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-l', '--lsf [ACTION]', [:clear, :add], "Submit jobs to the LSF, optionally specify whether to 'clear' or 'add' to existing jobs") { |a| options[:lsf] = true; options[:lsf_action] = a }
+  opts.on('-w', '--wait', 'Wait for LSF processing to complete') { options[:wait_for_lsf_completion] = true }
+  opts.on('-c', '--continue', 'Continue on error (to the next pattern)') { options[:continue] = true }
+  opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
+  opts.on('-f', '--file FILE', String, 'Override the default log file') { |o| options[:log_file] = o }
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
+  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
+  opts.on('-q', '--queue NAME', String, 'Specify the LSF queue, default is short') { |o| options[:queue] = o }
+  opts.on('-p', '--project NAME', String, 'Specify the LSF project, default is msg.te') { |o| options[:project] = o }
+  opts.on('--doc', 'Generate into doc format') { options[:doc] = true }
+  opts.on('--html', 'Generate into html format') { options[:html] = true }
+  opts.on('--nocom', 'No comments in the generated pattern') { options[:no_comments] = true }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.parse! ARGV
+options[:patterns] = ARGV
+
+def self._with_doc_tester(options)
+  if options[:doc] || options[:html]
+    Origen.app.with_doc_tester(options) do
+      yield
+    end
+  else
+    yield
+  end
+end
+
+Origen.load_application
+
+if options[:queue]
+  Origen.config.lsf.queue = options.delete(:queue)
+end
+if options[:project]
+  Origen.config.lsf.project = options.delete(:project)
+end
+
+_with_doc_tester(options) do
+  Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
+  Origen.environment.temporary = options[:environment] if options[:environment]
+  Origen.target.temporary = options[:target] if options[:target]
+  Origen.app.load_target!  # This initial load is required to apply any configuration
+  # options present in the target, it will loaded again before
+  # each generate/compile job
+  Origen.app.runner.generate(options)
+
+  Origen.lsf.wait_for_completion if options[:wait_for_lsf_completion]
+end
+
+#    method_option :vector_comments,    :default => false, :aliases => "-v", :type => :boolean,
+#                           :desc => "Add vector and cycle number comments to the pattern, disabled by default to make diff viewing easier"
+
+# === Task: $ origen g [patname/patlist] [options]
+# Generate a pattern or list of patterns.
+#
+# ==== Supplying a pattern name
+# Multiple pattern name arguments can be supplied on the command line. The generator is non-strict
+# about pre and post-fixes to the pattern names so the following all work; use whichever is most
+# convenient:
+#
+#   origen g prb_ers_mas_atuf
+#   origen g prb_ers_mas_atuf.rb
+#   origen g nvm_prb_ers_mas_atuf.atp
+#   origen g pattern/erase/prb_ers_mas_atuf.rb
+#
+# For patterns that use iterators you can supply either the pattern source name or the generated name,
+# for example these are equivalent:
+#
+#   origen g prb_ers_mas_bx.rb
+#   origen g prb_ers_mas_b0.atp
+#
+# Multiple patterns can be supplied on the command line and should be comma separated with no spaces
+# in between:
+#
+#   origen g prb_ers_mas_atuf,prb_ers_mas_bx
+#
+# A pattern list is simply the name of any file that resides in the /list directory and which contains
+# a list of patname arguments (same rules apply as for the command line version).
+# The list files can be commented with '#' and can reference other list files. For example it is
+# common to make a production.list or master.list file that references other sub lists: probe.list,
+# ft.list, etc.
+#
+# ==== Generator output
+# The command line output is as follows:
+#
+#   Generating... nvm_prb_ers_mas_atuf.atp            3039      0.201732
+#                           |                          |            |
+#       Created output file, can be found in       Number of   Execution time
+#                  output/<soc>/                    vectors     on the tester
+#
+# All output from the last run can be found in log.txt, this is just a direct copy of the output in
+# the console.
+#
+# ==== Tracking changes
+# Upon completion you will be alerted if there are some new or changed files and will prompted to
+# save these. It is recommended that you perform the save if you know why the change happened (or if
+# you are running in a brand new workspace). You can then use the automatic pattern diff feature to
+# be alerted to any change in the pattern content the next time you generate a given pattern. Note that
+# a tkdiff executable is automatically output to allow you to inspect the differences.
+#
+# To allow you to locate changed or new patterns easily they are automatically copied to:
+# output/<soc>/changed/
+#
+# The reference files are stored in $ORIGEN_WORK/.ref <br>
+# Very often you will want to compare the output of the current generator to a previous version,
+# to do this remove the .ref and replace it with a link to the .ref in another workspace.
+#   rm -fr .ref
+#   ln -s <path_to_my_ref_workspace>/.ref .ref
+# After that generate and save the patterns in the reference workspace and re-run the patterns in the original
+# workspace to see if there are any differences.
+#
+# ==== Options
+# For a list of options run:
+#   origen help g

data/lib/origen/commands/interactive.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+require 'irb'
+require 'irb/completion'
+begin
+  require 'pry'
+rescue LoadError
+  # If not installed simply not available
+end
+
+module Origen
+  # Methods available to the command line in a console session, split this to a
+  # separate file if it gets large over time
+  module ConsoleMethods
+    def j750
+      @_j750 ||= Origen::Tester::J750.new
+      @_j750.parser
+    end
+  end
+
+  # App options are options that the application can supply to extend this command
+  app_options = @application_options || []
+  options = {}
+  opt_parser = OptionParser.new do |opts|
+    opts.banner = <<-END
+Start an interactive console session with your target.
+Usage: origen i [options]
+    END
+    opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+    opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+    opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
+    opts.on('-p', '--pry', 'Use Pry for the session (instead of IRB)') { options[:pry] = true }
+    opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+    opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+    app_options.each do |app_option|
+      opts.on(*app_option) {}
+    end
+    opts.separator ''
+    opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+  end
+  opt_parser.parse! ARGV
+
+  Origen.load_application
+  Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
+  Origen.environment.temporary = options[:environment] if options[:environment]
+  Origen.target.temporary = options[:target] if options[:target]
+  Origen.app.load_console
+  Origen.app.runner.prepare_directories # Ensure tmp et all exist
+
+  if defined?(Pry) && options[:pry]
+    include ConsoleMethods
+  else
+    IRB::ExtendCommandBundle.send :include, Origen::ConsoleMethods
+    IRB.start
+    exit 0
+  end
+  # rubocop:disable Debugger, EmptyLines
+
+
+
+
+
+
+
+  binding.pry
+
+
+
+
+
+
+
+  # rubocop:enable Debugger, EmptyLines
+end

data/lib/origen/commands/lint.rb

@@ -0,0 +1,82 @@
+options = {}
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-END
+Run Ruby lint and style checks on your application code.
+
+Usage: origen lint [space separated files, or directories] [options]
+
+All options and the default files to test can be overridden via the
+lint_test application configuration parameter, see here for more info:
+
+http://origen.freescale.net/origen/latest/guides/utilities/lint/
+
+  END
+  opts.on('-c', '--correct', 'Correct errors automatically where possible') { options[:correct] = true }
+  opts.on('-n', '--no-correct', "Don't correct errors automatically (override if the app default is set to auto correct)") { options[:no_correct] = true }
+  opts.on('-e', '--easy', 'Be less strict, most checks run with this flag enabled can be corrected automatically') { options[:easy] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.parse! ARGV
+if ARGV.empty?
+  if Origen.config.lint_test[:files]
+    files = Origen.config.lint_test[:files].map { |f| "#{Origen.root}/#{f}" }.join(' ')
+  else
+    files = "#{Origen.root}/lib"
+  end
+else
+  files = ARGV.join(' ')
+end
+
+if options[:easy] || Origen.config.lint_test[:level] == :easy
+  config = "#{Origen.top}/config/rubocop/easy.yml"
+else
+  config = "#{Origen.top}/config/rubocop/strict.yml"
+end
+
+command = "rubocop #{files} --config #{config} --display-cop-names"
+
+unless options[:no_correct]
+  if options[:correct] || Origen.config.lint_test[:auto_correct]
+    command += ' --auto-correct'
+  end
+end
+
+if Origen.debugger_enabled?
+  command += ' --debug'
+end
+
+puts command
+result = system(command)
+
+if result == true
+  exit 0
+elsif result == false
+  exit 1
+else
+  begin
+    if gem 'rubocop'
+      if Origen.running_on_linux? && !File.exist?("#{Origen.top}/.bin/rubocop")
+        puts ''
+        puts 'It looks like you need to update your toolset to fix the above error, try running these commands before trying again:'
+        puts ''
+        puts "  pushd #{Origen.top}"
+        puts '  source source_setup update'
+        puts '  popd'
+        puts ''
+      end
+    end
+  rescue Gem::LoadError
+    require_gem 'rubocop', version: '0.20.1'
+  end
+  exit 1
+end

data/lib/origen/commands/lsf.rb

@@ -0,0 +1,93 @@
+require 'optparse'
+
+options = {}
+
+def require_type_or_id(options)
+  unless options[:id] || options[:type]
+    puts 'You must supply a job type or ID'
+    exit 1
+  end
+end
+
+# Provides the hook to launch a monitored system command
+# on a remote machine. This is intended to be used internally and
+# is not part of the public API.
+if ARGV.delete('--execute')
+  ix = ARGV.index('--id')
+  if ix
+    ARGV.delete_at(ix)
+    id = ARGV[ix]
+    ARGV.delete_at(ix)
+  else
+    puts 'You must supply a job ID to execute'
+    exit 1
+  end
+  ix = ARGV.index('--dependents')
+  if ix
+    ARGV.delete_at(ix)
+    dependents = ARGV[ix].split(',')
+    ARGV.delete_at(ix)
+  else
+    dependents = nil
+  end
+  Origen.app.lsf_manager.execute_remotely(cmd: ARGV, id: id, dependents: dependents)
+  exit 0
+end
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Manage job submissions to the LSF, with no options will display the current
+status summary of all tracked jobs.
+
+Usage: origen lsf [options]
+  EOT
+  opts.on('-v', '--verbose', 'Show job details') { options[:verbose] = true }
+  opts.on('-r', '--resubmit', 'Re-submit jobs') { options[:resubmit] = true }
+  opts.on('-c', '--clear', 'Clear jobs') {  options[:clear] = true }
+  opts.on('-l', '--log', 'Build a log file from the completed jobs') { options[:log] = true }
+  #  opts.on("-k", "--kill", "Kill jobs") { options[:kill] = true }
+  types = [:queuing, :running, :lost, :passed, :failed, :all]
+  opts.on('-t', '--type TYPE', types, 'Job type to apply the requested action to:', '  ' + types.join(', ')) { |t| options[:type] = t.to_sym }
+  opts.on('-i', '--id ID', String, 'Job ID to apply the requested action to') { |t| options[:id] = t }
+  opts.on('-w', '--wait', 'Wait for LSF processing to complete') { options[:wait_for_lsf_completion] = true }
+  # opts.on("-e", "--execute", "Execute....") { options[:execute] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.parse! ARGV
+
+if options[:clear] || options[:kill] || options[:resubmit]
+  require_type_or_id(options)
+end
+
+Origen.load_application
+Origen.app.lsf_manager.classify_jobs
+if options[:clear]
+  Origen.app.lsf_manager.clear(options)
+  Origen.app.lsf_manager.classify_jobs
+end
+if options[:resubmit]
+  Origen.app.lsf_manager.resubmit(options)
+  Origen.app.lsf_manager.classify_jobs
+end
+# if options[:kill]
+#  Origen.app.lsf_manager.kill(options)
+#  Origen.app.lsf_manager.classify_jobs
+# end
+if options[:log]
+  Origen.app.lsf_manager.build_log(options)
+else
+  Origen.app.lsf_manager.print_status(options)
+end
+
+Origen.lsf.wait_for_completion if options[:wait_for_lsf_completion]
+
+exit 0

data/lib/origen/commands/merge.rb

@@ -0,0 +1,55 @@
+require 'optparse'
+
+options = {}
+Origen.log.deprecate <<-END
+
+********************************************************************************************
+  The 'merge' command has now been deprecated as the same functionality can be achieved by
+  performing the following tasks:
+
+  origen compile [COMPILE DIRECTORY/FILE] -r [DIRECTORY/FILE FOR COMPARISON]
+
+  By using the -r switch, it overrides the default reference directory which origen uses,
+  therefore essentially allowing origen to diff between your output directory and any directory
+  of your choice (for example ASCII UTIL export directory)
+*********************************************************************************************
+END
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+The reverse of 'origen compile' to help merge any changes made to compiled files back to the source.
+The arguments are the same as the compile command, so run the merge with the same arguments and it will merge instead of compile.
+Changes are processed as follows:
+* Any files with a non-erb source are simply copied back if they have changes.
+* Any files that don't have a source copy are ignored.
+* Any differences in files with an ERB source are left to the user to resolve. Origen tries to help by giving you the
+  commands to execute to show the differences and the files that must be edited.
+
+Usage: origen merge [space separated files, lists or directories] [options]
+  EOT
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-c', '--continue', 'Continue on error (to the next file)') { options[:continue] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-f', '--file FILE', String, 'Override the default log file') { |o| options[:log_file] = o }
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
+  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+options[:patterns] = ARGV
+options[:job_type] = :merge  # To let the generator know a merge job has been requested
+
+Origen.load_application
+Origen.target.temporary = options[:target] if options[:target]
+Origen.app.load_target!
+
+Origen.app.runner.generate(options)
+
+exit 0

data/lib/origen/commands/modifications.rb

@@ -0,0 +1,12 @@
+module Origen
+  Origen.load_application
+  if Origen.app.cm.modified_objects_in_workspace?
+    puts 'Your workspace has the following modifications:'
+    Origen.app.cm.modified_objects_in_workspace_list.each do |file|
+      puts '  ' + Origen.app.cm.diff_cmd + ' ' + file
+    end
+  else
+    puts 'Your workspace is clean!'
+  end
+  exit 0
+end

data/lib/origen/commands/new.rb

@@ -0,0 +1,113 @@
+require 'optparse'
+require 'fileutils'
+require 'httparty'
+require 'digest'
+
+include Origen::Utility::InputCapture
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-END
+Generate a new Origen application.
+
+This runs the Origen App Generators plugin to generate the new application, this provides many
+engineering domain specific application shells as well as a generic application shell.
+
+By default this will always run the latest and greatest production release of the application
+generators regardless of the base Origen version that this command is being launched from.
+
+See the website for more details:
+
+http://origen.freescale.net/origen_app_generators
+
+Usage: origen new [APP_NAME] [options]
+END
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-v', '--version TAG', String, 'Use a specific version of Origen App Generators') { |f| options[:version] = f }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+
+opt_parser.orig_parse! ARGV
+options[:patterns] = ARGV
+
+dir = ARGV.first
+
+unless dir
+  puts 'You must supply a path to the workspace you wish to create'
+  exit 1
+end
+
+unless Dir["#{dir}/*"].empty?
+  puts 'The requested workspace is not empty, please delete it and try again, or select a different path.'
+  exit 1
+end
+
+version = options[:version] || begin
+  plugin = Origen.client.plugin(:origen_app_generators)
+  plugin[:latest_version_prod]
+end
+
+version ||= '0.0.0'
+
+version.sub!(/^v/, '')
+
+if Origen.running_on_windows?
+  tmp = 'C:/tmp/origen_app_generators'
+else
+  tmp = '/tmp/origen_app_generators'
+end
+
+dir = "#{tmp}/app_gen#{version}"
+lib = "#{dir}/lib"
+md5 = "#{tmp}/md5#{version}"
+
+# If the app generators already exists in /tmp, check that all files are still there.
+# This deals with the problem of some files being swept up by the tmp cleaner while
+# leaving the top-level folder there.
+if File.exist?(dir) && File.exist?(md5)
+  old_sig = File.read(md5)
+  hash = Digest::MD5.new
+  Dir["#{dir}/**/*"].each do |f|
+    hash << File.read(f) unless File.directory?(f)
+  end
+  new_sig = hash.hexdigest
+  all_present = old_sig == new_sig
+else
+  all_present = false
+end
+
+unless all_present
+
+  FileUtils.rm_rf(dir) if File.exist?(dir)
+  FileUtils.mkdir_p(tmp) unless File.exist?(tmp)
+
+  File.open("#{tmp}/app_gen#{version}.gem", 'wb') do |f|
+    response =  HTTParty.get("http://origen-hub.am.freescale.net:9292/gems/origen_app_generators-#{version}.gem")
+    if response.success?
+      f.write response.parsed_response
+    else
+      puts "Sorry, could not find app generators version #{version}"
+      exit 1
+    end
+  end
+
+  Dir.chdir tmp do
+    `gem unpack app_gen#{version}.gem`
+    `rm -f app_gen#{version}.gem`
+  end
+
+  hash = Digest::MD5.new
+  Dir["#{dir}/**/*"].each do |f|
+    hash << File.read(f) unless File.directory?(f)
+  end
+  File.open(md5, 'w') { |f| f.write(hash.hexdigest) }
+end
+
+$LOAD_PATH.unshift(lib)
+
+Origen.with_boot_environment do
+  require 'origen_app_generators'
+  OrigenAppGenerators.invoke(dir)
+end