private static void AppendParameters(DescriptionBuilder sb, NetBrowserManager manager, ParameterInfo[] parameters)
{
bool first = true;
foreach (ParameterInfo parameter in parameters)
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
if (parameter.IsOptional)
{
sb.Append("[");
}
NetTypeBrowserInfo.WriteParameterType(manager, sb, parameter, true);
sb.Append(" ");
sb.Append(parameter.Name);
if (parameter.IsOptional)
{
sb.Append("]");
}
}
}
private void AppendMethodAttributes(DescriptionBuilder sb, MethodInfo method)
{
AppendMethodAttribute(sb, method, MethodAttributes.Static);
AppendMethodAttribute(sb, method, MethodAttributes.PinvokeImpl);
// Sorting out "virtual", "new" and "override" methods requires more complex logic.
// The relevant MethodAttribute values are:
//
// override: Virtual
// virtual: Virtual, NewSlot
// abstract: Virtual, NewSlot, Abstract
if ((method.Attributes & MethodAttributes.Virtual) == MethodAttributes.Virtual)
{
if ((method.Attributes & MethodAttributes.NewSlot) == MethodAttributes.NewSlot)
{
if (!AppendMethodAttribute(sb, method, MethodAttributes.Abstract))
{
sb.Append(Settings.GetKeyword(MethodAttributes.Virtual));
sb.Append(" ");
}
}
else
{
sb.Append(Settings.GetKeyword(MethodAttributes.ReuseSlot));
sb.Append(" ");
}
}
}
private void DoSaveVm()
{
var binding = _WPFDoubleBrowserNavigator?.Binding?.JSBrideRootObject;
if (binding == null)
{
return;
}
var savefile = new SaveFileDialog
{
FileName = "vm.cjson",
InitialDirectory = ComputeProposedDirectory()
};
if (savefile.ShowDialog() != true)
{
return;
}
var fileName = savefile.FileName;
_SaveDirectory = Path.GetDirectoryName(fileName);
var descriptionBuilder = new DescriptionBuilder("null");
binding.BuilString(descriptionBuilder);
var content = descriptionBuilder.BuildString();
File.WriteAllLines(fileName, new[] { content });
}
private static void AppendParameters(DescriptionBuilder sb, ParameterDesc[] parameters)
{
bool first = true;
foreach (ParameterDesc parameter in parameters)
{
if (parameter != null)
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
ComTypeBrowserInfo.WriteParameterAttributes(sb, parameter);
sb.Append(parameter.Type);
sb.Append(" ");
sb.Append(parameter.Name);
}
}
}
internal void AppendCustomAttributes(DescriptionBuilder sb, ICustomAttributeProvider provider)
{
const string attributeSuffix = "Attribute";
Debug.Assert(sb != null && provider != null, "sb != null && provider != null");
NetBrowserSettings settings = (NetBrowserSettings)Settings;
foreach (Attribute attr in provider.GetCustomAttributes(false))
{
Type attrType = attr.GetType();
// Remove the "Attribute" suffix from the name.
string name = attrType.Name;
if (name.EndsWith(attributeSuffix))
{
name = name.Substring(0, name.Length - attributeSuffix.Length);
}
sb.Append(settings.GetKeyword(NetBrowserSettings.KeywordAttributeStart));
sb.AppendLink(name, GetTypeInfoForLink(
attrType.Assembly.Location, attrType.FullName));
sb.Append(settings.GetKeyword(NetBrowserSettings.KeywordAttributeEnd));
sb.EndLine();
}
}
private DescriptionText GetDescription()
{
try
{
DescriptionBuilder sb = new DescriptionBuilder(true);
sb.Append("Assembly ");
sb.AppendName(m_assembly.GetName().Name);
sb.EndFirstLine();
sb.Append(" ");
sb.Append(m_assembly.Location);
sb.EndLine();
sb.EndLine();
Manager.AppendCustomAttributes(sb, m_assembly);
return(sb.GetText());
}
catch (System.Exception ex)
{
throw new ApplicationException("Failed to write the assembly description for assembly '"
+ m_assembly.FullName + "'.", ex);
}
}
/// <summary>
/// 获取标签生成器
/// </summary>
protected override TagBuilder GetTagBuilder()
{
var builder = new DescriptionBuilder();
Config(builder);
return(builder);
}
private AccessorDescription BuildAccessorDefinition <T>() where T : ITypedReflectAccessor
{
var builder = new DescriptionBuilder();
var description = builder.Describe <T>();
return(description);
}
private string GetParameterTypes(MethodBase method)
{
DescriptionBuilder sb = new DescriptionBuilder(false);
bool first = true;
foreach (ParameterInfo parameter in method.GetParameters())
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
if (parameter.IsOptional)
{
sb.Append("[");
}
WriteParameterType(Manager, sb, parameter, false);
if (parameter.IsOptional)
{
sb.Append("]");
}
}
return(sb.ToString());
}
private DescriptionText GetDescription()
{
try
{
DescriptionBuilder sb = new DescriptionBuilder(true);
sb.Append("Type Library ");
sb.AppendName(DisplayName);
sb.EndFirstLine();
sb.Append(" ");
sb.Append(m_filePath);
sb.EndLine();
string description = GetDocString();
if (description != null && description.Length != 0)
{
sb.AppendHeading("Description:");
sb.Append(description);
}
return(sb.GetText());
}
catch (System.Exception ex)
{
throw new ApplicationException("Failed to write the type library description for type library '"
+ m_filePath + "'.", ex);
}
}
private DescriptionText GetDescription()
{
DescriptionBuilder sb = new DescriptionBuilder(true);
switch (m_member.MemberType)
{
case MemberTypes.Method:
case MemberTypes.Event:
AppendMethod(sb, (MethodDesc)m_member);
break;
case MemberTypes.Property:
AppendProperty(sb, (PropertyDesc)m_member);
break;
case MemberTypes.Field:
AppendField(sb, (FieldDesc)m_member);
break;
default:
throw new ApplicationException("Unsupported member type: '" + m_member.MemberType.ToString() + "'.");
}
sb.EndFirstLine();
sb.Append(@" Member of ");
sb.AppendLink(m_type.DisplayName, m_type);
sb.EndLine();
return(sb.GetText());
}
private static void AppendTypeAttribute(DescriptionBuilder sb, TYPEATTR typeAttr, TYPEFLAGS attribute)
{
if ((typeAttr.wTypeFlags & attribute) == attribute)
{
sb.Append(", ");
sb.Append(ComBrowserSettings.GetKeyword(attribute));
}
}
private void AppendFieldAttribute(DescriptionBuilder sb, FieldInfo field, FieldAttributes attribute)
{
if ((field.Attributes & attribute) == attribute)
{
sb.Append(Settings.GetKeyword(attribute));
sb.Append(" ");
}
}
private void AppendTypeAttribute(DescriptionBuilder sb, Type type, TypeAttributes attribute)
{
if ((type.Attributes & attribute) == attribute)
{
sb.Append(Settings.GetKeyword(attribute));
sb.Append(" ");
}
}
private void AppendConstructor(DescriptionBuilder sb, NetBrowserManager manager, ConstructorInfo constructor)
{
AppendMethodAttribute(sb, constructor, MethodAttributes.Static);
sb.AppendName(constructor.DeclaringType.Name);
sb.Append(" ( ");
AppendParameters(sb, manager, constructor.GetParameters());
sb.Append(" )");
}
private void AppendEvent(DescriptionBuilder sb, NetBrowserManager manager, EventInfo eventInfo)
{
sb.Append(Settings.GetKeyword(MemberTypes.Event));
sb.Append(" ");
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, eventInfo.EventHandlerType, false, true);
sb.Append(" ");
sb.AppendName(eventInfo.Name);
}
public void When_accessor_then_dispatcher_property_description_should_be_produced()
{
var builder = new DescriptionBuilder();
// Act
var description = builder.Describe <IExampleAccessorFixture>();
// Assert
description.DispatcherProperty.Should().NotBeNull();
}
public static string AsCircularJson(this IJsCsGlue glue)
{
var descriptionBuilder = new DescriptionBuilder("cmd({0})");
glue.BuilString(descriptionBuilder);
if (glue.Type == JsCsGlueType.Object)
{
descriptionBuilder.Prepend($@"{(descriptionBuilder.StringLength > 2 ? "," : "")}""version"":2");
}
return(descriptionBuilder.BuildString());
}
public void When_describing_properties_then_property_description_should_be_produced()
{
var builder = new DescriptionBuilder();
// Act
var description = builder.Describe <IExampleAccessorFixture>();
// Assert
description.Members.Should().ContainSingle(x => x.Value.MemberName == "Property")
.Which.Value.Should().BeAssignableTo <PropertyDescription>();
}
public void When_describing_methods_with_arguments_then_method_description_should_be_produced()
{
var builder = new DescriptionBuilder();
// Act
var description = builder.Describe <IExampleAccessorFixture>();
// Assert
description.Members.Should().ContainSingle(x => x.Value.MemberName == "MethodWithArguments")
.Which.Value.Should().BeAssignableTo <MethodDescription>();
}
internal static void WriteParameterAttributes(DescriptionBuilder sb, ParameterDesc parameter)
{
bool first = true;
if (parameter.IsIn)
{
if (first)
{
first = false;
sb.Append("[");
}
else
{
sb.Append(", ");
}
sb.Append(ComBrowserSettings.GetKeyword(ParameterAttributes.In));
}
if (parameter.IsOut)
{
if (first)
{
first = false;
sb.Append("[");
}
else
{
sb.Append(", ");
}
sb.Append(ComBrowserSettings.GetKeyword(ParameterAttributes.Out));
}
if (parameter.IsRetval)
{
if (first)
{
first = false;
sb.Append("[");
}
else
{
sb.Append(", ");
}
sb.Append(ComBrowserSettings.GetKeyword(ParameterAttributes.Retval));
}
if (!first)
{
sb.Append("] ");
}
}
private static void AppendField(DescriptionBuilder sb, FieldDesc field)
{
sb.Append(field.Type);
sb.Append(" ");
sb.AppendName(field.Name);
if (field.Value != null)
{
sb.Append(" = ");
sb.Append(field.Value);
}
}
private static void AppendMethod(DescriptionBuilder sb, MethodDesc method)
{
if (method.ReturnType != null)
{
sb.Append(method.ReturnType);
sb.Append(" ");
}
sb.AppendName(method.Name);
sb.Append(" ( ");
AppendParameters(sb, method.Parameters);
sb.Append(" )");
}
private bool AppendMethodAttribute(DescriptionBuilder sb, MethodBase method, MethodAttributes attribute)
{
if ((method.Attributes & attribute) == attribute)
{
sb.Append(Settings.GetKeyword(attribute));
sb.Append(" ");
return(true);
}
else
{
return(false);
}
}
public void When_MethodCall_is_called_then_instance_method_should_be_accessed()
{
var instanceMock = Substitute.For <IExampleAccessorFixture>();
var description = new DescriptionBuilder().Describe <IExampleAccessorFixture>();
var dispatcher = new Dispatcher(description);
var id = description.Members.Single(x => x.Value.MemberName == "VoidMethod").Key;
// Act
dispatcher.MethodCall(instanceMock, id, new object[0]);
// Assert
instanceMock.Received().VoidMethod();
}
public void When_FieldSet_is_called_then_instance_field_should_be_set()
{
var input = AutoFixture.Create <string>();
var instanceFake = new FieldExampleFixture();
var description = new DescriptionBuilder().Describe <IFieldExampleAccessorFixture>();
var dispatcher = new Dispatcher(description);
var id = description.Members.Single(x => x.Value.MemberName == "Field").Key;
// Act
dispatcher.FieldSet(instanceFake, id, input);
// Assert
instanceFake.Field.Should().Be(input);
}
public void When_PropertySet_is_called_then_instance_property_should_be_set()
{
var input = AutoFixture.Create <string>();
var instanceMock = Substitute.For <IExampleAccessorFixture>();
var description = new DescriptionBuilder().Describe <IExampleAccessorFixture>();
var dispatcher = new Dispatcher(description);
var id = description.Members.Single(x => x.Value.MemberName == "Property").Key;
// Act
dispatcher.PropertySet(instanceMock, id, input);
// Assert
instanceMock.Received().Property = input;
}
public void DescriptionBuilder_UsingStartingIndex()
{
//Arrange
List <string> inputParameters = new List <string>()
{
"!Steps", "#1.", "open", "application", "#2.", "type", "command", "Create", "Bug", "#3.", "error", "message", "appear", "!Steps", "First description to the workitem to be shown!"
};
var startingIndex = 14;
var descriptionBuilder = new DescriptionBuilder();
var sut = descriptionBuilder.BuildDescription(inputParameters, startingIndex);
Assert.AreEqual(sut, inputParameters[inputParameters.Count - 1]);
}
private void AppendProperty(DescriptionBuilder sb, NetBrowserManager manager, PropertyInfo property)
{
// Properties have many of the same attributes as methods, but these attributes are declared
// on the accessors, not on the properties themselves.
MethodInfo[] accessors = property.GetAccessors(true);
Debug.Assert(accessors.Length > 0, "Unable to get the accessors for property '"
+ property.DeclaringType.ToString() + "." + property.Name
+ "' - this property should not have been displayed.");
AppendMethodAttributes(sb, accessors[0]);
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, property.PropertyType, false, true);
sb.Append(" ");
sb.AppendName(property.Name);
if (property.CanRead)
{
if (property.CanWrite)
{
sb.Append(" [ get, set ]");
}
else
{
sb.Append(" [ get ]");
}
}
else if (property.CanWrite)
{
sb.Append(" [ set ]");
}
else
{
Debug.Fail("Property '" + property.Name + "' is not readable and not writeable.");
}
// Show indexer parameters as well (which the VS.NET object browser doesn't do).
ParameterInfo[] indexers = property.GetIndexParameters();
if (indexers.Length > 0)
{
sb.Append(" ( ");
AppendParameters(sb, manager, indexers);
sb.Append(" )");
}
}
private DescriptionText GetDescriptionInternal(NetNamespaceBrowserInfo ns, NetTypeBrowserInfo baseType)
{
try
{
DescriptionBuilder sb = new DescriptionBuilder(true);
sb.Append(Settings.GetKeyword(GetTypeAccess(m_type)));
sb.Append(" ");
AppendTypeAttribute(sb, m_type, TypeAttributes.Abstract);
AppendTypeAttribute(sb, m_type, TypeAttributes.Sealed);
sb.Append(Settings.GetKeyword(GetObjectType(m_type)));
sb.Append(" ");
sb.AppendName(GetTypeDisplayName(m_type));
if (baseType != null)
{
sb.Append(" : ");
sb.AppendLink(baseType.DisplayName, baseType);
}
if (m_type.IsEnum)
{
Type underlying = Enum.GetUnderlyingType(m_type);
sb.Append(" (");
sb.AppendName(Settings.GetKeyword(underlying.AssemblyQualifiedName));
sb.Append(")");
}
IElementBrowserInfo container = (ns.IsNullNamespace ? ns.Repository : (IElementBrowserInfo)ns);
sb.EndFirstLine();
sb.Append(@" Member of ");
sb.AppendLink(container.NodeText, container);
sb.EndLine();
return(sb.GetText());
}
catch (System.Exception ex)
{
throw new ApplicationException("Failed to write the type declaration for type '"
+ m_type.FullName + "'.", ex);
}
}
