origen 0.0.1 → 0.0.2

data/lib/origen/file_handler.rb

@@ -0,0 +1,429 @@
+require 'pathname'
+
+module Origen
+  # All logic for working with files/directories and resolving path names
+  # should be included here.
+  #
+  # An instance of this class is available as Origen.file_handler
+  #
+  # Some portions of Origen may implement local code to do this, but these
+  # should all be transitioned to use this over time.
+  class FileHandler
+    attr_accessor :default_extension
+
+    # Returns an array of file/pattern names lines from a list file.
+    # This will also take care of recursively expanding any embedded
+    # list references.
+    def expand_list(files, options = {})
+      [files].flatten.map do |file|
+        f = file.strip
+        # Takes care of blank or comment lines in a list file
+        if f.empty? || f =~ /^\s*#/
+          nil
+        # Don't expand program lists when submitting to lsf,
+        # there are likely to be relational dependencies between
+        # flows meaning that they must be generated together
+        elsif is_a_list?(f) && !(options[:lsf] && options[:action] == :program)
+          expand_list(open_list(f), options)
+        else
+          f
+        end
+      end.flatten.compact.uniq
+    end
+
+    # Returns the contents of the given list file in an array, if it
+    # can be found, if not will raise an error
+    def open_list(file)
+      f = clean_path_to(file, allow_missing: true)
+      if f
+        f = File.open(f, 'r')
+      elsif File.exist?("#{Origen.root}/list/#{File.basename(file)}")
+        f = File.open("#{Origen.root}/list/#{File.basename(file)}", 'r')
+      elsif @last_opened_list_dir && File.exist?("#{@last_opened_list_dir}/#{file}")
+        f = File.open("#{@last_opened_list_dir}/#{file}", 'r')
+      else
+        fail "Could not find list file: #{file}"
+      end
+      lines = f.readlines
+      f.close
+      # Before we go save the directory of this list, this will help
+      # us to resolve any relative path references to other lists that
+      # it may contain
+      @last_opened_list_dir = clean_path_to(Pathname.new(f).dirname)
+      lines
+    end
+
+    # Returns true if the input argument is a list, for now this is
+    # simply defined by the filename ending in .list
+    def is_a_list?(file)
+      !!(file =~ /list$/)
+    end
+
+    # Yields absolute paths to the given file or directory. If a directory is supplied
+    # the method will recurse into the sub directories and ultimately yield
+    # every file contained within the directory and its children.
+    def resolve_files(file_or_dir_path, options = {}, &block)
+      options = {
+        # Set to :template when calling to consider references to template
+        # files from an import library
+        import: false
+      }.merge(options)
+      [file_or_dir_path].flatten.each do |file_or_dir_path|
+        path = inject_import_path(file_or_dir_path, type: options[:import]) if options[:import]
+        path = clean_path_to(file_or_dir_path, options)
+        self.base_directory = path unless options[:internal_call]
+        if path.directory?
+          Dir.glob("#{path}/*").sort.each do |file|
+            resolve_files(file, { internal_call: true }.merge(options), &block)
+          end
+        else
+          # Ignore files with the given prefix if supplied, but only if this is a file that
+          # has been found, if explicitly asked to compile a file from the caller do it regardless
+          if options[:ignore_with_prefix] && options[:internal_call]
+            return nil if path.basename.to_s =~ /^#{options[:ignore_with_prefix]}/
+          end
+          yield path
+        end
+      end
+    end
+
+    # Returns a full path to the given file or directory, raises an error if it
+    # can't be resolved
+    def clean_path_to(file, options = {})
+      # Allow individual calls to this method to specify additional custom load paths to consider
+      if options[:load_paths]
+        [options[:load_paths]].each do |root|
+          if File.exist?("#{root}/#{file}")
+            return Pathname.new("#{root}/#{file}")
+          end
+        end
+      end
+      if File.exist?(file)
+        if Pathname.new(file).absolute?
+          Pathname.new(file)
+        else
+          Pathname.new("#{Pathname.pwd}/#{file}")
+        end
+      # Is it a relative reference within a list file?
+      elsif @last_opened_list_dir && File.exist?("#{@last_opened_list_dir}/#{file}")
+        Pathname.new("#{@last_opened_list_dir}/#{file}")
+      # Is it a relative reference to the current base directory?
+      elsif File.exist?("#{base_directory}/#{file}")
+        Pathname.new("#{base_directory}/#{file}")
+      # Is it a path relative to Origen.root?
+      elsif File.exist?("#{Origen.root}/#{file}")
+        Pathname.new("#{Origen.root}/#{file}")
+      # Is it a path relative to the current directory?
+      elsif current_directory && File.exist?("#{current_directory}/#{file}")
+        Pathname.new("#{current_directory}/#{file}")
+      # Is it a path relative to the current plugin's Origen.root?
+      elsif Origen.current_plugin.instance && File.exist?("#{Origen.current_plugin.instance.root}/#{file}")
+        Pathname.new("#{Origen.current_plugin.instance.root}/#{file}")
+      elsif options[:default_dir]
+        m = all_matches(file, options)
+        if m
+          Pathname.new(m)
+        else
+          if options[:allow_missing]
+            return nil
+          else
+            fail "Can't find: #{file}"
+          end
+        end
+      else
+        if options[:allow_missing]
+          return nil
+        else
+          fail "Can't find: #{file}"
+        end
+      end
+    end
+
+    def check(path)
+      file_plugin = Origen.import_manager.path_within_a_plugin(path)
+      if file_plugin
+        if Origen.current_plugin.name
+          if file_plugin == Origen.current_plugin.name
+            return path
+          else
+            puts "The requested file is from plugin #{file_plugin} and current system plugin is set to plugin #{Origen.current_plugin.name}!"
+            fail 'Incorrect plugin error!'
+          end
+        else
+          Origen.current_plugin.temporary = file_plugin
+          return path
+        end
+      else
+        return path
+      end
+    end
+
+    def all_matches(file, options)
+      if Origen.current_plugin.name
+        matches = Dir.glob("#{options[:default_dir]}/#{Origen.current_plugin.name}/**/#{file}").sort
+        matches = matches.flatten.uniq
+        if matches.size == 0
+          matches = Dir.glob("#{options[:default_dir]}/**/#{file}").sort
+          matches = matches.flatten.uniq
+        end
+      else
+        matches = (Dir.glob("#{options[:default_dir]}/**/#{file}") + # Avoids symlinks
+                    Dir.glob("#{options[:default_dir]}/#{file}")).sort
+        if matches.size == 0
+          matches = Dir.glob("#{options[:default_dir]}/**{,/*/**}/#{file}").sort # Takes symlinks into consideration
+          matches = matches.flatten.uniq
+        end
+      end
+
+      if matches.size == 0
+        return nil
+      elsif matches.size > 1
+        puts 'The following matches were found:'
+        puts matches
+        fail "Ambiguous file #{file}"
+      else
+        return check(matches.first)
+      end
+    end
+
+    # Returns an absolute path for the given
+    def relative_to_absolute(path)
+      if Pathname.new(path).absolute?
+        Pathname.new(path)
+      else
+        Pathname.new("#{Pathname.pwd}/#{path}")
+      end
+    end
+
+    def relative_path_to(path)
+      clean_path_to(path).relative_path_from(Pathname.pwd)
+    end
+
+    def clean_path_to_sub_template(file)
+      if File.exist?(file)
+        if Pathname.new(file).absolute?
+          return Pathname.new(file)
+        else
+          return Pathname.new("#{Pathname.pwd}/#{file}")
+        end
+      end
+      file = inject_import_path(file, type: :template)
+      file = add_underscore_to(file)
+      file = add_extension_to(file)
+      begin
+        # Allow relative references to templates/web when compiling a web template
+        if Origen.lsf.current_command == 'web'
+          clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
+        else
+          clean_path_to(file)
+        end
+      rescue
+        # Try again without .erb
+        file = file.gsub('.erb', '')
+        if Origen.lsf.current_command == 'web'
+          clean_path_to(file, load_paths: "#{Origen.root}/templates/web")
+        else
+          clean_path_to(file)
+        end
+      end
+    end
+
+    def clean_path_to_template(file)
+      file = inject_import_path(file, type: :template)
+      file = add_extension_to(file)
+      clean_path_to(file)
+    end
+
+    # If the current path looks like it is a reference to an import, the
+    # path will be replaced with the absolute path to the local import directory
+    def inject_import_path(path, options = {})
+      path = path.to_s unless path.is_a?(String)
+      if path =~ /(.*?)\/.*/
+        import_name = Regexp.last_match[1].downcase.to_sym
+        if import_name == :origen || import_name == :origen_core || Origen.import_manager.names.include?(import_name)
+          unless import_name == :origen || import_name == :origen_core
+            root = Origen.app(import_name).root
+          end
+          if options[:type] == :template
+            if import_name == :origen || import_name == :origen_core
+              path.sub! 'origen', "#{Origen.top}/templates/shared"
+            else
+              path.sub! Regexp.last_match[1], "#{root}/templates/shared"
+            end
+          else
+            fail 'Unknown import path type!'
+          end
+        end
+      end
+      path
+    end
+
+    def clean_path_to_sub_program(file)
+      file = add_underscore_to(file)
+      file = add_rb_to(file)
+      clean_path_to(file)
+    end
+
+    # Insert _ in file name if not present
+    def add_underscore_to(file)
+      f = Pathname.new(file)
+      if f.basename.to_s =~ /^_/
+        file
+      else
+        "#{f.dirname}/_#{f.basename}"
+      end
+    end
+
+    def add_rb_to(file)
+      f = Pathname.new(file)
+      "#{f.dirname}/#{f.basename('.rb')}.rb"
+    end
+
+    def add_extension_to(file)
+      f = Pathname.new(file)
+      if f.basename('.erb').extname.empty?
+        if default_extension
+          "#{f.dirname}/#{f.basename('.erb')}#{default_extension}.erb"
+        else
+          "#{f.dirname}/#{f.basename('.erb')}#{Pathname.new(Origen.file_handler.current_file).basename('.erb').extname}.erb"
+        end
+      else
+        "#{f.dirname}/#{f.basename('.erb')}.erb"
+      end
+    end
+
+    def set_output_directory(options = {})
+      options = {
+        create: true
+      }.merge(options)
+      if options[:output]
+        @output_directory = relative_to_absolute(options[:output])
+      else
+        @output_directory = Pathname.new(Origen.config.output_directory)
+      end
+      if options[:create]
+        FileUtils.mkdir_p(@output_directory) unless @output_directory.exist?
+      end
+      @output_directory
+    end
+
+    # Returns an absolute pathname to the current output directory
+    def output_directory
+      @output_directory ||= set_output_directory
+    end
+
+    def set_reference_directory(options = {})
+      options = {
+        create: true
+      }.merge(options)
+      if options[:reference]
+        @reference_directory = relative_to_absolute(options[:reference])
+      else
+        @reference_directory = Pathname.new(Origen.config.reference_directory)
+      end
+      if options[:create]
+        # Delete any broken symlinks in the top level .ref
+        dir = "#{Origen.root}/.ref"
+        if File.symlink?(dir)
+          FileUtils.rm_f(dir) unless File.exist?(dir)
+        end
+        FileUtils.mkdir_p(@reference_directory) unless @reference_directory.exist?
+      end
+      @reference_directory
+    end
+
+    # Returns an absolute pathname to the current reference directory
+    def reference_directory
+      @reference_directory ||= set_reference_directory
+    end
+
+    # Returns the base directory containing the source files being generated/compiled.
+    #
+    # When operating on a single file this will return the directory containing that
+    # file, when operating on a directory this will return the directory.
+    def base_directory
+      @base_directory
+    end
+
+    def base_directory=(file_or_dir)
+      # puts "Base directory changed by: #{caller[0]}"
+      if file_or_dir.directory?
+        @base_directory = file_or_dir
+      else
+        @base_directory = file_or_dir.dirname
+      end
+    end
+
+    def current_directory
+      return @current_directory if @current_directory
+      @current_directory = clean_path_to(current_file).dirname if current_file
+    end
+
+    def current_file=(file)
+      @current_directory = nil
+      @current_file = file
+    end
+
+    def current_file
+      @current_file
+    end
+
+    def preserve_current_file
+      file = current_file
+      yield
+      self.current_file = file
+    end
+
+    def preserve_state
+      file = current_file
+      dir = base_directory
+      output = output_directory
+      ref = reference_directory
+      yield
+      self.base_directory = dir if dir
+      self.current_file = file if file
+      set_output_directory(output: output) if output
+      set_reference_directory(reference: ref) if ref
+    end
+
+    def preserve_and_clear_state
+      file = current_file
+      dir = base_directory
+      output = output_directory
+      ref = reference_directory
+      current_file = nil
+      base_directory = nil
+      output_directory = nil
+      reference_directory = nil
+      yield
+      self.base_directory = dir if dir
+      self.current_file = file if file
+      set_output_directory(output: output) if output
+      set_reference_directory(reference: ref) if ref
+    end
+
+    # Returns the sub directory of the current base directory that the
+    # given file is in
+    def sub_dir_of(file, base = base_directory)
+      file = Pathname.new(file) unless file.respond_to?(:relative_path_from)
+      base = Pathname.new(base) unless base.respond_to?(:relative_path_from)
+      rel = file.relative_path_from(base)
+      if file.directory?
+        rel
+      else
+        rel.dirname
+      end
+    end
+
+    # Convenience method to use when you want to write to a file, this takes
+    # care of ensuring that the directory exists prior to attempting to open
+    # the file
+    def open_for_write(path)
+      dir = Pathname.new(path).dirname
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      File.open(path, 'w') do |f|
+        yield f
+      end
+    end
+  end
+end

data/lib/origen/generator/comparator.rb

@@ -0,0 +1,56 @@
+module Origen
+  class Generator
+    module Comparator
+      # Will check if the supplied file has changed from the last time it was generated
+      # Returns true if it is a new file, or if a change has been detected
+      def check_for_changes(new, old, options = {})
+        options = {
+          comment_char:   Origen.app.tester ? Origen.app.tester.comment_char : nil,
+          quiet:          false,
+          compile_job:    false,
+          suspend_string: 'STOPDIFF',
+          resume_string:  'STARTDIFF'
+        }.merge(options)
+
+        if File.exist?(old)
+          if Utility::Diff.new(file_a: new, file_b: old, ignore_blank_lines: true,
+                               comment_char: options[:comment_char],
+                               suspend_string: options[:suspend_string],
+                               resume_string: options[:resume_string]).diffs?
+
+            unless options[:quiet]
+              cmd = "*** CHANGE DETECTED *** To update the reference:  #{Origen.config.copy_command} #{relative_path_to(new)} #{relative_path_to(old)}"
+              cmd += ' /Y' if Origen.running_on_windows?
+              Origen.log.info cmd
+              Origen.log.info "#{Origen.config.diff_command} #{relative_path_to(old)} #{relative_path_to(new)} &"
+              Origen.log.info '**********************************************************************'
+            end
+            if options[:compile_job]
+              stats.changed_files += 1
+            else
+              stats.changed_patterns += 1
+            end
+            true
+          end
+        else
+          unless options[:quiet]
+            Origen.log.info "*** NEW FILE *** To save it:  #{Origen.config.copy_command} #{relative_path_to(new)} #{relative_path_to(old)}"
+            Origen.log.info '**********************************************************************'
+          end
+          if options[:compile_job]
+            stats.new_files += 1
+          else
+            stats.new_patterns += 1
+          end
+          true
+        end
+      end
+
+      def relative_path_to(file)
+        p = Pathname(file).relative_path_from(Pathname.pwd).to_s
+        p.gsub!('/', '\\') if Origen.running_on_windows?
+        p
+      end
+    end
+  end
+end