origen 0.34.3 → 0.52.0

data/origen_app_generators/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_boot:        { source: 'config/boot.rb' },
+        config_commands:    { source: 'config/commands.rb' },
+        config_dev:         { source: 'config/maillist_dev.txt' },
+        config_prod:        { source: 'config/maillist_prod.txt' },
+        doc_history:        { source: 'doc/history' },
+        target_default:     { source: 'target/default.rb' },
+        # target_default:      { source: 'debug.rb',          # Relative to the file being linked to
+        #                       dest:   'target/default.rb', # Relative to destination_root
+        #                       type:   :symlink },
+        environment_dir:    { dest: 'environment', type: :directory },
+        lib_module:         { source: 'app/lib/module.rb',
+                              dest:   "app/lib/#{@name}.rb" },
+        lib_module_dir:     { dest:   "app/lib/#{@name}", type: :directory },
+        app_blocks_dir:     { dest:   'app/blocks', type: :directory },
+        spec_helper:        { source: 'spec/spec_helper.rb' },
+        web_index:          { source: 'app/templates/web/index.md.erb' },
+        web_basic_layout:   { source: 'app/templates/web/layouts/_basic.html.erb' },
+        web_navbar:         { source: 'app/templates/web/partials/_navbar.html.erb' },
+        web_release_notes:  { source: 'app/templates/web/release_notes.md.erb' },
+        rakefile:           { source: 'Rakefile' },
+        gemfile:            { source: 'Gemfile' },
+        gitignore:          { source: '.gitignore' },
+        irbrc:              { source: '.irbrc' },
+        rspec:              { source: '.rspec' },
+        # This sets the initial mode of the new workspace to 'debug'
+        session:            { source: 'origen_core_session',
+                              dest:   '.session/origen_core',
+                              copy:   true
+                             }
+      }
+    end
+  end
+end

data/origen_app_generators/lib/origen_app_generators/base.rb

@@ -0,0 +1,257 @@
+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 validate_application_name
+      @name = args.first.to_s.strip
+      if @name == ''
+        puts
+        puts "You must supply a name for what you want to call your application: 'origen new my_name'"
+        puts
+        exit 1
+      elsif @name != @name.symbolize.to_s
+        puts
+        puts 'The name of your new app must be lowercased and underscored and contain no special characters'
+        puts
+        exit 1
+      end
+    end
+
+    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
+        if template_dir = OrigenAppGenerators.template_dirs[klass]
+          dir = []
+          last_class = nil
+          until klass.to_s =~ /^OrigenAppGenerators/
+            dir << "#{template_dir}/#{class_dir(klass)}"
+            last_class = klass
+            klass = klass.superclass
+          end
+          dir << "#{template_dir}/base"
+          klass = last_class
+        else
+          dir = []
+          class_dirs(klass).each do |class_dir|
+            dir << "#{Origen.root!}/templates/app_generators/#{class_dir}"
+            dir << "#{Origen.root!}/app/templates/app_generators/#{class_dir}"
+          end
+        end
+        Array(dir).each do |dir|
+          self.class.source_paths << dir if File.exist?(dir) && !self.class.source_paths.include?(dir)
+        end
+        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
+      # Don't bother asking the user for this, their life will be easier if they just go with
+      # Origen's default namespace based on their app's name
+      @namespace = @name.to_s.camelize
+    end
+
+    def get_lastest_origen_version
+      @latest_origen_version ||= begin
+        (Gems.info 'origen')['version']
+      rescue
+        # If the above fails, e.g. due to an SSL error in the runtime environment, try to fetch the
+        # latest Origen version from the Origen website, before finally falling back to the version
+        # we are currently running if all else fails
+        begin
+          require 'httparty'
+          response = HTTParty.get('http://origen-sdk.org/origen/release_notes/')
+          version = Origen::VersionString.new(response.body.match(/Tag: v(\d+\.\d+.\d+)</).to_a.last)
+          if version.valid?
+            version
+          else
+            fail "Can't get the latest version!"
+          end
+        rescue
+          Origen.version
+        end
+      end
+    end
+
+    protected
+
+    def class_dir(klass)
+      names = klass.to_s.split('::')
+      names.shift
+      names.map(&:underscore).join('/')
+    end
+
+    def class_dirs(klass)
+      names = klass.to_s.split('::')
+      names.shift
+      dirs = []
+      until names.empty?
+        dirs << names.map(&:underscore).join('/')
+        names.pop
+      end
+      dirs
+    end
+
+    # def application_class?(klass)
+    #  until klass == OrigenAppGenerators::Base
+    # end
+
+    def debugger
+      require 'byebug'
+      byebug # rubocop:disable Lint/Debugger
+    end
+
+    def plugin?
+      type == :plugin
+    end
+
+    def application?
+      !plugin?
+    end
+
+    def self.title
+      desc.sub(/^An? /, '').titleize
+    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
+          if file[:copy]
+            if (file.key? :dest) && (file.key? :source)
+              directory(file[:source], file[:dest])
+            else
+              directory(file[:dest] || file[:source])
+            end
+          elsif file[:nokeep]
+            empty_directory(file[:dest] || file[:source])
+          else
+            copy_file('dot_keep', "#{file[:dest]}/.keep")
+          end
+        else
+          dest = file[:dest] || file[:source]
+          if file[:copy] || dest =~ /.erb$/
+            copy_file(file[:source], dest)
+          else
+            @options = file[:options] || {}
+            template(file[:source], dest)
+          end
+        end
+      end
+      symlink_cmds.each { |cmd| system(cmd) }
+    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'
+      [@namespace_advice].each { |l| puts l } if @namespace_advice
+      puts
+      if !proposal && @name
+        proposal = @name.to_s.camelize
+      end
+      proposal = nil if proposal.length < 3
+
+      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."
+      [@name_advice].each { |l| puts l } if @name_advice
+      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/origen_app_generators/lib/origen_app_generators/empty_application.rb

@@ -0,0 +1,15 @@
+module OrigenAppGenerators
+  # Generates a generic application shell
+  class EmptyApplication < 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/origen_app_generators/lib/origen_app_generators/empty_plugin.rb

@@ -0,0 +1,15 @@
+module OrigenAppGenerators
+  # Generates a generic plugin shell
+  class EmptyPlugin < 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

data/origen_app_generators/lib/origen_app_generators/new.rb

@@ -0,0 +1,170 @@
+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
+      @namespace = Origen.app.namespace
+    end
+
+    def set_type
+      # Type not applicable in for this generator
+    end
+
+    def generate_files
+      build_filelist
+    end
+
+    def enable
+      available = Origen.app.namespace.constantize::AVAILABLE
+      test_inputs = Origen.app.namespace.constantize::TEST_INPUTS
+
+      # **** Add require line ****
+      module_declaration = /\nmodule #{Origen.app.namespace}/
+      inject_into_file "#{app_dir}lib/#{Origen.app.name}.rb", "require '#{Origen.app.name}/#{@domain_namespace.underscore}/#{@classname.underscore}'\n",
+                       before: module_declaration
+
+      # **** Add to the AVAILABLE hash ****
+      if available[@domain_summary]
+        existing_domain = /\s*('|")#{@domain_summary}('|") => \[\s*\n/
+        inject_into_file "#{app_dir}lib/#{Origen.app.name}.rb", "      #{Origen.app.namespace}::#{@domain_namespace}::#{@classname},\n",
+                         after: existing_domain
+      else
+        new_domain = <<-END
+    '#{@domain_summary}' => [
+      #{Origen.app.namespace}::#{@domain_namespace}::#{@classname},
+    ],
+        END
+        available_hash = /AVAILABLE = {\s*\n/
+        inject_into_file "#{app_dir}lib/#{Origen.app.name}.rb", new_domain, after: available_hash
+      end
+
+      # **** Add a starter set of test inputs ****
+      # First work out what the selection numbers will be for the new generator
+      if available[@domain_summary]
+        first = available.size - available.find_index { |k, _| k == @domain_summary }
+        second = available[@domain_summary].size
+      else
+        first = available.size + 1
+        second = 0
+      end
+      inputs = "\n    # #{test_inputs.size} - #{@domain_namespace}::#{@classname}\n"
+      if @parentclass == 'Plugin'
+        inputs += "    ['#{first}', '#{second}', :default, :default, 'A cool plugin', 'yes', :default]"
+      else
+        inputs += "    ['#{first}', '#{second}', :default]"
+      end
+      inputs = ",#{inputs}" unless test_inputs.empty?
+      end_of_test_inputs = /\n\s*\]\s*#\s*END_OF_TEST_INPUTS/
+      inject_into_file "#{app_dir}lib/#{Origen.app.name}.rb", inputs, before: end_of_test_inputs
+    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
+      system "origen lint #{Origen.root}/#{app_dir}lib/#{Origen.app.name}.rb"
+      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 app_dir
+      if File.exist?("#{Origen.root}/app/lib")
+        'app/'
+      else
+        ''
+      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?("#{Origen.app.namespace}::#{@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 APPLICATION DOMAIN WILL YOUR NEW APP TEMPLATE APPLY TO?'
+      puts
+      puts "Enter something like 'Test Engineering', 'Design', etc."
+      puts
+      domain = get_text(single: true)
+      domain = domain.split(' ').map do |word|
+        # Ensure all first letters capitalized, but make sure something like
+        # 'NVM' remains 'NVM' and not 'Nvm'
+        letters = word.split('')
+        letters.first.upcase!
+        letters.join
+      end.join(' ')
+
+      @domain_summary = domain
+      @domain_namespace =  @domain_summary.gsub(' ', '')
+    end
+
+    def filelist
+      @filelist ||= {
+        generator:     { source: 'generator.rb',
+                         dest:   "#{app_dir}lib/#{Origen.app.name}/#{@domain_namespace.underscore}/#{@classname.underscore}.rb" },
+        templates_dir: { dest: "#{app_dir}templates/app_generators/#{@domain_namespace.underscore}/#{@classname.underscore}",
+                         type: :directory },
+        # doc_info:      { source: 'info.md.erb',
+        #                 dest:   "#{app_dir}templates/web/#{Origen.app.name}/#{@domain_namespace.underscore}/#{@classname.underscore}.md.erb" }
+      }
+    end
+  end
+end