emacs query-replace-regexp inverted

Question

query-replace-regexp 동안 대체 할 서브 테이블을 대상으로하는 기존 패키지가 있습니까?

는 예를 들어 내가 중괄호 주위에 패딩을 제거하려면 다음

var foo1 = blah(properties, property_id); 

var foo2 = blah(properties, property_id); 

var foo3 = blah( properties, property_id  ); 

을 부여.

일반적으로 유지하려는 비트를 하위 그룹으로 나누고 교체를 어셈블하는 것입니다.

검색 :

\(var .* = blah\s-*(\)\s-*\(.*?\)\s-*\()\) 

교체는 :

\1\2\3 

그러나, 내가 주위에 otherway보다 삭제할 ​​ 그룹 비트를 regexp와 최대 일부 훨씬 쉽게 보인다. 이와 같이 :

var .* = blah\s-*(\(\s-*\).*?\(\s-*\)) 

이 두 개의 하위 그룹이 있습니다. 대체 대상으로 어떻게 타겟팅 할 수 있습니까?

편집 : 주어진 정규식을 "반전"할 수있는 대화식 방법을 묻습니다. 그래서 인터페이스는

1

이 그룹에 대한 교체를 입력 그룹에 대한 교체를 입력

1. 는 정규 표현식을 입력 query-replace-regexp 유사한 것 2

Answer 1

나는이 일부 변화가 일을해야한다고 생각 :

(defun remove-padding() 
    (interactive) 
    (while (search-forward-regexp 
      "var .* = [a-zA-Z_]+\\s-*(\\(\\s-*\\).*?\\(\\s-*\\))" 
      nil t) 
    ;; Replace the 2 subexpressions with nothing 
    (replace-match "" nil t nil 2) 
    (replace-match "" nil t nil 1))) 

하우 버전의 사용 사례에 따라 indent과 같은 도구를 사용하는 것도 고려해 볼 수 있습니다.

편집 : 다음은 매우 최소한의 대화 형 버전입니다. 함수 query-replace-regexp은 매우 복잡하며 모든 기능을 재현하려고 시도하지 않았습니다. 내가 여기 github

에 query-replace-regexp에 접선했습니다

(require 're-builder) 
(defun query-replace-subexpressions (regexp replacements) 
    "REPLACEMENTS need to be in reverse order if passed from lisp!" 
    ;; Read the correct number of subexpressions 
    (interactive 
    (let* ((re (read-from-minibuffer "Query replace subexps: ")) 
      (num-subexps (reb-count-subexps re)) 
      (replacement-list nil) 
      (replacements (dotimes (rep num-subexps) 
          (setq replacement-list 
           (cons 
           (read-from-minibuffer 
            (format "Replace subexpression %s with: " rep)) 
           replacement-list))))) 
    (list re replacement-list))) 
    ;; Search 
    (let ((len (length replacements))) 
    (while (search-forward-regexp regexp nil t) 
     (replace-highlight (match-beginning 0) (match-end 0) 
         (point-min) (point-max) regexp 
         t case-fold-search) 
     ;; Query 
     (when (save-match-data (y-or-n-p "Replace this occurrence? ")) 
     ;; Make all the replacements 
     (dotimes (i len) 
      (replace-match (nth i replacements) nil nil nil (- len i))))) 
    (replace-dehighlight))) 


;; Test it out below 
(query-replace-subexpressions 
"var .* = [a-zA-Z_]+\\s-*(\\(\\s-*\\).*?\\(\\s-*\\))" 
'("" "")) 

var foo1 = blah(properties, property_id ); 

var foo2 = blah (properties, property_id); 

var foo3 = blah(properties, property_id  ); 

Answer 2

는 죽은 링크의 경우에 붙여 넣기입니다 :

;; -*- lexical-binding: t -*- 

(provide inverted-replace) 

(require 're-builder) 
(require 'parallel-replace) 

(defun inverted-replace-generate-replacement (from to) 
    "invert result of current match (match-string 0)" 
    (let ((string (match-string 0)) 
     (count (reb-count-subexps from)) 
     (replacements (parallel-replace-read-list to))) 
    (save-match-data 
     (string-match from string) 
     (dotimes (i count) 
     (setq string (replace-match (nth i replacements) nil nil string (- count i))))) 
    string)) 

(defun inverted-replace-regexp (from to) 
    (interactive (destructuring-bind (from to _) 
        (query-replace-read-args "inverted-replace-regexp: " t) 
       (list from to))) 
    (query-replace-regexp from 
         (quote (replace-eval-replacement 
           replace-quote 
           (inverted-replace-generate-replacement from to))) 
         nil (and (and transient-mark-mode mark-active) 
           (region-beginning)) 
         (and (and transient-mark-mode mark-active) (region-end))))