mendix-ruby-bridge 0.1.1

data/lib/mendix_bridge/model.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  module Model
+    Attribute = Data.define(:name, :type, :required, :default, :options) do
+      def to_h
+        { name:, type:, required:, default:, **options }.compact
+      end
+    end
+
+    Association = Data.define(:name, :target, :cardinality, :owner) do
+      def to_h
+        { name:, target:, cardinality:, owner: }.compact
+      end
+    end
+
+    AccessRule = Data.define(:role, :create, :delete, :read, :write, :xpath) do
+      def to_h
+        {
+          role:,
+          create:,
+          delete:,
+          read:,
+          write:,
+          xpath:
+        }.compact
+      end
+    end
+
+    Entity = Data.define(
+      :name,
+      :persistable,
+      :attributes,
+      :associations,
+      :access_rules
+    ) do
+      def to_h
+        {
+          name:,
+          persistable:,
+          attributes: attributes.map(&:to_h),
+          associations: associations.map(&:to_h),
+          access_rules: access_rules.map(&:to_h)
+        }
+      end
+    end
+
+    EnumerationValue = Data.define(:name, :caption) do
+      def to_h
+        { name:, caption: }
+      end
+    end
+
+    Enumeration = Data.define(:name, :folder, :values) do
+      def to_h
+        { name:, folder:, values: values.map(&:to_h) }.compact
+      end
+    end
+
+    FlowParameter = Data.define(:name, :type) do
+      def to_h
+        { name:, type: }
+      end
+    end
+
+    Microflow = Data.define(
+      :name,
+      :parameters,
+      :return_type,
+      :folder,
+      :body,
+      :execute_roles
+    ) do
+      def to_h
+        {
+          name:,
+          parameters: parameters.map(&:to_h),
+          return_type:,
+          folder:,
+          body:,
+          execute_roles:
+        }.compact
+      end
+    end
+
+    Page = Data.define(
+      :name,
+      :title,
+      :layout,
+      :folder,
+      :parameters,
+      :content,
+      :view_roles
+    ) do
+      def to_h
+        {
+          name:,
+          title:,
+          layout:,
+          folder:,
+          parameters: parameters.map(&:to_h),
+          content:,
+          view_roles:
+        }.compact
+      end
+    end
+
+    ModuleRole = Data.define(:name, :description) do
+      def to_h
+        { name:, description: }.compact
+      end
+    end
+
+    UserRole = Data.define(:name, :module_roles, :manage_all_roles) do
+      def to_h
+        { name:, module_roles:, manage_all_roles: }
+      end
+    end
+
+    ProjectSecurity = Data.define(:level, :demo_users) do
+      def to_h
+        { level:, demo_users: }
+      end
+    end
+
+    NavigationItem = Data.define(:caption, :action, :target) do
+      def to_h
+        { caption:, action:, target: }
+      end
+    end
+
+    NavigationMenu = Data.define(:caption, :items) do
+      def to_h
+        { caption:, items: items.map(&:to_h) }
+      end
+    end
+
+    RoleHomePage = Data.define(:role, :page) do
+      def to_h
+        { role:, page: }
+      end
+    end
+
+    NavigationProfile = Data.define(
+      :name,
+      :home_page,
+      :role_home_pages,
+      :login_page,
+      :not_found_page,
+      :items
+    ) do
+      def to_h
+        {
+          name:,
+          home_page:,
+          role_home_pages: role_home_pages.map(&:to_h),
+          login_page:,
+          not_found_page:,
+          items: items.map(&:to_h)
+        }.compact
+      end
+    end
+
+    AppModule = Data.define(
+      :name,
+      :entities,
+      :enumerations,
+      :microflows,
+      :pages,
+      :module_roles
+    ) do
+      def to_h
+        {
+          name:,
+          entities: entities.map(&:to_h),
+          enumerations: enumerations.map(&:to_h),
+          microflows: microflows.map(&:to_h),
+          pages: pages.map(&:to_h),
+          module_roles: module_roles.map(&:to_h)
+        }
+      end
+    end
+
+    App = Data.define(
+      :name,
+      :version,
+      :modules,
+      :user_roles,
+      :project_security,
+      :navigation_profiles
+    ) do
+      def to_h
+        {
+          schema_version: 1,
+          app: { name:, version: }.compact,
+          modules: modules.map(&:to_h),
+          user_roles: user_roles.map(&:to_h),
+          project_security: project_security&.to_h,
+          navigation_profiles: navigation_profiles.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/mendix_bridge/page_parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class PageParser
+    class << self
+      def parse(description)
+        mdl = description.fetch("mdl")
+        header = mdl.match(
+          /\bpage\s+(?<name>[\w.]+)\s*\((?<settings>.*?)\)\s*\{/im
+        )
+        return { "mdl" => mdl, "parse_status" => "unsupported" } unless header
+
+        settings = header[:settings]
+        actions = mdl.scan(/\bAction:\s*([^,\n\)]+)/i).flatten.map(&:strip)
+        data_sources = mdl.scan(/\bDataSource:\s*([^,\n\)]+)/i).flatten.map(&:strip)
+
+        {
+          "title" => quoted_setting(settings, "Title"),
+          "layout" => scalar_setting(settings, "Layout"),
+          "folder" => quoted_setting(settings, "Folder"),
+          "parameters" => parse_parameters(settings),
+          "widgets" => parse_widgets(mdl),
+          "widget_types" => widget_counts(mdl),
+          "data_sources" => data_sources.uniq,
+          "actions" => actions.map { |action| parse_action(action) },
+          "microflow_calls" => referenced(actions, "microflow"),
+          "nanoflow_calls" => referenced(actions, "nanoflow"),
+          "page_links" => referenced(actions, "show_page"),
+          "attributes" => mdl.scan(/\bAttribute:\s*([^,\n\)]+)/i).flatten.map(&:strip).uniq,
+          "view_roles" => mdl.scan(
+            /^grant\s+view\s+on\s+page\s+[\w.]+\s+to\s+([\w.]+)/i
+          ).flatten,
+          "mdl" => mdl,
+          "parse_status" => "parsed"
+        }.compact
+      end
+
+      private
+
+      def quoted_setting(settings, name)
+        settings[/\b#{Regexp.escape(name)}:\s*'((?:''|[^'])*)'/i, 1]&.gsub("''", "'")
+      end
+
+      def scalar_setting(settings, name)
+        settings[/\b#{Regexp.escape(name)}:\s*([^,\n]+)/i, 1]&.strip
+      end
+
+      def parse_parameters(settings)
+        source = settings[/\bParams:\s*\{(.*?)\}/im, 1]
+        return [] unless source
+
+        source.scan(/\$(\w+):\s*([\w.]+)/).map do |name, type|
+          { "name" => name, "type" => type }
+        end
+      end
+
+      def parse_widgets(mdl)
+        mdl.lines.filter_map do |line|
+          stripped = line.strip
+          next if stripped.start_with?("--")
+
+          match = stripped.match(
+            /\A(?<type>[a-z][a-z0-9_]*)\s*(?<name>"[^"]+"|[A-Za-z_]\w*)?\s*(?<opening>\(|\{)/
+          )
+          next unless match
+          next if %w[create grant].include?(match[:type])
+
+          {
+            "type" => match[:type],
+            "name" => match[:name]&.delete_prefix('"')&.delete_suffix('"'),
+            "declaration" => stripped
+          }.compact
+        end
+      end
+
+      def widget_counts(mdl)
+        parse_widgets(mdl).each_with_object(Hash.new(0)) do |widget, counts|
+          counts[widget["type"]] += 1
+        end.sort.to_h
+      end
+
+      def parse_action(action)
+        kind, target = action.split(/\s+/, 2)
+        { "kind" => kind, "target" => target }.compact
+      end
+
+      def referenced(actions, kind)
+        actions.filter_map do |action|
+          match = action.match(/\A#{Regexp.escape(kind)}\s+([\w.]+)/i)
+          match[1] if match
+        end.uniq
+      end
+    end
+  end
+end

data/lib/mendix_bridge/presenter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class Presenter
+    def self.summary(element)
+      details = element.details&.reject { |key, _value| %w[mdl raw].include?(key) }
+      {
+        "name" => element.qualified_name || element.label,
+        "type" => element.type,
+        "path" => element.path,
+        "details" => details
+      }.compact
+    end
+
+    def self.search_result(element)
+      {
+        "name" => element.qualified_name || element.label,
+        "type" => element.type,
+        "path" => element.path.join(" / ")
+      }.compact
+    end
+
+    def self.text(element)
+      result = summary(element)
+      lines = [
+        "Name: #{result.fetch('name')}",
+        "Type: #{result.fetch('type')}",
+        "Path: #{element.path.join(' / ')}"
+      ]
+      details = result["details"]
+      lines << "Details:\n#{JSON.pretty_generate(details)}" if details && !details.empty?
+      lines.join("\n")
+    end
+  end
+end

data/lib/mendix_bridge/project_creator.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "tempfile"
+
+module MendixBridge
+  class ProjectCreationError < StandardError; end
+
+  class ProjectCreator
+    Result = Data.define(:project_dir, :project_file, :model_file, :git_initialized)
+
+    GITIGNORE = <<~IGNORE
+      deployment/
+      releases/
+      testresults/
+      *.mpr.bak
+      *.mpr.backup
+      .idea/
+      .vscode/
+    IGNORE
+
+    def initialize(mxcli:)
+      @mxcli = File.expand_path(mxcli)
+    end
+
+    def create(model, source_file:, output_dir:, version:, git: true)
+      source_file = File.expand_path(source_file)
+      output_dir = File.expand_path(output_dir)
+      validate_inputs!(source_file, output_dir, version)
+
+      run!(
+        @mxcli,
+        "new",
+        model.name,
+        "--version", version,
+        "--output-dir", output_dir,
+        "--skip-init",
+        error_prefix: "mxcli could not create the blank project"
+      )
+
+      project_file = locate_project_file(output_dir)
+      existing_modules = read_modules(project_file)
+      mdl = MendixBridge.compile(
+        model,
+        format: :mdl,
+        include_modules: true,
+        skip_modules: existing_modules
+      )
+      apply_model!(mdl, project_file)
+      check_project!(project_file, version)
+
+      model_file = File.join(output_dir, "app.rb")
+      FileUtils.cp(source_file, model_file)
+      File.write(File.join(output_dir, ".mendix-version"), "#{version}\n")
+      File.write(File.join(output_dir, ".gitignore"), GITIGNORE)
+      initialize_git!(output_dir) if git
+
+      Result.new(
+        project_dir: output_dir,
+        project_file:,
+        model_file:,
+        git_initialized: git
+      )
+    rescue ProjectCreationError
+      raise
+    rescue StandardError => error
+      raise ProjectCreationError, error.message
+    end
+
+    private
+
+    def validate_inputs!(source_file, output_dir, version)
+      raise ProjectCreationError, "Ruby model does not exist: #{source_file}" unless
+        File.file?(source_file)
+      raise ProjectCreationError, "mxcli is not executable: #{@mxcli}" unless
+        File.executable?(@mxcli)
+      raise ProjectCreationError, "output directory already exists: #{output_dir}" if
+        File.exist?(output_dir)
+      raise ProjectCreationError, "invalid Mendix version: #{version}" unless
+        version.to_s.match?(/\A\d+\.\d+\.\d+\z/)
+    end
+
+    def locate_project_file(output_dir)
+      projects = Dir[File.join(output_dir, "*.mpr")]
+      unless projects.length == 1
+        raise ProjectCreationError,
+          "expected one .mpr in #{output_dir}, found #{projects.length}"
+      end
+
+      projects.first
+    end
+
+    def read_modules(project_file)
+      output = run!(
+        @mxcli,
+        "-p", project_file,
+        "-c", "SHOW MODULES;",
+        error_prefix: "could not inspect modules in the blank project"
+      )
+      output.scan(/^\|\s+([A-Za-z_][A-Za-z0-9_]*)\s+\|/).flatten
+        .reject { |name| name == "Module" }
+    end
+
+    def apply_model!(mdl, project_file)
+      Tempfile.create(["mendix-ruby-new-", ".mdl"]) do |file|
+        file.write(mdl)
+        file.flush
+        run!(
+          @mxcli,
+          "check", file.path,
+          error_prefix: "generated project MDL is invalid"
+        )
+        run!(
+          @mxcli,
+          "exec", file.path,
+          "-p", project_file,
+          error_prefix: "mxcli could not apply the Ruby model"
+        )
+      end
+    end
+
+    def check_project!(project_file, version)
+      mx = File.join(
+        Dir.home,
+        ".mxcli",
+        "mxbuild",
+        version,
+        "modeler",
+        "mx"
+      )
+      raise ProjectCreationError, "Mendix mx #{version} is not installed: #{mx}" unless
+        File.executable?(mx)
+
+      run!(
+        mx,
+        "check",
+        project_file,
+        chdir: File.dirname(project_file),
+        error_prefix: "official Mendix consistency check failed"
+      )
+    end
+
+    def initialize_git!(output_dir)
+      run!(
+        "git",
+        "init",
+        "-b", "main",
+        chdir: output_dir,
+        error_prefix: "could not initialize Git"
+      )
+      run!(
+        "git",
+        "add",
+        ".",
+        chdir: output_dir,
+        error_prefix: "could not stage the initial project"
+      )
+      run!(
+        "git",
+        "commit",
+        "-m", "Initial Setup",
+        chdir: output_dir,
+        error_prefix: "could not create the initial Git commit"
+      )
+    end
+
+    def run!(*command, chdir: nil, error_prefix:)
+      stdout, stderr, status = if chdir
+        Open3.capture3(*command, chdir:)
+      else
+        Open3.capture3(*command)
+      end
+      return stdout if status.success?
+
+      detail = stderr.strip
+      detail = stdout.strip if detail.empty?
+      raise ProjectCreationError, "#{error_prefix}: #{detail}"
+    end
+  end
+end

data/lib/mendix_bridge/ruby_inventory_generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class RubyInventoryGenerator
+    def self.generate(inventory)
+      inventory.modules.each_with_object({}) do |app_module, result|
+        name = app_module.qualified_name
+        elements = inventory.elements.select do |element|
+          element.qualified_name&.start_with?("#{name}.") &&
+            %w[entity association].include?(element.type)
+        end
+        next if elements.empty?
+
+        result[name] = {
+          "entities" => elements.select { |element| element.type == "entity" }.map { |element| serialize(element) },
+          "associations" => elements.select { |element| element.type == "association" }.map { |element| serialize(element) }
+        }
+      end
+    end
+
+    def self.ruby_source(module_name, domain)
+      namespace = module_name.gsub(/[^A-Za-z0-9_]/, "_")
+      json = JSON.pretty_generate(domain)
+
+      <<~RUBY
+        # frozen_string_literal: true
+        # Generated by mendix-ruby import. Changes will be replaced by refresh.
+
+        require "json"
+
+        module MendixGenerated
+          module #{namespace}
+            DOMAIN_MODEL = JSON.parse(<<~JSON)
+        #{indent(json, 6)}
+            JSON
+          end
+        end
+      RUBY
+    end
+
+    def self.file_name(module_name)
+      module_name
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .gsub(/[^A-Za-z0-9]+/, "_")
+        .downcase
+    end
+
+    def self.serialize(element)
+      {
+        "name" => element.label,
+        "qualified_name" => element.qualified_name,
+        "details" => element.details
+      }.compact
+    end
+
+    def self.indent(text, spaces)
+      prefix = " " * spaces
+      text.lines.map { |line| "#{prefix}#{line}" }.join
+    end
+
+    private_class_method :serialize, :indent
+  end
+end

data/lib/mendix_bridge/security_parser.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class SecurityParser
+    class << self
+      def parse(type, description)
+        case type
+        when "projectsecurity" then parse_project_security(description)
+        when "modulerole" then parse_module_role(description)
+        when "userrole" then parse_user_role(description)
+        else raise ArgumentError, "unsupported security element: #{type}"
+        end
+      end
+
+      private
+
+      def parse_project_security(description)
+        settings = description.to_h do |entry|
+          [entry.fetch("Property"), typed_value(entry["Value"])]
+        end
+        {
+          "settings" => settings,
+          "parse_status" => "parsed",
+          "raw" => description
+        }
+      end
+
+      def parse_module_role(description)
+        mdl = description.fetch("mdl")
+        {
+          "description" => mdl[
+            /\bmodule\s+role\s+[\w.]+\s+description\s+'((?:''|[^'])*)'/i, 1
+          ]&.gsub("''", "'"),
+          "included_in_user_roles" => mdl[
+            /--\s*Included in user roles:\s*(.+)$/i, 1
+          ]&.split(",")&.map(&:strip) || [],
+          "mdl" => mdl,
+          "parse_status" => "parsed"
+        }
+      end
+
+      def parse_user_role(description)
+        mdl = description.fetch("mdl")
+        declaration = mdl.match(
+          /create\s+user\s+role\s+(?<name>\w+)\s*\((?<module_roles>.*?)\)(?<management>.*?);/im
+        )
+        return { "mdl" => mdl, "parse_status" => "unsupported" } unless declaration
+
+        management = declaration[:management].strip
+        {
+          "module_roles" => declaration[:module_roles].split(",").map(&:strip),
+          "manage_all_roles" => management.match?(/\bmanage\s+all\s+roles\b/i),
+          "manageable_roles" => management[
+            /\bmanage\s+roles\s*\((.*?)\)/i, 1
+          ]&.split(",")&.map(&:strip) || [],
+          "check_security" => mdl.match?(/--\s*Check security:\s*enabled/i),
+          "mdl" => mdl,
+          "parse_status" => "parsed"
+        }
+      end
+
+      def typed_value(value)
+        case value
+        when "true" then true
+        when "false" then false
+        when /\A\d+\z/ then value.to_i
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/mendix_bridge/snapshot_diff.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  class SnapshotDiff
+    Result = Data.define(:added, :modified, :removed) do
+      def empty?
+        added.empty? && modified.empty? && removed.empty?
+      end
+
+      def to_h
+        { added:, modified:, removed: }
+      end
+    end
+
+    def self.compare(before, after)
+      old_elements = index(before)
+      new_elements = index(after)
+      old_keys = old_elements.keys
+      new_keys = new_elements.keys
+
+      Result.new(
+        added: describe(new_keys - old_keys, new_elements),
+        modified: describe(
+          (old_keys & new_keys).select do |key|
+            canonical(old_elements.fetch(key)) != canonical(new_elements.fetch(key))
+          end,
+          new_elements
+        ),
+        removed: describe(old_keys - new_keys, old_elements)
+      )
+    end
+
+    def self.index(inventory)
+      inventory.elements.to_h do |element|
+        identity = element.qualified_name || element.path.join("/")
+        ["#{element.type}:#{identity}", element]
+      end
+    end
+
+    def self.describe(keys, elements)
+      keys.sort.map do |key|
+        element = elements.fetch(key)
+        {
+          "id" => key,
+          "type" => element.type,
+          "name" => element.qualified_name || element.label,
+          "path" => element.path
+        }.compact
+      end
+    end
+
+    def self.canonical(element)
+      JSON.generate(element.to_h)
+    end
+
+    private_class_method :index, :describe, :canonical
+  end
+end