origen 0.0.1 → 0.0.2

data/lib/origen/version_checker.rb

@@ -0,0 +1,117 @@
+require 'readline'
+module Origen
+  class VersionChecker
+    include Origen::Utility::InputCapture
+
+    def initialize(_options = {})
+      @disable_origen_version_check = false
+    end
+
+    # Check that the required origen version dependency is satisfied, or else
+    # update to it.
+    #
+    # This method will be disabled if version_check_disabled? returns true.
+    def check!
+      unless version_check_disabled?
+        if Origen.config.required_origen_version
+          if Origen.config.required_origen_version != Origen.version
+            update_origen(Origen.config.required_origen_version)
+          end
+        else
+          if Origen.config.min_required_origen_version
+            if Origen.version.less_than?(Origen.config.min_required_origen_version) ||
+               Origen.version.greater_than?(Origen.config.max_required_origen_version)
+              update_origen(Origen.config.min_required_origen_version)
+            end
+          elsif Origen.config.max_required_origen_version
+            fail "You can't specify a max_required_origen_version without providing a min_required_origen_version"
+          end
+        end
+      end
+    end
+
+    # Returns true if the given condition is satisfied by the current Origen
+    # version, examples of valid conditions are:
+    #
+    #   "v2.1.0"
+    #   "v2.1.0.dev10"
+    #   "> v2.1.0.dev10"
+    #   ">= v2.1.0.dev10"
+    def condition_satisfied?(condition, _options = {})
+      Origen.version.condition_met?(condition)
+    end
+
+    # Disable all Origen version checks called from within the given block.
+    # By default this will apply only to the current process, if :all_processes is
+    # supplied and set to true then this will also apply to any additional
+    # process threads started within the block.
+    def with_disable_origen_version_check(options = {})
+      if options[:all_processes]
+        system "touch #{Origen.root}/.disable_origen_version_check"
+      end
+      @disable_origen_version_check = true
+      begin
+        yield
+      ensure
+        if options[:all_processes]
+          system "rm -f #{Origen.root}/.disable_origen_version_check"
+        end
+        @disable_origen_version_check = false
+      end
+    end
+    alias_method :disable_origen_version_check, :with_disable_origen_version_check
+
+    # Returns true if version checking has been disabled or turned off
+    # for a particular workspace.
+    # Generally these are not things that an application can or should do, and are
+    # more features to allow Origen to internally handle multi-application scenarios.
+    def version_check_disabled?
+      @disable_origen_version_check ||
+        File.exist?("#{Origen.root}/.disable_origen_version_check")
+    end
+
+    # Check that the required origen version dependency is satisfied, or else
+    # update to it.
+    def update_origen(version, _options = {})
+      puts ''
+      puts 'Your Origen version needs to be changed, would you like this to be corrected automatically?'
+      puts ''
+      get_text(confirm: true, default: 'yes')
+
+      ds = Origen::Utility::DesignSync.new
+      mods = ds.modified_objects(Origen.top, rec: true, refresh: true)
+      unless mods.empty?
+
+        mods.map! do |local_path|
+          p = Pathname.new("#{Origen.top}/#{local_path}")
+          p.relative_path_from(Pathname.pwd)
+        end
+
+        puts 'Sorry but your environment has the following edits to Origen that are preventing automatic update:'
+        puts ''
+        mods.each do |file|
+          puts '  ' + Origen.app.cm.diff_cmd + ' ' + file.to_s
+        end
+        puts ''
+
+        abort <<-end_message
+      If you don't care about these edits you can force un update now by running the following comand:
+
+        dssc pop -rec -uni -force -ver #{version} #{Origen.top}
+
+        end_message
+
+      end
+
+      ds.populate(Origen.top, version: version, rec: true, force: true,
+                            unify: true, verbose: true, exclude: '.ref,.firmware',
+                            incremental: true)
+
+      puts ''
+      puts 'Origen has been updated, please re-run your previous command.'
+      puts ''
+
+      exit 0
+    end
+  end
+end

data/lib/origen/version_string.rb

@@ -0,0 +1,356 @@
+module Origen
+  class VersionString < String
+    include Utility::TimeAndDate
+    require 'date'
+
+    # Returns a new production timestamp version string
+    def self.production_timestamp
+      VersionString.new("Rel#{time_now(format: :universal, include_time: false)}")
+    end
+
+    # Returns a new development timestamp version string
+    def self.development_timestamp
+      VersionString.new("#{User.current.initials}_#{time_now(format: :universal, underscore: true)}")
+    end
+
+    # Returns true if the version is a production tag
+    def production?
+      !!(self =~ /^v?\d+\.\d+\.\d+$/ || self =~ /^Rel\d+$/)
+    end
+
+    # Returns true if the version is a development tag
+    def development?
+      !production?
+    end
+
+    def less_than?(version)
+      condition_met?("< #{version}")
+    end
+    alias_method :lt?, :less_than?
+
+    def less_than_or_equal_to?(version)
+      condition_met?("<= #{version}")
+    end
+    alias_method :lte?, :less_than_or_equal_to?
+
+    def greater_than?(version)
+      condition_met?("> #{version}")
+    end
+    alias_method :gt?, :greater_than?
+
+    def greater_than_or_equal_to?(version)
+      condition_met?(">= #{version}")
+    end
+    alias_method :gte?, :greater_than_or_equal_to?
+
+    # Returns true if the version is a correctly formatted semantic
+    # or timestamp version number
+    def valid?(_options = {})
+      latest? || semantic? || timestamp?
+    end
+
+    # Returns true if the version is a semantic format version number
+    def semantic?
+      !!(self =~ /^v?\d+\.\d+\.\d+$/ ||
+         self =~ /^v?\d+\.\d+\.\d+\.(dev|pre)\d+$/
+        )
+    end
+
+    def next_dev(type = :minor)
+      if semantic?
+        if pre
+          if self =~ /dev/
+            VersionString.new("#{major}.#{minor + 1}.0.pre#{pre + 1}")
+          else
+            VersionString.new("#{major}.#{minor}.#{tiny}.pre#{pre + 1}")
+          end
+        else
+          case type
+          when :major
+            VersionString.new("#{major + 1}.0.0.pre0")
+          when :minor, :development
+            VersionString.new("#{major}.#{minor + 1}.0.pre0")
+          when :tiny, :bugfix
+            VersionString.new("#{major}.#{minor}.#{tiny + 1}.pre0")
+          else
+            fail "Unknown version counter type '#{type}', must be :major, :minor or :tiny"
+          end
+        end
+      else
+        VersionString.new("#{User.current.initials}_#{time_now(format: :universal, underscore: true)}")
+      end
+    end
+
+    def next_prod(type = :minor)
+      if semantic?
+        if pre
+          if self =~ /dev/
+            case type
+            when :major
+              VersionString.new("#{major + 1}.0.0")
+            when :minor, :production
+              VersionString.new("#{major}.#{minor + 1}.0")
+            when :tiny, :bugfix
+              VersionString.new("#{major}.#{minor}.#{tiny + 1}")
+            else
+              fail "Unknown version counter type '#{type}', must be :major, :minor or :tiny"
+            end
+          else
+            VersionString.new("#{major}.#{minor}.#{tiny}")
+          end
+        else
+          case type
+          when :major
+            VersionString.new("#{major + 1}.0.0")
+          when :minor, :production
+            VersionString.new("#{major}.#{minor + 1}.0")
+          when :tiny, :bugfix
+            VersionString.new("#{major}.#{minor}.#{tiny + 1}")
+          else
+            fail "Unknown version counter type '#{type}', must be :major, :minor or :tiny"
+          end
+        end
+      else
+        VersionString.new("Rel#{time_now(format: :universal, include_time: false)}")
+      end
+    end
+
+    def major
+      @major ||= begin
+        if semantic?
+          self =~ /v?(\d+)/
+          Regexp.last_match[1].to_i
+        else
+          fail "#{self} is not a valid semantic version number!"
+        end
+      end
+    end
+
+    def minor
+      @minor ||= begin
+        if semantic?
+          self =~ /v?\d+.(\d+)/
+          Regexp.last_match[1].to_i
+        else
+          fail "#{self} is not a valid semantic version number!"
+        end
+      end
+    end
+
+    def bugfix
+      @bugfix ||= begin
+        if semantic?
+          self =~ /v?\d+.\d+.(\d+)/
+          Regexp.last_match[1].to_i
+        else
+          fail "#{self} is not a valid semantic version number!"
+        end
+      end
+    end
+    alias_method :tiny, :bugfix
+
+    def pre
+      @pre ||= begin
+        if semantic?
+          if self =~ /(dev|pre)(\d+)$/
+            Regexp.last_match[2].to_i
+          end
+        else
+          fail "#{self} is not a valid semantic version number!"
+        end
+      end
+    end
+    alias_method :dev, :pre
+
+    def latest?
+      downcase == 'trunk' || downcase == 'latest'
+    end
+
+    # Returns true if the version is a timestamp format version number
+    def timestamp?
+      !!(self =~ /^Rel\d\d\d\d\d\d\d\d$/ ||
+         self =~ /^\w\w\w?_\d\d\d\d_\d\d_\d\d_\d\d_\d\d$/)
+    end
+
+    # Returns true if the version fulfills the supplied condition.
+    # Example conditions:
+    #
+    #   "v2.1.3"      # must equal the given version
+    #   "= v2.1.3"    # alias for the above
+    #   "> v2.1.3"    # must be greater than the given version
+    #   ">= v2.1.3"   # must be greater than or equal to the given version
+    #   "< v2.1.3"    # must be less than the given version
+    #   "<= v2.1.3"   # must be less than or equal to the given version
+    #   "production"  # must be a production tag
+    def condition_met?(condition)
+      condition = condition.to_s.strip
+      if condition == 'prod' || condition == 'production'
+        production?
+
+      elsif condition =~ /^>=\s*(.*)/
+        tag = validate_condition!(condition, Regexp.last_match[1])
+        # Force false in the case where a production and development
+        # timestamp fall on the same date. Since the production tag
+        # does not contain time information it is impossible to say
+        # which one is greater
+        if production? != tag.production? && timestamp? &&
+           to_date == tag.to_date
+          false
+        else
+          numeric >= tag.numeric && ((self.latest? || tag.latest?) || self.timestamp? == tag.timestamp?)
+        end
+
+      elsif condition =~ /^>\s*(.*)/
+        tag = validate_condition!(condition, Regexp.last_match[1])
+        if production? != tag.production? && timestamp? &&
+           to_date == tag.to_date
+          false
+        else
+          numeric > tag.numeric && ((self.latest? || tag.latest?) || self.timestamp? == tag.timestamp?)
+        end
+
+      elsif condition =~ /^<=\s*(.*)/
+        tag = validate_condition!(condition, Regexp.last_match[1])
+        numeric <= tag.numeric && ((self.latest? || tag.latest?) || self.timestamp? == tag.timestamp?)
+
+      elsif condition =~ /^<\s*(.*)/
+        tag = validate_condition!(condition, Regexp.last_match[1])
+        numeric < tag.numeric && ((self.latest? || tag.latest?) || self.timestamp? == tag.timestamp?)
+
+      elsif condition =~ /^==?\s*(.*)/
+        tag = validate_condition!(condition, Regexp.last_match[1])
+        self == tag
+
+      else
+        tag = validate_condition!(condition, condition)
+        self == tag
+      end
+    end
+
+    # Returns a numeric representation of the version, this can be used
+    # for chronological comparison with other versions
+    def numeric
+      if latest?
+        1_000_000_000_000_000_000_000_000_000
+      elsif semantic?
+        # This assumes each counter will never go > 1000
+        if development?
+          self =~ /v?(\d+).(\d+).(\d+).(dev|pre)(\d+)/
+          (Regexp.last_match[1].to_i * 1000 * 1000 * 1000) +
+            (Regexp.last_match[2].to_i * 1000 * 1000) +
+            (Regexp.last_match[3].to_i * 1000) +
+            Regexp.last_match[5].to_i
+        else
+          self =~ /v?(\d+).(\d+).(\d+)/
+          (Regexp.last_match[1].to_i * 1000 * 1000 * 1000) +
+            (Regexp.last_match[2].to_i * 1000 * 1000) +
+            (Regexp.last_match[3].to_i * 1000)
+        end
+      elsif timestamp?
+        to_time.to_i
+      else
+        validate!
+      end
+    end
+
+    # Returns the version as a time, only applicable for timestamps,
+    # otherwise an error will be raised
+    def to_time
+      if latest?
+        Time.new(10_000, 1, 1)
+      elsif timestamp?
+        if development?
+          self =~ /\w+_(\d\d\d\d)_(\d\d)_(\d\d)_(\d\d)_(\d\d)$/
+          Time.new(Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4], Regexp.last_match[5])
+        else
+          self =~ /Rel(\d\d\d\d)(\d\d)(\d\d)/
+          Time.new(Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3])
+        end
+      else
+        fail "Version tag #{self} cannot be converted to a time!"
+      end
+    end
+
+    # Returns the version as a date, only applicable for timestamps,
+    # otherwise an error will be raised
+    def to_date
+      if latest?
+        Date.new(10_000, 1, 1)
+      elsif timestamp?
+        to_time.to_date
+      else
+        fail "Version tag #{self} cannot be converted to a date!"
+      end
+    end
+
+    # Validates the given condition and the extracted tag, returns the
+    # tag wrapped in a VersionString if valid, will raise an error if
+    # not
+    def validate_condition!(condition, tag)
+      tag = VersionString.new(tag)
+      tag.validate!("The version condition, #{condition}, is not valid!")
+      tag
+    end
+
+    # Will raise an error if the version is not valid, i.e. if valid?
+    # returns false
+    def validate!(msg = nil)
+      unless valid?
+        if msg
+          fail msg
+        else
+          fail "The version string, #{self}, is not valid!"
+        end
+      end
+      self
+    end
+
+    # Returns the minimum Origen version that would satisfy the given condition,
+    # if the condition does not specify a minimum nil will be returned
+    def self.minimum_version(condition)
+      if condition =~ /^==?\s*(.*)/
+        version = Regexp.last_match[1]
+      elsif condition =~ /^>=\s*(.*)/
+        version = Regexp.last_match[1]
+      elsif condition =~ /^>\s*(.*)/
+        # This is tricky to support, would probably require a lookup
+        # table of all versions to be maintained
+        fail 'Minimum > version is currently not supported!'
+      elsif condition =~ /^<=?\s*(.*)/
+        nil
+      else
+        version = condition
+      end
+      VersionString.new(version).validate! if version
+    end
+
+    # Returns the maximum Origen version that would satisfy the given condition,
+    # if the condition does not specify a maximum nil will be returned
+    def self.maximum_version(condition)
+      if condition =~ /^==?\s*(.*)/
+        version = Regexp.last_match[1]
+      elsif condition =~ /^<=\s*(.*)/
+        version = Regexp.last_match[1]
+      elsif condition =~ /^<\s*(.*)/
+        # This is tricky to support, would probably require a lookup
+        # table of all versions to be maintained
+        fail 'Maximum < version is currently not supported!'
+      elsif condition =~ /^>=?\s*(.*)/
+        nil
+      else
+        version = condition
+      end
+      VersionString.new(version).validate! if version
+    end
+
+    # Returns the version prefixed with the given value ('v' by default) if not
+    # already present
+    def prefixed(str = 'v')
+      if self =~ /^#{str}/
+        to_s
+      else
+        "#{str}#{self}"
+      end
+    end
+  end
+end