mxrb 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 571786ae22b838daaa4700d7a99816653046f645a5d4f49ee29d155f4a05fa99
-  data.tar.gz: 4366822b4731a3604eb2be09ee1f4408fe93108229486b6b45528772022c709f
+  metadata.gz: a734dae7c32bec492facdf80e775897c3b31af47fc595f4d4096f2cd27f091ee
+  data.tar.gz: db3a5207301da5c8f384515adf334c5739fba69379aec3c69175a653e68beff2
 SHA512:
-  metadata.gz: 97f38f00ed166946e0ea54e30c940631c2dfd91d919a20c9b701e8df25acd0cb653a68ae6f0bee8eb0742333ec1c921fb523882200be48def5a3a827bfe82e99
-  data.tar.gz: 648bd2c542071702fb6e9ac44559bfac32dd6128c0bb666f24c0f058992db702a69be6815db9bbd9093d5e92928c836d61e4cb84e28235d2dbf4742a1acac3f3
+  metadata.gz: 4aedde89b67e5d52e438b38e2f2c9835a9ca2407950a6c7ee04f10aa74fb0d1e9fae0fc380b50e3c3155fc7509eb0d513e90461c8058949849f9c4146df162c7
+  data.tar.gz: ed923449e412dc172462c951373408558244983db0d84b38d2a550791219190146064d900e2b6eb459fc8e6aa250def2c62614854e1e8b25d13192a6b437bd6e

data/bin/mxrb

@@ -64,7 +64,9 @@ end
 
 SCAFFOLD_COMMANDS = (Mxrb::Scaffold::Help::COMMANDS.keys - ["design"]).freeze
 
+progress_disabled = ARGV.delete("--no-progress")
 command = ARGV.shift
+Mxrb::Progress.configure(enabled: false) if progress_disabled || ARGV.include?("--json")
 
 case command
 when '--version', '-v'
@@ -1506,6 +1508,7 @@ else
     mxrb — Pure-Ruby Mendix .mpr toolkit
 
     Commands:
+      --no-progress                         Disable interactive progress rendering
       --version, -v                         Show the installed MXRB version
       doctor     [DIR] [--json]           Check project files and local toolchain
       benchmark <file.mpr>                Measure open, index and validation time

data/docs/pt-BR/entity-dsl.md

@@ -94,6 +94,12 @@ entity :AnimalSearchResult do
   string :Name
 end
 
+entity :AnimalSummaryView do
+  oql_view source: "VetClinic.AnimalSummarySource"
+  string :Name
+  integer :Total
+end
+
 entity :Animal do
   before_commit microflow: "VetClinic.VAL_Animal"
   after_commit microflow: "VetClinic.ACT_AfterAnimalCommit"
@@ -111,6 +117,8 @@ end
 
 Em `access_rule`, `read:` e `write:` aceitam `:all`, `:none` ou uma lista de
 atributos. Declare um ou mais papéis qualificados como primeiros argumentos.
+`oql_view` liga a entidade ao `ViewEntitySourceDocument`; ao exportar um projeto
+existente, a consulta OQL aparece junto da entidade em `domain/oql_views`.
 
 Use `mxrb entity --help` para o comando e `mxrb generate project.rb` seguido de
 `mxrb validate App.mpr` para validar o resultado.

data/docs/pt-BR/writing.md

@@ -5,6 +5,12 @@
 `mxrb generate` avalia uma definição Ruby e cria ou atualiza o MPR. Nomes
 Mendix são chaves estáveis, portanto reaplicar a definição não duplica units.
 
+Operações demoradas exibem progresso em `stderr` quando executadas em um
+terminal interativo. Quando o total é conhecido, o MXRB mostra barra e
+porcentagem; operações externas sem total confiável mostram spinner e tempo
+decorrido. Pipes, redirecionamentos e saídas `--json` permanecem limpos. Use
+`--no-progress` ou `MXRB_PROGRESS=0` para desativar explicitamente.
+
 Para iniciar em uma pasta vazia:
 
 ```sh
@@ -122,6 +128,28 @@ usam `bson_binary`. Alterações nesse Ruby sobrepõem o baseline antes das escr
 tipadas. Corpos de flow possuem `body_fingerprint`: o grafo nativo é reutilizado
 quando o Ruby não mudou e regenerado após uma edição.
 
+Export mappings, import mappings e JSON structures são materializados por
+módulo em `infrastructure/mappings/{exports,imports,json_structures}`. Esses
+arquivos mantêm `UnitID` e container/pasta originais, podem editar toda a
+estrutura profunda em Ruby e têm precedência sobre o baseline durante o
+`generate`.
+
+Serviços REST, OData e web services publicados são exportados para
+`infrastructure/endpoints`; recursos, operações, métodos HTTP, paths,
+parâmetros e referências a microflows permanecem no mesmo arquivo Ruby.
+Serviços consumidos são roteados para `infrastructure/integrations`, enquanto
+message definitions e XML schemas ficam em `infrastructure/mappings`.
+
+O Domain Model exportado separa entidades persistentes em `domain/entities`,
+DTOs/non-persistent em `domain/dtos` e entidades de OQL View em
+`domain/oql_views`. O arquivo da OQL View também contém seu
+`DomainModels$ViewEntitySourceDocument`, portanto a consulta `Oql` pode ser
+editada no mesmo Ruby sem perder a referência da entidade. Datasets OQL ficam
+em `application/queries/datasets`; enumerations e constants ficam em
+`domain/enumerations` e `domain/constants`. Scheduled events ficam em
+`application/jobs/scheduled_events`. O `domain/model.rb` e o
+`application/application.rb` carregam automaticamente todas essas categorias.
+
 A DSL cobre criação/alteração/retrieve/commit/delete, chamadas de microflow,
 Java, JavaScript, nanoflow e app service, páginas, REST, listas, decisões,
 loops, eventos de erro e rescue.

data/lib/mxrb/compiler/packager.rb

@@ -19,16 +19,24 @@ module Mxrb
         @deployment = File.expand_path(deployment || File.join(@project_root, 'deployment'))
       end
 
-      def pack(output:, force: false)
-        output_path = File.expand_path(output)
-        validate_input!(output_path, force:)
-        version = Mxrb.open(@mpr_path, &:mendix_version)
-        adapter = Adapter.for(version)
-        metadata = adapter.validate_deployment!(@deployment)
-        adapter.validate_freshness!(@mpr_path, @deployment)
-        files, directories = inventory
-        write_atomically(output_path, files, directories)
-        package_result(output_path, version, metadata)
+      def pack(output:, force: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        Progress.with("Packing #{File.basename(@mpr_path)}") do |progress|
+          output_path = File.expand_path(output)
+          validate_input!(output_path, force:)
+          version = Mxrb.open(@mpr_path, &:mendix_version)
+          adapter = Adapter.for(version)
+          metadata = adapter.validate_deployment!(@deployment)
+          adapter.validate_freshness!(@mpr_path, @deployment)
+          files, directories = inventory
+          progress.update(
+            current: 3, total: files.size + directories.size + 4,
+            detail: "#{files.size} files"
+          )
+          write_atomically(output_path, files, directories, progress)
+          package_result(output_path, version, metadata).tap do
+            progress.advance(detail: 'package checksum')
+          end
+        end
       end
 
       private
@@ -69,13 +77,19 @@ module Mxrb
         path.delete_prefix("#{@deployment}/").tr('\\', '/')
       end
 
-      def write_atomically(output, files, directories)
+      def write_atomically(output, files, directories, progress) # rubocop:disable Metrics/MethodLength
         FileUtils.mkdir_p(File.dirname(output))
         Dir.mktmpdir('mxrb-mda-', File.dirname(output)) do |tmpdir|
           temporary = File.join(tmpdir, 'package.mda')
           Zip::File.open(temporary, create: true) do |archive|
-            directories.each { add_directory(archive, _1) }
-            files.each { add_file(archive, _1) }
+            directories.each do |directory|
+              add_directory(archive, directory)
+              progress.advance(detail: relative(directory))
+            end
+            files.each do |file|
+              add_file(archive, file)
+              progress.advance(detail: relative(file))
+            end
           end
           FileUtils.mv(temporary, output, force: true)
         end

data/lib/mxrb/compiler/portable_packager.rb

@@ -309,17 +309,22 @@ module Mxrb
         @mendix_home = mendix_home && File.expand_path(mendix_home)
       end
 
-      def pack(output:, force: false)
-        output_path = File.expand_path(output)
-        validate_output!(output_path, force:)
-        version = Mxrb.open(@mpr_path, &:mendix_version)
-        adapter = Adapter.for(version)
-        metadata = adapter.validate_deployment!(@deployment)
-        adapter.validate_freshness!(@mpr_path, @deployment)
-        runtime = runtime_root(version)
-        validate_runtime!(runtime)
-        PortableArchiveWriter.new(@deployment, runtime, metadata).write(output_path)
-        result(output_path, version, metadata)
+      def pack(output:, force: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        Progress.with("Packing portable Runtime for #{File.basename(@mpr_path)}") do |progress|
+          output_path = File.expand_path(output)
+          validate_output!(output_path, force:)
+          progress.update(detail: 'validating deployment')
+          version = Mxrb.open(@mpr_path, &:mendix_version)
+          adapter = Adapter.for(version)
+          metadata = adapter.validate_deployment!(@deployment)
+          adapter.validate_freshness!(@mpr_path, @deployment)
+          runtime = runtime_root(version)
+          validate_runtime!(runtime)
+          progress.update(detail: 'writing Runtime archive')
+          PortableArchiveWriter.new(@deployment, runtime, metadata).write(output_path)
+          progress.update(detail: 'calculating checksum')
+          result(output_path, version, metadata)
+        end
       end
 
       private

data/lib/mxrb/dsl/builder.rb

@@ -872,15 +872,21 @@ module Mxrb
         @scheduled_events << sb.to_h
       end
 
-      def native_document(name, type:, deep_structure:, containment: 'Documents')
+      def native_document(name, type:, deep_structure:, containment: 'Documents',
+                          unit_id: nil, container_id: nil)
         raise ArgumentError, 'deep_structure requires a Hash' unless deep_structure.is_a?(Hash)
 
         @native_documents << {
           name: name.to_s, type: type.to_s, containment: containment.to_s,
+          unit_id: unit_id&.to_s, container_id: container_id&.to_s,
           doc: { '$Type' => type.to_s, 'Name' => name.to_s }.merge(deep_structure)
         }
       end
 
+      def bson_binary(base64, subtype: :generic)
+        BSON::Binary.new(Base64.strict_decode64(base64), subtype.to_sym)
+      end
+
       # Native responsive application shell. It deliberately uses only Mendix
       # core widgets, so generated projects do not depend on Atlas Core merely
       # to display their navigation.
@@ -1070,6 +1076,7 @@ module Mxrb
         @generalization = nil
         @system_members = nil
         @indexes = nil
+        @oql_view = nil
       end
 
       ATTR_TYPES.each do |type|
@@ -1081,6 +1088,16 @@ module Mxrb
       def non_persistent!  = (@persistable = false)
       def documentation(d) = (@doc = d)
 
+      # Marks an entity as an OQL-backed view. Modern Mendix projects keep the
+      # query in a separate ViewEntitySourceDocument; older projects may keep
+      # it directly on the embedded entity.
+      def oql_view(source: nil, query: nil)
+        raise ArgumentError, 'oql_view requires source or query' if source.nil? && query.nil?
+
+        @oql_view = { source: source&.to_s, query: query&.to_s }.compact
+        @persistable = false
+      end
+
       def generalizes(entity)
         @generalization = entity.to_s
       end
@@ -1164,7 +1181,7 @@ module Mxrb
           name: @name, persistable: @persistable, documentation: @doc,
           attributes: @attributes, associations: @associations, lifecycle: @lifecycle,
           access_rules: @access_rules, generalization: @generalization,
-          system_members: @system_members, indexes: @indexes
+          system_members: @system_members, indexes: @indexes, oql_view: @oql_view
         }
       end
 

data/lib/mxrb/exporter.rb

@@ -9,6 +9,7 @@ module Mxrb
   # Exports an MPR into an editable, layered Ruby source tree.
   class Exporter
     LAYERS = %w[domain application presentation infrastructure].freeze
+    MODULE_PROGRESS_WEIGHT = 10
     MARKETPLACE_PROVENANCE = [
       ".mxrb/marketplace.lock.json",
       ".mxrb/marketplace",
@@ -63,22 +64,30 @@ module Mxrb
     end
 
     def export!(parallel: true)
-      FileUtils.mkdir_p(@output_dir)
-      Mxrb.open(@mpr_path) do |project|
-        @architecture = project.architecture_definition
-        export_app_structure
-        export_project_assets
-        export_native_units(project)
-        export_security(project)
-        export_architecture_contracts(project)
-        mods = project.modules
-        if parallel && mods.size > 1
-          threads = mods.map { |mod| Thread.new { export_module(mod) } }
-          threads.each(&:join)
-        else
-          mods.each { export_module(_1) }
+      Progress.with("Exporting #{File.basename(@mpr_path)}") do |progress|
+        FileUtils.mkdir_p(@output_dir)
+        Mxrb.open(@mpr_path) do |project|
+          @architecture = project.architecture_definition
+          units = project.all_units
+          modules = project.modules
+          assets = project_asset_files
+          progress.update(
+            current: 0,
+            total: 4 + assets.size + (units.size * 2) + (modules.size * MODULE_PROGRESS_WEIGHT),
+            detail: "preparing Ruby project"
+          )
+          export_app_structure
+          progress.advance(detail: "project structure")
+          export_project_assets(assets, progress)
+          export_native_units(project, units, progress)
+          export_security(project)
+          progress.advance(detail: "project security")
+          export_architecture_contracts(project)
+          progress.advance(detail: "navigation and design system")
+          export_modules(modules, progress, parallel:)
+          write_project(project)
+          progress.advance(detail: "project.rb")
         end
-        write_project(project)
       end
       @output_dir
     end
@@ -91,6 +100,8 @@ module Mxrb
 
       export_domain(root, mod)
       export_microflows(root, mod)
+      export_application_documents(root, mod)
+      export_infrastructure_documents(root, mod)
       export_pages(root, mod)
       export_menus(root, mod)
       export_nanoflows(root, mod)
@@ -106,25 +117,31 @@ module Mxrb
       ].each { write(File.join(@output_dir, _1, ".keep"), "") }
     end
 
-    def export_project_assets
+    def project_asset_files
       source_root = File.dirname(@mpr_path)
-      files = (Model::DesignSystem::ASSET_DIRECTORIES + MARKETPLACE_PROVENANCE).flat_map do |directory|
+      (Model::DesignSystem::ASSET_DIRECTORIES + MARKETPLACE_PROVENANCE).flat_map do |directory|
         root = File.join(source_root, directory)
         next [root] if File.file?(root) && !File.symlink?(root)
         next [] unless File.directory?(root) && !File.symlink?(root)
 
         Dir.glob(File.join(root, "**", "*"), File::FNM_DOTMATCH)
       end.select { File.file?(_1) && !File.symlink?(_1) }.sort
+    end
+
+    def export_project_assets(files, progress)
+      source_root = File.dirname(@mpr_path)
       entries = files.map do |source|
         relative = Pathname.new(source).relative_path_from(Pathname.new(source_root)).to_s
         target = File.join(@output_dir, relative)
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.cp(source, target)
-        {
+        result = {
           "path" => relative,
           "size" => File.size(source),
           "sha256" => Digest::SHA256.file(source).hexdigest
         }
+        progress.advance(detail: "asset #{relative}")
+        result
       end
       write(
         File.join(@output_dir, ".mxrb", "assets.json"),
@@ -132,8 +149,8 @@ module Mxrb
       )
     end
 
-    def export_native_units(project)
-      units = project.all_units.filter_map do |unit|
+    def export_native_units(project, project_units, progress)
+      units = project_units.filter_map do |unit|
         doc = project.parse_bson(unit)
         type = doc["$Type"]
         next if type.to_s.empty? || type == "Projects$Project"
@@ -147,16 +164,21 @@ module Mxrb
           "type" => type,
           "contents" => Base64.strict_encode64(IO::BsonCodec.serialize(doc))
         }
+      ensure
+        progress.advance(detail: "native baseline")
       end
       write(
         File.join(@output_dir, ".mxrb", "native_units.json"),
         JSON.pretty_generate("format_version" => project.format_version.to_s, "units" => units)
       )
-      source = project.all_units.filter_map do |unit|
+      source = project_units.filter_map do |unit|
         doc = project.parse_bson(unit)
         next if doc["$Type"].to_s.empty? || doc["$Type"] == "Projects$Project"
+        next if Model::Module::EDITABLE_DOCUMENT_TYPES.include?(doc["$Type"])
 
         native_unit_source(project, unit, doc)
+      ensure
+        progress.advance(detail: "editable native units")
       end
       write(
         File.join(@output_dir, ".mxrb", "native_units.rb"),
@@ -164,6 +186,18 @@ module Mxrb
       )
     end
 
+    def export_modules(modules, progress, parallel:)
+      operation = lambda do |mod|
+        export_module(mod)
+        progress.advance(MODULE_PROGRESS_WEIGHT, detail: "module #{mod.name}")
+      end
+      if parallel && modules.size > 1
+        modules.map { |mod| Thread.new { operation.call(mod) } }.each(&:join)
+      else
+        modules.each { operation.call(_1) }
+      end
+    end
+
     def native_unit_source(project, unit, doc)
       <<~RUBY
         native_unit #{ruby(unit.fetch("UnitID"))},
@@ -211,8 +245,10 @@ module Mxrb
 
     def export_module_scaffolding(root)
       %w[
-        domain/enumerations domain/rules domain/policies
-        application/ports/repositories application/queries application/validations application/jobs
+        domain/entities domain/dtos domain/oql_views domain/enumerations domain/constants
+        domain/rules domain/policies
+        application/ports/repositories application/queries application/queries/datasets
+        application/validations application/jobs application/jobs/scheduled_events
         presentation/features presentation/client_actions presentation/snippets presentation/view_models
         presentation/menus
         infrastructure/persistence/mendix infrastructure/persistence/external
@@ -238,26 +274,62 @@ module Mxrb
 
     def export_domain(root, mod)
       domain = File.join(root, "domain")
-      entities_dir = File.join(domain, "entities")
-      FileUtils.mkdir_p(entities_dir)
-
       associations = mod.associations.group_by(&:from_entity_id)
       architecture = architecture_module(mod.name)
-      entity_files = unique_entity_filenames(mod.entities)
+      paths = {}
+      grouped = mod.entities.group_by { entity_domain_route(_1) }
+      grouped.each do |route, entities|
+        unique_entity_filenames(entities).each do |id, filename|
+          paths[id] = File.join(route, filename)
+        end
+      end
+      domain_documents = mod.domain_documents
+      oql_documents = mod.oql_view_documents
+      attached_oql_documents = {}
       mod.entities.each do |entity|
         entity_metadata = architecture&.fetch(:entities, [])&.find { _1[:name] == entity.name }
+        source = entity_source(entity, mod, associations.fetch(entity.id, []), entity_metadata)
+        if oql_view_entity?(entity) && (document = oql_document_for(entity, oql_documents, mod.name))
+          source = "#{source.rstrip}\n\n#{native_document_declaration(document)}"
+          attached_oql_documents[document.fetch(:id)] = true
+        end
         write(
-          File.join(entities_dir, entity_files.fetch(entity.id)),
-          entity_source(entity, mod, associations.fetch(entity.id, []), entity_metadata)
+          File.join(domain, paths.fetch(entity.id)), source
         )
       end
-
-      loads = entity_files.values.sort.map do |filename|
-        %(evaluate File.join(__dir__, "entities", #{ruby(filename)}))
+      used = paths.values.to_h { [_1, true] }
+      domain_documents.reject { attached_oql_documents[_1.fetch(:id)] }.each do |document|
+        relative = unique_relative_path(document.fetch(:route), underscore(document.fetch(:name)), used)
+        write(File.join(domain, relative), mapping_document_source(document))
+        paths[document.fetch(:id)] = relative
+      end
+      loads = paths.values.sort.map do |relative|
+        segments = relative.split(File::SEPARATOR).map { ruby(_1) }.join(", ")
+        %(evaluate File.join(__dir__, #{segments}))
       end
       write(File.join(domain, "model.rb"), "#{loads.join("\n")}\n")
     end
 
+    def entity_domain_route(entity)
+      return 'oql_views' if oql_view_entity?(entity)
+      return 'dtos' unless entity.persistable
+
+      'entities'
+    end
+
+    def oql_view_entity?(entity)
+      entity.respond_to?(:oql_view?) && entity.oql_view?
+    end
+
+    def oql_document_for(entity, documents, module_name)
+      reference = entity.oql_source_document.to_s
+      return nil if reference.empty?
+
+      documents.find do |document|
+        [document.fetch(:name), "#{module_name}.#{document.fetch(:name)}"].include?(reference)
+      end
+    end
+
     def export_microflows(root, mod)
       files = unique_filenames(mod.microflows)
       by_layer = { "application" => [], "infrastructure" => [] }
@@ -296,6 +368,74 @@ module Mxrb
       write_path_aggregator(File.join(presentation, "presentation.rb"), paths)
     end
 
+    def export_infrastructure_documents(root, mod)
+      documents = mod.infrastructure_documents
+      return if documents.empty?
+
+      infrastructure = File.join(root, "infrastructure")
+      used = {}
+      paths = documents.map do |document|
+        base = underscore(document.fetch(:name))
+        relative = unique_relative_path(document.fetch(:route), base, used)
+        write(File.join(infrastructure, relative), mapping_document_source(document))
+        relative
+      end
+      append_to_aggregator(File.join(infrastructure, "infrastructure.rb"), paths)
+    end
+
+    def export_application_documents(root, mod)
+      documents = mod.application_documents
+      return if documents.empty?
+
+      application = File.join(root, 'application')
+      used = {}
+      paths = documents.map do |document|
+        relative = unique_relative_path(document.fetch(:route), underscore(document.fetch(:name)), used)
+        write(File.join(application, relative), mapping_document_source(document))
+        relative
+      end
+      append_to_aggregator(File.join(application, 'application.rb'), paths)
+    end
+
+    def unique_relative_path(directory, base, used)
+      candidate = File.join(directory, "#{base}.rb")
+      suffix = 2
+      while used[candidate]
+        candidate = File.join(directory, "#{base}_#{suffix}.rb")
+        suffix += 1
+      end
+      used[candidate] = true
+      candidate
+    end
+
+    def mapping_document_source(document)
+      <<~RUBY
+        # frozen_string_literal: true
+
+        #{native_document_declaration(document)}
+      RUBY
+    end
+
+    def native_document_declaration(document)
+      <<~RUBY.rstrip
+        native_document #{symbol(document.fetch(:name))},
+                        type: #{ruby(document.fetch(:type))},
+                        unit_id: #{ruby(document.fetch(:id))},
+                        container_id: #{ruby(document.fetch(:container_id))},
+                        containment: #{ruby(document.fetch(:containment))},
+                        deep_structure: #{native_ruby(document.fetch(:doc), 24)}
+      RUBY
+    end
+
+    def append_to_aggregator(path, relative_paths)
+      existing = File.exist?(path) ? File.read(path).lines : []
+      additions = relative_paths.sort.map do |relative|
+        segments = relative.split(File::SEPARATOR).map { ruby(_1) }.join(", ")
+        "evaluate File.join(__dir__, #{segments})\n"
+      end
+      write(path, (existing + additions).uniq.join)
+    end
+
     def export_menus(root, mod)
       menus = mod.menus
       return if menus.empty?
@@ -586,6 +726,12 @@ module Mxrb
       end
       flags = []
       flags << "  non_persistent!" unless entity.persistable
+      if oql_view_entity?(entity)
+        options = []
+        options << "source: #{ruby(entity.oql_source_document)}" if entity.oql_source_document
+        options << "query: #{ruby(entity.oql_query)}" unless entity.oql_query.to_s.empty?
+        flags << "  oql_view #{options.join(', ')}" unless options.empty?
+      end
       flags << "  documentation #{ruby(entity.documentation)}" unless entity.documentation.to_s.empty?
       generalization = entity.respond_to?(:generalization_target) ? entity.generalization_target : nil
       flags << "  generalizes #{ruby(generalization)}" if generalization

data/lib/mxrb/integrity/validator.rb

@@ -11,19 +11,26 @@ module Mxrb
     class Validator
       def initialize(path)
         @path = path
+        @progress = Progress::NullTask.instance
       end
 
       def validate
-        @errors = []
-        @warnings = []
-        @mpr = IO::MprFile.open(@path, readonly: true)
-        validate_tables
-        validate_units
-        validate_v2_files
-        Result.new(errors: @errors, warnings: @warnings)
+        Progress.with("Validating #{File.basename(@path)}") do |progress|
+          @progress = progress
+          @errors = []
+          @warnings = []
+          @mpr = IO::MprFile.open(@path, readonly: true)
+          validate_tables
+          progress.advance(detail: "MPR tables")
+          validate_units
+          validate_v2_files
+          progress.advance(detail: "v2 contents")
+          Result.new(errors: @errors, warnings: @warnings)
+        end
       rescue Error => e
         Result.new(errors: [e.message], warnings: @warnings || [])
       ensure
+        @progress = Progress::NullTask.instance
         @mpr&.close
       end
 
@@ -40,8 +47,10 @@ module Mxrb
 
       def validate_units
         @units = @mpr.all_units
+        @progress.update(total: @units.size + 3, detail: "#{@units.size} units")
         validate_root
         validate_unit_ids
+        @progress.advance(detail: "unit tree")
         validate_contents
       end
 
@@ -78,6 +87,8 @@ module Mxrb
           next unless doc
 
           validate_doc_identity(unit, doc)
+        ensure
+          @progress&.advance(detail: "unit #{unit['UnitID']}")
         end
       end
 

data/lib/mxrb/model/entity.rb

@@ -10,7 +10,7 @@ module Mxrb
       attr_accessor :id, :name, :qualified_name, :documentation,
                     :persistable, :location, :data_storage_guid,
                     :export_level, :generalization, :access_rules, :indexes,
-                    :system_members
+                    :system_members, :source, :oql_query, :native_type
 
       # Build from a BSON hash (embedded in DomainModel's "entities" array).
       def self.from_bson(doc, _domain_model_id, mpr)
@@ -19,6 +19,9 @@ module Mxrb
         e.name               = doc["name"]  || doc["Name"]
         e.qualified_name     = doc["$QualifiedName"] || doc["\$QualifiedName"]
         e.documentation      = doc["documentation"] || doc["Documentation"] || ""
+        e.native_type        = doc["$Type"]
+        e.source             = doc["source"] || doc["Source"]
+        e.oql_query          = doc["oqlQuery"] || doc["OqlQuery"] || doc["OQLQuery"]
         e.data_storage_guid  = doc["dataStorageGuid"] || doc["DataStorageGuid"]
         e.export_level       = doc["exportLevel"] || doc["ExportLevel"] || "Hidden"
         e.location           = parse_location(doc["location"] || doc["Location"])
@@ -58,6 +61,19 @@ module Mxrb
         @generalization['generalization'] || @generalization['Generalization']
       end
 
+      def oql_view?
+        source_type = @source.is_a?(Hash) ? @source.fetch('$Type', '') : ''
+        @native_type.to_s.match?(/ViewEntity/i) ||
+          source_type.match?(/OqlViewEntitySource/i) ||
+          !@oql_query.to_s.empty?
+      end
+
+      def oql_source_document
+        return unless @source.is_a?(Hash)
+
+        @source['SourceDocument'] || @source['sourceDocument']
+      end
+
       def to_bson
         {
           "$ID"             => @id,