mxrb 0.1.3 → 0.1.4

data/lib/mxrb/environment.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'monitor'
+
+module Mxrb
+  # Immutable, stdlib-only environment configuration. Loading never mutates
+  # process ENV; apply and with are the explicit mutation boundaries.
+  class Environment # rubocop:disable Metrics/ClassLength
+    class Error < StandardError; end
+    class InvalidName < ArgumentError; end
+
+    # Syntax error with location but never with the offending secret value.
+    class ParseError < Error
+      attr_reader :path, :line
+
+      def initialize(path, line, reason)
+        @path = path
+        @line = line
+        super("invalid environment file #{path}:#{line}: #{reason}")
+      end
+    end
+
+    NAME_PATTERN = /\A[a-z][a-z0-9_-]*\z/
+    KEY_PATTERN = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    ALIASES = {
+      'dev' => 'development',
+      'development' => 'development',
+      'qa' => 'qa',
+      'homolog' => 'staging',
+      'homologation' => 'staging',
+      'staging' => 'staging',
+      'prod' => 'production',
+      'production' => 'production'
+    }.freeze
+    PROFILE_KEYS = %w[MXRB_ENV RACK_ENV RAILS_ENV].freeze
+    WITH_MONITOR = Monitor.new
+    UNSET = Object.new.freeze
+
+    attr_reader :name, :requested_name, :root, :sources
+
+    def self.load(name = nil, root: Dir.pwd, process: ENV)
+      new(name, root:, process:)
+    end
+
+    def initialize(name = nil, root: Dir.pwd, process: ENV)
+      @root = File.expand_path(root)
+      @process = stringify(process)
+      @requested_name = validate_name(name || detected_name)
+      @name = ALIASES.fetch(@requested_name, @requested_name)
+      @sources = existing_sources.freeze
+      @values = load_values.freeze
+    end
+
+    def fetch(key, default = UNSET, &block)
+      normalized = key.to_s
+      return @values.fetch(normalized, &block) if block
+      return @values.fetch(normalized) if default.equal?(UNSET)
+
+      @values.fetch(normalized, default)
+    end
+
+    def [](key) = @values[key.to_s]
+    def key?(key) = @values.key?(key.to_s)
+
+    def to_h = @values.dup
+
+    # Applies to ENV by default only when explicitly called. overwrite: false
+    # preserves keys already present in the target.
+    def apply(target = ENV, overwrite: true)
+      @values.each do |key, value|
+        next if !overwrite && target.key?(key)
+
+        target[key] = value
+      end
+      target
+    end
+
+    # Applies the configuration for one block and restores the target even if
+    # the block raises. Calls are serialized because process ENV is global.
+    def with(target = ENV, overwrite: true)
+      WITH_MONITOR.synchronize do
+        snapshot = snapshot(target, overwrite:)
+        apply(target, overwrite:)
+        begin
+          yield self
+        ensure
+          restore(target, snapshot)
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class} name=#{name.inspect} root=#{root.inspect} " \
+        "sources=#{sources.size} keys=#{@values.size}>"
+    end
+
+    private
+
+    def detected_name
+      PROFILE_KEYS.each do |key|
+        value = @process[key].to_s.strip
+        return value unless value.empty?
+      end
+      'development'
+    end
+
+    def validate_name(raw)
+      candidate = raw.to_s.strip.downcase
+      raise InvalidName, "invalid environment name #{raw.inspect}" unless NAME_PATTERN.match?(candidate)
+
+      candidate.freeze
+    end
+
+    def candidate_sources
+      [
+        File.join(root, '.env'),
+        File.join(root, ".env.#{name}"),
+        File.join(root, 'config', 'environments', "#{name}.env")
+      ]
+    end
+
+    def existing_sources = candidate_sources.select { File.file?(_1) }
+
+    def load_values
+      loaded = sources.each_with_object({}) do |path, values|
+        values.update(Parser.new(path).parse)
+      end
+      immutable(loaded.merge(@process))
+    end
+
+    def stringify(values)
+      immutable(values.to_h.to_h { |key, value| [key.to_s, value.to_s] })
+    end
+
+    def immutable(values)
+      values.to_h do |key, value|
+        [key.to_s.dup.freeze, value.to_s.dup.freeze]
+      end.freeze
+    end
+
+    def snapshot(target, overwrite:)
+      keys = overwrite ? @values.keys : @values.keys.reject { target.key?(_1) }
+      keys.to_h do |key|
+        [key, target.key?(key) ? [:present, target[key]] : [:missing, nil]]
+      end
+    end
+
+    def restore(target, snapshot)
+      snapshot.each do |key, (state, value)|
+        state == :present ? target[key] = value : target.delete(key)
+      end
+    end
+
+    # A deliberately non-shell parser: values are read as data and variable,
+    # command, or backtick expansion is never performed.
+    class Parser
+      def initialize(path)
+        @path = path
+      end
+
+      def parse
+        File.foreach(@path, encoding: 'bom|utf-8').with_index(1).each_with_object({}) do |(line, number), result|
+          parse_line(line, number, result)
+        end
+      rescue ArgumentError, EncodingError => e
+        raise ParseError.new(@path, 1, e.message), cause: e
+      end
+
+      private
+
+      def parse_line(line, number, result)
+        source = line.strip
+        return if source.empty? || source.start_with?('#')
+
+        source = source.delete_prefix('export ').lstrip
+        key, raw = source.split('=', 2)
+        key = key.to_s.strip
+        error(number, 'expected KEY=VALUE') if raw.nil? || !KEY_PATTERN.match?(key)
+        result[key] = parse_value(raw.lstrip, number)
+      end
+
+      def parse_value(source, number)
+        return '' if source.empty?
+        return quoted_value(source, number, "'") if source.start_with?("'")
+        return quoted_value(source, number, '"') if source.start_with?('"')
+
+        source.sub(/\s+#.*\z/, '').rstrip
+      end
+
+      def quoted_value(source, number, quote)
+        value, remainder = extract_quoted(source, quote)
+        error(number, 'unterminated quoted value') unless remainder
+        error(number, 'unexpected content after quoted value') unless remainder.strip.match?(/\A(?:#.*)?\z/)
+
+        quote == '"' ? unescape_double(value) : value
+      end
+
+      def extract_quoted(source, quote) # rubocop:disable Metrics/MethodLength
+        escaped = false
+        source.each_char.with_index do |character, index|
+          if escaped
+            escaped = false
+            next
+          end
+
+          if character == '\\' && quote == '"'
+            escaped = true
+          elsif character == quote && index.positive?
+            return [source[1...index], source[(index + 1)..]]
+          end
+        end
+        [nil, nil]
+      end
+
+      def unescape_double(value)
+        value.gsub(/\\([nrt"\\])/) do
+          { 'n' => "\n", 'r' => "\r", 't' => "\t", '"' => '"', '\\' => '\\' }.fetch(Regexp.last_match(1))
+        end
+      end
+
+      def error(line, reason)
+        raise ParseError.new(@path, line, reason)
+      end
+    end
+  end
+end

data/lib/mxrb/exporter.rb

@@ -8,6 +8,7 @@ require "digest"
 module Mxrb
   # Exports an MPR into an editable, layered Ruby source tree.
   class Exporter
+    MODES = %i[mendix ruby].freeze
     LAYERS = %w[domain application presentation infrastructure].freeze
     MODULE_PROGRESS_WEIGHT = 10
     MARKETPLACE_PROVENANCE = [
@@ -58,18 +59,25 @@ module Mxrb
       Microflows$RestCallAction
     ].freeze
 
-    def initialize(mpr_path, output_dir)
+    attr_reader :mode
+
+    def initialize(mpr_path, output_dir, mode: :mendix)
       @mpr_path = File.expand_path(mpr_path)
       @output_dir = File.expand_path(output_dir)
+      @mode = mode.to_sym
+      raise ArgumentError, "export mode must be mendix or ruby" unless MODES.include?(@mode)
     end
 
     def export!(parallel: true)
+      return export_ruby!(parallel:) if mode == :ruby
+
       Progress.with("Exporting #{File.basename(@mpr_path)}") do |progress|
         FileUtils.mkdir_p(@output_dir)
         Mxrb.open(@mpr_path) do |project|
           @architecture = project.architecture_definition
           units = project.all_units
           modules = project.modules
+          @inferred_public_artifacts = infer_public_artifacts(modules)
           assets = project_asset_files
           progress.update(
             current: 0,
@@ -80,12 +88,13 @@ module Mxrb
           progress.advance(detail: "project structure")
           export_project_assets(assets, progress)
           export_native_units(project, units, progress)
+          ruby_sources = export_ruby_app_sources(project)
           export_security(project)
           progress.advance(detail: "project security")
           export_architecture_contracts(project)
           progress.advance(detail: "navigation and design system")
           export_modules(modules, progress, parallel:)
-          write_project(project)
+          write_project(project, ruby_sources:)
           progress.advance(detail: "project.rb")
         end
       end
@@ -94,6 +103,12 @@ module Mxrb
 
     private
 
+    def export_ruby!(parallel:)
+      sidecar = File.join(@output_dir, ".mxrb", "mendix")
+      self.class.new(@mpr_path, sidecar, mode: :mendix).export!(parallel:)
+      RubyApp::Exporter.new(@mpr_path, @output_dir, mendix_sidecar: sidecar).export!
+    end
+
     def export_module(mod)
       root = File.join(@output_dir, "modules", mod.name)
       LAYERS.each { FileUtils.mkdir_p(File.join(root, _1)) }
@@ -186,6 +201,24 @@ module Mxrb
       )
     end
 
+    def export_ruby_app_sources(project)
+      files = project.mpr.ruby_app_sources
+      return false if files.empty?
+
+      payload = files.map do |file|
+        contents = file.fetch(:contents)
+        {
+          "path" => file.fetch(:path), "sha256" => file.fetch(:sha256),
+          "contents" => Base64.strict_encode64(contents), "mode" => file.fetch(:mode, 0o644)
+        }
+      end
+      write(
+        File.join(@output_dir, ".mxrb", "ruby_sources.json"),
+        JSON.pretty_generate("version" => 1, "files" => payload)
+      )
+      true
+    end
+
     def export_modules(modules, progress, parallel:)
       operation = lambda do |mod|
         export_module(mod)
@@ -279,7 +312,7 @@ module Mxrb
       paths = {}
       grouped = mod.entities.group_by { entity_domain_route(_1) }
       grouped.each do |route, entities|
-        unique_entity_filenames(entities).each do |id, filename|
+        unique_entity_filenames(entities, route:).each do |id, filename|
           paths[id] = File.join(route, filename)
         end
       end
@@ -337,7 +370,10 @@ module Mxrb
       mod.microflows.each do |flow|
         layer, category = flow_location(flow.name)
         relative = File.join(category, files.fetch(flow.id))
-        metadata = architecture&.fetch(:microflows, [])&.find { _1[:name] == flow.name }
+        metadata = flow_metadata(
+          mod.name, :microflow, flow.name,
+          architecture&.fetch(:microflows, [])&.find { _1[:name] == flow.name }
+        )
         write(File.join(root, layer, relative), microflow_source(flow, metadata))
         by_layer.fetch(layer) << relative
       end
@@ -466,7 +502,10 @@ module Mxrb
       architecture = architecture_module(mod.name)
       flows.each do |flow|
         relative = File.join("client_actions", files.fetch(flow.id))
-        metadata = architecture&.fetch(:nanoflows, [])&.find { _1[:name] == flow.name }
+        metadata = flow_metadata(
+          mod.name, :nanoflow, flow.name,
+          architecture&.fetch(:nanoflows, [])&.find { _1[:name] == flow.name }
+        )
         write(File.join(presentation, relative), nanoflow_source(flow, metadata))
         paths << relative
       end
@@ -497,7 +536,7 @@ module Mxrb
       end
     end
 
-    def write_project(project)
+    def write_project(project, ruby_sources: false)
       module_loads = project.modules.map do |mod|
         %(  evaluate File.join(__dir__, "modules", #{ruby(mod.name)}, "module.rb"))
       end.join("\n")
@@ -513,6 +552,7 @@ module Mxrb
           mendix_version #{ruby(project.mendix_version || "10.18.0")}
           native_units File.join(__dir__, ".mxrb", "native_units.json")
           project_assets File.join(__dir__, ".mxrb", "assets.json"), root: __dir__
+      #{'    ruby_app_sources File.join(__dir__, ".mxrb", "ruby_sources.json")' if ruby_sources}
           evaluate File.join(__dir__, ".mxrb", "native_units.rb")
           evaluate File.join(__dir__, "app", "security", "security.rb")
           evaluate File.join(__dir__, "app", "navigation", "navigation.rb")
@@ -824,19 +864,21 @@ module Mxrb
       end
     end
 
-    def unique_entity_filenames(entities)
-      unique_filenames(entities)
+    def unique_entity_filenames(entities, route: nil)
+      suffix = route == "dtos" ? "_dto" : nil
+      unique_filenames(entities, suffix:)
     end
 
-    def unique_filenames(entities)
+    def unique_filenames(entities, suffix: nil)
       used = {}
       entities.to_h do |entity|
         base = underscore(entity.name)
+        base = "#{base}#{suffix}" if suffix && !base.end_with?(suffix)
         candidate = "#{base}.rb"
-        suffix = 2
+        sequence = 2
         while used[candidate]
-          candidate = "#{base}_#{suffix}.rb"
-          suffix += 1
+          candidate = "#{base}_#{sequence}.rb"
+          sequence += 1
         end
         used[candidate] = true
         [entity.id, candidate]
@@ -864,6 +906,8 @@ module Mxrb
       body << "  return_type #{symbol(flow.return_type)}" if flow.return_type.is_a?(String)
       body << "  documentation #{ruby(flow.documentation)}" unless flow.documentation.to_s.empty?
       body << "  allow_concurrent_execution #{flow.allow_concurrent_execution ? 'true' : 'false'}"
+      apply_entity_access = flow.respond_to?(:apply_entity_access) && flow.apply_entity_access
+      body << "  apply_entity_access #{apply_entity_access ? 'true' : 'false'}"
       body << "  mark_as_used #{flow.mark_as_used ? 'true' : 'false'}"
       body << "  excluded #{flow.excluded ? 'true' : 'false'}"
       body << "  allowed_roles #{flow.allowed_module_roles.map { symbol(_1) }.join(', ')}" unless flow.allowed_module_roles.empty?
@@ -883,10 +927,12 @@ module Mxrb
       elsif objects.any?
         body << "  # Native body baseline retained: this graph shape has no typed DSL mapping yet"
       end
+      declaration = [symbol(flow.name)]
+      declaration << "public: true" if metadata&.fetch(:public, false)
       <<~RUBY
         # frozen_string_literal: true
 
-        microflow #{symbol(flow.name)} do
+        microflow #{declaration.join(', ')} do
       #{body.join("\n")}
         end
       RUBY
@@ -927,7 +973,7 @@ module Mxrb
       body << "  allowed_roles #{page.allowed_module_roles.map { symbol(_1) }.join(', ')}" unless page.allowed_module_roles.empty?
       deep = page_deep_structure(page)
       if (source = metadata&.dig(:data_source) || page.data_source)
-        body << "  data_source #{source.fetch(:kind)}: #{symbol(source.fetch(:name))}"
+        body << "  data_source #{source.fetch(:kind)}: #{reference(source.fetch(:name))}"
       end
       body << "  deep_structure(#{native_ruby(deep, 2)})" if deep
       metadata&.fetch(:events, [])&.each do |event|
@@ -1016,7 +1062,9 @@ module Mxrb
     def render_widget(widget, indent)
       pad       = " " * indent
       child_pad = " " * (indent + 2)
-      type      = widget.fetch(:type)
+      # Architecture metadata is serialized through JSON inside generated MPRs,
+      # so a second export can surface widget type values as strings.
+      type      = widget.fetch(:type).to_sym
       options   = widget.fetch(:options, {})
 
       # Snippet: snippet :name, from: "..."
@@ -1856,6 +1904,32 @@ module Mxrb
       @architecture&.fetch(:modules, [])&.find { _1[:name] == name }
     end
 
+    def infer_public_artifacts(modules)
+      modules.each_with_object({}) do |mod, public_artifacts|
+        mod.pages.each do |page|
+          source = page.data_source
+          next unless source
+
+          target_module, target_name = source.fetch(:name).to_s.split(".", 2)
+          next if target_name.to_s.empty? || target_module == mod.name
+
+          public_artifacts[[target_module, source.fetch(:kind).to_sym, target_name]] = true
+        end
+      end
+    end
+
+    def flow_metadata(module_name, kind, name, metadata)
+      result = metadata ? metadata.dup : {}
+      if @inferred_public_artifacts&.include?([module_name, kind, name])
+        result[:public] = true
+      end
+      result.empty? ? nil : result
+    end
+
+    def reference(value)
+      value.to_s.include?(".") ? ruby(value.to_s) : symbol(value)
+    end
+
     def symbol(value)
       value.to_s.to_sym.inspect
     end

data/lib/mxrb/http/server.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'puma'
+require 'uri'
+
+module Mxrb
+  module Http
+    # Case-insensitive HTTP header collection used by the internal request API.
+    class Headers
+      def initialize(values = {})
+        @values = values.to_h { |name, value| [name.to_s.downcase, value.to_s] }
+      end
+
+      def [](name) = @values[name.to_s.downcase]
+    end
+
+    Request = Data.define(:path, :request_method, :body, :query, :headers) do
+      def [](name) = headers[name]
+    end
+
+    # Mutable response keeps the existing MXRB dispatchers independent of Rack.
+    class Response
+      attr_accessor :status, :body
+      attr_reader :headers
+
+      def initialize
+        @status = 200
+        @body = ''
+        @headers = {}
+      end
+
+      def [](name) = headers[name]
+
+      def []=(name, value)
+        headers[name] = value
+      end
+    end
+
+    # Small embedded-Puma adapter for MXRB's loopback-only HTTP services.
+    class Server
+      DEFAULT_MAX_THREADS = 5
+
+      attr_reader :host, :port, :puma
+
+      def initialize(host:, port:, logger: nil, max_threads: DEFAULT_MAX_THREADS, &dispatcher)
+        raise ArgumentError, 'HTTP dispatcher is required' unless dispatcher
+
+        @host = host.to_s
+        @port = Integer(port)
+        @dispatcher = dispatcher
+        @logger = logger
+        @max_threads = Integer(max_threads)
+      end
+
+      def start
+        @puma = Puma::Server.new(method(:call), nil, puma_options)
+        @puma.add_tcp_listener(host, port)
+        yield(@puma) if block_given?
+        @thread = @puma.run
+        @thread.join
+      end
+
+      def shutdown = @puma&.stop
+
+      def call(environment)
+        request = request_from(environment)
+        response = Response.new
+        @dispatcher.call(request, response)
+        [response.status, response.headers, [response.body.to_s]]
+      end
+
+      private
+
+      def puma_options
+        {
+          min_threads: 0,
+          max_threads: @max_threads,
+          environment: 'production',
+          log_writer: @logger || Puma::LogWriter.null,
+          queue_requests: true
+        }
+      end
+
+      def request_from(environment)
+        input = environment['rack.input']
+        body = input ? input.read.to_s : ''
+        input.rewind if input.respond_to?(:rewind)
+        Request.new(
+          path: "#{environment['SCRIPT_NAME']}#{environment.fetch('PATH_INFO', '/')}",
+          request_method: environment.fetch('REQUEST_METHOD', 'GET'),
+          body:,
+          query: URI.decode_www_form(environment['QUERY_STRING'].to_s).to_h,
+          headers: Headers.new(request_headers(environment))
+        )
+      end
+
+      def request_headers(environment)
+        environment.each_with_object({}) do |(name, value), headers|
+          next unless name.start_with?('HTTP_')
+
+          header = name.delete_prefix('HTTP_').split('_').map(&:capitalize).join('-')
+          headers[header] = value
+        end
+      end
+    end
+  end
+end