metanorma-plugin-glossarist 0.3.0 → 0.3.2

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

@@ -1,59 +1,35 @@
 # frozen_string_literal: true
 
 require "asciidoctor"
-
-require "liquid"
 require "asciidoctor/reader"
 require "glossarist"
-require "metanorma/plugin/glossarist/document"
-require "metanorma/plugin/glossarist/liquid/custom_filters/filters"
+
+require_relative "sanitize"
+require_relative "concept_renderer"
+require_relative "bibliography_renderer"
+require_relative "concept_serializer"
+require_relative "document"
+require_relative "liquid/custom_filters/filters"
+require_relative "liquid/custom_blocks/with_glossarist_context"
 
 module Metanorma
   module Plugin
     module Glossarist
       class DatasetPreprocessor < Asciidoctor::Extensions::Preprocessor
-        include Metanorma::Plugin::Glossarist::Liquid::CustomFilters::Filters
-
-        GLOSSARIST_DATASET_REGEX = /^:glossarist-dataset:\s*(.*?)$/m.freeze
-        GLOSSARIST_IMPORT_REGEX = /^glossarist::import\[(.*?)\]$/m.freeze
-        GLOSSARIST_RENDER_REGEX = /^glossarist::render\[(.*?)\]$/m.freeze
-        GLOSSARIST_BLOCK_REGEX = /^\[glossarist,(.+?),(.+?)\]$/m.freeze
-        GLOSSARIST_BIBLIOGRAPHY_REGEX = /^glossarist::render_bibliography\[(.*?)\]$/m.freeze # rubocop:disable Layout/LineLength
-        GLOSSARIST_BIBLIOGRAPHY_ENTRY_REGEX = /^glossarist::render_bibliography_entry\[(.*?)\]$/m.freeze # rubocop:disable Layout/LineLength
-
-        # Search document for the following blocks
-        #   - :glossarist-dataset: dataset1:./dataset1;dataset2:./dataset2
-        #     This will load `glossarist` concepts from `./dataset1` path into
-        #     `dataset1` and concepts from `./dataset2` path into `dataset2`,
-        #     These can then be used anywhere in the document like
-        #     {{dataset1.concept_name.en.definition.content}}
-        #
-        #   - glossarist:render[dataset1, concept_name]
-        #     this will render the `concept_name` using the below format
-        #
-        #     ==== concept term
-        #     alt:[if additional terms]
-        #
-        #     definition text
-        #
-        #     NOTE: if there is a note.
-        #
-        #     [example]
-        #     If there is an example.
-        #
-        #     [.source]
-        #     <<If there is some source>>
-        #
-        #   - glossarist:import[dataset1]
-        #     this will render all concepts in the `dataset1` using the above
-        #     format
+        DATASET_ATTR_REGEX = /^:glossarist-dataset:\s*(.*?)$/m
+        IMPORT_REGEX = /^glossarist::import\[(.*?)\]$/m
+        RENDER_REGEX = /^glossarist::render\[(.*?)\]$/m
+        BLOCK_REGEX = /^\[glossarist,(.+?),(.+?)\]$/m
+        BIBLIOGRAPHY_REGEX = /^glossarist::render_bibliography\[(.*?)\]$/m
+        BIBLIOGRAPHY_ENTRY_REGEX = /^glossarist::render_bibliography_entry\[(.*?)\]$/m
+
         def initialize(config = {})
           super
           @config = config
           @datasets = {}
-          @title_depth = { value: 2 }
-          @rendered_bibliographies = {}
-          @seen_glossarist = []
+          @title_depth = 2
+          @bibliography_renderer = BibliographyRenderer.new
+          @seen_glossarist = false
           @context_names = []
         end
 
@@ -61,7 +37,7 @@ module Metanorma
           input_lines = reader.lines.to_enum
           @config[:file_system] = relative_file_path(document, "")
           processed_doc = prepare_document(document, input_lines)
-          log(document, processed_doc.to_s) unless @seen_glossarist.empty?
+          log(document, processed_doc.to_s) if @seen_glossarist
           Asciidoctor::PreprocessorReader.new(document,
                                               processed_doc.to_s.split("\n"))
         end
@@ -77,10 +53,8 @@ module Metanorma
 
         private
 
-        def prepare_document( # rubocop:disable Metrics/MethodLength
-          document, input_lines, end_mark = nil,
-          skip_dataset: false
-        )
+        def prepare_document(document, input_lines, end_mark = nil,
+                             skip_dataset: false)
           liquid_doc = Document.new
           liquid_doc.file_system = @config[:file_system]
 
@@ -88,9 +62,7 @@ module Metanorma
             current_line = input_lines.next
             break if end_mark && current_line == end_mark
 
-            if !(
-              skip_dataset && current_line.start_with?(":glossarist-dataset:")
-            )
+            unless skip_dataset && current_line.start_with?(":glossarist-dataset:")
               process_line(document, input_lines, current_line, liquid_doc)
             end
           end
@@ -98,346 +70,192 @@ module Metanorma
           liquid_doc
         end
 
-        def process_line( # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          document, input_lines, current_line, liquid_doc
-        )
-          if match = current_line.match(GLOSSARIST_DATASET_REGEX)
+        def process_line(document, input_lines, current_line, liquid_doc)
+          if (match = current_line.match(DATASET_ATTR_REGEX))
             process_dataset_tag(document, input_lines, liquid_doc, match)
-          elsif match = current_line.match(GLOSSARIST_RENDER_REGEX)
+          elsif (match = current_line.match(RENDER_REGEX))
             process_render_tag(liquid_doc, match)
-          elsif match = current_line.match(GLOSSARIST_IMPORT_REGEX)
+          elsif (match = current_line.match(IMPORT_REGEX))
             process_import_tag(liquid_doc, match)
-          elsif match = current_line.match(GLOSSARIST_BIBLIOGRAPHY_REGEX)
+          elsif (match = current_line.match(BIBLIOGRAPHY_REGEX))
             process_bibliography(document, liquid_doc, match)
-          elsif match = current_line.match(GLOSSARIST_BIBLIOGRAPHY_ENTRY_REGEX)
+          elsif (match = current_line.match(BIBLIOGRAPHY_ENTRY_REGEX))
             process_bibliography_entry(document, liquid_doc, match)
-          elsif match = current_line.match(GLOSSARIST_BLOCK_REGEX)
+          elsif (match = current_line.match(BLOCK_REGEX))
             process_glossarist_block(document, liquid_doc, input_lines, match)
           else
             if /^==+ \S/.match?(current_line)
-              @title_depth[:value] = current_line.sub(/ .*$/, "").size
+              @title_depth = current_line.sub(/ .*$/,
+                                              "").size
             end
             liquid_doc.add_content(current_line)
           end
         end
 
         def process_dataset_tag(document, input_lines, liquid_doc, match)
-          @seen_glossarist << "x"
+          @seen_glossarist = true
           @context_names << prepare_dataset_contexts(document, match[1])
           @context_names.flatten!
-          dataset_section = <<~TEMPLATE
-            #{prepare_document(document, input_lines)}
-          TEMPLATE
-
-          liquid_doc.add_content(
-            dataset_section,
-            render: false,
-          )
+          liquid_doc.add_content(prepare_document(document, input_lines).to_s,
+                                 render: false)
         end
 
         def process_glossarist_block(document, liquid_doc, input_lines, match)
-          @seen_glossarist << "x"
+          @seen_glossarist = true
           end_mark = input_lines.next
 
-          glossarist_params, template =
-            prepare_glossarist_block_params(document, match)
-          glossarist_section = <<~TEMPLATE.strip
-            {% with_glossarist_context #{glossarist_params} %}
-            #{prepare_document(
-              document, input_lines, end_mark,
-              skip_dataset: true
-            )}
+          params, template = prepare_glossarist_block_params(document, match)
+          section = <<~SECTION.strip
+            {% with_glossarist_context #{params} %}
+            #{prepare_document(document, input_lines, end_mark, skip_dataset: true)}
             {% endwith_glossarist_context %}
-          TEMPLATE
+          SECTION
 
           options = { render: true }
           options[:template] = template if template
-
-          liquid_doc.add_content(glossarist_section, options)
+          liquid_doc.add_content(section, options)
         end
 
-        def prepare_glossarist_block_params(document, match) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def prepare_glossarist_block_params(document, match)
           path = get_context_path(document, match[1])
           matched_arr = match[2].split(",").map(&:strip)
-          # get the last element as context name
           context_name = matched_arr.last
 
-          glossarist_block_params = []
-          glossarist_block_params << "#{context_name}=#{path}"
-
+          params = ["#{context_name}=#{path}"]
           template = nil
-          if matched_arr.size > 1
-            filters_or_template = matched_arr[0..-2]
-            filters_or_template.each do |item|
-              if item.start_with?("filter=")
-                filters = item.gsub(/^filter=/, "").strip
-                glossarist_block_params << filters
-              elsif item.start_with?("template=")
-                template = relative_file_path(
-                  document,
-                  item.gsub(/^template=/, "").strip,
-                )
-              end
+
+          matched_arr[0..-2].each do |item|
+            if item.start_with?("filter=")
+              filters = item.delete_prefix("filter=").strip
+              params << filters
+            elsif item.start_with?("template=")
+              template = relative_file_path(document,
+                                            item.delete_prefix("template=").strip)
             end
           end
 
-          [glossarist_block_params.join(";"), template]
+          [params.join(";"), template]
         end
 
-        def get_context_path(document, key) # rubocop:disable Metrics/MethodLength
-          context_path = nil
-          # try to get context_path from glossarist-dataset definition
+        def get_context_path(document, key)
           if @context_names && !@context_names.empty?
             context_names = @context_names.map(&:strip)
-            context_path = context_names.find do |context|
+            found = context_names.find do |context|
               context_name, = context.split("=")
               context_name == key
             end
+            return found.split("=").last.strip if found
           end
 
-          return context_path.split("=").last.strip if context_path
-
           relative_file_path(document, key)
         end
 
         def process_render_tag(liquid_doc, match)
-          @seen_glossarist << "x"
+          @seen_glossarist = true
           matches = match[1].split(",").map(&:strip)
-
           context_name = matches[0]
           concept_name = matches[1]
-          render_options = matches[2..-1]
+          options = parse_options(matches[2..])
 
-          liquid_doc.add_content(
-            concept_template(context_name.strip, concept_name.strip,
-                             render_options),
-          )
+          concept = find_concept(context_name, concept_name)
+          return unless concept
+
+          renderer = ConceptRenderer.new(concept,
+                                         depth: @title_depth,
+                                         anchor_prefix: options["anchor-prefix"])
+          liquid_doc.add_content(renderer.render)
         end
 
-        def process_import_tag(liquid_doc, match) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          @seen_glossarist << "x"
+        def process_import_tag(liquid_doc, match)
+          @seen_glossarist = true
           matches = match[1].split(",").map(&:strip)
           context_name = matches[0]
-          render_options = matches[1..-1]
+          options = parse_options(matches[1..])
           dataset = @datasets[context_name.strip]
+          return unless dataset
 
-          liquid_doc.add_content(
-            dataset.map do |concept|
-              concept_name = concept.data.localizations["eng"].data
-                .terms[0].designation
-              concept_template(context_name, concept_name, render_options)
-            end.join("\n"),
-          )
+          rendered = dataset.filter_map do |concept|
+            designation = concept.default_designation
+            next unless designation
+
+            renderer = ConceptRenderer.new(concept,
+                                           depth: @title_depth,
+                                           anchor_prefix: options["anchor-prefix"])
+            renderer.render
+          end.join("\n\n")
+
+          liquid_doc.add_content(rendered)
         end
 
-        def process_bibliography(document, liquid_doc, match) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          @seen_glossarist << "x"
+        def process_bibliography(document, liquid_doc, match)
+          @seen_glossarist = true
           dataset_name = match[1].strip
-          dataset = @datasets[dataset_name]
-
-          if dataset.nil? || @datasets.empty?
-            path = relative_file_path(document, dataset_name)
-            dataset = load_dataset_from_path(path)
-          end
+          dataset = resolve_dataset(document, dataset_name)
+          return unless dataset
 
-          liquid_doc.add_content(
-            dataset.map do |concept|
-              concept_bibliography(concept)
-            end.compact.sort.join("\n"),
-          )
+          liquid_doc.add_content(@bibliography_renderer.render_all(dataset))
         end
 
         def process_bibliography_entry(document, liquid_doc, match)
-          @seen_glossarist << "x"
+          @seen_glossarist = true
           dataset_name, concept_name = match[1].split(",").map(&:strip)
-          concept = get_concept(dataset_name, concept_name, document)
-          bibliography = concept_bibliography(concept)
+          concept = find_concept(dataset_name, concept_name, document)
+          return unless concept
 
-          if bibliography
-            liquid_doc.add_content(bibliography)
-          end
-        end
-
-        def concept_bibliography(concept) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          sources = concept.data.localizations["eng"].data.sources
-          return nil if sources.nil? || sources.empty?
-
-          bibliography = sources.map do |source|
-            ref = source.origin.text
-            next if @rendered_bibliographies[ref] || ref.nil? || ref.empty?
-
-            @rendered_bibliographies[ref] = ref.gsub(/[ \/:]/, "_")
-            "* [[[#{@rendered_bibliographies[ref]},#{ref}]]]"
-          end.compact.join("\n")
-
-          bibliography == "" ? nil : bibliography
+          entry = @bibliography_renderer.render_entry(concept)
+          liquid_doc.add_content(entry) if entry
         end
 
         def prepare_dataset_contexts(document, contexts)
           contexts.split(";").map do |context|
             context_name, file_path = context.split(":").map(&:strip)
             path = relative_file_path(document, file_path)
-            dataset = load_dataset_from_path(path)
-            @datasets[context_name] = dataset.map(&:to_liquid)
-
+            dataset = load_dataset(path)
+            @datasets[context_name] = dataset.to_a
             "#{context_name}=#{path}"
           end
         end
 
-        def load_dataset_from_path(path)
-          dataset = ::Glossarist::ManagedConceptCollection.new
-          dataset.load_from_files(path)
-          dataset
+        def load_dataset(path)
+          collection = ::Glossarist::ManagedConceptCollection.new
+          collection.load_from_files(path)
+          collection
         end
 
-        def relative_file_path(document, file_path)
-          docfile_directory = File.dirname(
-            document.attributes["docfile"] || ".",
-          )
-          document
-            .path_resolver
-            .system_path(file_path, docfile_directory)
-        end
-
-        def concept_template(dataset_name, concept_name, options = [])
-          options = options_to_hash(options)
-
-          <<~CONCEPT_TEMPLATE
-            [[#{identifier(dataset_name, concept_name, options)}]]
-            #{'=' * (@title_depth[:value] + 1)} #{concept_title(dataset_name, concept_name)}
-
-            #{alt_terms(dataset_name, concept_name)}
+        def find_concept(dataset_name, concept_name, document = nil)
+          dataset = resolve_dataset(document, dataset_name)
+          return unless dataset
 
-            #{concept_definition(dataset_name, concept_name)}
-
-            #{examples(dataset_name, concept_name)}
-
-            #{notes(dataset_name, concept_name)}
-
-            #{sources(dataset_name, concept_name)}
-          CONCEPT_TEMPLATE
+          dataset.find do |concept|
+            concept.default_designation == concept_name
+          end
         end
 
-        def get_concept(dataset_name, concept_name, document = nil)
+        def resolve_dataset(document, dataset_name)
           dataset = @datasets[dataset_name]
+          return dataset if dataset
 
-          if document && dataset.nil?
-            path = relative_file_path(document, dataset_name)
-            dataset = load_dataset_from_path(path)
-          end
+          return unless document
 
-          dataset.find do |c|
-            c.data.localizations["eng"]
-              .data.terms[0]
-              .designation == concept_name
-          end
+          path = relative_file_path(document, dataset_name)
+          collection = load_dataset(path)
+          @datasets[dataset_name] = collection.to_a
         end
 
-        def identifier(dataset_name, concept_name, options = {})
-          prefix = options["anchor-prefix"].to_s if options["anchor-prefix"]
-          concept = get_concept(dataset_name, concept_name)
-
-          id = "#{prefix}#{concept.data.id}"
-          # id starts with digits 0-9
-          return id if id.start_with?(/[0-9]/)
-
-          Metanorma::Utils.to_ncname(id.gsub(":", "_"))
+        def relative_file_path(document, file_path)
+          docfile_directory = File.dirname(
+            document.attributes["docfile"] || ".",
+          )
+          document.path_resolver.system_path(file_path, docfile_directory)
         end
 
-        def options_to_hash(options_arr)
+        def parse_options(options_arr)
           return {} if !options_arr || options_arr.empty?
 
-          options_arr.map { |option| option.split("=") }.to_h
-        end
-
-        def concept_title(dataset_name, concept_name)
-          concept = get_concept(dataset_name, concept_name)
-          concept.data.localizations["eng"].data.terms[0].designation
-        end
-
-        def concept_definition(dataset_name, concept_name)
-          concept = get_concept(dataset_name, concept_name)
-          definition = concept.data.localizations["eng"].data
-            .definition[0].content
-          sanitize_references(definition.to_s)
-        end
-
-        def alt_terms(dataset_name, concept_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          concept = get_concept(dataset_name, concept_name)
-          term_types = %w[preferred admitted deprecated]
-          concept_terms = concept.data.localizations["eng"].data.terms
-
-          concept_terms[1..-1].map do |term|
-            type = if term_types.include?(term.normative_status)
-                     term.normative_status
-                   else
-                     "alt"
-                   end
-            "#{type}:[#{term.designation}]"
-          end.join("\n")
-        end
-
-        def examples(dataset_name, concept_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          concept = get_concept(dataset_name, concept_name)
-          examples = concept.data.localizations["eng"].data.examples
-          result = []
-
-          examples.each do |example|
-            content = <<~EXAMPLE
-              [example]
-              #{sanitize_references(example.content)}
-
-            EXAMPLE
-            result << content
+          options_arr.each_with_object({}) do |option, hash|
+            key, value = option.split("=", 2)
+            hash[key] = value if key && value
           end
-
-          result.join("\n")
-        end
-
-        def notes(dataset_name, concept_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          concept = get_concept(dataset_name, concept_name)
-          notes = concept.data.localizations["eng"].data.notes
-          result = []
-
-          notes.each do |note|
-            content = <<~NOTE
-              [NOTE]
-              ====
-              #{sanitize_references(note.content)}
-              ====
-
-            NOTE
-            result << content
-          end
-
-          result.join("\n")
-        end
-
-        def sources(dataset_name, concept_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          concept = get_concept(dataset_name, concept_name)
-          sources = concept.data.localizations["eng"].data.sources
-          result = []
-
-          sources.each do |source|
-            if source.origin.text &&
-                source.origin.text != "" &&
-                source.origin.locality.type == "clause"
-              source_origin_text = source.origin.text
-                .gsub(" ", "_")
-                .gsub("/", "_")
-                .gsub(":", "_")
-              source_content = "#{source_origin_text}," \
-                               "#{source.origin.locality.reference_from}"
-              content = <<~SOURCES
-                [.source]
-                <<#{source_content}>>
-
-              SOURCES
-              result << content
-            end
-          end
-
-          result.join("\n")
         end
       end
     end

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

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "liquid/custom_blocks/with_glossarist_context"
-require_relative "liquid/custom_filters/filters"
+require "liquid"
 require_relative "liquid/multiply_local_file_system"
 
 module Metanorma
   module Plugin
     module Glossarist
       class Document
-        attr_accessor :content, :bibliographies, :file_system
+        attr_accessor :content, :file_system
 
         def initialize
           @content = []
-          @bibliographies = []
         end
 
         def add_content(content, options = {})
@@ -27,33 +25,20 @@ module Metanorma
           @content.compact.join("\n")
         end
 
-        def render_liquid(file_content, options = {}) # rubocop:disable Metrics/AbcSize
+        private
+
+        def render_liquid(file_content, options = {})
           include_paths = [file_system, options[:template]].compact
-          template = ::Liquid::Template
-            .parse(file_content, environment: create_liquid_environment)
+          template = ::Liquid::Template.parse(file_content)
           template.registers[:file_system] = ::Metanorma::Plugin::Glossarist::Liquid::LocalFileSystem.new(
             include_paths, ["%s.liquid", "_%s.liquid", "_%s.adoc"]
           )
-          rendered_template = template.render(strict_variables: false,
-                                              error_mode: :warn)
+          rendered = template.render
 
-          return rendered_template unless template.errors.any?
+          return rendered unless template.errors.any?
 
           raise template.errors.first.cause
         end
-
-        def create_liquid_environment
-          ::Liquid::Environment.new.tap do |liquid_env|
-            liquid_env.register_tag(
-              "with_glossarist_context",
-              ::Metanorma::Plugin::Glossarist::Liquid::CustomBlocks::
-              WithGlossaristContext,
-            )
-            liquid_env.register_filter(
-              ::Metanorma::Plugin::Glossarist::Liquid::CustomFilters::Filters,
-            )
-          end
-        end
       end
     end
   end