mxrb 0.1.0

data/lib/mxrb/compiler/project_materializer.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Mxrb
+  module Compiler
+    ProjectMaterialization = Data.define(:model_path, :modules, :documents)
+
+    # Rebuilds the Runtime project/module index after native document materialization.
+    class ProjectMaterializer # rubocop:disable Metrics/ClassLength
+      EDITORIAL_TYPES = %w[
+        Projects$ModuleSettings Security$ModuleSecurity Folders$Folder Projects$Folder
+      ].freeze
+
+      def initialize(mpr_path, deployment:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize
+        source = SourceModel.read(@mpr_path)
+        path = File.join(@deployment, 'model', 'model.mdp')
+        package = ModelPackage.read(path)
+        project = compile_project(source, package, project_unit(source))
+        package = write_modules(source, package)
+        package = package.upsert(project)
+        package = ensure_deployment_header(package, source)
+        package = ProjectModelOrderer.new(package, project).order
+        package.write(path)
+        result(path, project)
+      end
+
+      private
+
+      def compile_project(source, package, unit)
+        existing = package.find(unit.id)&.document
+        {
+          '$ID' => unit.document['$ID'], '$Type' => unit.document['$Type'],
+          'ProjectDocuments' => project_documents(source, package, existing),
+          'Modules' => preserved_modules(source, existing, package) + compiled_modules(source, package)
+        }
+      end
+
+      def project_documents(source, package, existing)
+        units = source.units.select { _1.containment == 'ProjectDocuments' }
+        source_documents = units.filter_map { reference(_1, package) }
+        source_ids = source_documents.filter_map { IO::BsonCodec.extract_id(_1['$ID']) }
+        preserved = Array(existing&.fetch('ProjectDocuments', nil)).reject do |document|
+          source_ids.include?(IO::BsonCodec.extract_id(document['$ID']))
+        end
+        preserved + source_documents
+      end
+
+      def compile_module(source, package, module_unit) # rubocop:disable Metrics/AbcSize
+        units = source.units.select { _1.module_name == module_unit.document['Name'] }
+        domain = units.find { _1.document['$Type'] == 'DomainModels$DomainModel' }
+        documents = units.reject { skip_document?(_1, module_unit, domain) }
+                         .filter_map { reference(_1, package) }
+        {
+          '$ID' => module_unit.document['$ID'], '$Type' => module_unit.document['$Type'],
+          'DomainModel' => reference(domain, package), 'AllDocuments' => documents
+        }
+      end
+
+      def skip_document?(unit, module_unit, domain)
+        unit == module_unit || unit == domain || EDITORIAL_TYPES.include?(unit.document['$Type'])
+      end
+
+      def reference(unit, package)
+        return nil unless unit && package.find(unit.id)
+
+        { '$ID' => unit.document['$ID'], '$Type' => unit.document['$Type'] }
+      end
+
+      def project_unit(source)
+        source.units.find { _1.document['$Type'] == 'Projects$Project' } ||
+          raise(CompilationError, 'MPR has no project document')
+      end
+
+      def preserved_modules(source, existing, package)
+        return seeded_modules(source, package) unless existing
+
+        source_ids = source.units_of('Projects$ModuleImpl').map(&:id)
+        existing.fetch('Modules').reject { source_ids.include?(IO::BsonCodec.extract_id(_1['$ID'])) }
+      end
+
+      def seeded_modules(source, package)
+        return [] unless package.find(SystemModelSeed::MODULE_ID)
+
+        seed = SystemModelSeed.for(source.version)
+        [seed.module_reference]
+      end
+
+      def compiled_modules(source, package)
+        source.units_of('Projects$ModuleImpl').map { compile_module(source, package, _1) }
+      end
+
+      def write_modules(source, package)
+        source.units_of('Projects$ModuleImpl').reduce(package) do |result, unit|
+          document = {
+            '$ID' => unit.document['$ID'], '$Type' => unit.document['$Type'],
+            'Name' => unit.document['Name']
+          }
+          result.upsert(document)
+        end
+      end
+
+      def result(path, project)
+        modules = project.fetch('Modules')
+        ProjectMaterialization.new(
+          model_path: path, modules: modules.length, documents: document_count(modules)
+        )
+      end
+
+      def document_count(modules) = modules.sum { _1.fetch('AllDocuments').length }
+
+      def deployment_header?(package)
+        package.documents.any? do |document|
+          document['$Type'] == 'Projects$Project' && document.key?('DeploymentID')
+        end
+      end
+
+      def ensure_deployment_header(package, source)
+        return package if deployment_header?(package)
+
+        package.with_appended(deployment_header(source, project_unit(source)))
+      end
+
+      def deployment_header(source, unit)
+        {
+          '$ID' => unit.document['$ID'], '$Type' => unit.document['$Type'],
+          'DeploymentID' => Digest::SHA256.hexdigest(unit.id)[0, 16].to_i(16).to_s,
+          'RuntimeVersion' => source.version, 'ModelVersion' => 'unversioned',
+          'SprintrProjectName' => File.basename(source.path, File.extname(source.path))
+        }
+      end
+    end # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/mxrb/compiler/project_model_orderer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Orders model documents so containers precede children during Runtime resolution.
+    class ProjectModelOrderer
+      def initialize(package, project)
+        @package = package
+        @project = project
+      end
+
+      def order
+        ordered = [@project, deployment_header]
+        ordered.concat(resolve(@project.fetch('ProjectDocuments')))
+        @project.fetch('Modules').each { append_module(ordered, _1) }
+        ordered.compact!
+        ordered.concat(remaining(ordered))
+        ModelPackage.from_documents(ordered)
+      end
+
+      private
+
+      def append_module(ordered, mod)
+        ordered.concat(resolve([mod]))
+        ordered.concat(resolve([mod.fetch('DomainModel')]))
+        ordered.concat(resolve(mod.fetch('AllDocuments')))
+      end
+
+      def resolve(references)
+        Array(references).filter_map do |reference|
+          next unless reference
+
+          id = IO::BsonCodec.extract_id(reference['$ID'])
+          @package.entries.find { _1.id == id && !header?(_1.document) }&.document
+        end
+      end
+
+      def deployment_header = @package.documents.find { header?(_1) }
+
+      def remaining(ordered)
+        used = ordered.map(&:object_id)
+        @package.documents.reject do |document|
+          used.include?(document.object_id) || document.equal?(@project) || header?(document)
+        end
+      end
+
+      def header?(document)
+        document['$Type'] == 'Projects$Project' && document.key?('DeploymentID')
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/runtime_data_types.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Maps editable MPR data-type documents to Runtime type identifiers.
+    module RuntimeDataTypes
+      SCALARS = {
+        'DataTypes$VoidType' => 'Void', 'DataTypes$StringType' => 'String',
+        'DataTypes$BooleanType' => 'Boolean', 'DataTypes$IntegerType' => 'Integer',
+        'DataTypes$DecimalType' => 'Decimal', 'DataTypes$DateTimeType' => 'DateTime'
+      }.freeze
+
+      private
+
+      def data_type(document) # rubocop:disable Metrics/AbcSize
+        return 'Void' unless document
+        return SCALARS.fetch(document['$Type']) if SCALARS.key?(document['$Type'])
+        return document['Entity'].to_s if document['$Type'] == 'DataTypes$ObjectType'
+        return "[#{document['Entity']}]" if document['$Type'] == 'DataTypes$ListType'
+        return "##{document['Enumeration']}" if document['$Type'] == 'DataTypes$EnumerationType'
+        return 'Unknown' if document['$Type'] == 'DataTypes$UnknownType'
+
+        raise CompilationError, "unsupported Runtime data type #{document['$Type']}"
+      end # rubocop:enable Metrics/AbcSize
+
+      def data_type_document?(value)
+        value.is_a?(Hash) && value['$Type'].to_s.start_with?('DataTypes$')
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/runtime_model_schema.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Learns ordered Runtime BSON fields and existing compiled values from model.mdp.
+    class RuntimeModelSchema
+      DEFAULT_FIELDS = JSON.parse(
+        File.read(File.join(__dir__, 'schemas', 'runtime-11.json'))
+      ).transform_values(&:freeze).freeze
+      AUDITED_FIELDS = Dir[File.join(__dir__, 'schemas', 'runtime-*.json')].sort.reduce(DEFAULT_FIELDS) do |all, path|
+        all.merge(JSON.parse(File.read(path)).transform_values(&:freeze))
+      end.freeze
+      def self.builtin_fields(version)
+        return DEFAULT_FIELDS unless version
+
+        seed_version = SystemModelSeed.seed_version_for(version)
+        path = schema_path(seed_version)
+        return DEFAULT_FIELDS unless path
+
+        versioned = JSON.parse(File.read(path)).transform_values(&:freeze)
+        AUDITED_FIELDS.merge(versioned).freeze
+      end
+
+      def self.schema_path(version)
+        exact = File.join(__dir__, 'schemas', "runtime-#{version}.json")
+        major = File.join(__dir__, 'schemas', "runtime-#{version.to_s.split('.').first}.json")
+        [exact, major].find { File.file?(_1) }
+      end
+
+      def initialize(package, version: nil)
+        @by_id = {}
+        @by_qualified_name = {}
+        @fields = Hash.new { |hash, key| hash[key] = [] }
+        @builtin_fields = self.class.builtin_fields(version)
+        @versioned_fields = versioned_fields(version)
+        package.documents.each { index(_1) }
+      end
+
+      def counterpart(source)
+        @by_id[IO::BsonCodec.extract_id(source['$ID'])]
+      end
+
+      def counterpart_id(id) = @by_id[IO::BsonCodec.extract_id(id)]
+      def named(qualified_name) = @by_qualified_name[qualified_name]
+
+      def fields_for(source) # rubocop:disable Metrics/AbcSize
+        return @versioned_fields.fetch(source['$Type']) if @versioned_fields.key?(source['$Type'])
+
+        existing = counterpart(source)
+        return existing.keys if existing && existing['$Type'] == source['$Type']
+        return @builtin_fields.fetch(source['$Type']) if @builtin_fields.key?(source['$Type'])
+
+        candidates = @fields.fetch(source['$Type'], [])
+        raise CompilationError, "no Runtime schema for #{source['$Type']}" if candidates.empty?
+
+        candidates.max_by(&:length)
+      end # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def versioned_fields(version)
+        return {} unless version
+
+        seed_version = SystemModelSeed.seed_version_for(version)
+        path = self.class.schema_path(seed_version)
+        path ? JSON.parse(File.read(path)) : {}
+      end
+
+      def index(value)
+        case value
+        when Hash then index_document(value)
+        when Array then value.each { index(_1) }
+        end
+      end
+
+      def index_document(document)
+        type = document['$Type']
+        if type
+          @fields[type] << document.keys unless @fields[type].include?(document.keys)
+          id = IO::BsonCodec.extract_id(document['$ID'])
+          @by_id[id] = document if id
+          @by_qualified_name[document['QualifiedName']] = document if document['QualifiedName']
+        end
+        document.each_value { index(_1) }
+      end
+    end
+  end
+end