origen_app_generators 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b62097b0a52eb5b3b37d8861518f5673c23bc609
+  data.tar.gz: 53dba9b5c337583764bb55fd591bdd82091cd4fe
+SHA512:
+  metadata.gz: 4054a7da719c69903d3f00e3623e6f9404698e3d71c81324aa55dc83cf92308c2e6055e22131102219001084ab79a73082af4b43348e7ef85843bce2c6c73e08
+  data.tar.gz: ff3a36f08acdadb8dff73c87b9c6426d36bc1825829cec4bab95632a4bea9b0885242e71f6ce112f9edb7aa4e683f2212c3f0062a2f73d58b25dde281fcd6629

data/config/application.rb

@@ -0,0 +1,146 @@
+require 'origen'
+class OrigenAppGeneratorsApplication < Origen::Application
+  # This information is used in headers and email templates, set it specific
+  # to your application
+  config.name     = "Origen App Generators"
+  config.initials = "Origen_App_Generators"
+  config.rc_url   = "ssh://git@github.com:Origen-SDK/origen_app_generators.git"
+  config.release_externally = true
+
+  # To enable deployment of your documentation to a web server (via the 'origen web'
+  # command) fill in these attributes. The example here is configured to deploy to
+  # the origen.freescale.net domain, which is an easy option if you don't have another
+  # server already in mind. To do this you will need an account on CDE and to be a member
+  # of the 'origen' group.
+  config.web_directory = "/proj/.web_origen/html/origen_app_generators"
+  config.web_domain = "http://origen-sdk.org/origen_app_generators"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  # See: http://origen.freescale.net/origen/latest/guides/utilities/lint/
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    run_on_tag: true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    auto_correct: true, 
+    # Limit the testing for large legacy applications
+    #level: :easy,
+    # Run on these directories/files by default
+    #files: ["lib", "config/application.rb"],
+  }
+
+  # Versioning is based on a timestamp by default, if you would rather use semantic
+  # versioning, i.e. v1.0.0 format, then set this to true.
+  # In parallel go and edit config/version.rb to enable the semantic version code.
+  config.semantically_version = true
+
+  # An example of how to set application specific LSF parameters
+  #config.lsf.project = "msg.te"
+  
+  # An example of how to specify a prefix to add to all generated patterns
+  #config.pattern_prefix = "nvm"
+
+  # An example of how to add header comments to all generated patterns
+  #config.pattern_header do
+  #  cc "This is a pattern created by the example origen application"
+  #end
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory. 
+  #config.output_directory do
+  #  "#{Origen.root}/output/#{$dut.class}"
+  #end
+
+  # Similary for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  #config.reference_directory do
+  #  "#{Origen.root}/.ref/#{$dut.class}"
+  #end
+ 
+  # This will automatically deploy your documentation after every tag
+  #def after_release_email(tag, note, type, selector, options)
+  #  deployer = Origen.app.deployer
+  #  if deployer.running_on_cde? && deployer.user_belongs_to_origen?
+  #    command = "origen web compile --remote --api"
+  #    if Origen.app.version.production?
+  #      command += " --archive #{Origen.app.version}"
+  #    end
+  #    Dir.chdir Origen.root do
+  #      system command
+  #    end
+  #  end 
+  #end
+
+  # Ensure that all tests pass before allowing a release to continue
+  #def validate_release
+  #  if !system("origen specs") || !system("origen examples")
+  #    puts "Sorry but you can't release with failing tests, please fix them and try again."
+  #    exit 1
+  #  else
+  #    puts "All tests passing, proceeding with release process!"
+  #  end
+  #end
+
+  # To enabled source-less pattern generation create a class (for example PatternDispatcher)
+  # to generate the pattern. This should return false if the requested pattern has been
+  # dispatched, otherwise Origen will proceed with looking up a pattern source as normal.
+  #def before_pattern_lookup(requested_pattern)
+  #  PatternDispatcher.new.dispatch_or_return(requested_pattern)
+  #end
+
+  # If you use pattern iterators you may come accross the case where you request a pattern
+  # like this:
+  #   origen g example_pat_b0.atp
+  #
+  # However it cannot be found by Origen since the pattern name is actually example_pat_bx.atp
+  # In the case where the pattern cannot be found Origen will pass the name to this translator
+  # if it exists, and here you can make any substitutions to help Origen find the file you 
+  # want. In this example any instances of _b\d, where \d means a number, are replaced by
+  # _bx.
+  #config.pattern_name_translator do |name|
+  #  name.gsub(/_b\d/, "_bx")
+  #end
+
+  # If you want to use pattern iterators, that is the ability to generate multiple pattern
+  # variants from a single source file, then you can define the required behavior here.
+  # The examples below implement some of the iterators that were available in Origen 1,
+  # you can remove them if you don't want to use them, or of course modify or add new 
+  # iterators specific to your application logic.
+  
+  # By setting iterator
+  config.pattern_iterator do |iterator|
+    # Define a key that you will use to enable this in a pattern, here the iterator
+    # can be enabled like this: Pattern.create(by_setting: [1,2,3]) do
+    iterator.key = :by_setting
+
+    # The value passed from the pattern via the key comes in here as the first
+    # argument, the name applied here can be anything, but settings seem reasonable since
+    # an array of setting values is expected.
+    # The last argument &pattern is mandatory and represents the pattern block (the bit contained
+    # within Pattern.create do ... end)
+    iterator.loop do |settings, &pattern|
+      # Implement the loop however you like, here we loop for each value in the array
+      settings.each do |setting|
+        # Now call the pattern passing in the setting argument, this would be captured
+        # in the pattern like this:
+        #   Pattern.create do |setting|
+        pattern.call(setting)
+      end
+    end
+
+    # Each pattern iteration needs a unique name, otherwise Origen will simply overwrite 
+    # the same output file each time.
+    # The base pattern name and the pattern argument, in this case the setting, will be
+    # passed in here and whatever is returned is what will be used as the name.
+    iterator.pattern_name do |name, setting|
+      # Substiture _x in the name with the setting, _1, _2, etc.
+      name.gsub("_x", "_#{setting}")
+    end
+  end
+
+
+end

data/config/commands.rb

@@ -0,0 +1,75 @@
+# This file should be used to extend the origen command line tool with tasks 
+# specific to your application.
+# The comments below should help to get started and you can also refer to
+# lib/origen/commands.rb in your Origen core workspace for more examples and 
+# inspiration.
+#
+# Also see the official docs on adding commands:
+#   http://origen.freescale.net/origen/latest/guides/custom/commands/
+
+# Map any command aliases here, for example to allow origen -x to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "-x" => "execute",
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+## Now branch to the specific task code
+#case @command
+#
+## Run the unit tests  
+#when "specs"
+#  ARGV.unshift "spec"
+#  require "rspec"
+#  # For some unidentified reason Rspec does not autorun on this version
+#  if RSpec::Core::Version::STRING && RSpec::Core::Version::STRING == "2.11.1"
+#    RSpec::Core::Runner.run ARGV
+#  else
+#    require "rspec/autorun"
+#  end
+#  exit 0 # This will never be hit on a fail, RSpec will automatically exit 1
+#
+## Run the example-based (diff) tests
+#when "examples"  
+#  Origen.load_application
+#  status = 0
+#
+#  # Compiler tests
+#  ARGV = %w(templates/example.txt.erb -t debug -r approved)
+#  load "origen/commands/compile.rb"
+#  # Pattern generator tests
+#  #ARGV = %w(some_pattern -t debug -r approved)
+#  #load "#{Origen.top}/lib/origen/commands/generate.rb"
+#
+#  if Origen.app.stats.changed_files == 0 &&
+#     Origen.app.stats.new_files == 0 &&
+#     Origen.app.stats.changed_patterns == 0 &&
+#     Origen.app.stats.new_patterns == 0
+#
+#    Origen.app.stats.report_pass
+#  else
+#    Origen.app.stats.report_fail
+#    status = 1
+#  end
+#  puts
+#  exit status  # Exit with a 1 on the event of a failure per std unix result codes
+#
+## Always leave an else clause to allow control to fall back through to the
+## Origen command handler.
+## You probably want to also add the command details to the help shown via
+## origen -h, you can do this be assigning the required text to @application_commands
+## before handing control back to Origen. Un-comment the example below to get started.
+#else
+#  @application_commands = <<-EOT
+# specs        Run the specs (tests), -c will enable coverage
+# examples     Run the examples (tests), -c will enable coverage
+#  EOT
+#
+#  # Uncomment the following and update the path with the file
+#  # that handles the commands that are shared from this plugin
+#  #require "#{Origen.app_root}/config/shared_commands"
+#
+#end 

data/config/environment.rb

@@ -0,0 +1 @@
+require "origen_app_generators"

data/config/users.rb

@@ -0,0 +1,19 @@
+# This file defines the users associated with your project, it is basically the 
+# mailing list for release notes.
+#
+# You can split your users into "admin" and "user" groups, the main difference 
+# between the two is that admin users will get all tag emails, users will get
+# emails on external/official releases only.
+#
+# Users are also prohibited from running the "origen tag" task, but this is 
+# really just to prevent a casual user from executing it inadvertently and is
+# not intended to be a serious security gate.
+module Origen
+  module Users
+    def users
+      @users ||= [
+
+      ]
+    end
+  end
+end

data/config/version.rb

@@ -0,0 +1,8 @@
+module OrigenAppGenerators
+  MAJOR = 0
+  MINOR = 0
+  BUGFIX = 2
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/origen_app_generators/application.rb

@@ -0,0 +1,62 @@
+module OrigenAppGenerators
+  # The base generator class that should be used by all application generators
+  class Application < Base
+    # Any methods that are not protected will get invoked in the order they are
+    # defined when the generator is run
+
+    protected
+
+    def type
+      :application
+    end
+
+    # This is the default list of files that will get generated for a new application
+    # when you call the compile_filelist method.
+    # To customize this for a domain specific application generator you can either
+    # delete an entry:
+    #
+    #   filelist.delete(:config_application)
+    #   compile_filelist
+    #
+    # Or point it to a different template, the supplied path is relative to templates/app_generators
+    #
+    #   filelist[:config_application][:source] = "dng_test_app/config/application.rb"
+    #   compile_filelist
+    def filelist
+      fail '@name must be defined before calling filelist for the first time' unless @name
+      @filelist ||= {
+        config_application: { source: 'config/application.rb' },
+        config_version:     { source: 'config/version.rb' },
+        config_users:       { source: 'config/users.rb' },
+        config_environment: { source: 'config/environment.rb' },
+        config_commands:    { source: 'config/commands.rb' },
+        doc_history:        { source: 'doc/history' },
+        target_debug:       { source: 'target/debug.rb' },
+        target_production:  { source: 'target/production.rb' },
+        target_default:     { source: 'debug.rb',          # Relative to the file being linked to
+                              dest:   'target/default.rb', # Relative to destination_root
+                              type:   :symlink },
+        lib_module:         { source: 'lib/module.rb',
+                              dest:   "lib/#{@name}.rb" },
+        lib_top_level:      { source: 'lib/top_level.rb',
+                              dest:   "lib/#{@name}/top_level.rb" },
+        lib_tasks:          { source: 'lib/app.rake',
+                              dest:   "lib/tasks/#{@name}.rake" },
+        spec_helper:        { source: 'spec/spec_helper.rb' },
+        web_index:          { source: 'templates/web/index.md.erb' },
+        web_basic_layout:   { source: 'templates/web/layouts/_basic.html.erb' },
+        web_doc_layout:     { source: 'templates/web/layouts/_doc.html.erb' },
+        web_navbar:         { source: 'templates/web/partials/_navbar.html.erb' },
+        web_references:     { source: 'templates/web/references.md.erb' },
+        web_archive:        { source: 'templates/web/archive.md.erb' },
+        web_contact:        { source: 'templates/web/contact.md.erb' },
+        web_release_notes:  { source: 'templates/web/release_notes.md.erb' },
+        web_defintions:     { source: 'templates/web/docs/environment/definitions.md.erb' },
+        web_installation:   { source: 'templates/web/docs/environment/installation.md.erb' },
+        web_introduction:   { source: 'templates/web/docs/environment/introduction.md.erb' },
+        rakefile:           { source: 'Rakefile' },
+        gemfile:            { source: 'Gemfile' }
+      }
+    end
+  end
+end

data/lib/origen_app_generators/base.rb

@@ -0,0 +1,201 @@
+module OrigenAppGenerators
+  # This is the base generator used by all generators in this application
+  class Base < Origen::CodeGenerators::Base
+    include Origen::Utility::InputCapture
+
+    require 'gems'
+
+    def set_source_paths
+      # The base Origen generator puts the Origen core directory on the source path, in retrospect this
+      # was a bad idea and makes for hard to debug errors if an app generator resolves a template from
+      # outside of this app.
+      # So to keep things sane remove any inherited source paths.
+      self.class.source_paths.pop until self.class.source_paths.empty?
+      klass = self.class
+      until klass == OrigenAppGenerators::Base
+        dir = klass.to_s.sub('OrigenAppGenerators::', '').split('::').map(&:underscore).join('/')
+        dir = File.expand_path("../../../templates/app_generators/#{dir}", __FILE__)
+        self.class.source_paths << dir if File.exist?(dir)
+        klass = klass.superclass
+      end
+    end
+
+    # Just makes the type (:plugin or :application) available to all templates
+    def set_type
+      @type = type
+    end
+
+    def get_common_user_input
+      get_name_and_namespace
+      get_revision_control
+    end
+
+    def get_lastest_origen_version
+      (Gems.info 'origen')['version']
+    end
+
+    protected
+
+    def self.title
+      desc.sub(/^An? /, '').titleize
+    end
+
+    def get_revision_control
+      puts ''
+      puts 'IS THIS FOR TRAINING?'
+      puts ''
+      training = get_text(confirm: :return_boolean, default: 'no')
+      if type == :plugin && !training
+        puts ''
+        puts 'WHAT CATEGORY BEST DESCRIBES YOUR PLUGIN??'
+        puts ''
+        cats = {
+          dut:      'Top-level SoC/DUT models',
+          helper:   'Helper methods and code snippets',
+          physical: 'Physical interface drivers (e.g. JTAG)',
+          protocol: 'Protocol driver providing read/write register APIs (e.g. JTAG2IPS)',
+          module:   'A module to support testing a specific silicon block',
+          tester:   'Any Origen tester model, could be an ATE or a debugger or testbench stimulus generator ',
+          misc:     'Anything else'
+        }
+        cats.each do |key, val|
+          puts "#{key} - #{val}"
+        end
+        puts ''
+        category = get_text(single: true, accept: cats.keys).downcase.to_sym
+      end
+      @vault = 'sync://sync-15088:15088/Projects/common_tester_blocks/'
+      if training
+        @vault += 'origen_training/'
+      elsif type == :plugin
+        @vault += "origen_blocks/#{category}/"
+      else
+        @vault += 'blocks/'
+      end
+      @vault += "#{@name}/tool_data/origen"
+    end
+
+    # Calling this will compile all files in filelist against the current instance
+    # variable values
+    def build_filelist
+      symlink_cmds = []
+      self.destination_root = args.first
+      filelist.each do |_name, file|
+        if file[:type] == :symlink
+          if Origen.running_on_windows?
+            dest = Pathname.new("#{destination_root}/#{file[:dest]}")
+            source = dest.dirname.to_s + "/#{file[:source]}"
+            symlink_cmds << "call mklink /h #{dest.to_s.gsub('/', '\\')} #{source.to_s.gsub('/', '\\')}"
+          else
+            create_link file[:dest], file[:source]
+          end
+        elsif file[:type] == :dir || file[:type] == :directory
+          empty_directory(file[:dest] || file[:source])
+        else
+          dest = file[:dest] || file[:source]
+          if file[:copy] || dest =~ /.erb$/
+            copy_file(file[:source], dest)
+          else
+            template(file[:source], dest)
+          end
+        end
+      end
+      symlink_cmds.each { |cmd| system(cmd) }
+    end
+
+    # Convenience method that is equivalent to calling get_name and then get_namespace
+    def get_name_and_namespace
+      get_name
+      get_namespace
+    end
+
+    # Prompts the user to confirm or enter the Ruby namespace to be used in the app.
+    #
+    # If @name is already defined a proposal will be generated from that, alternatively a proposal
+    # can be supplied. If not proposal is resolved the user will be prompted to input from scratch.
+    def get_namespace(proposal = nil)
+      puts
+      puts "SELECT YOUR #{type.to_s.upcase}'S NAMESPACE"
+      puts
+      puts "All #{type} code needs to reside in a unique namespace, this prevents naming collisions with 3rd party plugins."
+      puts 'By Ruby conventions this must start with a capital letter and should ideally be CamelCased and not use underscores'
+      puts 'Some examples:: C40TFSNVMTester, CAPIOrigen, LS2080, ApacheOrigen'
+      puts
+      if !proposal && @name
+        proposal = @name.to_s.camelize
+      end
+      proposal = nil if proposal.length < 3
+      proposal.gsub(/Rgen/i, 'Origen') if proposal
+
+      valid = false
+      until valid
+        @namespace = get_text(single: true, default: proposal)
+        proposal = nil
+        unless @namespace.empty?
+          if @namespace.length >= 3
+            valid = valid_constant?(@namespace)
+          end
+          unless valid
+            puts 'That namespace is not valid :-('
+            puts
+          end
+        end
+      end
+      @namespace
+    end
+
+    # Returns true if the given string can be converted to a valid Ruby constant and one that
+    # does not already exist within the scope of this application and Origen Core
+    def valid_constant?(string)
+      valid = false
+      # Try and convert this to a constant to test for validity, this will also screen things
+      # like Origen since that will not trigger an error
+      begin
+        string.constantize
+      rescue NameError => e
+        if e.message =~ /^uninitialized constant/
+          valid = true
+        end
+      else
+        # Something else is wrong with it
+      end
+      valid
+    end
+
+    # Prompts the user to input a name for the new application, this will be screened to ensure
+    # that it can cleanly cast to a symbol for use in Origen.
+    #
+    # This should be unique within the whole Origen ecosystem, in future this method will be enhanced
+    # to check with the Origen server which will in future maintain a database of known app names.
+    #
+    # The final name is returned at the end and assigned to variable @name for use in templates.
+    def get_name
+      proposal = args.first.symbolize.to_s
+      proposal = nil if proposal.length < 3
+      puts
+      puts "WHAT DO YOU WANT TO CALL YOUR NEW #{type.to_s.upcase}?"
+      puts
+      puts "This should be lowercased and underscored and will be used to uniquely identify your #{type} within the Origen ecosystem."
+      puts 'Some examples: c40tfs_nvm_tester, capi_origen, ls2080, apache_origen'
+      puts
+      valid = false
+      until valid
+        name = get_text(single: true, default: proposal)
+        proposal = nil
+        unless name.empty?
+          if name == name.symbolize.to_s
+            if name.symbolize.to_s.length >= 3
+              valid = true
+              @name = name
+            end
+          else
+            puts
+            puts 'That name is not valid, how about this?'
+            proposal = name.symbolize.to_s
+          end
+        end
+      end
+      @name
+    end
+  end
+end

data/lib/origen_app_generators/generic_application.rb

@@ -0,0 +1,15 @@
+module OrigenAppGenerators
+  # Generates a generic application shell
+  class GenericApplication < Application
+    # Any methods that are not protected will get invoked in the order they are
+    # defined when the generator is run
+
+    def generate_files
+      build_filelist
+    end
+
+    def conclude
+      puts "New app created at: #{destination_root}"
+    end
+  end
+end

data/lib/origen_app_generators/generic_plugin.rb

@@ -0,0 +1,15 @@
+module OrigenAppGenerators
+  # Generates a generic plugin shell
+  class GenericPlugin < Plugin
+    # Any methods that are not protected will get invoked in the order they are
+    # defined when the generator is run
+
+    def generate_files
+      build_filelist
+    end
+
+    def conclude
+      puts "New app created at: #{destination_root}"
+    end
+  end
+end