Re: An automatically commit

[Mike Ayers]

Giohanna MEndez wrote:

>                                   /---Version 11
>                /---version 1-----/
>               /                  \
>              /                    \----Version 12
> version base /---version 2
>             \---version 3 ----- Version 31
>
> Each version has:
> version base
>    |-----include (inside some files .h)
>    |-----server (inside some files .c)
>    +-----client (inside some files .c)
>
> version 1
>    |-----include (inside same files as include in version base
>          and more files .h)
>    |-----server (inside same files as server in version base
>           and more files .c)
>    |-----client (inside same files as client in version base
>           and more files .c)
>    +-----communications (inside some files .c)
>
> version 2
>    |-----include (inside same files as include in version base
>           and more files .h -different from version 1)
>    |-----server (inside same files as server in version base
>           and more files .c -different from version 1)
>    +-----client (inside same files as client in version base
>           and more files .c -different from version 1)

<Snipped more of the same/>

> I made this logical structure in this way: first I create the version 
> base, then from the version base I made a checkout, then I modify it and 
> import it with the name version 1, I made the same procedure to create 
> version 2 and 3, It is important to say to each modification is 
> different between each version, to create the version 11, I made a 
> checkout from the version 1, then I modify it and import it with the 
> name version 11, I made the same to create version 12. To obtain version 
> 31: I made a checkout from the version 3, then I modify it and import it 
> with the name version 31.

        Didn't this seem more than a bit awkward? (see below)

> In this way, I had created modules for each version (at the same level 
> in my cvs repository), but what I want to do is: each time I made a 
> modification in program of the version 1, and I make a commit, the cvs 
> automatically makes a commit for the version 11 and 12. Other example: 
> if I made a commit for a modified program of the version base, cvs make 
> automatically a commit for the dependent versions from it (according to 
> my logical structure). This is my problem: how can I do it automatically?

        By not archiving multiple copies of the same file. (see below)

> what I am doing at the moment, that is by the way too expensive, it is:
> I make checkout of the version 1, then I modify it, then I made commit, 
> after that and manually I made a checkout of the version 11, then I made 
> the same modification and I made a commit, then I made a checkout of the 
> version 12, then I made the same modification and I made a commit

        This is not only too "expensive", it is too error prone.

> Somebody can help me to make this process more automatically?

	I shall try.  First, I must point out your fundamental problem: you 
are trying to solve a configuration problem with an archiving system. 
 This is why your solution is so awkward and error prone.  The thing 
to do is to treat this as a CM problem, and you're halfway home.

	Basically, instead of maintaining so many copies of the same files, 
you should maintain only one copy, and use a manifest and conversion 
script to translate the archive into your chosen directories.  This 
results in far less files to archive.  It also means that your 
"automatic commit" happens by default, although you will need to rerun 
your conversion script each time you commit.  That can be handled with 
a checkin script, if necessary.


        HTH,

/|/|ike