mendix-ruby-bridge 0.1.1

data/lib/mendix_bridge/dependency_index.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class DependencyIndex
+    Edge = Data.define(:from, :to, :kind, :path) do
+      def to_h
+        { from:, to:, kind:, path: }
+      end
+    end
+
+    UNQUALIFIED_REFERENCE_KEYS = %w[
+      included_in_user_roles manageable_roles
+    ].freeze
+
+    KIND_KEYS = {
+      "calls" => "call",
+      "microflow_calls" => "microflow_call",
+      "nanoflow_calls" => "nanoflow_call",
+      "javascript_action_calls" => "javascript_action_call",
+      "page_links" => "page_link",
+      "layout" => "layout",
+      "structure" => "mapping_structure",
+      "generalization" => "generalization",
+      "from" => "association_source",
+      "to" => "association_target",
+      "execute_roles" => "execute_role",
+      "view_roles" => "view_role",
+      "module_roles" => "module_role",
+      "role" => "security_role",
+      "home_page" => "navigation_home",
+      "login_page" => "navigation_login",
+      "not_found_page" => "navigation_not_found",
+      "target" => "target",
+      "type" => "type_reference"
+    }.freeze
+
+    attr_reader :edges
+
+    def self.load(path, inventory:)
+      data = JSON.parse(File.read(path))
+      edges = data.fetch("edges").map do |edge|
+        Edge.new(
+          from: edge.fetch("from"),
+          to: edge.fetch("to"),
+          kind: edge.fetch("kind"),
+          path: edge.fetch("path")
+        )
+      end
+      new(inventory, edges:)
+    end
+
+    def initialize(inventory, edges: nil)
+      @inventory = inventory
+      @names = inventory.elements.filter_map(&:qualified_name).to_set
+      @qualified_names = @names.select { |name| name.include?(".") }.to_set
+      @edges = (edges || build_edges).freeze
+    end
+
+    def dependencies(name, transitive: false)
+      traverse(name, direction: :forward, transitive:)
+    end
+
+    def dependents(name, transitive: false)
+      traverse(name, direction: :reverse, transitive:)
+    end
+
+    def callers(name, transitive: false)
+      select_edges(
+        dependents(name, transitive:),
+        %w[call microflow_call nanoflow_call javascript_action_call]
+      )
+    end
+
+    def callees(name, transitive: false)
+      select_edges(
+        dependencies(name, transitive:),
+        %w[call microflow_call nanoflow_call javascript_action_call]
+      )
+    end
+
+    def impact(name)
+      dependents(name, transitive: true)
+    end
+
+    def to_h
+      {
+        schema_version: 1,
+        nodes: @names.length,
+        edges: edges.map(&:to_h)
+      }
+    end
+
+    private
+
+    def build_edges
+      found = []
+      @inventory.elements.each do |element|
+        next unless element.qualified_name && element.details
+
+        walk(
+          element.details.reject { |key, _value| %w[mdl raw].include?(key) },
+          source: element.qualified_name,
+          path: [],
+          found:
+        )
+        scan_mdl(element, found)
+      end
+      found.uniq { |edge| [edge.from, edge.to, edge.kind, edge.path] }
+        .sort_by { |edge| [edge.from, edge.to, edge.kind, edge.path] }
+    end
+
+    def walk(value, source:, path:, found:)
+      case value
+      when Hash
+        value.each do |key, child|
+          walk(child, source:, path: [*path, key.to_s], found:)
+        end
+      when Array
+        value.each_with_index do |child, index|
+          walk(child, source:, path: [*path, index.to_s], found:)
+        end
+      when String
+        references(value, path.last).each do |target|
+          add_edge(source, target, path, found)
+        end
+      end
+    end
+
+    def references(value, key)
+      matches = value.scan(/[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*/)
+        .select { |name| @qualified_names.include?(name) }
+      if UNQUALIFIED_REFERENCE_KEYS.include?(key) && @names.include?(value)
+        matches << value
+      end
+      matches.uniq
+    end
+
+    def scan_mdl(element, found)
+      mdl = element.details["mdl"]
+      return unless mdl
+
+      references(mdl, nil).each do |target|
+        add_edge(element.qualified_name, target, ["mdl"], found, kind: "mdl_reference")
+      end
+    end
+
+    def add_edge(source, target, path, found, kind: nil)
+      return if source == target
+
+      key = path.reverse.find { |part| !part.match?(/\A\d+\z/) }
+      found << Edge.new(
+        from: source,
+        to: target,
+        kind: kind || KIND_KEYS.fetch(key, "reference"),
+        path: path.join(".")
+      )
+    end
+
+    def traverse(name, direction:, transitive:)
+      raise ArgumentError, "unknown inventory element: #{name}" unless @names.include?(name)
+
+      selected = []
+      frontier = [name]
+      visited = Set[name]
+      loop do
+        current = frontier.shift
+        break unless current
+
+        matches = edges.select do |edge|
+          direction == :forward ? edge.from == current : edge.to == current
+        end
+        matches.each do |edge|
+          selected << edge
+          neighbor = direction == :forward ? edge.to : edge.from
+          next unless transitive && visited.add?(neighbor)
+
+          frontier << neighbor
+        end
+        break unless transitive || frontier.any?
+      end
+      selected.uniq { |edge| [edge.from, edge.to, edge.kind, edge.path] }
+    end
+
+    def select_edges(selected, kinds)
+      selected.select { |edge| kinds.include?(edge.kind) }
+    end
+  end
+end

data/lib/mendix_bridge/desktop_app.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+
+module MendixBridge
+  class DesktopApp
+    APP_TITLE = "Mendix Ruby Bridge"
+    WINDOW_WIDTH = 1280
+    WINDOW_HEIGHT = 800
+    READY_TIMEOUT = 15
+
+    def initialize(inventory_dir:, bridge_dir: nil)
+      @inventory_dir = File.expand_path(inventory_dir)
+      @bridge_dir = bridge_dir || File.expand_path("../..", __dir__)
+      @server_thread = nil
+      @backend = nil
+    end
+
+    def run
+      require_gtk!
+      configure_env!
+
+      port = free_port
+      start_backend(port)
+      wait_for_backend(port)
+
+      Gtk.init
+      window = build_window(port)
+      window.show_all
+      Gtk.main
+    ensure
+      @backend&.shutdown
+      @server_thread&.kill
+    end
+
+    private
+
+    def configure_env!
+      # WebKit2GTK crashes on Wayland with a protocol error; XWayland is stable.
+      # GPU compositing also fails on XWayland with some drivers (GBM buffer errors).
+      ENV["GDK_BACKEND"] ||= "x11"
+      ENV["WEBKIT_DISABLE_COMPOSITING_MODE"] ||= "1"
+    end
+
+    def require_gtk!
+      require "gtk3"
+      require "webkit2-gtk"
+    rescue LoadError => e
+      abort <<~MSG
+        mendix-desktop requires GTK3 and WebKit2 Ruby bindings.
+
+        Install them with:
+          gem install gtk3 webkit2-gtk
+
+        Or install the system packages:
+          Ubuntu/Debian: sudo apt install ruby-gtk3 gir1.2-webkit2-4.0
+          Arch/Omarchy:  sudo pacman -S ruby-gtk3 webkit2gtk
+
+        Original error: #{e.message}
+      MSG
+    end
+
+    def free_port
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+      server.close
+      port
+    end
+
+    def start_backend(port)
+      web_root = File.join(@bridge_dir, "web", "dist")
+      mxcli    = File.join(@bridge_dir, "bin", "mxcli")
+
+      @server_thread = Thread.new do
+        @backend = BackendServer.new(
+          inventory_dir: @inventory_dir,
+          web_root: web_root,
+          mxcli: mxcli,
+          bind: "127.0.0.1",
+          port: port
+        )
+        @backend.start
+      rescue => e
+        warn "mendix-desktop: backend error: #{e.message}"
+      end
+      @server_thread.abort_on_exception = false
+    end
+
+    def wait_for_backend(port)
+      Timeout.timeout(READY_TIMEOUT) do
+        loop do
+          TCPSocket.new("127.0.0.1", port).close
+          break
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      abort "mendix-desktop: backend did not start within #{READY_TIMEOUT}s"
+    end
+
+    def build_window(port)
+      window = Gtk::Window.new
+      window.title = APP_TITLE
+      window.set_default_size(WINDOW_WIDTH, WINDOW_HEIGHT)
+      window.set_window_position(:center)
+
+      webview = WebKit2Gtk::WebView.new
+      webview.load_uri("http://127.0.0.1:#{port}")
+
+      window.add(webview)
+      window.signal_connect("destroy") do
+        @backend&.shutdown
+        Gtk.main_quit
+      end
+
+      window
+    end
+  end
+end

data/lib/mendix_bridge/document_parser.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class DocumentParser
+    class << self
+      def parse(type, description)
+        mdl = description.fetch("mdl")
+        details = case type
+                  when "constant" then parse_constant(mdl)
+                  when "javaaction" then parse_java_action(mdl)
+                  when "importmapping", "exportmapping" then parse_mapping(mdl)
+                  when "layout", "snippet" then parse_ui_document(type, mdl)
+                  when "navprofile" then parse_navigation(mdl)
+                  else {}
+                  end
+
+        details.merge("mdl" => mdl, "parse_status" => "parsed")
+      end
+
+      private
+
+      def parse_constant(mdl)
+        {
+          "data_type" => mdl[/^\s*type\s+(.+)$/i, 1]&.strip,
+          "default" => unquote(mdl[/^\s*default\s+(.+)$/i, 1]&.strip),
+          "folder" => quoted_setting(mdl, "folder")
+        }.compact
+      end
+
+      def parse_java_action(mdl)
+        header = mdl.match(
+          /\bjava\s+action\s+[\w.]+\s*\((?<parameters>.*?)\)\s*returns\s+(?<returns>\S+)/im
+        )
+        {
+          "parameters" => parse_action_parameters(header&.[](:parameters).to_s),
+          "return_type" => header&.[](:returns),
+          "source_available" => !mdl.include?("source not available")
+        }.compact
+      end
+
+      def parse_action_parameters(source)
+        source.lines.filter_map do |line|
+          match = line.strip.delete_suffix(",").match(
+            /\A(\w+):\s*(.+?)(?:\s+(not null))?(?:\s*--\s*(.*))?\z/i
+          )
+          next unless match
+
+          {
+            "name" => match[1],
+            "type" => match[2].strip,
+            "required" => !match[3].nil?,
+            "description" => match[4]
+          }.compact
+        end
+      end
+
+      def parse_mapping(mdl)
+        {
+          "direction" => mdl[/\bcreate\s+(import|export)\s+mapping\b/i, 1]&.downcase,
+          "structure" => mdl[/\bwith\s+(?:json|xml)\s+structure\s+([\w.]+)/i, 1],
+          "entities" => mdl.scan(
+            /^\s*(?:create\s+)?([\w.]+)\s*\{\s*$/
+          ).flatten.uniq,
+          "attribute_mappings" => mdl.scan(
+            /^\s*(\w+)\s*=\s*([\w.]+)\s*,?\s*$/
+          ).map { |attribute, member| { "attribute" => attribute, "member" => member } }
+        }.compact
+      end
+
+      def parse_ui_document(type, mdl)
+        {
+          "document_type" => type,
+          "layout_type" => mdl[/^--\s*Layout Type:\s*(.+)$/i, 1]&.strip,
+          "folder" => quoted_setting(mdl, "Folder"),
+          "studio_pro_only" => mdl.match?(/cannot be created via MDL/i)
+        }.compact
+      end
+
+      def parse_navigation(mdl)
+        default_home = mdl.lines.filter_map do |line|
+          match = line.match(/^\s*home\s+page\s+([\w.]+)(?:\s+for\s+[\w.]+)?/i)
+          match[1] if match && !line.match?(/\s+for\s+[\w.]+/i)
+        end.first
+        {
+          "kind" => mdl[/^--\s*Kind:\s*(.+)$/i, 1]&.strip,
+          "home_page" => default_home,
+          "role_home_pages" => mdl.scan(
+            /^\s*home\s+page\s+([\w.]+)\s+for\s+([\w.]+)/i
+          ).map { |page, role| { "role" => role, "page" => page } },
+          "login_page" => mdl[/^\s*login\s+page\s+([\w.]+)/i, 1],
+          "not_found_page" => mdl[/^\s*not\s+found\s+page\s+([\w.]+)/i, 1],
+          "menu_groups" => mdl.scan(
+            /^\s*menu\s+'((?:''|[^'])+)'\s*\(/i
+          ).flatten.map { |caption| caption.gsub("''", "'") },
+          "menu_items" => mdl.scan(
+            /^\s*menu\s+item\s+'((?:''|[^'])+)'\s+(page|microflow|nanoflow)\s+([\w.]+)\s*;/i
+          ).map do |caption, action, target|
+            {
+              "caption" => caption.gsub("''", "'"),
+              "action" => action.downcase,
+              "target" => target
+            }
+          end
+        }.compact
+      end
+
+      def quoted_setting(mdl, name)
+        value = mdl[/^\s*#{Regexp.escape(name)}\s+'((?:''|[^'])*)'/i, 1]
+        value&.gsub("''", "'")
+      end
+
+      def unquote(value)
+        return unless value
+        return value unless value.start_with?("'") && value.end_with?("'")
+
+        value[1...-1].gsub("''", "'")
+      end
+    end
+  end
+end

data/lib/mendix_bridge/domain_parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class DomainParser
+    class << self
+      def parse(description)
+        case description.fetch("type")
+        when "entity" then parse_entity(description)
+        when "association" then parse_association(description)
+        else { "mdl" => description["mdl"] }
+        end
+      end
+
+      private
+
+      def parse_entity(description)
+        mdl = description.fetch("mdl")
+        declaration = mdl.match(
+          /\b(?<kind>persistent|non-persistent|external)\s+entity\s+(?<name>[\w.]+)(?:\s+extends\s+(?<generalization>[\w.]+))?\s*\((?<body>.*?)\);/im
+        )
+        return { "mdl" => mdl, "parse_status" => "unsupported" } unless declaration
+
+        {
+          "kind" => declaration[:kind].downcase,
+          "persistable" => declaration[:kind].casecmp?("persistent"),
+          "generalization" => declaration[:generalization],
+          "attributes" => parse_attributes(declaration[:body]),
+          "access_rules" => parse_access_rules(mdl),
+          "mdl" => mdl,
+          "parse_status" => "parsed"
+        }
+      end
+
+      def parse_attributes(body)
+        body.lines.filter_map do |line|
+          declaration = line.strip.delete_suffix(",")
+          next if declaration.empty? || declaration.start_with?("@", "--")
+
+          match = declaration.match(/\A(?<name>\w+):\s*(?<rest>.+)\z/)
+          next unless match
+
+          rest = match[:rest]
+          default = rest[/\s+default\s+(.+)\z/i, 1]
+          type = rest.sub(/\s+default\s+.+\z/i, "").sub(/\s+not\s+null\z/i, "")
+
+          {
+            "name" => match[:name],
+            "type" => type,
+            "required" => rest.match?(/\s+not\s+null(?:\s|\z)/i),
+            "default" => default,
+            "declaration" => declaration
+          }.compact
+        end
+      end
+
+      def parse_association(description)
+        mdl = description.fetch("mdl")
+
+        {
+          "from" => mdl[/^from\s+(\S+)\s+to\s+\S+/i, 1],
+          "to" => mdl[/^from\s+\S+\s+to\s+(\S+)/i, 1],
+          "association_type" => mdl[/^type\s+([^;\s]+)/i, 1],
+          "owner" => mdl[/^owner\s+([^;\s]+)/i, 1],
+          "storage" => mdl[/^storage\s+([^;\s]+)/i, 1],
+          "delete_behavior" => mdl[/^delete_behavior\s+([^;]+)/i, 1],
+          "mdl" => mdl,
+          "parse_status" => "parsed"
+        }.compact
+      end
+
+      def parse_access_rules(mdl)
+        mdl.lines.filter_map do |line|
+          match = line.strip.match(
+            /\Agrant\s+(?<role>[\w.]+)\s+on\s+(?<entity>[\w.]+)\s+\((?<permissions>.*)\)(?:\s+where\s+'(?<xpath>.*)')?;\z/i
+          )
+          next unless match
+
+          permissions = match[:permissions]
+          {
+            "role" => match[:role],
+            "create" => permission?(permissions, "create"),
+            "delete" => permission?(permissions, "delete"),
+            "read" => attribute_permission(permissions, "read"),
+            "write" => attribute_permission(permissions, "write"),
+            "xpath" => match[:xpath]&.gsub("''", "'")
+          }.compact
+        end
+      end
+
+      def permission?(permissions, name)
+        permissions.match?(/(?:\A|,\s*)#{Regexp.escape(name)}(?:,|\z)/i)
+      end
+
+      def attribute_permission(permissions, name)
+        match = permissions.match(/\b#{Regexp.escape(name)}\s+(\*|\([^)]*\))/i)
+        return [] unless match
+        return "*" if match[1] == "*"
+
+        match[1].delete_prefix("(").delete_suffix(")").split(",").map(&:strip)
+      end
+    end
+  end
+end