origen 0.0.1 → 0.0.2

data/lib/origen/application/plugins_manager.rb

@@ -0,0 +1,280 @@
+module Origen
+  class Application
+    class PluginsManager
+      # Returns the temporary plugin instance if set, otherwise nil
+      attr_reader :temporary
+
+      # Returns the current plugin instance, this will be the temporary plugin if set, if
+      # not then the current default plugin if set, otherwise nil
+      def current
+        if @disabled || @set_to_nil
+          nil
+        else
+          temporary || default
+        end
+      end
+      alias_method :instance, :current
+      alias_method :current_plugin_instance, :current
+
+      def disable
+        @disabled = true
+      end
+
+      def enable
+        @disabled = false
+      end
+
+      # Returns the current plugin name, equivalent to calling current.name
+      def name
+        current ? current.name : nil
+      end
+
+      # Sets the given plugin as the temporary current plugin, this will last until
+      # changed or the end of the current Origen thread
+      def temporary=(plugin_name)
+        if !plugin_name || plugin_name.to_sym == :none
+          @set_to_nil = true
+          @temporary = nil
+        else
+          @set_to_nil = false
+          @temporary = find_plugin!(plugin_name)
+        end
+      end
+
+      # Same as temporary= except it will be remembered in the next Origen thread.
+      # Setting this will also clear any temporary assignment that is currently in
+      # effect.
+      def default=(plugin_name)
+        self.temporary = nil
+        if !plugin_name || plugin_name.to_sym == :none
+          @default = nil
+        else
+          @default = find_plugin!(plugin_name)
+          Origen.app.session.origen_core[:default_plugin] = @default.name
+          @default
+        end
+      end
+
+      # Returns the current plugin instance currently set as the default plugin,
+      # otherwise nil
+      def default
+        return @default if @default
+        if name = Origen.app.session.origen_core[:default_plugin]
+          begin
+            @default = find_plugin!(name)
+          rescue
+            # Hit here if what has been set to the default plugin has since been
+            # removed from the application
+            self.default = :none
+            nil
+          end
+        end
+      end
+
+      # Checks the given plugin name with the list of installed plugins
+      # and returns true if found else returns false
+      def valid_plugin_name?(plugin_name)
+        Origen.import_manager.names.include?(plugin_name)
+      end
+
+      # Lists all the plugins available on server
+      def list
+        puts 'The following plugins are available to add to your application:'
+        puts ''
+        Origen.client.plugins.group_by { |p| p[:category] }.sort_by { |k, _v| k }.each do |category, plugins|
+          puts category.upcase
+          puts '=' * category.length
+          plugins.sort_by { |p| p[:name] }.each do |plugin|
+            line =  "#{plugin[:origen_name]}".ljust(25) + plugin[:name].strip.ljust(30)
+            if plugin[:latest_version_prod] || plugin[:latest_version_dev]
+              line += [plugin[:latest_version_prod] || plugin[:latest_version_dev]].compact.join(', ')
+            end
+            puts line
+          end
+          puts ''
+        end
+      end
+
+      # Updates the plugin to the supplied version
+      def update(plugin_name, version)
+        if plugin_name.class != Symbol
+          plugin_name = plugin_name.to_sym
+        end
+        if valid_plugin_name?(plugin_name)
+          update_config_file!(version:     version,
+                              plugin_name: plugin_name,
+                              action:      :update)
+        else
+          puts "Plugin #{plugin_name} not found in this app!"
+        end
+      end
+
+      # Adds the given plugin to the current app
+      def add(plugin_name, version, options)
+        if plugin_name.class != Symbol
+          plugin_name = plugin_name.to_sym
+        end
+        if !valid_plugin_name?(plugin_name)
+          plugin_data = read_plugin_info_from_server(plugin_name)
+          update_config_file!(vault:       plugin_data[:vault],
+                              version:     version,
+                              plugin_name: plugin_name,
+                              action:      :add,
+                              dev_import:  options[:dev_import])
+
+          puts 'Plugin added successfully!'
+        else
+          puts "Plugin #{plugin_name} is already included in this app!"
+        end
+      end
+
+      def remove(plugin_name)
+        if plugin_name.class != Symbol
+          plugin_name = plugin_name.to_sym
+        end
+        if valid_plugin_name?(plugin_name)
+          update_config_file!(plugin_name: plugin_name,
+                              action:      :remove)
+          if File.exist?("#{imports_dir}/#{plugin_name}")
+            FileUtils.rm_rf("#{imports_dir}/#{plugin_name}")
+            puts "Plugin '#{plugin_name}' removed successfully!"
+          end
+        else
+          puts "Plugin #{plugin_name} not found in this app!"
+        end
+      end
+
+      # Lists out the currently added plugins within the app on console
+      def list_added_plugins
+        puts 'The following plugins are included in this app:'
+        format = "%30s\t%30s\t%30s\n"
+        printf(format, 'Origen_Name', 'Name', 'Version')
+        printf(format, '---------', '----', '-------')
+
+        Origen.plugins.each do |plugin|
+          printf(format, plugin.name, plugin.config.name, plugin.version)
+        end
+        puts ''
+      end
+
+      # Describes the plugin
+      def describe(plugin_name)
+        if plugin_name
+          if plugin_name.class != Symbol
+            plugin_name = plugin_name.to_sym
+          end
+          description = nil
+          Origen.client.plugins.each do |plugin|
+            if plugin[:origen_name].to_sym == plugin_name
+              description = <<-EOT
+Origen_Name:    #{plugin[:origen_name]}
+Actual Name:  #{plugin[:name]}
+Category:     #{plugin[:category]}
+Description:  #{plugin[:description]}
+EOT
+              break
+            end
+          end
+          if description.nil?
+            puts "Plugin #{plugin_name} not found or it does not include a description"
+            exit 1
+          end
+          description
+        else
+          puts 'No plugin name provided'
+          exit 1
+        end
+      end
+
+      private
+
+      def find_plugin!(name)
+        plugin = Origen.plugins.find { |p| p.name.to_sym == name.to_sym }
+        return plugin if plugin
+        puts ''
+        puts "No plugin named '#{name}' is included in this application!"
+        puts 'The plugins currently available are:'
+        Origen.plugins.each do |plugin|
+          puts "  #{plugin.name}"
+        end
+        puts ''
+        fail 'Missing plugin error!'
+      end
+
+      def read_plugin_info_from_server(plugin_name)
+        plugin_data = nil
+        Origen.client.plugins.each do |plugin|
+          if plugin[:origen_name].to_sym == plugin_name
+            plugin_data = plugin
+            break
+          end
+        end
+
+        if plugin_data.nil?
+          fail "No plugin with name #{plugin_name} found!"
+        end
+        plugin_data
+      end
+
+      def update_config_file!(options = {})
+        file = "#{Origen.root}/config/application.rb"
+        lines = File.readlines(file)
+        if options[:action] == :add && !valid_plugin_name?(options[:plugin_name])
+          if options[:dev_import]
+            unless lines.find_index { |line| line =~ /config.imports_dev/ }
+              index = lines.find_index { |line| line =~ /config.vault =/ }
+              lines.insert(index + 1, '  config.imports_dev = [', '', '  ]')
+            end
+          else
+            unless lines.find_index { |line| line =~ /config.imports\s=\s/ }
+              index = lines.find_index { |line| line =~ /config.vault =/ }
+              lines.insert(index + 1, '  config.imports = [', '', '  ]')
+            end
+          end
+
+          File.open(file, 'w') do |f|
+            lines.each do |line|
+              f.puts line
+              if line =~ (options[:dev_import] ? (/config.imports_dev\s=\s/) : (/config.imports\s=\s/))
+                f.puts '    {'
+                f.puts "      :vault => \"#{options[:vault]}\","
+                f.puts "      :version => \"#{options[:version]}\","
+                if (options[:dev_import] ? (Origen.config.imports_dev) : (Origen.config.imports)).size == 0
+                  f.puts '    }'
+                else
+                  f.puts '    },'
+                end
+              end
+            end
+          end
+        elsif options[:action] == :remove && valid_plugin_name?(options[:plugin_name])
+          lines.slice!(plugin_index_range(lines, options))
+          File.open(file, 'w') { |f| lines.each { |line| f.puts line } }
+        elsif options[:action] == :update && valid_plugin_name?(options[:plugin_name])
+          range = plugin_index_range(lines, options)
+          version_index = lines[range].find_index { |line| line =~ /:version/ }
+          version_index += range.first
+          lines[version_index] = "      :version => \"#{options[:version]}\","
+          File.open(file, 'w') { |f| lines.each { |line| f.puts line } }
+        end
+        load "#{Origen.root}/config/application.rb"
+        Origen.import_manager.required = false
+        Origen.import_manager.require!
+      end
+
+      def plugin_index_range(file_lines, options)
+        center = file_lines.find_index { |line| line =~ /:vault(.*)(#{options[:plugin_name]})/i }
+        if center
+          first = file_lines[0..center].length - 1 - file_lines[0..center].rindex.find_index { |line| line =~ /^(\s*)({)(\s*)$/ }
+          last = file_lines[center..(file_lines.size - 1)].find_index { |line| line =~ /^\s*}(,?)\s*$/ }
+          last = center + last
+          first..last
+        end
+      end
+
+      def imports_dir
+        Origen.application.workspace_manager.imports_directory
+      end
+    end
+  end
+end

data/lib/origen/application/release.rb

@@ -0,0 +1,359 @@
+require 'colored'
+module Origen
+  class Application
+    # Responsible for co-ordinating application releases
+    class Release
+      include Users
+      include Utility::TimeAndDate
+      include Utility::InputCapture
+
+      def initialize
+        @mailer = Utility::Mailer.new
+      end
+
+      def self.valid_types
+        if Origen.config.semantically_version
+          if Origen.app.version.development?
+            [:development, :production]
+          else
+            [:development, :tiny, :minor, :major]
+          end
+        else
+          [:development, :production]
+        end
+      end
+
+      # Release a new application version
+      def run(options)
+        # Don't want plugin callbacks kicking in during the release process
+        Origen.current_plugin.disable
+        @options = options
+        if authorized?
+          Origen.import_manager.validate_production_status(true)
+          unless Origen.app.rc.local_modifications.empty?
+            puts <<-EOT
+Your workspace has local modifications that are preventing the requested action
+  - run 'origen rc mods' to see them.
+            EOT
+            exit 1
+          end
+          get_release_type unless type
+          validate_branch
+          # For development tags always include the latest updates from everyone else,
+          # for production tag exactly what is in the user's workspace
+          if type == :development && !options[:no_fetch]
+            puts 'Fetching the latest version of all application files...'
+            Origen.app.rc.checkout(force: true)
+          end
+          Origen.app.listeners_for(:validate_release).each(&:validate_release)
+          lint_test
+          get_latest_version_files
+          base_version = Origen.app.version(refresh: true)  # Read in the latest version
+          get_release_note unless note
+          new_version = get_or_confirm_version(type)  # Don't mask this like the above!
+          write_version(new_version)
+          # Refresh the version in the current thread
+          Origen.app.version(refresh: true)
+          if Origen.app.version != new_version
+            fail "Sorry something has gone wrong trying to update the version counter to #{new_version}!"
+          end
+          Origen.app.version_tracker.add_version(Origen.app.version) if Origen.app.version.production?
+          write_history
+          Origen.app.listeners_for(:before_release_tag).each do |listener|
+            listener.before_release_tag(tag, note, type, selector, options)
+          end
+          puts "Tagging workspace, this could take a few minutes, don't interrupt..."
+          Origen.app.rc.checkin("#{version_file} #{history_file} Gemfile.lock", force: true, comment: 'Updated app version and history')
+          workspace_dirs.each do |wdir|
+            Origen.app.rc.tag tag
+          end
+          begin
+            Origen.client.release!
+          rescue
+            # Don't allow any server post errors to kill the release process
+          end
+          release_gem
+          Origen.app.listeners_for(:after_release_tag).each do |listener|
+            listener.after_release_tag(tag, note, type, selector, options)
+          end
+          # @mailer.send_release_notice(tag, note, type, selector) unless options[:silent]
+          Origen.app.listeners_for(:after_release_email).each do |listener|
+            listener.after_release_email(tag, note, type, selector, options)
+          end
+          puts "Successfully released version #{Origen.app.version}!"
+        end
+      end
+
+      protected
+
+      def validate_branch
+        if Origen.app.rc.git?
+          if Origen.app.config.rc_workflow == :gitflow
+            if type == :development && Origen.app.rc.current_branch == 'master'
+              puts "Development releases can only be made on the develop branch, your current branch is: #{Origen.app.rc.current_branch}"
+              exit 1
+            elsif type == :production && Origen.app.rc.current_branch != 'master'
+              puts "Production releases can only be made on the master branch, your current branch is: #{Origen.app.rc.current_branch}"
+              exit 1
+            end
+          else
+            unless Origen.app.rc.current_branch == 'master'
+              puts "With Git you can only release onto the master branch, your current branch is: #{Origen.app.rc.current_branch}"
+              puts
+              puts 'If you want to use a Gitflow workflow you will be able to do development releases on the develop branch, to'
+              puts 'do that set config.rc_workflow = :gitflow in your config/application.rb'
+              puts
+              puts 'Otherwise, for release on a non-standard branch you will need to manage it yourself.'
+              exit 1
+            end
+          end
+        end
+      end
+
+      def release_gem
+        if File.exist?(File.join Origen.root, "#{Origen.app.gem_name}.gemspec")
+          unless system 'rake gem:release'
+            puts '***************************************'.red
+            puts '***************************************'.red
+            puts 'SOMETHING WENT WRONG RELEASING THE GEM!'.red
+            puts '***************************************'.red
+            puts '***************************************'.red
+          end
+        end
+      end
+
+      # Run the lint test and require that it passes if enabled
+      def lint_test
+        if Origen.config.lint_test[:run_on_tag]
+          unless system('origen lint --no-correct')
+            puts ''
+            puts "Can't release due to lint/style errors, fix any errors from running 'origen lint' before trying again"
+            exit 1
+          end
+        end
+      end
+
+      # Sets the current release type
+      def type=(type)
+        type = type.to_s.chomp.downcase.to_sym
+        @type = self.class.valid_types.include?(type) ? type : nil
+      end
+
+      def type
+        @type ||= @options[:type]
+      end
+
+      # Sets the release note, returns nil if invalid
+      def note=(note)
+        if note.to_s =~ /[a-f]|[A-F]/
+          @note = note
+        else
+          @note = nil
+        end
+      end
+
+      def note
+        @note ||= @options[:note]
+      end
+
+      # Returns the selector, formatted as a string
+      def selector
+        "Branch: '#{Origen.app.rc.current_branch}'"
+      end
+
+      def version_file
+        File.join(Origen.root, 'config', 'version.rb')
+      end
+
+      def history_file
+        Origen.config.history_file
+      end
+
+      def workspace_dirs
+        dirs = ["#{Origen.root}"]
+        Origen.app.config.external_app_dirs.each do |edir|
+          dirs << edir
+        end
+        dirs
+      end
+
+      # Pull the latest versions of the history and version ID files into the workspace
+      def get_latest_version_files
+        # Get the latest version of the version and history files
+        if Origen.app.rc.dssc?
+          # Legacy code that makes use of the fact that DesignSync can handle different branch selectors
+          # for individual files, this capability has not been abstracted by the newer object oriented
+          # revision controllers since most others cannot do it
+          system "dssc co -get -force \"#{history_file};Trunk:Latest\" #{version_file}"
+          # Force the history selector to Trunk, only 1 branch of this file should ever exist
+          system "dssc setselector Trunk #{history_file}"
+          # Make sure both are writable
+          if Origen.running_on_windows?
+            `attrib -R #{history_file.gsub('/', '\\')} #{version_file.gsub('/', '\\')}`
+          else
+            `chmod 666 #{history_file} #{version_file}`
+          end
+        else
+          Origen.app.rc.checkout "#{history_file} #{version_file}", force: true
+        end
+      end
+
+      # Prompts the user to enter a release note
+      def get_release_note
+        puts ''
+        if @options[:note_file]
+          f = Origen.file_handler.clean_path_to(@options[:note_file])
+        else
+          f = "#{Origen.root}/release_note.txt"
+        end
+        if File.exist?(f)
+          lines = File.readlines(f)
+          puts 'HAPPY TO USE THIS RELEASE NOTE?:'
+          puts '------------------------------------------------------------------------------------------'
+          lines.each { |l| puts l }
+          puts '------------------------------------------------------------------------------------------'
+          if get_text(confirm: :return_boolean)
+            self.note = lines.join('')
+            return if note
+          end
+        end
+        puts 'RELEASE NOTE:'
+        self.note = get_text
+        unless note
+          puts 'Sorry but you must supply at least a minor description for this release!'
+          get_release_note
+        end
+      end
+
+      # Prompts the user to enter a release type
+      def get_release_type
+        puts ''
+        puts "RELEASE TYPE (#{self.class.valid_types.join(', ')}):"
+        self.type = get_text(default: self.class.valid_types.first, single: true)
+        unless type
+          puts 'Sorry but that release type is not valid!'
+          get_release_type
+        end
+      end
+
+      # Prompts the user to confirm the proposed version or enter a different one
+      def get_or_confirm_version(type)
+        proposed = nil
+        until version_unique?(proposed)
+          proposed ||= Origen.app.version
+          if type == :development
+            proposed = proposed.next_dev
+          else
+            proposed = proposed.next_prod(type)
+          end
+        end
+        if Origen.config.semantically_version
+          puts
+          puts 'HAPPY TO RELEASE THIS VERSION?:'
+          unless get_text(default: proposed, confirm: :return_boolean)
+            valid = false
+            puts
+            until valid
+              puts
+              puts 'ENTER THE VERSION NUMBER YOU WOULD LIKE TO USE INSTEAD:'
+              proposed = Origen::VersionString.new(get_text(single: true).strip)
+              valid = proposed.semantic?
+              unless valid
+                puts 'SORRY BUT THAT IS NOT A VALID VERSION NUMBER'
+              end
+            end
+          end
+        else
+          valid = false
+          until valid
+            puts
+            puts 'RELEASE TAG:'
+            proposed = Origen::VersionString.new(get_text(default: proposed, single: true).strip)
+            valid = proposed.timestamp?
+            unless valid
+              puts 'SORRY BUT THAT IS NOT A VALID VERSION NUMBER'
+            end
+          end
+        end
+        proposed
+      end
+
+      def version_unique?(version)
+        if version
+          if version.semantic?
+            if Origen.app.rc.git?
+              !Origen.app.rc.tag_exists?(version.prefixed)
+            else
+              # Don't worry about dssc, since a single branch is used for the version it will
+              # always be unique
+              true
+            end
+          else
+            true
+          end
+        end
+      end
+
+      # For now apply a leading 'v' to keep design sync happy, will make this CM type
+      # specific in future
+      def tag
+        tag = Origen.app.version
+        if tag =~ /^\d/
+          "v#{tag}"
+        else
+          tag
+        end
+      end
+
+      # Write out details of the given version to the history file
+      def write_history
+        text = File.read(history_file)           # Read the existing contents
+        File.open(history_file, 'w') do |file|   # Write them back, substituting the version number as required
+          if Origen.app.version.production?
+            file.puts "<a class=\"anchor release_tag\" name=\"#{tag.gsub('.', '_')}\"></a>"
+            file.puts "<h1><a href=\"##{tag.gsub('.', '_')}\">Tag: #{tag}</a></h1>"
+            file.puts ''
+            file.puts "##### #{selector}".escape_underscores
+            file.puts ''
+            file.puts "##### by #{User.current.name} on #{time_now}"
+            file.puts ''
+          else
+            file.puts "<a class=\"anchor release_tag\" name=\"#{tag.gsub('.', '_')}\"></a>"
+            file.puts "<h2><a href=\"##{tag.gsub('.', '_')}\">Tag: #{tag}</a></h2>"
+            file.puts ''
+            file.puts "##### #{selector}".escape_underscores
+            file.puts ''
+            file.puts "##### by #{User.current.name} on #{time_now}"
+            file.puts ''
+          end
+          file.puts ''
+          file.puts note.escape_underscores
+          file.puts ''
+          file.puts text
+        end
+      end
+
+      # Sets the version number in the file store
+      def write_version(version)
+        if version.semantic?
+          Origen::CodeGenerators.invoke 'semver', [], config: { change: version }
+        else
+          Origen::CodeGenerators.invoke 'timever', [], config: { change: version }
+        end
+        system 'origen -v' # Invoke Origen under the new version, this updates Gemfile.lock
+      end
+
+      # Only allows admins to release
+      def authorized?
+        # Not sure yet if this concept can work in the open source world...
+        true
+        # if User.current.admin?
+        #  true
+        # else
+        #  puts "Sorry but you can't run the release script, please contact a development team member"
+        #  false
+        # end
+      end
+    end
+  end
+end