origen 0.2.6 → 0.3.0

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

@@ -1,66 +0,0 @@
-module Origen
-  module Tester
-    class Doc
-      module Generator
-        class TestGroup
-          attr_accessor :name, :version, :append_version
-
-          include Enumerable
-
-          def initialize(name, _options = {})
-            @name = name
-            @store = []
-            @append_version = true
-          end
-
-          def name
-            if unversioned_name
-              if version && @append_version
-                "#{unversioned_name}_v#{version}"
-              else
-                unversioned_name.to_s
-              end
-            end
-          end
-
-          def to_yaml(options = {})
-            y = {}
-            y['group'] = @store.map { |t| t.to_yaml(options) }
-            y
-          end
-
-          def unversioned_name
-            if @name
-              if @name =~ /grp$/
-                @name
-              else
-                "#{@name}_grp"
-              end
-            end
-          end
-
-          def <<(instance)
-            @store << instance
-          end
-
-          def size
-            @store.size
-          end
-
-          def each
-            @store.each { |ins| yield ins }
-          end
-
-          def ==(other_instance_group)
-            self.class == other_instance_group.class &&
-              unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
-              size == other_instance_group.size &&
-              self.all? do |ins|
-                other_instance_group.any? { |other_ins| ins == other_ins }
-              end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Origen
-  module Tester
-    class Doc
-      module Generator
-        class Tests
-          attr_accessor :collection
-
-          def initialize
-            @collection = []
-          end
-
-          class IndexedString < ::String
-            attr_accessor :index
-
-            def name
-              self
-            end
-          end
-
-          def add(name, attrs = {})
-            test = Test.new(name, attrs)
-            if @current_group
-              @current_group << test
-            else
-              collection << test
-            end
-            test
-          end
-
-          # Arbitrarily group a subset of tests together, see the J750 API for details on how to use
-          # this.
-          def group(name = nil, options = {})
-            name, options = nil, name if name.is_a?(Hash)
-            @current_group = TestGroup.new(name, options)
-            collection << @current_group
-            yield @current_group
-            @current_group = nil
-          end
-          alias_method :add_group, :group
-
-          def render(_file, _options = {})
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-module Origen
-  module Tester
-    class Doc
-      # Class representing a program model, provides an API to iterate
-      # on the flow based on context (e.g. which job).
-      class Model
-        attr_accessor :flows, :target
-
-        def initialize
-          @flows = {}
-        end
-
-        # Iterates through each line in the given flow returning a hash for each
-        # line with the following structure:
-        #
-        #   {
-        #     :type => Symbol,     # Type of flow line
-        #     :description => [],  # Array of strings
-        #     :instance => [{}],   # Array of attributes hashes (each one represents an individual test instance)
-        #     :flow => {},         # Hash of attributes
-        #     :context => {},      # Hash of attributes
-        #   }
-        #
-        # In all cases if an item is missing then it will be replaced by an empty
-        # array or hash as appropriate so that the caller does not need to worry
-        # about this.
-        #
-        # Supply the name of the flow(s) to consider, if the flows argument is left
-        # out then all lines in all flows will be returned.
-        #
-        # A context option can be supplied to only return the tests for which the given
-        # context is true.
-        #
-        #   puts "The following tests run at FR:"
-        #   program_model.each_in_flow(:ft_flow, :context => { :job => "FR" }) do |line|
-        #     puts "  #{line[:flow][:name]}"
-        #   end
-        def each_in_flow(flows = nil, options = {})
-          if flows.is_a?(Hash)
-            options = flows
-            flows = nil
-          end
-          unless flows
-            flows = self.flows.keys
-          end
-          [flows].flatten.each do |flow|
-            @flows[flow.to_sym].each do |test|
-              test = format_test(test)
-              if valid_in_context?(test, options[:context])
-                yield test
-              end
-            end
-          end
-          nil
-        end
-
-        # Searches the given flows to find dependents of the given test id. The dependents
-        # are returned in arrays grouped by context:
-        #
-        #   {
-        #     :if_failed => [],
-        #     :if_passed => [],
-        #     :if_ran => [],
-        #     :unless_ran => [],
-        #   }
-        #
-        # Each test will have the same format as described in #each_in_flow.
-        #
-        # If no dependents are found an empty hash is returned.
-        def dependents_of(id, flows, options = {})
-          d = {}
-          each_in_flow(flows, options) do |test|
-            test[:context].each do |key, val|
-              if val == id
-                d[key] ||= []
-                d[key] << test
-              end
-            end
-          end
-          d
-        end
-
-        # Search for the given test id in the given flows.
-        # Returns nil if not found.
-        def find_by_id(id, flows, options = {})
-          each_in_flow(flows, options) do |test|
-            return test if test[:flow][:id] == id
-          end
-        end
-
-        # Returns true if the given tests id valid under the given context
-        # (currently only tests for job matching)
-        def valid_in_context?(test, context = nil)
-          if context && context[:job] && test[:context]
-            if test[:context][:if_jobs]
-              test[:context][:if_jobs].include?(context[:job])
-            elsif test[:context][:unless_jobs]
-              !test[:context][:unless_jobs].include?(context[:job])
-            else
-              true
-            end
-          else
-            true
-          end
-        end
-
-        # @api private
-        def format_test(test, _options = {})
-          {
-            type:        test[:type] ? test[:type].to_sym : :unknown,
-            description: test[:description] || [],
-            instance:    build_instance(test),
-            flow:        test[:flow] ? test[:flow][:attributes] || {} : {},
-            context:     test[:flow] ? test[:flow][:context] || {} : {}
-          }
-        end
-
-        # @api private
-        def build_instance(test)
-          if test[:instance]
-            if test[:instance][:group]
-              test[:instance][:group].map { |g| g[:attributes] || {} }
-            else
-              [test[:instance][:attributes] || {}]
-            end
-          else
-            [{}]
-          end
-        end
-
-        # YAML likes strings for keys, we don't, so make sure all keys are symbols
-        # when receiving a new flow
-        # @api private
-        def add_flow(name, content)
-          @flows[name.to_sym] = content.map do |h|
-            h = symbolize_keys h
-            if h[:instance] && h[:instance][:group]
-              h[:instance][:group] = h[:instance][:group].map { |j| symbolize_keys j }
-            end
-            h
-          end
-        end
-
-        # @api private
-        def symbolize_keys(hash)
-          hash.reduce({}) do |result, (key, value)|
-            new_key = case key
-                      when String then key.to_sym
-                      else key
-                      end
-            new_value = case value
-                        when Hash then symbolize_keys(value)
-                        else value
-                        end
-            result[new_key] = new_value
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/generator.rb

@@ -1,271 +0,0 @@
-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