origen 0.2.6 → 0.3.0

data/lib/origen/tester/doc/generator.rb

@@ -1,126 +0,0 @@
-require 'active_support/concern'
-
-module Origen
-  module Tester
-    class Doc
-      module Generator
-        extend ActiveSupport::Concern
-
-        autoload :Test,  'origen/tester/doc/generator/test'
-        autoload :TestGroup,  'origen/tester/doc/generator/test_group'
-        autoload :Tests, 'origen/tester/doc/generator/tests'
-        autoload :Flow,  'origen/tester/doc/generator/flow'
-        autoload :FlowLine,  'origen/tester/doc/generator/flow_line'
-        autoload :Placeholder, 'origen/tester/generator/placeholder'
-
-        included do
-          include Origen::Tester::Interface  # adds the interface helpers/Origen hook-up
-          include Origen::Tester::Generator::FlowControlAPI::Interface
-          PLATFORM = Origen::Tester::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
-end

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

@@ -1,71 +0,0 @@
-module Origen
-  module Tester
-    class Doc
-      module Generator
-        class Flow
-          include Origen::Tester::Generator
-          include Origen::Tester::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
-end

data/lib/origen/tester/doc/generator/flow_line.rb

@@ -1,203 +0,0 @@
-module Origen
-  module Tester
-    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
-end

data/lib/origen/tester/doc/generator/test.rb

@@ -1,68 +0,0 @@
-module Origen
-  module Tester
-    class Doc
-      module Generator
-        class Test
-          attr_accessor :name, :index, :version, :append_version, :attributes
-
-          def initialize(name, attrs = {})
-            attrs = {}.merge(attrs)  # Important to keep this to clone the original options
-            # so that the caller's copy if not affected by stripping
-            # out the flow/relation options
-            @attributes = {}
-            @append_version = true
-            self.name = name
-            Origen.interface.extract_relation_options!(attrs)
-            Origen.interface.extract_flow_control_options!(attrs)
-            attrs.each do |attribute, val|
-              @attributes[attribute] = val
-            end
-          end
-
-          def to_yaml(options = {})
-            {
-              'attributes' => attributes_to_yaml(options)
-            }
-          end
-
-          def attributes_to_yaml(_options = {})
-            a = {}
-            @attributes.each do |name, val|
-              a[name.to_s] = val if val
-            end
-            a['name'] = name
-            a
-          end
-
-          def method_missing(method, *args, &_block)
-            method = method.to_s
-            if method.gsub!('=', '')
-              @attributes[method] = args.first
-            else
-              @attributes[method]
-            end
-          end
-
-          def ==(other_test)
-            self.class == other_test.class &&
-              unversioned_name.to_s == other_test.unversioned_name.to_s &&
-              attributes.size == other_test.attributes.size &&
-              attributes.all? { |name, val| other_test.attributes[name] == val }
-          end
-
-          def name
-            if version && @append_version
-              "#{@name}_v#{version}"
-            else
-              @name.to_s
-            end
-          end
-
-          def unversioned_name
-            @name.to_s
-          end
-        end
-      end
-    end
-  end
-end