strictdoc 0.6.0__tar.gz → 0.6.1a1__tar.gz

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictdoc
-Version: 0.6.0
+Version: 0.6.1a1
 Summary: StrictDoc is open-source software for technical documentation and requirements management.
 Project-URL: Changelog, https://github.com/strictdoc-project/strictdoc/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://strictdoc.readthedocs.io/en/stable/

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.6.0"
+__version__ = "0.6.1a1"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/backend/sdoc/models/node.py

@@ -262,6 +262,9 @@ class SDocNode(SDocObject):
     def is_requirement(self) -> bool:
         return True
 
+    def is_normative_node(self) -> bool:
+        return not self.is_text_node()
+
     def is_text_node(self) -> bool:
         return self.node_type == "TEXT"
 

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/backend/sdoc/models/section.py

@@ -130,6 +130,12 @@ class SDocSection(SDocObject):
     def is_section(self):
         return True
 
+    def has_any_text_nodes(self):
+        return any(
+            not node_.is_section and node_.node_type == "TEXT"
+            for node_ in self.section_contents
+        )
+
     @property
     def is_root(self) -> bool:
         return self.document.config.root is True

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/core/file_traceability_index.py

@@ -50,7 +50,7 @@ class FileTraceabilityIndex:
 
         # This is only public non-static functions from languages like C.
         self.map_all_function_names_to_definition_functions: Dict[
-            str, Function
+            str, List[Function]
         ] = {}
 
         # "file.py" -> (
@@ -241,70 +241,77 @@ class FileTraceabilityIndex:
                     and function_.name
                     in self.map_all_function_names_to_definition_functions
                 ):
-                    definition_function: Optional[Function]
+                    definition_functions: List[Function] = []
                     if not function_.is_public():
                         definition_function = traceability_info_.ng_map_names_to_definition_functions.get(
-                            function_.name
+                            function_.name, None
                         )
+                        if definition_function is not None:
+                            definition_functions.append(definition_function)
                     else:
-                        definition_function = (
+                        mapped_definition_functions = (
                             self.map_all_function_names_to_definition_functions[
                                 function_.name
                             ]
                         )
-                    if definition_function is None:
+                        definition_functions.extend(mapped_definition_functions)
+                    if len(definition_functions) == 0:
                         continue
-                    definition_function_trace_info: SourceFileTraceabilityInfo = definition_function.parent
 
-                    for marker_ in function_.markers:
-                        function_marker = ForwardFunctionRangeMarker(
-                            parent=None,
-                            reqs_objs=marker_.reqs_objs,
-                            scope="function",
-                        )
-                        function_marker.ng_source_line_begin = (
-                            definition_function.line_begin
-                        )
-                        function_marker.ng_source_column_begin = 1
-                        function_marker.ng_range_line_begin = (
-                            definition_function.line_begin
-                        )
-                        function_marker.ng_range_line_end = (
-                            definition_function.line_end
-                        )
-                        function_marker.ng_marker_line = (
-                            definition_function.line_begin
-                        )
-                        function_marker.ng_marker_column = 1
-                        function_marker.set_description(
-                            f"function {function_.display_name}"
-                        )
+                    for definition_function_ in definition_functions:
+                        definition_function_trace_info: SourceFileTraceabilityInfo = definition_function_.parent
 
-                        for req_uid_ in marker_.reqs:
-                            markers = definition_function_trace_info.ng_map_reqs_to_markers.setdefault(
-                                req_uid_, []
+                        for marker_ in function_.markers:
+                            function_marker = ForwardFunctionRangeMarker(
+                                parent=None,
+                                reqs_objs=marker_.reqs_objs,
+                                scope="function",
                             )
-                            markers.append(function_marker)
-
-                            path_to_info = reversed_trace_info[
-                                definition_function_trace_info
-                            ]
-                            self.map_reqs_uids_to_paths.setdefault(
-                                req_uid_, OrderedSet()
+                            function_marker.ng_source_line_begin = (
+                                definition_function_.line_begin
                             )
-                            self.map_reqs_uids_to_paths[req_uid_].add(
-                                path_to_info
+                            function_marker.ng_source_column_begin = 1
+                            function_marker.ng_range_line_begin = (
+                                definition_function_.line_begin
                             )
-
-                            node = traceability_index.get_node_by_uid(req_uid_)
-                            self.map_paths_to_reqs.setdefault(
-                                path_to_info, OrderedSet()
+                            function_marker.ng_range_line_end = (
+                                definition_function_.line_end
+                            )
+                            function_marker.ng_marker_line = (
+                                definition_function_.line_begin
+                            )
+                            function_marker.ng_marker_column = 1
+                            function_marker.set_description(
+                                f"function {function_.display_name}"
                             )
-                            self.map_paths_to_reqs[path_to_info].add(node)
 
-                        definition_function_trace_info.markers.append(
-                            function_marker
-                        )
+                            for req_uid_ in marker_.reqs:
+                                markers = definition_function_trace_info.ng_map_reqs_to_markers.setdefault(
+                                    req_uid_, []
+                                )
+                                markers.append(function_marker)
+
+                                path_to_info = reversed_trace_info[
+                                    definition_function_trace_info
+                                ]
+                                self.map_reqs_uids_to_paths.setdefault(
+                                    req_uid_, OrderedSet()
+                                )
+                                self.map_reqs_uids_to_paths[req_uid_].add(
+                                    path_to_info
+                                )
+
+                                node = traceability_index.get_node_by_uid(
+                                    req_uid_
+                                )
+                                self.map_paths_to_reqs.setdefault(
+                                    path_to_info, OrderedSet()
+                                )
+                                self.map_paths_to_reqs[path_to_info].add(node)
+
+                            definition_function_trace_info.markers.append(
+                                function_marker
+                            )
 
         for (
             traceability_info_
@@ -440,14 +447,13 @@ class FileTraceabilityIndex:
             marker_type: RangeMarkerType
 
             if FunctionAttribute.DEFINITION in function_.attributes:
-                assert (
-                    function_.name
-                    not in self.map_all_function_names_to_definition_functions
-                ), function_.name
                 if function_.is_public():
+                    self.map_all_function_names_to_definition_functions.setdefault(
+                        function_.name, []
+                    )
                     self.map_all_function_names_to_definition_functions[
                         function_.name
-                    ] = function_
+                    ].append(function_)
 
             if (
                 source_file.in_doctree_source_file_rel_path_posix

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/core/query_engine/query_object.py

@@ -265,4 +265,4 @@ class QueryObject:
                 f"Section objects, got: {node.__class__.__name__}. To fix "
                 f"the error, prepend your query with node.is_section."
             )
-        return len(node.free_texts) > 0
+        return node.has_any_text_nodes()

strictdoc-0.6.1a1/strictdoc/export/html/_static/controllers/autocompletable_field_controller.js

@@ -0,0 +1,297 @@
+// MIT License
+//
+// based on https://github.com/afcapel/stimulus-autocomplete/
+// Copyright (c) 2021 Alberto Fernández-Capel
+
+const optionSelector = "[role='option']:not([aria-disabled])"
+const activeSelector = "[aria-selected='true']"
+
+Stimulus.register("autocompletable", class extends Controller {
+  static targets = ["name"]
+  static classes = ["selected"]
+  static values = {
+    ready: Boolean,
+    url: String,
+    minLength: Number,
+    delay: { type: Number, default: 300 },
+    queryParam: { type: String, default: "q" },
+  }
+  static uniqOptionId = 0
+  
+  connect() {
+    // this.element is the DOM element to which the controller is connected to.
+    const autocompletable = this.element
+    this.autocompletable = autocompletable
+    this.hidden = autocompletable.nextElementSibling
+    this.results = this.hidden.nextElementSibling
+    
+    this.close()
+
+    if(!autocompletable.hasAttribute("autocompletable")) autocompletable.setAttribute("autocompletable", "off")
+    autocompletable.setAttribute("spellcheck", "false")
+
+    this.mouseDown = false
+
+    this.onInputChange = debounce(this.onInputChange, this.delayValue)
+
+    autocompletable.addEventListener("keydown", (event) => {
+      const handler = this[`on${event.key}Keydown`]
+      if (handler) handler(event)
+    });
+
+    autocompletable.addEventListener("blur", (event) => {
+      if (this.mouseDown) return
+      this.close()   
+    });
+
+    autocompletable.addEventListener("input", (event) => {    
+      const query = autocompletable.innerText.trim()
+      if (query && query.length >= this.minLengthValue) {
+        this.fetchResults(query)
+      } else {
+        this.hideAndRemoveOptions()
+      }
+
+      const text = filterSingleLine(this.autocompletable.innerText) 
+      this.hidden.value = text
+    });
+
+    this.results.addEventListener("mousedown", this.onResultsMouseDown)
+    this.results.addEventListener("click", this.onResultsClick)
+
+    if (autocompletable.hasAttribute("autofocus")) {
+      autocompletable.focus()
+    }
+
+    this.readyValue = true
+  }
+
+  disconnect() {
+    this.autocompletable.removeEventListener("keydown", this.onKeydown)
+    this.autocompletable.removeEventListener("blur", this.onInputBlur)
+    this.autocompletable.removeEventListener("input", this.onInputChange)
+
+    this.results.removeEventListener("mousedown", this.onResultsMouseDown)
+    this.results.removeEventListener("click", this.onResultsClick)
+  }
+
+  sibling(next) {
+    console.group(this.options)
+    const options = this.options
+    const selected = this.selectedOption
+    const index = options.indexOf(selected)
+    const sibling = next ? options[index + 1] : options[index - 1]
+    const def = next ? options[0] : options[options.length - 1]
+    return sibling || def
+  }
+
+  select(target) {
+    const previouslySelected = this.selectedOption
+    if (previouslySelected) {
+      previouslySelected.removeAttribute("aria-selected")
+      previouslySelected.classList.remove(...this.selectedClassesOrDefault)
+    }
+
+    target.setAttribute("aria-selected", "true")
+    target.classList.add(...this.selectedClassesOrDefault)
+    this.autocompletable.setAttribute("aria-activedescendant", target.id)
+    target.scrollIntoView({ behavior: "auto", block: "nearest" })
+  }
+
+  onEscapeKeydown = (event) => {
+    if (!this.resultsShown) return
+
+    this.hideAndRemoveOptions()
+    event.stopPropagation()
+    event.preventDefault()
+  }
+
+  onArrowDownKeydown = (event) => {
+    const item = this.sibling(true)
+    if (item) this.select(item)
+    event.preventDefault()
+  }
+
+  onArrowUpKeydown = (event) => {
+    const item = this.sibling(false)
+    if (item) this.select(item)
+    event.preventDefault()
+  }
+
+  onTabKeydown = (event) => {
+    const selected = this.selectedOption
+    if (selected) this.commit(selected)
+  }
+
+  onEnterKeydown = (event) => {
+    const selected = this.selectedOption
+    if (selected && this.resultsShown) {
+      this.commit(selected)
+    }
+    /* single line, dont allow enter */
+    event.preventDefault()
+  }
+
+  commit(selected) {
+    if (selected.getAttribute("aria-disabled") === "true") return
+
+    if (selected instanceof HTMLAnchorElement) {
+      selected.click()
+      this.close()
+      return
+    }
+
+    const textValue = selected.getAttribute("data-autocompletable-label") || selected.textContent.trim()
+    const value = selected.getAttribute("data-autocompletable-value") || textValue
+    this.autocompletable.innerText = value
+
+    this.hidden.value = value
+    this.hidden.dispatchEvent(new Event("input"))
+    this.hidden.dispatchEvent(new Event("change"))
+
+    this.autocompletable.focus()
+    this.hideAndRemoveOptions()
+
+    this.element.dispatchEvent(
+      new CustomEvent("autocompletable.change", {
+        bubbles: true,
+        detail: { value: value, textValue: textValue, selected: selected }
+      })
+    )
+  }
+
+  clear() {
+    this.autocompletable.innerText = ""
+    this.hidden.value = ""
+  }
+
+  onResultsClick = (event) => {
+    if (!(event.target instanceof Element)) return
+    const selected = event.target.closest(optionSelector)
+    if (selected) this.commit(selected)
+  }
+
+  onResultsMouseDown = () => {
+    this.mouseDown = true
+    this.results.addEventListener("mouseup", () => {
+      this.mouseDown = false
+    }, { once: true })
+  }
+
+  identifyOptions() {
+    const prefix = this.results.id || "autocompletable"
+    const optionsWithoutId = this.results.querySelectorAll(`${optionSelector}:not([id])`)
+    optionsWithoutId.forEach(el => el.id = `${prefix}-option-${this.constructor.uniqOptionId++}`)
+  }
+
+  hideAndRemoveOptions() {
+    this.close()
+    this.results.innerHTML = null
+  }
+
+  fetchResults = async (query) => {
+    if (!this.hasUrlValue) return
+
+    const url = this.buildURL(query)
+    try {
+      this.element.dispatchEvent(new CustomEvent("loadstart"))
+      const html = await this.doFetch(url)
+      this.replaceResults(html)
+      this.element.dispatchEvent(new CustomEvent("load"))
+      this.element.dispatchEvent(new CustomEvent("loadend"))
+    } catch(error) {
+      this.element.dispatchEvent(new CustomEvent("error"))
+      this.element.dispatchEvent(new CustomEvent("loadend"))
+      throw error
+    }
+  }
+
+  buildURL(query) {
+    const url = new URL(this.urlValue, window.location.href)
+    const params = new URLSearchParams(url.search.slice(1))
+    params.append(this.queryParamValue, query)
+    url.search = params.toString()
+
+    return url.toString()
+  }
+
+  doFetch = async (url) => {
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      throw new Error(`Server responded with status ${response.status}`)
+    }
+
+    const html = await response.text()
+    return html
+  }
+
+  replaceResults(html) {
+    this.results.innerHTML = html
+    this.identifyOptions()
+    if (!!this.options) {
+      this.open()
+    } else {
+      this.close()
+    }
+  }
+
+  open() {
+    if (this.resultsShown) return
+
+    this.resultsShown = true
+    this.element.setAttribute("aria-expanded", "true")
+    this.element.dispatchEvent(
+      new CustomEvent("toggle", {
+        detail: { action: "open", autocompletable: this.autocompletable, results: this.results }
+      })
+    )
+  }
+
+  close() {
+    if (!this.resultsShown) return
+
+    this.resultsShown = false
+    this.autocompletable.removeAttribute("aria-activedescendant")
+    this.element.setAttribute("aria-expanded", "false")
+    this.element.dispatchEvent(
+      new CustomEvent("toggle", {
+        detail: { action: "close", autocompletable: this.autocompletable, results: this.results }
+      })
+    )
+  }
+
+  get resultsShown() {
+    return !this.results.hidden
+  }
+
+  set resultsShown(value) {
+    this.results.hidden = !value
+  }
+
+  get options() {
+    return Array.from(this.results.querySelectorAll(optionSelector))
+  }
+
+  get selectedOption() {
+    return this.results.querySelector(activeSelector)
+  }
+
+  get selectedClassesOrDefault() {
+    return this.hasSelectedClass ? this.selectedClasses : ["autocomplete-active"]
+  }
+
+});
+
+function filterSingleLine(text) {
+  return text.replace(/\s/g, ' ').replace(/\s\s+/g, ' ')
+};
+
+const debounce = (fn, delay = 10) => {
+  let timeoutId = null
+
+  return (...args) => {
+    clearTimeout(timeoutId)
+    timeoutId = setTimeout(fn, delay)
+  }
+}

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/export/html/_static/form.css

@@ -227,7 +227,10 @@ sdoc-form-grid {
   padding:
           calc(var(--base-rhythm)*4)
           calc(var(--base-rhythm)*3); /* (4-1) related to column gap */
-  overflow-x: hidden; /* related to field_action::before */
+
+  overflow-x: clip; /* Prevents overflow issues affecting:
+                       - field_action::before (highlight visibility on delete) and
+                       - autocompletable (dropdown visibility) */
 
   /* content container has no padding-block */
   margin-top: calc(var(--base-rhythm)*2);
@@ -306,15 +309,46 @@ sdoc-form-field-group:focus-within::before {
  * sdoc-contenteditable
  */
 
-sdoc-contenteditable {
+sdoc-contenteditable,
+sdoc-autocompletable {
   display: block;
   position: relative;
 }
 
-sdoc-contenteditable[contenteditable="false"] {
+sdoc-contenteditable[contenteditable="false"],
+sdoc-autocompletable[contenteditable="false"] {
   color: var(--color-fg-secondary);
 }
 
+.autocomplete-items {
+  position: absolute;
+  border: 1px solid #d4d4d4;
+  background-color: var(--color-bg-contrast);
+  border-bottom: none;
+  border-top: none;
+  z-index: 99;
+  top: 100%;
+  left: 0;
+  right: 0;
+  width: 40vw;
+  max-height: 60vh;
+  overflow-y: auto;
+  z-index: 999;
+}
+
+.autocomplete-active {
+  /*when navigating through the items using the arrow keys:*/
+  background-color: var(--color-highlight) !important;
+}
+
+.autocompletable-result-item {
+  position:relative;
+  display:block;
+  padding:.25rem 0.25rem;
+  margin-bottom:-1px;
+  border:1px solid rgba(0,0,0,.125)
+}
+
 .monospace {
   font-family: var(--code-font-family);
 }
@@ -329,7 +363,8 @@ sdoc-contenteditable[contenteditable="false"] {
 /* todo: Join sdoc-contenteditable with sdoc-form-field */
 
 sdoc-form-field label,
-sdoc-contenteditable::before {
+sdoc-contenteditable::before,
+sdoc-autocompletable::before {
   /* for contenteditable */
   content: attr(data-field-label);
   /* for all */
@@ -346,7 +381,8 @@ sdoc-contenteditable::before {
 }
 
 sdoc-form-field:focus-within label,
-sdoc-contenteditable:focus::before {
+sdoc-contenteditable:focus::before,
+sdoc-autocompletable:focus::before {
   color: var(--color-fg-accent);
 }
 

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/export/html/generators/project_statistics.py

@@ -39,18 +39,14 @@ class ProgressStatisticsGenerator:
             ):
                 if isinstance(node, SDocSection):
                     document_tree_stats.total_sections += 1
+                    if not node.has_any_text_nodes():
+                        document_tree_stats.sections_without_text_nodes += 1
 
-                    contains_text_nodes = any(
-                        isinstance(node_, SDocNode)
-                        and node_.node_type == "TEXT"
-                        for node_ in node.section_contents
-                    )
-                    if contains_text_nodes:
-                        document_tree_stats.sections_without_free_text += 1
-
-                if isinstance(node, SDocNode):
+                elif isinstance(node, SDocNode):
                     requirement: SDocNode = assert_cast(node, SDocNode)
-                    document_tree_stats.total_requirements += 1
+                    if not requirement.is_text_node():
+                        document_tree_stats.total_requirements += 1
+
                     if requirement.reserved_uid is None:
                         document_tree_stats.requirements_no_uid += 1
 

{strictdoc-0.6.0 → strictdoc-0.6.1a1}/strictdoc/export/html/generators/view_objects/project_tree_stats.py

@@ -21,7 +21,7 @@ class DocumentTreeStats:
     git_commit_hash: Optional[str] = None
 
     # Section
-    sections_without_free_text: int = 0
+    sections_without_text_nodes: int = 0
 
     # UID
     requirements_no_uid: int = 0

strictdoc-0.6.1a1/strictdoc/export/html/templates/autocomplete/uid/stream_autocomplete_uid.jinja.html

@@ -0,0 +1,2 @@
+{% for node in nodes %}
+<li class="autocompletable-result-item" role="option" data-autocompletable-value="{{ node.reserved_uid }}"><span class="requirement__link-parent"><span class="requirement__parent-uid">{{ node.reserved_uid }}</span> {{ node.reserved_title }}</span></li>{% endfor %}