metanorma-plugin-glossarist 0.3.0 → 0.3.2

data/lib/metanorma/plugin/glossarist/concept_filter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class ConceptFilter
+        COLLECTION_FILTERS = %w[lang domain group sort_by].freeze
+        SORT_LAST = ["￿"].freeze
+
+        def initialize(filters)
+          @filters = filters || {}
+        end
+
+        def apply(collection)
+          result = collection
+          result = filter_by_lang(result) if @filters.key?("lang")
+          if @filters.key?("domain") || @filters.key?("group")
+            result = filter_by_domain(result)
+          end
+          result = filter_by_field(result) if field_filter?
+          result = sort(result) if @filters.key?("sort_by")
+          result
+        end
+
+        private
+
+        def field_filter?
+          (@filters.keys - COLLECTION_FILTERS).any?
+        end
+
+        def field_filter_key
+          (@filters.keys - COLLECTION_FILTERS).first
+        end
+
+        def filter_by_lang(collection)
+          lang = @filters["lang"]
+          collection.reject { |c| c.localization(lang).nil? }
+        end
+
+        def filter_by_domain(collection)
+          domain = @filters["domain"] || @filters["group"]
+          collection.select do |c|
+            c.data.domains&.any? { |d| d.concept_id == domain }
+          end
+        end
+
+        def sort(collection)
+          field = @filters["sort_by"]
+          return collection unless field
+
+          case field
+          when "term", "default_designation"
+            collection.sort_by { |c| c.default_designation.to_s.downcase }
+          else
+            parts = parse_path(field)
+            collection.sort_by { |c| sort_key(c, parts) }
+          end
+        end
+
+        def sort_key(concept, parts)
+          hash = ConceptSerializer.new(concept).to_h
+          value = dig_path(hash, parts)
+          value.nil? ? SORT_LAST : natural_sort_key(value.to_s)
+        end
+
+        def natural_sort_key(str)
+          str.scan(/(\d+)|(\D+)/)
+            .map { |num, txt| num ? num.to_i : txt.downcase }
+        end
+
+        def filter_by_field(collection)
+          path = field_filter_key
+          value = @filters[path]
+
+          start_with = path.include?(".start_with(")
+          path, match_value = extract_start_with(path, value, start_with)
+
+          parts = parse_path(path)
+          collection.select do |concept|
+            hash = ConceptSerializer.new(concept).to_h
+            actual = dig_path(hash, parts)
+            if start_with
+              actual&.start_with?(match_value)
+            else
+              actual == value
+            end
+          end
+        end
+
+        def extract_start_with(path, value, start_with)
+          return [path, value] unless start_with
+
+          match = path.match(/^([^.]+(?:\.[^.]+)*)\.start_with\(([^)]+)\)$/)
+          return [path, value] unless match
+
+          [match[1], match[2]]
+        end
+
+        def parse_path(path)
+          path.split(".").flat_map do |segment|
+            if segment.include?("[")
+              parse_indexed_segment(segment)
+            else
+              [segment]
+            end
+          end
+        end
+
+        def parse_indexed_segment(segment)
+          field, index_part = segment.split("[", 2)
+          index = index_part&.delete("]'\"")
+          if index.match?(/\A\d+\z/)
+            [field, index.to_i]
+          else
+            [field, index]
+          end
+        end
+
+        def dig_path(hash, parts)
+          parts.reduce(hash) do |current, key|
+            case current
+            when Hash
+              current[key] || current[key.to_s]
+            when Array
+              key.is_a?(Integer) ? current[key] : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/concept_renderer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class ConceptRenderer
+        TERM_TYPES = %w[preferred admitted deprecated].freeze
+
+        def initialize(concept, depth:, anchor_prefix: nil)
+          @concept = concept
+          @depth = depth
+          @anchor_prefix = anchor_prefix
+        end
+
+        def render
+          sections = [concept_header]
+          sections << alt_terms_section
+          sections << definition_section
+          sections << examples_section
+          sections << notes_section
+          sections << sources_section
+          sections.compact.join("\n\n")
+        end
+
+        private
+
+        def eng_l10n
+          @eng_l10n ||= @concept.localization("eng")
+        end
+
+        def concept_header
+          "[[#{anchor_id}]]\n#{heading_line}"
+        end
+
+        def anchor_id
+          id = "#{@anchor_prefix}#{@concept.data.id}"
+          id.match?(/\A\d/) ? id : Metanorma::Utils.to_ncname(id.gsub(":", "_"))
+        end
+
+        def heading_line
+          "#{'=' * (@depth + 1)} #{term_designation}"
+        end
+
+        def term_designation
+          eng_l10n.terms.first&.designation.to_s
+        end
+
+        def alt_terms_section
+          terms = eng_l10n.terms[1..].map do |term|
+            type = TERM_TYPES.include?(term.normative_status) ? term.normative_status : "alt"
+            "#{type}:[#{term.designation}]"
+          end
+          terms.empty? ? nil : terms.join("\n")
+        end
+
+        def definition_section
+          content = eng_l10n.definition.first&.content
+          return nil unless content
+
+          Sanitize.references(content.to_s)
+        end
+
+        def examples_section
+          examples = eng_l10n.examples.map do |example|
+            "[example]\n#{Sanitize.references(example.content.to_s)}"
+          end
+          examples.empty? ? nil : examples.join("\n")
+        end
+
+        def notes_section
+          notes = eng_l10n.notes.map do |note|
+            "[NOTE]\n====\n#{Sanitize.references(note.content.to_s)}\n===="
+          end
+          notes.empty? ? nil : notes.join("\n")
+        end
+
+        def sources_section
+          sources = eng_l10n.sources.filter_map do |source|
+            next if source.origin&.text.nil? || source.origin.text.empty?
+            next unless source.origin.locality&.type == "clause"
+
+            ref = source.origin.text.gsub(%r{[ /:]}, "_")
+            clause = source.origin.locality.reference_from
+            "[.source]\n<<#{ref},#{clause}>>"
+          end
+          sources.empty? ? nil : sources.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/concept_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class ConceptSerializer
+        def initialize(concept)
+          @concept = concept
+        end
+
+        def to_h
+          data = @concept.data.to_hash
+          data["localizations"] = localizations_hash unless @concept.localizations.empty?
+          { "data" => data.compact }
+        end
+
+        private
+
+        def localizations_hash
+          @concept.localizations.to_h do |l10n|
+            [l10n.language_code, l10n.to_hash]
+          end
+        end
+      end
+    end
+  end
+end