mxrb 0.1.2 → 0.1.4

data/lib/mxrb/writer.rb

@@ -31,24 +31,55 @@ module Mxrb
     def initialize(path, definition)
       @path = File.expand_path(path)
       @definition = definition
+      @progress = Progress::NullTask.instance
     end
 
     def write!
-      create_project! unless File.exist?(@path)
-      mpr = IO::MprFile.open(@path)
-      mpr.transaction do
-        apply(mpr)
-        mpr.write_architecture_definition(@definition)
-      end
-      materialize_project_assets
-      materialize_design_system
+      mpr = nil
+      native_units = prepared_native_units
+      asset_manifest = project_asset_manifest
+      total = 4 + native_units.count { _1["containment"] != "Modules" } +
+              @definition.fetch(:modules).size + Array(asset_manifest&.fetch("files", [])).size
+      Progress.with("Generating #{File.basename(@path)}", total:) do |progress|
+        @progress = progress
+        create_project! unless File.exist?(@path)
+        progress.advance(detail: "project container")
+        mpr = IO::MprFile.open(@path)
+        mpr.transaction do
+          apply(mpr, native_units)
+          write_native_compatibility(mpr, native_units)
+          mpr.write_architecture_definition(@definition)
+          mpr.write_ruby_app_sources(ruby_app_source_files) if @definition[:ruby_app_sources_path]
+        end
+        progress.advance(detail: "model transaction")
+        materialize_project_assets(asset_manifest)
+        materialize_design_system
+        progress.advance(detail: "design system")
+      end
       self
     ensure
+      @progress = Progress::NullTask.instance
       mpr&.close
     end
 
     private
 
+    def ruby_app_source_files
+      path = @definition.fetch(:ruby_app_sources_path)
+      manifest = JSON.parse(File.read(path))
+      manifest.fetch("files").map do |file|
+        relative = safe_asset_path(file.fetch("path"))
+        contents = Base64.strict_decode64(file.fetch("contents"))
+        checksum = Digest::SHA256.hexdigest(contents)
+        raise SerializationError, "Ruby source checksum mismatch: #{relative}" \
+          unless checksum == file.fetch("sha256")
+
+        { path: relative, contents:, sha256: checksum, mode: file.fetch("mode", 0o644) }
+      end
+    rescue JSON::ParserError, KeyError, ArgumentError => e
+      raise SerializationError, "invalid Ruby source manifest: #{e.message}"
+    end
+
     def materialize_design_system
       design_system = @definition[:design_system]
       return unless design_system
@@ -56,11 +87,17 @@ module Mxrb
       Model::DesignMaterializer.new(File.dirname(@path), design_system).materialize!
     end
 
-    def materialize_project_assets
+    def project_asset_manifest
       assets = @definition[:project_assets]
       return unless assets
 
-      manifest = JSON.parse(File.read(assets.fetch(:manifest)))
+      JSON.parse(File.read(assets.fetch(:manifest)))
+    end
+
+    def materialize_project_assets(manifest)
+      assets = @definition[:project_assets]
+      return unless assets && manifest
+
       source_root = File.realpath(assets.fetch(:root))
       target_root = File.dirname(@path)
       manifest.fetch("files").each do |entry|
@@ -79,6 +116,7 @@ module Mxrb
         FileUtils.mv(temporary, target)
       ensure
         FileUtils.rm_f(temporary) if temporary
+        @progress.advance(detail: "asset #{relative}") if defined?(relative) && relative
       end
     end
 
@@ -161,7 +199,7 @@ module Mxrb
       JSON.parse(File.read(path))["format_version"]
     end
 
-    def apply(mpr)
+    def apply(mpr, native_units)
       root = mpr.root_unit
       root_id = root.fetch("UnitID")
       root_doc = mpr.parse_contents(root)
@@ -171,10 +209,6 @@ module Mxrb
         "IsSystemProject" => false
       }
       mpr.update_unit(root_id, root_doc)
-      native_units = load_native_units(@definition[:native_units_path])
-      native_units = apply_native_unit_overrides(
-        native_units, @definition.fetch(:native_unit_overrides, [])
-      )
       apply_native_project_units(mpr, root_id, native_units)
       apply_default_project_units(mpr, root_id)
       ensure_project_documents(mpr, root_id)
@@ -194,9 +228,18 @@ module Mxrb
         write_module_security(mpr, module_id, mod) if mod.key?(:module_roles)
         write_domain_model(mpr, module_id, mod)
         write_documents(mpr, module_id, mod)
+        @progress.advance(detail: "module #{mod.fetch(:name)}")
       end
       write_project_security(mpr, root_id, @definition[:security]) if @definition[:security]
       write_project_navigation(mpr, root_id, @definition[:navigation]) if @definition[:navigation]
+      @progress.advance(detail: "project security and navigation")
+    end
+
+    def prepared_native_units
+      apply_native_unit_overrides(
+        load_native_units(@definition[:native_units_path]),
+        @definition.fetch(:native_unit_overrides, [])
+      )
     end
 
     def load_native_units(path)
@@ -323,8 +366,21 @@ module Mxrb
       mod.fetch(:native_documents, []).each do |document|
         doc = document.fetch(:doc)
         doc = legacy_layout_doc(doc) if doc['$Type'] == 'Forms$Layout' && legacy_layout?
+        existing = mpr.unit(document[:unit_id]) if document[:unit_id]
+        if existing
+          current = mpr.parse_contents(existing)
+          preserved = current.merge(doc).merge(
+            '$ID' => current['$ID'] || existing.fetch('UnitID'),
+            '$Type' => doc['$Type'] || doc[:'$Type'] || document.fetch(:type)
+          )
+          mpr.update_unit(existing.fetch('UnitID'), preserved)
+          next
+        end
+
+        requested_container = document[:container_id]
+        target_container = requested_container && mpr.unit(requested_container) ? requested_container : module_id
         upsert_native_unit(
-          mpr, module_id,
+          mpr, target_container,
           'containment' => document.fetch(:containment), 'doc' => doc
         )
       end
@@ -365,7 +421,10 @@ module Mxrb
 
     def apply_native_unit_tree(mpr, target_root_id, units)
       if units.any? { _1["unit_id"].to_s.empty? || _1["container_id"].to_s.empty? }
-        units.each { upsert_native_unit(mpr, target_root_id, _1) }
+        units.each do |unit|
+          upsert_native_unit(mpr, target_root_id, unit)
+          @progress.advance(detail: "native unit #{unit['name']}")
+        end
         return
       end
 
@@ -382,6 +441,7 @@ module Mxrb
           target_container = mapped_containers.fetch(unit.fetch("container_id"))
           actual_id = upsert_native_unit(mpr, target_container, unit)
           mapped_containers[unit.fetch("unit_id")] = actual_id
+          @progress.advance(detail: "native unit #{unit['name']}")
         end
         pending = blocked
       end
@@ -390,26 +450,59 @@ module Mxrb
     def upsert_native_unit(mpr, container_id, unit)
       doc = unit.fetch("doc")
       name = doc["Name"] || doc["name"]
-      existing = if name.to_s.empty?
-        mpr.children_of(container_id).find { mpr.parse_contents(_1)["$Type"] == doc["$Type"] }
-      else
-        mpr.children_of(container_id).find do |raw|
-          existing_doc = mpr.parse_contents(raw)
-          (existing_doc["Name"] || existing_doc["name"]) == name && existing_doc["$Type"] == doc["$Type"]
-        end
-      end
+      requested_id = unit["unit_id"].to_s
+      requested_id = nil if requested_id.empty?
+      stable = mpr.unit(requested_id) if requested_id
+      existing = stable if stable && mpr.parse_contents(stable)["$Type"] == doc["$Type"]
+      candidates = mpr.children_of(container_id)
+      existing ||= if name.to_s.empty?
+                     candidates.find { mpr.parse_contents(_1)["$Type"] == doc["$Type"] }
+                   else
+                     candidates.find do |raw|
+                       existing_doc = mpr.parse_contents(raw)
+                       (existing_doc["Name"] || existing_doc["name"]) == name &&
+                         existing_doc["$Type"] == doc["$Type"]
+                     end
+                   end
       if existing
         current = mpr.parse_contents(existing)
         preserved = {
           "$ID" => current["$ID"] || existing.fetch("UnitID"),
           "$Type" => doc["$Type"]
         }.merge(current).merge(doc)
+        preserved["$ID"] = current["$ID"] || existing.fetch("UnitID") unless existing.equal?(stable)
         mpr.update_unit(existing.fetch("UnitID"), preserved)
         existing.fetch("UnitID")
       else
         containment = unit.fetch("containment")
-        mpr.insert_unit(container_uuid: container_id, containment_name: containment, contents_doc: doc)
+        inserted_id = stable ? SecureRandom.uuid : requested_id
+        inserted_doc = stable ? doc.merge("$ID" => inserted_id) : doc
+        mpr.insert_unit(
+          container_uuid: container_id,
+          containment_name: containment,
+          contents_doc: inserted_doc,
+          unit_uuid: inserted_id
+        )
+      end
+    end
+
+    def write_native_compatibility(mpr, native_units)
+      mismatches = native_units.filter_map do |unit|
+        unit_id = unit["unit_id"].to_s
+        doc = unit.fetch("doc")
+        content_id = IO::BsonCodec.extract_id(doc["$ID"]).to_s
+        next if unit_id.empty? || content_id.empty? || unit_id == content_id
+
+        raw = mpr.unit(unit_id)
+        next unless raw
+
+        written = mpr.parse_contents(raw)
+        written_id = IO::BsonCodec.extract_id(written["$ID"]).to_s
+        next unless written_id == content_id && written["$Type"] == doc["$Type"]
+
+        { unit_id: unit_id, content_id: content_id, type: doc["$Type"] }
       end
+      mpr.write_legacy_unit_identity_mismatches(mismatches)
     end
 
     def write_project_security(mpr, root_id, security)
@@ -858,6 +951,7 @@ module Mxrb
       doc.delete("__mxrb_preserve_native_body")
       doc.delete("__mxrb_deep_structure_declared")
       doc.delete("__mxrb_allow_concurrent_execution_declared")
+      doc.delete("__mxrb_apply_entity_access_declared")
       doc.delete("__mxrb_mark_as_used_declared")
       doc.delete("__mxrb_excluded_declared")
       strip_nested_internal_keys(doc)
@@ -894,15 +988,61 @@ module Mxrb
     def configure_pluggable_widget!(widget, options)
       properties = custom_widget_properties(widget)
       options.fetch(:properties, {}).each do |key, configured|
-        value = properties.dig(key.to_s, "Value")
-        next unless value
+        property = properties[key.to_s]
+        configure_custom_widget_value!(property, configured) if property
+      end
+    end
+
+    def configure_custom_widget_value!(property, configured)
+      value = property.fetch('Value')
+      unless configured.is_a?(Hash)
+        value['PrimitiveValue'] = configured.to_s unless configured.nil?
+        return value
+      end
+      return value.merge!(stringify_keys(configured)) unless semantic_widget_value?(configured)
+
+      configured = configured.to_h { |key, item| [key.to_sym, item] }
+      value['PrimitiveValue'] = configured[:primitive].to_s if configured.key?(:primitive)
+      value['Expression'] = configured[:expression].to_s if configured.key?(:expression)
+      value['Selection'] = configured[:selection].to_s if configured.key?(:selection)
+      value['TextTemplate'] = client_template_doc(configured[:text]) if configured.key?(:text)
+      value['AttributeRef'] = attribute_ref_doc(configured[:attribute]) if configured.key?(:attribute)
+      value['EntityRef'] = indirect_entity_ref_doc(configured[:association]) if configured.key?(:association)
+      configure_widget_data_source!(value, configured[:data_source]) if configured.key?(:data_source)
+      configure_widget_children!(value, configured[:widgets]) if configured.key?(:widgets)
+      configure_widget_objects!(property, value, configured[:objects]) if configured.key?(:objects)
+      value
+    end
+
+    def semantic_widget_value?(value)
+      value.is_a?(Hash) && (value.keys.map(&:to_sym) & %i[
+        primitive expression selection text attribute association data_source widgets objects
+      ]).any?
+    end
 
-        if configured.is_a?(Hash)
-          value.merge!(stringify_keys(configured))
-        elsif !configured.nil?
-          value["PrimitiveValue"] = configured.to_s
+    def configure_widget_data_source!(value, configured)
+      options = configured.is_a?(Hash) ? configured : { entity: configured }
+      value['DataSource'] = custom_xpath_source_doc(
+        options.fetch(:entity), xpath: options.fetch(:xpath, '')
+      )
+    end
+
+    def configure_widget_children!(value, widgets)
+      children = (widgets.is_a?(Array) ? widgets : [widgets]).compact.map { widget_doc(_1) }
+      value['Widgets'] = IO::BsonCodec.build_array(children, marker: 2)
+    end
+
+    def configure_widget_objects!(property, value, configurations)
+      object_type = property.dig('ValueType', 'ObjectType')
+      objects = Array(configurations).map do |configuration|
+        object = custom_widget_object_doc(object_type)
+        nested = widget_object_properties(object_type, object)
+        configuration.each do |key, configured|
+          configure_custom_widget_value!(nested.fetch(key.to_s), configured)
         end
+        object
       end
+      value['Objects'] = IO::BsonCodec.build_array(objects, marker: 2)
     end
 
     def stringify_keys(value)
@@ -946,6 +1086,15 @@ module Mxrb
       if options[:entity] && properties["datasource"]
         properties["datasource"]["Value"]["DataSource"] = custom_xpath_source_doc(options[:entity])
       end
+      if options[:selection] && properties['itemSelection']
+        properties.dig('itemSelection', 'Value')['Selection'] = options[:selection].to_s
+      end
+      if properties['filtersPlaceholder'] && options[:filters]
+        configured_filters = options[:filters].is_a?(Array) ? options[:filters] : [options[:filters]]
+        filters = configured_filters.map { widget_doc(_1) }
+        properties.dig('filtersPlaceholder', 'Value')['Widgets'] =
+          IO::BsonCodec.build_array(filters, marker: 2)
+      end
       return unless properties["columns"] && options[:columns]
 
       column_type = properties["columns"].dig("ValueType", "ObjectType")
@@ -1011,16 +1160,20 @@ module Mxrb
     end
 
     def custom_widget_properties(widget)
-      types = array_items(widget.dig("Type", "ObjectType", "PropertyTypes")).to_h do |type|
+      widget_object_properties(widget.dig('Type', 'ObjectType'), widget['Object'])
+    end
+
+    def widget_object_properties(object_type, object)
+      types = array_items(object_type&.fetch('PropertyTypes', nil)).to_h do |type|
         [IO::BsonCodec.extract_id(type["$ID"]), type]
       end
-      array_items(widget.dig("Object", "Properties")).to_h do |property|
+      array_items(object&.fetch('Properties', nil)).to_h do |property|
         type = types[IO::BsonCodec.extract_id(property["TypePointer"])]
         [type && type["PropertyKey"], property.merge("ValueType" => type && type["ValueType"])]
       end.compact
     end
 
-    def custom_xpath_source_doc(entity)
+    def custom_xpath_source_doc(entity, xpath: '')
       {
         "$ID" => SecureRandom.uuid, "$Type" => "CustomWidgets$CustomWidgetXPathSource",
         "EntityRef" => {
@@ -1032,19 +1185,24 @@ module Mxrb
           "$ID" => SecureRandom.uuid, "$Type" => "Forms$GridSortBar",
           "SortItems" => IO::BsonCodec.build_array([], marker: 2)
         },
-        "SourceVariable" => nil, "XPathConstraint" => ""
+        "SourceVariable" => nil, "XPathConstraint" => xpath.to_s
       }
     end
 
     def data_grid2_column_doc(object_type, column, entity: nil)
       attribute = column[:attribute]
       attribute = "#{entity}.#{attribute}" if entity && attribute && !attribute.include?('.')
+      filters = column[:filter].is_a?(Array) ? column[:filter] : [column[:filter]].compact
       overrides = {
         "showContentAs" => { "PrimitiveValue" => "attribute" },
         "attribute" => { "AttributeRef" => attribute_ref_doc(attribute) },
         "header" => { "TextTemplate" => client_template_doc(column[:caption] || column[:name]) },
         "tooltip" => { "TextTemplate" => empty_client_template_doc },
-        "filter" => { "TextTemplate" => empty_client_template_doc }
+        "filter" => {
+          "Widgets" => IO::BsonCodec.build_array(
+            filters.map { widget_doc(_1) }, marker: 2
+          )
+        }
       }
       custom_widget_object_doc(object_type, overrides)
     end
@@ -1090,6 +1248,7 @@ module Mxrb
     def preserve_flow_metadata(merged, existing, generated)
       {
         "AllowConcurrentExecution" => "__mxrb_allow_concurrent_execution_declared",
+        "ApplyEntityAccess" => "__mxrb_apply_entity_access_declared",
         "MarkAsUsed" => "__mxrb_mark_as_used_declared",
         "Excluded" => "__mxrb_excluded_declared"
       }.each do |field, declaration|
@@ -1360,7 +1519,7 @@ module Mxrb
         previous&.dig(rules_key) || IO::BsonCodec.build_array([])
       end
       doc = (previous || {}).merge(
-        "$ID" => id, "$Type" => "DomainModels$EntityImpl",
+        "$ID" => id, "$Type" => previous&.fetch("$Type", nil) || "DomainModels$EntityImpl",
         "Name" => entity.fetch(:name), "Documentation" => entity.fetch(:documentation, ""),
         "GUID" => previous&.dig("GUID") || SecureRandom.uuid,
         "Location" => previous&.dig("Location") || "#{(index % 4) * 220};#{(index / 4) * 160}",
@@ -1368,6 +1527,7 @@ module Mxrb
         "IsRemote" => previous&.fetch("IsRemote", false) || false,
         "RemoteSource" => previous&.fetch("RemoteSource", "") || ""
       )
+      apply_oql_view!(doc, entity.fetch(:oql_view, nil), previous)
       doc[attrs_key] = IO::BsonCodec.build_array(attrs)
       doc[rules_key] = access_rules
       doc[validation_key] = validation_rules_doc(
@@ -1397,8 +1557,27 @@ module Mxrb
       doc
     end
 
+    def apply_oql_view!(doc, view, previous)
+      return unless view
+
+      if view[:source]
+        source_key = native_existing_key(previous, 'source', 'Source') || 'Source'
+        current_source = previous&.dig(source_key)
+        source = (current_source.is_a?(Hash) ? current_source : {}).merge(
+          '$ID' => current_source&.fetch('$ID', nil) || SecureRandom.uuid,
+          '$Type' => 'DomainModels$OqlViewEntitySource',
+          'SourceDocument' => view.fetch(:source)
+        )
+        doc[source_key] = source
+      end
+      return unless view[:query]
+
+      query_key = native_existing_key(previous, 'oqlQuery', 'OqlQuery', 'OQLQuery') || 'OqlQuery'
+      doc[query_key] = view.fetch(:query)
+    end
+
     def attribute_doc(attr, previous)
-      storage_type = Model::Attribute::TYPE_MAP.fetch(attr.fetch(:type))
+      storage_type = Model::Attribute::TYPE_MAP.fetch(attr.fetch(:type).to_sym)
       type_key = native_existing_key(previous, "type", "Type", "newType", "NewType") || "NewType"
       value_key = native_existing_key(previous, "value", "Value") || "Value"
       name_key = native_key(previous, "name", "Name")
@@ -1410,9 +1589,11 @@ module Mxrb
         { "$ID" => SecureRandom.uuid, "$Type" => storage_type }
       end
       type_doc = type_doc.merge("Enumeration" => attr[:enumeration].to_s) if attr[:enumeration]
-      if attr[:length]
+      string_type = storage_type == Model::Attribute::TYPE_MAP[:string]
+      if attr[:length] || (string_type && !previous_type&.key?('length') && !previous_type&.key?('Length'))
         length_key = native_key(previous_type, 'length', 'Length')
-        type_doc = type_doc.merge(length_key => Integer(attr[:length]))
+        length = attr[:length] || Model::Attribute::DEFAULT_STRING_LENGTH
+        type_doc = type_doc.merge(length_key => Integer(length))
       end
       if attr.key?(:localize_date)
         localize_key = native_key(previous_type, 'localizeDate', 'LocalizeDate')
@@ -2198,6 +2379,48 @@ module Mxrb
       }
     end
 
+    # A project created outside Studio Pro may not have the pluggable-widget
+    # package available yet. These standard-shaped fallback fields preserve
+    # the concise Ruby projection until Studio Pro can hydrate the widget.
+    def configure_fallback_data_grid!(doc, options)
+      entity = options[:entity].to_s
+      columns = Array(options[:columns]).map do |column|
+        attribute = column[:attribute].to_s
+        attribute = "#{entity}.#{attribute}" if !entity.empty? && !attribute.empty? && !attribute.include?('.')
+        {
+          '$ID' => SecureRandom.uuid, '$Type' => 'Forms$DataGridColumn',
+          'Name' => column[:name].to_s,
+          'AttributeRef' => attribute_ref_doc(attribute),
+          'Caption' => text_doc(column[:caption] || column[:name])
+        }
+      end
+      toolbar = Array(options.dig(:toolbar, :buttons)).map do |button|
+        kind = { new: 'New', delete: 'Delete', search: 'Search', export: 'ExportToExcel' }
+               .fetch(button[:type].to_sym)
+        {
+          '$ID' => SecureRandom.uuid, '$Type' => "Forms$Grid#{kind}Button",
+          'Caption' => text_doc(button[:caption].to_s)
+        }
+      end
+      doc['DataSource'] = {
+        '$ID' => SecureRandom.uuid, '$Type' => 'Forms$DatabaseSource', 'Entity' => entity
+      }
+      doc['Columns'] = IO::BsonCodec.build_array(columns)
+      doc['ToolBar'] = {
+        '$ID' => SecureRandom.uuid, '$Type' => 'Forms$GridControlBar',
+        'Buttons' => IO::BsonCodec.build_array(toolbar)
+      }
+      doc
+    end
+
+    def configure_fallback_combo_box!(doc, options)
+      doc['AttributePath'] = options[:attribute].to_s if options[:attribute]
+      doc['LabelText'] = text_doc(options[:caption]) if options.key?(:caption)
+      doc['SelectorType'] = options[:__kind].to_sym == :reference_selector ? 'Reference' : 'Enumeration'
+      doc['DisplayAttribute'] = options[:display_attribute].to_s if options[:display_attribute]
+      doc
+    end
+
     def combo_box_descriptor
       {
         id: "com.mendix.widget.web.combobox.Combobox", name: "Combo box",
@@ -2244,6 +2467,15 @@ module Mxrb
       configure_data_grid2!(doc, options) if descriptor.fetch(:id) == data_grid2_descriptor[:id]
       configure_combo_box!(doc, options) if descriptor.fetch(:id) == combo_box_descriptor[:id]
       configure_pluggable_widget!(doc, options) if widget.fetch(:type) == :pluggable_widget
+      if definition.nil? && descriptor.fetch(:id) == data_grid2_descriptor[:id]
+        configure_fallback_data_grid!(doc, options)
+      end
+      if definition.nil? && descriptor.fetch(:id) == combo_box_descriptor[:id]
+        configure_fallback_combo_box!(doc, options)
+      end
+      widget.fetch(:events, []).each do |event|
+        doc[event_property(event.fetch(:event))] = client_action_doc(event)
+      end
       doc
     end
 
@@ -2404,6 +2636,8 @@ module Mxrb
       case event.fetch(:kind).to_sym
       when :action
         native_action_doc(event.fetch(:handler))
+      when :page
+        form_action_doc(event.fetch(:handler))
       when :nanoflow
         {
           "$ID" => SecureRandom.uuid,
@@ -2523,6 +2757,7 @@ module Mxrb
       body_declared   = !flow[:body].nil? || !flow[:return_expression].nil?
       return_var_name = flow[:return_variable_name] || "ReturnValue"
       allow_concurrent = flow[:allow_concurrent_execution]
+      apply_entity_access = flow[:apply_entity_access]
       mark_as_used = flow[:mark_as_used]
       excluded = flow[:excluded]
 
@@ -2540,6 +2775,7 @@ module Mxrb
         "Name" => flow_name, "Documentation" => flow.fetch(:documentation, ""),
         "ReturnVariableName" => return_var_name,
         "AllowConcurrentExecution" => allow_concurrent.nil? ? true : allow_concurrent,
+        "ApplyEntityAccess" => apply_entity_access.nil? ? false : apply_entity_access,
         "MarkAsUsed" => mark_as_used.nil? ? false : mark_as_used,
         "Excluded" => excluded.nil? ? false : excluded,
         "AllowedModuleRoles" => IO::BsonCodec.build_array(Array(flow[:allowed_roles]), marker: 1),
@@ -2547,6 +2783,7 @@ module Mxrb
         "__mxrb_body_declared" => body_declared,
         "__mxrb_preserve_native_body" => flow[:preserve_native_body] == true,
         "__mxrb_allow_concurrent_execution_declared" => !allow_concurrent.nil?,
+        "__mxrb_apply_entity_access_declared" => !apply_entity_access.nil?,
         "__mxrb_mark_as_used_declared" => !mark_as_used.nil?,
         "__mxrb_excluded_declared" => !excluded.nil?,
         "MicroflowReturnType" => microflow_data_type_doc(flow[:return_type], module_name),

data/lib/mxrb.rb

@@ -2,9 +2,12 @@
 
 require_relative "mxrb/version"
 require_relative "mxrb/errors"
+require_relative "mxrb/http/server"
+require_relative "mxrb/progress"
 require_relative "mxrb/doctor"
 require_relative "mxrb/benchmark"
 require_relative "mxrb/project_lifecycle"
+require_relative "mxrb/environment"
 require_relative "mxrb/scaffold/templates"
 require_relative "mxrb/scaffold/page_templates"
 require_relative "mxrb/initializer"
@@ -15,8 +18,11 @@ require_relative "mxrb/scaffold/recipes"
 require_relative "mxrb/scaffold/generator"
 require_relative "mxrb/scaffold/help"
 require_relative "mxrb/scaffold/cli"
+require_relative "mxrb/cli/help"
+require_relative "mxrb/cli/release"
 require_relative "mxrb/io/bson_codec"
 require_relative "mxrb/widget_package"
+require_relative "mxrb/widget_certification"
 require_relative "mxrb/frontend/migrator"
 require_relative "mxrb/io/mxunit_codec"
 require_relative "mxrb/io/mpr_file"
@@ -35,6 +41,13 @@ require_relative "mxrb/model/design_migration"
 require_relative "mxrb/model/module"
 require_relative "mxrb/model/connector"
 require_relative "mxrb/model/project"
+require_relative "mxrb/modeler/catalog"
+require_relative "mxrb/domain_diagram"
+require_relative "mxrb/domain_diagram/lifecycle"
+require_relative "mxrb/uml/class_diagram"
+require_relative "mxrb/uml/activity_diagram"
+require_relative "mxrb/uml/sequence_diagram"
+require_relative "mxrb/uml/server"
 require_relative "mxrb/protocols"
 require_relative "mxrb/oql"
 require_relative "mxrb/oql/plan_analyzer"
@@ -115,6 +128,7 @@ require_relative "mxrb/compiler/image_bundle_compiler"
 require_relative "mxrb/compiler/generic_widget_bundle_compiler"
 require_relative "mxrb/compiler/combo_box_bundle_compiler"
 require_relative "mxrb/compiler/legacy_data_grid_compiler"
+require_relative "mxrb/compiler/legacy_custom_widget_compiler"
 require_relative "mxrb/compiler/legacy_page_builder"
 require_relative "mxrb/compiler/page_bundle_compiler"
 require_relative "mxrb/compiler/compatibility_analyzer"
@@ -125,6 +139,14 @@ require_relative "mxrb/widget_synchronizer"
 require_relative "mxrb/runtime/docker_workspace"
 require_relative "mxrb/runtime/executor"
 require_relative "mxrb/runtime/native"
+require_relative "mxrb/runtime/schema_migrator"
+require_relative "mxrb/runtime/sqlite_store"
+require_relative "mxrb/runtime/access_control"
+require_relative "mxrb/runtime/shared_store"
+require_relative "mxrb/runtime/scheduler"
+require_relative "mxrb/ruby_app"
+require_relative "mxrb/ruby_app/preset"
+require_relative "mxrb/ruby_app/exporter"
 require_relative "mxrb/runtime/docker_executor"
 require_relative "mxrb/runtime/clipboard"
 require_relative "mxrb/runtime/database_workspace"
@@ -139,14 +161,18 @@ module Mxrb
   #
   #   Mxrb.open("MyApp.mpr") { |p| puts p.modules.map(&:name) }
   #
-  def self.open(path, readonly: true, &block)
-    project = Model::Project.open(path, readonly: readonly)
-    return project unless block
+  def self.open(path, readonly: true, &block) # rubocop:disable Metrics/MethodLength
+    return Model::Project.open(path, readonly: readonly) unless block
 
-    begin
-      block.call(project)
-    ensure
-      project.close
+    Progress.with("Loading #{File.basename(path)}") do |progress|
+      progress.update(detail: "opening model")
+      project = Model::Project.open(path, readonly: readonly)
+      begin
+        progress.update(detail: "processing model")
+        block.call(project)
+      ensure
+        project.close
+      end
     end
   end
 
@@ -164,9 +190,13 @@ module Mxrb
   #
   def self.define(path, &block)
     output = ENV.fetch("MXRB_OUTPUT_PATH", path)
-    Dsl::Builder.new(output).tap { _1.instance_eval(&block) }.build!
+    builder = Dsl::Builder.new(output).tap { _1.instance_eval(&block) }.build!
+    @last_defined_path = builder.path
+    builder
   end
 
+  def self.last_defined_path = @last_defined_path
+
   def self.validate(path)
     Integrity::Validator.new(path).validate
   end