mxrb 0.1.2 → 0.1.4

data/lib/mxrb/compiler/packager.rb

@@ -19,16 +19,24 @@ module Mxrb
         @deployment = File.expand_path(deployment || File.join(@project_root, 'deployment'))
       end
 
-      def pack(output:, force: false)
-        output_path = File.expand_path(output)
-        validate_input!(output_path, force:)
-        version = Mxrb.open(@mpr_path, &:mendix_version)
-        adapter = Adapter.for(version)
-        metadata = adapter.validate_deployment!(@deployment)
-        adapter.validate_freshness!(@mpr_path, @deployment)
-        files, directories = inventory
-        write_atomically(output_path, files, directories)
-        package_result(output_path, version, metadata)
+      def pack(output:, force: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        Progress.with("Packing #{File.basename(@mpr_path)}") do |progress|
+          output_path = File.expand_path(output)
+          validate_input!(output_path, force:)
+          version = Mxrb.open(@mpr_path, &:mendix_version)
+          adapter = Adapter.for(version)
+          metadata = adapter.validate_deployment!(@deployment)
+          adapter.validate_freshness!(@mpr_path, @deployment)
+          files, directories = inventory
+          progress.update(
+            current: 3, total: files.size + directories.size + 4,
+            detail: "#{files.size} files"
+          )
+          write_atomically(output_path, files, directories, progress)
+          package_result(output_path, version, metadata).tap do
+            progress.advance(detail: 'package checksum')
+          end
+        end
       end
 
       private
@@ -69,13 +77,19 @@ module Mxrb
         path.delete_prefix("#{@deployment}/").tr('\\', '/')
       end
 
-      def write_atomically(output, files, directories)
+      def write_atomically(output, files, directories, progress) # rubocop:disable Metrics/MethodLength
         FileUtils.mkdir_p(File.dirname(output))
         Dir.mktmpdir('mxrb-mda-', File.dirname(output)) do |tmpdir|
           temporary = File.join(tmpdir, 'package.mda')
           Zip::File.open(temporary, create: true) do |archive|
-            directories.each { add_directory(archive, _1) }
-            files.each { add_file(archive, _1) }
+            directories.each do |directory|
+              add_directory(archive, directory)
+              progress.advance(detail: relative(directory))
+            end
+            files.each do |file|
+              add_file(archive, file)
+              progress.advance(detail: relative(file))
+            end
           end
           FileUtils.mv(temporary, output, force: true)
         end

data/lib/mxrb/compiler/page_bundle_compiler.rb

@@ -341,7 +341,10 @@ module Mxrb
           return grid.render
         end
 
-        gallery = GalleryBundleCompiler.new(@source, @qualified_name, widget)
+        gallery = GalleryBundleCompiler.new(
+          @source, @qualified_name, widget,
+          render_widgets: ->(widgets, scope, entity) { render_scoped_widgets(widgets, scope, entity) }
+        )
         if gallery.supported?
           @uses_gallery = true
           nano_reference = nanoflow_reference(gallery.data_source.nanoflow_name) if gallery.data_source.nanoflow?
@@ -1818,17 +1821,21 @@ module Mxrb
         if @generic_widgets&.any?
           imports.concat([
                            'import { AttributeProperty } from "mendix/AttributeProperty";',
+                           'import { ListAttributeProperty } from "mendix/ListAttributeProperty";',
                            'import { ExpressionProperty } from "mendix/ExpressionProperty";',
                            'import { ListExpressionProperty } from "mendix/ListExpressionProperty";',
-                           'import { DatabaseObjectListProperty } from "mendix/DatabaseObjectListProperty";'
+                           'import { DatabaseObjectListProperty } from "mendix/DatabaseObjectListProperty";',
+                           'import { SelectionProperty } from "mendix/SelectionProperty";',
+                           'import { TemplatedWidgetProperty } from "mendix/TemplatedWidgetProperty";'
                          ])
         end
         if @uses_data_grid
           imports.concat([
                            'import { DatabaseObjectListProperty } from "mendix/DatabaseObjectListProperty";',
-                           'import { AttributeProperty } from "mendix/AttributeProperty";',
+                           'import { ListAttributeProperty } from "mendix/ListAttributeProperty";',
                            'import { ExpressionProperty } from "mendix/ExpressionProperty";',
                            'import { ListExpressionProperty } from "mendix/ListExpressionProperty";',
+                           'import { SelectionProperty } from "mendix/SelectionProperty";',
                            'import { TemplatedWidgetProperty } from "mendix/TemplatedWidgetProperty";',
                            'import Datagrid from "../widgets/com/mendix/widget/web/datagrid/Datagrid.mjs";'
                          ])
@@ -1988,7 +1995,9 @@ module Mxrb
 
       def render_content(content)
         JSON.pretty_generate(content).sub(/\A\{/, '{').sub(/\}\z/, '}')
-            .gsub(/"(renderKey =>[^\n]+)"/) { Regexp.last_match(1).gsub('\\"', '"') }
+            .gsub(/"(renderKey =>[^\n]+)"/) do
+              JSON.parse(%("#{Regexp.last_match(1)}"))
+            end
       end
 
       def layout

data/lib/mxrb/compiler/portable_packager.rb

@@ -309,17 +309,22 @@ module Mxrb
         @mendix_home = mendix_home && File.expand_path(mendix_home)
       end
 
-      def pack(output:, force: false)
-        output_path = File.expand_path(output)
-        validate_output!(output_path, force:)
-        version = Mxrb.open(@mpr_path, &:mendix_version)
-        adapter = Adapter.for(version)
-        metadata = adapter.validate_deployment!(@deployment)
-        adapter.validate_freshness!(@mpr_path, @deployment)
-        runtime = runtime_root(version)
-        validate_runtime!(runtime)
-        PortableArchiveWriter.new(@deployment, runtime, metadata).write(output_path)
-        result(output_path, version, metadata)
+      def pack(output:, force: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        Progress.with("Packing portable Runtime for #{File.basename(@mpr_path)}") do |progress|
+          output_path = File.expand_path(output)
+          validate_output!(output_path, force:)
+          progress.update(detail: 'validating deployment')
+          version = Mxrb.open(@mpr_path, &:mendix_version)
+          adapter = Adapter.for(version)
+          metadata = adapter.validate_deployment!(@deployment)
+          adapter.validate_freshness!(@mpr_path, @deployment)
+          runtime = runtime_root(version)
+          validate_runtime!(runtime)
+          progress.update(detail: 'writing Runtime archive')
+          PortableArchiveWriter.new(@deployment, runtime, metadata).write(output_path)
+          progress.update(detail: 'calculating checksum')
+          result(output_path, version, metadata)
+        end
       end
 
       private

data/lib/mxrb/compiler/web_bundle_builder.rb

@@ -120,7 +120,11 @@ module Mxrb
           constants: { LAYOUT_SCOPE_ID_PREFIX: 'l' },
           registerServiceWorker: false, enableServiceWorkerCaching: true
         }
-        File.write(path, "import { startApp } from \"mendix\";\n\nstartApp(#{JSON.pretty_generate(payload)});\n")
+        File.write(
+          path,
+          "import { startApp } from \"mendix\";\n\n" \
+          "startApp(#{JSON.pretty_generate(payload)});\n"
+        )
       end
 
       def languages

data/lib/mxrb/compiler/web_shell_materializer.rb

@@ -24,7 +24,8 @@ module Mxrb
       def materialize
         return 0 unless File.directory?(@web)
 
-        changed = html_files.count { render_html(_1) }
+        changed = materialize_widget_stylesheet ? 1 : 0
+        changed += html_files.count { render_html(_1) }
         changed += materialize_dynamic_imports
         write_missing(File.join(@web, 'js', 'login_i18n.js'), login_i18n)
         write_missing(File.join(@web, 'lib', 'bootstrap', 'css', 'bootstrap.min.css'), login_styles)
@@ -51,6 +52,29 @@ module Mxrb
 
       def html_files = Dir.glob(File.join(@web, '*.html')).sort
 
+      def materialize_widget_stylesheet
+        destination = File.join(@web, 'widgets', 'mxrb-widgets.css')
+        styles = Dir.glob(File.join(@web, 'widgets', '**', '*.css')).sort
+        styles.delete(destination)
+        return remove_widget_stylesheet(destination) if styles.empty?
+
+        rendered = widget_stylesheet(styles)
+        return false if File.file?(destination) && File.binread(destination) == rendered
+
+        File.binwrite(destination, rendered)
+        true
+      end
+
+      def remove_widget_stylesheet(path)
+        existed = File.exist?(path)
+        FileUtils.rm_f(path)
+        existed
+      end
+
+      def widget_stylesheet(styles)
+        styles.map { File.binread(_1) }.join("\n") << "\n"
+      end
+
       def render_javascript(source)
         rendered = source.gsub(DYNAMIC_PAGE_CACHE) do
           %(`?#{cache_token}\${#{Regexp.last_match(1)}}`)
@@ -68,7 +92,7 @@ module Mxrb
         rendered = rendered.gsub('{{themecss}}', theme_css)
         rendered = rendered.gsub('{{manifest}}', manifest)
         rendered = rendered.gsub(PLACEHOLDER, '')
-        rendered = inject_navigation_compatibility(rendered) if File.basename(path) == 'index.html'
+        rendered = render_application_html(rendered) if File.basename(path) == 'index.html'
         return false if source == rendered
 
         File.write(path, rendered)
@@ -115,6 +139,22 @@ module Mxrb
         html.sub('</head>', "#{navigation_compatibility}\n</head>")
       end
 
+      def render_application_html(html)
+        inject_navigation_compatibility(inject_widget_stylesheet(html))
+      end
+
+      def inject_widget_stylesheet(html)
+        return html unless File.file?(File.join(@web, 'widgets', 'mxrb-widgets.css'))
+
+        stylesheet = '<link data-mxrb-widget-styles rel="stylesheet" ' \
+                     "href=\"widgets/mxrb-widgets.css?#{cache_token}\">"
+        return html.sub(/<link\b[^>]*data-mxrb-widget-styles[^>]*>/, stylesheet) if
+          html.include?('data-mxrb-widget-styles')
+        return html unless html.include?('</head>')
+
+        html.sub('</head>', "#{stylesheet}\n</head>")
+      end
+
       def navigation_compatibility # rubocop:disable Metrics/MethodLength
         <<~HTML.chomp
           <script data-mxrb-navigation-compat="#{CACHE_REVISION}">

data/lib/mxrb/compiler/widget_package_extractor.rb

@@ -10,10 +10,13 @@ module Mxrb
     class WidgetPackageExtractor
       def initialize(project_root, web_root)
         @source = File.join(project_root, 'widgets')
+        @web_root = web_root
         @destination = File.join(web_root, 'widgets')
       end
 
       def extract
+        FileUtils.rm_f(File.join(@web_root, 'mxrb-widgets.css'))
+        FileUtils.rm_f(File.join(@destination, 'mxrb-widgets.css'))
         return 0 unless File.directory?(@source)
 
         FileUtils.mkdir_p(@destination)

data/lib/mxrb/domain_diagram/lifecycle.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'net/http'
+require 'rbconfig'
+require 'securerandom'
+require 'time'
+
+module Mxrb
+  module DomainDiagram
+    # Background lifecycle for the ER editor. Control happens through a
+    # token-authenticated loopback endpoint rather than a potentially stale PID.
+    # rubocop:disable Metrics
+    class Lifecycle
+      STATE_ROOT_ENV = 'MXRB_DIAGRAM_STATE_ROOT'
+      START_TIMEOUT = 8
+      STOP_TIMEOUT = 8
+
+      Status = Data.define(:state, :source, :output, :url, :pid, :log) do
+        def running? = state == 'running'
+        def to_h = { state:, source:, output:, url:, pid:, log: }.compact
+      end
+
+      attr_reader :source, :state_root, :executable
+
+      def initialize(source, state_root: self.class.default_state_root, executable: $PROGRAM_NAME)
+        @source = File.expand_path(source)
+        @state_root = File.expand_path(state_root)
+        @executable = File.expand_path(executable)
+      end
+
+      def self.default_state_root
+        configured = ENV[STATE_ROOT_ENV]
+        return configured unless configured.to_s.empty?
+
+        File.join(Dir.home, '.local', 'state', 'mxrb', 'diagram-er')
+      end
+
+      def up(output: nil, modules: nil, port: nil, force: false)
+        previous = read_state
+        raise ArgumentError, "diagram already running at #{url_for(previous)}" if running?(previous)
+        raise ArgumentError, 'managed diagram is already starting' if starting?(previous)
+
+        settings = settings_for(previous, output:, modules:, port:)
+        managed_paths = prepare_output(previous, settings, force:)
+        token = SecureRandom.hex(24)
+        state = settings.merge(
+          'version' => 1, 'source' => source, 'token' => token, 'state' => 'starting',
+          'pid' => nil, 'log' => log_path, 'managed_paths' => managed_paths,
+          'created_at' => Time.now.utc.iso8601
+        )
+        write_state(state)
+        pid = spawn_worker(state)
+        Process.detach(pid)
+        write_state(read_state.merge('pid' => pid))
+        wait_until(START_TIMEOUT) { running?(read_state, token:) }
+        status
+      rescue StandardError
+        mark_stopped(token) if defined?(token) && token
+        raise
+      end
+
+      def status
+        state = read_state
+        return Status.new('absent', source, nil, nil, nil, nil) unless state
+
+        lifecycle_state = if running?(state)
+                            'running'
+                          elsif starting?(state)
+                            'starting'
+                          else
+                            'stopped'
+                          end
+        Status.new(
+          lifecycle_state, source, state['output'], url_for(state), state['pid'], state['log']
+        )
+      end
+
+      def down
+        state = read_state or raise ArgumentError, "no managed diagram for #{source}"
+        unless running?(state)
+          raise ArgumentError, 'managed diagram is still starting; retry in a moment' if starting?(state)
+
+          mark_stopped(state.fetch('token'))
+          return status
+        end
+
+        response = request(state, Net::HTTP::Post, '/api/admin/shutdown')
+        raise ArgumentError, 'managed diagram refused the shutdown request' unless response.is_a?(Net::HTTPSuccess)
+
+        wait_until(STOP_TIMEOUT) { !running?(read_state) }
+        mark_stopped(state.fetch('token'))
+        status
+      end
+
+      def destroy(confirm: false)
+        raise ArgumentError, 'destroy requires --yes' unless confirm
+
+        state = read_state or raise ArgumentError, "no managed diagram for #{source}"
+        current = status
+        down if %w[running starting].include?(current.state)
+        Array(state['managed_paths']).reverse_each do |path|
+          remove_managed_path(path, state.fetch('output'))
+        end
+        FileUtils.remove_entry_secure(instance_dir) if File.exist?(instance_dir)
+        Status.new('absent', source, nil, nil, nil, nil)
+      end
+
+      # Internal worker entrypoint used by `mxrb diagram-er __serve`.
+      def run_worker(output:, modules:, port:, token:)
+        state = read_state or raise ArgumentError, 'diagram lifecycle state is missing'
+        raise ArgumentError, 'diagram lifecycle token does not match' unless state['token'] == token
+
+        server = Server.new(
+          source, output:, modules:, port:, reuse: true, lifecycle_token: token
+        )
+        trap('INT') { Thread.new { server.shutdown } }
+        trap('TERM') { Thread.new { server.shutdown } }
+        server.start do
+          write_state(state.merge(
+                        'pid' => Process.pid, 'state' => 'running',
+                        'started_at' => Time.now.utc.iso8601
+                      ))
+        end
+      ensure
+        mark_stopped(token) if defined?(token) && token
+      end
+
+      private
+
+      def settings_for(previous, output:, modules:, port:)
+        selected_output = File.expand_path(output || previous&.fetch('output', nil) || default_output)
+        if previous && output && selected_output != File.expand_path(previous.fetch('output'))
+          raise ArgumentError, 'destroy the existing managed diagram before changing --output'
+        end
+
+        {
+          'output' => selected_output,
+          'modules' => modules.nil? ? Array(previous&.fetch('modules', [])) : Array(modules),
+          'port' => Integer(port || previous&.fetch('port', nil) || 4568),
+          'host' => '127.0.0.1'
+        }
+      end
+
+      def prepare_output(previous, settings, force:)
+        output = settings.fetch('output')
+        if previous && File.file?(output) && !force
+          Server.new(source, output:, port: settings.fetch('port'), reuse: true)
+          return Array(previous['managed_paths'])
+        end
+
+        server = Server.new(source, output:, port: settings.fetch('port'), force:)
+        (Array(previous&.fetch('managed_paths', [])) + server.managed_paths).uniq
+      end
+
+      def spawn_worker(state)
+        arguments = [
+          RbConfig.ruby, executable, 'diagram-er', '__serve', source,
+          '--output', state.fetch('output'), '--port', state.fetch('port').to_s,
+          '--token', state.fetch('token'), '--state-root', state_root
+        ]
+        Array(state['modules']).each { arguments.concat(['--module', _1.to_s]) }
+        prepare_instance_dir
+        FileUtils.touch(state.fetch('log'))
+        File.chmod(0o600, state.fetch('log'))
+        Process.spawn(*arguments, out: state.fetch('log'), err: %i[child out])
+      end
+
+      def starting?(state)
+        return false unless state&.fetch('state', nil) == 'starting'
+
+        created_at = Time.iso8601(state.fetch('created_at'))
+        Time.now.utc - created_at <= START_TIMEOUT
+      rescue ArgumentError, KeyError
+        false
+      end
+
+      def running?(state, token: state&.fetch('token', nil))
+        return false unless state && token
+
+        response = request(state, Net::HTTP::Get, '/api/admin/status', token:)
+        response&.is_a?(Net::HTTPSuccess) == true
+      end
+
+      def request(state, request_class, path, token: state.fetch('token'))
+        request = request_class.new(path)
+        request['X-MXRB-Lifecycle-Token'] = token
+        Net::HTTP.start(
+          state.fetch('host'), Integer(state.fetch('port')),
+          open_timeout: 0.25, read_timeout: 0.5
+        ) { _1.request(request) }
+      rescue IOError, SystemCallError, Timeout::Error, SocketError
+        nil
+      end
+
+      def wait_until(timeout)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        loop do
+          return true if yield
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            raise ArgumentError, "diagram lifecycle timed out; see #{log_path}"
+          end
+
+          sleep 0.05
+        end
+      end
+
+      def mark_stopped(token)
+        state = read_state
+        return unless state && state['token'] == token
+
+        write_state(state.merge(
+                      'pid' => nil, 'state' => 'stopped',
+                      'stopped_at' => Time.now.utc.iso8601
+                    ))
+      end
+
+      def remove_managed_path(path, output)
+        expanded = File.expand_path(path)
+        output = File.expand_path(output)
+        external = File.join(File.dirname(output), 'mprcontents')
+        raise ArgumentError, 'refusing to remove the source MPR' if expanded == source
+
+        unless expanded == output || expanded == external
+          raise ArgumentError, "refusing to remove unmanaged path #{expanded}"
+        end
+        return unless File.exist?(expanded) || File.symlink?(expanded)
+
+        if File.directory?(expanded) && !File.symlink?(expanded)
+          FileUtils.remove_entry_secure(expanded)
+        else
+          FileUtils.rm_f(expanded)
+        end
+      end
+
+      def read_state
+        JSON.parse(File.binread(state_path))
+      rescue Errno::ENOENT
+        nil
+      rescue JSON::ParserError => e
+        raise ArgumentError, "invalid diagram lifecycle state: #{e.message}"
+      end
+
+      def write_state(payload)
+        prepare_instance_dir
+        temporary = "#{state_path}.#{Process.pid}.tmp"
+        File.binwrite(temporary, JSON.pretty_generate(payload))
+        File.chmod(0o600, temporary)
+        File.rename(temporary, state_path)
+      ensure
+        FileUtils.rm_f(temporary) if defined?(temporary) && temporary
+      end
+
+      def default_output
+        File.join(File.dirname(source), "#{File.basename(source, '.mpr')}.domain-layout.mpr")
+      end
+
+      def prepare_instance_dir
+        FileUtils.mkdir_p(instance_dir)
+        File.chmod(0o700, instance_dir)
+      end
+
+      def url_for(state) = "http://#{state.fetch('host')}:#{state.fetch('port')}"
+      def instance_dir = File.join(state_root, Digest::SHA256.hexdigest(source)[0, 24])
+      def state_path = File.join(instance_dir, 'state.json')
+      def log_path = File.join(instance_dir, 'server.log')
+    end
+    # rubocop:enable Metrics
+  end
+end