origen_app_generators 0.0.2

data/lib/origen_app_generators/new.rb

@@ -0,0 +1,137 @@
+module OrigenAppGenerators
+  class New < Base
+    include Origen::Utility::InputCapture
+
+    desc 'Creates a new application generator within this application'
+
+    # Naming of this method is important here to override the default user input which
+    # does not apply to this generator
+    def get_common_user_input
+      get_domain
+      get_name
+      get_type
+      get_summary
+    end
+
+    def set_type
+      # Type not applicable in for this generator
+    end
+
+    def generate_files
+      build_filelist
+    end
+
+    def enable
+      # Add require line
+      module_declaration = /\nmodule OrigenAppGenerators/
+      inject_into_file 'lib/origen_app_generators.rb', "require 'origen_app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}'\n",
+                       before: module_declaration
+
+      # Add to the AVAILABLE hash
+      if OrigenAppGenerators::AVAILABLE[@domain_summary]
+        existing_domain = /\s*('|")#{@domain_summary}('|") => \[\s*\n/
+        inject_into_file 'lib/origen_app_generators.rb', "      OrigenAppGenerators::#{@domain_namespace}::#{@classname},\n",
+                         after: existing_domain
+      else
+        new_domain = <<-END
+    '#{@domain_summary}' => [
+      OrigenAppGenerators::#{@domain_namespace}::#{@classname},
+    ],
+        END
+        available_hash = /AVAILABLE = {\s*\n/
+        inject_into_file 'lib/origen_app_generators.rb', new_domain, after: available_hash
+      end
+    end
+
+    # Can't compile this as contains some final ERB, so substitute instead
+    def customize_doc_page
+      file = filelist[:doc_info][:dest]
+      gsub_file file, 'TITLE_GOES_HERE', @title
+      if @type == :plugin
+        gsub_file file, 'INTRO_GOES_HERE', "This generates a customized version of the [Generic Plugin](<%= path 'origen_app_generators/plugin' %>)."
+      else
+        gsub_file file, 'INTRO_GOES_HERE', "This generates a customized version of the [Generic Application](<%= path 'origen_app_generators/application' %>)."
+      end
+    end
+
+    def conclude
+      puts
+      puts "New generator created at: #{filelist[:generator][:dest]}"
+      puts
+      puts "Create any template files you need for this generator in: #{filelist[:templates_dir][:dest]}"
+      puts
+      puts "Before you go add some documentation about what this generates to: templates/web/origen_app_generators/origen_app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}.md.erb"
+      puts
+    end
+
+    protected
+
+    def existing_domains
+      OrigenAppGenerators::AVAILABLE.keys.map do |key|
+        key.sub(/ Engineering$/, '')
+      end
+    end
+
+    def get_summary
+      puts
+      puts 'DESCRIBE YOUR NEW GENERATOR IN A FEW WORDS'
+      puts
+      @summary = get_text(single: true)
+      @title = @summary.sub(/^An? /, '').titleize
+    end
+
+    def get_type
+      puts
+      puts 'WILL YOUR TEMPLATE GENERATE A PLUGIN OR A TOP-LEVEL APPLICATION?'
+      puts
+      type = get_text(single: true, accept: %w(application plugin)).downcase
+      @parentclass = type.capitalize
+    end
+
+    def get_name
+      puts
+      puts 'GIVE YOUR NEW GENERATOR CLASS A NAME'
+      puts
+      puts 'Your new generator needs a class name, this should be reasonably descriptive although it will not be displayed to end users'
+      puts 'Some examples: GenericTestBlock, IPBlock, MPGBOMApp'
+      puts
+      valid = false
+      until valid
+        @classname = get_text(single: true).split('::').last
+        unless @classname.empty?
+          if @classname.length >= 3
+            valid = valid_constant?("OrigenAppGenerators::#{@domain_namespace}::#{@classname}")
+          end
+          unless valid
+            puts 'That class name is not valid :-('
+            puts
+          end
+        end
+      end
+      @classname
+    end
+
+    def get_domain
+      puts
+      puts 'WHAT ENGINEERING DOMAIN WILL YOUR NEW APP TEMPLATE APPLY TO?'
+      puts
+      puts "Enter something like 'Test', 'Design', 'Product', etc."
+      puts
+      domain = get_text(single: true)
+      domain = domain.sub(/ Engineering$/i, '').titleize
+      @domain_summary = "#{domain} Engineering"
+      @domain_namespace =  @domain_summary.gsub(' ', '')
+    end
+
+    def filelist
+      @filelist ||= {
+        generator:     { source: 'generator.rb',
+                         dest:   "lib/origen_app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}.rb" },
+        templates_dir: { dest: "templates/app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}",
+                         type: :directory },
+        doc_info:      { source: 'info.md.erb',
+                         dest:   "templates/web/origen_app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}.md.erb" }
+      }
+    end
+  end
+end

data/lib/origen_app_generators/plugin.rb

@@ -0,0 +1,39 @@
+module OrigenAppGenerators
+  # The base generator class that should be used by all plugin generators
+  class Plugin < Application
+    def get_common_user_input
+      get_name_and_namespace
+      get_summary
+      get_revision_control
+    end
+
+    protected
+
+    # See Application#filelist for more details
+    def filelist
+      @filelist ||= begin
+        list = super
+        list.delete(:web_doc_layout)
+        list.delete(:web_references)
+        list.delete(:web_defintions)
+        list.delete(:web_installation)
+        list.delete(:web_introduction)
+        list[:config_development] = { source: 'config/development.rb' }
+        list[:gemspec] = { source: 'gemspec.rb', dest: "#{@name}.gemspec" }
+        list[:templates_shared] = { dest: 'templates/shared', type: :directory }
+        list
+      end
+    end
+
+    def get_summary
+      puts
+      puts 'DESCRIBE YOUR NEW PLUGIN IN A FEW WORDS'
+      puts
+      @summary = get_text(single: true)
+    end
+
+    def type
+      :plugin
+    end
+  end
+end

data/lib/origen_app_generators/test_engineering/generic_test_block.rb

@@ -0,0 +1,68 @@
+module OrigenAppGenerators
+  module TestEngineering
+    # Generates a generic plugin shell
+    class GenericTestBlock < Plugin
+      desc 'A generic test block'
+
+      def generate_files
+        @runtime_dependencies = [
+          ['origen_testers', '>= 0.3.0.pre35']
+        ]
+        build_filelist
+      end
+
+      def add_requires
+        prepend_to_file "lib/#{@name}.rb", "require 'origen_testers'\n"
+      end
+
+      def conclude
+        puts "New test block created at: #{destination_root}"
+      end
+
+      protected
+
+      # Defines the filelist for the generator, the default list is inherited from the
+      # parent class (Plugin).
+      # The filelist can contain references to generate files, directories or symlinks in the
+      # new application.
+      #
+      # Generally to make your generator more maintainable try and re-use as much as possible
+      # from the parent generator, this means that your generator will automatically stay up
+      # to date with the latest conventions
+      #
+      # The master templates live in templates/app_generators/plugin, but
+      # DO NOT MODIFY THESE FILES DIRECTLY.
+      # Either add or remove things post-generation in the modify_files method or copy the
+      # master file to the equivalent sub-directory of templates/app_generators/test_engineering/mpg_test_block
+      # which will override the version in the master directory.
+      #
+      # Additional files can be added or removed from the filelist as shown below.
+      def filelist
+        @filelist ||= begin
+          list = super  # Always pick up the parent list
+          # Example of how to remove a file from the parent list
+          list.delete(:target_debug)
+          list.delete(:target_production)
+          # Example of how to add a file, in this case the file will be compiled and copied to
+          # the same location in the new app
+          list[:target_v93k] = { source: 'target/v93k.rb' }
+          list[:target_j750] = { source: 'target/j750.rb' }
+          list[:target_ultraflex] = { source: 'target/ultraflex.rb' }
+          list[:program_prb1] = { source: 'program/prb1.rb' }
+          list[:lib_interface] = { source: 'lib/interface.rb', dest: "lib/#{@name}/interface.rb" }
+          # Alternatively specifying a different destination, typically you would do this when
+          # the final location is dynamic
+          # list[:gemspec] = { source: 'gemspec.rb', dest: "#{@name}.gemspec" }
+          # Example of how to create a directory
+          list[:pattern_dir] = { dest: 'pattern', type: :directory }
+          # Example of how to create a symlink
+          list[:target_default] = { source: 'j750.rb',          # Relative to the file being linked to
+                                    dest:   'target/default.rb', # Relative to destination_root
+                                    type:   :symlink }
+          # Remember to return the final list
+          list
+        end
+      end
+    end
+  end
+end

data/lib/origen_app_generators.rb

@@ -0,0 +1,67 @@
+require 'origen'
+require 'colored'
+require 'origen_app_generators/base'
+require 'origen_app_generators/application'
+require 'origen_app_generators/plugin'
+require 'origen_app_generators/generic_application'
+require 'origen_app_generators/generic_plugin'
+require 'origen_app_generators/new'
+require 'origen_app_generators/test_engineering/generic_test_block'
+
+module OrigenAppGenerators
+  extend Origen::Utility::InputCapture
+
+  # If adding any new generators manually always add them at the top, but
+  # generally speaking don't, use 'rake new' to create a new generator instead
+  AVAILABLE = {
+    'Test Engineering' => [
+      OrigenAppGenerators::TestEngineering::GenericTestBlock
+    ]
+  }
+
+  def self.invoke(path)
+    puts
+    puts 'CHOOSE AN ENGINEERING DOMAIN'
+    puts
+    puts "Domain specific application templates are available for the following areas (enter '0' to build a generic one)"
+    puts
+    i = 0
+    accept = [0]
+    puts '0 - Generic / Not listed'
+    AVAILABLE.reverse_each do |domain, _generators|
+      i += 1
+      accept << i
+      puts "#{i} - #{domain}"
+    end
+    puts
+    selection = get_text(single: true, default: '0', accept: accept).to_i
+    if selection == 0
+      puts
+      puts "WHAT TYPE OF APPLICATION DO YOU WANT TO BUILD? (if you don't know go with 'application')"
+      puts
+      type = get_text(single: true, default: 'application', accept: %w(application plugin)).downcase.to_sym
+
+      if type == :application
+        OrigenAppGenerators::GenericApplication.start [path]
+      else
+        OrigenAppGenerators::GenericPlugin.start [path]
+      end
+    else
+      domain = AVAILABLE.to_a
+      domain = domain[domain.size - selection]
+      puts
+      puts "CHOOSE FROM THE FOLLOWING #{domain[0].upcase} APPLICATION TEMPLATES"
+      puts
+      accept = []
+      i = 0
+      domain[1].reverse_each do |generator|
+        accept << i
+        puts "#{i} - #{generator.desc}"
+        i += 1
+      end
+      puts
+      selection = get_text(single: true, accept: accept).to_i
+      domain[1][domain[1].size - 1 - selection].start [path]
+    end
+  end
+end

data/lib/tasks/app_generators.rake

@@ -0,0 +1,50 @@
+desc 'Create an application generator'
+task :new do
+  OrigenAppGenerators::New.start []
+end
+
+desc 'Test run the new app process'
+task :test do
+  _delete_tmp_dir
+  _execute_generator(:invoke)
+end
+
+desc "Test run a specific generator: rake 'run[TestEngineering::GenericTestBlock]'"
+task :run, [:generator_class] do |_t, args|
+  _delete_tmp_dir
+  begin
+    klass = eval(args[:generator_class])
+  rescue
+    klass = eval("OrigenAppGenerators::#{args[:generator_class]}")
+  end
+  _execute_generator(klass)
+end
+
+def _execute_generator(klass)
+  # With the generator identified this now launches it in a standalone shell
+  # This is to emulate how it will run in real life and cause it to fail if there are
+  # any dependencies on running within an Origen app environment
+
+  boot = "#{File.expand_path(File.dirname(__FILE__))}/boot.rb"
+  origen_lib = "#{Origen.top}/lib"
+  cmd = "#{boot} #{origen_lib} #{klass}"
+  cmd = "ruby #{cmd}" if Origen.running_on_windows?
+  # puts cmd
+  Bundler.with_clean_env do
+    system cmd
+  end
+end
+
+def _delete_tmp_dir
+  sh "rm -rf #{Origen.root}/tmp", verbose: false do |ok, _res|
+    # Sometimes vim can lock a dir if the file is being viewed, trying again will
+    # usually finish the job
+    unless ok
+      sh "rm -rf #{Origen.root}/tmp", verbose: false do |ok, _res|
+        unless ok
+          # I did my best!
+        end
+      end
+    end
+  end
+end

data/lib/tasks/boot.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# This is used to boot the generator in an environment with no
+# Origen application loaded.
+# This emulates how it will run when generating an app and means
+# that any unintended dependencies on a real app environment will
+# be highlighted during test.
+
+# Path to Origen lib dir must be supplied as first arg
+$LOAD_PATH.unshift ARGV[0]
+$LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../"
+
+require 'fileutils'
+
+# Prevent the bundle from loading by running this outside of the
+if RUBY_PLATFORM == 'i386-mingw32'
+  tmp_dir = 'C:/tmp/origen_app_generators/new_app'
+else
+  tmp_dir = '/tmp/origen_app_generators/new_app'
+end
+FileUtils.rm_rf tmp_dir if File.exist?(tmp_dir)
+FileUtils.mkdir_p tmp_dir
+
+begin
+  Dir.chdir tmp_dir do
+    require 'origen'
+    # For some reason this is not being defined by required origen anymore
+    User = Origen::Users::User unless defined? User
+    if RUBY_VERSION >= '2.0.0'
+      gem 'byebug', '~>3.5'
+    else
+      gem 'debugger', '~>1.6'
+    end
+    require 'origen_app_generators'
+    if ARGV[1] == 'invoke'
+      OrigenAppGenerators.invoke('tmp')
+    else
+      eval(ARGV[1]).start ['tmp']
+    end
+  end
+ensure
+  system "mv #{tmp_dir}/tmp tmp"
+end

data/templates/app_generators/application/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+source 'http://origen-hub.am.freescale.net:9292'
+
+gem "origen_core", ">= <%= @latest_origen_version %>"
+
+gem "doc_helpers"
+
+if RUBY_VERSION >= '2.0.0'
+  gem 'byebug', '~>3.5'
+else
+  gem 'debugger', '~>1.6'
+end

data/templates/app_generators/application/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/app_tasks.rake, and they will automatically be available to Rake.
+
+# Any task files found in lib/tasks/shared/*.rake will be available to other apps that
+# include this app as a plugin
+
+require "bundler/setup"
+require "origen"
+
+Origen.app.load_tasks

data/templates/app_generators/application/config/application.rb

@@ -0,0 +1,110 @@
+require 'origen'
+class <%= @namespace %>Application < Origen::Application
+
+  # See http://origen.freescale.net/origen/latest/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  # These attributes should never be changed, the duplication here will be resolved in future
+  # by condensing these attributes that do similar things
+  self.name       = "<%= @name %>"
+  self.namespace  = "<%= @namespace %>"
+  config.name     = "<%= @name %>"
+  config.initials = "<%= @namespace %>"
+  config.vault    = "<%= @vault %>" 
+
+  # 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/<%= @name %>"
+  config.web_domain = "http://origen.freescale.net/<%= @name %>"
+
+  # 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"],
+  }
+
+  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
+
+  # Similarly 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.prefixed}"
+      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 across 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
+
+end

data/templates/app_generators/application/config/commands.rb

@@ -0,0 +1,76 @@
+# 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 ex' to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "ex" => "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
+
+# Here is an example of how to implement a command, the logic can go straight
+# in here or you can require an external file if preferred.
+when "my_command"
+  puts "Doing something..."
+  require "commands/my_command"    # Would load file lib/commands/my_command.rb
+  # You must always exit upon successfully capturing a command to prevent 
+  # control flowing back to Origen
+  exit 0
+
+## Example of how to make a command to run unit tests, this simply invokes RSpec on
+## the spec directory
+#when "specs"
+#  ARGV.unshift "spec"
+#  require "rspec"
+#  require "rspec/autorun"
+#  exit 0 # This will never be hit on a fail, RSpec will automatically exit 1
+
+## Example of how to make a command to run diff-based 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.
+else
+  # You probably want to also add the your commands 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.
+#  @application_commands = <<-EOT
+# specs        Run the specs (tests), -c will enable coverage
+# examples     Run the examples (tests), -c will enable coverage
+#  EOT
+
+end 

data/templates/app_generators/application/config/environment.rb

@@ -0,0 +1,4 @@
+# This file will be loaded by Origen to boot your application, just leave it as
+# is and modify lib/<%= @name %>.rb to load the additional resources that your
+# application requires
+require "<%= @name %>"

data/templates/app_generators/application/config/users.rb

@@ -0,0 +1,29 @@
+# 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 rc tag" command, 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 ||= [
+
+        # Admins - Notified on every tag
+        User.new("<%= User.current.name %>", "<%= User.current.core_id %>", :admin),
+
+        # Users - Notified on official release tags only
+        #User.new("Stephen McGinty", "r49409"),
+        # The r-number attribute can be anything that can be prefixed to an 
+        # @freescale.com email address, so you can add mailing list references
+        # as well like this:
+        #User.new("Origen Users", "origen"),  # The Origen mailing list
+        
+      ]
+    end
+  end
+end

data/templates/app_generators/application/config/version.rb

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

data/templates/app_generators/application/lib/app.rake

@@ -0,0 +1,6 @@
+# You can define any Rake tasks to support your application here (or in any file
+# ending in .rake in this directory).
+#
+# Rake (Ruby Make) is very useful for creating build scripts, see this short video
+# for a quick introduction:
+# http://railscasts.com/episodes/66-custom-rake-tasks