private static void DigestBuildItems(Project project, ProjectDigest projectDigest, string projectBasePath, ICollection<ProjectReference> projectReferences, ICollection<Reference> references, ICollection<Compile> compiles, ICollection<None> nones, ICollection<WebReferenceUrl> webReferenceUrls, ICollection<Content> contents, ICollection<Folder> folders, ICollection<WebReferences> webReferencesList, ICollection<EmbeddedResource> embeddedResources, ICollection<BootstrapperPackage> bootstrapperPackages, ICollection<string> globalNamespaceImports, IList<ComReference> comReferenceList)
        {
            string targetFramework = projectDigest.TargetFramework != null ? projectDigest.TargetFramework.Substring(0,3) : "2.0";
            RspUtility rsp = new RspUtility();
            foreach (BuildItemGroup buildItemGroup in project.ItemGroups)
            {
                foreach (BuildItem buildItem in buildItemGroup)
                {
                    if (!buildItem.IsImported)
                    {

                        switch (buildItem.Name)
                        {
                            case "ProjectReference":
                                ProjectReference prjRef = new ProjectReference(projectBasePath);
                                prjRef.ProjectPath = buildItem.Include;
                                prjRef.Name = GetProjectAssemblyName(Path.GetFullPath(prjRef.ProjectFullPath));
                                prjRef.RoleType = buildItem.GetMetadata("RoleType");
                                projectReferences.Add(prjRef);
                                break;
                            case "Reference":
                                // TODO: significant refactoring needed here - it should be calling the same resolution code that is in
                                //   AbstractPomConverter to find the right artifact based on the simple name

                                Reference reference = new Reference(projectBasePath);
                                //set processorArchitecture property to platform, it will be used by GacUtility in
                                // order to resolve artifact to right processor architecture
                                if (!string.IsNullOrEmpty(projectDigest.Platform))
                                {
                                    reference.ProcessorArchitecture = projectDigest.Platform;
                                }
                                string hintPath = buildItem.GetMetadata("HintPath");
                                if (!string.IsNullOrEmpty(hintPath))
                                {
                                    string fullHint = Path.Combine(projectBasePath, hintPath);
                                    if(File.Exists(fullHint))
                                        reference.HintPath = Path.GetFullPath(fullHint);
                                    else
                                        reference.HintPath = fullHint;
                                    SetReferenceFromFile(new FileInfo(fullHint), reference);
                                }
                                if ((string.IsNullOrEmpty(reference.HintPath) || !(new FileInfo(reference.HintPath).Exists)) && !rsp.IsRspIncluded(buildItem.Include, projectDigest.Language))
                                {
                                    if (buildItem.Include.Contains(","))
                                    {
                                        // complete name
                                        reference.SetAssemblyInfoValues(buildItem.Include);
                                    }
                                    else if (projectDigest.DependencySearchConfig.SearchGac && projectDigest.TargetFrameworkIdentifier != "Silverlight")
                                    {
                                        // simple name needs to be resolved
                                        List<string> refs = GacUtility.GetInstance().GetAssemblyInfo(buildItem.Include, null, null);
                                        if (refs.Count == 0)
                                        {
                                            log.Warn("Unable to find reference '" + buildItem.Include + "' in " + string.Join("; ", refs.ToArray()));
                                        }
                                        else if (refs.Count > 1)
                                        {
                                            string best = null;
                                            string bestFramework = "0.0";
                                            foreach (string s in refs)
                                            {
                                                try
                                                {
                                                    Assembly a = Assembly.ReflectionOnlyLoad(s);
                                                    string framework = a.ImageRuntimeVersion.Substring(1, 3);
                                                    if (framework.CompareTo(targetFramework) <= 0 && framework.CompareTo(bestFramework) > 0)
                                                    {
                                                        best = s;
                                                        bestFramework = framework;
                                                    }
                                                }
                                                catch (Exception e)
                                                {
                                                    // skip this assembly
                                                    log.Error("An error occurred loading assembly '" + s + "' - check that your PATH to gacutil matches your runtime environment: " + e.Message);
                                                }
                                            }
                                            reference.SetAssemblyInfoValues(best);
                                        }
                                        else
                                        {
                                            reference.SetAssemblyInfoValues(refs[0]);
                                        }
                                    }
                                    else
                                    {
                                        reference.Name = buildItem.Include;
                                    }
                                }
                                if ("NUnit.Framework".Equals(reference.Name, StringComparison.OrdinalIgnoreCase))
                                {
                                    reference.Name = "NUnit.Framework";
                                    projectDigest.UnitTest = true;
                                }
                                if (!string.IsNullOrEmpty(reference.Name))
                                {
                                    references.Add(reference);
                                }
                                break;
                            case "Compile":
                                Compile compile = new Compile(projectBasePath);
                                compile.IncludePath = buildItem.Include;
                                compile.AutoGen = buildItem.GetMetadata("AutoGen");
                                compile.DesignTimeSharedInput = buildItem.GetMetadata("DesignTimeSharedInput");
                                compile.DependentUpon = buildItem.GetMetadata("DependentUpon");
                                compile.DesignTime = buildItem.GetMetadata("DesignTime");
                                compile.SubType = buildItem.GetMetadata("SubType");
                                compiles.Add(compile);
                                break;
                            case "None":
                                None none = new None(projectBasePath);
                                none.IncludePath = buildItem.Include;

                                none.Link = buildItem.GetMetadata("Link");

                                none.Generator = buildItem.GetMetadata("Generator");
                                none.LastGenOutput = buildItem.GetMetadata("LastGenOutput");
                                none.DependentUpon = buildItem.GetMetadata("DependentUpon");

                                nones.Add(none);

                                //add included web reference when reimporting
                                if (buildItem.Include.Contains(".wsdl"))
                                {
                                    string path = Path.GetDirectoryName(buildItem.Include) + "\\";

                                    WebReferenceUrl webUrl = new WebReferenceUrl();
                                    webUrl.UrlBehavior = "Dynamic";
                                    webUrl.RelPath = path;

                                    if (!webRefExists(webUrl, webReferenceUrls))
                                    {
                                        webReferenceUrls.Add(webUrl);
                                    }

                                }
                                break;
                            case "WebReferenceUrl":
                                WebReferenceUrl web = new WebReferenceUrl();
                                web.UrlBehavior = buildItem.GetMetadata("UrlBehavior");
                                web.RelPath = buildItem.GetMetadata("RelPath");
                                web.UpdateFromURL = buildItem.GetMetadata("UpdateFromURL");
                                web.ServiceLocationURL = buildItem.GetMetadata("ServiceLocationURL");
                                web.CachedDynamicPropName = buildItem.GetMetadata("CachedDynamicPropName");
                                web.CachedAppSettingsObjectName = buildItem.GetMetadata("CachedAppSettingsObjectName");
                                web.CachedSettingsPropName = buildItem.GetMetadata("CachedSettingsPropName");

                                if (!webRefExists(web, webReferenceUrls))
                                {
                                    webReferenceUrls.Add(web);
                                }
                                break;
                            case "COMReference":
                                ComReference comRef = new ComReference();
                                comRef.Include = buildItem.Include;
                                comRef.Guid = buildItem.GetMetadata("Guid");
                                comRef.VersionMajor = buildItem.GetMetadata("VersionMajor");
                                comRef.VersionMinor = buildItem.GetMetadata("VersionMinor");
                                comRef.Lcid = buildItem.GetMetadata("Lcid");
                                comRef.Isolated = buildItem.GetMetadata("Isolated");
                                comRef.WrapperTool = buildItem.GetMetadata("WrapperTool");
                                comReferenceList.Add(comRef);
                                break;
                            case "Content":
                                Content content = new Content(projectBasePath);
                                content.IncludePath = buildItem.Include;
                                contents.Add(content);

                                //add web reference in <includes> tag of compile-plugin
                                if (content.IncludePath.Contains("Web References"))
                                {
                                    Compile compileWebRef = new Compile(projectBasePath);
                                    compileWebRef.IncludePath = buildItem.Include;
                                    compiles.Add(compileWebRef);
                                }
                                break;
                            case "Folder":
                                Folder folder = new Folder(projectBasePath);
                                folder.IncludePath = buildItem.Include;
                                folders.Add(folder);
                                break;
                            case "WebReferences":
                                WebReferences webReferences = new WebReferences(projectBasePath);
                                webReferences.IncludePath = buildItem.Include;
                                webReferencesList.Add(webReferences);
                                break;
                            case "EmbeddedResource":
                                EmbeddedResource embeddedResource = new EmbeddedResource(projectBasePath);
                                embeddedResource.IncludePath = buildItem.Include;

                                embeddedResource.DependentUpon = buildItem.GetMetadata("DependentUpon");
                                embeddedResource.SubType = buildItem.GetMetadata("SubType");
                                embeddedResource.Generator = buildItem.GetMetadata("Generator");
                                embeddedResource.LastGenOutput = buildItem.GetMetadata("LastGenOutput");
                                embeddedResource.WithCulture = buildItem.GetMetadata("WithCulture");
                                if (string.IsNullOrEmpty(embeddedResource.WithCulture))
                                {
                                    embeddedResource.WithCulture = MSBuildUtils.DetermineResourceCulture(buildItem.Include);
                                }

                                embeddedResources.Add(embeddedResource);
                                break;
                            case "BootstrapperPackage":
                                BootstrapperPackage bootstrapperPackage = new BootstrapperPackage(projectBasePath);
                                bootstrapperPackage.IncludePath = buildItem.Include;
                                bootstrapperPackage.Visible = buildItem.GetMetadata("Visible");
                                bootstrapperPackage.ProductName = buildItem.GetMetadata("ProductName");
                                bootstrapperPackage.Install = buildItem.GetMetadata("Install");

                                bootstrapperPackages.Add(bootstrapperPackage);
                                break;
                            case "Import":
                                globalNamespaceImports.Add(buildItem.Include);
                                break;
                            case "BaseApplicationManifest":
                                projectDigest.BaseApplicationManifest = buildItem.Include;
                                break;
                           default:
                                log.Debug("Unhandled ItemGroup: " + buildItem.Name);
                                break;
                        }
                    }
                }
            }
        }
        public AbstractPomConverter(ProjectDigest projectDigest, string mainPomFile, NPanday.Model.Pom.Model parent, string groupId)
        {
            artifactContext = new ArtifactContext();
            this.projectDigest = projectDigest;
            this.mainPomFile = mainPomFile;
            this.parent = parent;
            this.groupId = FilterID(groupId);
            this.version = parent != null ? parent.version : null;

            this.rspUtil = new RspUtility();
            this.model = new NPanday.Model.Pom.Model();

            // Add build Tag
            this.model.build = new NPanday.Model.Pom.Build();

            this.missingReferences = new List<Reference>();
            this.nonPortableReferences = new List<string>();

            // TODO: this is a hack because of bad design. The things that talk to the local repository should be pulled out of here, and able to be stubbed/mocked instead
            if (testingArtifacts != null)
            {
                this.localArtifacts = testingArtifacts;
            }
        }