public static void WriteFile(object rootObject, ParsedPath xnbFile)
 {
     using (FileStream fileStream = new FileStream(xnbFile, FileMode.Create))
     {
         new XnbFileWriterV5(fileStream).Write(rootObject);
     }
 }
        public static PinboardFileV1 Load(ParsedPath pinboardFileName)
        {
            PinboardFileV1 data = null;

            if (pinboardFiles == null)
                pinboardFiles = new Dictionary<ParsedPath, PinboardFileV1>();

            if (pinboardFiles.TryGetValue(pinboardFileName, out data))
            {
                return data;
            }

            try
            {
                data = PinboardFileReaderV1.ReadFile(pinboardFileName);
            }
            catch
            {
                throw new ContentFileException("Unable to read pinboard file '{0}'".CultureFormat(pinboardFileName));
            }

            pinboardFiles.Add(pinboardFileName, data);

            return data;
        }
 public static PinboardFileV1 ReadFile(ParsedPath contentFile)
 {
     using (XmlReader reader = XmlReader.Create(contentFile))
     {
         return new PinboardFileReaderV1(reader).ReadPinboardXml();
     }
 }
        /// <summary>
        /// See <see cref="DirectoryInfoUtility.GetFiles(string, SearchScope)"/>.
        /// </summary>
        /// <param name="fileSpec"></param>
        /// <param name="scope"></param>
        /// <returns></returns>
        public static IList<ParsedPath> GetFiles(ParsedPath fileSpec, SearchScope scope)
        {
            IList<FileInfo> fileInfos = DirectoryInfoUtility.GetFiles(fileSpec, scope);

            ParsedPath[] files = new ParsedPath[fileInfos.Count];

            for (int i = 0; i < fileInfos.Count; i++)
                files[i] = new ParsedPath(fileInfos[i].FullName, PathType.File);

            return files;
        }
        /// <summary>
        /// See <see cref="DirectoryInfoUtility.GetDirectories(string, SearchScope)"/>
        /// </summary>
        /// <param name="dirSpec"></param>
        /// <param name="scope"></param>
        /// <returns></returns>
        public static IList<ParsedPath> GetDirectories(ParsedPath dirSpec, SearchScope scope)
        {
            IList<DirectoryInfo> dirInfos = DirectoryInfoUtility.GetDirectories(dirSpec, scope);

            ParsedPath[] dirs = new ParsedPath[dirInfos.Count];

            for (int i = 0; i < dirInfos.Count; i++)
                dirs[i] = new ParsedPath(dirInfos[i].FullName, PathType.Directory);

            return dirs;
        }
        private static void RecursiveGetParentDirectories(ParsedPath rootPath, ref List<DirectoryInfo> dirs)
        {
            DirectoryInfo dirInfo = new DirectoryInfo(rootPath.VolumeAndDirectory);
            DirectoryInfo [] dirInfos = dirInfo.GetDirectories(rootPath.FileAndExtension);

            dirs.AddRange(dirInfos);

            if (!rootPath.IsRootDirectory)
            {
                RecursiveGetParentDirectories(rootPath.MakeParentPath(), ref dirs);
            }
        }
Beispiel #7
0
        static ToolPaths()
        {
            try
            {
            #if WINDOWS
                RegistryKey key = Registry.ClassesRoot.OpenSubKey(@"svgfile\shell\Inkscape\command", false);

                if (key != null)
                {
                    string s = (string)key.GetValue("");

                    if (s != null && s.Length > 0)
                    {
                        if (s[0] == '"')
                            s = s.Substring(1, s.IndexOf('"', 1) - 1);

                        ParsedPath path  = new ParsedPath(s, PathType.File).WithExtension(".com");

                        if (File.Exists(path))
                            Inkscape = path;
                    }
                }

                key = Registry.ClassesRoot.OpenSubKey(@"svgfile\shell\Edit with GIMP\command", false);

                if (key != null)
                {
                    string s = (string)key.GetValue("");

                    if (s != null && s.Length > 0)
                    {
                        if (s[0] == '"')
                            s = s.Substring(1, s.IndexOf('"', 1) - 1);

                        ParsedPath path = new ParsedPath(s, PathType.File).WithFileAndExtension("rsvg-convert.exe");

                        if (File.Exists(path))
                            RSvgConvert = path;
                    }
                }
            #elif OSX
                ParsedPath path = new ParsedPath("/Applications/Inkscape.app/Contents/Resources/bin/inkscape", PathType.File);

                if (File.Exists(path))
                    Inkscape = path;
            #else
                throw new NotImplementedException();
            #endif
            }
            catch
            {
            }
        }
Beispiel #8
0
        private SlnDocument(ParsedPath filePath, string content)
        {
            projects = new List<SlnProject>();
            globalSections = new List<SlnGlobalSection>();
            solutionConfigs = new List<SlnConfiguration>();
            projectConfigs = new List<SlnProjectConfiguration>();

            Regex slnProjectRegex = new Regex("Project\\(\"(?'type'{.*?})\"\\) = \"(?'name'.*?)\", \"(?'path'.*?)\", \"(?'guid'{.*?})\"[\\t\\r ]*\\n(?'content'(.*\\n)*?)EndProject[\\t\\r ]*\\n",
                RegexOptions.Multiline | RegexOptions.ExplicitCapture);
            MatchCollection matches = slnProjectRegex.Matches(content);

            foreach (Match match in matches)
            {
                this.projects.Add(new SlnProject
                {
                    TypeGuid = match.Groups["type"].Value,
                    Name = match.Groups["name"].Value,
                    Path = new ParsedFilePath(match.Groups["path"].Value).MakeFullPath(filePath),
                    ProjectGuid = match.Groups["guid"].Value,
                    Content = match.Groups["content"].Value
                });
            }

            Regex slnGlobalSectionRegex = new Regex("[\\t ]*GlobalSection\\((?'name'.*?)\\) = (?'order'(pre|post)Solution)[\\t\\r ]*\\n(?'content'([\\t ]*.*[\\t ]*\\n)+?)[\\t ]*EndGlobalSection[\\t\\r ]*\\n",
                RegexOptions.Multiline | RegexOptions.ExplicitCapture);

            matches = slnGlobalSectionRegex.Matches(content);

            foreach (Match match in matches)
            {
                var name = match.Groups["name"].Value;
                var groupContent = match.Groups["content"].Value;

                if (name == "SolutionConfigurationPlatforms")
                {
                    ParseSolutionConfigurationPlatforms(groupContent);
                }
                else if (name == "ProjectConfigurationPlatforms")
                {
                    ParseProjectConfigurationPlatforms(groupContent);
                }
                else
                {
                    this.globalSections.Add(new SlnGlobalSection
                    {
                        Name = name,
                        Order = match.Groups["order"].Value,
                        Content = groupContent
                    });
                }
            }
        }
Beispiel #9
0
        public static PngFile ReadFile(ParsedPath pngFileName)
        {
            PngFile pngFile = new PngFile();

            ImageSurface image = new ImageSurface(pngFileName);

            if (image.Format != Format.ARGB32)
                throw new NotSupportedException("Only PNG's in ARGB32 format currently supported");

            pngFile.Width = image.Width;
            pngFile.Height = image.Height;
            pngFile.RgbaData = GetRgbaData(image);

            return pngFile;
        }
Beispiel #10
0
 public static void AssertBadPath(
     string path, 
     PathType type)
 {
     try
     {
         ParsedPath pp = new ParsedPath(path, type);
         Assert.IsNotNull(pp);
         Assert.Fail("Badly formed path not caught");
     }
     catch (Exception e)
     {
         Assert.IsTrue(e is ArgumentException);
     }
 }
 public static ContentFileV2 ReadFile(ParsedPath contentFile)
 {
     using (XmlReader reader = XmlReader.Create(contentFile))
     {
         try
         {
             return new ContentFileReaderV2(reader).ReadContentElement();
         }
         catch (Exception e)
         {
             e.Data["LineNumber"] = ((IXmlLineInfo)reader).LineNumber;
             throw;
         }
     }
 }
Beispiel #12
0
        public static void AssertParentPath(
            string path,
            int level,
            string machine,
            string share,
            string drive,
            string directory,
            string file,
            string extension)
        {
            ParsedPath pp;

            // Test out specific entry points based on the values passed in
            if (level < -1)
            {
                pp = new ParsedPath(path, PathType.Unknown).MakeParentPath(level);

                if (pp == null)
                {
                    Assert.IsNull(directory, "Expected result was not null");
                    return;
                }
            }
            else
            {
                pp = new ParsedPath(path, PathType.Unknown).MakeParentPath();

                if (pp == null)
                {
                    Assert.IsNull(directory, "Expected result was not null");
                    return;
                }
            }

            #if MACOS
            // We have to compare to OS specific paths
            machine = machine.Replace(@"\", "/");
            share = share.Replace(@"\", "/");
            directory = directory.Replace(@"\", "/");
            #endif

            Assert.AreEqual(machine, pp.Machine.ToString());
            Assert.AreEqual(share, pp.Share.ToString());
            Assert.AreEqual(drive, pp.Drive.ToString());
            Assert.AreEqual(directory, pp.Directory.ToString());
            Assert.AreEqual(file, pp.File.ToString());
            Assert.AreEqual(extension, pp.Extension.ToString());
        }
 public static StringsFileV1 ReadFile(ParsedPath fileName)
 {
     using (XmlReader reader = XmlReader.Create(fileName))
     {
         try
         {
             return new StringsFileReaderV1(reader).ReadStringsElement();
         }
         catch (Exception e)
         {
             e.Data["ContentFile"] = fileName;
             e.Data["LineNumber"] = ((IXmlLineInfo)reader).LineNumber;
             throw;
         }
     }
 }
Beispiel #14
0
 public static void AssertBadPathFull(
     string path, 
     string baseDir)
 {
     try
     {
         ParsedPath pp = new ParsedPath(path, PathType.Unknown).MakeFullPath(
             baseDir == null ? null : new ParsedPath(baseDir, PathType.Directory));
         Assert.IsNotNull(pp);
         Assert.Fail("Badly formed path not caught");
     }
     catch (Exception e)
     {
         Assert.IsTrue(e is ArgumentException);
     }
 }
Beispiel #15
0
        private void ProcessDirectory(ParsedPath dir)
        {
            var files = DirectoryUtility.GetFiles(dir, SearchScope.DirectoryOnly);

            foreach (var file in files)
            {
                if (file.Extension == ".cs")
                    ScanFile(file);
            }

            var dirs = DirectoryUtility.GetDirectories(dir, SearchScope.DirectoryOnly);

            foreach (var subDir in dirs)
            {
                ProcessDirectory(subDir);
            }
        }
        public static void CombinePngs(List<ImagePlacement> placements, ParsedPath pngPath)
        {
            try
            {
                int w = 0;
                int h = 0;

                foreach (var placement in placements)
                {
                    int wt = (int)placement.TargetRectangle.Width;
                    int ht = (int)placement.TargetRectangle.Height;

                    if (wt > w)
                        w = wt;

                    if (ht > h)
                        h = ht;
                }

                using (ImageSurface combinedImage = new ImageSurface(Format.Argb32, w, h))
                {
                    using (Cairo.Context g = new Cairo.Context(combinedImage))
                    {
                        foreach (var placement in placements)
                        {
                            using (ImageSurface image = new ImageSurface(placement.ImageFile))
                            {
                                int x = (int)placement.TargetRectangle.X;
                                int y = (int)placement.TargetRectangle.Y;

                                g.SetSourceSurface(image, x, y);
                                g.Paint();
                            }
                        }
                    }

                    combinedImage.WriteToPng(pngPath);
                }
            }
            catch (Exception e)
            {
                throw new ArgumentException("Unable to combine images into file '{0}'".CultureFormat(pngPath), e);
            }
        }
        private CsprojDocument(ParsedPath csprojPath, string content)
        {
            refs = new List<CsprojReference>();
            projRefs = new List<CsprojProjectReference>();

            this.xdoc = XDocument.Parse(content);

            XElement firstItemGroup;
            var refElems = GetElements(ns + "Reference", out firstItemGroup);

            this.refItemGroup = firstItemGroup;

            foreach (var refElem in refElems)
            {
                var hintPath = refElem.Element(ns + "HintPath");

                refs.Add(new CsprojReference
                {
                    Name = refElem.Attribute("Include").Value,
                    HintPath = (hintPath != null ? new ParsedPath(hintPath.Value, PathType.File).MakeFullPath(csprojPath) : null)
                });
            }

            refElems.Remove();

            var projRefElems = GetElements(ns + "ProjectReference", out firstItemGroup);

            this.projRefItemGroup = firstItemGroup;

            foreach (var projRefElem in xdoc.Descendants(ns + "ProjectReference"))
            {
                projRefs.Add(new CsprojProjectReference
                {
                    Include = new ParsedPath(projRefElem.Attribute("Include").Value, PathType.File).MakeFullPath(csprojPath),
                    Guid = projRefElem.Element(ns + "Project").Value,
                    Name = projRefElem.Element(ns + "Name").Value
                });
            }

            projRefElems.Remove();

            this.projectGuid = xdoc.Descendants(ns + "ProjectGuid").First().Value;
        }
        /// <summary>
        /// Returns a list of files given a file search pattern.  Will also search sub-directories.
        /// </summary>
        /// <param name="searchPattern">Search pattern.  Can include a full or partial path and standard wildcards for the file name.</param>
        /// <param name="scope">The scope of the search.</param>
        /// <param name="baseDir">Base directory to use for partially qualified paths</param>
        /// <returns>An array of <c>FileInfo</c> objects for files matching the search pattern. </returns>
        public static IList<FileInfo> GetFiles(ParsedPath fileSpec, SearchScope scope)
        {
            ParsedPath rootPath = fileSpec.MakeFullPath();

            if (scope != SearchScope.DirectoryOnly)
            {
                List<FileInfo> files = new List<FileInfo>();

                if (scope == SearchScope.RecurseParentDirectories)
                    RecursiveGetParentFiles(rootPath, ref files);
                else
                    RecursiveGetSubFiles(rootPath, (scope == SearchScope.RecurseSubDirectoriesBreadthFirst), ref files);

                return files.ToArray();
            }
            else
            {
                return NonRecursiveGetFiles(rootPath);
            }
        }
Beispiel #19
0
        public static void AssertBadParentPath(
            string path,
            int level)
        {
            try
            {
                ParsedPath pp;

                if (level <= -1 || level > 0)
                    pp = new ParsedPath(path, PathType.Unknown).MakeParentPath(level);
                else
                    pp = new ParsedPath(path, PathType.Unknown).MakeParentPath();

                Assert.IsNotNull(pp);
                Assert.Fail("Get parent succeeded and should have failed");
            }
            catch (Exception e)
            {
                Assert.IsTrue(e is ArgumentException || e is InvalidOperationException);
            }
        }
        /// <summary>
        /// Returns a list of directories given a file search pattern.  Will also search sub-directories and 
        /// parent directories.
        /// </summary>
        /// <param name="dirSpec">Search specification with with optional directory and wildcards</param>
        /// <param name="scope">The scope of the search. <see cref="SearchScope"/></param>
        /// <returns>An array of <c>DirectoryInfo</c> objects for files matching the search pattern. </returns>
        public static IList<DirectoryInfo> GetDirectories(ParsedPath dirSpec, SearchScope scope)
        {
            if (!dirSpec.HasFilename)
                throw new ArgumentException("Path does not have a filename");

            ParsedPath rootPath = dirSpec.MakeFullPath();

            if (scope != SearchScope.DirectoryOnly)
            {
                List<DirectoryInfo> dirs = new List<DirectoryInfo>();

                if (scope == SearchScope.RecurseParentDirectories)
                    RecursiveGetParentDirectories(rootPath, ref dirs);
                else
                    RecursiveGetSubDirectories(rootPath, (scope == SearchScope.RecurseSubDirectoriesBreadthFirst), ref dirs);

                return dirs.ToArray();
            }
            else
            {
                return NonRecursiveGetDirectories(rootPath);
            }
        }
Beispiel #21
0
 private void AssertPathPartsRelative(
     string path,
     string basePath,
     string directory)
 {
     ParsedPath pp = new ParsedPath(path, PathType.Unknown).MakeRelativePath(new ParsedPath(basePath, PathType.Unknown));
     Assert.AreEqual(directory, pp.Directory);
 }
Beispiel #22
0
        public void Save(ParsedPath fileName)
        {
            using (var writer = new StreamWriter(fileName))
            {
                writer.Write("\r\nMicrosoft Visual Studio Solution File, Format Version 12.00\r\n");
                writer.Write("# Visual Studio 2012\r\n");

                foreach (var project in this.projects)
                {
                    var projectPath = project.Path.MakeRelativePath(fileName).ToString("\\");
                    var prefix = ".\\";

                    if (projectPath.StartsWith(prefix))
                        projectPath = projectPath.Substring(prefix.Length);

                    writer.Write("Project(\"{0}\") = \"{1}\", \"{2}\", \"{3}\"\r\n{4}EndProject\r\n",
                        project.TypeGuid, project.Name,
                        projectPath,
                        project.ProjectGuid, project.Content);
                }

                writer.Write("Global\r\n");

                writer.Write("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n");
                foreach (var solutionConfig in this.solutionConfigs)
                {
                    writer.Write("\t\t{0}|{1} = {0}|{1}\r\n", solutionConfig.Configuration, solutionConfig.Platform);
                }
                writer.Write("\tEndGlobalSection\r\n");

                writer.Write("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n");
                foreach (var projectConfig in this.projectConfigs)
                {
                    writer.Write("\t\t{0}.{1}|{2}.ActiveCfg = {3}|{4}\r\n",
                        projectConfig.Guid,
                        projectConfig.SolutionConfiguration.Configuration,
                        projectConfig.SolutionConfiguration.Platform,
                        projectConfig.ProjectConfiguration.Configuration,
                        projectConfig.ProjectConfiguration.Platform);
                    writer.Write("\t\t{0}.{1}|{2}.Build.0 = {3}|{4}\r\n",
                        projectConfig.Guid,
                        projectConfig.SolutionConfiguration.Configuration,
                        projectConfig.SolutionConfiguration.Platform,
                        projectConfig.ProjectConfiguration.Configuration,
                        projectConfig.ProjectConfiguration.Platform);
                }
                writer.Write("\tEndGlobalSection\r\n");

                foreach (var globalSection in this.globalSections)
                {
                    writer.Write("\tGlobalSection({0}) = {1}\r\n", globalSection.Name, globalSection.Order);
                    writer.Write(globalSection.Content);
                    writer.Write("\tEndGlobalSection\r\n");
                }

                writer.Write("EndGlobal\r\n");
            }
        }
Beispiel #23
0
 public static SlnDocument Parse(ParsedPath filePath)
 {
     return new SlnDocument(filePath, File.ReadAllText(filePath));
 }
 public ImagePlacement(ParsedPath pngPath, Cairo.Rectangle targetRectangle)
 {
     this.ImageFile = pngPath;
     this.TargetRectangle = targetRectangle;
 }
        public static void RotatePng(ParsedPath pngPath, ImageRotation rotation)
        {
            if (rotation == ImageRotation.None)
                return;

            using (ImageSurface originalImage = new ImageSurface(pngPath))
            {
                int w;
                int h;

                if (rotation == ImageRotation.Left || rotation == ImageRotation.Right)
                {
                    w = originalImage.Height;
                    h = originalImage.Width;
                }
                else
                {
                    w = originalImage.Width;
                    h = originalImage.Height;
                }

                double[] rotationRadians = {0, -Math.PI / 2, Math.PI / 2, Math.PI };

                using (ImageSurface rotatedImage = new ImageSurface(Format.Argb32, w, h))
                {
                    using (Cairo.Context g = new Cairo.Context(rotatedImage))
                    {
                        g.Translate(rotatedImage.Width / 2.0, rotatedImage.Height / 2.0);
                        g.Rotate(rotationRadians[(int)rotation]);
                        g.Translate(-originalImage.Width / 2.0, -originalImage.Height / 2.0);

                        g.SetSourceSurface(originalImage, 0, 0);
                        g.Paint();
                    }

                    rotatedImage.WriteToPng(pngPath);
                }
            }
        }
        public static void CompressPngToTexture2DContent(
			ParsedPath pngFileName, 
			string compressionType, 
			out Texture2DContent textureContent)
        {
            PngFile pngFile = PngFileReader.ReadFile(pngFileName);

            SquishMethod? squishMethod = null;
            SurfaceFormat surfaceFormat = SurfaceFormat.Color;

            switch (compressionType.ToLower())
            {
            case "dxt1":
                squishMethod = SquishMethod.Dxt1;
                surfaceFormat = SurfaceFormat.Dxt1;
                break;
            case "dxt3":
                squishMethod = SquishMethod.Dxt3;
                surfaceFormat = SurfaceFormat.Dxt3;
                break;
            case "dxt5":
                squishMethod = SquishMethod.Dxt5;
                surfaceFormat = SurfaceFormat.Dxt5;
                break;
            default:
            case "none":
                surfaceFormat = SurfaceFormat.Color;
                break;
            }

            BitmapContent bitmapContent;

            if (surfaceFormat != SurfaceFormat.Color)
            {
                byte[] rgbaData = Squish.CompressImage(
                    pngFile.RgbaData, pngFile.Width, pngFile.Height,
                    squishMethod.Value, SquishFit.IterativeCluster, SquishMetric.Default, SquishExtra.None);

                bitmapContent = new BitmapContent(surfaceFormat, pngFile.Width, pngFile.Height, rgbaData);
            }
            else
            {
                bitmapContent = new BitmapContent(SurfaceFormat.Color, pngFile.Width, pngFile.Height, pngFile.RgbaData);
            }

            textureContent = new Texture2DContent(bitmapContent);
        }
Beispiel #27
0
        public void MakeFullPath()
        {
            // Test some good paths
            AssertPathPartsFull(@".txt",
                @"c:\temp\", "", "", @"c:", @"\temp\", "", ".txt");
            AssertPathPartsFull(@"c:\test\..\temp\??.txt",
                null, "", "", @"c:", @"\temp\", @"??", @".txt");
            AssertPathPartsFull(@"\test\..\temp\abc.txt",
                @"c:\a\b\", "", "", "c:", @"\temp\", @"abc", @".txt");
            AssertPathPartsFull(@"test\..\temp\abc.txt",
                @"c:\a\b\", "", "", @"c:", @"\a\b\temp\", @"abc", @".txt");
            AssertPathPartsFull(@".\test\....\temp\abc.txt",
                @"c:\a\b\c\", "", "", "c:", @"\a\temp\", @"abc", @".txt");
            AssertPathPartsFull(@"...\test\abc.txt",
                @"c:\a\b\c\", "", "", "c:", @"\a\test\", @"abc", @".txt");
            AssertPathPartsFull(@"C:\temp\..yes...this...is.a..legal.file.name....\and...\so...\...is\.this.\blah.txt",
                null, "", "", @"C:",
                @"\temp\..yes...this...is.a..legal.file.name\and\so\...is\.this\",
                @"blah", @".txt");

            // Test that using the current directory works
            ParsedPath pp = new ParsedPath(Environment.CurrentDirectory, PathType.Directory);
            AssertPathPartsFull(@"test.txt", null, pp.Machine, pp.Share, pp.Drive, pp.Directory, "test", ".txt");

            // Test some bad paths
            AssertBadPathFull(@"c:\test\..\..\temp\abc.txt", null);  // Too many '..'s
            AssertBadPathFull(@"test\......\temp\.\abc.txt", @"c:\");  // Too many '....'s
        }
Beispiel #28
0
        private ParsedPath FindNugetLibrary(ParsedPath slnPath, ParsedPath csprojPath)
        {
            var projectName = ProjectName;
            var packagesConfigPath = csprojPath.WithFileAndExtension("packages.config");

            if (!File.Exists(packagesConfigPath))
                throw new PopperToolExeception("Cannot find '{0}'".InvariantFormat(packagesConfigPath));

            var doc = XDocument.Parse(File.ReadAllText(packagesConfigPath));
            var element = doc.Root.Elements("package").Where(e => e.Attribute("id").Value == projectName).FirstOrDefault();

            if (element == null)
                throw new PopperToolExeception("Cannot find project '{0}' in '{1}'".InvariantFormat(projectName, packagesConfigPath));

            var s = "packages/{0}.{1}/lib/{2}/{0}.dll".InvariantFormat(
                projectName, element.Attribute("version").Value, element.Attribute("targetFramework").Value);

            return slnPath.VolumeAndDirectory.Append(s , PathType.File);
        }
Beispiel #29
0
        private ParsedPath GetSlnForProject(ParsedPath csprojPath)
        {
            var files = DirectoryUtility.GetFiles(csprojPath.WithFileAndExtension("*.sln"), SearchScope.RecurseParentDirectories);

            if (files.Count == 0)
                throw new PopperToolExeception("Cannot find .sln for project '{0}'".InvariantFormat(csprojPath));

            return files[0];
        }
Beispiel #30
0
        private void AssertPathPartsFull(
            string path,
            string baseDir,
            string machine,
            string share,
            string drive,
            string directory,
            string file,
            string extension)
        {
            ParsedPath pp;

            if (baseDir != null)
                pp = new ParsedPath(path, PathType.Unknown).MakeFullPath(new ParsedPath(baseDir, PathType.Directory));
            else
                pp = new ParsedPath(path, PathType.Unknown).MakeFullPath();

            Assert.AreEqual(machine, pp.Machine);
            Assert.AreEqual(share, pp.Share);
            Assert.AreEqual(drive, pp.Drive);
            Assert.AreEqual(directory, pp.Directory);
            Assert.AreEqual(file, pp.File);
            Assert.AreEqual(extension, pp.Extension);
        }