mendix-ruby-bridge 0.1.3 → 0.1.4

data/lib/mendix_bridge/git_workflow.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "open3"
 require "pathname"
 require "shellwords"
+require "timeout"
 
 module MendixBridge
   class GitWorkflowError < StandardError; end
@@ -28,13 +30,13 @@ module MendixBridge
 
     def status
       {
-        "branch" => current_branch,
-        "clean" => clean?,
+        "branch"               => current_branch,
+        "clean"                => clean?,
         "operation_in_progress" => operation_in_progress,
-        "project" => @project_file,
-        "project_tracked" => tracked?(@project_file),
-        "mprcontents_tracked" => mprcontents_tracked?,
-        "ready_to_switch" => clean? && operation_in_progress.nil?
+        "project"              => @project_file,
+        "project_tracked"      => tracked?(@project_file),
+        "mprcontents_tracked"  => mprcontents_tracked?,
+        "ready_to_switch"      => clean? && operation_in_progress.nil?
       }
     end
 
@@ -43,10 +45,44 @@ module MendixBridge
         .lines.map(&:strip).reject { |name| name.end_with?("/HEAD") }
     end
 
+    def tags
+      git!("tag", "--list", "--sort=-creatordate").lines.map(&:strip).reject(&:empty?)
+    end
+
+    def worktrees
+      records = []
+      current = {}
+      git!("worktree", "list", "--porcelain").each_line do |line|
+        line = line.chomp
+        if line.empty?
+          records << current unless current.empty?
+          current = {}
+        elsif line.start_with?("worktree ")
+          current["path"] = line.delete_prefix("worktree ")
+        elsif line.start_with?("HEAD ")
+          current["sha"] = line.delete_prefix("HEAD ")
+        elsif line.start_with?("branch ")
+          current["branch"] = line.delete_prefix("branch refs/heads/")
+        elsif line == "detached"
+          current["detached"] = true
+        elsif line == "prunable"
+          current["prunable"] = true
+        elsif line.start_with?("locked")
+          current["locked"] = true
+        end
+      end
+      records << current unless current.empty?
+      records
+    end
+
     def fetch
       git!("fetch", "--prune", "origin")
     end
 
+    def remote_names
+      git!("remote").lines.map(&:strip).reject(&:empty?)
+    end
+
     def switch(branch, studio_closed:)
       ensure_switch_ready!(branch, studio_closed:)
       previous = current_branch
@@ -63,25 +99,96 @@ module MendixBridge
       validate_and_refresh!
       status
     rescue StandardError => error
-      rollback(previous) if switched
+      git!("switch", previous) if switched && current_branch != previous
       raise error
     end
 
-    def create(branch, studio_closed:)
-      ensure_switch_ready!(branch, studio_closed:)
+    def create(branch, studio_closed:, start_point: nil, carry_changes: false)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      validate_branch_name!(branch)
       raise GitWorkflowError, "branch already exists: #{branch}" if local_branch?(branch) || remote_branch?(branch)
 
       previous = current_branch
       switched = false
-      git!("switch", "-c", branch)
+      stashed = false
+      if !clean? && !carry_changes
+        git!("stash", "push", "--include-untracked", "-m", "Before creating #{branch}")
+        stashed = true
+      end
+      arguments = ["switch", "-c", branch]
+      arguments << start_point if start_point
+      git!(*arguments)
       switched = true
-      validate_and_refresh!
-      status
+      # Creating a ref does not change the project contents. Existing Mendix
+      # consistency errors must not make Git undo an otherwise valid branch.
+      { **status, "carried_changes" => !clean?, "stashed_changes" => stashed }
     rescue StandardError => error
-      rollback(previous) if switched
+      begin
+        git!("switch", previous) if switched && current_branch != previous
+        git!("stash", "pop", "--index") if stashed
+      rescue GitWorkflowError
+        # Keep the original error; the named automatic stash remains recoverable.
+      end
       raise error
     end
 
+    TERMINAL_SUBCOMMANDS = %w[
+      status diff log show blame branch switch checkout add restore reset commit
+      fetch pull push merge rebase cherry-pick revert stash tag remote worktree
+      rev-parse reflog clean mv rm grep shortlog describe bisect
+    ].freeze
+
+    # Non-interactive Git CLI used by the embedded terminal. It deliberately
+    # accepts Git commands only: a browser must never become an arbitrary shell
+    # on the machine hosting the bridge.
+    def terminal_command(command, studio_closed:)
+      arguments = Shellwords.split(command.to_s.strip)
+      arguments.shift if arguments.first == "git"
+      raise GitWorkflowError, "enter a git command" if arguments.empty?
+      raise GitWorkflowError, "git global options are not allowed in the embedded terminal" if
+        arguments.first.start_with?("-")
+
+      subcommand = arguments.first
+      unless TERMINAL_SUBCOMMANDS.include?(subcommand)
+        raise GitWorkflowError, "unsupported git command: #{subcommand}"
+      end
+
+      read_only = %w[status diff log show blame rev-parse reflog grep shortlog describe].include?(subcommand)
+      read_only ||= subcommand == "remote" &&
+        (arguments.length == 1 || arguments[1] == "-v" || arguments[1] == "show")
+      mutating = !read_only
+      ensure_studio_closed!(studio_closed) if mutating
+      ensure_no_operation! if mutating && !%w[rebase merge cherry-pick revert bisect].include?(subcommand)
+
+      output = error = nil
+      result = nil
+      Timeout.timeout(120) do
+        output, error, result = Open3.capture3(
+          {
+            "GIT_TERMINAL_PROMPT" => "0",
+            "GIT_EDITOR" => "true",
+            "GIT_SEQUENCE_EDITOR" => "true"
+          },
+          "git", "-C", @root, *arguments
+        )
+      end
+      combined = [output, error].compact.reject(&:empty?).join
+      raise GitWorkflowError, combined.strip.empty? ? "git command failed" : combined.strip unless result.success?
+
+      {
+        "ok" => true,
+        "command" => "git #{Shellwords.join(arguments)}",
+        "output" => combined.strip,
+        "exit_code" => result.exitstatus,
+        **status
+      }
+    rescue ArgumentError => error
+      raise GitWorkflowError, "invalid command line: #{error.message}"
+    rescue Timeout::Error
+      raise GitWorkflowError, "git command timed out after 120 seconds"
+    end
+
     def stash_push(studio_closed:, message: nil, include_untracked: false)
       ensure_studio_closed!(studio_closed)
       ensure_no_operation!
@@ -168,9 +275,8 @@ module MendixBridge
       status
     end
 
-    # Stages the Mendix project directory and commits it. Deliberately skips the
-    # `mx check` consistency validation so work-in-progress (even inconsistent)
-    # state can be committed; branch switches still guard against a dirty tree.
+    # Stages the whole project directory then commits. Skips mx check so
+    # work-in-progress can be committed; branch switches still guard a dirty tree.
     def commit(message, studio_closed:)
       ensure_studio_closed!(studio_closed)
       ensure_no_operation!
@@ -186,8 +292,206 @@ module MendixBridge
       status
     end
 
+    # Commits only what is already staged — no implicit git add. Enables
+    # fine-grained staging via the git panel before committing.
+    def commit_staged(message, studio_closed:)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      message = message.to_s.strip
+      raise GitWorkflowError, "commit message cannot be empty" if message.empty?
+      raise GitWorkflowError, "nothing staged to commit" if
+        git!("diff", "--cached", "--name-only").strip.empty?
+
+      git!("commit", "-m", message)
+      status
+    end
+
+    # Commit log across all branches in topo order (newest first).
+    # Returns an array of hashes with sha, short_sha, author, email, date,
+    # subject, refs (typed array), parents (SHA array).
+    def log(max: 200)
+      fmt = "%H%x1f%h%x1f%an%x1f%ae%x1f%ai%x1f%P%x1f%D%x1f%s"
+      raw = git!("log", "--all", "--topo-order",
+                 "--pretty=format:#{fmt}",
+                 "--max-count=#{max.to_i}")
+      raw.each_line.filter_map do |line|
+        fields = line.chomp.split("\x1f", 8)
+        next if fields.length < 8
+
+        sha, short_sha, author, email, date, parents_str, refs_str, subject = fields
+        next if sha.to_s.strip.empty?
+
+        {
+          "sha"       => sha.strip,
+          "short_sha" => short_sha.strip,
+          "author"    => author.strip,
+          "email"     => email.strip,
+          "date"      => date.strip,
+          "subject"   => subject.to_s.strip,
+          "refs"      => parse_refs(refs_str.to_s.strip),
+          "parents"   => parents_str.to_s.strip.split.reject(&:empty?)
+        }
+      end
+    end
+
+    # Per-file working-tree and index status (porcelain v1, NUL-terminated).
+    def file_status
+      raw = git!("status", "--porcelain=v1", "-z")
+      files = []
+      entries = raw.split("\x00")
+      i = 0
+      while i < entries.length
+        entry = entries[i]
+        unless entry.length >= 4
+          i += 1
+          next
+        end
+        xy            = entry[0..1]
+        path          = entry[3..]
+        renamed_from  = nil
+        if xy[0] == "R" || xy[0] == "C"
+          renamed_from = entries[i + 1].to_s
+          i += 1
+        end
+        files << {
+          "path"            => path.to_s,
+          "xy"              => xy,
+          "index_status"    => xy[0].to_s,
+          "worktree_status" => xy[1].to_s,
+          "renamed_from"    => renamed_from
+        }
+        i += 1
+      end
+      files
+    end
+
+    def stage(path)
+      git!("add", "--", path)
+      { "ok" => true }
+    end
+
+    def unstage(path)
+      begin
+        git!("reset", "HEAD", "--", path)
+      rescue GitWorkflowError
+        # HEAD doesn't exist yet (empty repo) — use rm --cached instead
+        git!("rm", "--cached", "--", path)
+      end
+      { "ok" => true }
+    end
+
+    def discard(path)
+      target = File.expand_path(path, @root)
+      unless target.start_with?("#{@root}/")
+        raise GitWorkflowError, "path is outside the Git repository: #{path}"
+      end
+
+      raw = git!("status", "--porcelain", "--", path).strip
+      if raw.start_with?("??")
+        FileUtils.rm_rf(target)
+      else
+        git!("checkout", "--", path)
+      end
+      { "ok" => true }
+    end
+
+    def push(remote: "origin", branch: nil)
+      branch ||= current_branch
+      output = git!("push", "--set-upstream", remote, branch)
+      { "ok" => true, "output" => output.strip }
+    end
+
+    def add_remote(name, url)
+      name = name.to_s.strip
+      url = url.to_s.strip
+      raise GitWorkflowError, "remote name cannot be empty" if name.empty?
+      raise GitWorkflowError, "remote URL cannot be empty" if url.empty?
+      raise GitWorkflowError, "invalid remote name: #{name}" unless name.match?(/\A[A-Za-z0-9._-]+\z/)
+
+      git!("remote", "add", name, url)
+      { "ok" => true, "name" => name, "url" => url }
+    end
+
+    def pull(studio_closed:)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      output = git!("pull", "--rebase")
+      refresh_inventory! if @inventory_dir
+      { "ok" => true, "output" => output.strip, **status }
+    end
+
+    def cherry_pick(sha, studio_closed:)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      output, error, result = Open3.capture3("git", "-C", @root, "cherry-pick", sha)
+      raise GitWorkflowError, "cherry-pick failed:\n#{error}#{output}" unless result.success?
+
+      refresh_inventory! if @inventory_dir
+      { "ok" => true, "output" => output.strip, **status }
+    end
+
+    def revert_commit(sha, studio_closed:)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      output, error, result = Open3.capture3("git", "-C", @root, "revert", "--no-edit", sha)
+      raise GitWorkflowError, "revert failed:\n#{error}#{output}" unless result.success?
+
+      refresh_inventory! if @inventory_dir
+      { "ok" => true, "output" => output.strip, **status }
+    end
+
+    def reset_to(sha, mode: "mixed", studio_closed:)
+      ensure_studio_closed!(studio_closed)
+      ensure_no_operation!
+      raise GitWorkflowError, "invalid reset mode: #{mode}" unless
+        %w[soft mixed hard].include?(mode.to_s)
+
+      git!("reset", "--#{mode}", sha)
+      refresh_inventory! if @inventory_dir && mode == "hard"
+      { "ok" => true, **status }
+    end
+
+    def create_tag(name, sha: nil, message: nil)
+      args = ["tag"]
+      args.concat(["-a", name, "-m", message]) if message
+      args << name unless message
+      args << sha if sha
+      git!(*args)
+      { "ok" => true }
+    end
+
+    def delete_tag(name)
+      git!("tag", "-d", name)
+      { "ok" => true }
+    end
+
+    def delete_branch(name, force: false)
+      raise GitWorkflowError, "cannot delete the current branch" if name == current_branch
+
+      git!("branch", force ? "-D" : "-d", name)
+      { "ok" => true }
+    end
+
     private
 
+    def parse_refs(refs_str)
+      return [] if refs_str.to_s.strip.empty?
+
+      refs_str.split(",").map(&:strip).reject(&:empty?).filter_map do |ref|
+        if ref.start_with?("HEAD -> ")
+          { "name" => ref.sub("HEAD -> ", ""), "type" => "head" }
+        elsif ref == "HEAD"
+          { "name" => "HEAD", "type" => "detached" }
+        elsif ref.start_with?("tag: ")
+          { "name" => ref.sub("tag: ", ""), "type" => "tag" }
+        elsif ref.include?("/")
+          { "name" => ref, "type" => "remote" }
+        else
+          { "name" => ref, "type" => "local" }
+        end
+      end
+    end
+
     def project_pathspec
       relative = Pathname.new(@project_dir).relative_path_from(Pathname.new(@root)).to_s
       relative == "." ? "." : relative
@@ -197,7 +501,10 @@ module MendixBridge
       ensure_studio_closed!(studio_closed)
       raise GitWorkflowError, "working tree is dirty; commit or stash changes first" unless clean?
       ensure_no_operation!
+      validate_branch_name!(branch)
+    end
 
+    def validate_branch_name!(branch)
       _output, error, status = Open3.capture3("git", "check-ref-format", "--branch", branch)
       raise GitWorkflowError, "invalid branch name: #{branch} (#{error.strip})" unless status.success?
     end

data/lib/mendix_bridge/mdl_parser.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module MendixBridge
+  # Parses the widget tree out of a Mendix page MDL string.
+  #
+  # Each widget node is a Hash:
+  #   {
+  #     "type"       => "dataview",          # MDL keyword (lowercase)
+  #     "name"       => "dv1",               # widget identifier (nil if anonymous)
+  #     "properties" => { "DataSource" => "$Customer", "Class" => "..." },
+  #     "children"   => [ ...widget nodes... ]
+  #   }
+  #
+  # Usage:
+  #   tree  = MdlParser.parse_page_widgets(full_mdl_string)
+  #   names = MdlParser.flat_widget_names(tree)
+  module MdlParser
+    # Words that open MDL statements and are never widget type keywords.
+    STATEMENT_KEYWORDS = %w[
+      create or modify alter grant revoke drop select
+    ].to_set.freeze
+
+    # Value qualifiers: first word of a multi-word property value.
+    MULTI_WORD_QUALIFIERS = %w[
+      microflow nanoflow database association xpath show_page open_page
+    ].to_set.freeze
+
+    # Parse the full MDL of a page (including its CREATE / MODIFY header) and
+    # return the top-level widget tree extracted from the page body { }.
+    def self.parse_page_widgets(full_mdl)
+      sc = StringScanner.new(full_mdl.to_s)
+      # Advance past 'page Module.Name ('
+      unless sc.skip_until(/\bpage\s+[\w.]+\s*\(/i)
+        return []
+      end
+      # Consume balanced settings (...) — opening ( already consumed by skip_until
+      collect_balanced(sc, "(", ")")
+      sc.skip(/\s*/)
+      return [] unless sc.scan(/\{/)
+      body = collect_balanced(sc, "{", "}")
+      parse_widget_tree(body)
+    end
+
+    # Parse a raw MDL body (content between outer braces) into a widget tree.
+    def self.parse_widget_tree(source)
+      sc = StringScanner.new(source.to_s)
+      nodes = []
+      until sc.eos?
+        skip_ws_and_comments(sc)
+        break if sc.eos?
+        node = parse_widget_node(sc)
+        if node
+          nodes << node
+        else
+          sc.getch # skip unknown char and keep going
+        end
+      end
+      nodes
+    end
+
+    # Return a flat array of all named widget identifiers in the tree (DFS).
+    def self.flat_widget_names(tree)
+      tree.flat_map do |node|
+        named = node["name"] ? [node["name"]] : []
+        named + flat_widget_names(node["children"] || [])
+      end
+    end
+
+    # Return a flat array of all widget nodes (named and anonymous), DFS.
+    def self.flat_widgets(tree)
+      tree.flat_map do |node|
+        [node] + flat_widgets(node["children"] || [])
+      end
+    end
+
+    # -------------------------------------------------------------------------
+    private_class_method def self.skip_ws_and_comments(sc)
+      loop do
+        sc.skip(/\s+/)
+        sc.scan(/--[^\n]*/) ? next : break
+      end
+    end
+
+    private_class_method def self.parse_widget_node(sc)
+      start = sc.pos
+
+      # Widget type must be a lowercase word
+      type = sc.scan(/[a-z][a-z0-9_]*/)
+      return nil unless type
+      if STATEMENT_KEYWORDS.include?(type)
+        sc.pos = start
+        return nil
+      end
+
+      skip_ws_and_comments(sc)
+
+      # Optional widget name: quoted or plain identifier (not a paren or brace)
+      name = sc.scan(/"[^"]*"/) || sc.scan(/[A-Za-z_]\w*/)
+      if name
+        # Roll back if we consumed a keyword that isn't a name
+        if STATEMENT_KEYWORDS.include?(name.downcase)
+          sc.pos -= name.bytesize
+          name = nil
+        else
+          name = name.delete_prefix('"').delete_suffix('"')
+        end
+      end
+
+      skip_ws_and_comments(sc)
+
+      # Must be followed by '(' to be a widget declaration
+      unless sc.scan(/\(/)
+        sc.pos = start
+        return nil
+      end
+
+      props_raw  = collect_balanced(sc, "(", ")")
+      properties = parse_properties(props_raw)
+
+      skip_ws_and_comments(sc)
+
+      children = []
+      if sc.scan(/\{/)
+        body = collect_balanced(sc, "{", "}")
+        children = parse_widget_tree(body)
+      end
+
+      { "type" => type, "name" => name, "properties" => properties, "children" => children }.compact
+    end
+
+    # Collect everything between a matched pair of delimiters.  The opening
+    # delimiter has already been consumed; depth starts at 1.
+    private_class_method def self.collect_balanced(sc, open, close)
+      depth = 1
+      buf = +""
+      until sc.eos? || depth.zero?
+        ch = sc.getch
+        case ch
+        when open  then depth += 1; buf << ch
+        when close
+          depth -= 1
+          buf << ch unless depth.zero?
+        when "'"
+          # Single-quoted string: '' is an escaped quote inside the string.
+          buf << ch
+          loop do
+            c = sc.getch
+            break if c.nil?
+            buf << c
+            next unless c == "'"
+            if sc.peek(1) == "'"
+              buf << sc.getch # consume the escaped-quote twin
+            else
+              break
+            end
+          end
+        else
+          buf << ch
+        end
+      end
+      buf
+    end
+
+    private_class_method def self.parse_properties(raw)
+      sc  = StringScanner.new(raw.strip)
+      out = {}
+      until sc.eos?
+        skip_ws_and_comments(sc)
+        sc.skip(/,/)
+        skip_ws_and_comments(sc)
+        break if sc.eos?
+
+        key = sc.scan(/[A-Za-z_]\w*/)
+        break unless key
+
+        skip_ws_and_comments(sc)
+        next unless sc.scan(/:/)
+        skip_ws_and_comments(sc)
+
+        value = parse_value(sc)
+        out[key] = value unless value.nil?
+      end
+      out
+    end
+
+    private_class_method def self.parse_value(sc)
+      sc.skip(/\s*/)
+      return nil if sc.eos?
+
+      # Single-quoted string
+      if sc.scan(/'/)
+        str = +""
+        loop do
+          c = sc.getch
+          break if c.nil?
+          if c == "'" && sc.peek(1) == "'"
+            str << "'"
+            sc.getch  # consume the escape twin, discard it
+          elsif c == "'"
+            break
+          else
+            str << c
+          end
+        end
+        return str
+      end
+
+      # Expression in square brackets [...]
+      if sc.scan(/\[/)
+        return "[#{collect_balanced(sc, "[", "]")}]"
+      end
+
+      # Nested block {...}
+      if sc.scan(/\{/)
+        return "{#{collect_balanced(sc, "{", "}")}}"
+      end
+
+      # Number (integer or float, optionally negative)
+      if (num = sc.scan(/-?\d+(?:\.\d+)?/))
+        return num.include?(".") ? num.to_f : num.to_i
+      end
+
+      # Identifier-based value (includes $variables and dotted paths like Module.Attr)
+      if (first = sc.scan(/\$?[A-Za-z_]\w*(?:[.$\/]\w+)*/))
+        skip_ws_and_comments(sc)
+
+        # Function call: ident(args)  →  "ident(args)"
+        if sc.scan(/\(/)
+          args = collect_balanced(sc, "(", ")")
+          return "#{first}(#{args})"
+        end
+
+        # Multi-word qualifiers: microflow Module.Name, database Module.Entity, etc.
+        if MULTI_WORD_QUALIFIERS.include?(first)
+          saved = sc.pos
+          sc.skip(/\s+/)
+          second = sc.scan(/\$?[A-Za-z_]\w*(?:[.$\/]\w+)*/)
+          if second
+            skip_ws_and_comments(sc)
+            if sc.scan(/\(/)
+              args = collect_balanced(sc, "(", ")")
+              return "#{first} #{second}(#{args})"
+            end
+            if first == "xpath" && sc.scan(/\[/)
+              constraint = "[#{collect_balanced(sc, "[", "]")}]"
+              return "#{first} #{second}#{constraint}"
+            end
+            return "#{first} #{second}"
+          else
+            sc.pos = saved
+          end
+        end
+
+        return true  if first == "true"
+        return false if first == "false"
+        return first
+      end
+
+      nil
+    end
+  end
+end