What I want to do is this

[SkybuckFlying]

(Yeah stack overflow is pretty anal lol, so I will explain here what I want to do in abstract terms).

There is this file let's called it Original.txt it contains three texts: ObjectA, ObjectB, ObjectC, like so:

ObjectA
<some text/story>

ObjectB
<some text/story>

ObjectC
<some txt/story>

Tree would look like:

 Original.txt

Now I think this file is to big so I want to split it up into three files ObjectA, ObjectB, ObjectC.

Tree now becomes

Original.txt ----> ObjectA.txt  ObjectB.txt  ObjectC.txt

Now original.txt is updated, Tree could look like:

Original.txt ----> ObjectA.txt  ObjectB.txt  ObjectC.txt       (UserA)
                 \----> Original.txt (updated)                             (UserB)

So UserA is using the "splitted files" branch.
So UserB is using the "original" branch and making updates to it (this is the master branch).

Now the changes from original.txt should be re-implemented in the splitted files so they can benefit from the changes to original.txt

I tried a couple of methods, but no success so far.

Now even if this would work somehow, and yes that would already be incredibly usefull.

There is a further complexity. To make matters worse the files should also be moved to a subfolder like so:

Original.txt ----> Original\ObjectA.txt  Original\ObjectB.txt  Original\ObjectC.txt       (UserA)
                 \----> Original.txt (updated)                             (UserB)

So that the usage of the subfolder name Original indicates where ObjectA, B,C came from... they came out of this file called original which is now basically turned into a subfolder, with it's contents split into three files.

And again the mission would be to update ObjectA, ObjectB and ObjectC with changes from original,txt as it is updated on the master branch.

Basically there could even be two repositories to work isolated from each other.

RepositoryA would work with original.txt only.
RepositoryB would work with the splitted files only and would "down stream"updates from the original repository.

Now to make it even more complex/desirable. It would also be very cool if RepositoryB can make additional updates to it's own files and still benefit from changes made in RepositoryA.

Such a script would be very handy for "non-cooperating" repositories.

Let's say UserA does not want to split Repository A and wants to keep working on a single big file.

While UserB wants to work on RepositoryB and wants to work with splitted files, but still benefit from UserA updates then this script would be worth GOLD to me ! ;) =D and maybe other people too.

If you could create some kind of script which can do this I would be very happy.

Now it can either work with repositories/streaming/pushing/pulling... but that has the disadventage of having to be online and using github protocols and such.

So an alternative is to simply work with two branches.

BranchA to mimic RepositoryA
BranchB to mimic RepositoryB

So then UserB simply "fetches remote repositoryA into BranchA" and happily continues working on his own BranchB incorporating changes from BranchA as he/she works through the updates/commits from BranchA or so.