origen_testers 0.5.7 → 0.6.0

data/lib/origen_testers/doc.rb

@@ -1,224 +0,0 @@
-module OrigenTesters
-  # Tester model to generate test program documentation from your pattern sources.
-  # This is intended to be a drop in replacement for existing testers and instead
-  # of generating patterns or test program sheets it will generate a document object
-  # which you can then render out via a template or manually.
-  class Doc
-    include VectorBasedTester
-
-    autoload :Generator, 'origen_testers/doc/generator'
-    autoload :Model, 'origen_testers/doc/model'
-
-    attr_accessor :html_mode
-
-    def generate?
-      html_mode
-    end
-
-    def initialize(*_args)
-      @pat_extension = 'md'
-      @indent = 0
-      @snip_counters = []
-    end
-
-    # Snip the number of comment lines generated by the contained block
-    # to the number given, this is useful for keeping files sizes down and
-    # is typically used to snip sections like downloading LRE code.
-    def snip(number, _options = {})
-      @snip_counters.push number + 1
-      yield
-      @snip_counters.pop
-    end
-
-    def pc(msg)
-      if @snip_counters.last
-        if @snip_counters.last == 1
-          @snip_counters[@snip_counters.size - 1] = 0
-          msg = '  ...snipped'
-        elsif @snip_counters.last == 0
-          return
-        else
-          @snip_counters[@snip_counters.size - 1] -= 1
-        end
-      end
-      if html_mode
-        push_comment(msg)
-      else
-        Origen.log.info((' ' * @indent) + msg)
-      end
-    end
-
-    def c1(msg, options = {})
-      if generating_program?
-        Origen.interface.doc_comments_capture(msg)
-      else
-        unless @inhibit_comments
-          options = {
-            prefix: true
-          }.merge(options)
-          if @step_comment_on
-            open_text_block
-            if options[:prefix]
-              pc "# #{msg}"
-            else
-              pc "#{msg}"
-            end
-          end
-        end
-      end
-    end
-
-    def c2(msg, options = {})
-      unless @inhibit_comments
-        options = {
-          prefix: true
-        }.merge(options)
-        open_text_block
-        if options[:prefix]
-          pc "# #{msg}"
-        else
-          pc "#{msg}"
-        end
-      end
-    end
-
-    def annotate(msg, _options)
-      unless @inhibit_comments
-        if html_mode
-          pc ''
-          lines = msg.split("\n")
-          leading_spaces = lines.first[/\A */].size
-          lines.each do |line|
-            pc line.gsub(/^.{#{leading_spaces}}/, '')
-          end
-          pc ''
-        end
-      end
-    end
-
-    def open_text_block
-      if html_mode
-        unless @text_block_open
-          pc ''
-          pc '~~~text'
-          @text_block_open = true
-        end
-      end
-    end
-
-    def close_text_block
-      if html_mode
-        if @text_block_open
-          pc '~~~'
-          pc ''
-          @text_block_open = false
-        end
-      end
-    end
-
-    def pattern_name
-      Origen.app.current_job.output_pattern_filename.gsub('.md', '')
-    end
-
-    def pre_header
-      # pc "---"
-      # pc "layout: bootstrap"
-      # pc "title: #{pattern_name}"
-      # pc "gzip: false"
-      # pc "---"
-      # pc ""
-      # pc "# #{pattern_name}"
-      # pc ""
-    end
-
-    def pattern_section(msg)
-      unless @inhibit_comments
-        if generating_program?
-          Origen.interface.flow.start_section(name: msg)
-          yield
-          Origen.interface.flow.stop_section
-        else
-          if html_mode
-            counter = next_accordion_counter
-            close_text_block
-            pc ''
-            pc "<div class=\"accordion-group\">"
-            pc "<div class=\"accordion-heading\">"
-            pc "<a class=\"accordion-toggle\" data-toggle=\"collapse\" data-parent=\"#accordion2\" href=\"#collapseComment#{counter}\">"
-            pc "#{msg}"
-            pc '</a>'
-            pc '</div>'
-            pc "<div id=\"collapseComment#{counter}\" class=\"accordion-body collapse\">"
-            pc "<div class=\"accordion-inner\" markdown=\"1\">"
-            yield
-            close_text_block
-            pc '</div>'
-            pc '</div>'
-            pc '</div>'
-          else
-            pc ''
-            pc "#{msg}"
-            pc ''
-            @indent += 4
-            yield
-            @indent -= 4
-          end
-        end
-      end
-    end
-
-    def next_accordion_counter
-      @accordion_counter ||= 0
-      @accordion_counter += 1
-    end
-
-    def ss(msg = nil)
-      unless @inhibit_comments
-        @step_comment_on = true
-        if block_given?
-          yield
-        else
-          c2(msg)
-        end
-        @step_comment_on = false
-      end
-    end
-
-    def self.generate_program_model(files, options = {})
-      options = {
-        action:       :program,
-        return_model: true,
-        skip_diff:    true
-      }.merge(options)
-      Origen.app.with_doc_tester do
-        Origen.target.temporary = options[:target] if options[:target]
-        Origen.app.load_target!
-        Origen.interface.reset_globals
-        options[:files] = files
-        Origen.file_handler.preserve_and_clear_state do
-          Origen.app.runner.launch(options)
-        end
-      end
-      model.target = Origen.target.name
-      model
-    end
-
-    def self.model
-      @model ||= Model.new
-    end
-
-    def doc?
-      true
-    end
-
-    def cycle(_options = {})
-    end
-
-    # Ignore any tester-specific methods
-    def method_missing(_method, *_args, &_block)
-      if block_given?
-        yield
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/generator.rb

@@ -1,124 +0,0 @@
-require 'active_support/concern'
-
-module OrigenTesters
-  class Doc
-    module Generator
-      extend ActiveSupport::Concern
-
-      autoload :Test,  'origen_testers/doc/generator/test'
-      autoload :TestGroup,  'origen_testers/doc/generator/test_group'
-      autoload :Tests, 'origen_testers/doc/generator/tests'
-      autoload :Flow,  'origen_testers/doc/generator/flow'
-      autoload :FlowLine,  'origen_testers/doc/generator/flow_line'
-      autoload :Placeholder, 'origen_testers/generator/placeholder'
-
-      included do
-        include OrigenTesters::Interface  # adds the interface helpers/Origen hook-up
-        include OrigenTesters::Generator::FlowControlAPI::Interface
-        PLATFORM = OrigenTesters::Doc
-      end
-
-      # Returns the current flow (as defined by the name of the current top
-      # level flow source file).
-      #
-      # Pass in a filename argument to have a specific flow returned instead.
-      #
-      # If the flow does not exist yet it will be created.
-      def flow(filename = nil)
-        unless filename
-          if Origen.file_handler.current_file
-            filename = Origen.file_handler.current_file.basename('.rb').to_s
-          else
-            filename = 'anonymous'
-          end
-        end
-        f = filename.to_sym
-        return flows[f] if flows[f]
-        p = Flow.new
-        p.inhibit_output if Origen.interface.resources_mode?
-        p.filename = f
-        flows[f] = p
-      end
-
-      # @api private
-      def at_flow_start
-      end
-
-      # @api private
-      def at_run_start
-        flow.at_run_start
-        @@tests = nil
-        @@flows = nil
-      end
-      alias_method :reset_globals, :at_run_start
-
-      # Returns a container for all generated tests.
-      def tests
-        @@tests ||= Tests.new
-      end
-      alias_method :test_instances, :tests
-
-      # Returns a hash containing all flows
-      def flows
-        @@flows ||= {}
-      end
-
-      # Returns an array containing all sheet generators where a sheet generator is a flow,
-      # test instance, patset or pat group sheet.
-      # All Origen program generators must implement this method
-      def sheet_generators # :nodoc:
-        g = []
-        [flows].each do |sheets|
-          sheets.each do |_name, sheet|
-            g << sheet
-          end
-        end
-        g
-      end
-
-      # Returns an array containing all flow generators.
-      # All Origen program generators must implement this method
-      def flow_generators
-        g = []
-        flows.each do |_name, sheet|
-          g << sheet
-        end
-        g
-      end
-
-      # The source of all program files is passed in here before executing.
-      # This will replace all comments with a method call containing the comment so that
-      # they can be captured.
-      def filter_source(source) # :nodoc:
-        src = ''
-        source.split(/\r?\n/).each do |line|
-          if line !~ /^\s*#-/ && line =~ /^\s*#(.*)/
-            comment = Regexp.last_match[1].gsub("'", "\\\\'")
-            src << "Origen.interface.doc_comments_capture('#{comment}')\n"
-          else
-            src << "#{line}\n"
-          end
-        end
-        src
-      end
-
-      def doc_comments_capture(comment)
-        doc_comments << "#{comment}"
-      end
-
-      def doc_comments
-        @doc_comments ||= []
-      end
-
-      def doc_comments_consume
-        c = doc_comments
-        doc_comments_discard
-        c
-      end
-
-      def doc_comments_discard
-        @doc_comments = []
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/generator/flow.rb

@@ -1,69 +0,0 @@
-module OrigenTesters
-  class Doc
-    module Generator
-      class Flow
-        include OrigenTesters::Generator
-        include OrigenTesters::Generator::FlowControlAPI
-
-        OUTPUT_POSTFIX = 'flow'
-        OUTPUT_EXTENSION = 'yaml'
-
-        def add(type, options = {})
-          preserve_comments = options.delete(:preserve_comments)
-          line = track_relationships(options) do |options|
-            FlowLine.new(type, options)
-          end
-          collection << line unless Origen.interface.resources_mode?
-          if preserve_comments
-            line.description = Origen.interface.doc_comments
-          else
-            line.description = Origen.interface.doc_comments_consume
-          end
-          line
-        end
-
-        def start_section(options = {})
-          l = FlowLine.new(:section_start, options)
-          if options[:name]
-            desc = [options[:name]]
-          else
-            desc = []
-          end
-          l.description = desc + Origen.interface.doc_comments_consume
-          collection << l
-        end
-
-        def stop_section(options = {})
-          collection << FlowLine.new(:section_stop, options)
-        end
-
-        def test(instance, options = {})
-          options = save_context(options)
-          add(:test, { test: instance }.merge(options))
-        end
-
-        def set_device(options = {})
-          add(:set_device, options)
-        end
-
-        def to_yaml(options = {})
-          collection.map { |l| l.to_yaml(options) }
-        end
-
-        def render(file, options = {})
-          options[:file] = file
-          add(:render, options)
-        end
-
-        def skip(identifier = nil, options = {})
-          identifier, options = nil, identifier if identifier.is_a?(Hash)
-          identifier = generate_unique_label(identifier)
-          options[:test] = identifier
-          add(:branch, options)
-          yield
-          add(:label, test: identifier)
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/generator/flow_line.rb

@@ -1,201 +0,0 @@
-module OrigenTesters
-  class Doc
-    module Generator
-      class FlowLine
-        attr_accessor :type, :id, :test, :context, :attributes, :description
-
-        def initialize(type, attrs = {})
-          @type = type
-          @test = attrs.delete(:test)
-          @context = {}
-          @attributes = {}
-          flow_control_options = Origen.interface.extract_flow_control_options!(attrs)
-          flow_control_options.each do |opt, val|
-            send("#{opt}=", val)
-          end
-          attrs.each do |attribute, val|
-            @attributes[attribute] = val
-          end
-        end
-
-        def to_yaml(options = {})
-          options = {
-            include_descriptions: true
-          }.merge(options)
-          y = {
-            'type'        => @type,
-            'description' => description,
-            'instance'    => test_to_yaml(options),
-            'flow'        => {
-              'attributes' => attributes_to_yaml(options),
-              'context'    => context_to_yaml(options)
-            }
-          }
-          y.delete('description') unless options[:include_descriptions]
-          y
-        end
-
-        def attributes_to_yaml(_options = {})
-          a = {}
-          @attributes.each do |name, val|
-            a[name.to_s] = val if val
-          end
-          a
-        end
-
-        def context_to_yaml(_options = {})
-          # Turn attribute keys into strings for prettier yaml, this includes all
-          # relationship meta data
-          c = @context.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
-          # Now add job/enable word data
-          if @enable
-            c['if_enable'] = @enable
-          end
-          if @unless_enable
-            c['unless_enable'] = @unless_enable
-          end
-          unless if_jobs.empty?
-            c['if_jobs'] = if_jobs
-          end
-          unless unless_jobs.empty?
-            c['unless_jobs'] = unless_jobs
-          end
-          c
-        end
-
-        def test_to_yaml(options = {})
-          if @test
-            if @test.is_a?(String) || @test.is_a?(Symbol)
-              {
-                'attributes' => {
-                  'name' => @test.to_s
-                }
-              }
-            else
-              @test.to_yaml(options)
-            end
-          end
-        end
-
-        def method_missing(method, *args, &_block)
-          method = method.to_s
-          if method.gsub!('=', '')
-            @attributes[method] = args.first
-          else
-            @attributes[method]
-          end
-        end
-
-        def job
-          if !if_jobs.empty? && !unless_jobs.empty?
-            fail "Both if and unless jobs have been defined for test: #{parameter}"
-          elsif !if_jobs.empty?
-            if_jobs.join(',')
-          elsif !unless_jobs.empty?
-            unless_jobs.map { |j| "!#{j}" }.join(',')
-          else
-            ''
-          end
-        end
-        alias_method :jobs, :job
-
-        def if_jobs
-          @if_jobs ||= []
-        end
-
-        def unless_jobs
-          @unless_jobs ||= []
-        end
-
-        def if_enable=(val)
-          @enable = val
-        end
-        alias_method :enable=, :if_enable=
-        alias_method :if_enabled=, :if_enable=
-
-        def unless_enable=(val)
-          @unless_enable = val
-        end
-        alias_method :unless_enabled=, :unless_enable=
-
-        def if_job=(jobs)
-          [jobs].flatten.compact.each do |job|
-            job = job.to_s.upcase
-            if job =~ /!/
-              self.unless_job = job
-            else
-              if_jobs << job unless if_jobs.include?(job)
-            end
-          end
-        end
-        alias_method :if_jobs=, :if_job=
-        alias_method :add_if_jobs, :if_job=
-        alias_method :add_if_job, :if_job=
-
-        def unless_job=(jobs)
-          [jobs].flatten.compact.each do |job|
-            job = job.to_s.upcase
-            job.gsub!('!', '')
-            unless_jobs << job unless unless_jobs.include?(job)
-          end
-        end
-        alias_method :unless_jobs=, :unless_job=
-        alias_method :add_unless_jobs, :unless_job=
-        alias_method :add_unless_job, :unless_job=
-
-        def run_if_failed(id)
-          @context[:if_failed] = id
-        end
-
-        def run_if_passed(id)
-          @context[:if_passed] = id
-        end
-
-        def run_if_ran(id)
-          @context[:if_ran] = id
-        end
-
-        def run_unless_ran(id)
-          @context[:unless_ran] = id
-        end
-
-        def run_if_any_passed(parent)
-          @context[:if_any_passed] = parent.id
-        end
-
-        def run_if_all_passed(parent)
-          @context[:if_all_passed] = parent.id
-        end
-
-        def run_if_any_failed(parent)
-          @context[:if_any_failed] = parent.id
-        end
-
-        def run_if_all_failed(parent)
-          @context[:if_all_failed] = parent.id
-        end
-
-        def continue_on_fail
-          @attributes[:continue] = true
-        end
-
-        def id
-          @id || "#{parameter}_#{unique_counter}"
-        end
-
-        def unique_counter
-          @unique_counter ||= self.class.unique_counter
-        end
-
-        def self.unique_counter
-          @ix ||= -1
-          @ix += 1
-        end
-
-        def test?
-          @type == :test
-        end
-      end
-    end
-  end
-end