/// <summary>
/// Opens a file, appends the specified string to the file, and then closes the file. If the file does not exist, this method creates a file, writes the specified string to the file, then closes the file.
/// </summary>
internal static void AppendJson(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue contents, BoxedValue onComplete, BoxedValue encodingName)
{
if (!path.IsString)
throw new ArgumentException("[appendJson] First parameter should be defined and be a string.");
if (!contents.IsStrictlyObject)
throw new ArgumentException("[appendJson] Second parameter should be defined and be an object.");
if (!onComplete.IsUndefined && !onComplete.IsFunction)
throw new ArgumentException("[appendJson] Third parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// The encoding to use
Encoding encoding = encodingName.IsString
? TextEncoding.GetEncoding(encodingName.String)
: null;
// Defaults to UTF8
if (encoding == null)
encoding = TextEncoding.UTF8;
// Unbox the array of lines and execute the append
File.AppendAllText(
path.Unbox<string>(),
Native.Serialize(instance.Env, contents, false).Unbox<string>(),
encoding
);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance);
});
}
/// <summary>
/// Represents an event fired when a script object property has been changed.
/// </summary>
/// <param name="instance">The instance of the script object that contains the property.</param>
/// <param name="changeType">The type of the change.</param>
/// <param name="propertyName">The name of the property.</param>
/// <param name="newValue">The new value of the property.</param>
/// <param name="oldValue">The old value of the property.</param>
public static void OnPropertyChange(ScriptObject instance, PropertyChangeType changeType, string propertyName, BoxedValue newValue, BoxedValue oldValue)
{
// Ignore identifier property
if (propertyName == "$i")
return;
switch (changeType)
{
// Occurs when a new property is assigned to an object, either by
// using the indexer, property access or array methods.
case PropertyChangeType.Put:
{
// We need to make sure the new value is marked as observed
// as well, so its members will notify us too.
if (newValue.IsStrictlyObject)
newValue.Object.Observe();
// Send the change through the current scope
Channel.Current.SendPropertyChange(PropertyChangeType.Put, instance.Oid, propertyName, newValue);
break;
}
// Occurs when a property change occurs, by using an assignment
// operator, or the array indexer.
case PropertyChangeType.Set:
{
// We need to unmark the old value and ignore it, as we no
// longer require observations from that value.
if (oldValue.IsStrictlyObject)
oldValue.Object.Ignore();
// We need to make sure the new value is marked as observed
// as well, so its members will notify us too.
if (newValue.IsStrictlyObject)
newValue.Object.Observe();
// Send the change through the current scope
Channel.Current.SendPropertyChange(PropertyChangeType.Set, instance.Oid, propertyName, newValue);
break;
}
// Occurs when a property was deleted from the object, either by
// using a 'delete' keyword or the array removal methods.
case PropertyChangeType.Delete:
{
// We need to unmark the old value and ignore it, as we no
// longer require observations from that value.
if (oldValue.IsStrictlyObject)
oldValue.Object.Ignore();
// Send the change through the current scope
Channel.Current.SendPropertyChange(PropertyChangeType.Delete, instance.Oid, propertyName, newValue);
break;
}
}
//Console.WriteLine("Observe: [{0}] {1} = {2}", changeType.ToString(), propertyName, propertyValue);
}
public static BoxedValue GetValue(ScriptObject o)
{
var vo = o as ValueObject;
if (vo == null)
return o.Env.RaiseTypeError<BoxedValue>("Cannot read the value of a non-value object.");
return vo.Value.Value;
}
/// <summary>
/// Gets the session time.
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
internal static BoxedValue GetConnectedFor(FunctionObject ctx, ScriptObject instance)
{
// Get the first client
var client = Channel.Current.First;
if (client == null)
return Undefined.Boxed;
// Return the address
return BoxedValue.Box(
client.Channel.ConnectedFor
);
}
/// <summary>
/// Creates a new instance of an object.
/// </summary>
/// <param name="prototype">The prototype to use.</param>
/// <param name="param">Either the size of the buffer, a string or the array of octets.</param>
/// <param name="encodingName">The encoding of a string.</param>
public BufferObject(ScriptObject prototype, BoxedValue param, BoxedValue encodingName)
: base(prototype)
{
if (param.IsNumber)
{
// Create a new array with the provided size
this.Buffer = new ArraySegment<byte>(
new byte[(int)param.Number]
);
this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly);
return;
}
if (param.IsString)
{
// The encoding to use
Encoding encoding = encodingName.IsString
? TextEncoding.GetEncoding(encodingName.String)
: null;
// Defaults to UTF8
if (encoding == null)
encoding = TextEncoding.UTF8;
// Decode
this.Buffer = new ArraySegment<byte>(encoding.GetBytes(param.String));
this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly);
return;
}
if (param.IsStrictlyObject && param.Object is ArrayObject)
{
// Allocate a new array
var bytes = (param.Object as ArrayObject);
this.Buffer = new ArraySegment<byte>(new byte[bytes.Length]);
this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly);
// Iterate through the array and convert each integer to a byte
for (int i = 0; i < bytes.Length; ++i)
{
// Get the number and convert to byte
var item = bytes.Get(i);
if (item.IsNumber)
this.Buffer.Array[i] = Convert.ToByte(item.Number);
}
}
}
public static BoxedValue ToBoxedValue(ScriptObject o)
{
return BoxedValue.Box(o);
}
public static void InvokePropertyChange(ScriptObject instance, PropertyChangeType type, string name, double newValue, BoxedValue oldValue)
{
// Invoke the changed event
if (ScriptObject.PropertyChange != null)
ScriptObject.PropertyChange(instance, type, name, BoxedValue.Box(newValue), oldValue);
}
public static BoxedValue ToPrimitive(ScriptObject o, DefaultValueHint hint)
{
return o.DefaultValue(hint);
}
public static string ToString(ScriptObject o)
{
var s = o as StringObject;
return s != null
? s.Value.Value.String
: ToString(o.DefaultValue(DefaultValueHint.String));
}
/// <summary>
/// Displays an interactive listing of the properties of a specified JavaScript object. This
/// listing lets you use disclosure triangles to examine the contents of child objects.
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
/// <param name="eventValue">The value of the event.</param>
internal static void Dir(FunctionObject ctx, ScriptObject instance, BoxedValue eventValue)
{
ConsoleObject.SendEvent("dir", eventValue);
}
/// <summary>
/// Opens a binary file, reads the contents of the file into a byte array, and then closes the file.
/// </summary>
internal static void ReadBuffer(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue onComplete)
{
if (!path.IsString)
throw new ArgumentException("[readBuffer] First parameter should be defined and be a string.");
if (!onComplete.IsFunction)
throw new ArgumentException("[readBuffer] Second parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// Read the file
var arr = File.ReadAllBytes(path.Unbox<string>());
var seg = new ArraySegment<byte>(arr);
// Unbox the array of lines and execute the append
var buffer = BoxedValue.Box(
new BufferObject(seg, instance.Env)
);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance, buffer);
});
}
/// <summary>
/// Opens a file, reads all lines of the file with the specified encoding, and then closes the file.
/// </summary>
internal static void ReadLines(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue onComplete, BoxedValue encodingName)
{
if (!path.IsString)
throw new ArgumentException("[readLines] First parameter should be defined and be a string.");
if (!onComplete.IsFunction)
throw new ArgumentException("[readLines] Second parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// The encoding to use
Encoding encoding = encodingName.IsString
? TextEncoding.GetEncoding(encodingName.String)
: null;
// Defaults to UTF8
if (encoding == null)
encoding = TextEncoding.UTF8;
// Unbox the array of lines and execute the append
var lines = File.ReadAllLines(
path.Unbox<string>(),
encoding
);
// Create a new array
var array = new ArrayObject(instance.Env, (uint)lines.Length);
for (uint i = 0; i < lines.Length; ++i)
{
// Put a boxed string inside for each line
array.Put(i, BoxedValue.Box(lines[i]));
}
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance, BoxedValue.Box(array));
});
}
/// <summary>
/// Replaces an existing file with a new file.
/// </summary>
internal static void Replace(FunctionObject ctx, ScriptObject instance, BoxedValue sourceFileName, BoxedValue destFileName, BoxedValue onComplete)
{
if (!sourceFileName.IsString)
throw new ArgumentException("[replace] First parameter should be defined and be a string.");
if (!destFileName.IsString)
throw new ArgumentException("[replace] Second parameter should be defined and be a string.");
if (!onComplete.IsUndefined && !onComplete.IsFunction)
throw new ArgumentException("[replace] Third parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// Copy the file
if (File.Exists(destFileName.String))
File.Copy(sourceFileName.String, destFileName.String, true);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance);
});
}
public ValueObject(Environment env, Schema map, ScriptObject prototype)
: base(env, map, prototype)
{
}
/// <summary>
/// Gets the hash code reference of the channel.
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
internal static BoxedValue GetHashCode(FunctionObject ctx, ScriptObject instance)
{
// Return the address
return BoxedValue.Box(
Channel.Current.GetHashCode()
);
}
/// <summary>
/// Creates a new instance of an object.
/// </summary>
/// <param name="prototype">The prototype to use.</param>
public FileObject(ScriptObject prototype)
: base(prototype)
{
}
/// <summary>
/// Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file.
/// </summary>
internal static void WriteLines(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue contents, BoxedValue onComplete, BoxedValue encodingName)
{
if (!path.IsString)
throw new ArgumentException("[writeLines] TFirst parameter should be defined and be a string.");
if (!contents.IsArray)
throw new ArgumentException("[writeLines] TSecond parameter should be defined and be an array.");
if (!onComplete.IsUndefined && !onComplete.IsFunction)
throw new ArgumentException("[writeLines] Third parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// The encoding to use
Encoding encoding = encodingName.IsString
? TextEncoding.GetEncoding(encodingName.String)
: null;
// Defaults to UTF8
if (encoding == null)
encoding = TextEncoding.UTF8;
// Unbox the array of lines and execute the append
File.WriteAllLines(
path.Unbox<string>(),
contents.Array.ToArray<string>(),
encoding
);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance);
});
}
/// <summary>
/// Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already exists, it is overwritten.
/// </summary>
internal static void WriteBuffer(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue contents, BoxedValue onComplete)
{
if (!path.IsString)
throw new ArgumentException("[writeBuffer] First parameter should be defined and be a string.");
if (!contents.IsObject || !(contents.Object is BufferObject))
throw new ArgumentException("[writeBuffer] Second parameter should be defined and be a Buffer.");
if (!onComplete.IsUndefined && !onComplete.IsFunction)
throw new ArgumentException("[writeBuffer] Third parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// Get the buffer
var buffer = contents.Object as BufferObject;
// Write the contents
File.WriteAllBytes(
path.Unbox<string>(),
buffer.Array
);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance);
});
}
/// <summary>
/// Constructs a new instance of an <see cref="AppScope"/>.
/// </summary>
/// <param name="name">The unique name for the scope.</param>
/// <param name="parent">The parent scope to attach to the scope.</param>
/// <param name="context">The execution context that is used to execute scripts.</param>
internal PageScope(string name, SessionScope parent, ScriptContext context, ScriptObject prototype)
: base(name, parent, context, prototype)
{
}
/// <summary>
/// Stops the specified timer and logs the elapsed time in seconds since its start.
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
/// <param name="eventValue">The value of the event.</param>
internal static void TimeEnd(FunctionObject ctx, ScriptObject instance, BoxedValue eventValue)
{
ConsoleObject.SendEvent("timeEnd", eventValue);
}
/// <summary>
/// Creates a new container that servers as an application container for a scope.
/// </summary>
/// <param name="prototype">The prototype to use.</param>
internal PageScope(ScriptObject prototype)
: base(prototype)
{
}
/// <summary>
/// Opens a file, reads all lines of the file with the specified encoding, and then closes the file.
/// </summary>
internal static void ReadText(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue onComplete, BoxedValue encodingName)
{
if (!path.IsString)
throw new ArgumentException("[readText] First parameter should be defined and be a string.");
if (!onComplete.IsFunction)
throw new ArgumentException("[readText] Second parameter should be an onComplete function.");
// Get the curent channel
var channel = Channel.Current;
// Dispatch the task
channel.Async(() =>
{
// The encoding to use
Encoding encoding = encodingName.IsString
? TextEncoding.GetEncoding(encodingName.String)
: null;
// Defaults to UTF8
if (encoding == null)
encoding = TextEncoding.UTF8;
// Read the text
var text = BoxedValue.Box(
File.ReadAllText(path.Unbox<string>(), encoding)
);
// Dispatch the on complete asynchronously
channel.DispatchCallback(onComplete, instance, text);
});
}
/// <summary>
/// Creates a new container that servers as an application container for a scope.
/// </summary>
/// <param name="prototype">The prototype to use.</param>
public RemoteObject(ScriptObject prototype)
: base(prototype)
{
}
public static object ToClrObject(ScriptObject o)
{
return o;
}
/// <summary>
/// Exits the current inline group.
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
/// <param name="eventValue">The value of the event.</param>
internal static void GroupEnd(FunctionObject ctx, ScriptObject instance)
{
ConsoleObject.SendEvent("groupEnd", Undefined.Boxed);
}
public static double ToNumber(ScriptObject o)
{
var n = o as NumberObject;
return n != null
? n.Value.Value.Number
: ToNumber(o.DefaultValue(DefaultValueHint.Number));
}
/// <summary>
/// Creates a new container that servers as an application container for a scope.
/// </summary>
/// <param name="prototype">The prototype to use.</param>
public ConsoleObject(ScriptObject prototype)
: base(prototype)
{
}
public static ScriptObject ToObject(Environment env, ScriptObject o)
{
return o;
}
/// <summary>
/// Creates a new inline group, indenting all following output by another level; unlike group(),
/// this starts with the inline group collapsed, requiring the use of a disclosure button to
/// expand it. To move back out a level, call groupEnd()
/// </summary>
/// <param name="ctx">The function context.</param>
/// <param name="instance">The console object instance.</param>
/// <param name="eventName">The name of the event.</param>
/// <param name="eventValue">The value of the event.</param>
internal static void GroupCollapsed(FunctionObject ctx, ScriptObject instance, BoxedValue eventValue)
{
ConsoleObject.SendEvent("groupCollapsed", eventValue);
}
public static bool ToBoolean(ScriptObject o)
{
return true;
}