origen 0.34.3 → 0.52.0

data/lib/origen/code_generators/model.rb

@@ -0,0 +1,60 @@
+module Origen
+  module CodeGenerators
+    class Model < Origen::CodeGenerators::Base
+      def self.banner
+        'origen new model NAME'
+      end
+
+      desc <<-END
+This generator creates a model and optionally a controller for it within your application's
+app/lib directory.
+
+The NAME of the model should be given, in lower case, optionally indicating the presence
+of any namespacing you want it to be created under.
+
+If the model is intended to represent a top-level DUT or a primary sub-block/IP (e.g. RAM,
+ATD, PLL, Flash, etc) then use `origen new dut` or `origen new block` instead.
+
+If the model is intended to represent a sub-component of an existing block then the
+block generator should be used to create a nested sub-block - see the comments within
+sub_blocks.rb of one of the existing block models for an example.
+
+Otherwise, models in the app/lib directory as produced by this generator are good for when
+the model is representing some abstract concept which may not map directly to hardware, or
+hen you need to model a minor sub-component which needs to be shared by multuple higher level
+blocks.
+
+Examples:
+  origen new model sequencer       # Creates app/lib/my_application/sequencer.rb
+  origen new model bist/sequencer  # Creates app/lib/my_application/bist/sequencer.rb
+END
+
+      def validate_args
+        if args.size > 1 || args.size == 0
+          msg = args.size > 1 ? 'Only one' : 'One'
+          msg << " argument is expected by the model generator, e.g. 'origen new model sequencer', 'origen new model bist/sequencer'"
+          puts msg
+          exit 1
+        end
+
+        validate_resource_name(args.first)
+      end
+
+      def create_model_file
+        @resource_path = args.first
+        klass = resource_path_to_class(args.first)
+        @namespaces = klass.split('::').map(&:underscore)
+        @name = @namespaces.pop
+        @namespaces = add_type_to_namespaces(@namespaces)
+        @root_class = true
+        file = class_name_to_lib_file(klass)
+        template 'templates/code_generators/model.rb', file
+        if yes? 'Does this model need a controller? (n):'
+          file = file.to_s.sub(/\.rb/, '_controller.rb')
+          template 'templates/code_generators/controller.rb', file
+        end
+        add_acronyms
+      end
+    end
+  end
+end

data/lib/origen/code_generators/module.rb

@@ -0,0 +1,92 @@
+module Origen
+  module CodeGenerators
+    class Mod < Origen::CodeGenerators::Base
+      def self.banner
+        'origen new module NAME [CLASS]'
+      end
+
+      desc <<-END
+This generator creates a plain old Ruby module within your application's lib directory,
+or if a CLASS argument is given, it will create it a child of that class in either the
+lib or blocks directory as appropriate.
+
+Where a CLASS argument is given, the new module will be automatically included in the
+class.
+
+The NAME of the module should be given, in lower case, optionally indicating the presence
+of any namespacing you want it to be created under.
+
+The CLASS argument should be a path to the Ruby file that defines the class.
+
+Examples:
+  origen new module helpers          # Creates app/lib/my_application/helpers.rb
+  origen new module helpers/math     # Creates app/lib/my_application/helpers/math.rb
+
+  # Creates app/lib/blocks/dut/derivatives/falcon/model/helpers.rb
+  origen new module blocks/dut/derivatives/falcon/model.rb helpers
+END
+
+      def validate_args
+        if args.size > 2 || args.size == 0
+          msg = args.size == 0 ? 'At least one argument is' : 'No more than two arguments are'
+          msg << " expected by the module generator, e.g. 'origen new module helpers', 'origen new module helpers app/lib/my_app/my_class.rb'"
+          puts msg
+          exit 1
+        end
+
+        if args.size == 2
+          @class_file = args.first
+          unless File.exist?(@class_file)
+            puts "This class file does not exist: #{@class_file}"
+            exit 1
+          end
+        end
+
+        @resource_path = validate_resource_path(args.last)
+      end
+
+      def create_module_file
+        if @class_file
+          @namespaces = resource_path_to_class(@class_file).split('::').map(&:underscore)
+          paths = resource_path_to_class(@resource_path).split('::').map(&:underscore)
+          @name = paths.pop
+          paths.shift  # Lose the app namespace
+          @namespaces += paths
+          file = File.join(@class_file.sub('.rb', ''), "#{@name}.rb")
+          @module_name = (@namespaces + [@name]).map { |n| camelcase(n) }.join('::')
+        else
+          @module_name = resource_path_to_class(@resource_path)
+          @namespaces = @module_name.split('::').map(&:underscore)
+          @name = @namespaces.pop
+          file = class_name_to_lib_file(@module_name)
+        end
+        @namespaces = add_type_to_namespaces(@namespaces)
+        template 'templates/code_generators/module.rb', file
+      end
+
+      def include_module
+        if @class_file
+          klass = resource_path_to_class(@class_file)
+
+          # Does file have a nested namespace structure
+          snippet = File.foreach(@class_file).first(50)
+          if snippet.any? { |line| line =~ /\s*class #{klass.split('::').last}/ }
+            indent = '  ' * klass.split('::').size
+            lines = []
+            lines << indent + "include #{@module_name}"
+            lines << ''
+            inject_into_class @class_file, klass.split('::').last, lines.join("\n") + "\n"
+
+          # Else assume it is the compact style (class MyApp::DUT::Falcon)
+          else
+            lines = []
+            lines << "  include #{@module_name}"
+            lines << ''
+            inject_into_class @class_file, klass, lines.join("\n") + "\n"
+          end
+        end
+        add_acronyms
+      end
+    end
+  end
+end

data/lib/origen/commands.rb

@@ -2,6 +2,7 @@
 # is done here (i.e. options that apply to all commands) before handing
 # over to the specific command handlers
 require 'optparse'
+require 'fileutils'
 
 ARGV << '--help' if ARGV.empty?
 
@@ -29,10 +30,22 @@ ORIGEN_COMMAND_ALIASES = {
 # Moved here so boot.rb file can know the current command
 Origen.send :current_command=, @command
 
+# Do some housekeeping, remove all .git directories in vendor/gems, this allows gems
+# that have been vendored via a Git reference to be checked in as normal
+if File.exist?(Origen.root.join('vendor', 'gems'))
+  Dir.glob("#{Origen.root}/vendor/gems/ruby/*/bundler/gems/*/.git").each do |f|
+    FileUtils.rm_rf(f)
+  end
+  # Also remove any nested vendor/gems folders to save space
+  Dir.glob("#{Origen.root}/vendor/gems/ruby/*/bundler/gems/*/vendor/gems").each do |f|
+    FileUtils.rm_rf(f)
+  end
+end
+
 # Don't log to file during the save command since we need to preserve the last log,
 # this is done as early in the process as possible so any deprecation warnings during
 # load don't trigger a new log
-Origen::Log.console_only = (%w(save target environment version).include?(@command) || ARGV.include?('--exec_remote'))
+Origen::Log.console_only = %w(save target environment version).include?(@command)
 
 if ARGV.delete('--coverage') ||
    ((@command == 'specs' || @command == 'examples' || @command == 'test') && (ARGV.delete('-c') || ARGV.delete('--coverage')))
@@ -97,22 +110,13 @@ Origen.lsf.current_command = @command
 
 if ARGV.delete('-d') || ARGV.delete('--debug')
   begin
-    if RUBY_VERSION >= '2.0.0'
-      require 'byebug'
-    else
-      require 'rubygems'
-      require 'ruby-debug'
-    end
+    require 'byebug'
   rescue LoadError
     def debugger
       caller[0] =~ /.*\/(\w+\.rb):(\d+).*/
       puts 'The debugger gem is not installed, add the following to your Gemfile:'
       puts
-      puts "if RUBY_VERSION >= '2.0.0'"
-      puts "  gem 'byebug', '~>3.5'"
-      puts 'else'
-      puts "  gem 'debugger', '~>1.6'"
-      puts 'end'
+      puts "  gem 'byebug', '~>8'"
       puts
     end
   end
@@ -230,11 +234,16 @@ end.compact
 
 case @command
 when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'environment',
-     'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin', 'fetch', 'mode', 'gem' # , 'add'
+     'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin', 'fetch', 'mode', 'gem',
+     'archive'
 
   require "origen/commands/#{@command}"
   exit 0 unless @command == 'interactive'
 
+when 'new'
+  require 'origen/commands/new_resource'
+  exit 0
+
 when 'exec'
   load ARGV.first
   exit 0
@@ -244,6 +253,10 @@ when 'version'
   require 'origen/commands/version'
   exit 0
 
+when 'site'
+  require 'origen/commands/site'
+  exit 0
+
 else
   if ['-h', '--help'].include?(@command)
     status = 0
@@ -267,12 +280,16 @@ The core origen commands are:
  compile      Compile a template file or directory (short-cut alias: "c")
  exec         Execute any Ruby file with access to your app environment
 
+ setup        Setup an app workspace for the first time, or fix if it can't boot
  rc           Revision control commands, see -h for details
  save         Save the new or changed files from the last run or a given log file
  lsf          Monitor and manage LSF jobs (short-cut alias: "l")
  web          Web page tools, see -h for details
  time         Tools for test time analysis and forecasting
  lint         Lint and style check (and correct) your application code
+ archive      Create an archive of your current application state
+ site         Monitor and manage the Origen site configuration
+ new          Generate a new block, flow, pattern, etc. for your application
   EOT
   cmds.split(/\n/).each do |line|
     puts Origen.clean_help_line(line)

data/lib/origen/commands/archive.rb

@@ -0,0 +1,175 @@
+require 'optparse'
+require 'fileutils'
+require 'find'
+require 'bundler'
+
+options = {}
+options[:exclude] = []
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: origen archive [options]'
+  opts.on('--local', 'Install gems within your app so that it can run completely standalone, no archive is created') { options[:local] = true }
+  opts.on('--no-local', "Reverses a previously executed 'origen archive --local' operation, returning the app to use a conventional gem installation") { options[:no_local] = true }
+  opts.on('-e', '--exclude DIR', 'Exclude the given directory from the archive, e.g. --exclude simulation') { |dir| options[:exclude] << dir }
+end
+opt_parser.parse! ARGV
+
+origen_binstub = File.join(Origen.root, 'lbin', 'origen')
+
+unless  File.exist?(origen_binstub) && File.read(origen_binstub) =~ /This file was generated by Origen/
+  puts 'An archive can only be created after your application is running the latest Origen boot system,'
+  puts 'run the following command to update your application and then try again:'
+  puts
+  puts '  origen setup'
+  puts
+  exit 1
+end
+
+if options[:no_local]
+  Dir.chdir Origen.root do
+    dir = File.join('vendor', 'gems')
+    FileUtils.rm_rf(dir) if File.exist?(dir)
+  end
+  passed = true
+  Bundler.with_clean_env do
+    passed = system('origen -v')
+  end
+  if passed
+    Origen.log.success 'Local gems have been removed and your application has been restored to use a conventional gem installation.'
+    exit 0
+  else
+    Origen.log.error 'A problem was encountered when trying to boot your application after removing local gems!'
+    exit 1
+  end
+end
+
+Origen.log.info 'Preparing the workspace' unless options[:local]
+tmp1 = File.join(Origen.root, '..', "#{Origen.app.name}_copy")
+name = "#{Origen.app.name}-#{Origen.app.version}"
+tmpdir = File.join(Origen.root, 'tmp')
+tmp = File.join(tmpdir, name)
+archive = File.join(Origen.root, 'tmp', "#{name}.origen")
+unless options[:local]
+  FileUtils.rm_rf(tmp1) if File.exist?(tmp1)
+  FileUtils.rm_rf(tmp) if File.exist?(tmp)
+  FileUtils.rm_rf(archive) if File.exist?(archive)
+end
+
+exclude_dirs = ['.bundle', 'output', 'tmp', 'web', 'waves', '.git', '.ref', 'dist', 'log', '.lsf', '.session'] + options[:exclude]
+
+unless options[:local]
+  begin
+    Origen.log.info 'Creating a copy of the application'
+    if Origen.os.linux?
+      Dir.chdir Origen.root do
+        cmd = "rsync -av --progress . tmp/#{name} --exclude tmp"
+        exclude_dirs.each do |dir|
+          cmd += " --exclude #{dir}"
+        end
+        passed = system cmd
+        unless passed
+          Origen.log.error 'A problem was encountered when creating a copy of your application, archive aborted!'
+          exit 1
+        end
+      end
+    else
+      FileUtils.mkdir_p(tmp1)
+      FileUtils.cp_r "#{Origen.root}/.", tmp1
+      FileUtils.mv tmp1, tmp
+    end
+    # Remove all .svn or .SYNC directories
+    Find.find(tmp) do |path|
+      n = File.basename(path)
+      if FileTest.directory?(path) && (n == '.svn' || n == '.SYNC')
+        puts "Removing: #{path}"
+        FileUtils.remove_dir(path)
+      end
+    end
+  ensure
+    FileUtils.rm_rf(tmp1) if File.exist?(tmp1)
+  end
+end
+
+Origen.log.info 'Fetching all required gems' unless options[:local]
+dir = options[:local] ? Origen.root : tmp
+Dir.chdir dir do
+  # When archiving, also include copies of all gem packages for other platforms, this will help if the
+  # archive needs to run on a different platform to the one used to create it in the future
+  unless options[:local]
+    Bundler.with_clean_env do
+      FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+      system 'hash -r'  # Ignore fail if not on bash
+
+      passed = system "GEM_HOME=#{File.expand_path(Origen.site_config.gem_install_dir)} bundle package --all --all-platforms --no-install"
+      unless passed
+        Origen.log.error 'A problem was encountered when packaging the gems, archive aborted!'
+        exit 1
+      end
+      FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+    end
+  end
+
+  Origen.log.info 'Installing gems into the application (this could take a while)'
+  FileUtils.mkdir_p(File.join('vendor', 'gems'))
+  require 'origen/boot/app'
+  begin
+    Origen::Boot.setup(dir)
+    Origen::Boot.setup_bundler(dir)
+  rescue Exception => e
+    Origen.log.error e.to_s
+    Origen.log.error 'A problem was encountered setting up the workspace, archive aborted!'
+    exit 1
+  end
+  FileUtils.touch('.origen_archive') unless options[:local]
+
+  Bundler.with_clean_env do
+    passed = system('bundle') && system('origen -v')
+    unless passed
+      Origen.log.error 'A problem was encountered installing the gem bundle, archive aborted!'
+      exit 1
+    end
+  end
+
+  unless options[:local]
+    Origen.log.info 'Removing all temporary and output files'
+    exclude_dirs.each do |dir|
+      if File.exist?(dir)
+        if File.symlink?(dir)
+          FileUtils.rm(dir)
+        else
+          FileUtils.rm_rf(dir)
+        end
+      end
+    end
+  end
+end
+
+if options[:local]
+  Origen.log.success 'Gems have been successfully installed to your application'
+  Origen.log.success ''
+  Origen.log.success 'If you ran this in error or otherwise want to undo it, run the following command:'
+  Origen.log.success '  origen archive --no-local'
+  Origen.log.success ''
+else
+  Origen.log.info 'Creating archive'
+  Dir.chdir tmpdir do
+    FileUtils.rm_rf('.bundle') if File.exist?('.bundle')
+    passed = system "tar -cvzf #{name}.origen ./#{name}"
+    unless passed
+      Origen.log.error 'A problem was encountered creating the tarball, archive aborted!'
+      exit 1
+    end
+
+    Origen.log.info 'Cleaning up'
+    FileUtils.rm_rf(name)
+  end
+
+  puts
+  begin
+    size = `du -sh tmp/#{name}.origen`.split(/\s+/).first
+    Origen.log.success "Your application archive is complete and is #{size}B in size"
+  rescue
+    Origen.log.success 'Your application archive is complete'
+  end
+  Origen.log.success archive
+end

data/lib/origen/commands/extract.rb

@@ -0,0 +1,43 @@
+require 'optparse'
+require 'fileutils'
+require 'bundler'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: origen extract FILE [options]'
+end
+opt_parser.parse! ARGV
+
+archive = ARGV.first
+
+unless File.exist?(archive)
+  Origen.log.error "File not found: #{archive}"
+  exit 1
+end
+
+dirname = Pathname.new(archive).basename('.origen').to_s
+
+if File.exist?(dirname)
+  Origen.log.error "The application directory already exists (#{dirname}), delete it and then try again if you want to overwrite it"
+  exit 1
+end
+
+passed = system "tar -xvzf #{archive}"
+unless passed
+  Origen.log.error 'A problem was encountered extracting the tarball, extraction aborted!'
+  exit 1
+end
+
+Dir.chdir dirname do
+  Bundler.with_clean_env do
+    Origen.log.info 'Trying to boot the application...'
+
+    passed = system "#{File.join('lbin', 'origen')} -v"
+    if passed
+      Origen.log.success 'Your application has been extracted and can boot up'
+    else
+      Origen.log.error 'Something went wrong at the final hurdle, your application has been extracted but cannot boot'
+    end
+  end
+end