origen 0.44.0 → 0.50.0

data/lib/origen/code_generators/dut.rb

@@ -0,0 +1,62 @@
+module Origen
+  module CodeGenerators
+    class Dut < Origen::CodeGenerators::Base
+      include BlockCommon
+
+      def self.banner
+        'origen new dut NAME'
+      end
+
+      desc <<-END
+This generator creates a top-level (DUT) block and all of the associated resources for it, e.g. a model,
+controller, target, timesets, pins, etc.
+
+The NAME of the DUT should be given in lower case, optionally prefixed by parent DUT name(s) separated
+by a forward slash.
+
+Any parent DUT(s) will be created if they don't exist, but they will not be modified if they do.
+
+Examples:
+  origen new dut falcon         # Creates app/blocks/dut/derivatives/falcon/...
+  origen new dut dsp/falcon     # Creates app/blocks/dut/derivatives/dsp/derivatives/falcon/...
+END
+
+      def validate_args
+        if args.size > 1 || args.size == 0
+          msg = args.size > 1 ? 'Only one' : 'One'
+          msg << " argument is expected by the DUT generator, e.g. 'origen new dut my_soc', 'origen new dut my_family/my_soc"
+          puts msg
+          exit 1
+        end
+        validate_args_common
+      end
+
+      def setup
+        @generate_model = true
+        @generate_pins = true
+        @generate_timesets = true
+        @generate_parameters = true
+        @top_level = true
+        extract_model_name
+        create_files
+      end
+
+      def create_target
+        contents = ''
+        contents << @final_namespaces.map { |n| camelcase(n) }.join('::')
+        contents << "::#{camelcase(@name)}.new\n"
+
+        create_file "#{Origen.root}/target/#{@name}.rb", contents
+      end
+
+      def completed
+        add_acronyms
+        puts
+        puts 'New DUT created, run the following command to target it in your workspace:'.green
+        puts
+        puts "  origen t #{@name}"
+        puts
+      end
+    end
+  end
+end

data/lib/origen/code_generators/feature.rb

@@ -0,0 +1,50 @@
+module Origen
+  module CodeGenerators
+    class Feature < Origen::CodeGenerators::Base
+      include BlockCommon
+
+      def self.banner
+        'origen new feature NAME'
+      end
+
+      desc <<-END
+This generator creates a new feature block, which is similar to a regular block but with no model and controller.
+Such features can then be loaded (re-used) by multiple blocks within your application code.
+
+The name of the feature should be given in lower case, optionally prefixed by parent feature name(s) separated
+by a forward slash.
+
+Any parent features will be created if they don't exist, but they will not be modified if they do.
+
+Examples:
+  origen new feature my_feature              # Creates app/blocks/my_feature/...
+  origen new feature features/my_feature     # Creates app/blocks/features/my_feature/...
+
+The above can then be loaded to models in your application code via:
+
+  my_model.load_block('my_feature')
+  my_model.load_block('features/my_feature')
+END
+
+      def validate_args
+        if args.size > 1 || args.size == 0
+          msg = args.size > 1 ? 'Only one' : 'One'
+          msg << " argument is expected by the feature generator, e.g. 'origen new feature my_feature', 'origen new feature features/my_feature"
+          puts msg
+          exit 1
+        end
+        validate_args_common
+      end
+
+      def setup
+        @generate_model = false
+        @generate_pins = true
+        @generate_timesets = true
+        @generate_parameters = true
+        extract_model_name
+        create_files
+        add_acronyms
+      end
+    end
+  end
+end

data/lib/origen/code_generators/klass.rb

@@ -0,0 +1,41 @@
+module Origen
+  module CodeGenerators
+    class Klass < Origen::CodeGenerators::Base
+      def self.banner
+        'origen new class NAME'
+      end
+
+      desc <<-END
+This generator creates a plain old Ruby class within your application's lib directory.
+
+The NAME of the class should be given, in lower case, optionally indicating the presence
+of any namespacing you want it to be created under.
+
+Examples:
+  origen new class counter          # Creates app/lib/my_application/counter.rb
+  origen new class helpers/counter  # Creates app/lib/my_application/helpers/counter.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 class generator, e.g. 'origen new class counter', 'origen new class helpers/counter'"
+          puts msg
+          exit 1
+        end
+        validate_resource_name(args.first)
+      end
+
+      def create_class_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/class.rb', file
+      end
+    end
+  end
+end

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/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/commands/lint.rb

@@ -32,7 +32,12 @@ 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"
+    files = []
+    ['lib', 'app/lib', 'app/blocks'].each do |sub_dir|
+      dir = "#{Origen.root}/#{sub_dir}"
+      files << dir if File.exist?(dir)
+    end
+    files = files.join(' ')
   end
 else
   files = ARGV.join(' ')

data/lib/origen/commands/new.rb

@@ -62,7 +62,7 @@ else
   end
 end
 
-generators = [['https://rubygems.org', 'origen_app_generators']] + Array(Origen.site_config.app_generators)
+generators = [['https://rubygems.org', 'origen_app_generators_v2']] + Array(Origen.site_config.app_generators)
 
 def use_packaged_generators
   FileUtils.cp_r Origen.top.join('origen_app_generators').to_s, '.'

data/lib/origen/commands/new_resource.rb

@@ -0,0 +1,41 @@
+# require 'optparse'
+# require 'origen/commands/helpers'
+#
+# 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 new RESOURCE_TYPE RESOURCE_NAME [options]'
+#  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+#  # Apply any application option extensions to the OptionParser
+#  Origen::CommandHelpers.extend_options(opts, app_options, options)
+#  opts.separator ''
+#  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+# end
+#
+# opt_parser.parse! ARGV
+#
+# command = ARGV.shift
+#
+# case command
+# when "model"
+#
+#
+# else
+#  puts "Unknown resource type, must be one of: model"
+#  exit 1
+# end
+
+require 'origen/code_generators'
+
+# if no argument/-h/--help is passed to origen add command, then
+# it generates the help associated.
+if [nil, '-h', '--help'].include?(ARGV.first)
+  Origen::CodeGenerators.help 'new'
+  exit
+end
+
+name = ARGV.shift
+
+Origen::CodeGenerators.invoke name, ARGV # , behavior: :invoke, destination_root: Origen.root

data/lib/origen/commands/web.rb

@@ -19,7 +19,7 @@ The following commands are available:
   serve           Start a webserver from the current directory
 
   compile [FILE]  Compile all web templates and start a server to view them, optionally supply a
-                  file argument to only update a single page e.g. 'origen web compile templates/web/index.md.erb'
+                  file argument to only update a single page e.g. 'origen web compile app/templates/web/index.md.erb'
                   Use the --remote option to copy the compiled files to a remote web server directory (the
                   location of which should be specified via Origen.config.web_directory). In this case when no
                   FILE argument is specified the entire site will be copied over to a fresh web server
@@ -104,7 +104,7 @@ The following options are available:
     puts "Web server directory created at: #{dir}"
     puts ''
     puts "Compile any files you want to test into the #{dir}/content directory, e.g.:"
-    puts "  origen c templates/file.md.erb -o #{dir}/content"
+    puts "  origen c app/templates/file.md.erb -o #{dir}/content"
     puts ''
     puts 'To turn them into web pages:'
     puts "  cd #{dir}"
@@ -149,9 +149,12 @@ The following options are available:
           Origen.app.listeners_for(:before_web_compile).each do |listener|
             listener.before_web_compile(options)
           end
-          Origen.app.runner.launch action: :compile,
-                                   files:  'templates/web',
-                                   output: 'web/content'
+          templates_web_dir = 'app/templates/web'
+          templates_web_dir = 'templates/web' unless File.exist?("#{Origen.root}/#{templates_web_dir}")
+          templates_web_dir =
+        Origen.app.runner.launch action: :compile,
+                                 files:  templates_web_dir,
+                                 output: 'web/content'
           Origen.app.listeners_for(:after_web_compile).each do |listener|
             listener.after_web_compile(options)
           end
@@ -168,7 +171,9 @@ The following options are available:
         ARGV.each do |file|
           path = Origen.file_handler.clean_path_to(file)
           if path.to_s =~ /origen_guides/
-            output = Origen.file_handler.sub_dir_of(path, "#{Origen.root}/templates/origen_guides")
+            origen_guides_dir = 'app/templates/origen_guides'
+            origen_guides_dir = 'templates/origen_guides' unless File.exist?("#{Origen.root}/#{origen_guides_dir}")
+            output = Origen.file_handler.sub_dir_of(path, "#{Origen.root}/#{origen_guides_dir}")
           else
             output = Origen.file_handler.sub_dir_of(path, "#{Origen.root}/templates/web")
           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,6 +30,18 @@ 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
@@ -227,6 +240,10 @@ when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'enviro
   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
@@ -272,6 +289,7 @@ The core origen commands are:
  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/file_handler.rb

@@ -100,7 +100,7 @@ module Origen
     def clean_path_to(file, options = {})
       # Allow individual calls to this method to specify additional custom load paths to consider
       if options[:load_paths]
-        [options[:load_paths]].each do |root|
+        Array(options[:load_paths]).each do |root|
           if File.exist?("#{root}/#{file}")
             return Pathname.new("#{root}/#{file}")
           end
@@ -222,7 +222,7 @@ module Origen
       begin
         # Allow relative references to templates/web when compiling a web template
         if Origen.lsf.current_command == 'web' || web_file
-          clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
+          clean_path_to(file, load_paths: ["#{Origen.root}/app/templates/web", "#{Origen.root}/templates/web"])
         else
           clean_path_to(file)
         end
@@ -230,7 +230,7 @@ module Origen
         # Try again without .erb
         file = file.gsub('.erb', '')
         if Origen.lsf.current_command == 'web' || web_file
-          clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
+          clean_path_to(file, load_paths: ["#{Origen.root}/app/templates/web", "#{Origen.root}/templates/web"])
         else
           clean_path_to(file)
         end
@@ -264,7 +264,11 @@ module Origen
             if import_name == :origen || import_name == :origen_core
               path.sub! 'origen', "#{Origen.top}/templates/shared"
             else
-              path.sub! Regexp.last_match[1], "#{root}/templates/shared"
+              if File.exist?("#{root}/app/templates/shared")
+                path.sub! Regexp.last_match[1], "#{root}/app/templates/shared"
+              else
+                path.sub! Regexp.last_match[1], "#{root}/templates/shared"
+              end
             end
           else
             fail 'Unknown import path type!'

data/lib/origen/generator/pattern_finder.rb

@@ -95,10 +95,10 @@ module Origen
           matches = Dir.glob("#{current_plugin_pattern_path}/**/#{name}.rb").sort
           # If the current plugin does  not include the pattern then look into the current app
           if matches.size == 0
-            matches = Dir.glob("#{pattern_directory}/**/#{name}.rb").sort # <= this does not include symlinks
+            matches = Dir.glob(["#{pattern_directory}/**/#{name}.rb", "#{Origen.root}/app/patterns/**/#{name}.rb"]).sort # <= this does not include symlinks
           end
         else
-          matches = Dir.glob("#{pattern_directory}/**/#{name}.rb").sort # <= this does not include symlinks
+          matches = Dir.glob(["#{pattern_directory}/**/#{name}.rb", "#{Origen.root}/app/patterns/**/#{name}.rb"]).sort # <= this does not include symlinks
         end
 
         matches
@@ -114,7 +114,7 @@ module Origen
 
       def all_matches(name)
         name = name.gsub(/\..*$/, '')
-        matches = Dir.glob("#{pattern_directory}/**{,/*/**}/#{name}.rb").sort # Takes symlinks into consideration
+        matches = Dir.glob(["#{pattern_directory}/**{,/*/**}/#{name}.rb", "#{Origen.root}/app/patterns/**{,/*/**}/#{name}.rb"]).sort # Takes symlinks into consideration
         matches.flatten.uniq
       end