mxrb 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d95f5a294643904d99fdac9afbf3d0e6f08e1aa209c8aff81b812daec751c9e
-  data.tar.gz: eba324a63596fc22694d5fb672a3a1bc072e937d1d4d92715c0f907c68f23931
+  metadata.gz: e51d4e375ddb7b88ccce5938f52509af44491bffd29750c8be8d749d651c150a
+  data.tar.gz: 9ae4445757a494e29f96cfad382f0077c4fc8ca72e2c9172cbf9c5e74f2f7e0d
 SHA512:
-  metadata.gz: f3499ae32520b02952d2ded0622ec8be158a8d7e3ae36da5937b4cd5e187fb963100ad01925917f1d583db5b50dcf52b5a171abc09c128267dfcdb4d812ffe59
-  data.tar.gz: d8c1c51f90002b755ad9a3f03e4656c352cb09744ff8a893cae380cbb9d0b3b81074acbf758c788935b30ae6741efe8df7d5f87cfc06f3b2d25424211914c64c
+  metadata.gz: 9863efee0dd4e177f41e15142beb0282c219bc11b5a4e4d1e5c1dfec69ff80b3069fd5138cf5f027afdd1e53bd61e14d59487097904342bbcfa8d8cf3e4f372d
+  data.tar.gz: 326698d03a28eb9fad7bc6e7323e61430739f9b21c9f8ca2b4889a6a8a5a750ec6d6644d2bc4dbfdd2e950250ba4eab895d3ea81a3c155570e68c7fb3463fbae

data/docs/de-DE/validation-matrix.md

@@ -56,9 +56,9 @@ Gate.
 ## Semantik, Tests und Runtime
 
 - 1.778 Artefakte und 3.387 Referenzen;
-- 1.329 Beispiele, keine Fehler;
-- 100 % Zeilenabdeckung (23.771/23.771);
-- 100 % Branch-Abdeckung (9.704/9.704);
+- 1.337 Beispiele, keine Fehler;
+- 100 % Zeilenabdeckung (24.082/24.082);
+- 100 % Branch-Abdeckung (9.883/9.883);
 - Sudoku-Modellbewertung: 7/7;
 - funktionale Runtime-Tests: 3/3 lokal und 3/3 in Docker.
 

data/docs/en-US/validation-matrix.md

@@ -237,9 +237,9 @@ instead of dumping the complete removed and added flow bodies.
 
 ## Ruby evaluations and coverage gate
 
-The current suite contains 1,329 examples and passes with 100.00% line coverage
-(23,771/23,771 executable library lines) and 100.00% branch coverage
-(9,704/9,704 branches).
+The current suite contains 1,337 examples and passes with 100.00% line coverage
+(24,082/24,082 executable library lines) and 100.00% branch coverage
+(9,883/9,883 branches).
 Run the enforced gate with:
 
 ```sh

data/docs/pt-BR/validation-matrix.md

@@ -100,9 +100,9 @@ sem MDL.
 
 ## Avaliações, cobertura e runtime
 
-- 1.329 exemplos, zero falhas;
-- 100% das linhas: 23.771/23.771;
-- 100% dos branches: 9.704/9.704;
+- 1.337 exemplos, zero falhas;
+- 100% das linhas: 24.082/24.082;
+- 100% dos branches: 9.883/9.883;
 - avaliação Sudoku: 7/7 checks;
 - testes funcionais Sudoku: 3/3 localmente em 34,16 s;
 - testes funcionais Sudoku: 3/3 no Docker em 39,52 s.

data/lib/mxrb/model/page.rb

@@ -243,11 +243,140 @@ module Mxrb
       end
 
       def pluggable_widget(widget)
-        case widget.dig("Type", "WidgetId")
+        widget_id = widget.dig("Type", "WidgetId").to_s
+        return native_widget(widget) if widget_id.empty?
+
+        case widget_id
         when "com.mendix.widget.web.datagrid.Datagrid" then data_grid2_widget(widget)
         when "com.mendix.widget.web.combobox.Combobox"  then combo_box_widget(widget)
         when "com.mendix.widget.web.gallery.Gallery"    then gallery_widget(widget)
-        else native_widget(widget)
+        else generic_pluggable_widget(widget)
+        end
+      end
+
+      def generic_pluggable_widget(widget)
+        object_type = widget.dig("Type", "ObjectType")
+        properties = pluggable_properties(widget["Object"], object_type)
+        children = nested_pluggable_widgets(properties)
+        properties = strip_pluggable_widgets(properties)
+        options = appearance_options(widget).merge(
+          widget_id: widget.dig("Type", "WidgetId"),
+          widget_name: widget.dig("Type", "WidgetName"),
+          platform: widget.dig("Type", "SupportedPlatform"),
+          properties:
+        ).compact
+        {
+          type: :pluggable_widget, name: widget["Name"] || "widget",
+          options:, children:, events: pluggable_events(properties)
+        }
+      end
+
+      def pluggable_properties(object, object_type)
+        return {} unless object.is_a?(Hash) && object_type.is_a?(Hash)
+
+        types = parse_array(object_type["PropertyTypes"])
+        types_by_id = types.to_h { [IO::BsonCodec.extract_id(_1["$ID"]), _1] }
+        parse_array(object["Properties"]).each_with_object({}) do |property, result|
+          type = types_by_id[IO::BsonCodec.extract_id(property["TypePointer"])]
+          next unless type
+
+          result[type["PropertyKey"].to_s] = pluggable_value(
+            property["Value"], type["ValueType"]
+          )
+        end
+      end
+
+      def pluggable_value(value, value_type)
+        return nil unless value.is_a?(Hash)
+
+        type = value_type.is_a?(Hash) ? value_type["Type"].to_s : ""
+        widgets = parse_array(value["Widgets"])
+        unless widgets.empty?
+          parsed = []
+          parse_widgets(widgets, parsed)
+          return { widgets: parsed }
+        end
+        objects = parse_array(value["Objects"])
+        unless objects.empty?
+          object_type = value_type.is_a?(Hash) ? value_type["ObjectType"] : nil
+          return { objects: objects.map { pluggable_properties(_1, object_type) } }
+        end
+
+        return extract_text(value["TextTemplate"]) if value["TextTemplate"].is_a?(Hash)
+        return value.dig("AttributeRef", "Attribute") if value["AttributeRef"].is_a?(Hash)
+        return pluggable_data_source(value["DataSource"]) if value["DataSource"].is_a?(Hash)
+        return value["Expression"] unless value["Expression"].to_s.empty?
+        return value["Image"] unless value["Image"].to_s.empty?
+        return value["Form"] unless value["Form"].to_s.empty?
+
+        primitive = value["PrimitiveValue"]
+        return primitive == true || primitive.to_s.casecmp("true").zero? if type == "Boolean"
+        return primitive.to_i if type == "Integer"
+        return primitive.to_f if %w[Decimal Number].include?(type)
+        return primitive unless primitive.nil? || primitive.to_s.empty?
+
+        action = value["Action"]
+        return pluggable_action(action) if action.is_a?(Hash) && action["$Type"] != "Forms$NoAction"
+        return value["Selection"] unless value["Selection"].to_s.empty? || value["Selection"] == "None"
+
+        nil
+      end
+
+      def pluggable_data_source(source)
+        {
+          data_source: source.dig("EntityRef", "Entity") || source["Entity"],
+          xpath: source["XPathConstraint"].to_s,
+          sort: parse_array(source.dig("SortBar", "SortItems")).map do |item|
+            {
+              attribute: item.dig("AttributeRef", "Attribute"),
+              direction: item["SortDirection"].to_s
+            }.compact
+          end
+        }.compact
+      end
+
+      def pluggable_action(action)
+        candidates = {
+          "nanoflow" => action["Nanoflow"],
+          "microflow" => action["Microflow"],
+          "page" => action["Form"]
+        }
+        kind, handler = candidates.find { |_candidate, value| !value.to_s.empty? }
+        kind ||= "action"
+        handler ||= action["$Type"]
+        { kind:, handler: handler.to_s }
+      end
+
+      def nested_pluggable_widgets(value, found = [])
+        case value
+        when Hash
+          widgets = value[:widgets] || value["widgets"]
+          found.concat(Array(widgets)) if widgets
+          value.each_value { nested_pluggable_widgets(_1, found) }
+        when Array then value.each { nested_pluggable_widgets(_1, found) }
+        end
+        found.uniq { [_1[:name] || _1["name"], _1[:type] || _1["type"]] }
+      end
+
+      def strip_pluggable_widgets(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, child), result|
+            next if key.to_s == "widgets"
+
+            result[key] = strip_pluggable_widgets(child)
+          end
+        when Array then value.map { strip_pluggable_widgets(_1) }
+        else value
+        end
+      end
+
+      def pluggable_events(properties)
+        properties.filter_map do |key, value|
+          next unless value.is_a?(Hash) && value[:handler]
+
+          event = key.to_s.match?(/change/i) ? :on_change : :on_click
+          value.merge(event:)
         end
       end