lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml_repository/static_site/search_index_builder.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      class SearchIndexBuilder
-        attr_reader :repository, :id_generator, :options
-
-        STOP_WORDS = %w[
-          the a an and or but in on at to for of with from by
-          is are was were be been being have has had
-          this that these those it its
-        ].freeze
-
-        def initialize(repository, options = {})
-          @repository = repository
-          @options = default_options.merge(options)
-          @id_generator = IDGenerator.new
-        end
-
-        def build
-          {
-            version: "1.0.0",
-            fields: field_definitions,
-            ref: "id",
-            documentStore: build_document_store,
-            pipeline: ["stemmer", "stopWordFilter"],
-          }
-        end
-
-        private
-
-        def default_options
-          {
-            languages: ["en"],
-          }
-        end
-
-        def field_definitions
-          [
-            { name: "name", boost: 10 },
-            { name: "qualifiedName", boost: 5 },
-            { name: "type", boost: 3 },
-            { name: "package", boost: 2 },
-            { name: "content", boost: 1 },
-          ]
-        end
-
-        def build_document_store
-          documents = []
-          documents.concat(build_class_documents)
-          documents.concat(build_association_documents)
-          documents.concat(build_package_documents)
-          documents
-        end
-
-        def build_class_document(klass)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("class", klass.xmi_id),
-            type: "class",
-            entity_type: class_type(klass),
-            entity_id: @id_generator.class_id(klass),
-            name: klass.name,
-            qualified_name: qualified_name(klass),
-            package: package_name(klass),
-            content: build_class_content(klass),
-            boost: 1.5,
-          )
-        end
-
-        def build_attribute_document(attribute, owner)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("attribute",
-                                          "#{owner.xmi_id}::#{attribute.name}"),
-            type: "attribute",
-            entity_type: "Attribute",
-            entity_id: @id_generator.attribute_id(attribute, owner),
-            name: attribute.name,
-            qualified_name: "#{qualified_name(owner)}::#{attribute.name}",
-            package: package_name(owner),
-            content: build_attribute_content(attribute, owner),
-            boost: 1.0,
-          )
-        end
-
-        def build_association_document(association)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("association", association.xmi_id),
-            type: "association",
-            entity_type: "Association",
-            entity_id: @id_generator.association_id(association),
-            name: association.name || "unnamed",
-            qualified_name: association.name || "unnamed",
-            package: "",
-            content: build_association_content(association),
-            boost: 0.8,
-          )
-        end
-
-        def build_package_document(package)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("package", package.xmi_id),
-            type: "package",
-            entity_type: "Package",
-            entity_id: @id_generator.package_id(package),
-            name: package.name,
-            qualified_name: package_path(package),
-            package: parent_package_name(package),
-            content: build_package_content(package),
-            boost: 1.2,
-          )
-        end
-
-        def build_class_content(klass)
-          parts = [
-            klass.name,
-            qualified_name(klass),
-            class_type(klass),
-            Array(klass.stereotype).join(" "),
-            klass.definition,
-            collect_names(klass.attributes),
-            collect_names(klass.operations),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_attribute_content(attribute, owner)
-          parts = [
-            attribute.name,
-            attribute.type,
-            owner.name,
-            qualified_name(owner),
-            attribute.definition,
-            Array(attribute.stereotype).join(" "),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_association_content(association)
-          parts = [
-            association.name,
-            association.owner_end,
-            association.member_end,
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_package_content(package)
-          parts = [
-            package.name,
-            package_path(package),
-            package.definition,
-            Array(package.stereotype).join(" "),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def normalize_content(text)
-          text = text.downcase
-          tokens = text.split(/[\s:]+/)
-          all_content = [text] + tokens
-          all_content = all_content.uniq.reject do |word|
-            STOP_WORDS.include?(word)
-          end
-          all_content.join(" ").gsub(/\s+/, " ").strip
-        end
-
-        def build_class_documents
-          docs = []
-          repository.classes_index.each do |klass|
-            docs << build_class_document(klass)
-            klass.attributes&.each do |attr|
-              docs << build_attribute_document(attr, klass)
-            end
-          end
-          docs
-        end
-
-        def build_association_documents
-          repository.associations_index.map do |assoc|
-            build_association_document(assoc)
-          end
-        end
-
-        def build_package_documents
-          repository.packages_index.map do |package|
-            build_package_document(package)
-          end
-        end
-
-        def collect_names(items)
-          items&.map(&:name)&.join(" ")
-        end
-
-        def class_type(klass)
-          klass.class.name.split("::").last
-        end
-
-        def qualified_name(klass)
-          path_parts = []
-          current = klass
-
-          while current
-            if current.is_a?(Lutaml::Uml::TopElement) || current.is_a?(Lutaml::Uml::Package)
-              path_parts.unshift(current.name)
-              current = current.namespace
-            else
-              break
-            end
-          end
-
-          path_parts.join("::")
-        end
-
-        def package_name(klass)
-          return "" unless klass.namespace.is_a?(Lutaml::Uml::Package)
-
-          package_path(klass.namespace)
-        end
-
-        def parent_package_name(package)
-          return "" unless package.namespace.is_a?(Lutaml::Uml::Package)
-
-          package_path(package.namespace)
-        end
-
-        def package_path(package)
-          return package.name unless package.namespace.is_a?(Lutaml::Uml::Package)
-
-          "#{package_path(package.namespace)}::#{package.name}"
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/serializers/attribute_serializer.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Serializers
-        class AttributeSerializer
-          include Lutaml::Uml::ModelHelpers
-
-          def initialize(repository, id_generator, options)
-            @repository = repository
-            @id_generator = id_generator
-            @options = options
-          end
-
-          def build_map
-            attributes = {}
-            @repository.classes_index.each do |klass|
-              next unless klass.attributes
-
-              klass.attributes.each do |attr|
-                id = @id_generator.attribute_id(attr, klass)
-                attributes[id] = serialize(attr, klass, id)
-              end
-            end
-            attributes
-          end
-
-          def serialize(attribute, owner, id)
-            Models::SpaAttribute.new(
-              id: id,
-              name: attribute.name,
-              type: attribute.type,
-              visibility: attribute.visibility,
-              owner: @id_generator.class_id(owner),
-              owner_name: owner.name,
-              cardinality: serialize_cardinality(attribute.cardinality),
-              definition: format_definition(attribute.definition),
-              stereotypes: normalize_stereotypes(attribute.stereotype),
-              is_static: attribute.is_static,
-              is_read_only: attribute.is_read_only,
-              default_value: attribute.default,
-            )
-          end
-
-          private
-
-          def serialize_cardinality(cardinality)
-            return nil unless cardinality
-
-            Models::SpaCardinality.new(
-              min: cardinality.min,
-              max: cardinality.max,
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/serializers/class_serializer.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Serializers
-        class ClassSerializer
-          include Lutaml::Uml::ModelHelpers
-
-          def initialize(repository, id_generator, options,
-inheritance_resolver)
-            @repository = repository
-            @id_generator = id_generator
-            @options = options
-            @inheritance_resolver = inheritance_resolver
-          end
-
-          def build_map
-            classes = {}
-            @repository.classes_index.each do |klass|
-              id = @id_generator.class_id(klass)
-              classes[id] = serialize(klass, id)
-            end
-            classes
-          end
-
-          private
-
-          def serialize(klass, id)
-            Models::SpaClass.new(
-              id: id,
-              xmi_id: klass.xmi_id,
-              name: klass.name,
-              qualified_name: qualified_name_for(klass),
-              type: class_type_for(klass),
-              package: package_id_for_class(klass),
-              stereotypes: normalize_stereotypes(klass.stereotype),
-              definition: format_definition(klass.definition),
-              attributes: serialize_attribute_ids(klass),
-              operations: serialize_class_operations(klass),
-              associations: sort_associations(find_class_associations(klass),
-                                              klass),
-              is_abstract: klass.is_abstract,
-              literals: serialize_literals(klass),
-              **inheritance_data(klass),
-            )
-          end
-
-          def inheritance_data(klass)
-            {
-              generalizations: @inheritance_resolver.find_generalizations(klass),
-              specializations: @inheritance_resolver.find_specializations(klass),
-              inherited_attributes: @inheritance_resolver.compute_inherited_attributes(klass),
-              inherited_associations: @inheritance_resolver.compute_inherited_associations(klass),
-            }
-          end
-
-          def resolve_assoc_role(assoc, klass)
-            if assoc.owner_end_xmi_id == klass.xmi_id
-              assoc.owner_end_attribute_name || assoc.owner_end || ""
-            elsif assoc.member_end_xmi_id == klass.xmi_id
-              assoc.member_end_attribute_name || assoc.member_end || ""
-            else
-              ""
-            end
-          end
-
-          def serialize_attribute_ids(klass)
-            (klass.attributes || []).sort_by { |a| a.name || "" }
-              .map { |attr| @id_generator.attribute_id(attr, klass) }
-          end
-
-          def find_class_associations(klass)
-            associations = @repository.associations_of(klass)
-            associations.map { |assoc| @id_generator.association_id(assoc) }
-          rescue StandardError
-            []
-          end
-
-          def sort_associations(assoc_ids, klass)
-            assoc_ids.sort_by do |assoc_id|
-              assoc = find_assoc_by_id(assoc_id)
-              next "" unless assoc
-
-              resolve_assoc_role(assoc, klass)
-            end
-          end
-
-          def find_assoc_by_id(assoc_id)
-            @repository.associations_index.find do |a|
-              @id_generator.association_id(a) == assoc_id
-            end
-          end
-
-          def serialize_class_operations(klass)
-            return [] unless klass.operations
-
-            klass.operations.map { |op| @id_generator.operation_id(op, klass) }
-          end
-
-          def serialize_literals(klass)
-            return [] unless klass.is_a?(Lutaml::Uml::Enum) && klass.owned_literal
-
-            klass.owned_literal.map do |literal|
-              Models::SpaLiteral.new(
-                name: literal.name,
-                definition: format_definition(literal.definition),
-              )
-            end
-          rescue StandardError
-            []
-          end
-
-          def package_id_for_class(klass)
-            return nil unless klass.namespace.is_a?(Lutaml::Uml::Package)
-
-            @id_generator.package_id(klass.namespace)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/serializers/diagram_serializer.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Serializers
-        class DiagramSerializer
-          def initialize(repository, id_generator, options)
-            @repository = repository
-            @id_generator = id_generator
-            @options = options
-          end
-
-          def build_map
-            diagrams = {}
-            @repository.diagrams_index.each do |diagram|
-              id = @id_generator.diagram_id(diagram)
-              diagrams[id] = serialize(diagram, id)
-            end
-            diagrams
-          rescue StandardError
-            {}
-          end
-
-          private
-
-          def serialize(diagram, id)
-            Models::SpaDiagram.new(
-              id: id,
-              xmi_id: diagram.xmi_id,
-              name: diagram.name,
-              type: diagram.diagram_type,
-              package: find_diagram_package(diagram),
-              object_count: (diagram.diagram_objects || []).size,
-              link_count: (diagram.diagram_links || []).size,
-              svg: render_svg(diagram),
-            )
-          end
-
-          def render_svg(diagram)
-            return nil unless @options[:render_diagrams]
-            return nil unless diagram.diagram_objects&.any?
-
-            presenter = Presenters::DiagramPresenter.new(diagram, @repository)
-            presenter.svg_output
-          rescue StandardError
-            nil
-          end
-
-          def find_diagram_package(diagram)
-            @repository.packages_index.each do |pkg|
-              diagrams = package_diagrams(pkg)
-              if diagrams.any? { |d| d.xmi_id == diagram.xmi_id }
-                return @id_generator.package_id(pkg)
-              end
-            end
-            nil
-          rescue StandardError
-            nil
-          end
-
-          def package_diagrams(package)
-            return [] unless @options[:include_diagrams]
-
-            package.diagrams || []
-          rescue StandardError
-            []
-          end
-        end
-      end
-    end
-  end
-end