mxrb 0.1.0

data/lib/mxrb/compiler/deployment_asset_copier.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Mxrb
+  module Compiler
+    # Copies project-owned libraries, resources, and compiled theme assets into deployment.
+    class DeploymentAssetCopier
+      include ModelValues
+
+      SAFE_IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+      def initialize(project_root, deployment, copier, source: nil)
+        @project_root = project_root
+        @deployment = deployment
+        @copier = copier
+        @source = source
+      end
+
+      def copy
+        %w[userlib vendorlib].each do |name|
+          @copier.call(File.join(@project_root, name), File.join(@deployment, 'model', 'lib', 'userlib'))
+        end
+        copy_root('resources', 'model/resources')
+        copy_root('theme/web', 'web')
+        copy_root('theme-cache/web', 'web')
+        copy_theme_public_assets
+        export_images if @source
+      end
+
+      private
+
+      def copy_root(source, destination)
+        @copier.call(File.join(@project_root, source), File.join(@deployment, destination))
+      end
+
+      def copy_theme_public_assets
+        pattern = File.join(@project_root, 'themesource', '*', 'public')
+        Dir.glob(pattern).sort.each { @copier.call(_1, File.join(@deployment, 'web')) }
+      end
+
+      def export_images # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        directory = File.join(@deployment, 'web', 'img')
+        FileUtils.mkdir_p(directory)
+        @source.units_of('Images$ImageCollection').each do |unit|
+          collection = unit.document
+          array(collection['Images']).each do |item|
+            names = [unit.module_name, collection['Name'], item['Name']]
+            unless names.all? { _1.to_s.match?(SAFE_IDENTIFIER) }
+              raise CompilationError, "unsafe image identifier #{names.inspect}"
+            end
+
+            filename = "#{names.join('$')}.#{image_format(item)}"
+            File.binwrite(File.join(directory, filename), image_bytes(item['Image']))
+          end
+        end
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+end

data/lib/mxrb/compiler/deployment_bootstrapper.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'zip'
+
+module Mxrb
+  module Compiler
+    DeploymentBootstrap = Data.define(:deployment, :created, :template_root)
+
+    # Creates a deployment workspace from versioned Studio Pro templates without invoking its builders.
+    class DeploymentBootstrapper # rubocop:disable Metrics/ClassLength
+      COMMON_TEMPLATE_ROOTS = %w[data log model native run tmp].freeze
+      REQUIRED_DIRECTORIES = %w[
+        data/database data/files data/tmp log model/bundles model/lib/userlib model/resources run tmp web/img
+      ].freeze
+
+      def initialize(mpr_path, deployment:, mendix_home: nil)
+        @mpr_path = File.expand_path(mpr_path)
+        @project_root = File.dirname(@mpr_path)
+        @deployment = File.expand_path(deployment)
+        @source = SourceModel.read(@mpr_path)
+        @version_root = resolve_version_root(mendix_home)
+        @template_root = File.join(@version_root, 'modeler', 'runtemplates', 'deployment')
+      end
+
+      def prepare
+        return prepare_existing if ready?
+
+        validate_templates!
+        prepare_fresh
+      end
+
+      def prepare_existing
+        ensure_web_build_templates if modern_react_web?
+        ensure_required_directories
+        copy_project_assets
+        finalize_web_shell
+        DeploymentBootstrap.new(deployment: @deployment, created: false, template_root: @template_root)
+      end
+
+      def prepare_fresh
+        FileUtils.mkdir_p(@deployment)
+        copy_version_templates
+        ensure_required_directories
+        render_templates
+        initialize_model
+        copy_project_assets
+        finalize_web_shell
+        DeploymentBootstrap.new(deployment: @deployment, created: true, template_root: @template_root)
+      end
+
+      private
+
+      def ready?
+        Adapter::REQUIRED_FILES.all? { File.file?(File.join(@deployment, _1)) }
+      end
+
+      def resolve_version_root(mendix_home)
+        root = File.expand_path(mendix_home || File.join(Dir.home, '.local', 'share', 'mendix', @source.version))
+        File.basename(root) == 'runtime' ? File.dirname(root) : root
+      end
+
+      def validate_templates!
+        return if File.directory?(@template_root) || File.file?(deployment_archive)
+
+        raise CompilationError, "Mendix #{@source.version} deployment templates not found at #{@template_root}"
+      end
+
+      def copy_version_templates
+        extract_deployment_archive if legacy_archive?
+        COMMON_TEMPLATE_ROOTS.each { copy_tree(File.join(@template_root, _1), File.join(@deployment, _1)) }
+        web_template_roots.each do |source_name, destination_name|
+          copy_tree(File.join(@template_root, source_name), File.join(@deployment, destination_name))
+        end
+      end
+
+      def web_template_roots
+        return { 'react-web' => 'web' } if modern_react_web?
+        return { 'dojo-web' => 'web' } if @source.version.to_i == 10
+        return { 'web' => 'web', 'modern-web' => 'modern-web' } if @source.version.to_i == 9
+
+        { 'web' => 'web' }
+      end
+
+      def modern_react_web?
+        @source.version.to_i >= 11 || (@source.version.to_i == 10 && @source.optimized_web_client?)
+      end
+
+      def legacy_archive? = @source.version.to_i <= 7 && File.file?(deployment_archive)
+      def deployment_archive = File.join(@version_root, 'modeler', 'deployment.mxz')
+
+      def extract_deployment_archive # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        root = "#{File.expand_path(@deployment)}#{File::SEPARATOR}"
+        Zip::File.open(deployment_archive) do |archive|
+          archive.each do |entry|
+            destination = File.expand_path(entry.name, @deployment)
+            unless destination.start_with?(root)
+              raise CompilationError, "unsafe deployment template entry #{entry.name.inspect}"
+            end
+
+            entry.directory? ? FileUtils.mkdir_p(destination) : extract_template_entry(entry, destination)
+          end
+        end
+      rescue Zip::Error => e
+        raise CompilationError, "invalid deployment template #{deployment_archive}: #{e.message}"
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def extract_template_entry(entry, destination)
+        return if File.exist?(destination)
+
+        FileUtils.mkdir_p(File.dirname(destination))
+        entry.get_input_stream do |input|
+          File.open(destination, 'wb') { |output| ::IO.copy_stream(input, output) }
+        end
+      end
+
+      def copy_tree(source, destination)
+        return unless File.directory?(source)
+
+        FileUtils.mkdir_p(destination)
+        Dir.children(source).sort.each do |name|
+          from = File.join(source, name)
+          to = File.join(destination, name)
+          next if File.exist?(to)
+
+          File.directory?(from) ? copy_tree(from, to) : FileUtils.cp(from, to)
+        end
+      end
+
+      def render_templates
+        Dir.glob(File.join(@deployment, '**', '*.template')).sort.each do |source|
+          destination = source.delete_suffix('.template')
+          File.write(destination, render(File.read(source)))
+          FileUtils.rm_f(source)
+        end
+      end
+
+      def ensure_web_build_templates
+        validate_templates!
+        %w[rspack.config.mjs.template rollup.config.mjs.template].each do |name|
+          source = File.join(@template_root, 'react-web', name)
+          destination = File.join(@deployment, 'web', name)
+          FileUtils.cp(source, destination) unless File.exist?(destination.delete_suffix('.template'))
+        end
+        render_templates
+      end
+
+      def render(content)
+        replacements.reduce(content) { |result, (token, value)| result.gsub(token, value) }
+                    .gsub('\\{', '{').gsub('\\}', '}')
+      end
+
+      def replacements
+        {
+          '{InstallDir:JsStringEncode}' => @version_root,
+          '{InstallDir:HtmlAttributeEncode}' => @version_root,
+          '{DeploymentDir:JsStringEncode}' => @deployment,
+          '{DeploymentDir:HtmlAttributeEncode}' => @deployment,
+          '{ProjectDir:HtmlAttributeEncode}' => @project_root,
+          '{ProjectName:HtmlAttributeEncode}' => project_name,
+          '{EnableWatchman:true|false}' => 'false', '{MxBuildNumber}' => "mxrb-#{@source.version}"
+        }
+      end
+
+      def initialize_model
+        model = File.join(@deployment, 'model')
+        FileUtils.mkdir_p(model)
+        SystemModelSeed.for(@source.version).package.write(File.join(model, 'model.mdp'))
+        initialize_json_files(model)
+        ProjectJarArchive.new(@mpr_path, @project_root, @deployment)
+                         .write(File.join(model, 'bundles', 'project.jar'), empty_classes)
+      end
+
+      def initialize_json_files(model)
+        metadata = DeploymentMetadata.new(@mpr_path, @source)
+        write_json(File.join(model, 'metadata.json'), metadata.document)
+        write_json(File.join(model, 'dependencies.json'), metadata.dependencies)
+        write_json(File.join(model, 'microflows.json'), {})
+        write_json(File.join(model, 'operations.json'), [])
+      end
+
+      def empty_classes
+        path = File.join(@deployment, 'tmp', 'mxrb-empty-classes')
+        FileUtils.mkdir_p(path)
+        path
+      end
+
+      def project_name = File.basename(@mpr_path, File.extname(@mpr_path))
+
+      def write_json(path, value) = File.write(path, JSON.pretty_generate(value))
+
+      def copy_project_assets
+        DeploymentAssetCopier.new(
+          @project_root, @deployment, method(:copy_tree), source: @source
+        ).copy
+      end
+
+      def ensure_required_directories
+        REQUIRED_DIRECTORIES.each { FileUtils.mkdir_p(File.join(@deployment, _1)) }
+      end
+
+      def finalize_web_shell
+        WebShellMaterializer.new(File.join(@deployment, 'web'), version: @source.version).materialize
+      end
+    end # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/mxrb/compiler/deployment_materializer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    DeploymentMaterialization = Data.define(:deployment, :mendix_version, :stages)
+
+    # Runs the complete native MPR-to-deployment model pipeline in dependency order.
+    class DeploymentMaterializer
+      STAGES = [
+        SecurityMaterializer, ConstantsMaterializer, DomainModelMaterializer,
+        ArtifactMaterializer, TranslationMaterializer, SystemTextMaterializer,
+        SystemQueueMaterializer, ClientModelMaterializer,
+        CodeActionMaterializer, SettingsMaterializer, MicroflowMaterializer, ProjectMaterializer
+      ].freeze
+
+      def initialize(mpr_path, deployment: nil, mendix_home: nil)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment || File.join(File.dirname(@mpr_path), 'deployment'))
+        @mendix_home = mendix_home
+      end
+
+      def materialize
+        source = SourceModel.read(@mpr_path)
+        DeploymentBootstrapper.new(
+          @mpr_path, deployment: @deployment, mendix_home: @mendix_home
+        ).prepare
+        Adapter.for(source.version).validate_deployment!(@deployment)
+        results = materialize_stages
+        DeploymentMaterialization.new(
+          deployment: @deployment, mendix_version: source.version, stages: results.freeze
+        )
+      end
+
+      private
+
+      def materialize_stages
+        STAGES.to_h do |stage|
+          [stage.name.split('::').last, stage.new(@mpr_path, deployment: @deployment).materialize]
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/deployment_metadata.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Derives initial Runtime metadata from an application MPR.
+    class DeploymentMetadata
+      def initialize(mpr_path, source)
+        @mpr_path = mpr_path
+        @source = source
+      end
+
+      def document
+        {
+          'RuntimeVersion' => @source.version, 'ProjectID' => project_id,
+          'ProjectName' => project_name, 'ModelVersion' => 'unversioned', 'Description' => '',
+          'AdminUser' => 'MxAdmin', 'AdminRole' => '', 'JavaVersion' => java_version,
+          'Roles' => {}, 'Constants' => [], 'ScheduledEvents' => [], 'Languages' => languages,
+          'Configuration' => configuration, 'RequestHandlers' => request_handlers,
+          'ModelRuntimeCompatibilityHash' => ''
+        }
+      end
+
+      def dependencies
+        { 'schemaVersion' => '2.3', 'appName' => project_name, 'published' => [], 'consumed' => [] }
+      end
+
+      private
+
+      def project_id
+        @source.units.find { _1.document['$Type'] == 'Projects$Project' }&.id.to_s
+      end
+
+      def project_name = File.basename(@mpr_path, File.extname(@mpr_path))
+      def java_version = Runtime::Toolchain.new(@mpr_path).plan.java_version.to_i
+
+      def languages
+        @source.documents.flat_map { collect_languages(_1) }.uniq.sort
+      end
+
+      def collect_languages(value)
+        case value
+        when Hash
+          own = value['$Type'] == 'Texts$Translation' ? [value['LanguageCode'].to_s] : []
+          own + value.values.flat_map { collect_languages(_1) }
+        when Array then value.flat_map { collect_languages(_1) }
+        else []
+        end.reject(&:empty?)
+      end
+
+      def configuration
+        {
+          'SourceDatabaseType' => 'HSQLDB', 'SourceDatabaseName' => 'home',
+          'SourceBuiltInDatabasePath' => 'model/sampledata/data/database'
+        }
+      end
+
+      def request_handlers
+        [['/api/', true], ['/link/', true], ['/p/', false]].map do |name, enabled|
+          { 'Name' => name, 'DefaultEnabled' => enabled, 'MatchExactly' => false }
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/domain_document_compiler.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Converts domain-model documents from editor shape to Runtime shape.
+    class DomainDocumentCompiler # rubocop:disable Metrics/ClassLength
+      include ModelValues
+
+      def initialize(source)
+        @source = source
+        domain_units = source.respond_to?(:units_of) ? source.units_of('DomainModels$DomainModel') : []
+        @entities = domain_units.each_with_object({}) do |unit, result|
+          array(unit.document['Entities']).each do |entity|
+            result["#{unit.module_name}.#{entity['Name']}"] = entity
+          end
+        end
+        @security = DomainSecurityCompiler.new(source)
+      end
+
+      def compile(unit) # rubocop:disable Metrics/AbcSize
+        source = unit.document
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Entities' => array(source['Entities']).map { compile_entity(_1, unit.module_name) },
+          'Associations' => array(source['Associations']).map { @security.association(_1, unit.module_name) },
+          'CrossAssociations' => array(source['CrossAssociations']).map do |association|
+            @security.association(association, unit.module_name)
+          end
+        }
+      end
+
+      private
+
+      def compile_entity(source, module_name)
+        name = source['Name'].to_s
+        entity_content(source).merge(
+          'Source' => compile_entity_source(source['Source']),
+          'GUID' => source['GUID'], 'Image' => source['Image'].to_s,
+          'QualifiedName' => "#{module_name}.#{name}", 'UnqualifiedName' => name
+        )
+      end
+
+      def compile_entity_source(source) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return nil unless source
+        return plain_document(source) unless source['$Type'] == 'DomainModels$OqlViewEntitySource'
+
+        qualified_name = source['SourceDocument'].to_s
+        document = @source.units.find do |unit|
+          unit.document['$Type'] == 'DomainModels$ViewEntitySourceDocument' &&
+            "#{unit.module_name}.#{unit.document['Name']}" == qualified_name
+        end
+        raise CompilationError, "OQL view source #{qualified_name.inspect} not found" unless document
+
+        source.slice('$ID', '$Type', 'SourceDocument').merge(
+          'OqlRuntime' => document.document['Oql'].to_s,
+          'SourceDocumentName' => qualified_name,
+          'SourceType' => 'OQL'
+        )
+      end
+
+      def entity_content(source) # rubocop:disable Metrics/AbcSize
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'MaybeGeneralization' => compile_generalization(source['MaybeGeneralization']),
+          'Attributes' => array(source['Attributes']).map { compile_attribute(_1) },
+          'ValidationRules' => array(source['ValidationRules']).map { compile_validation(_1) },
+          'Events' => plain_array(source['Events']),
+          'Indexes' => array(source['Indexes']).map { compile_index(_1) },
+          'AccessRules' => array(source['AccessRules']).map { @security.access_rule(_1) }
+        }
+      end
+
+      def compile_generalization(source)
+        type = source.fetch('$Type')
+        result = { '$ID' => source['$ID'], '$Type' => type }
+        result['Key'] = source['Key'] if type == 'DomainModels$NoGeneralization'
+        result.merge(generalization_flags(source, type))
+              .merge('Generalization' => source['Generalization'].to_s)
+      end
+
+      def generalization_flags(source, type)
+        inherited = inherited_flags(source['Generalization']) if type == 'DomainModels$Generalization'
+        {
+          'Persistable' => source.fetch('Persistable', inherited&.fetch('Persistable', false)) == true,
+          'HasCreatedDateAttr' => source.fetch('HasCreatedDateAttr',
+                                               inherited&.fetch('HasCreatedDateAttr', false)) == true,
+          'HasChangedDateAttr' => source.fetch('HasChangedDateAttr',
+                                               inherited&.fetch('HasChangedDateAttr', false)) == true,
+          'HasOwnerAttr' => source.fetch('HasOwnerAttr', inherited&.fetch('HasOwnerAttr', false)) == true,
+          'HasChangedByAttr' => source.fetch('HasChangedByAttr', inherited&.fetch('HasChangedByAttr', false)) == true
+        }
+      end
+
+      def inherited_flags(qualified_name)
+        return system_flags if qualified_name.to_s.start_with?('System.')
+
+        parent = @entities[qualified_name.to_s]
+        return system_flags unless parent
+
+        generalization = parent['MaybeGeneralization'] || {}
+        generalization_flags(generalization, generalization['$Type'])
+      end
+
+      def system_flags
+        {
+          'Persistable' => true, 'HasCreatedDateAttr' => true, 'HasChangedDateAttr' => true,
+          'HasOwnerAttr' => true, 'HasChangedByAttr' => true
+        }
+      end
+
+      def compile_attribute(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Value' => plain_document(source['Value']), 'Type' => compile_attribute_type(source['NewType']),
+          'Name' => source['Name'], 'GUID' => source['GUID']
+        }
+      end
+
+      def compile_attribute_type(source)
+        result = plain_document(source)
+        if result['$Type'] == 'DomainModels$DateTimeAttributeType'
+          result['LocalizeDate'] = source.fetch('LocalizeDate', true) == true
+        end
+        result
+      end
+
+      def compile_validation(source)
+        message = source['Message'] || {}
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Message' => message.slice('$ID', '$Type'),
+          'RuleInfo' => plain_document(source['RuleInfo']), 'Attribute' => source['Attribute'].to_s
+        }
+      end
+
+      def compile_index(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Attributes' => array(source['Attributes']).map { compile_indexed_attribute(_1) },
+          'GUID' => source['GUID'], 'IncludeInOffline' => source['IncludeInOffline'] == true
+        }
+      end
+
+      def compile_indexed_attribute(source)
+        result = plain_document(source)
+        result['AssociationPointer'] ||= BSON::Binary.new(
+          IO::BsonCodec.uuid_to_blob('00000000-0000-0000-0000-000000000000'), :generic
+        )
+        result
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/domain_model_materializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    DomainModelMaterialization = Data.define(:model_path, :domain_models, :entities)
+
+    # Replaces or inserts Runtime domain-model documents in model.mdp.
+    class DomainModelMaterializer
+      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)
+        Adapter.for(source.version)
+        compiler = DomainDocumentCompiler.new(source)
+        documents = source.units_of('DomainModels$DomainModel').map { compiler.compile(_1) }
+        path = File.join(@deployment, 'model', 'model.mdp')
+        write_model(path, documents)
+        DomainModelMaterialization.new(
+          model_path: path, domain_models: documents.length,
+          entities: documents.sum { _1.fetch('Entities').length }
+        )
+      end
+
+      private
+
+      def write_model(path, documents)
+        package = documents.reduce(ModelPackage.read(path)) { |result, document| result.upsert(document) }
+        package.write(path)
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/domain_security_compiler.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Resolves project roles and association security into Runtime fields.
+    class DomainSecurityCompiler
+      include ModelValues
+
+      def initialize(source)
+        @role_map = project_role_map(source)
+      end
+
+      def access_rule(source)
+        module_roles = array(source['AllowedModuleRoles']).map(&:to_s)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'MemberAccesses' => array(source['MemberAccesses']).map { member_access(_1) },
+          'AllowedUserRoles' => module_roles.flat_map { @role_map.fetch(_1, []) }.uniq,
+          'AllowCreate' => source['AllowCreate'] == true, 'AllowDelete' => source['AllowDelete'] == true,
+          'XPathConstraint' => source['XPathConstraint'].to_s
+        }
+      end
+
+      def association(source, module_name)
+        name = source['Name'].to_s
+        result = association_fields(source).merge(
+          'QualifiedName' => "#{module_name}.#{name}",
+          'UnqualifiedName' => name, 'Navigability' => 'BothDirections'
+        )
+        child_key = source['$Type'] == 'DomainModels$CrossAssociation' ? 'Child' : 'ChildPointer'
+        result.merge(child_key => source[child_key])
+      end
+
+      private
+
+      def member_access(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Attribute' => source['Attribute'].to_s, 'Association' => source['Association'].to_s,
+          'AccessRights' => source['AccessRights']
+        }
+      end
+
+      def association_fields(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'DeleteBehavior' => delete_behavior(source['DeleteBehavior']),
+          'Source' => source['Source'], 'GUID' => source['GUID'], 'Type' => source['Type'],
+          'Owner' => source['Owner'], 'StorageFormat' => source['StorageFormat'],
+          'ParentPointer' => source['ParentPointer']
+        }
+      end
+
+      def delete_behavior(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'ParentErrorMessage' => text_reference(source['ParentErrorMessage']),
+          'ChildErrorMessage' => text_reference(source['ChildErrorMessage']),
+          'ParentDeleteBehavior' => runtime_delete_behavior(source['ParentDeleteBehavior']),
+          'ChildDeleteBehavior' => runtime_delete_behavior(source['ChildDeleteBehavior'])
+        }
+      end
+
+      def text_reference(source)
+        source&.slice('$ID', '$Type')
+      end
+
+      def runtime_delete_behavior(value)
+        value == 'NoAction' ? 'DeleteMeAndReferences' : value
+      end
+
+      def project_role_map(source)
+        security = source.documents('Security$ProjectSecurity').first
+        return {} unless security
+
+        array(security['UserRoles']).each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |role, map|
+          array(role['ModuleRoles']).each { |module_role| map[module_role.to_s] << role['Name'].to_s }
+        end
+      end
+    end
+  end
+end