origen 0.0.1 → 0.0.2

data/lib/origen/revision_control/git.rb

@@ -0,0 +1,243 @@
+module Origen
+  module RevisionControl
+    class Git < Base
+      def build
+        if Dir["#{local}/*"].empty?
+          FileUtils.rm_rf(local.to_s)
+          # Not using the regular 'git' method here since the local dir doesn't exist to CD into
+          system "git clone #{remote} #{local}"
+        else
+          fail "The requested workspace is not empty: #{local}"
+        end
+      end
+
+      def checkout(path = nil, options = {})
+        paths, options = clean_path(path, options)
+        # Pulls latest metadata from server, does not change workspace
+        git 'fetch', options
+
+        version = options[:version] || current_branch
+
+        if version == 'HEAD'
+          puts "Sorry, but you are not currently on a branch and I don't know which branch you want to checkout"
+          puts 'Please supply a branch name as the version to checkout the latest version of it, e.g. origen rc co -v develop'
+          exit 1
+        end
+
+        if options[:force]
+          git 'reset HEAD'
+          git "checkout #{version} #{paths.join(' ')}", options
+        else
+          if paths.size > 1 || paths.first != local.to_s
+            fail 'The Git driver does not support partial merge checkout, it has to be the whole workspace'
+          end
+          git 'reset HEAD'
+          res = git 'stash', options
+          stashed = !res.any? { |l| l =~ /^No local changes to save/ }
+          git "checkout #{version}", options
+          if stashed
+            result = git 'stash pop', { check_errors: false }.merge(options)
+            conflicts = []
+            result.each do |line|
+              if line =~ /CONFLICT.* (.*)$/
+                conflicts << Regexp.last_match(1)
+              end
+            end
+            git 'reset HEAD'
+            unless conflicts.empty?
+              Origen.log.info ''
+              Origen.log.error 'Your local changes could not automatically merged into the following files, open them to fix the conflicts:'
+              conflicts.each do |conflict|
+                Origen.log.error "  #{conflict}"
+              end
+            end
+          end
+        end
+        paths
+      end
+
+      def checkin(path = nil, options = {})
+        paths, options = clean_path(path, options)
+        # Can't check in unless we have the latest
+        if options[:force] && !options[:initial]
+          # Locally check in the given files
+          checkin(paths.join(' '), local: true, verbose: false, comment: options[:comment])
+          local_rev = current_commit
+          # Pull latest
+          checkout
+          # Restore the given files to our previous version
+          # Errors are ignored here since this can fail if the given file didn't exist until now,
+          # in that case we already implicitly have the previous version
+          git("checkout #{local_rev} -- #{paths.join(' ')}", check_errors: false)
+          # Then proceed with checking them in as latest
+        else
+          checkout unless options[:initial]
+        end
+        cmd = 'add'
+        cmd += ' -u' unless options[:unmanaged]
+        cmd += " #{paths.join(' ')}"
+        git cmd, options
+        if changes_pending_commit?
+          cmd = 'commit'
+          if options[:comment] && !options[:comment].strip.empty?
+            cmd += " -m \"#{options[:comment].strip}\""
+          else
+            cmd += " -m \"No comment!\""
+          end
+          if options[:author]
+            if options[:author].respond_to?(:name_and_email)
+              author =  options[:author].name_and_email
+            else
+              author = "#{options[:author]} <>"
+            end
+            cmd += " --author=\"#{author}\""
+          end
+          if options[:time]
+            cmd += " --date=\"#{options[:time].strftime('%a %b %e %H:%M:%S %Y %z')}\""
+          end
+          git cmd, options
+        end
+        git "push origin #{current_branch}" unless options[:local]
+        paths
+      end
+
+      def changes(dir = nil, options = {})
+        paths, options = clean_path(dir, options)
+        options = {
+          verbose: false
+        }.merge(options)
+        # Pulls latest metadata from server, does not change workspace
+        git 'fetch', options
+
+        version = options[:version] || 'HEAD'
+        objects = {}
+
+        objects[:added]   = git("diff --name-only --diff-filter=A #{version} #{paths.first}", options).map(&:strip)
+        objects[:removed] = git("diff --name-only --diff-filter=D #{version} #{paths.first}", options).map(&:strip)
+        objects[:changed] = git("diff --name-only --diff-filter=M #{version} #{paths.first}", options).map(&:strip)
+
+        objects[:present] = !objects[:added].empty? || !objects[:removed].empty? || !objects[:changed].empty?
+        # Return full paths
+        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 = 'diff --name-only'
+        dir = " #{paths.first}"
+        unstaged = git(cmd + dir, options).map(&:strip)
+        staged = git(cmd + ' --cached' + dir, options).map(&:strip)
+        unstaged + staged
+      end
+
+      def unmanaged(dir = nil, options = {})
+        paths, options = clean_path(dir, options)
+        options = {
+          verbose: false
+        }.merge(options)
+        cmd = "ls-files #{paths.first} --exclude-standard --others"
+        git(cmd, options).map(&:strip)
+      end
+
+      def diff_cmd(file, version)
+        "git difftool --tool tkdiff -y #{prefix_tag(version)} #{file}"
+      end
+
+      def tag(id, options = {})
+        id = VersionString.new(id)
+        id = id.prefixed if id.semantic?
+        if options[:comment]
+          git "tag -a #{id} -m \"#{options[:comment]}\""
+        else
+          git "tag #{id}"
+        end
+        git "push origin #{id}"
+      end
+
+      def root
+        Pathname.new(git('rev-parse --show-toplevel', verbose: false).first.strip)
+      end
+
+      def current_branch
+        git('rev-parse --abbrev-ref HEAD', verbose: false).first
+      end
+
+      # Returns true if the given tag already exists
+      def tag_exists?(tag)
+        git('fetch', verbose: false) unless @all_tags_fetched
+        @all_tags_fetched = true
+        git('tag', verbose: false).include?(tag.to_s)
+      end
+
+      private
+
+      def create_gitignore
+        c = Origen::Generator::Compiler.new
+        c.compile "#{Origen.top}/templates/git/gitignore.erb",
+                  output_directory:  local,
+                  quiet:             true,
+                  check_for_changes: false
+        FileUtils.mv "#{local}/gitignore", "#{local}/.gitignore"
+      end
+
+      def changes_pending_commit?
+        !(git('status --verbose', verbose: false).last =~ /^(no changes|nothing to commit)/)
+      end
+
+      def current_commit
+        git('rev-parse HEAD', verbose: false).first
+      end
+
+      def initialize_local_dir
+        super
+        unless initialized?
+          Origen.log.debug "Initializing Git workspace at #{local}"
+          git 'init'
+          git "remote add origin #{remote}"
+        end
+      end
+
+      def initialized?
+        File.exist?("#{local}/.git")
+      end
+
+      # Execute a git operation, the resultant output is returned in an array
+      def git(command, options = {})
+        options = {
+          check_errors: true,
+          verbose:      true
+        }.merge(options)
+        output = []
+        if options[:verbose]
+          Origen.log.info "git #{command}"
+          Origen.log.info ''
+        end
+        Dir.chdir local do
+          Open3.popen2e("git #{command}") do |_stdin, stdout_err, wait_thr|
+            while line = stdout_err.gets
+              Origen.log.info line.strip if options[:verbose]
+              unless line.strip.empty?
+                output << line.strip
+              end
+            end
+
+            exit_status = wait_thr.value
+            unless exit_status.success?
+              if options[:check_errors]
+                fail GitError, "This command failed: 'git #{command}'"
+              end
+            end
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/origen/revision_control/subversion.rb

@@ -0,0 +1,6 @@
+module Origen
+  module RevisionControl
+    class Subversion < Base
+    end
+  end
+end

data/lib/origen/revision_control.rb

@@ -0,0 +1,44 @@
+module Origen
+  module RevisionControl
+    require 'origen/revision_control/base'
+    autoload :DesignSync, 'origen/revision_control/design_sync'
+    autoload :Git,        'origen/revision_control/git'
+    autoload :Subversion, 'origen/revision_control/subversion'
+
+    IGNORE_DIRS =  %w(
+      .ws .lsf log output web coverage .ref .yardoc .collection .bin
+      .session .bundle .tpc pkg tmp lbin .git
+    )
+
+    IGNORE_FILES = %w(
+      target/.default release_note.txt *.swp *.swo *~ .bin
+      list/referenced.list tags .ref .pdm/pi_attributes.txt
+      environment/.default
+    )
+
+    # Creates a new revision controller object based on the supplied :local and :remote
+    # options.
+    #
+    # The revision control system will be worked out from the supplied remote value. This method
+    # should therefore be used whenever the remote is a variable that could refer to many different
+    # systems.
+    #
+    # @example
+    #
+    #   # I know that the remote refers to DesignSync
+    #   rc = Origen::RevisionControl::DesignSync.new remote: "sync//....", local: "my/path"
+    #
+    #   # The remote is a variable and I don't know the type
+    #   rc = Origen::RevisionControl.new remote: rc_url, local: "my/path"
+    def self.new(options = {})
+      case
+      when options[:remote] =~ /^sync/
+        DesignSync.new(options)
+      when options[:remote] =~ /git/
+        Git.new(options)
+      else
+        fail "Could not work out the revision control system for: #{options[:remote]}"
+      end
+    end
+  end
+end

data/lib/origen/ruby_version_check.rb

@@ -0,0 +1,131 @@
+require 'pathname'
+
+def origen_top
+  # This is set in bin/origen
+  $origen_launch_root
+end
+
+def ruby_acceptable_to_run?
+  if RUBY_PLATFORM == 'i386-mingw32'
+    RUBY_VERSION >= '1.9.3'
+  else
+    ruby_latest?
+  end
+end
+
+def ruby_latest?
+  # For now assume windows is always a valid installation
+  if RUBY_PLATFORM == 'i386-mingw32'
+    true
+  else
+    RUBY_VERSION == '2.1.5' && RUBY_PATCHLEVEL && RUBY_PATCHLEVEL == 273
+    # RUBY_VERSION == '1.9.3' && RUBY_PATCHLEVEL && RUBY_PATCHLEVEL == 327
+  end
+end
+
+def puts_latest_policy_files
+  puts <<-END
+  Please contact your system administrator to have the latest versions of the following packages
+  installed (when they are available you can import them by running the commands above):
+
+  END
+  File.readlines("#{origen_top}/config/origen.policy").each do |line|
+    if line !~ /^#/
+      puts "      #{line}"
+    end
+  end
+  puts ''
+end
+
+def puts_require_latest_ruby
+  puts <<-END
+  It's possible that your Ruby version may be stale or out of date, please run the following commands:
+
+  cd #{origen_top}
+  source source_setup update
+  cd #{FileUtils.pwd}
+
+  If you see this message again after performing the above steps then it may be that your site
+  does not have the most recent version of the Ruby package installed.
+  Please contact your system administrator to have the latest version of this package
+  installed (when it is available you can re-run the commands above):
+
+  END
+  File.readlines("#{origen_top}/config/origen.policy").each do |line|
+    if line !~ /^#/ && line =~ /ruby/
+      puts "      #{line}"
+    end
+  end
+  puts ''
+end
+
+def _running_from_tr?
+  if RUBY_PLATFORM != 'i386-mingw32'
+    !!(`echo $PATH` =~ /fs-origen-/)
+  end
+end
+
+unless ruby_latest?
+  if ruby_acceptable_to_run?
+    puts <<-END
+
+  Origen has upgraded to a new toolset but you are currently running with the old tools.
+
+  Your site may already have access to the new tools and you can test this by running the
+  following commands which may be sufficient to remove this message:
+
+    cd #{origen_top}
+    source source_setup update
+    cd #{FileUtils.pwd}
+
+  If that doesn't work then the most likely problem is that your site does not have the required
+  packages installed and you should get some feedback to this effect when running source_setup.
+
+  END
+    puts_latest_policy_files
+
+  else
+
+    if _running_from_tr?
+      puts <<-END
+  I can see that you have added the Origen bin directory to your path, however the required Ruby
+  executable is being overridden by another version that has higher precedence in your path.
+
+  To fix this you should move the Origen bin directory higher up your path, e.g. add this at the very
+  end of your setup file to place it at the head of your path:
+
+    setenv PATH ./lbin:/run/pkg/fs-origen-/latest/bin:$PATH
+
+  For now you can resolve the problem in this shell by running:
+
+    source /run/pkg/fs-origen-/latest/origen_setup
+
+      END
+      exit 1
+    else
+
+      puts <<-END
+
+  Sorry but your Ruby installation is too old to guarantee that Origen will run properly.
+
+  It's possible that you haven't installed Origen correctly, please ensure that you have followed
+  the instructions here:
+
+      http://freeshare.freescale.net:2222/public/origen-cmty-svc/Lists/Posts/Post.aspx?ID=8
+
+  If that doesn't help then perhaps your local copy of the tool collection is stale and
+  running the following commands may help:
+
+      cd #{origen_top}
+      source source_setup update
+      cd #{FileUtils.pwd}
+
+  If that doesn't work then the most likely problem is that your site does not have the required
+  packages installed and you should get some feedback to this effect when running source_setup.
+
+  END
+      puts_latest_policy_files
+      exit 1
+    end
+  end
+end

data/lib/origen/site_config.rb

@@ -0,0 +1,61 @@
+module Origen
+  class SiteConfig
+    require 'pathname'
+    require 'yaml'
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method =~ /(.*)!$/
+        method = Regexp.last_match(1)
+        must_be_present = true
+      end
+      env = "ORIGEN_#{method.upcase}"
+      if ENV.key?(env)
+        val = ENV[env]
+      else
+        config = configs.find { |c| c.key?(method) }
+        val = config ? config[method] : nil
+      end
+      if must_be_present && val.nil?
+        puts "No value assigned for site_config attribute '#{method}'"
+        puts
+        fail 'Missing site_config value!'
+      end
+      define_singleton_method(method) do
+        val
+      end
+      val
+    end
+
+    private
+
+    def configs
+      @configs ||= begin
+        path = Pathname.pwd
+        configs = []
+        # Add any site_configs from where we are currently running from, i.e. the application
+        # directory area
+        until path.root?
+          file = File.join(path, 'origen_site_config.yml')
+          configs << YAML.load_file(file) if File.exist?(file)
+          path = path.parent
+        end
+        # Add and any site_configs from the directory hierarchy where Ruby is installed
+        path = Pathname.new($LOAD_PATH.last)
+        until path.root?
+          file = File.join(path, 'origen_site_config.yml')
+          configs << YAML.load_file(file) if File.exist?(file)
+          path = path.parent
+        end
+        # Add the one from the Origen core as the lowest priority, this one defines
+        # the default values
+        configs << YAML.load_file(File.expand_path('../../../origen_site_config.yml', __FILE__))
+        configs
+      end
+    end
+  end
+
+  def self.site_config
+    @site_config ||= SiteConfig.new
+  end
+end

data/lib/origen/specs/checkers.rb

@@ -0,0 +1,103 @@
+# rubocop:disable Style/RescueModifier:
+def name_audit(name)
+  return name if name.nil?
+  return nil unless name.is_a?(Symbol) || name.is_a?(String)
+  if name == :inspect
+    Origen.log.debug ':inspect is a reserved spec name'
+    return nil
+  end
+  if name.match(/^\d/)
+    Origen.log.debug "Spec #{name} starts with a number"
+    return nil
+  end
+  if name.match(/\s+/)
+    Origen.log.debug "Spec #{name} contains white space, removing it"
+    name.delete!(/\s+/)
+  end
+  name.is_a?(String) ? name.downcase.to_sym : name
+end
+
+# Check that min, max are not mixed with typ.  If a user wants
+# a baseline value for a spec use target as it will not be
+# checked against pass/fail
+def limits_ok?
+  status = true
+  if (@min.exp.to_s.include? '/') || (@max.exp.to_s.include? '/')
+    return status
+  end
+  if @min.exp.nil? ^ @max.exp.nil?
+    @limit_type = :single_sided
+    if @typ.exp
+      # status = false
+      Origen.log.debug "Spec #{@name} has a typical limit defined with either min or max.  They are mutually exclusive, use 'target' when using min or max"
+    end
+  elsif @min.exp && @max.exp
+    @limit_type = :double_sided
+    # Both min and max must be numerical to compare them
+    if @min.value.is_a?(Numeric) && @max.value.is_a?(Numeric)
+      # Check that min and max make sense
+      if @max.value <= @min.value || @min.value >= @max.value
+        status = false
+        Origen.log.debug "Spec #{@name} has min (#{@min.value}) and max (#{@max.value}) reversed"
+      end
+      # Check that target is OK
+      unless @target.nil?
+        if @target.value <= @min.value || @target.value >= @max.value
+          status = false
+          Origen.log.debug "Spec #{@name} has a target (#{@target.value}) that is not within the min (#{@min.value}) and max #{@max.value}) values"
+        end
+      end
+    end
+  end
+  status
+end
+
+def get_mode
+  spec_mode = nil
+  if current_mode.nil?
+    if self == Origen.top_level
+      spec_mode = :global
+    else
+      spec_mode = :local
+    end
+  else
+    spec_mode = current_mode.name
+  end
+  spec_mode
+end
+
+def evaluate_limit(limit)
+  return limit if limit.is_a?(Numeric) || limit.is_a?(Symbol)
+  return nil if limit.nil?
+  limit.gsub!("\n", ' ')
+  limit.scrub!
+  result = false
+  if !!(limit.match(/^\d+\.\d+$/)) || !!(limit.match(/^-\d+\.\d+$/))
+    result = Float(limit).round(4) rescue false # Use the same four digits of accuracy as the Spec model
+  elsif !!(limit.match(/\d+\.\d+\s+\d+\.\d+/)) # workaround for multiple specs authoring bug
+    Origen.log.debug "Found two numbers without an operator in the limit string '#{limit}', choosing the first..."
+    first_number = limit.match(/(\d+\.\d+)\s+\d+\.\d+/).captures.first
+    result = Float(first_number).round(4) rescue false # Use the same four digits of accuracy as the Spec model
+  # elsif !!(limit.match(/^tbd$/i)) # unique case of TBD or To Be Determined, will convert to symbol
+  #  limit = limit.downcase.to_sym
+  else
+    result = Integer(limit) rescue false
+  end
+  if result == false
+    # Attempt to eval the limit because users could write a limit like "3.3 + 50.mV"
+    # which would not work with the code above but should eval to a number 3.35
+    begin
+      result = eval(limit)
+      return result.round(4) if result.is_a? Numeric
+      rescue SyntaxError, NameError, TypeError
+        Origen.log.debug "Limit '#{limit}' had to be rescued, storing it as a #{limit.class}"
+        if limit.is_a? Symbol
+          return limit
+        else
+          return "#{limit}"
+        end
+    end
+  else
+    return result
+  end
+end

data/lib/origen/specs/creation_info.rb

@@ -0,0 +1,17 @@
+module Origen
+  module Specs
+    # This class is used to store spec note information used to document IP
+    class Creation_Info
+      attr_accessor :author, :date, :revision, :source, :tool, :tool_version
+
+      def initialize(author, date, src_info = {}, tool_info = {})
+        @author = author
+        @date = date
+        @revision = src_info[:revision]
+        @source = src_info[:source]
+        @tool = tool_info[:tool]
+        @tool_version = tool_info[:version]
+      end
+    end
+  end
+end