public static JJsonObjectExpression Add(this JJsonObjectExpression exp, string name, JExpression value)
{
if (exp.NamesValues == null)
{
exp.NamesValues = new List <JJsonNameValue>();
}
exp.NamesValues.Add(JsonNameValue(name, value));
return(exp);
}
public void VisitsJsonObjectExpression(JJsonObjectExpression node)
{
if (node.NamesValues.IsNullOrEmpty())
{
Write("{}");
}
else
{
var singleLine = node.NamesValues.Where(t => t.Value.IsAny(typeof(JFunction), typeof(JJsonObjectExpression))).FirstOrDefault() == null;
if (!singleLine && OpenBraceInNewLine)
{
WriteLine();
}
BeginBlock(singleLine);
VisitEachJoin(node.NamesValues, (first) =>
{
if (EmptyLineBetweenJsonMethods && !singleLine && first.Value != null && first.Value is JFunction)
{
WriteLine();
}
}, (prev, next) =>
{
if (singleLine)
{
WriteComma();
}
else
{
WriteComma();
WriteLine();
if (EmptyLineBetweenJsonMethods && ((prev.Value != null && prev.Value is JFunction) || (next.Value != null && next.Value is JFunction)))
{
WriteLine();
}
}
}, (last) =>
{
if (EmptyLineBetweenJsonMethods && !singleLine && last.Value != null && last.Value is JFunction)
{
WriteLine();
}
});
if (!singleLine)
{
WriteLine();
}
EndBlock(true);
}
}
public virtual List <JEntityDeclaration> _VisitEnum(ITypeDefinition ce)
{
var unit = new JUnit {
Statements = new List <JStatement>()
};
ExportTypeNamespace(ce);
var att = ce.GetMetadata <JEnumAttribute>();
bool valuesAsNames;
JMeta.UseJsonEnums(ce, out valuesAsNames);
//var valuesAsNames = att != null && att.ValuesAsNames;
var constants = ce.GetConstants().ToList();
if (!valuesAsNames && constants.Where(t => t.ConstantValue == null).FirstOrDefault() != null)
{
var value = 0L;
foreach (var c in constants)
{
if (c.ConstantValue == null)
{
c.SetConstantValue(value);
}
else
{
value = Convert.ToInt64(c.ConstantValue);
}
value++;
}
}
constants.RemoveAll(t => !JMeta.IsJsExported(t));
var json = new JJsonObjectExpression {
NamesValues = new List <JJsonNameValue>()
};
json.NamesValues.AddRange(constants.Select(t => Export(t, valuesAsNames)));
var st = ce.JAccess().Assign(json).Statement();
unit.Statements.Add(st);
throw new NotSupportedException();
}
public void VisitJsonObjectExpression(JJsonObjectExpression node)
{
throw new NotImplementedException();
}
public virtual List <JEntityDeclaration> _Visit(IProperty pe)
{
var list = GetAccessorsToExport(pe);
if (JMeta.IsNativeProperty(pe))
{
var statements = new List <JStatement>();
statements.AddRange(list.Select(ExportMethod).Cast <JStatement>());
var json = new JJsonObjectExpression();
foreach (var accessor in list)
{
//if (accessor == pe.Getter) json.Add("get", (JsFunction)ExportMethod(accessor));
//if (accessor == pe.Setter) json.Add("set", (JsFunction)ExportMethod(accessor));
if (accessor == pe.Getter)
{
json.Add("get", ExportTypePrefix(pe.Getter.GetDeclaringTypeDefinition(), pe.IsStatic).Member("get_" + pe.Name));
}
if (accessor == pe.Setter)
{
json.Add("set", ExportTypePrefix(pe.Setter.GetDeclaringTypeDefinition(), pe.IsStatic).Member("set_" + pe.Name));
}
}
if (JMeta.IsNativePropertyEnumerable(pe))
{
json.Add("enumerable", new JCodeExpression()
{
Code = "true"
});
}
//json.Add("configurable", new JsCodeExpression() { Code = "true" });
var defineStatement = new JExpressionStatement()
{
Expression = new JInvocationExpression()
{
Member = new JMemberExpression()
{
Name = "Object.defineProperty"
},
Arguments = new List <JExpression>(new JExpression[]
{
ExportTypePrefix(pe.GetDeclaringTypeDefinition(), pe.IsStatic),
new JStringExpression()
{
Value = pe.Name
},
json
})
}
};
statements.Add(defineStatement);
throw new NotSupportedException();
//return new JsUnit() { Statements = statements };
}
else
{
var list2 = list.Select(ExportMethod).ToList();
return(list2.SelectMany(t => t).ToList());
}
}
