Convert braces to Right Hand Brace (Sad Brace) Right hand brace is a style of code bracketing in which curly braces and semicolons are all aligned to a single point on the right side of a a file.

Generally, this is considered bad practice, for several reasons.
The Challenge
Take a multiline string through any method, and convert it's brace style to Right Hand Brace.
For this challenge, you only need it to work on Java code, however, it should theoretically work on any code that uses Braces and Semicolons.
You must grab all {}; characters in a row, with any amount of whitespace between them. EG. }}, ; } }\n\t\t}, and line them up on the right side of the file through the use of whitespace.
for example:
a {
b;
{c

should become
a {
b ;{
c

Or, more abstractly, push any and all whitespace from the left of all {}; characters, to the right.
Indentation of lines should be otherwise preserved. Lines only containing whitespace after the movement of the {}; characters may optionally be removed.
For example:
a{
    b{
        c;
    }
}
d;

May become either
a        {
    b    {
        c;}}
d        ;

or
a        {
    b    {
        c;}}
    

d        ;

Pushed to the right refers to all the {}; characters being aligned to a point no shorter than the longest line. Any amount of space after that is acceptable.
So all the below is acceptable:
a {
bc;

a  {
bc ;

a   {
bc  ;

etc...
Lines in any code may contain {}; characters between other non-whitspace characters, the handling of this case isn't necessary, although if you're inclined, you should leave them in place. Lines may also not contain any {}; characters at all, and this should be handled correctly. As is shown below.
a {
b ;
c
d }

Because we don't want Code Review to see the horrible things we're doing, you need to make your code as small as possible.
Examples / Testcases
Generic Java
public class HelloWorld{
       public static void main(String[] args){
           System.out.println(&quot;Hello, World!&quot;);
       }
}

becomes...
public class HelloWorld                        {
    public static void main(String[] args)     {
        System.out.println(&quot;Hello, World!&quot;)    ;}}

The image itself
public class Permuter{
    private static void permute(int n, char[] a){
        if (n == 0){
            System.out.println(String.valueOf(a));
        }else{
            for (int i=0; i&lt;= n; i++){
                permute(n-1, a);
                swap(a, n % 2 == 0 ? i : 0, n);
            }
        }
    }
    private static void swap(char[] a, int i, int j){
        char saved = a[i];
        a[i] = a[j];
        a[j] = saved;
    }
}

becomes...
public class Permuter                                {
    private static void permute(int n, char[] a)     {
        if (n == 0)                                  {
            System.out.println(String.valueOf(a))    ;}
        else                                         {
            for (int i=0; i&lt;= n; i++)                {
                permute(n-1, a)                      ;
                swap(a, n % 2 == 0 ? i : 0, n)       ;}}}
    private static void swap(char[] a, int i, int j) {
        char saved = a[i]                            ;
        a[i] = a[j]                                  ;
        a[j] = saved                                 ;}}

Not so Perfectly Generic Python
For contrast
def Main():
    print(&quot;Hello, World!&quot;);

Main();

becomes...
def Main():
    print(&quot;Hello, World!&quot;)    ;
Main()                        ;

Notes

Standard Loopholes apply
Standard IO applies
This is code-golf, so shortest program in bytes wins!
I am not Liable for damages related to programming in Right Hand Brace style
Have Fun!

Edit Notes
I reworded the challenge details, Hopefully I didn't break anyone's view of the rules, I assure you it was unintentional. This should be a much more clear and less self-conflicting spec.
V + Bash utilities, 64 62 61 60 62 bytes

1 byte saved thanks to @DJMcMayhem for putting the ex commands together

:se ve=all|%!wc -L
y$uò/^ *&lt;93&gt;[{};]
xk$pòò/&lt;84&gt; {};][{};]«$
lDî^R0|p


^R is the character literal for &lt;C-r&gt; (0x12) and &lt;84&gt; is 0x84 and &lt;94&gt; is 0x94.

wc -L works on most *nix based systems, but not macOS. For macOS, you have to do gwc -L  after getting coreutils using brew, if you haven't already.

Try it online! (Java)

Try it online! (Python)

Try it online! (Java again)

This preserves all blank lines and does not handle tabs, only spaces.

Hexdump:

00000000: 3a73 6520 7665 3d61 6c6c 7c25 2177 6320  :se ve=all|%!wc 
00000010: 2d4c 0a79 2475 f22f 5e20 2a93 5b7b 7d3b  -L.y$u./^ *.[{};
00000020: 5d0a 786b 2470 f2f2 2f84 207b 7d3b 5d5b  ].xk$p../. {};][
00000030: 7b7d 3b5d ab24 0a6c 44ee 1230 7c70       {};].$.lD..0|p


Explanation

First we need to be able to move the cursor anywhere in the buffer, so we use 

:se ve=all|...


and we chain this with another ex command using |

We need to get the length of the longest line in the input. This can be done with the shell command wc -L.

       ...|%!wc -L


This overwrites the current buffer (containing the input) with the result of wc -L. It gives an output of something like:

            42


and the cursor lands on the 4 in 42. Then we copy this number by using y$: yank text from the cursor's position to the end of the line. This conveniently stores this number in register 0. But more on that later. The input is replaced with this number, so to revert back, we undo.

Now say the input looked somewhat like this:

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello, World!");
    }
}


we need to move the braces } from the end of the buffer to just after the println statement.

ò                  " recursively do this until a breaking error:
 /^ *&lt;93&gt;[{};]     "   this compressed regex becomes /^ *\zs[{};]
                   "   this finds any character from `{};` after leading spaces
                   "   the cursor then goes to the `{};`

x                  "   delete character
 k$                "   go to the end of the line above
   p               "   and paste
    ò


If the regex cannot be found, a breaking error happens and breaks out of the recursion caused by ò.

Now comes the main part of this program, move all braces and semi-colons and align them as stated in the question.

ò                  " starts recursion
 /&lt;84&gt; {};][{};]«$ "   compressed form of [^ {};][{};]\+$
                   "   finds a sequence of `{};`s at the end of the line with a non-`{};` char to preceding it
 l                 "   move the cursor 1 to the right (since we were on the non-`{};` char now)
  D                "   delete everything from this position to the end of line
                   "   the deleted text contains `{};`
   î               "   execute as normal commands:
    ^R0            "   contains what's in register `0`, ie the length of the longest line
       |           "   now go to the column specified by that number
        p          "   and paste the contents 
                   " implicit ending `ò`


Again, this recursion will be stopped by a breaking error caused when the regex could not be found in the buffer.

Edits


Used D instead of d$ (I don't even know why I missed that in the first place)
Compressed [^ (in the regex) to &lt;84&gt;
Fixed bug by using \zs (compressing it into &lt;93&gt;) and by removing the $ in $xk$pò
Removed useless newline
Changed regex to make submission compliant with new rules and gained 2 bytes