Esistono strumenti di unione per il controllo del codice sorgente che comprendono il codice?

Question

Di recente ho lavorato su una base di codice di grandi dimensioni, refactoring e generalmente migliorando il design per aumentare la copertura. Inoltre, in parecchi file ho rimosso l'eccesso usando istruzioni, spostato metodi in modo che funzionalità simili fossero vicine tra loro, aggiunte regioni ecc. Ma non cambiassero effettivamente la funzionalità del codice nel file.

Nel frattempo, altrove nel team altri sviluppatori stanno correggendo bug e cambiando righe di codice qua e là. Ovviamente quando si tratta di unire questo può essere un problema poiché i numeri di riga non corrispondono più e i metodi potrebbero essersi spostati.

Ora capisco la regola generale secondo cui in un ambiente controllato dalla fonte può essere pericoloso spostare i metodi, e abbiamo deciso che il vantaggio era superiore al costo. Ciò che non capisco, tuttavia, è perché dovrebbe essere così.

Supponi che il mio file iniziale fosse una semplice calcolatrice:

public class Calculator
{
    public int Subtract(int a, int b)
    {
        return a + b;
    }

    public int Add(int a, int b)
    {
        return a + b;
    }
}

E ho deciso che volevo che i metodi fossero alfabetici:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a + b;
    }        
}

Mentre un altro sviluppatore ha corretto l'errore nel metodo di sottrazione

public class Calculator
{
    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Add(int a, int b)
    {
        return a + b;
    }
}

Uno strumento di unione standard richiederebbe probabilmente di unire manualmente questi due file, ma uno che comprendesse la funzionalità del codice sarebbe in grado di conciliare facilmente queste due modifiche. Lo stesso vale per la rimozione o l'aggiunta di altri metodi, commenti, regioni o l'utilizzo di istruzioni.

Quindi, per (finalmente!) arrivare alla domanda: ci sono strumenti di unione là fuori che hanno una comprensione intelligente della funzionalità del codice e potrebbero unire i due file sopra senza alcun intervento umano? In caso contrario, perché no? Ci sono delle complicazioni che rendono questo un problema irrisolvibile (ovviamente capisco che non è così semplice come sto insinuando - ma è impossibile per qualche motivo che non riesco a vedere?)

Uso C # nel mio codice sorgente e mi piacerebbe qualcosa che funzionasse con quello, ma mi interessa se questo esiste in qualsiasi parte del mondo della programmazione ...

---

Sono già molto preoccupato per la lunghezza di questa domanda, ma modificato per aggiungere come mi aspetto che funzioni il sistema di sorgente intelligente:

Quando il file iniziale della calcolatrice veniva controllato, il sistema analizzava il file e creava una gerarchia della classe:

File: Calculator.cs
|
|--Class[0]: Calculator
    |
    |--Method[0]: Subtract
         |
         |--Line[0]: return a + b;
    |
    |--Method[1]: Add
         |
         |--Line[0]: return a +b;

(Con linee extra lì per le parentesi graffe ecc ...)

Quando controllo il mio codice (rendendo i metodi alfabetici) aggiorna la gerarchia sopra in modo che Sottrai diventi Metodo [1] e Aggiungi diventi Metodo [0].

Il secondo sviluppatore controlla il suo codice (che ovviamente il sistema di controllo del codice sorgente conosce era basato sull'originale) e nota la modifica alla prima riga in sottrazione. Ora, piuttosto che trovare quel numero riga per riga nel file complessivo, sa che può trovarlo in Calculator.cs / Calculator / Subtract / 0 e il fatto che il metodo abbia cambiato posizione non ha importanza, può comunque rendere il unisci lavoro.

Answer 1

Penso che Codice sorgente nel database è una potenziale risposta alla tua domanda. L'idea generale è che non si eseguono i file di versione, i blocchi di versione del codice. Il sistema di controllo delle versioni conosce il codice DOM e consente di eseguire query sul codice DOM per verificare funzioni, classi, what-have-you, per la modifica, la compilazione, ecc.

Poiché l'ordine dei metodi non ha necessariamente importanza, non vengono archiviati nel database con alcun ordine in mente. Quando dai un'occhiata alla classe, puoi specificare l'ordine che preferisci (alfabetico, pubblico / protetto / privato, ecc.). Le uniche modifiche che contano sono quelle come dove cambi + in - . Non avrai conflitti a causa del riordino dei metodi.

Sfortunatamente, SCID è ancora MOLTO giovane e non ci sono molti strumenti là fuori per questo. Tuttavia, si tratta di un'evoluzione piuttosto interessante nel modo in cui uno visualizza e modifica il codice.

Modifica: Ecco un altro riferimento per SCID

Answer 2

Il nostro approccio con Plastic SCM è ancora lungi dall'essere "completo", ma è già stato rilasciato e può aiutare in questo tipo di situazioni. Dai un'occhiata a Xmerge . Naturalmente, il feedback sarà più che benvenuto e garantirà alcune licenze gratuite ;-)