dim-toolkit 2.1.0

data/lib/dim/exporter/csv.rb

@@ -0,0 +1,25 @@
+require_relative '../globals'
+require_relative '../requirement'
+
+module Dim
+  class Csv < ExporterInterface
+    EXPORTER['csv'] = self
+
+    def header(content)
+      @keys = @loader.all_attributes.keys
+      @keys.delete('test_setups')
+      content.puts 'Sep=,'
+      content.puts "id,document_name,originator,#{@keys.join(',')}"
+    end
+
+    def requirement(content, req)
+      vals = [req.id, req.document, req.origin]
+      @keys.each { |k| vals << req.data[k] }
+      # These values will never be nil.
+      # ID cannot be nil in Dim file, so as origin (default is "") and
+      # document cannot be missing in Dim files.
+      # Which leaves with data and YAML file cannot define nil value.
+      content.puts(vals.map { |a| "\"#{a.gsub('"', '""')}\"" }.join(','))
+    end
+  end
+end

data/lib/dim/exporter/exporterInterface.rb

@@ -0,0 +1,37 @@
+module Dim
+  # This is how the interface is used by the Dim::Export:
+  #
+  # initialize()
+  #
+  # for every module:
+  #   header()
+  #   document()
+  #   metadata()
+  #   for every requirement in module:
+  #     requirement()
+  #   footer()
+  #
+  # if hasIndex:
+  #   for every originator/category combination:
+  #     index()
+  class ExporterInterface
+    attr_reader :hasIndex
+
+    def initialize(loader)
+      @hasIndex = false
+      @loader = loader
+    end
+
+    def header(f); end
+
+    def document(f, name); end
+
+    def metadata(f, metadata); end
+
+    def requirement(f, r); end
+
+    def footer(f); end
+
+    def index(f, category, origin, modules); end
+  end
+end

data/lib/dim/exporter/json.rb

@@ -0,0 +1,32 @@
+require 'json'
+
+require_relative '../globals'
+require_relative '../requirement'
+
+module Dim
+  class Json < ExporterInterface
+    EXPORTER['json'] = self
+
+    def header(_f)
+      @content = []
+    end
+
+    def requirement(_f, r)
+      vals = { 'id' => r.id, 'document_name' => r.document, 'originator' => r.origin }
+
+      @loader.all_attributes.keys.each do |k|
+        next if k == 'test_setups'
+
+        v = r.data[k]
+        v = v.cleanUniqArray.join(',') if k == 'refs'
+        vals[k] = v.strip
+      end
+
+      @content << vals
+    end
+
+    def footer(f)
+      f.puts(JSON.pretty_generate(@content))
+    end
+  end
+end

data/lib/dim/exporter/rst.rb

@@ -0,0 +1,142 @@
+require 'json'
+
+module Dim
+  class Rst < ExporterInterface
+    EXPORTER['rst'] = self
+
+    def initialize(loader)
+      super(loader)
+      @hasIndex = true
+    end
+
+    def document(f, name)
+      raw_html_name = ':raw-html:`' + name + '`'
+      f.puts raw_html_name
+      f.puts '=' * raw_html_name.length
+      @lastHeadingLevel = 0
+      @moduleName = name
+    end
+
+    def metadata(f, meta)
+      f.puts ''
+      f.puts html(meta.strip.escape_html, with_space: false)
+    end
+
+    def level2char(level)
+      { 0 => '=',
+        1 => '-',
+        2 => '+',
+        3 => '~',
+        4 => '^',
+        5 => '"' }.fetch(level, '"')
+    end
+
+    def html(elem, with_space: true)
+      return if elem.empty?
+
+      with_space ? " :raw-html:`#{elem}`" : ":raw-html:`#{elem}`"
+    end
+
+    def handle_empty_value(value)
+      return '' if value.empty?
+
+      ' ' + (value.is_a?(Array) ? value.join(', ') : value)
+    end
+
+    def createMultiLanguageElement(r, name)
+      lang_elems = r.data.keys.select { |k| k.start_with?("#{name}_") && !r.data[k].empty? }.sort
+      if lang_elems.empty?
+        return r.data[name].empty? ? '' : r.data[name]
+      end
+
+      str = (r.data[name].empty? ? '-' : r.data[name])
+      lang_elems.each do |l|
+        str << "<br><br><b>#{l.split('_').map(&:capitalize).join(' ')}: </b>"
+        str << r.data[l]
+      end
+      str
+    end
+
+    def requirement(f, r)
+      r.data.each { |k, v| r.data[k] = v.strip.escape_html }
+
+      if r.data['type'].start_with?('heading')
+        (@lastHeadingLevel + 1...r.depth).each do |l|
+          str = '<Skipped Heading Level>'
+          f.puts ''
+          f.puts str
+          f.puts level2char(l) * str.length
+        end
+        f.puts ''
+        str = ':raw-html:`' + r.data['text'] + '`'
+        f.puts str
+        f.puts level2char(r.depth) * str.length
+        @lastHeadingLevel = r.depth
+        return
+      end
+
+      r.data['tester'].gsub!('<br>', ' ')
+      r.data['developer'].gsub!('<br>', ' ')
+      text = createMultiLanguageElement(r, 'text')
+      comment = createMultiLanguageElement(r, 'comment')
+      refs = r.data['refs'].cleanUniqArray.select do |ref|
+        !@loader.requirements.has_key?(ref) || !@loader.requirements[ref].type.start_with?('heading')
+      end
+      tags = r.data['tags'].cleanUniqString
+      sources = r.data['sources'].cleanUniqString
+
+      f.puts ''
+      f.puts ".. #{r.data['type']}:: #{r.id}"
+      f.puts "    :category: #{r.category}"
+      f.puts "    :status: #{r.data['status']}"
+      f.puts "    :review_status: #{r.data['review_status']}"
+      f.puts "    :asil: #{r.data['asil']}"
+      f.puts "    :cal: #{r.data['cal']}"
+      f.puts "    :tags:#{handle_empty_value(tags)}"
+      f.puts "    :comment:#{html(comment)}"
+      f.puts "    :miscellaneous:#{html(r.data['miscellaneous'])}"
+      f.puts "    :refs:#{handle_empty_value(refs)}"
+      @loader.custom_attributes.each_key do |custom_attribute|
+        f.puts "    :#{custom_attribute}:#{handle_empty_value(r.data[custom_attribute])}"
+      end
+      if r.data['type'] == 'requirement'
+        vc = createMultiLanguageElement(r, 'verification_criteria')
+
+        f.puts "    :sources:#{handle_empty_value(sources)}"
+        f.puts "    :feature:#{html(r.data['feature'])}"
+        f.puts "    :change_request:#{html(r.data['change_request'])}"
+        f.puts "    :developer:#{handle_empty_value(r.data['developer'])}"
+        f.puts "    :tester:#{handle_empty_value(r.data['tester'])}"
+        f.puts "    :verification_methods:#{handle_empty_value(r.data['verification_methods'])}"
+        f.puts "    :verification_criteria:#{html(vc)}"
+      end
+
+      f.puts "\n   #{html(text)}" unless text.empty?
+    end
+
+    def footer(f)
+      files = @loader.module_data[@moduleName][:files].values.flatten
+      return if files.empty?
+
+      f.puts ''
+      f.puts '.. enclosed::'
+      f.puts ''
+      files.each do |file|
+        f.puts "    #{file}"
+      end
+    end
+
+    def index(f, category, origin, modules)
+      caption = category.capitalize + ' (' + origin + ')'
+      f.puts caption
+      f.puts '=' * caption.length
+      f.puts ''
+      f.puts '.. toctree::'
+      f.puts '  :maxdepth: 1'
+      f.puts ''
+      modules.sort.each do |m|
+        f.puts "  #{m.sanitize}/Requirements"
+      end
+    end
+  end
+end

data/lib/dim/ext/psych.rb

@@ -0,0 +1,63 @@
+require_relative '../exit_helper'
+
+module Dim
+  module Refinements
+    refine Psych::Nodes::Document do
+      def line_numbers
+        hash = {}
+        children[0].children.each do |node|
+          if node.is_a?(Psych::Nodes::Scalar)
+            hash[node.value] = node.start_line + 1
+          end
+        end
+        hash
+      end
+    end
+  end
+end
+
+module Psych
+  module Visitors
+    class ToRuby
+      alias revive_hash_org revive_hash
+
+      def patched_revive_hash(hash, o)
+        test_hash = {}
+        o.children.each_slice(2) do |k, _v|
+          key = accept(k)
+          if test_hash.has_key?(key)
+            line = "line #{k.start_line + 1}: "
+            Dim::ExitHelper.exit(code: 1, msg: "#{line}found \"#{key}\" twice which must be unique.")
+          end
+          test_hash[key] = k
+        end
+        revive_hash_org hash, o
+      end
+
+      def self.add_patch
+        alias revive_hash patched_revive_hash
+      end
+
+      def self.revert_patch
+        alias revive_hash revive_hash_org
+      end
+    end
+  end
+
+  module Nodes
+    class Scalar
+      alias initialize_org initialize
+      def quoted_initialize(value, anchor = nil, tag = nil, plain = true, _quoted = false, style = ANY)
+        initialize_org(value, anchor, tag, plain, true, style)
+      end
+
+      def self.add_patch
+        alias initialize quoted_initialize
+      end
+
+      def self.revert_patch
+        alias initialize initialize_org
+      end
+    end
+  end
+end

data/lib/dim/ext/string.rb

@@ -0,0 +1,85 @@
+class String
+  def cleanString
+    cleanArray.join(', ')
+  end
+
+  def cleanUniqString
+    cleanUniqArray.join(', ')
+  end
+
+  def cleanUniqArray
+    cleanArray.uniq
+  end
+
+  def cleanArray
+    cleanSplit.select { |s| !s.empty? }
+  end
+
+  def cleanSplit
+    split(/(?<!\\),/).map(&:strip)
+  end
+
+  def addEnum(e)
+    replace((cleanArray << e).uniq.join(', '))
+  end
+
+  def removeEnum(e)
+    arr = cleanArray
+    arr.delete(e)
+    replace(arr.join(', '))
+  end
+
+  def escapeHtmlOutside
+    gsub(/&(?!(amp|lt|gt|quot|apos|emsp);)/, '&amp;')
+      .gsub('<',  '&lt;')
+      .gsub('>',  '&gt;')
+      .gsub('"', '&quot;')
+      .gsub("'",  '&apos;')
+      .gsub("\t", '&emsp;')
+      .gsub("\n", '<br>')
+      .gsub('`', '&#96;')
+      .gsub(/(?<= ) /, '&nbsp')
+  end
+
+  def escape_html_inside
+    gsub('`', '&#96;')
+      .gsub("\t", '&emsp;')
+      .gsub("\n", ' ')
+  end
+
+  def get_next_escape_token(pos)
+    ind = index(%r{<\s*(\/?)\s*html\s*>}, pos)
+    return [:none, length - pos, -1] if ind.nil?
+
+    type = Regexp.last_match(1).empty? ? :start : :end
+    [type, ind - pos, ind + Regexp.last_match(0).length]
+  end
+
+  def escape_html
+    str = ''
+    search_pos = 0
+    nested = 0
+    while true
+      next_token, token_pos, after_token_pos = get_next_escape_token(search_pos)
+      if nested == 0
+        str << self[search_pos, token_pos].escapeHtmlOutside
+        nested = 1 if next_token == :start
+      else
+        str << self[search_pos, token_pos].escape_html_inside
+        nested += (next_token == :start ? +1 : -1)
+      end
+      break if next_token == :none
+
+      search_pos = after_token_pos
+    end
+    str.strip
+  end
+
+  def sanitize
+    gsub(/[^a-zA-Z0-9.\-_]/, '_')
+  end
+
+  def universal_newline
+    encode(encoding, universal_newline: true)
+  end
+end

data/lib/dim/globals.rb

@@ -0,0 +1,12 @@
+OPTIONS ||= {}
+SUBCOMMANDS ||= {}
+EXPORTER ||= {}
+CATEGORY_ORDER = {
+  'input' => 1,
+  'system' => 2,
+  'software' => 3,
+  'architecture' => 4,
+  'module' => 5,
+}.freeze
+ALLOWED_CATEGORIES = CATEGORY_ORDER.keys.each_with_object({}) { |k, obj| obj[k.to_sym] = k }.freeze
+SRS_NAME_REGEX = /[^a-zA-Z0-9-]+/.freeze

data/lib/dim/helpers/attribute_helper.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'file_helper'
+
+module Dim
+  module Helpers
+    module AttributeHelper
+      include FileHelper
+
+      CHECK_SINGLE_ENUM = :check_single_enum
+      CHECK_MULTI_ENUM = :check_multi_enum
+      FORMAT_STYLES = {
+        'list' => 'list',
+        'multi' => 'multi',
+        'single' => 'single',
+        'split' => 'split',
+        'text' => 'text'
+      }.freeze
+      @filepath = ''
+
+      def resolve_attributes(folder:, filename:)
+        @filepath = "#{folder}/#{filename}"
+        attributes = open_yml_file(folder, filename, allow_empty_file: true)
+        unless attributes
+          puts "Warning: empty file detected; skipped loading of #{filename}"
+          return
+        end
+
+        check_for_default_attributes(attributes, filename)
+
+        attributes.each do |attribute, attr_config|
+          attr_config.transform_keys!(&:to_sym)
+
+          change_type_to_format_style(attr_config)
+          validate_format_style(attribute, attr_config)
+          add_check_value(attr_config)
+          validate_default(attribute, attr_config)
+          validate_allowed(attribute, attr_config)
+          validate_allowed_for_enum(attribute, attr_config)
+          validate_default_for_enum(attribute, attr_config)
+
+          symbolize_values(attr_config)
+        end
+
+        attributes
+      end
+
+      def check_for_default_attributes(attributes, filename)
+        common_values = Requirement::SYNTAX.keys & attributes.keys
+        return if common_values.empty?
+
+        Dim::ExitHelper.exit(
+          code: 1,
+          filename: @filepath,
+          msg: 'Defining standard attributes as a custom attributes is not allowed; ' \
+               "#{common_values.join(',')} in #{filename}"
+        )
+      end
+
+      # TODO: change "format_style" to "type" in requirements syntax and then remove this conversion
+      def change_type_to_format_style(config)
+        config[:format_style] = config.delete(:type)
+      end
+
+      def validate_format_style(attribute, config)
+        return if FORMAT_STYLES.values.include?(config[:format_style])
+
+        exit_with_error(config: 'type', config_value: config[:format_style], attribute: attribute)
+      end
+
+      def add_check_value(config)
+        config[:check] = CHECK_SINGLE_ENUM if config[:format_style] == FORMAT_STYLES['single']
+        config[:check] = CHECK_MULTI_ENUM if config[:format_style] == FORMAT_STYLES['multi']
+      end
+
+      def validate_default(attribute, config)
+        return unless config[:default] == 'auto'
+
+        exit_with_error(config: 'default', config_value: config[:default], attribute: attribute)
+      end
+
+      def validate_allowed(attribute, config)
+        return if config[:allowed].nil? || config[:allowed].is_a?(Array)
+
+        exit_with_error(config: 'allowed', config_value: config[:allowed], attribute: attribute)
+      end
+
+      def validate_allowed_for_enum(attribute, config)
+        return unless FORMAT_STYLES.fetch_values('single', 'multi').include?(config[:format_style])
+
+        return if config[:allowed].is_a?(Array) && config[:allowed].map { |val| val.is_a?(String) }.all?
+
+        Dim::ExitHelper.exit(
+          code: 1,
+          filename: @filepath,
+          msg: "Allowed value must be list of strings; invalid allowed value for #{attribute}"
+        )
+      end
+
+      def validate_default_for_enum(attribute, config)
+        return unless FORMAT_STYLES.fetch_values('single', 'multi').include?(config[:format_style])
+
+        return if config[:allowed].include?(config[:default])
+
+        Dim::ExitHelper.exit(
+          code: 1,
+          filename: @filepath,
+          msg: "default value for #{attribute} must be from allowed list of #{config[:allowed]}"
+        )
+      end
+
+      def symbolize_values(config)
+        config[:format_style] = config[:format_style].to_sym if config[:format_style]
+        config[:format_shift] = config[:format_shift].to_i
+        config[:default] = '' unless config[:default]
+      end
+
+      private
+
+      def exit_with_error(config:, config_value:, attribute:)
+        msg = "Invalid value \"#{config_value}\" for #{config} detected for attribute #{attribute}"
+        Dim::ExitHelper.exit(code: 1, filename: @filepath, msg: msg)
+      end
+    end
+  end
+end

data/lib/dim/helpers/file_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../exit_helper'
+
+module Dim::Helpers
+  module FileHelper
+    def open_yml_file(folder, filename, allow_empty_file: false)
+      file_path = Pathname.new(File.join(folder, filename)).cleanpath.to_s
+      binary_data = File.binread(file_path).chomp
+      begin
+        data = YAML.parse(
+          binary_data.encode('utf-8', invalid: :replace, undef: :replace, replace: '?'),
+          filename: file_path
+        )
+      rescue Psych::SyntaxError => e
+        Dim::ExitHelper.exit(code: 1, filename: filename, msg: e.message)
+      end
+
+      Dim::ExitHelper.exit(code: 1, filename: filename, msg: 'not a valid yaml file') unless data || allow_empty_file
+      return unless data
+
+      data.to_ruby
+    end
+  end
+end