mxrb 0.1.0

data/lib/mxrb/compiler/code_action_document_compiler.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Compiles Java and JavaScript action signatures consumed by the Runtime model.
+    class CodeActionDocumentCompiler
+      include ModelValues
+      include CodeActionTypeCompiler
+
+      TYPES = %w[JavaActions$JavaAction JavaScriptActions$JavaScriptAction].freeze
+
+      def compile(unit)
+        source = unit.document
+        case source['$Type']
+        when 'JavaActions$JavaAction' then java_action(source, unit.module_name)
+        when 'JavaScriptActions$JavaScriptAction' then javascript_action(source, unit.module_name)
+        else raise CompilationError, "unsupported code action #{source['$Type']}"
+        end
+      end
+
+      private
+
+      def java_action(source, module_name)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Parameters' => array(source['Parameters']).map { java_parameter(_1) },
+          'Name' => source['Name'], 'QualifiedName' => qualified_name(module_name, source['Name']),
+          'ReturnType' => code_action_type(source['JavaReturnType'])
+        }
+      end
+
+      def java_parameter(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'], 'Name' => source['Name'],
+          'Type' => java_parameter_type(source['ParameterType'])
+        }
+      end
+
+      def java_parameter_type(source)
+        return 'String' if source['$Type'] == 'JavaActions$MicroflowJavaActionParameterType'
+
+        code_action_type(source['Type'])
+      end
+
+      def javascript_action(source, module_name)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Parameters' => array(source['Parameters']).map { javascript_parameter(_1) },
+          'Name' => source['Name'], 'QualifiedName' => qualified_name(module_name, source['Name'])
+        }
+      end
+
+      def javascript_parameter(source)
+        { '$ID' => source['$ID'], '$Type' => source['$Type'], 'Name' => source['Name'] }
+      end
+
+      def qualified_name(module_name, name)
+        raise CompilationError, "code action #{name} is outside a module" unless module_name
+
+        "#{module_name}.#{name}"
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/code_action_materializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    CodeActionMaterialization = Data.define(:model_path, :java_actions, :javascript_actions)
+
+    # Materializes server and client action signatures into model.mdp.
+    class CodeActionMaterializer
+      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')
+        documents = compile_documents(source)
+        documents.reduce(ModelPackage.read(path)) { |package, document| package.upsert(document) }.write(path)
+        counts = documents.map { _1['$Type'] }.tally
+        CodeActionMaterialization.new(
+          model_path: path, java_actions: counts.fetch('JavaActions$JavaAction', 0),
+          javascript_actions: counts.fetch('JavaScriptActions$JavaScriptAction', 0)
+        )
+      end
+
+      private
+
+      def compile_documents(source)
+        compiler = CodeActionDocumentCompiler.new
+        source.units.select { CodeActionDocumentCompiler::TYPES.include?(_1.document['$Type']) }
+              .map { compiler.compile(_1) }
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/code_action_type_compiler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Converts CodeActions type trees into Runtime type identifiers.
+    module CodeActionTypeCompiler
+      SCALARS = {
+        'CodeActions$VoidType' => 'Void', 'CodeActions$StringType' => 'String',
+        'CodeActions$BooleanType' => 'Boolean', 'CodeActions$IntegerType' => 'Integer',
+        'CodeActions$LongType' => 'Integer', 'CodeActions$DecimalType' => 'Decimal',
+        'CodeActions$FloatType' => 'Decimal', 'CodeActions$DateTimeType' => 'DateTime'
+      }.freeze
+
+      private
+
+      def code_action_type(source)
+        return 'Void' unless source
+
+        type = source['$Type'].to_s.sub(/\AJavaActions\$/, 'CodeActions$')
+        return SCALARS.fetch(type) if SCALARS.key?(type)
+
+        case type
+        when 'CodeActions$ConcreteEntityType' then source['Entity'].to_s
+        when 'CodeActions$EnumerationType' then "##{source['Enumeration']}"
+        when 'CodeActions$ParameterizedEntityType' then 'Unknown'
+        when 'CodeActions$ListType' then "[#{code_action_type(source['Parameter'])}]"
+        else raise CompilationError, "unsupported code-action type #{source['$Type']}"
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/combo_box_bundle_compiler.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Compiles association- and database-backed instances of the official React Combo box widget.
+    # rubocop:disable Metrics
+    class ComboBoxBundleCompiler
+      include ModelValues
+
+      WIDGET_ID = 'com.mendix.widget.web.combobox.Combobox'
+
+      def initialize(source, page_name, widget, scope:, entity:)
+        @source = source
+        @page_name = page_name
+        @widget = widget
+        @scope = scope
+        @entity = entity
+        @index = document_index
+        @values = property_values(widget['Object'])
+        @data_source = WebListDataSource.new(source, widget)
+      end
+
+      def supported?
+        widget_type&.fetch('WidgetId', nil) == WIDGET_ID && supported_source? && resolved_scope
+      end
+
+      def render # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        properties = primitive_properties.merge(
+          key: widget_key, '$widgetId': widget_key, class: css_class, id: widget_key,
+          optionsSourceStaticDataSource: [],
+          ariaRequired: raw(expression(false))
+        )
+        properties.merge!(source_properties)
+        control = "React.createElement($Combobox, #{javascript(properties)})"
+        caption = translated_text(@widget['LabelTemplate'])
+        group = {
+          key: "#{widget_key}$formGroup", '$widgetId': "#{widget_key}$formGroup",
+          class: "#{css_class} mx-combobox", control: raw("[#{control}]"),
+          width: 3, orientation: 'horizontal', labelFor: widget_key,
+          caption: raw(expression(caption)), hasError: raw(expression(false))
+        }
+        "React.createElement($FormGroup, #{javascript(group)})"
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def supported_source?
+        return database_source_supported? if primitive('source') == 'database'
+        return enumeration_source_supported? if primitive('optionsSourceType') == 'enumeration'
+
+        association_source_supported?
+      end
+
+      def database_source_supported?
+        target_attribute && database_caption_attribute && database_value_attribute && list_source_supported?
+      end
+
+      def association_source_supported?
+        primitive('source') == 'context' && primitive('optionsSourceType') == 'association' &&
+          association_step && (association_caption_attribute || association_caption_expression) &&
+          list_source_supported?
+      end
+
+      def enumeration_source_supported?
+        primitive('source') == 'context' && enumeration_attribute
+      end
+
+      def list_source_supported?
+        @data_source.supported? && !@data_source.entity.to_s.empty?
+      end
+
+      def source_properties
+        return database_properties if primitive('source') == 'database'
+        return enumeration_properties if primitive('optionsSourceType') == 'enumeration'
+
+        association_properties
+      end
+
+      def enumeration_properties
+        { attributeEnumeration: raw(attribute_property(enumeration_attribute)) }
+      end
+
+      def database_properties
+        return database_association_properties if target_steps.any?
+
+        {
+          databaseAttributeString: raw(attribute_property(target_attribute)),
+          optionsSourceDatabaseCaptionAttribute: raw(list_attribute_property(database_caption_attribute)),
+          optionsSourceDatabaseValueAttribute: raw(list_attribute_property(database_value_attribute)),
+          optionsSourceDatabaseDataSource: raw(list_property),
+          optionsSourceDatabaseItemSelection: raw(selection_property)
+        }
+      end
+
+      def database_association_properties
+        {
+          source: 'context',
+          optionsSourceAssociationCaptionAttribute: raw(list_attribute_property(database_caption_attribute)),
+          attributeAssociation: raw(association_property(target_steps.first)),
+          optionsSourceAssociationDataSource: raw(list_property)
+        }
+      end
+
+      def association_properties
+        properties = {
+          attributeAssociation: raw(association_property(association_step)),
+          optionsSourceAssociationDataSource: raw(list_property)
+        }
+        if association_caption_attribute
+          properties[:optionsSourceAssociationCaptionAttribute] = raw(
+            list_attribute_property(association_caption_attribute)
+          )
+        else
+          properties[:optionsSourceAssociationCaptionExpression] = raw(list_expression_property)
+        end
+        properties
+      end
+
+      def list_expression_property
+        source = value('optionsSourceAssociationCaptionExpression')&.fetch('Expression', '').to_s
+        path = source[%r{\A\$currentObject/(.+)\z}, 1]
+        "ListExpressionProperty(#{javascript(
+          expression: {
+            expr: { type: 'variable', variable: 'currentObject', path: },
+            args: { currentObject: { widget: widget_key, source: 'object' } }
+          },
+          dataSourceId: data_source_id
+        )})"
+      end
+
+      def association_property(step)
+        "AssociationProperty(#{javascript(
+          type: 'Reference', entity: resolved_entity, path: '', attribute: step['Association'],
+          endpointEntity: step['DestinationEntity'], selectableObjectsId: data_source_id,
+          scope: resolved_scope, onChange: do_nothing
+        )})"
+      end
+
+      def list_property
+        config = {
+          dataSourceId: data_source_id, entity: @data_source.entity, scope: resolved_scope,
+          operationId: WebOperationCompiler.operation_id(@page_name, @widget['Name'])
+        }
+        if @data_source.xpath?
+          "DatabaseObjectListProperty(#{javascript(config.merge(sort: []))})"
+        else
+          "MicroflowObjectListProperty(#{javascript(config.merge(argMap: {}, fetchOnlyWithAllParams: false))})"
+        end
+      end
+
+      def selection_property
+        selection = value('optionsSourceDatabaseItemSelection')&.fetch('Selection', 'Single') || 'Single'
+        "SelectionProperty(#{javascript(selectionType: selection, dataSourceId: data_source_id)})"
+      end
+
+      def attribute_property(attribute)
+        entity, name = split_attribute(attribute.fetch('Attribute'))
+        path = entity_steps(attribute).flat_map do |step|
+          [step['Association'], step['DestinationEntity']]
+        end.join('/')
+        config = {
+          scope: resolved_scope, path:, entity:, attribute: name, onChange: do_nothing,
+          isList: false, validation: nil, formatting: {}
+        }
+        "AttributeProperty(#{javascript(config)})"
+      end
+
+      def list_attribute_property(attribute)
+        entity, name = split_attribute(attribute.fetch('Attribute'))
+        "ListAttributeProperty(#{javascript(
+          path: '', entity:, attribute: name, attributeType: 'String', sortable: true,
+          filterable: true, dataSourceId: data_source_id, isList: false
+        )})"
+      end
+
+      def split_attribute(qualified)
+        entity, separator, name = qualified.to_s.rpartition('.')
+        raise CompilationError, "invalid Combo box attribute #{qualified.inspect}" unless separator == '.'
+
+        [entity, name]
+      end
+
+      def resolved_scope
+        @resolved_scope ||= begin
+          parameter = target_value&.dig('SourceVariable', 'PageParameter').to_s
+          parameter.empty? ? @scope : "$#{parameter}"
+        end
+      end
+
+      def resolved_entity
+        return @entity unless @entity.to_s.empty?
+
+        parameter = target_value&.dig('SourceVariable', 'PageParameter').to_s
+        page_parameter_entity(parameter)
+      end
+
+      def page_parameter_entity(name)
+        module_name, document_name = @page_name.split('.', 2)
+        page = @source.units_of('Forms$Page').find do |unit|
+          unit.module_name == module_name && unit.document['Name'] == document_name
+        end
+        parameter = array(page&.document&.fetch('Parameters', nil)).find { _1['Name'] == name }
+        parameter&.dig('ParameterType', 'Entity').to_s
+      end
+
+      def target_value = value('databaseAttributeString')
+      def target_attribute = target_value&.fetch('AttributeRef', nil)
+      def enumeration_attribute = value('attributeEnumeration')&.fetch('AttributeRef', nil)
+      def database_caption_attribute = value('optionsSourceDatabaseCaptionAttribute')&.fetch('AttributeRef', nil)
+      def database_value_attribute = value('optionsSourceDatabaseValueAttribute')&.fetch('AttributeRef', nil)
+      def association_caption_attribute = value('optionsSourceAssociationCaptionAttribute')&.fetch('AttributeRef', nil)
+      def association_caption_expression = value('optionsSourceAssociationCaptionExpression')&.fetch('Expression', nil)
+
+      def association_step
+        entity_steps(value('attributeAssociation')).first
+      end
+
+      def target_steps = entity_steps(target_attribute)
+
+      def entity_steps(value)
+        array(value&.dig('EntityRef', 'Steps'))
+      end
+
+      def primitive_properties
+        @values.each_with_object({}) do |(key, (type, property)), result|
+          compiled = compile_primitive(type, property)
+          result[key.to_sym] = compiled unless compiled.nil?
+        end
+      end
+
+      def compile_primitive(type, property)
+        case type
+        when 'Boolean' then property['PrimitiveValue'] == 'true'
+        when 'Integer' then property['PrimitiveValue'].to_i
+        when 'Enumeration' then property['PrimitiveValue'].to_s
+        when 'TextTemplate' then raw(expression(translated_text(property['TextTemplate'])))
+        when 'Widgets' then [] if array(property['Widgets']).empty?
+        end
+      end
+
+      def translated_text(template)
+        items = array(template&.dig('Template', 'Items'))
+        items.find { _1['LanguageCode'] == 'en_US' }&.fetch('Text', '') ||
+          items.first&.fetch('Text', '') || ''
+      end
+
+      def expression(value)
+        "ExpressionProperty(#{javascript(expression: { expr: { type: 'literal', value: }, args: {} })})"
+      end
+
+      def do_nothing
+        { type: 'doNothing', argMap: {}, config: {}, disabledDuringExecution: false }
+      end
+
+      def data_source_id = "p.#{Digest::SHA256.hexdigest(widget_key)[0, 6].to_i(16)}"
+      def widget_key = "p.#{@page_name}.#{@widget['Name']}"
+
+      def css_class
+        ["mx-name-#{@widget['Name']}", @widget.dig('Appearance', 'Class')]
+          .map(&:to_s).reject(&:empty?).uniq.join(' ')
+      end
+
+      def primitive(key) = value(key)&.fetch('PrimitiveValue', nil)
+      def value(key) = @values[key]&.last
+      def raw(value) = { '$raw' => value }
+
+      def javascript(value)
+        return value['$raw'] if value.is_a?(Hash) && value.key?('$raw')
+        return "[#{value.map { javascript(_1) }.join(', ')}]" if value.is_a?(Array)
+        if value.is_a?(Hash)
+          return "{ #{value.map { |key, item| "#{JSON.generate(key)}: #{javascript(item)}" }.join(', ')} }"
+        end
+
+        JSON.generate(value)
+      end
+
+      def property_values(object)
+        array(object&.fetch('Properties', nil)).filter_map do |property|
+          type = @index[IO::BsonCodec.extract_id(property['TypePointer'])]
+          next unless type
+
+          [type.fetch('PropertyKey'), [type.dig('ValueType', 'Type'), property['Value']]]
+        end.to_h
+      end
+
+      def widget_type
+        object_type_id = IO::BsonCodec.extract_id(@widget.dig('Object', 'TypePointer'))
+        @index.values.find do |document|
+          IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == object_type_id
+        end
+      end
+
+      def document_index
+        return @source.document_index if @source.is_a?(SourceModel)
+
+        {}.tap { |index| @source.documents.each { index_document(_1, index) } }
+      end
+
+      def index_document(value, index)
+        case value
+        when Hash
+          id = IO::BsonCodec.extract_id(value['$ID'])
+          index[id] = value if id
+          value.each_value { index_document(_1, index) }
+        when Array then value.each { index_document(_1, index) }
+        end
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/compiler/compatibility_analyzer.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    CompatibilityFinding = Data.define(:severity, :category, :type, :location, :message, :count) do
+      def to_h = { severity:, category:, type:, location:, message:, count: }
+    end
+
+    CompatibilityReport = Data.define(:path, :mendix_version, :findings, :stats) do
+      def compatible? = findings.none? { _1.severity == :error }
+      def errors = findings.select { _1.severity == :error }
+      def warnings = findings.select { _1.severity == :warning }
+
+      def to_h
+        {
+          path:, mendix_version:, compatible: compatible?, stats:,
+          findings: findings.map(&:to_h)
+        }
+      end
+    end
+
+    # Read-only preflight for features consumed by the native compiler and web runtime.
+    # rubocop:disable Metrics
+    class CompatibilityAnalyzer
+      include ModelValues
+
+      def initialize(path, source: nil)
+        @path = File.expand_path(path)
+        @source = source || SourceModel.read(@path)
+        @findings = []
+      end
+
+      def analyze
+        analyze_version
+        analyze_features if @adapter
+        CompatibilityReport.new(
+          path: @path, mendix_version: @source.version, findings: collapsed_findings.freeze,
+          stats: statistics.freeze
+        )
+      end
+
+      private
+
+      def analyze_features
+        if @adapter.web_profiles.include?(:react)
+          analyze_pages
+          analyze_layouts
+          analyze_nanoflows
+        else
+          analyze_legacy_pages
+        end
+      end
+
+      def analyze_version
+        @adapter = Adapter.for(@source.version, source: @source)
+      rescue UnsupportedVersion => e
+        add(:error, :version, "Mendix #{@source.version}", 'project', e.message)
+      end
+
+      def analyze_legacy_pages
+        LegacyPageBuilder.new(@source, '', profiles: @adapter.web_profiles).audit.each do |location, types|
+          types.each do |type|
+            add(:error, page_category(type), type, location,
+                "#{type} is not compiled by the native legacy web renderer")
+          end
+        end
+      rescue CompilationError, KeyError, TypeError => e
+        add(:error, :page, 'Forms$Page', 'project', e.message)
+      end
+
+      def analyze_pages
+        @source.units_of('Forms$Page').select { web_page?(_1) }.each do |unit|
+          location = qualified_name(unit)
+          bundle = PageBundleCompiler.new(@source).compile(unit)
+          bundle.unsupported_widgets.each do |type|
+            if type == 'CustomWidgets$CustomWidget'
+              bundle.unsupported_custom_widgets.each do |identifier|
+                add(:error, :custom_widget, identifier, location,
+                    "#{identifier} is not compiled by the native web renderer")
+              end
+            else
+              add(:error, page_category(type), type, location,
+                  "#{type} is not compiled by the native web renderer")
+            end
+          end
+        rescue CompilationError, KeyError, TypeError => e
+          add(:error, :page, 'Forms$Page', location, e.message)
+        end
+      end
+
+      def analyze_nanoflows
+        compiler = NanoflowProgramCompiler.new(@source)
+        @source.units_of('Microflows$Nanoflow').each { compiler.reference(qualified_name(_1)) }
+        compiler.unsupported.each do |entry|
+          location, type = entry.split(':', 2)
+          add(:error, :nanoflow, type, location, "#{type} is not compiled by the native nanoflow runtime")
+        end
+      end
+
+      def analyze_layouts
+        @source.units_of('Forms$Layout').select { web_layout?(_1) }.each do |unit|
+          location = qualified_name(unit)
+          bundle = PageBundleCompiler.new(@source).compile_layout(unit)
+          add_bundle_findings(bundle, location)
+        rescue CompilationError, KeyError, TypeError => e
+          add(:error, :layout, 'Forms$Layout', location, e.message)
+        end
+      end
+
+      def add_bundle_findings(bundle, location)
+        bundle.unsupported_widgets.each do |type|
+          if type == 'CustomWidgets$CustomWidget'
+            bundle.unsupported_custom_widgets.each do |identifier|
+              add(:error, :custom_widget, identifier, location,
+                  "#{identifier} is not compiled by the native web renderer")
+            end
+          else
+            add(:error, page_category(type), type, location,
+                "#{type} is not compiled by the native web renderer")
+          end
+        end
+      end
+
+      def page_category(type)
+        return :client_action if type.end_with?('Action')
+        return :custom_widget if type == 'CustomWidgets$CustomWidget'
+
+        :widget
+      end
+
+      def web_page?(unit) = !@source.is_a?(SourceModel) || @source.web_page?(unit)
+      def web_layout?(unit) = !@source.is_a?(SourceModel) || @source.web_layout?(unit)
+
+      def add(severity, category, type, location, message)
+        @findings << CompatibilityFinding.new(
+          severity:, category:, type: type.to_s, location: location.to_s, message:, count: 1
+        )
+      end
+
+      def collapsed_findings
+        grouped = @findings.group_by { finding_key(_1) }
+        findings = grouped.map { |key, matches| collapsed_finding(key, matches.size) }
+        findings.sort_by { [_1.severity.to_s, _1.category.to_s, _1.location, _1.type] }
+      end
+
+      def finding_key(finding)
+        [finding.severity, finding.category, finding.type, finding.location, finding.message]
+      end
+
+      def collapsed_finding(key, count)
+        severity, category, type, location, message = key
+        CompatibilityFinding.new(severity:, category:, type:, location:, message:, count:)
+      end
+
+      def statistics
+        {
+          units: @source.units.size,
+          pages: @source.units_of('Forms$Page').size,
+          layouts: @source.units_of('Forms$Layout').size,
+          nanoflows: @source.units_of('Microflows$Nanoflow').size,
+          microflows: @source.units_of('Microflows$Microflow').size
+        }
+      end
+
+      def qualified_name(unit) = [unit.module_name, unit.document['Name']].compact.join('.')
+    end
+    # rubocop:enable Metrics
+  end
+end