protected override void Merge(IProjectItem newProjectItem, bool overwrite)
        {
            base.Merge(newProjectItem, overwrite);

            var newItemBase = newProjectItem as DatabaseProjectItem;
            Assert.Cast(newItemBase, nameof(newItemBase));

            if (overwrite)
            {
                ItemNameProperty.SetValue(newItemBase.ItemNameProperty);

                ItemIdOrPath = newItemBase.ItemIdOrPath;
                DatabaseName = newItemBase.DatabaseName;
            }

            if (!string.IsNullOrEmpty(newItemBase.DatabaseName))
            {
                DatabaseName = newItemBase.DatabaseName;
            }

            if (!string.IsNullOrEmpty(newItemBase.Icon))
            {
                IconProperty.SetValue(newItemBase.IconProperty, SetValueOptions.DisableUpdates);
            }

            IsEmittable = IsEmittable || newItemBase.IsEmittable;
            IsImport = IsImport || newItemBase.IsImport;

            References.AddRange(newItemBase.References);
        }

        public override void Compile(ICompileContext context, IProjectItem projectItem)
        {
            var include = context.Configuration.GetString(Constants.Configuration.BuildProjectCompileBinFilesInclude);
            if (string.IsNullOrEmpty(include))
            {
                return;
            }

            var binFile = projectItem as BinFile;
            Assert.Cast(binFile, nameof(binFile));

            var exclude = context.Configuration.GetString(Constants.Configuration.BuildProjectCompileBinFilesExclude);

            var pathMatcher = new PathMatcher(include, exclude);
            if (!pathMatcher.IsMatch(binFile.FilePath))
            {
                return;
            }

            try
            {
                var assembly = Assembly.LoadFrom(binFile.Snapshots.First().SourceFile.AbsoluteFileName);

                foreach (var type in assembly.GetExportedTypes())
                {
                    context.Pipelines.Resolve<BinFileCompilerPipeline>().Execute(context, binFile, type);
                }
            }
            catch (Exception ex)
            {
                context.Trace.TraceError(Msg.C1059, ex.Message, binFile.FilePath);
            }
        }

        public override void Compile(ICompileContext context, IProjectItem projectItem)
        {
            var rendering = projectItem as Rendering;
            if (rendering == null)
            {
                return;
            }

            var project = rendering.Project;
            var snapshot = rendering.Snapshots.First();
            var snapshotTextNode = new SnapshotTextNode(snapshot);
            var guid = StringHelper.GetGuid(project, rendering.ItemPath);
            var item = context.Factory.Item(project, snapshotTextNode, guid, rendering.DatabaseName, rendering.ItemName, rendering.ItemPath, rendering.TemplateIdOrPath);
            item.ItemNameProperty.AddSourceTextNode(new FileNameTextNode(rendering.ItemName, snapshot));
            item.OverwriteWhenMerging = true;

            var field = context.Factory.Field(item, snapshotTextNode, "Path", rendering.FilePath);
            field.ValueProperty.Flags = SourcePropertyFlags.IsFileName;
            item.Fields.Add(field);
            item.References.Add(new FileReference(item, field.ValueProperty));

            if (rendering.Placeholders.Any())
            {
                var placeholdersField = context.Factory.Field(item, TextNode.Empty, "Place Holders", string.Join(",", rendering.Placeholders));
                item.Fields.Add(placeholdersField);
            }

            var addedItem = rendering.Project.AddOrMerge(item);
            rendering.RenderingItemUri = addedItem.Uri;
        }

 public FolderModel(IProjectItem parent, string name)
 {
     Parent = parent;
     Name = name;
     RelativePath = Path.Combine(parent.RelativePath, name) + "/";
     Children = new List<IProjectItem>();
 }

        public override void Emit(IEmitContext context, IProjectItem projectItem)
        {
            var unicornFile = projectItem as UnicornFile;
            Assert.Cast(unicornFile, nameof(unicornFile));

            var snapshot = unicornFile.Snapshots.First();

            // todo: use real Unicorn configuration instead of hacking it
            var log = new TraceLogger(context.Trace);
            var logger = new DefaultDeserializerLogger(log);
            var fieldFilter = new AllFieldFilter();
            var defaultDeserializer = new DefaultDeserializer(logger, fieldFilter);

            // todo: file has already been read and parsed - do not read it again
            var formatter = new YamlSerializationFormatter(null, null);
            using (var stream = new FileStream(snapshot.SourceFile.AbsoluteFileName, FileMode.Open))
            {
                var serializedItem = formatter.ReadSerializedItem(stream, unicornFile.ShortName);

                if (string.IsNullOrEmpty(serializedItem.DatabaseName))
                {
                    serializedItem.DatabaseName = unicornFile.DatabaseName;
                }

                try
                {
                    defaultDeserializer.Deserialize(serializedItem);
                }
                catch (Exception ex)
                {
                    throw new RetryableEmitException(Texts.Failed_to_deserialize_item, unicornFile.Snapshots.First(), ex.Message);
                }
            }
        }

        public override void Compile(ICompileContext context, IProjectItem projectItem)
        {
            var serializationFile = projectItem as SerializationFile;
            if (serializationFile == null)
            {
                return;
            }

            var textDocument = (ITextSnapshot)serializationFile.Snapshots.First();
            var rootTextNode = textDocument.Root;
            if (rootTextNode == TextNode.Empty)
            {
                context.Trace.TraceError(Msg.C1050, Texts.Document_is_not_valid, textDocument.SourceFile.AbsoluteFileName, TextSpan.Empty);
                return;
            }

            var lines = textDocument.SourceFile.ReadAsLines();
            var itemBuilder = context.Factory.ItemBuilder();

            ParseItem(context, textDocument, itemBuilder, lines, 0);

            var item = itemBuilder.Build(serializationFile.Project, rootTextNode);
            item.IsEmittable = false;

            var addedItem = serializationFile.Project.AddOrMerge(item);
            serializationFile.SerializationItemUri = addedItem.Uri;
        }

        /// <summary>
        /// Searches directories of the project items project file and the parents thereof to see 
        /// if a Settings file exists.
        /// </summary>
        /// <param name="projectItem">
        /// File being examined.
        /// </param>
        /// <returns>
        /// Path to the settings file.
        /// </returns>
        public string FindSettingsFilePath(IProjectItem projectItem)
        {
            StyleCopTrace.In(projectItem);

            string cacheKey = string.Format("{0}::{1}", "FindSettingsFilePath", projectItem.Location.FullPath.ToLowerInvariant());

            string settings;

            if (StringCache.TryGetValue(cacheKey, out settings))
            {
                StyleCopTrace.Out();

                return settings;
            }

            IProject projectFile = projectItem.GetProject();

            string result = this.FindSettingsFilePath(projectFile);

            // TODO: This is adding a watcher for settings.stylecop in the folder of the source file
            // This is creating a watcher for *ALL* source files that are monitored!
            this.AddWatcherForSettingsFile(projectItem.Location.FullPath);
            StringCache[cacheKey] = result;

            return StyleCopTrace.Out(result);
        }

        bool IMvcQuickFixTemplateProvider.IsAvailable(IProjectItem context)
        {
            // ReSharper will suggest the "default" quickfix items for MVC-like projects, which include ASPX views generation.
            // ASPX views are not used in Nancy, so we return false here to prevent R# from suggesting them.

            return false;
        }

 protected override void ParseRenderingReferences(ItemParseContext context, ICollection<IReference> references, IProjectItem projectItem, ITextNode renderingTextNode)
 {
     var childNode = renderingTextNode.ChildNodes.FirstOrDefault();
     if (childNode != null)
     {
         base.ParseRenderingReferences(context, references, projectItem, childNode);
     }
 }

        public override void Emit(IEmitContext context, IProjectItem projectItem)
        {
            var item = projectItem as Item;
            Assert.Cast(item, nameof(item));

            if (!item.IsEmittable || item.IsImport)
            {
                return;
            }

            var templateIdOrPath = ResolveTemplateIdOrPath(item);
            if (string.IsNullOrEmpty(templateIdOrPath))
            {
                throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty, item.ItemNameProperty), item.TemplateIdOrPath);
            }

            var database = Factory.GetDatabase(item.DatabaseName);
            var templateItem = database.GetItem(templateIdOrPath);
            if (string.IsNullOrEmpty(templateIdOrPath))
            {
                throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty), item.TemplateIdOrPath);
            }

            var template = TemplateManager.GetTemplate(templateItem.ID, templateItem.Database);
            if (template == null)
            {
                throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty), item.TemplateIdOrPath);
            }

            // todo: convert to pipeline
            ValidateFields(database, template, item);

            var itemWriter = new ItemWriter
            {
                Snapshot = item.Snapshots.First(),
                DatabaseName = item.DatabaseName,
                Guid = projectItem.Uri.Guid,
                ItemName = item.ItemName,
                ItemIdOrPath = item.ItemIdOrPath,
                TemplateIdOrPath = templateIdOrPath
            };

            foreach (var field in item.Fields)
            {
                var templateField = template.GetField(field.FieldName);
                if (templateField == null)
                {
                    throw new RetryableEmitException(Texts.Template_field_missing, TraceHelper.GetTextNode(field.FieldNameProperty, item.ItemNameProperty), field.FieldName);
                }

                var fieldWriter = new FieldWriter(field.FieldIdProperty, field.FieldNameProperty, field.Language, field.Version, field.CompiledValue);
                itemWriter.Fields.Add(fieldWriter);
            }

            var dataItem = itemWriter.Write(context);

            Check(context, item, dataItem);
        }

        public override void Emit(IEmitContext context, IProjectItem projectItem)
        {
            var configFile = (ConfigFile)projectItem;

            var destinationFileName = FileUtil.MapPath(configFile.FilePath);

            context.FileSystem.CreateDirectoryFromFileName(destinationFileName);
            context.FileSystem.Copy(projectItem.Snapshots.First().SourceFile.AbsoluteFileName, destinationFileName, context.ForceUpdate);
        }

 public DocumentModel(IProjectItem parent, string name, int numberOfLines)
 {
     Parent = parent;
     Name = name;
     RelativePath = Path.Combine(parent.RelativePath, name); ;
     NumberOfLines = numberOfLines;
     Children = new List<IProjectItem>();
     Tokens = new List<Token>();
 }

 public TextItemViewModel(IProjectItem item)
 {
     Item = item;
     Title = "Item: " + Item.Name;
     MenuItems = new BindableCollection<MenuItemViewModel> {
         new MenuItemViewModel {
             Header = "_hello"
         }
     };
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SelectProjectItemViewModel" /> class.
        /// </summary>
        /// <param name="rootProjectItem">The root Project Item.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="rootProjectItem" /> is <c>null</c>.</exception>
        public SelectProjectItemViewModel(IProjectItem rootProjectItem)
        {
            Argument.IsNotNull("rootProjectItem", rootProjectItem);

            RootProjectItems = new List<IProjectItem>();
            foreach (var projectItem in rootProjectItem.ProjectItems)
            {
                RootProjectItems.Add(projectItem);
            }
        }

        public override bool CanCompile(ICompileContext context, IProjectItem projectItem)
        {
            var item = projectItem as Item;
            if (item == null)
            {
                return false;
            }

            return item.SourceTextNodes.Select(n => n.GetAttributeValue("Template.CreateFromFields")).Any(value => string.Equals(value, "true", StringComparison.OrdinalIgnoreCase));
        }

        public override void Emit(IEmitContext context, IProjectItem projectItem)
        {
            var template = (Template)projectItem;
            if (!template.IsEmittable || template.IsImport)
            {
                return;
            }

            var templateWriter = new TemplateWriter(template);
            templateWriter.Write(context);
        }

 protected void RemoveProjectItemNode(IProjectItem projectItem)
 {
     foreach (ItemNode node in Nodes)
     {
         if (node is IProjectItemNode && ((IProjectItemNode)node).ProjectItem == projectItem)
         {
             node.Delete();
             return;
         }
     }
 }

        public ProjectItem(EnvDTE.ProjectItem projectItem, IProjectItem parent = null)
        {
            Argument.IsNotNull("projectItem", projectItem);

            Initialize(projectItem.GetObjectName(), projectItem.IsFolder() ? ProjectItemType.Folder : ProjectItemType.File, parent);

            foreach (EnvDTE.ProjectItem subProjectItem in projectItem.ProjectItems)
            {
                ProjectItems.Add(new ProjectItem(subProjectItem, this));
            }
        }

        public override void Compile(ICompileContext context, IProjectItem projectItem)
        {
            var item = projectItem as Item;
            Assert.Cast(item, nameof(item));

            var fileName = item.GetValue<string>(LayoutPage)?.Trim() ?? string.Empty;
            if (string.IsNullOrEmpty(fileName))
            {
                return;
            }

            var property = item.GetProperty<string>(LayoutPage);

            // find page html file
            var rendering = item.Project.Files.FirstOrDefault(i => string.Equals(i.FilePath, fileName, StringComparison.OrdinalIgnoreCase));
            if (rendering == null)
            {
                context.Trace.TraceError(Msg.C1047, Texts.Rendering_reference_not_found, TraceHelper.GetTextNode(property), fileName);
            }

            // find MvcLayout
            var layoutItem = item.Project.ProjectItems.OfType<Item>().FirstOrDefault(i => i.ItemIdOrPath == "/sitecore/layout/Layouts/MvcLayout");
            if (layoutItem == null)
            {
                context.Trace.TraceError(Msg.C1048, Texts.Layout_reference_not_found, TraceHelper.GetTextNode(property), "/sitecore/layout/Layouts/MvcLayout");
            }

            if (rendering == null || layoutItem == null)
            {
                return;
            }

            var sourceFile = rendering.Snapshots.First().SourceFile;

            var writer = new StringWriter();
            var output = new XmlTextWriter(writer);
            output.Formatting = Formatting.Indented;

            var buildContext = new BuildContext(context, sourceFile, output, item, layoutItem);

            var literalRendering = FindRendering(buildContext, "Literal", string.Empty, TextSpan.Empty);
            if (literalRendering == null)
            {
                return;
            }

            buildContext.Placeholder = layoutItem["Place Holders"];
            buildContext.LiteralRendering = literalRendering;

            ParseHtml(buildContext);

            SetRenderingsField(buildContext, buildContext.Item, writer.ToString());
        }

        public override void Emit(IEmitContext context, IProjectItem projectItem)
        {
            var binFile = (BinFile)projectItem;
            var destinationFileName = FileUtil.MapPath(binFile.FilePath);

            if (!CanCopyBinFile(context, binFile, destinationFileName))
            {
                return;
            }

            context.FileSystem.CreateDirectory(Path.GetDirectoryName(destinationFileName) ?? string.Empty);
            context.FileSystem.Copy(projectItem.Snapshots.First().SourceFile.AbsoluteFileName, destinationFileName, context.ForceUpdate);
        }