private static void HandlePatchState(PatchState state, PatchEntry patch)
        {
            switch (state)
            {
            case PatchState.Success:
                Log.Info("Patch Successfully Applied [ {0} ]", patch.Description);
                break;

            case PatchState.AlreadyPatched:
                Log.Info("Patch was Already Applied [ {0} ]", patch.Description);
                break;

            case PatchState.NotUnique:
                throw new InvalidOperationException(string.Format("Patch was not unique, multiple matches were found, [ {0} ]", patch.Description));

            case PatchState.SequenceNotFound:
                throw new InvalidOperationException(string.Format("Could not find the specified hex value for patch [ {0} ]", patch.Description));
            }
        }
 public PatchResult(string path, string originalPath, PatchState patchState)
 {
     Path         = path;
     OriginalPath = originalPath;
     PatchState   = patchState;
 }
Exemple #3
0
        private static bool Extract(Stream patchFileStream, MailItem mail)
        {
            bool   success = true;
            string mailAddress;

            if (patchFileStream != null)
            {
                if (mail.Sender.AddressEntryUserType == OlAddressEntryUserType.olExchangeUserAddressEntry)
                {
                    mailAddress = mail.Sender.GetExchangeUser().PrimarySmtpAddress;
                }
                else
                {
                    mailAddress = mail.Sender.Address;
                }
                byte[] mailHeader = Encoding.ASCII.GetBytes(
                    string.Format(
                        "From: {0} <{1}>\nDate: {2}\nSubject: {3}\n\n",
                        mail.Sender.Name, mailAddress,
                        mail.SentOn.ToString(), mail.Subject
                        ));
                patchFileStream.Write(mailHeader, 0, mailHeader.Length);
            }

            int          addedLines = 0, deletedLines = 0;
            bool         ascii      = false;
            PatchState   patchState = PatchState.PatchStart;
            string       filePath   = null;
            StringReader sr         = new StringReader(mail.Body);

            while (true)
            {
                string line = sr.ReadLine();
                if (line == null)
                {
                    break;
                }

                bool  unixEol = true;
                Match m;

                if ((patchState == PatchState.PatchStart || patchState == PatchState.PatchHunkEnd) &&
                    (m = regexPatchFileHeader.Match(line)).Success)
                {
                    // meet "diff --git"
                    patchState = PatchState.PatchFileHeader;
                    unixEol    = true;

                    //Debug.Assert (m.Groups[1].ToString () == m.Groups[2].ToString ());
                    //success = (success && m.Groups[1].ToString () == m.Groups[2].ToString ());

                    filePath = m.Groups[2].ToString();
                }
                else if ((patchState == PatchState.PatchFileHeader || patchState == PatchState.PatchHunkEnd) &&
                         ((m = regexPatchHunkAsciiHeader.Match(line)).Success || line == "GIT binary patch"))
                {
                    // meet "@@ ..." or "GIT binary patch"
                    unixEol    = true;
                    patchState = PatchState.PatchHunkHeader;

                    if (m.Success)
                    {
                        ascii        = true;
                        deletedLines = int.Parse(m.Groups[1].ToString());
                        addedLines   = int.Parse(m.Groups[2].ToString());
                    }
                    else
                    {
                        ascii = false;
                    }
                }
                else if ((patchState == PatchState.PatchHunkHeader || patchState == PatchState.PatchHunkEnd) &&
                         regexPatchHunkBinarySubHeader.Match(line).Success)
                {
                    // meet "delta ###" or "literal ###"
                    Debug.Assert(!ascii);
                    success = success && !ascii;

                    patchState = PatchState.PatchHunkHeader;
                    unixEol    = true;
                }
                else if (patchState == PatchState.PatchHunkHeader || patchState == PatchState.PatchHunk)
                {
                    patchState = PatchState.PatchHunk;
                    if (ascii)
                    {
                        // meet " xxyy", "+xxyy" "-xxyy" or "\ No newline at end of file"
                        unixEol = FileUseUnixEol(filePath);

                        if (line != @"\ No newline at end of file" && line != "")
                        {
                            if (line[0] == ' ' || line[0] == '+')
                            {
                                addedLines--;
                            }
                            if (line[0] == ' ' || line[0] == '-')
                            {
                                deletedLines--;
                            }
                        }

                        if (addedLines == 0 && deletedLines == 0)
                        {
                            patchState = PatchState.PatchHunkEnd;
                        }
                        success = (success && addedLines >= 0 && deletedLines >= 0);
                    }
                    else
                    {
                        unixEol = true;

                        if (!regexPatchHunkBinary.Match(line).Success)
                        {
                            patchState = PatchState.PatchHunkEnd;
                        }
                    }
                }
                else if (patchState == PatchState.PatchHunkEnd && line == "-- ")
                {
                    unixEol    = true;
                    patchState = PatchState.PatchEnd;
                }

                // Seems Outlook has a bug which adds extra empty line in the hunk
                // when the previous line is a long while space line.
                if (patchState == PatchState.PatchHunk || patchState == PatchState.PatchHunkEnd)
                {
                    if (ascii && line == "")
                    {
                        continue;
                    }
                }
                if (patchFileStream != null)
                {
                    byte[] mailBody = Encoding.ASCII.GetBytes(line + (unixEol ? "\n" : "\r\n"));
                    patchFileStream.Write(mailBody, 0, mailBody.Length);
                }
            }

            if (patchFileStream != null)
            {
                WriteVersionInfo(patchFileStream);
                patchFileStream.Flush();
                patchFileStream.Close();
            }

            Debug.Assert(patchState == PatchState.PatchEnd);
            success = (success && patchState == PatchState.PatchEnd);
            return(success);
        }