origen 0.0.1 → 0.0.2

data/lib/origen/tester/generator.rb

@@ -0,0 +1,271 @@
+require 'active_support/concern'
+require 'erb'
+require 'yaml'
+
+module Origen
+  module Tester
+    module Generator
+      autoload :Placeholder,   'origen/tester/generator/placeholder'
+      autoload :IdentityMap,   'origen/tester/generator/identity_map'
+      autoload :FlowControlAPI, 'origen/tester/generator/flow_control_api'
+
+      extend ActiveSupport::Concern
+
+      included do
+        include Origen::Generator::Comparator
+      end
+
+      # The program source files are executed by eval to allow the tester to filter the
+      # source contents before executing. For examples the doc tester replaces all comments
+      # with a method call containing each comment so that they can be captured.
+      def self.execute_source(file)
+        if Origen.tester.doc? && Origen.interface_loaded? && Origen.interface.respond_to?(:filter_source)
+          File.open(file) do |f|
+            src = f.read
+            src = Origen.interface.filter_source(src)
+            # With source file wrapping here to ensure that any calls to Origen.app! within
+            # the source code will evaluate to the correct app instance
+            Origen.with_source_file(file) do
+              eval(src, global_binding)
+            end
+          end
+        else
+          load file
+        end
+      end
+
+      # When called on a generater no output files will be created from it
+      def inhibit_output
+        @inhibit_output = true
+      end
+
+      # Returns true if the output files from this generator will be inhibited
+      def output_inhibited?
+        @inhibit_output
+      end
+
+      # Expands and inserts all render statements that have been encountered
+      def close(options = {})
+        Origen.profile "closing #{filename}" do
+          base_collection = collection
+          base_collection.each_with_index do |item, i|
+            if item.is_a? Placeholder
+              if item.type == :render
+                txt = ''
+                Origen.file_handler.preserve_current_file do
+                  Origen.file_handler.default_extension = file_extension
+                  placeholder = compiler.render(item.file, item.options)
+                  txt = compiler.insert(placeholder).chomp
+                end
+                base_collection[i] = txt
+              else
+                fail 'Unknown placeholder encountered!'
+              end
+            end
+          end
+          @collection = base_collection.flatten.compact
+          on_close(options)
+        end
+      end
+
+      def file_pipeline
+        @@file_pipeline ||= []
+      end
+
+      # Returns the directory of the current source file being generated
+      def current_dir
+        if file_pipeline.empty?
+          Origen.file_handler.base_directory
+        else
+          Pathname.new(file_pipeline.last).dirname
+        end
+      end
+
+      # Redefine this in the parent which includes this module if you want anything to
+      # occur after closing the generator (expanding all render/import statements) but
+      # before writing to a file.
+      def on_close(_options = {})
+      end
+
+      # Redefine this in the parent which includes this module if you want anything to
+      # occur after all tests have been generated but before file writing starts.
+      def finalize(_options = {})
+      end
+
+      def compiler
+        Origen.generator.compiler
+      end
+
+      def filename=(name)
+        @filename = name
+      end
+
+      def filename(options = {})
+        options = {
+          include_extension: true
+        }.merge(options)
+        name = (@filename || Origen.file_handler.current_file.basename('.rb')).to_s
+        if Origen.config.program_prefix
+          unless name =~ /^#{Origen.config.program_prefix}/i
+            name = "#{Origen.config.program_prefix}_#{name}"
+          end
+        end
+        f = Pathname.new(name).basename
+        ext = f.extname.empty? ? file_extension : f.extname
+        body = f.basename(".#{ext}").to_s
+        body.gsub!('_resources', '')
+        if defined? self.class::OUTPUT_POSTFIX
+          # Unless the postfix is already in the name
+          unless body =~ /#{self.class::OUTPUT_POSTFIX}$/i
+            body = "#{body}_#{self.class::OUTPUT_POSTFIX}"
+          end
+        end
+        ext = ".#{ext}" unless ext =~ /^\./
+        if options[:include_extension]
+          "#{body}#{ext}"
+        else
+          "#{body}"
+        end
+      end
+
+      def dont_diff=(val)
+        @dont_diff = val
+      end
+
+      # All generators must implement a collection method that returns an
+      # array containing the generated items
+      def collection
+        @collection ||= []
+      end
+
+      def collection=(array)
+        @collection = array
+      end
+
+      def file_extension
+        if defined? self.class::OUTPUT_EXTENSION
+          self.class::OUTPUT_EXTENSION
+        elsif defined? self.class::TEMPLATE
+          p = Pathname.new(self.class::TEMPLATE)
+          ext = p.basename('.erb').extname
+          ext.empty? ? 'txt' : ext
+        else
+          'txt'
+        end
+      end
+
+      def write_to_file(options = {})
+        unless output_inhibited?
+          if defined? self.class::TEMPLATE || Origen.tester.is_a?(Origen::Tester::Doc)
+            write_from_template(options)
+          else
+            fail "Don't know hot to write without a template!"
+          end
+          stats.completed_files += 1
+        end
+      end
+
+      def write_from_template(options = {})
+        options = {
+          quiet:     false,
+          skip_diff: false
+        }.merge(options)
+        unless output_inhibited?
+          # If this is not the first time we have written to the current output file
+          # then appen to it, otherwise clear it and start from scratch.
+          # The use of a class variable to store the opened files means that it will be
+          # shared by all generators in this run.
+          @@opened_files ||= []
+          if @@opened_files.include?(output_file) && !Origen.tester.is_a?(Origen::Tester::Doc)
+            @append = true
+            Origen.file_handler.preserve_state do
+              File.open(output_file, 'a') do |out|
+                content = compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
+                out.puts content unless content.empty?
+              end
+            end
+            Origen.log.info "Appending... #{output_file.basename}" unless options[:quiet]
+          else
+            @append = false
+            Origen.file_handler.preserve_state do
+              if Origen.tester.is_a?(Origen::Tester::Doc)
+                if options[:return_model]
+                  Origen::Tester::Doc.model.add_flow(filename(include_extension: false), to_yaml)
+                else
+                  Origen.file_handler.open_for_write(output_file) do |f|
+                    f.puts YAML.dump(to_yaml(include_descriptions: false))
+                  end
+                end
+              else
+                File.open(output_file, 'w') do |out|
+                  out.puts compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
+                end
+              end
+            end
+            @@opened_files << output_file
+            Origen.log.info "Writing... #{output_file.basename}" unless options[:quiet]
+          end
+          if !@dont_diff && !options[:skip_diff] && !options[:quiet]
+            check_for_changes(output_file, reference_file,
+                              compile_job:  true,
+                              comment_char: Origen.app.tester.program_comment_char)
+          end
+        end
+      end
+
+      def output_file
+        Pathname.new("#{Origen.file_handler.output_directory}/#{filename}")
+      end
+
+      def reference_file
+        Pathname.new("#{Origen.file_handler.reference_directory}/#{filename}")
+      end
+
+      def import(file, options = {})
+        file = Pathname.new(file).absolute? ? file : "#{current_dir}/#{file}"
+        file = Origen.file_handler.clean_path_to_sub_program(file)
+        base_collection = collection
+        @collection = []
+        Origen.generator.option_pipeline << options
+        file_pipeline << file
+        Origen::Tester::Generator.execute_source(file)
+        file_pipeline.pop
+        base_collection << @collection
+        @collection = base_collection.flatten
+      end
+
+      def render(file, options = {})
+        if options.delete(:_inline)
+          super Origen.file_handler.clean_path_to_sub_template(file), options
+        else
+          collection << Placeholder.new(:render, file, options)
+        end
+      end
+
+      def stats
+        Origen.app.stats
+      end
+
+      def to_be_written?
+        true
+      end
+
+      def set_flow_description(desc)
+        Origen.interface.descriptions.add_for_flow(output_file, desc)
+      end
+
+      def identity_map # :nodoc:
+        Origen.interface.identity_map
+      end
+
+      module ClassMethods
+        def new(*args, &block) # :nodoc:
+          x = allocate
+          x.send(:initialize, *args, &block)
+          Origen.interface.sheet_generators << x
+          x
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/interface.rb

@@ -0,0 +1,154 @@
+require 'active_support/concern'
+
+module Origen
+  module Tester
+    # Include this module in any class you define as a test interface
+    module Interface
+      extend ActiveSupport::Concern
+
+      included do
+        Origen.add_interface(self)
+      end
+
+      # This identifier will be used to make labels and other references unique to the
+      # current application. This will help to avoid name duplication if a program is
+      # comprised of many modules generated by Origen.
+      #
+      # Override in the application interface to customize, by default the identifier
+      # will be Origen.config.initials
+      def app_identifier
+        Origen.config.initials || 'Anon App'
+      end
+
+      def close(options = {})
+        sheet_generators.each do |generator|
+          generator.close(options)
+        end
+      end
+
+      # Compile a template file
+      def compile(file, options = {})
+        Origen.file_handler.preserve_state do
+          begin
+            file = Origen.file_handler.clean_path_to_template(file)
+            Origen.generator.compile_file_or_directory(file, initial_options: options)
+          rescue
+            file = Origen.file_handler.clean_path_to(file)
+            Origen.generator.compile_file_or_directory(file, initial_options: options)
+          end
+        end
+      end
+
+      def import(file, options = {})
+        # Attach the import request to the first generator, when it imports
+        # it any generated resources will automatically find their way to the
+        # correct generator/collection
+        generator = flow || sheet_generators.first
+        generator.import(file, options)
+      end
+
+      def render(file, options = {})
+        if sheet_generators.size > 1
+          fail "You must specify which generator to render content to! e.g.  i.test_instances.render '#{file}'"
+        else
+          sheet_generators.first.render(file, options)
+        end
+      end
+
+      def write_files(options = {})
+        sheet_generators.each do |generator|
+          generator.finalize(options)
+        end
+        sheet_generators.each do |generator|
+          generator.write_to_file(options) if generator.to_be_written?
+        end
+        reset_globals
+      end
+
+      # All generators should push to this array whenever they reference a pattern
+      # so that it is captured in the pattern list, e.g.
+      #   Origen.interface.referenced_patterns << pattern
+      def referenced_patterns
+        @@referenced_patterns ||= []
+      end
+
+      # Add a comment line into the buffer
+      def comment(text)
+        comments << text
+      end
+
+      def comments
+        @@comments ||= []
+      end
+
+      def discard_comments
+        @@comments = nil
+      end
+
+      # Returns the buffered description comments and clears the buffer
+      def consume_comments
+        c = comments
+        discard_comments
+        c
+      end
+
+      def top_level_flow
+        @@top_level_flow ||= nil
+      end
+      alias_method :top_level_flow_filename, :top_level_flow
+
+      def flow_generator
+        flow
+      end
+
+      def set_top_level_flow
+        @@top_level_flow = flow_generator.output_file
+      end
+
+      def clear_top_level_flow
+        @@top_level_flow = nil
+      end
+
+      # A storage Hash that all generators can push comment descriptions
+      # into when generating.
+      # At the end of a generation run this will contain all descriptions
+      # for all flows that were just created.
+      #
+      # Access via Origen.interface.descriptions
+      def descriptions
+        @@descriptions ||= Parser::DescriptionLookup.new
+      end
+
+      # Any tests generated within the given block will be generated in resources mode.
+      # Generally this means that all resources for a given test will be generated but
+      # flow entries will be inhibited.
+      def resources_mode
+        orig = @resources_mode
+        @resources_mode = true
+        yield
+        @resources_mode = orig
+      end
+
+      def resources_mode?
+        @resources_mode
+      end
+
+      def identity_map # :nodoc:
+        @@identity_map ||= Origen::Tester::Generator::IdentityMap.new
+      end
+
+      module ClassMethods
+        # Returns true if the interface class supports the
+        # given tester instance
+        def supports?(tester_instance)
+          # Testers uses different platform check than Origen core
+          if self.respond_to?('platform')
+            tester_instance.is_a?(platform)
+          else
+            tester_instance.is_a?(self::PLATFORM)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/files.rb

@@ -0,0 +1,45 @@
+module Origen
+  module Tester
+    class J750
+      # Methods for handling all J750 file parsing, e.g. datalogs,
+      # test time profiles, etc.
+      module Files
+        # Reads all lines from a J750 detailed execution time file, returning the lines
+        # as an array like this:
+        #
+        #   [
+        #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
+        #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
+        #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
+        #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
+        #   ]
+        def read_test_times(file, _options = {})
+          tests = []
+          File.readlines(file).each do |line|
+            unless line.strip.empty? || line =~ /Entire Job/
+              # http://rubular.com/r/vZOcqovTsf
+              if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
+                t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
+                # If an indexed test
+                if Regexp.last_match[2]
+                  str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
+                  fields = str.split('/')
+                  i = fields[0].to_i
+                  g = fields[1].to_i
+                  t[:index] = i
+                  t[:group] = g
+
+                else
+                  t[:index] = nil
+                  t[:group] = nil
+                end
+                tests << t
+              end
+            end
+          end
+          tests
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/flow.rb

@@ -0,0 +1,123 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class Flow
+          include Origen::Tester::Generator
+          include Origen::Tester::Generator::FlowControlAPI
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/j750/generator/templates/flow.txt.erb"
+          OUTPUT_POSTFIX = 'flow'
+
+          def add(type, options = {})
+            ins = false
+            options = save_context(options) if [:test, :cz].include?(type)
+            branch_unless_enabled(options) do |options|
+              ins = track_relationships(options) do |options|
+                FlowLine.new(type, options)
+              end
+              collection << ins unless Origen.interface.resources_mode?
+              if ins.test?
+                c = Origen.interface.consume_comments
+                unless Origen.interface.resources_mode?
+                  Origen.interface.descriptions.add_for_test_usage(ins.parameter, Origen.interface.top_level_flow, c)
+                end
+              else
+                Origen.interface.discard_comments
+              end
+            end
+            ins
+          end
+
+          def logprint(message, options = {})
+            message.gsub!(/\s/, '_')
+            add(:logprint, options.merge(parameter: message))
+          end
+
+          def test(instance, options = {})
+            add(:test, options.merge(parameter: instance))
+          end
+
+          def cz(instance, cz_setup, options = {})
+            add(:cz, options.merge(parameter: instance, cz_setup: cz_setup))
+          end
+
+          def goto(label, options = {})
+            add(:goto, options.merge(parameter: label))
+          end
+
+          def nop(options = {})
+            add(:nop, options.merge(parameter: nil))
+          end
+
+          def set_device(options = {})
+            add(:set_device, options)
+          end
+
+          def set_error_bin(options = {})
+            add(:set_error_bin, options)
+          end
+
+          def enable_flow_word(word, options = {})
+            add(:enable_flow_word, options.merge(parameter: word))
+          end
+
+          def disable_flow_word(word, options = {})
+            add(:disable_flow_word, options.merge(parameter: word))
+          end
+
+          # All tests generated will not run unless the given enable word is asserted.
+          #
+          # This is specially implemented for J750 since it does not have a native
+          # support for flow word not enabled.
+          # It will generate a goto branch around the tests contained with the block
+          # if the given flow word is enabled.
+          def unless_enable(word, options = {})
+            if options[:or]
+              yield
+            else
+              @unless_enable_block = word
+              options = options.merge(unless_enable: word)
+              branch_unless_enabled(options.merge(_force_unless_enable: true)) do
+                yield
+              end
+              @unless_enable_block = nil
+            end
+          end
+          alias_method :unless_enabled, :unless_enable
+
+          def start_flow_branch(identifier, options = {})
+            goto(identifier, options)
+          end
+
+          def skip(identifier = nil, options = {})
+            identifier, options = nil, identifier if identifier.is_a?(Hash)
+            identifier = generate_unique_label(identifier)
+            goto(identifier, options)
+            yield
+            nop(label: identifier)
+          end
+
+          private
+
+          # If the test has an unless_enable then branch around it
+          def branch_unless_enabled(options)
+            word = options.delete(:unless_enable) || options.delete(:unless_enabled)
+            if word && (word != @unless_enable_block || options.delete(:_force_unless_enable))
+              # Not sure if this is really required, but duplicating these hashes here to ensure
+              # that all other flow context keys are preserved and applied to the branch lines
+              orig_options = options.merge({})
+              close_options = options.merge({})
+              label = generate_unique_label
+              goto(label, options.merge(if_enable: word))
+              yield orig_options
+              nop(close_options.merge(label: label))
+            else
+              yield options
+            end
+          end
+        end
+      end
+    end
+  end
+end