mxrb 0.1.0

data/lib/mxrb/semantic/inliner.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "set"
+
+module Mxrb
+  module Semantic
+    class InlinePlan
+      attr_reader :source, :called_name, :call_id
+
+      def initialize(project:, source:, called_name:, call_id:,
+                     inner_objects:, inner_flows:,
+                     entry_flow:, exit_flow:,
+                     source_doc:, source_raw:)
+        @project = project
+        @source = source
+        @called_name = called_name
+        @call_id = call_id
+        @inner_objects = inner_objects
+        @inner_flows = inner_flows
+        @entry_flow = entry_flow
+        @exit_flow = exit_flow
+        @source_doc = source_doc
+        @source_raw = source_raw
+        @applied = false
+      end
+
+      def applied? = @applied
+
+      def changes
+        count = @inner_objects.size
+        suffix = count == 1 ? "y" : "ies"
+        [
+          "inline #{@called_name} into #{@source.qualified_name}",
+          "replace call_microflow activity with #{count} inlined activit#{suffix}"
+        ]
+      end
+
+      def apply!
+        raise ArgumentError, "inline plan was already applied" if applied?
+
+        @project.mpr.transaction { patch_source_microflow! }
+        @project.refresh!
+        @applied = true
+        self
+      end
+
+      private
+
+      def patch_source_microflow!
+        # Remap every inlined object's UUID to avoid collisions with existing caller objects
+        id_map = @inner_objects.to_h { [_1["$ID"], SecureRandom.uuid] }
+
+        remapped_objects = @inner_objects.map { |obj| obj.merge("$ID" => id_map.fetch(obj["$ID"])) }
+        remapped_flows   = @inner_flows.map do |flow|
+          flow.merge(
+            "$ID"                  => SecureRandom.uuid,
+            "OriginPointer"        => id_map.fetch(flow["OriginPointer"],      flow["OriginPointer"]),
+            "DestinationPointer"   => id_map.fetch(flow["DestinationPointer"], flow["DestinationPointer"])
+          )
+        end
+
+        first_id  = id_map.fetch(@entry_flow["DestinationPointer"])
+        last_id   = id_map.fetch(@exit_flow["OriginPointer"])
+        origin_id = @entry_flow["OriginPointer"]
+        dest_id   = @exit_flow["DestinationPointer"]
+
+        all_objects = normalize_all(parse_array(@source_doc["ObjectCollection"]["Objects"]))
+        kept_objects = all_objects.reject { _1["$ID"] == @call_id }
+        kept_objects.concat(remapped_objects)
+
+        removed_flow_ids = Set.new([@entry_flow["$ID"], @exit_flow["$ID"]].compact)
+        all_flows = normalize_all(parse_array(@source_doc["Flows"]))
+        kept_flows = all_flows.reject { removed_flow_ids.include?(_1["$ID"]) }
+        kept_flows << simple_flow_doc(origin_id, first_id)
+        kept_flows << simple_flow_doc(last_id,   dest_id)
+        kept_flows.concat(remapped_flows)
+
+        patched = @source_doc.merge(
+          "ObjectCollection" => @source_doc["ObjectCollection"].merge(
+            "Objects" => IO::BsonCodec.build_array(kept_objects)
+          ),
+          "Flows" => IO::BsonCodec.build_array(kept_flows)
+        )
+        @project.mpr.update_unit(@source_raw.fetch("UnitID"), patched)
+      end
+
+      def simple_flow_doc(from_id, to_id)
+        {
+          "$ID"                    => SecureRandom.uuid,
+          "$Type"                  => "Microflows$SequenceFlow",
+          "OriginPointer"          => from_id,
+          "DestinationPointer"     => to_id,
+          "IsErrorHandler"         => false,
+          "OriginConnectionIndex"  => 1,
+          "DestinationConnectionIndex" => 3
+        }
+      end
+
+      POINTER_KEYS = %w[$ID OriginPointer DestinationPointer].freeze
+
+      def normalize_ids(hash)
+        hash.each_with_object({}) do |(k, v), out|
+          out[k] = POINTER_KEYS.include?(k) ? (IO::BsonCodec.extract_id(v) || v) : v
+        end
+      end
+
+      def normalize_all(arr) = arr.map { normalize_ids(_1) }
+      def parse_array(value) = IO::BsonCodec.parse_array(value)[:items]
+    end
+
+    # Inlines a called microflow back into its caller, replacing the
+    # call_microflow activity with the callee's activities.
+    class Inliner
+      FLOW_KINDS = %i[microflow nanoflow].freeze
+
+      def initialize(project)
+        @project = project
+      end
+
+      # @param source_name [String] qualified name of the caller microflow
+      # @param calling     [String] qualified name of the microflow to inline
+      def plan(source_name, calling:)
+        source = resolve(source_name)
+        raise ArgumentError, "#{source.qualified_name} is not a microflow or nanoflow" \
+          unless FLOW_KINDS.include?(source.kind)
+
+        called = resolve(calling)
+        raise ArgumentError, "#{called.qualified_name} is not a microflow or nanoflow" \
+          unless FLOW_KINDS.include?(called.kind)
+
+        source_raw = @project.raw_unit(source.unit_id)
+        source_doc = @project.parse_bson(source_raw)
+
+        all_objects = normalize_all(parse_array(source_doc["ObjectCollection"]["Objects"]))
+        all_flows   = normalize_all(parse_array(source_doc["Flows"]))
+
+        call_activity = all_objects.find do |obj|
+          obj["$Type"] == "Microflows$ActionActivity" &&
+            obj.dig("Action", "MicroflowCall", "Microflow") == calling
+        end
+        raise ArgumentError, "no call to #{calling.inspect} found in #{source_name.inspect}" \
+          unless call_activity
+
+        call_id    = call_activity["$ID"]
+        entry_flow = all_flows.find { _1["DestinationPointer"] == call_id }
+        exit_flow  = all_flows.find { _1["OriginPointer"]      == call_id }
+        raise ArgumentError, "cannot find entry flow for call activity" unless entry_flow
+        raise ArgumentError, "cannot find exit flow for call activity"  unless exit_flow
+
+        called_raw = @project.raw_unit(called.unit_id)
+        called_doc = @project.parse_bson(called_raw)
+
+        called_objects = normalize_all(parse_array(called_doc["ObjectCollection"]["Objects"]))
+        called_flows   = normalize_all(parse_array(called_doc["Flows"]))
+
+        start_event = called_objects.find { _1["$Type"] == "Microflows$StartEvent" }
+        end_event   = called_objects.find { _1["$Type"] == "Microflows$EndEvent"   }
+        raise ArgumentError, "#{calling.inspect} has no start event" unless start_event
+        raise ArgumentError, "#{calling.inspect} has no end event" unless end_event
+
+        start_id = start_event["$ID"]
+        end_id   = end_event["$ID"]
+
+        inner_objects = called_objects.reject { [start_id, end_id].include?(_1["$ID"]) }
+        raise ArgumentError, "#{calling.inspect} has no activities to inline" if inner_objects.empty?
+
+        inner_flows = called_flows.reject do |f|
+          [start_id, end_id].include?(f["OriginPointer"]) ||
+            [start_id, end_id].include?(f["DestinationPointer"])
+        end
+
+        start_to_first = called_flows.find { _1["OriginPointer"]      == start_id }
+        last_to_end    = called_flows.find { _1["DestinationPointer"] == end_id   }
+        raise ArgumentError, "cannot resolve first activity in #{calling.inspect}" unless start_to_first
+        raise ArgumentError, "cannot resolve last activity in #{calling.inspect}" unless last_to_end
+
+        # Synthesise entry/exit flows that point at the actual first/last inlined objects
+        synthetic_entry = entry_flow.merge("DestinationPointer" => start_to_first["DestinationPointer"])
+        synthetic_exit  = exit_flow.merge("OriginPointer"       => last_to_end["OriginPointer"])
+
+        InlinePlan.new(
+          project:       @project,
+          source:        source,
+          called_name:   calling,
+          call_id:       call_id,
+          inner_objects: inner_objects,
+          inner_flows:   inner_flows,
+          entry_flow:    synthetic_entry,
+          exit_flow:     synthetic_exit,
+          source_doc:    source_doc,
+          source_raw:    source_raw
+        )
+      end
+
+      private
+
+      def resolve(name)
+        artifact = @project.find_artifact(name)
+        raise KeyError, "unknown Mendix artifact #{name.inspect}" unless artifact
+        artifact
+      end
+
+      POINTER_KEYS = %w[$ID OriginPointer DestinationPointer].freeze
+
+      def normalize_ids(hash)
+        hash.each_with_object({}) do |(k, v), out|
+          out[k] = POINTER_KEYS.include?(k) ? (IO::BsonCodec.extract_id(v) || v) : v
+        end
+      end
+
+      def normalize_all(arr) = arr.map { normalize_ids(_1) }
+      def parse_array(value) = IO::BsonCodec.parse_array(value)[:items]
+    end
+  end
+end

data/lib/mxrb/semantic/mover.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Semantic
+    class MovePlan
+      attr_reader :source, :target, :before_container, :containment_name
+
+      def initialize(project:, source:, target:, before_container:, containment_name:)
+        @project = project
+        @source = source
+        @target = target
+        @before_container = before_container
+        @containment_name = containment_name
+        @applied = false
+      end
+
+      def after_container = target.unit_id
+      def empty? = before_container == after_container
+      def applied? = @applied
+
+      def apply!
+        raise ArgumentError, "move plan was already applied" if applied?
+
+        unless empty?
+          @project.mpr.transaction do
+            @project.mpr.relocate_unit(
+              source.unit_id,
+              container_uuid: after_container,
+              containment_name:
+            )
+          end
+        end
+        @project.refresh!
+        @applied = true
+        self
+      end
+    end
+
+    # Cross-module move: relocates a unit AND renames its qualified name across
+    # the project so that all references stay consistent.
+    class CrossModuleMovePlan
+      attr_reader :source, :target, :before_container, :rename_changes
+
+      def initialize(project:, source:, target:, rename_plan:, before_container:, containment_name:)
+        @project = project
+        @source = source
+        @target = target
+        @rename_plan = rename_plan
+        @before_container = before_container
+        @containment_name = containment_name
+        @applied = false
+      end
+
+      def after_container = target.unit_id
+      def empty? = false
+      def rename_changes = @rename_plan.changes
+      def applied? = @applied
+
+      def apply!
+        raise ArgumentError, "cross-module move plan was already applied" if applied?
+
+        @project.mpr.transaction do
+          @rename_plan.documents.each do |unit_id, doc|
+            @project.mpr.update_unit(unit_id, doc)
+          end
+          @project.mpr.relocate_unit(
+            @source.unit_id,
+            container_uuid: @target.unit_id,
+            containment_name: @containment_name
+          )
+        end
+        @project.refresh!
+        @applied = true
+        self
+      end
+    end
+
+    class Mover
+      EMBEDDED_KINDS = %i[module entity attribute association].freeze
+      CONTAINER_KINDS = %i[module folder].freeze
+
+      def initialize(project)
+        @project = project
+      end
+
+      def plan(name, to:)
+        source = resolve(name)
+        target = resolve(to)
+        validate_kinds(source, target)
+
+        raw = @project.raw_unit(source.unit_id)
+        raise ArgumentError, "#{source.qualified_name} is not a movable unit" unless raw
+        if descendant_ids(source.unit_id).include?(target.unit_id)
+          raise ArgumentError, "cannot move #{source.qualified_name} into its descendant"
+        end
+
+        if source.module_name != target.module_name
+          plan_cross_module(source, target, raw)
+        else
+          MovePlan.new(
+            project: @project,
+            source:,
+            target:,
+            before_container: raw.fetch("ContainerID"),
+            containment_name: raw.fetch("ContainmentName")
+          )
+        end
+      end
+
+      private
+
+      def plan_cross_module(source, target, raw)
+        new_name = "#{target.module_name}.#{source.name}"
+        rename_plan = Renamer.new(@project).plan(source.qualified_name, to: new_name, cross_module: true)
+        CrossModuleMovePlan.new(
+          project: @project,
+          source:,
+          target:,
+          rename_plan:,
+          before_container: raw.fetch("ContainerID"),
+          containment_name: raw.fetch("ContainmentName")
+        )
+      end
+
+      def resolve(name)
+        artifact = @project.find_artifact(name)
+        return artifact if artifact
+
+        matches = @project.semantic_index.find_all(name)
+        raise KeyError, "unknown Mendix artifact #{name.inspect}" if matches.empty?
+        raise ArgumentError, "ambiguous Mendix artifact #{name.inspect}" if matches.size > 1
+
+        matches.first
+      end
+
+      def validate_kinds(source, target)
+        if EMBEDDED_KINDS.include?(source.kind)
+          raise ArgumentError, "#{source.kind} cannot be moved as a standalone unit"
+        end
+        return if CONTAINER_KINDS.include?(target.kind)
+
+        raise ArgumentError, "#{target.qualified_name} is not a module or folder"
+      end
+
+      def descendant_ids(unit_id)
+        direct = @project.children_of(unit_id)
+        direct.flat_map do |child|
+          [child.fetch("UnitID"), *descendant_ids(child.fetch("UnitID"))]
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/semantic/onnx_embedder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Semantic
+    # Optional sentence-transformer backend powered by the informers gem.
+    class OnnxEmbedder
+      MODEL = 'sentence-transformers/all-MiniLM-L6-v2'
+      MODEL_REVISION = '1110a243fdf4706b3f48f1d95db1a4f5529b4d41'
+
+      def self.available?
+        require 'informers'
+        true
+      rescue LoadError
+        false
+      end
+
+      def initialize(pipeline: nil)
+        require 'informers' unless pipeline
+        @pipeline = pipeline || Informers.pipeline(
+          'embedding', MODEL, revision: MODEL_REVISION
+        )
+        @dimension = nil
+      end
+
+      def backend = :onnx
+      def dimension = (@dimension ||= embed('warmup').size)
+
+      def embed(text)
+        vector = @pipeline.call(text)
+        vector.first.is_a?(Array) ? vector.first : vector
+      end
+    end
+  end
+end

data/lib/mxrb/semantic/remover.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Semantic
+    class RemovalPlan
+      attr_reader :artifact, :incoming, :children
+
+      def initialize(project:, artifact:, incoming:, children:)
+        @project = project
+        @artifact = artifact
+        @incoming = incoming.freeze
+        @children = children.freeze
+        @applied = false
+      end
+
+      def safe? = incoming.empty? && children.empty?
+      def applied? = @applied
+
+      def apply!
+        raise ArgumentError, "removal plan was already applied" if applied?
+        unless safe?
+          raise ArgumentError,
+                "cannot remove #{artifact.qualified_name}: " \
+                "#{incoming.size} incoming reference(s), #{children.size} child unit(s)"
+        end
+
+        @project.mpr.transaction { @project.mpr.delete_unit(artifact.unit_id) }
+        @project.refresh!
+        @applied = true
+        self
+      end
+    end
+
+    class Remover
+      EMBEDDED_KINDS = %i[module entity attribute association].freeze
+
+      def initialize(project)
+        @project = project
+      end
+
+      def plan(name)
+        artifact = resolve(name)
+        if EMBEDDED_KINDS.include?(artifact.kind)
+          raise ArgumentError,
+                "#{artifact.kind} removal requires a typed domain-model mutation"
+        end
+        raw = @project.raw_unit(artifact.unit_id)
+        raise ArgumentError, "#{artifact.qualified_name} is not a removable unit" unless raw
+
+        incoming = @project.references_to(artifact)
+                           .reject { _1.source.id == artifact.id }
+        children = @project.children_of(artifact.unit_id)
+        RemovalPlan.new(project: @project, artifact:, incoming:, children:)
+      end
+
+      private
+
+      def resolve(name)
+        artifact = @project.find_artifact(name)
+        return artifact if artifact
+
+        matches = @project.semantic_index.find_all(name)
+        raise KeyError, "unknown Mendix artifact #{name.inspect}" if matches.empty?
+        raise ArgumentError, "ambiguous Mendix artifact #{name.inspect}" if matches.size > 1
+
+        matches.first
+      end
+    end
+  end
+end

data/lib/mxrb/semantic/renamer.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Semantic
+    RenameChange = Data.define(:unit_id, :artifact, :path, :before, :after)
+
+    # Immutable preview plus the prepared BSON documents needed for an explicit
+    # apply. Construct plans through Project#plan_rename.
+    class RenamePlan
+      attr_reader :source, :target, :changes, :documents, :architecture
+
+      def initialize(project:, source:, target:, changes:, documents:, architecture: nil)
+        @project = project
+        @source = source
+        @target = target
+        @changes = changes.freeze
+        @documents = documents.freeze
+        @architecture = architecture
+        @applied = false
+      end
+
+      def empty? = @changes.empty?
+      def applied? = @applied
+      def affected_units = @documents.keys.freeze
+
+      def apply!
+        raise ArgumentError, "rename plan was already applied" if @applied
+
+        @project.mpr.transaction do
+          @documents.each { |unit_id, document| @project.mpr.update_unit(unit_id, document) }
+          @project.mpr.write_architecture_definition(@architecture) if @architecture
+        end
+        @project.refresh!
+        @applied = true
+        self
+      end
+    end
+
+    # Plans and applies model-wide renames without introducing a query
+    # language. Every changed BSON string is visible in the Ruby preview.
+    class Renamer
+      METADATA_FIELDS = %w[Documentation documentation Caption caption Text text].freeze
+
+      def initialize(project)
+        @project = project
+      end
+
+      def plan(source_name, to:, cross_module: false)
+        source = resolve(source_name)
+        target = qualified_target(source, to, cross_module: cross_module)
+        reject_collision(source, target)
+
+        changes = []
+        documents = {}
+        @project.all_units.each do |raw|
+          original = @project.parse_bson(raw)
+          transformed = transform(
+            original, source:, target:, unit_id: raw.fetch("UnitID"),
+            target_unit: source.unit_id == raw.fetch("UnitID"), changes:
+          )
+          documents[raw.fetch("UnitID")] = transformed unless transformed.equal?(original)
+        end
+        original_architecture = @project.architecture_definition
+        architecture = if original_architecture
+                         transform(
+                           original_architecture, source:, target:, unit_id: "architecture",
+                           target_unit: false, changes:
+                         )
+                       end
+
+        RenamePlan.new(
+          project: @project, source:, target:, changes:, documents:, architecture:
+        )
+      end
+
+      private
+
+      def resolve(name)
+        artifact = @project.find_artifact(name)
+        return artifact if artifact
+
+        matches = @project.semantic_index.find_all(name)
+        raise KeyError, "unknown Mendix artifact #{name.inspect}" if matches.empty?
+
+        kinds = matches.map(&:kind).uniq.join(", ")
+        raise ArgumentError, "ambiguous Mendix artifact #{name.inspect} (#{kinds})"
+      end
+
+      def qualified_target(source, value, cross_module: false)
+        requested = value.to_s
+        raise ArgumentError, "new name cannot be empty" if requested.empty?
+        unless requested.match?(/\A[A-Za-z_][A-Za-z0-9_.]*\z/)
+          raise ArgumentError, "invalid Mendix name #{requested.inspect}"
+        end
+
+        old_parts = source.qualified_name.split(".")
+        new_parts = requested.split(".")
+        target = if new_parts.one?
+                   (old_parts[0...-1] + new_parts).join(".")
+                 else
+                   requested
+                 end
+        unless target.split(".").length == old_parts.length
+          raise ArgumentError, "#{source.kind} rename must keep its qualification depth"
+        end
+        if !cross_module && old_parts.length > 1 && target.split(".")[0...-1] != old_parts[0...-1]
+          raise ArgumentError, "#{source.kind} rename cannot move the artifact to another container"
+        end
+        target
+      end
+
+      def reject_collision(source, target)
+        collisions = @project.semantic_index.find_all(target)
+                             .reject { _1.id == source.id }
+        return if collisions.empty?
+
+        raise ArgumentError, "Mendix artifact #{target.inspect} already exists"
+      end
+
+      def transform(
+        value, source:, target:, unit_id:, target_unit:, changes:, path: [],
+        target_object: false
+      )
+        case value
+        when Hash
+          transformed_hash(
+            value, source:, target:, unit_id:, target_unit:, changes:, path:,
+            target_object:
+          )
+        when Array
+          transformed_array(
+            value, source:, target:, unit_id:, target_unit:, changes:, path:,
+            target_object:
+          )
+        when String
+          transformed_string(
+            value, source:, target:, target_object:, field: path.last
+          ).tap do |replacement|
+            next if replacement == value
+
+            changes << RenameChange.new(
+              unit_id, source, path.map(&:to_s).freeze, value, replacement
+            )
+          end
+        else
+          value
+        end
+      end
+
+      def transformed_hash(value, **context)
+        object_id = IO::BsonCodec.extract_id(value["$ID"])
+        target_object = context.fetch(:target_unit) &&
+                        object_id == artifact_object_id(context.fetch(:source))
+        changed = false
+        result = value.each_with_object({}) do |(key, child), hash|
+          transformed = transform(
+            child, **context, target_object:, path: context.fetch(:path) + [key]
+          )
+          changed ||= !transformed.equal?(child)
+          hash[key] = transformed
+        end
+        changed ? result : value
+      end
+
+      def transformed_array(value, **context)
+        changed = false
+        result = value.each_with_index.map do |child, index|
+          transformed = transform(
+            child, **context, target_object: false,
+            path: context.fetch(:path) + [index]
+          )
+          changed ||= !transformed.equal?(child)
+          transformed
+        end
+        changed ? result : value
+      end
+
+      def transformed_string(value, source:, target:, target_object:, field:)
+        return value if METADATA_FIELDS.include?(field.to_s)
+
+        replacement = replace_qualified(value, source.qualified_name, target)
+        return replacement unless replacement == value
+        return value unless target_object && declaration_field?(field)
+
+        value == source.name ? target.split(".").last : value
+      end
+
+      def artifact_object_id(artifact)
+        artifact.id.sub(/\A(?:module|entity|attribute|association|unit):/, "")
+      end
+
+      def replace_qualified(value, source, target)
+        pairs = [[source, target]]
+        if source.count(".") == 2
+          pairs << [source.sub(/\.[^.]+\z/, "/\\0").sub("/.", "/"),
+                    target.sub(/\.[^.]+\z/, "/\\0").sub("/.", "/")]
+        end
+        pairs.reduce(value) do |current, (old_name, new_name)|
+          current.gsub(
+            /(?<![A-Za-z0-9_])#{Regexp.escape(old_name)}(?![A-Za-z0-9_])/,
+            new_name
+          )
+        end
+      end
+
+      def declaration_field?(field)
+        %w[Name name $QualifiedName].include?(field.to_s)
+      end
+    end
+  end
+end