origen 0.0.1 → 0.0.2

data/lib/origen/revision_control/base.rb

@@ -0,0 +1,257 @@
+require 'open3'
+module Origen
+  module RevisionControl
+    # Base class of all revision control system drivers,
+    # all drivers should support the API methods defined here.
+    #
+    # Each instance of this class represents the concept of mapping a local directory to
+    # a remote repository.
+    #
+    # Origen.app.rc will return an instance of this class for the revision control system used
+    # by the current application, the :local attribute will be automatically set to
+    # Origen.root and the :remote attribute will be set per the revision control attributes
+    # defined in config/application.rb.
+    class Base
+      # Returns a pointer to the remote location (a Pathname object)
+      attr_reader :remote
+      # Returns a pointer to the local location (a Pathname object)
+      attr_reader :local
+
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # All revision control instances represent a remote server mapping
+      # to a local directory, :remote and :local options are required
+      def initialize(options = {})
+        unless options[:remote] && options[:local]
+          fail ':remote and :local options must be supplied when instantiating a new RevisionControl object'
+        end
+        @remote = Pathname.new(options[:remote])
+        @local = Pathname.new(options[:local]).expand_path
+        initialize_local_dir
+      end
+
+      # Build the local workspace for the first time.
+      #
+      # This is roughly equivalent to running the checkout command, but should be used in the case where
+      # the local workspace is being setup for the first time.
+      def build(options = {})
+        fail "The #{self.class} driver does not support the build method!"
+      end
+
+      # Checkout the given file or directory, it returns a path to the local file.
+      #
+      # The path argument is optional and when not supplied the entire directory will be checked out.
+      #
+      # @param [String, Pathname] path
+      #   The path to the remote item to checkout, this can be a pointer to a file or directory
+      #   and it can either be a relative path or absolute path to either the local or remote locations.
+      #   Multiple values can be supplied and should be separated by a space.
+      # @param [Hash] options Options to customize the operation
+      # @option options [Boolean] :force (false) Force overwrite of any existing local copy
+      # @option options [String] :version (nil) A specific version to checkout, will get latest if
+      #   not supplied
+      # @option options [Boolean] :verbose (true) When true will show the command being executed and
+      #   the raw output from the underlying revision control tool. When false will show nothing, but
+      #   will still raise an error if the underlying command fails.
+      def checkout(path = nil, options = {})
+        fail "The #{self.class} driver does not support the checkout method!"
+      end
+
+      # Checkin the given file or directory, it returns a path to the local file.
+      #
+      # The path argument is optional and when not supplied the entire directory will be checked in.
+      #
+      # @param [String, Pathname] path
+      #   The path to the remote item to checkout, this can be a pointer to a file or directory
+      #   and it can either be a relative path or absolute path to either the local or remote locations.
+      #   Multiple values can be supplied and should be separated by a space.
+      # @param [Hash] options Options to customize the operation
+      # @option options [Boolean] :force (false) Force overwrite of any newer version of the file that may
+      #   exist, i.e. force checkin the current version to become the latest.
+      # @option options [Boolean] :unmanaged (false) Include files matching the given path that are not currently
+      #   managed by the revision control system.
+      # @option options [Boolean] :comment (nil) Optionally supply a checkin comment.
+      # @option options [Boolean] :verbose (true) When true will show the command being executed and
+      #   the raw output from the underlying revision control tool. When false will show nothing, but
+      #   will still raise an error if the underlying command fails.
+      def checkin(path = nil, options = {})
+        fail "The #{self.class} driver does not support the checkin method!"
+      end
+
+      # Returns a hash containing the list of files that have changes compared to the given tag
+      # or compared to the latest version (on the server).
+      #
+      #   {
+      #     :added => [],           # Paths to files that have been added since the previous tag
+      #     :removed => [],         # Paths to files that have been removed since the previous tag
+      #     :changed => [],         # Paths to files that have changed since the previous tag
+      #     :present => true/false, # Convenience attribute for the caller to check if there are any changes, when
+      #                             # true at least one of the other arrays will contain a value
+      #   }
+      #
+      # The dir argument is optional and when not supplied the entire directory will be checked for
+      # changes.
+      #
+      # Note that added files only refers to those files which have been checked into revision control
+      # since the compared to version, it does not refer to unmanaged files in the workspace.
+      # Use the unmanaged method to get a list of those.
+      #
+      # Note also that while a file is considered added or removed depends on the chronological
+      # relationship between the current version (the user's workspace) and the reference version.
+      # If the reference version is older than the current version (i.e. an earlier tag), then an added
+      # file means a file that the current version has and the reference (previous) version did not have.
+      #
+      # However if the reference version is newer than the current version (e.g. when comparing to a newer
+      # tag or the latest version on the server), then an added file means a file that the current
+      # version does not have and which has been added in a newer version of the remote directory.
+      #
+      # @param [String, Pathname] dir
+      #   The path to a sub-directory to check for changes, it can either be a relative path or an
+      #   absolute path to either the local or remote locations.
+      # @param [Hash] options Options to customize the operation
+      # @option options [String] :version (nil) A specific version to compare against, will compare to
+      #   latest if not supplied
+      # @option options [Boolean] :verbose (false) When true will show the command being executed and
+      #   the raw output from the underlying revision control tool. When false will show nothing. False
+      #   is the default as with this command the user is more concerned with seeing the organized
+      #   summary that is returned from this method.
+      def changes(dir = nil, options = {})
+        fail "The #{self.class} driver does not support the changes method!"
+      end
+
+      # Returns an array containing the files that have un-committed local changes.
+      #
+      # The dir argument is optional and when not supplied the entire directory will be checked for
+      # changes.
+      #
+      # @param [String, Pathname] dir
+      #   The path to a sub-directory to check for changes, it can either be a relative path or an
+      #   absolute path to either the local or remote locations.
+      # @param [Hash] options Options to customize the operation
+      # @option options [Boolean] :verbose (false) When true will show the command being executed and
+      #   the raw output from the underlying revision control tool. When false will show nothing. False
+      #   is the default as with this command the user is more concerned with seeing the organized
+      #   summary that is returned from this method.
+      def local_modifications(dir = nil, options = {})
+        fail "The #{self.class} driver does not support the local_modifications method!"
+      end
+
+      # Returns an array containing the list of files that are present in the given directory but
+      # which are not managed by the revision control system.
+      #
+      # The dir argument is optional and when not supplied the entire directory will be checked for
+      # unmanaged files.
+      #
+      # @param [String, Pathname] dir
+      #   The path to a sub-directory to check for unmanaged files, it can either be a relative path or an
+      #   absolute path to either the local or remote locations.
+      # @param [Hash] options Options to customize the operation
+      # @option options [Boolean] :verbose (false) When true will show the command being executed and
+      #   the raw output from the underlying revision control tool. When false will show nothing. False
+      #   is the default as with this command the user is more concerned with seeing the organized
+      #   summary that is returned from this method.
+      def unmanaged(dir = nil, options = {})
+        fail "The #{self.class} driver does not support the unmanaged method!"
+      end
+
+      # Returns the command the user must run to execute a diff of the current version of the given file
+      # against the given version of it.
+      #
+      # @param [String, Pathname] file
+      #   The local path to the file to be compared.
+      # @param [String] version
+      #   The version of the file to compare to.
+      def diff_cmd(file, version)
+        fail "The #{self.class} driver does not support the diff_cmd method!"
+      end
+
+      # Returns what is considered to be the top-level root directory by the revision control system.
+      #
+      # In the case of an application's revision controller (returned by Origen.app.rc) this method will often
+      # return the same directory as Origen.root. However in some cases an application owner may choose to store
+      # their application in a sub directory of a larger project entity that is revision controlled. In that
+      # case Origen.root will return the sub directory and this method will return the top-level directory
+      # of the wider project.
+      def root
+        fail "The #{self.class} driver does not support the root method!"
+      end
+
+      # Returns the name of the current branch in the local workspace
+      def current_branch
+        fail "The #{self.class} driver does not support the current_branch method!"
+      end
+
+      # Returns true if the revision controller object uses Design Sync
+      def dssc?
+        is_a?(DesignSync)
+      end
+      alias_method :design_sync?, :dssc?
+
+      # Returns true if the revision controller object uses Git
+      def git?
+        is_a?(Git) # :-)
+      end
+
+      # Returns true if the revision controller object uses Subversion
+      def svn?
+        is_a?(Subversion) # :-)
+      end
+      alias_method :subversion?, :svn?
+
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      private
+
+      def clean_path(path = nil, options = {})
+        path, options = nil, path if path.is_a?(Hash)
+        if path
+          paths = to_local(path)
+        else
+          paths = [local.to_s]
+        end
+        [paths, options]
+      end
+
+      # Converts a given path string to files/directories to an array of absolute paths to the
+      # resources within the local directory.
+      # The input can either contain a path to the local directory, or the remote.
+      #
+      # @example
+      #   to_local("config/application.rb sync://sync-15088:15088/Projects/common_tester_blocks/origen/lib")
+      #     # => ["/home/r49409/origen/config/application.rb", "/home/r49409/origen/lib"]
+      def to_local(path)
+        local_abs_paths = []
+        path.to_s.split(/\s+/).each do |p|
+          if p =~ /^#{remote}/
+            p.sub!(/^#{remote}/, '')
+            p.slice!(0) if p =~ /^\//
+            p = "#{local}/#{p}"
+          else
+            if Pathname.new(p).absolute?
+              # No action required
+            else
+              p = "#{local}/#{p}"
+            end
+          end
+          local_abs_paths << p
+        end
+        local_abs_paths
+      end
+
+      # If the supplied tag looks like a semantic version number, then make sure it has the
+      # 'v' prefix
+      def prefix_tag(tag)
+        tag = Origen::VersionString.new(tag)
+        if tag.semantic?
+          tag.prefixed
+        else
+          tag
+        end
+      end
+
+      def initialize_local_dir
+        FileUtils.mkdir_p(local.to_s) unless local.exist?
+      end
+    end
+  end
+end

data/lib/origen/revision_control/design_sync.rb

@@ -0,0 +1,276 @@
+module Origen
+  module RevisionControl
+    class DesignSync < Base
+      # Check in the contents of the given directory to a remote vault location, meaning a vault location
+      # that is not necessarily associated with the current workspace that the given files are in.
+      #
+      # Anything found in the given directory will be checked in, even files which are not currently under
+      # revision control.
+      #
+      # No attempt will be made to merge the current vault contents with the local data, the local data
+      # will always be checked in as latest.
+      #
+      # A tag can be optionally supplied and if present will be applied to the files post check in.
+      #
+      # @example
+      #
+      #   Origen::RevisionControl::DesignSync.remote_check_in("#{Origen.root}/output/j750", vault: "sync://sync-15088:15088/Projects/common_tester_blocks/origen_training/j750", tag: Origen.app.version)
+      def self.remote_check_in(dir, options = {})
+        options = {
+          force: true
+        }.merge(options)
+
+        dir = Pathname.new(dir)
+        fail "Directory does not exist: #{dir}" unless dir.exist?
+        fail "Only directories are supported by remote_check_in, this is not a directory: #{dir}" unless dir.directory?
+        fail 'No vault option supplied to remote_check_in!' unless options[:vault]
+        scratch = Pathname.new("#{Origen.app.workspace_manager.imports_directory}/design_sync/scratch")
+        FileUtils.rm_rf(scratch) if scratch.exist?
+        FileUtils.mkdir_p(scratch)
+        FileUtils.cp_r("#{dir}/.", scratch)
+        remove_dot_syncs!(scratch)
+        ds = new(remote: options[:vault], local: scratch)
+        ds.checkin(options)
+        ds.tag(options[:tag], options) if options[:tag]
+        FileUtils.rm_rf(scratch)
+      end
+
+      # Recursively remove all .SYNC directories from the given directory
+      def self.remove_dot_syncs!(dir, options = {})
+        dir = Pathname.new(dir)
+        fail "Directory does not exist: #{dir}" unless dir.exist?
+        fail "Only directories are supported by remove_dot_syncs, this is not a directory: #{dir}" unless dir.directory?
+        Dir.glob("#{dir}/**/.SYNC").sort.each do |dot_sync|
+          FileUtils.rm_rf(dot_sync)
+        end
+      end
+
+      def build
+        checkout
+      end
+
+      def checkout(path = nil, options = {})
+        paths, options = clean_path(path, options)
+        cmd = 'pop'
+        cmd += ' -rec -get -uni'
+        cmd += ' -force' if options[:force]
+        if options[:version]
+          cmd += " -version #{prefix_tag(options[:version])}"
+        else
+          cmd += ' -merge' unless options[:force]
+        end
+        paths = paths.join(' ')
+        dssc("#{cmd} #{paths}", options)
+        # Design sync can be funny and even with -get it can leave unwritable files, so let's fix that
+        `chmod a+w -R #{paths}`
+        paths
+      end
+
+      def checkin(path = nil, options = {})
+        paths, options = clean_path(path, options)
+        cmd = 'ci'
+        cmd += ' -rec -keep'
+        cmd += ' -skip' if options[:force]
+        cmd += ' -new' if options[:unmanaged] || options[:force]
+        if options[:comment] && !options[:comment].strip.empty?
+          cmd += " -com \"#{options[:comment].strip}\""
+        else
+          # cmd += ' -nocom' # DO NOT USE nocom option with DesignSync, doesn't always work
+          cmd += ' -com None'
+        end
+        paths = paths.join(' ')
+        dssc("#{cmd} #{paths}", options)
+        # Make sure the file is still writable
+        `chmod a+w -R #{paths}`
+        paths
+      end
+
+      def changes(dir = nil, options = {})
+        paths, options = clean_path(dir, options)
+        options = {
+          verbose: false
+        }.merge(options)
+
+        cmd = 'compare -rec -path -report silent'
+        if options[:version]
+          cmd += " -selector #{prefix_tag(options[:version])}"
+        end
+        cmd += " #{paths.first}"
+
+        objects = {
+          added: [], removed: [], changed: []
+        }
+        dssc(cmd, options).each do |line|
+          # We need to parse the following data from the output, ignore everything else
+          # which will mostly refer to un-managed files.
+          #
+          # Added since previous version...
+          # 1.12                                          First only         source_setup
+          # Removed since previous version...
+          #                        1.13                   Second only        lib/history
+          # Modified since previous version...
+          # 1.32                   1.31                   Different versions lib/origen/application.rb
+          # Modified since previous version including a local edit...
+          # 1.7 (Locally Modified) 1.7                    Different states   lib/origen/commands/rc.rb
+          unless line =~ /Unmanaged/
+            # http://www.rubular.com/r/GoNYB75upB
+            if line =~ /\s*(\S+)\s+First only\s+(\S+)\s*/
+              objects[:added] << Regexp.last_match[2]
+            # http://www.rubular.com/r/Xvh32Lm4hS
+            elsif line =~ /\s*(\S+)\s+Second only\s+(\S+)\s*/
+              objects[:removed] << Regexp.last_match[2]
+            # http://www.rubular.com/r/tvTHod9Mye
+            elsif line =~ /\s*\S+\s+(\(Locally Modified\))?\s*(\S+)\s+Different (versions|states)\s+(\S+)\s*/
+              objects[:changed] << Regexp.last_match[4]
+            end
+          end
+        end
+        objects[:present] = !objects[:added].empty? || !objects[:removed].empty? || !objects[:changed].empty?
+        objects[:added].map! { |i| "#{paths.first}/" + i }
+        objects[:removed].map! { |i| "#{paths.first}/" + i }
+        objects[:changed].map! { |i| "#{paths.first}/" + i }
+        objects
+      end
+
+      def local_modifications(dir = nil, options = {})
+        paths, options = clean_path(dir, options)
+        options = {
+          verbose: false
+        }.merge(options)
+
+        cmd = 'ls -rec -managed -path -report N -modified -format text'
+        cmd += " #{paths.first}"
+
+        files = dssc(cmd, options).reject do |item|
+          item.strip.empty? ||
+          item =~ /^(Name|Directory|---)/
+        end
+        files.map! do |file|
+          file.strip!  # Strip off any whitespace from all objects
+          file.sub!(/^#{full_path_prefix}/, '')
+          file.sub('|', ':')
+          file.sub!(/^/, "#{paths.first}/")
+        end
+      end
+
+      def unmanaged(dir = nil, options = {})
+        paths, options = clean_path(dir, options)
+        options = {
+          verbose: false
+        }.merge(options)
+        cmd = 'ls -rec -unmanaged -fullpath -report N -modified -format text'
+        cmd += " #{paths.first}"
+        files = dssc(cmd, options).reject do |item|
+          # removes extraneous lines
+          item =~ /^(Name|Directory|---)/ || item.strip.empty?
+        end
+        files.map! do |file|
+          file.strip!  # Strip off any whitespace from all objects
+          file.sub!(/^#{full_path_prefix}/, '')
+          file.sub('|', ':')
+        end
+      end
+
+      def diff_cmd(file, version)
+        "dssc diff -gui -ver #{prefix_tag(version)} #{file}"
+      end
+
+      def tag(id, options = {})
+        id = VersionString.new(id)
+        id = id.prefixed if id.semantic?
+        replace = options[:force] ? '-replace' : ''
+        dssc "tag #{id} -rec #{replace} *"
+        # Applying this rule recursively seems to cause havoc, so running on its own.
+        # This hits any dot files in the root directory, any dot files in sub directories
+        # already get hit by the above tag job.
+        dssc "tag #{id} #{replace} .*"
+      end
+
+      def root
+        # This is an expensive operation the way it is currently implemented, so
+        # cache the result for future calls
+        Origen.app.session.dssc["root-#{local}"] ||= begin
+          root = local
+          resolved = false
+          vault = dssc("url vault #{root}").first
+          until resolved || root.root?
+            parent = root.parent
+            if File.exist?("#{parent}/.SYNC")
+              parent_vault = dssc("url vault #{parent}").first
+              if vault.to_s =~ /^#{parent_vault}/
+                root = parent
+              else
+                resolved = true
+              end
+            else
+              resolved = true
+            end
+          end
+          root
+        end
+      end
+
+      def current_branch
+        dssc("url selector #{local}", verbose: false).first
+      end
+
+      private
+
+      def full_path_prefix
+        @full_path_prefix ||= begin
+          if Origen.running_on_windows?
+            'file:///'
+          else
+            'file://'
+          end
+        end
+      end
+
+      def initialize_local_dir
+        super
+        unless initialized?
+          Origen.log.debug "Initializing DSSC workspace at #{local}"
+          dssc "setvault #{remote} ."
+        end
+      end
+
+      def initialized?
+        File.exist?("#{local}/.SYNC")
+      end
+
+      # Execute a dssc operation, the resultant output is returned in an array
+      def dssc(command, options = {})
+        options = {
+          check_errors: true,
+          verbose:      true
+        }.merge(options)
+        output = []
+        if options[:verbose]
+          Origen.log.info "dssc #{command}"
+          Origen.log.info ''
+        end
+        Dir.chdir local do
+          Open3.popen2e("dssc #{command}") do |_stdin, stdout_err, wait_thr|
+            while line = stdout_err.gets
+              Origen.log.info line.strip if options[:verbose]
+              # Screen out common redundant output
+              unless line =~ /^Logging/ || line == '' ||
+                     line =~ /V(\d+\.\d+-\d+|\d.\d+)/ || # Screen out something like "V5.1-1205" or "V6R2010"
+                     line.strip.empty?
+                output << line.strip
+              end
+            end
+
+            exit_status = wait_thr.value
+            unless exit_status.success?
+              if options[:check_errors]
+                fail DesignSyncError, "This command failed: 'dssc #{command}'"
+              end
+            end
+          end
+        end
+        output
+      end
+    end
+  end
+end