mbeditor 0.5.3 → 0.7.1

data/app/controllers/mbeditor/git_controller.rb

@@ -80,38 +80,7 @@ module Mbeditor
       return render json: { error: "sha required" }, status: :bad_request if sha.blank?
       return render json: { error: "Invalid sha" }, status: :bad_request unless sha.match?(/\A[0-9a-fA-F]{1,40}\z/)
 
-      files_output, _err, files_status = Open3.capture3(
-        "git", "-C", workspace_root.to_s,
-        "diff-tree", "--no-commit-id", "-r", "--name-status", sha
-      )
-      numstat_output, _err, numstat_status = Open3.capture3(
-        "git", "-C", workspace_root.to_s,
-        "diff-tree", "--no-commit-id", "-r", "--numstat", sha
-      )
-
-      numstat_map = numstat_status.success? ? GitService.parse_numstat(numstat_output) : {}
-
-      files = []
-      if files_status.success?
-        files = files_output.lines.map do |line|
-          parts = line.strip.split("\t", 2)
-          next if parts.length < 2
-          file = { "status" => parts[0].strip, "path" => parts[1].strip }
-          file.merge(numstat_map.fetch(file["path"], {}))
-        end.compact
-      end
-
-      log_output, _err, log_status = Open3.capture3(
-        "git", "-C", workspace_root.to_s,
-        "log", "-1", "--pretty=format:%s%x1f%an%x1f%aI", sha
-      )
-      meta = {}
-      if log_status.success?
-        fields = log_output.strip.split("\x1f", 3)
-        meta = { "title" => fields[0].to_s, "author" => fields[1].to_s, "date" => fields[2].to_s }
-      end
-
-      render json: { sha: sha, title: meta["title"] || "", author: meta["author"] || "", date: meta["date"] || "", files: files }
+      render json: GitCommitDetailService.new(repo_path: workspace_root, sha: sha).call
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -122,35 +91,7 @@ module Mbeditor
     # scope=branch → git diff <branch-base>..HEAD (same baseline as git_info)
     def combined_diff
       scope = params[:scope] == 'branch' ? :branch : :local
-
-      if scope == :local
-        out, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "diff", "HEAD")
-        out = status.success? ? out : ""
-      else
-        repo = workspace_root.to_s
-        branch = GitService.current_branch(repo)
-        base_sha, = GitService.find_branch_base(repo, branch)
-
-        if base_sha.present?
-          out, _err, status = Open3.capture3("git", "-C", repo, "diff", "#{base_sha}..HEAD")
-          out = status.success? ? out : ""
-        else
-          upstream_out, _err, upstream_status = Open3.capture3(
-            "git", "-C", repo,
-            "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"
-          )
-          upstream = upstream_status.success? ? upstream_out.strip : nil
-          upstream = nil unless upstream&.match?(%r{\A[\w./-]+\z})
-
-          if upstream.present?
-            out, _err, status = Open3.capture3("git", "-C", repo, "diff", "#{upstream}..HEAD")
-            out = status.success? ? out : ""
-          else
-            return render plain: "", content_type: "text/plain"
-          end
-        end
-      end
-
+      out = GitCombinedDiffService.new(repo_path: workspace_root, scope: scope).call
       render plain: out, content_type: "text/plain"
     rescue StandardError
       render plain: "", content_type: "text/plain"

data/app/services/mbeditor/availability_probe.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+
+module Mbeditor
+  class AvailabilityProbe
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    def self.rubocop_command(workspace_root)
+      root = Pathname.new(workspace_root)
+      command = Mbeditor.configuration.rubocop_command.to_s.strip
+      command = "rubocop" if command.empty?
+      tokens = Shellwords.split(command)
+
+      local_bin = root.join("bin", "rubocop")
+      return [local_bin.to_s] if tokens == ["rubocop"] && local_bin.exist?
+
+      tokens
+    rescue ArgumentError
+      ["rubocop"]
+    end
+
+    def self.haml_lint_command(workspace_root)
+      root = Pathname.new(workspace_root)
+      workspace_bin = root.join("bin", "haml-lint")
+      return [workspace_bin.to_s] if workspace_bin.exist?
+
+      begin
+        [Gem.bin_path("haml_lint", "haml-lint")]
+      rescue Gem::Exception, Gem::GemNotFoundException
+        ["haml-lint"]
+      end
+    end
+
+    def self.rubocop(workspace_root)
+      key = "rubocop:#{Mbeditor.configuration.rubocop_command}"
+      probe_cached(key) do
+        cmd = rubocop_command(workspace_root)
+        _out, _err, status = Open3.capture3(*cmd, "--version")
+        status.success?
+      end
+    end
+
+    def self.haml_lint(workspace_root)
+      cmd = haml_lint_command(workspace_root)
+      key = "haml_lint:#{cmd.join(' ')}"
+      probe_cached(key) do
+        _out, _err, status = Open3.capture3(*cmd, "--version")
+        status.success?
+      end
+    end
+
+    def self.git(workspace_root)
+      key = "git:#{workspace_root}"
+      probe_cached(key) do
+        _out, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "rev-parse", "--is-inside-work-tree")
+        status.success?
+      end
+    end
+
+    def self.reset!
+      MUTEX.synchronize { @cache = {} }
+      nil
+    end
+
+    def self.probe_cached(key)
+      MUTEX.synchronize do
+        @cache ||= {}
+        unless @cache.key?(key)
+          @cache[key] = begin
+            yield
+          rescue StandardError
+            false
+          end
+        end
+        @cache[key]
+      end
+    end
+    private_class_method :probe_cached
+  end
+end

data/app/services/mbeditor/code_search_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mbeditor
+  class CodeSearchService
+    JS_GLOBS = %w[*.js *.jsx *.ts *.tsx *.js.jsx *.js.erb *.jsx.erb].freeze
+
+    class << self
+      def call(pattern, workspace_root, globs: JS_GLOBS)
+        if SearchReplaceService::RG_AVAILABLE
+          run_rg(pattern, workspace_root, globs)
+        else
+          run_grep(pattern, workspace_root, globs)
+        end
+      rescue StandardError
+        []
+      end
+
+      private
+
+      def run_rg(pattern, workspace_root, globs)
+        args = ["rg", "--no-heading", "-n", "--color=never", "-e", pattern]
+        args += globs.flat_map { |g| ["-g", g] }
+        args << workspace_root
+        out, = Open3.capture2(*args)
+        out.lines
+      rescue StandardError
+        []
+      end
+
+      def run_grep(pattern, workspace_root, globs)
+        includes = globs.map { |g| "--include=#{g}" }
+        args = ["grep", "-rn", "--color=never", "-E", pattern] + includes + [workspace_root]
+        out, = Open3.capture2(*args)
+        out.lines
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/app/services/mbeditor/editor_state_service.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  class EditorStateService
+    PayloadTooLargeError = Class.new(StandardError)
+    InvalidBranchError   = Class.new(StandardError)
+
+    STATE_MAX_BYTES  = 1 * 1024 * 1024
+    SAFE_BRANCH_NAME = /\A[a-zA-Z0-9._\-\/]+\z/
+
+    def initialize(workspace_root)
+      @root = workspace_root
+    end
+
+    def read_state
+      path = workspace_path
+      return {} unless File.exist?(path)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError, Errno::ENOENT
+      {}
+    end
+
+    def read_branch_state(branch)
+      path = branch_states_path
+      return {} unless File.exist?(path)
+      all = JSON.parse(File.read(path))
+      all[branch] || {}
+    rescue JSON::ParserError, Errno::ENOENT
+      {}
+    end
+
+    def write_branch_state(branch, state)
+      raise InvalidBranchError, "Invalid branch name" unless branch.match?(SAFE_BRANCH_NAME)
+      payload_json = state.to_json
+      raise PayloadTooLargeError, "State payload too large" if payload_json.bytesize > STATE_MAX_BYTES
+      path = branch_states_path
+      FileUtils.mkdir_p(path.dirname)
+      File.open(path, File::RDWR | File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        existing = f.size > 0 ? JSON.parse(f.read) : {}
+        existing[branch] = state
+        f.truncate(0)
+        f.rewind
+        f.write(existing.to_json)
+      end
+      nil
+    end
+
+    def prune_branch_states(active_branches:)
+      path = branch_states_path
+      return [] unless File.exist?(path)
+      pruned = []
+      File.open(path, File::RDWR) do |f|
+        f.flock(File::LOCK_EX)
+        all = JSON.parse(f.read) rescue {}
+        pruned = all.keys - active_branches
+        if pruned.any?
+          pruned.each { |b| all.delete(b) }
+          f.truncate(0)
+          f.rewind
+          f.write(all.to_json)
+        end
+      end
+      pruned
+    end
+
+    def write_state(state)
+      payload = state.to_json
+      raise PayloadTooLargeError, "State payload too large" if payload.bytesize > STATE_MAX_BYTES
+      path = workspace_path
+      FileUtils.mkdir_p(path.dirname)
+      File.open(path, File::RDWR | File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        f.truncate(0)
+        f.rewind
+        f.write(payload)
+      end
+      nil
+    end
+
+    private
+
+    def workspace_path
+      @root.join("tmp", "mbeditor_workspace.json")
+    end
+
+    def branch_states_path
+      @root.join("tmp", "mbeditor_branch_states.json")
+    end
+  end
+end

data/app/services/mbeditor/exclusion_matcher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  class ExclusionMatcher
+    def initialize(patterns)
+      @patterns = patterns.map(&:to_s).reject(&:empty?)
+    end
+
+    def excluded?(relative_path)
+      @patterns.any? { |pattern| matches?(pattern, relative_path) }
+    end
+
+    private
+
+    def matches?(pattern, rel)
+      if pattern.include?("/")
+        rel == pattern || rel.start_with?("#{pattern}/")
+      else
+        File.basename(rel) == pattern || rel.split("/").include?(pattern)
+      end
+    end
+  end
+end

data/app/services/mbeditor/file_operation_service.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Mbeditor
+  class FileOperationService
+    MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024
+
+    class FileTooLargeError  < StandardError; end
+    class FileExistsError    < StandardError; end
+    class PathNotFoundError  < StandardError; end
+    class TargetExistsError  < StandardError; end
+
+    def initialize(workspace_root)
+      @workspace_root = Pathname(workspace_root)
+    end
+
+    def save(path, content)
+      raise FileTooLargeError if content.bytesize > MAX_FILE_SIZE_BYTES
+
+      File.write(path, content)
+      { ok: true, path: relative_path(path) }
+    end
+
+    def destroy_path(path)
+      return { ok: true } unless File.exist?(path)
+
+      if File.directory?(path)
+        FileUtils.rm_rf(path)
+        { ok: true, type: "folder", path: relative_path(path) }
+      else
+        File.delete(path)
+        { ok: true, type: "file", path: relative_path(path) }
+      end
+    end
+
+    def rename(old_path, new_path)
+      raise PathNotFoundError unless File.exist?(old_path)
+      raise TargetExistsError if File.exist?(new_path)
+
+      FileUtils.mkdir_p(File.dirname(new_path))
+      FileUtils.mv(old_path, new_path)
+      { ok: true, oldPath: relative_path(old_path), path: relative_path(new_path), name: File.basename(new_path) }
+    end
+
+    def create_dir(path)
+      raise FileExistsError if File.exist?(path)
+
+      FileUtils.mkdir_p(path)
+      { ok: true, type: "folder", path: relative_path(path), name: File.basename(path) }
+    end
+
+    def create_file(path, content)
+      raise FileTooLargeError if content.bytesize > MAX_FILE_SIZE_BYTES
+      raise FileExistsError if File.exist?(path)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, content)
+      { ok: true, type: "file", path: relative_path(path), name: File.basename(path) }
+    end
+
+    private
+
+    def relative_path(path)
+      Pathname(path).relative_path_from(@workspace_root).to_s
+    end
+  end
+end

data/app/services/mbeditor/file_tree_service.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  class FileTreeService
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    def self.build(workspace_root)
+      root = workspace_root.to_s
+      MUTEX.synchronize do
+        @cache ||= {}
+        entry = @cache[root]
+        if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < 15
+          return entry[:data]
+        end
+      end
+
+      matcher = ExclusionMatcher.new(Mbeditor.configuration.excluded_paths)
+      data = traverse(root, root, matcher)
+
+      MUTEX.synchronize do
+        @cache ||= {}
+        @cache[root] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
+      end
+
+      data
+    end
+
+    def self.invalidate(workspace_root)
+      MUTEX.synchronize do
+        @cache ||= {}
+        @cache.delete(workspace_root.to_s)
+      end
+      nil
+    end
+
+    def self.reset!
+      MUTEX.synchronize { @cache = {} }
+      nil
+    end
+
+    def self.traverse(dir, workspace_root, matcher, max_depth: 10, depth: 0)
+      return [] if depth >= max_depth
+
+      entries = Dir.entries(dir).sort.reject { |e| e == "." || e == ".." }
+      entries.filter_map do |name|
+        full = File.join(dir, name)
+        rel  = full.delete_prefix(workspace_root + "/")
+        rel  = "" if rel == workspace_root
+        is_excl = matcher.excluded?(rel)
+
+        if File.directory?(full)
+          children = is_excl ? [] : traverse(full, workspace_root, matcher, max_depth: max_depth, depth: depth + 1)
+          node = { name: name, type: "folder", path: rel, children: children }
+          node[:excluded] = true if is_excl
+          node
+        else
+          node = { name: name, type: "file", path: rel }
+          node[:size] = (File.size(full) rescue nil) unless is_excl
+          node[:excluded] = true if is_excl
+          node
+        end
+      end
+    rescue Errno::EACCES
+      []
+    end
+    private_class_method :traverse
+  end
+end

data/app/services/mbeditor/git_combined_diff_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  class GitCombinedDiffService
+    include GitService
+
+    attr_reader :repo_path, :scope
+
+    def initialize(repo_path:, scope:)
+      @repo_path = repo_path.to_s
+      @scope     = scope
+    end
+
+    def call
+      return local_diff if scope == :local
+
+      branch_diff
+    end
+
+    private
+
+    def local_diff
+      out, status = GitService.run_git(repo_path, "diff", "HEAD")
+      status.success? ? out : ""
+    end
+
+    def branch_diff
+      branch  = GitService.current_branch(repo_path)
+      base_sha, = GitService.find_branch_base(repo_path, branch)
+
+      if base_sha.present?
+        out, status = GitService.run_git(repo_path, "diff", "#{base_sha}..HEAD")
+        return status.success? ? out : ""
+      end
+
+      upstream = GitService.upstream_branch(repo_path)
+      return "" unless upstream.present?
+
+      out, status = GitService.run_git(repo_path, "diff", "#{upstream}..HEAD")
+      status.success? ? out : ""
+    end
+  end
+end

data/app/services/mbeditor/git_commit_detail_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  class GitCommitDetailService
+    include GitService
+
+    attr_reader :repo_path, :sha
+
+    def initialize(repo_path:, sha:)
+      @repo_path = repo_path.to_s
+      @sha       = sha.to_s
+    end
+
+    def call
+      meta = fetch_meta
+      { "sha" => sha, "title" => meta["title"], "author" => meta["author"], "date" => meta["date"], "files" => fetch_files }
+    end
+
+    private
+
+    def fetch_files
+      name_out, name_st = GitService.run_git(repo_path, "diff-tree", "--no-commit-id", "-r", "--name-status", sha)
+      return [] unless name_st.success?
+
+      num_out, num_st = GitService.run_git(repo_path, "diff-tree", "--no-commit-id", "-r", "--numstat", sha)
+      numstat = num_st.success? ? GitService.parse_numstat(num_out) : {}
+
+      name_out.lines.filter_map do |line|
+        parts = line.strip.split("\t", 2)
+        next if parts.length < 2
+
+        path = parts[1].strip
+        stats = numstat.fetch(path, { added: 0, removed: 0 })
+        { "status" => parts[0].strip, "path" => path, "added" => stats[:added], "removed" => stats[:removed] }
+      end
+    end
+
+    def fetch_meta
+      out, status = GitService.run_git(repo_path, "log", "-1", "--pretty=format:%s%x1f%an%x1f%aI", sha)
+      return { "title" => "", "author" => "", "date" => "" } unless status.success?
+
+      fields = out.strip.split("\x1f", 3)
+      { "title" => fields[0].to_s, "author" => fields[1].to_s, "date" => fields[2].to_s }
+    end
+  end
+end

data/app/services/mbeditor/git_info_service.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mbeditor
+  module GitInfoService
+    module_function
+
+    GIT_INFO_MUTEX = Mutex.new
+    private_constant :GIT_INFO_MUTEX
+
+    def call(repo_path)
+      cached = cached_git_info(repo_path)
+      return cached if cached
+
+      branch = GitService.current_branch(repo_path)
+      unless branch
+        return { ok: false, error: "Unable to determine current branch" }
+      end
+
+      # Wave 1: all independent git reads run in parallel
+      status_t   = Thread.new { Open3.capture3("git", "-C", repo_path, "status", "--porcelain") }
+      numstat_t  = Thread.new { Open3.capture3("git", "-C", repo_path, "diff", "--numstat", "HEAD") }
+      upstream_t = Thread.new { Open3.capture3("git", "-C", repo_path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}") }
+      base_t     = Thread.new { GitService.find_branch_base(repo_path, branch) }
+
+      working_output, _err, working_status = status_t.value
+      working_tree = working_status.success? ? GitService.parse_porcelain_status(working_output) : []
+
+      numstat_out = numstat_t.value.first
+      numstat_map = GitService.parse_numstat(numstat_out)
+      working_tree = working_tree.map { |f| f.merge(numstat_map.fetch(f[:path], {})) }
+
+      upstream_output, _err, upstream_status = upstream_t.value
+      upstream_branch = upstream_status.success? ? upstream_output.strip : nil
+      upstream_branch = nil unless upstream_branch&.match?(%r{\A[\w./-]+\z})
+
+      base_sha, base_ref = base_t.value
+
+      ahead_count    = 0
+      behind_count   = 0
+      unpushed_files = []
+      unpushed_commits = []
+      diff_base = base_sha || upstream_branch
+
+      # Wave 2: conditional parallel reads that depend on Wave 1 results
+      wave2 = {}
+      wave2[:counts]    = Thread.new { Open3.capture3("git", "-C", repo_path, "rev-list", "--left-right", "--count", "HEAD...#{upstream_branch}") } if upstream_branch.to_s != ""
+      wave2[:unp_log]   = Thread.new { Open3.capture3("git", "-C", repo_path, "log", "#{upstream_branch}..HEAD", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e") } if upstream_branch.to_s != ""
+      wave2[:diff_name] = Thread.new { Open3.capture3("git", "-C", repo_path, "diff", "--name-status", "#{diff_base}..HEAD") } if diff_base.to_s != ""
+      wave2[:diff_num]  = Thread.new { Open3.capture3("git", "-C", repo_path, "diff", "--numstat", "#{diff_base}..HEAD") } if diff_base.to_s != ""
+      wave2[:branch_log] = Thread.new do
+        if base_sha
+          Open3.capture3("git", "-C", repo_path, "log", "--first-parent", "#{base_sha}..HEAD",
+                         "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
+        else
+          Open3.capture3("git", "-C", repo_path, "log", "--first-parent", branch, "-n", "100",
+                         "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
+        end
+      end
+
+      wave2.each_value(&:join)
+
+      if (ct = wave2[:counts])
+        counts_output, _err, counts_status = ct.value
+        if counts_status.success?
+          ahead_str, behind_str = counts_output.strip.split("\t", 2)
+          ahead_count  = ahead_str.to_i
+          behind_count = behind_str.to_i
+        end
+      end
+
+      if (ul = wave2[:unp_log])
+        unpushed_log_output, _err, unpushed_log_status = ul.value
+        unpushed_commits = GitService.parse_git_log(unpushed_log_output) if unpushed_log_status.success?
+      end
+
+      if (dn = wave2[:diff_name]) && (dnum = wave2[:diff_num])
+        diff_name_out, _err, diff_name_status = dn.value
+        if diff_name_status.success?
+          unpushed_files  = GitService.parse_name_status(diff_name_out)
+          unp_numstat_out = dnum.value.first
+          unp_numstat_map = GitService.parse_numstat(unp_numstat_out)
+          unpushed_files  = unpushed_files.map { |f| f.merge(unp_numstat_map.fetch(f[:path], {})) }
+        end
+      end
+
+      branch_log_output, _err, branch_log_status = wave2[:branch_log].value
+      branch_commits = branch_log_status.success? ? GitService.parse_git_log(branch_log_output) : []
+
+      redmine_ticket_id = nil
+      if Mbeditor.configuration.redmine_enabled
+        if Mbeditor.configuration.redmine_ticket_source == :branch
+          m = branch.match(/\A(\d+)/)
+          redmine_ticket_id = m[1] if m
+        else
+          branch_commits.each do |commit|
+            m = commit["title"]&.match(/#(\d+)/)
+            if m
+              redmine_ticket_id = m[1]
+              break
+            end
+          end
+        end
+      end
+
+      payload = {
+        ok: true,
+        branch: branch,
+        upstreamBranch: upstream_branch,
+        ahead: ahead_count,
+        behind: behind_count,
+        workingTree: working_tree,
+        unpushedFiles: unpushed_files,
+        unpushedCommits: unpushed_commits,
+        branchCommits: branch_commits,
+        branchBaseRef: base_ref,
+        redmineTicketId: redmine_ticket_id
+      }
+      store_git_info(repo_path, payload)
+      payload
+    rescue StandardError => e
+      { ok: false, error: e.message }
+    end
+
+    def invalidate(repo_path)
+      GIT_INFO_MUTEX.synchronize do
+        cache = instance_variable_get(:@git_info_cache) || {}
+        cache.delete(repo_path)
+        instance_variable_set(:@git_info_cache, cache)
+      end
+    end
+
+    def cached_git_info(repo_path, ttl: 5)
+      GIT_INFO_MUTEX.synchronize do
+        cache = instance_variable_get(:@git_info_cache) || {}
+        entry = cache[repo_path]
+        return entry[:data] if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < ttl
+      end
+      nil
+    end
+
+    def store_git_info(repo_path, data)
+      GIT_INFO_MUTEX.synchronize do
+        cache = instance_variable_get(:@git_info_cache) || {}
+        cache[repo_path] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
+        instance_variable_set(:@git_info_cache, cache)
+      end
+    end
+  end
+end