public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
int width;
if (arguments["width"] is decimal)
width = Convert.ToInt32((decimal) arguments["width"]);
else
width = (int) arguments["width"];
int height;
if (arguments["height"] is decimal)
height = Convert.ToInt32((decimal) arguments["height"]);
else
height = (int) arguments["height"];
var imageFormat = new ImageFormat
{
Width = width,
Height = height,
Type = (string) arguments["format"]
};
var baseUrl = (string) arguments["baseUrl"];
var url = _imageService.GetURL(new Uri(baseUrl), imageFormat);
writer.Write(url.ToString());
}
void IGenerator.GetText(Scope keyScope, TextWriter writer, Scope contextScope)
{
Dictionary<string, object> arguments = _arguments.GetArguments(keyScope, contextScope);
IEnumerable<NestedContext> contexts = _definition.GetChildContext(writer, keyScope, arguments, contextScope);
List<IGenerator> generators;
if (_definition.ShouldGeneratePrimaryGroup(arguments))
{
generators = _primaryGenerators;
}
else
{
generators = new List<IGenerator>();
if (_subGenerator != null)
{
generators.Add(_subGenerator);
}
}
foreach (NestedContext context in contexts)
{
foreach (IGenerator generator in generators)
{
generator.GetText(context.KeyScope ?? keyScope, context.Writer ?? writer, context.ContextScope);
if (context.WriterNeedsConsidated)
{
writer.Write(_definition.ConsolidateWriter(context.Writer ?? writer, arguments));
}
}
}
}
/// <summary>
/// Gets the context to use when building the inner text of the tag.
/// </summary>
/// <param name="writer">The text writer passed</param>
/// <param name="keyScope">The current scope.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <returns>The scope to use when building the inner text of the tag.</returns>
public override IEnumerable<NestedContext> GetChildContext(
TextWriter writer,
Scope keyScope,
Dictionary<string, object> arguments,
Scope contextScope)
{
object value = arguments[collectionParameter];
IEnumerable enumerable = value as IEnumerable;
if (enumerable == null)
{
yield break;
}
int index = 0;
foreach (object item in enumerable)
{
NestedContext childContext = new NestedContext()
{
KeyScope = keyScope.CreateChildScope(item),
Writer = writer,
ContextScope = contextScope.CreateChildScope(),
};
childContext.ContextScope.Set("index", index);
yield return childContext;
++index;
}
}
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
var partial = (string)arguments["partial"];
var source = arguments["source"];
var rendered = _engine.RenderPartial(partial, source);
writer.Write(rendered);
}
/// <summary>
/// Gets the text to output.
/// </summary>
/// <param name="writer">The writer to write the output to.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <param name="contextScope">Extra data passed along with the context.</param>
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope contextScope)
{
object index;
if (contextScope.TryFind("index", out index))
{
writer.Write(Convert.ToInt32(index) % 2 == 0? "even" : "odd");
}
}
/// <summary>
/// Gets the text to output.
/// </summary>
/// <param name="writer">The writer to write the output to.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <param name="contextScope">Extra data passed along with the context.</param>
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope contextScope)
{
object index;
if (contextScope.TryFind("index", out index))
{
writer.Write(index);
}
}
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
var str = (string) arguments["string"];
if (string.IsNullOrWhiteSpace(str)) return;
writer.Write(str.CamelCase());
}
/// <summary>
/// Creates a child scope that searches for keys in the given object.
/// </summary>
/// <param name="source">The object to search for keys in.</param>
/// <returns>The new child scope.</returns>
public Scope CreateChildScope(object source)
{
Scope scope = new Scope(source, this);
scope.KeyFound = KeyFound;
scope.KeyNotFound = KeyNotFound;
scope.ValueRequested = ValueRequested;
return scope;
}
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
var filenameToReplace = arguments["filename"] as string;
if (null != filenameToReplace)
{
var relativeFileUrl = DocSet.RelativePathToRootFromFile(
this.DestinationFile,
Path.Combine(this.RootDestinationFolder, filenameToReplace),
true);
writer.Write(relativeFileUrl);
}
}
void IGenerator.GetText(Scope scope, TextWriter writer, Scope context)
{
Dictionary<string, object> arguments;
if (_definition.IsSetter)
{
arguments = _arguments.GetArgumentKeyNames();
}
else
{
arguments = _arguments.GetArguments(scope, context);
}
_definition.GetText(writer, arguments, context);
}
/// <summary>
/// Gets the context to use when building the inner text of the tag.
/// </summary>
/// <param name="writer">The text writer passed</param>
/// <param name="keyScope">The current key scope.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <returns>The scope to use when building the inner text of the tag.</returns>
public override IEnumerable<NestedContext> GetChildContext(
TextWriter writer,
Scope keyScope,
Dictionary<string, object> arguments,
Scope contextScope)
{
object contextSource = arguments[contextParameter];
NestedContext context = new NestedContext()
{
KeyScope = keyScope.CreateChildScope(contextSource),
Writer = writer,
ContextScope = contextScope.CreateChildScope()
};
yield return context;
}
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
var str = arguments["string"] as string;
if (str == null) return;
object indexObj;
if (!context.TryFind("index", out indexObj)) return;
var index = (int) indexObj;
if (index > 0)
{
writer.Write(str);
}
}
/// <summary>
/// Substitutes the key placeholders with their respective values.
/// </summary>
/// <param name="keyScope">The key/value pairs in the current lexical scope.</param>
/// <param name="contextScope">The key/value pairs in current context.</param>
/// <returns>A dictionary associating the parameter name to the associated value.</returns>
public Dictionary<string, object> GetArguments(Scope keyScope, Scope contextScope)
{
Dictionary<string, object> arguments = new Dictionary<string,object>();
foreach (KeyValuePair<TagParameter, IArgument> pair in _argumentLookup)
{
object value;
if (pair.Value == null)
{
value = pair.Key.DefaultValue;
}
else
{
value = pair.Value.GetValue(keyScope, contextScope);
}
arguments.Add(pair.Key.Name, value);
}
return arguments;
}
/// <summary>
/// Substitutes the key placeholders with their respective values.
/// </summary>
/// <param name="keyScope">The key/value pairs in the current lexical scope.</param>
/// <param name="contextScope">The key/value pairs in current context.</param>
/// <returns>A dictionary associating the parameter name to the associated value.</returns>
public Dictionary<string, object> GetArguments(Scope keyScope, Scope contextScope)
{
Dictionary<string, object> arguments = new Dictionary<string,object>();
foreach (KeyValuePair<TagParameter, string> pair in _argumentLookup)
{
object value;
if (pair.Value == null)
{
value = pair.Key.DefaultValue;
}
else if (pair.Value.StartsWith("@"))
{
value = contextScope.Find(pair.Value.Substring(1));
}
else
{
value = keyScope.Find(pair.Value);
}
arguments.Add(pair.Key.Name, value);
}
return arguments;
}
private string render(IFormatProvider provider, object source)
{
Scope keyScope = new Scope(source);
Scope contextScope = new Scope(new Dictionary<string, object>());
foreach (EventHandler<KeyFoundEventArgs> handler in _foundHandlers)
{
keyScope.KeyFound += handler;
contextScope.KeyFound += handler;
}
foreach (EventHandler<KeyNotFoundEventArgs> handler in _notFoundHandlers)
{
keyScope.KeyNotFound += handler;
contextScope.KeyNotFound += handler;
}
foreach (EventHandler<ValueRequestEventArgs> handler in _valueRequestedHandlers)
{
contextScope.ValueRequested += handler;
}
StringWriter writer = new StringWriter(provider);
_generator.GetText(keyScope, writer, contextScope);
return writer.ToString();
}
public override IEnumerable <NestedContext> GetChildContext(TextWriter writer, Scope keyScope, Dictionary <string, object> arguments, Scope contextScope)
{
return(new List <NestedContext>());
}
/// <summary>
/// Gets the text to output.
/// </summary>
/// <param name="writer">The writer to write the output to.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <param name="context">Extra data passed along with the context.</param>
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
writer.Write(Environment.NewLine);
}
public object GetValue(Scope keyScope, Scope contextScope)
{
return contextScope.Find(name);
}
void IGenerator.GetText(Scope scope, TextWriter writer, Scope context)
{
writer.Write(Value);
}
/// <summary>
/// Gets the context to use when building the inner text of the tag.
/// </summary>
/// <param name="writer">The text writer passed</param>
/// <param name="keyScope">The current key scope.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <returns>The scope to use when building the inner text of the tag.</returns>
public virtual IEnumerable<NestedContext> GetChildContext(
TextWriter writer,
Scope keyScope,
Dictionary<string, object> arguments,
Scope contextScope)
{
NestedContext context = new NestedContext()
{
KeyScope = keyScope,
Writer = writer,
ContextScope = contextScope.CreateChildScope()
};
yield return context;
}
/// <summary>
/// Initializes a new instance of a KeyScope.
/// </summary>
/// <param name="source">The object to search for keys in.</param>
/// <param name="parent">The parent scope to search in if the value is not found.</param>
internal Scope(object source, Scope parent)
{
_parent = parent;
_source = source;
}
public object GetValue(Scope keyScope, Scope contextScope)
{
return value;
}
void IGenerator.GetText(Scope scope, TextWriter writer, Scope context)
{
object value = _isVariable ? context.Find(_key) : scope.Find(_key);
writer.Write(_format, value);
}
/// <summary>
/// Applies additional formatting to the inner text of the tag.
/// </summary>
/// <param name="writer">The text writer to write to.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <param name="context">The data associated to the context.</param>
public virtual void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
}
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope context)
{
writer.Write($"{{{Guid.NewGuid()}}}");
}
/// <summary>
/// Gets the text to output.
/// </summary>
/// <param name="writer">The writer to write the output to.</param>
/// <param name="arguments">The arguments passed to the tag.</param>
/// <param name="contextScope">Extra data passed along with the context.</param>
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope contextScope)
{
string name = (string)arguments[nameParameter];
contextScope.Set(name);
}
void IGenerator.GetText(Scope scope, TextWriter writer, Scope context)
{
writer.Write(Value);
}