Reemplazo de subcadena sensible a la sintaxis

Question

Tengo una cadena que contiene un formulario Clojure válido. Quiero reemplazar una parte, al igual que con assoc-in, pero procesar toda la cadena como tokens.

=> (assoc-in [:a [:b :c]] [1 0] :new) 
[:a [:new :c]] 
=> (assoc-in [:a 
       [:b,, :c]] [1 0] :new) 
[:a [:new :c]] 
=> (string-assoc-in "[:a 
         [:b,, :c]]" [1 0] ":new") 
"[:a 
    [:new,, :c]]" 

Quiero escribir string-assoc-in. Tenga en cuenta que su primer y último argumento son cadenas, y mantiene el salto de línea y las comas. ¿Es factible en Clojure? Lo más parecido que encontré es read que llama a clojure.lang.LispReader, pero no sé cómo funciona.

Quiero usarlo para leer un archivo fuente Clojure y mostrarlo con algunas modificaciones, manteniendo la estructura del archivo.

Answer 1

creo que esto debería funcionar, ya sea en su totalidad en general y no requiere su propio lector/analizador:

(defn is-clojure-whitespace? [c] 
    (or (Character/isSpace c) 
     (= \, c))) 

(defn whitespace-split 
    "Returns a map of true -> (maximal contiguous substrings of s 
    consisting of Clojure whitespace), false -> (as above, non-whitespace), 
    :starts-on-whitespace? -> (whether s starts on whitespace)." 
    [s] 
    (if (empty? s) 
    {} 
    (assoc (group-by (comp is-clojure-whitespace? first) 
        (map (partial apply str) 
          (partition-by is-clojure-whitespace? s))) 
     :starts-on-whitespace? 
     (if (is-clojure-whitespace? (first s)) true false)))) 

(defn string-assoc-in [s coords subst] 
    (let [{space-blocks true 
     starts-on-whitespace? :starts-on-whitespace?} 
     (whitespace-split s) 
     s-obj (assoc-in (binding [*read-eval* false] (read-string s)) 
         coords 
         (binding [*read-eval* false] (read-string subst))) 
     {non-space-blocks false} 
     (whitespace-split (pr-str s-obj))] 
    (apply str 
      (if starts-on-whitespace? 
      (interleave space-blocks (concat non-space-blocks [nil])) 
      (interleave non-space-blocks (concat space-blocks [nil])))))) 

Ejemplo:

user> (string-assoc-in "[:a [:b,, :c]]" [1 0] ":new") 
"[:a [:new,, :c]]" 

Actualización: Ay, cogió un error:

user> (string-assoc-in "[:a [:b,, :c\n]]" [1 0] ":new") 
"[:a [:new,, :c]]\n" 

Me encantaría que no importara, pero supongo que lo haré e intentar y hacer algo al respecto ... suspiro

Answer 2

Supongo que no quiere leer realmente un formulario y evaluarlo? fnparse tiene un Clojure parser (escrito en Clojure usando fnparse). ¿Podrías usar eso para llevarte de una cuerda a otra, luego manipularlo y volver a ponerlo en una cuerda?

Answer 3

Usted puede hacer esto con una combinación de (cadena lectura) y un poco de manipulación de cadenas:

(defn string-assoc-in 
    [a b c] 
    (.replaceAll 
    (str 
    (assoc-in (read-string (.replaceAll a ",," ",_,")) b (read-string c))) 
    " _ " ",, ")) 

user> (string-assoc-in "[:a [:b,, :c]]" [1 0] ":new") 
"[:a [:new,, :c]]" 

Tenga en cuenta que se requiere un marcador de posición de carácter reservado (en este caso, _), que usted no quiere en tus palabras clave El truco consiste en sacarlos del camino cuando el lector está haciendo un crujido en la cadena del vector y luego volverlos a poner.

Este ejemplo no aborda las nuevas líneas, pero creo que podría manejarlas de la misma manera.

Answer 4

O bien, otra opción sería utilizar ANTLR en el código parse the Clojure en un AST, luego transformar el AST y exportar de nuevo a una cadena.