private RepositoryTreeNode EnsureServerOf(Uri uri)
{
Uri serverUri;
RepositoryTreeNode serverNode = FindServer(uri, out serverUri);
if (serverNode == null)
{
serverNode = new RepositoryTreeNode(serverUri, true);
serverNode.Text = serverUri.ToString();
if (IconMapper != null)
{
serverNode.IconIndex = IconMapper.GetSpecialIcon(SpecialIcon.Server);
}
if (serverNode.Text.ToString() == "file:///")
{
serverNode.IconIndex = IconMapper.GetSpecialFolderIcon(Environment.SpecialFolder.MyComputer);
serverNode.Text = RepositoryStrings.LocalRepositories;
}
SortedAddNode(RootNode.Nodes, serverNode);
if (!RootNode.IsExpanded)
{
RootNode.Expand();
}
}
return(serverNode);
}
public static List <CodeItem> Map(string filePath, ICodeViewUserControl control)
{
_control = control;
var jsString = File.ReadAllText(filePath);
var ast = new TypeScriptAST(jsString, filePath);
return(new List <CodeItem>
{
new CodeNamespaceItem
{
Id = "Namespace" + filePath,
Kind = CodeItemKindEnum.Namespace,
Members = new List <CodeItem>
{
new CodeClassItem
{
Id = filePath,
Kind = CodeItemKindEnum.Class,
Access = CodeItemAccessEnum.Public,
Moniker = IconMapper.MapMoniker(CodeItemKindEnum.Class, CodeItemAccessEnum.Public),
Name = Path.GetFileNameWithoutExtension(filePath),
BorderColor = Colors.DarkGray,
Members = ast.RootNode.Children?.SelectMany(MapMember)?.ToList() ?? new List <CodeItem>()
}
}
}
});
}
private RepositoryTreeNode EnsureNodeUri(Uri uri, Uri repositoryUri, SvnNodeKind kind)
{
Uri nUri = SvnTools.GetNormalizedUri(uri);
RepositoryTreeNode tn;
if (!_nodeMap.TryGetValue(nUri, out tn))
{
Uri parentUri = new Uri(uri, kind == SvnNodeKind.Directory ? "../" : "./");
if (parentUri == uri)
{
return(null);
}
RepositoryTreeNode parent = EnsureNodeUri(parentUri, repositoryUri, SvnNodeKind.Directory);
if (parent != null)
{
tn = new RepositoryTreeNode(new SvnOrigin(uri, repositoryUri));
string name = uri.ToString();
tn.Text = tn.Origin.Target.FileName;
if (IconMapper != null)
{
if (kind == SvnNodeKind.Directory)
{
tn.IconIndex = IconMapper.DirectoryIcon;
}
else
{
tn.IconIndex = IconMapper.GetIconForExtension(Path.GetExtension(name));
}
}
_nodeMap.Add(nUri, tn);
tn.Preload(kind);
SortedAddNode(parent.Nodes, tn);
if (!parent.IsExpanded && IsLoading(nUri))
{
parent.LoadExpand();
tn.EnsureVisible();
}
else if (IsLoading(nUri))
{
tn.EnsureVisible();
}
}
}
return(tn);
}
protected override DrawingBrush CreateIconSourceBrush()
{
ITypeId type = (ITypeId)this.StyleType;
if (type != null)
{
return(IconMapper.GetDrawingBrushForType(type, true, 24, 24));
}
return((DrawingBrush)null);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
ITypeId type = value as ITypeId;
if (type != null)
{
return((object)IconMapper.GetDrawingBrushForType(type, false, 12, 12));
}
return((object)null);
}
public static List <CodeItem> MapFunction(Node function, NodeArray <ParameterDeclaration> parameters, string id, ICodeViewUserControl control)
{
if (function == null)
{
return(null);
}
List <CodeItem> children;
try
{
children = function.Children
.FirstOrDefault(c => c.Kind == SyntaxKind.Block)?.Children
.SelectMany(SyntaxMapperJS.MapMember)
.ToList();
}
catch (NullReferenceException)
{
return(new List <CodeItem>());
}
if (children != null && children.Any())
{
SyntaxMapper.FilterNullItems(children);
var item = BaseMapperJS.MapBase <CodeClassItem>(function, id, control);
item.BorderColor = Colors.DarkGray;
item.Kind = CodeItemKindEnum.Method;
item.Parameters = $"({string.Join(", ", parameters.Select(p => p.IdentifierStr))})";
item.Tooltip = TooltipMapper.Map(item.Access, null, item.Name, item.Parameters);
item.Id = IdMapper.MapId(item.FullName, parameters);
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.Members = children;
return(new List <CodeItem> {
item
});
}
CodeFunctionItem functionItem = BaseMapperJS.MapBase <CodeFunctionItem>(function, id, control);
functionItem.Kind = CodeItemKindEnum.Method;
functionItem.Parameters = $"({string.Join(", ", parameters.Select(p => p.IdentifierStr))})";
functionItem.Tooltip = TooltipMapper.Map(functionItem.Access, null, functionItem.Name, functionItem.Parameters);
functionItem.Id = IdMapper.MapId(functionItem.FullName, parameters);
functionItem.Moniker = IconMapper.MapMoniker(functionItem.Kind, functionItem.Access);
return(new List <CodeItem> {
functionItem
});
}
/// <summary>
/// The ensure the repository root
/// </summary>
/// <param name="uri">Always the repository root</param>
/// <returns></returns>
private RepositoryTreeNode EnsureRoot(Uri uri)
{
EnsureServerOf(uri);
Uri serverUri;
Uri nUri = SvnTools.GetNormalizedUri(uri);
RepositoryTreeNode serverNode = FindServer(uri, out serverUri);
if (serverNode == null)
{
return(null);
}
if (!serverNode.IsExpanded && IsLoading(nUri))
{
serverNode.LoadExpand();
}
foreach (RepositoryTreeNode reposRoot in serverNode.Nodes)
{
if (reposRoot.NormalizedUri == nUri)
{
return(reposRoot);
}
}
// uri is always the repos root here
RepositoryTreeNode rtn = new RepositoryTreeNode(new SvnOrigin(uri, uri));
rtn.Text = uri.GetComponents(UriComponents.Path, UriFormat.SafeUnescaped);
if (IconMapper != null)
{
rtn.IconIndex = IconMapper.GetSpecialIcon(SpecialIcon.Db);
}
serverNode.Nodes.Add(rtn);
if (!_nodeMap.ContainsKey(rtn.NormalizedUri))
{
_nodeMap.Add(rtn.NormalizedUri, rtn);
}
if (!serverNode.IsExpanded || IsLoading(nUri))
{
serverNode.LoadExpand();
}
return(rtn);
}
private RepositoryTreeNode CreateRootNode()
{
RepositoryTreeNode rootNode;
rootNode = new RepositoryTreeNode(null, true);
rootNode.Text = RepositoryStrings.RootName;
if (IconMapper != null)
{
rootNode.IconIndex = IconMapper.GetSpecialIcon(SpecialIcon.Servers);
}
SortedAddNode(Nodes, rootNode);
return(rootNode);
}
private DrawingBrush CacheLargeIcon()
{
IUnreferencedType unreferencedType = this.type as IUnreferencedType;
if (unreferencedType != null && unreferencedType.LargeIcon != null)
{
return(unreferencedType.LargeIcon);
}
if (this.exampleInfo != null && this.exampleInfo.LargeIcon != null)
{
DrawingBrush drawingBrushFromStream = IconMapper.CreateDrawingBrushFromStream((Stream) new MemoryStream(this.exampleInfo.LargeIcon), this.TypeName + this.exampleInfo.DisplayName + "24x24");
if (drawingBrushFromStream != null)
{
return(drawingBrushFromStream);
}
}
return(IconMapper.GetDrawingBrushForType((ITypeId)this.type, true, 24, 24));
}
private static List <CodeItem> MapVariable(VariableStatement variable)
{
var declarator = variable.DeclarationList.Declarations.First();
if (declarator.Initializer != null)
{
switch (declarator.Initializer.Kind)
{
case SyntaxKind.FunctionExpression:
return(FunctionMapperJS.MapFunctionExpression(declarator, _control));
case SyntaxKind.ArrowFunction:
return(FunctionMapperJS.MapArrowFunctionExpression(declarator, _control));
case SyntaxKind.NewExpression:
return(FunctionMapperJS.MapNewExpression(declarator, _control));
default:
break;
}
}
if (variable.Parent.Kind != SyntaxKind.SourceFile)
{
return(new List <CodeItem>());
}
var item = BaseMapperJS.MapBase <CodeItem>(variable, declarator.IdentifierStr, _control);
item.Kind = CodeItemKindEnum.Variable;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(new List <CodeItem> {
item
});
}
