public static MutableString /*!*/ GetZone(RubyContext /*!*/ context, RubyTime /*!*/ self)
{
if (self.Kind == DateTimeKind.Utc)
{
return(MutableString.CreateAscii("UTC"));
}
else
{
var name = RubyTime.GetCurrentZoneName();
if (name.IsAscii())
{
return(MutableString.CreateAscii(name));
}
else
{
// TODO: what encoding should we use?
return(MutableString.Create(name, context.GetPathEncoding()));
}
}
}
private void ExpandArgument(RubyArray /*!*/ args, string /*!*/ arg)
{
if (arg.IndexOf('*') != -1 || arg.IndexOf('?') != -1)
{
bool added = false;
foreach (string path in Glob.GlobResults(_context, arg, 0))
{
args.Add(MutableString.Create(path));
added = true;
}
if (!added)
{
args.Add(MutableString.Create(arg));
}
}
else
{
args.Add(MutableString.Create(arg));
}
}
private void ExpandArgument(RubyArray /*!*/ args, string /*!*/ arg, RubyEncoding /*!*/ encoding)
{
if (arg.IndexOf('*') != -1 || arg.IndexOf('?') != -1)
{
bool added = false;
foreach (string path in Glob.GetMatches(_context.DomainManager.Platform, arg, 0))
{
args.Add(MutableString.Create(path, encoding));
added = true;
}
if (!added)
{
args.Add(MutableString.Create(arg, encoding));
}
}
else
{
args.Add(MutableString.Create(arg, encoding));
}
}
public static object Shift(RubyContext /*!*/ context, object /*!*/ self)
{
PlatformAdaptationLayer pal = context.DomainManager.Platform;
IDictionary variables = pal.GetEnvironmentVariables();
if (variables.Count == 0)
{
return(null);
}
RubyArray result = new RubyArray(2);
foreach (DictionaryEntry entry in pal.GetEnvironmentVariables())
{
string key = entry.Key.ToString();
result.Add(MutableString.Create(key).Freeze());
result.Add(MutableString.Create(entry.Value.ToString()).Freeze());
pal.SetEnvironmentVariable(key, null);
break;
}
return(result);
}
public static object EachValue(RubyContext /*!*/ context, BlockParam block, object /*!*/ self)
{
PlatformAdaptationLayer pal = context.DomainManager.Platform;
IDictionary variables = pal.GetEnvironmentVariables();
if (variables.Count > 0 && block == null)
{
throw RubyExceptions.NoBlockGiven();
}
foreach (DictionaryEntry entry in variables)
{
MutableString value = MutableString.Create(entry.Value.ToString()).Freeze();
object result;
if (block.Yield(value, out result))
{
return(result);
}
}
return(self);
}
public static MutableString /*!*/ ToPrintedString(RubyContext /*!*/ context, object obj)
{
IDictionary <object, object> hash;
List <object> list;
MutableString str;
if ((list = obj as List <object>) != null)
{
return(IListOps.Join(context, list, Environment.NewLine));
}
else if ((hash = obj as IDictionary <object, object>) != null)
{
return(IDictionaryOps.ToString(context, hash));
}
else if (obj == null)
{
return(MutableString.Create("nil"));
}
else if (obj is bool)
{
return(MutableString.Create((bool)obj ? "true" : "false"));
}
else if (obj is double)
{
var result = MutableString.Create(obj.ToString());
if ((double)(int)(double)obj == (double)obj)
{
result.Append(".0");
}
return(result);
}
else if ((str = obj as MutableString) != null)
{
return(str);
}
else
{
return(RubySites.ToS(context, obj));
}
}
public static RubyArray /*!*/ GetEntries(object self, [NotNull] MutableString /*!*/ dirname)
{
string strDir = dirname.ConvertToString();
string[] rawEntries = null;
try {
rawEntries = Directory.GetFileSystemEntries(strDir);
} catch (Exception ex) {
throw ToRubyException(ex, strDir, DirectoryOperation.Open);
}
RubyArray ret = new RubyArray(rawEntries.Length + 2);
ret.Add(MutableString.Create("."));
ret.Add(MutableString.Create(".."));
foreach (string entry in rawEntries)
{
ret.Add(MutableString.Create(Path.GetFileName(entry)));
}
return(ret);
}
public static MutableString /*!*/ DirName(RubyClass /*!*/ self, MutableString /*!*/ path)
{
string directoryName = path.ConvertToString();
if (IsValidPath(path.ConvertToString()))
{
directoryName = Path.GetDirectoryName(path.ConvertToString());
string fileName = Path.GetFileName(path.ConvertToString());
if (!String.IsNullOrEmpty(fileName))
{
directoryName = StripPathCharacters(path.ConvertToString().Replace(fileName, ""));
}
}
else
{
if (directoryName.Length > 1)
{
directoryName = "//";
}
}
return(Glob.CanonicalizePath(MutableString.Create(String.IsNullOrEmpty(directoryName) ? "." : directoryName)));
}
public static object Status(Thread /*!*/ self)
{
RubyThreadInfo.RegisterThread(Thread.CurrentThread);
switch (self.ThreadState)
{
case ThreadState.WaitSleepJoin:
return(MutableString.Create("sleep"));
case ThreadState.Running:
return(MutableString.Create("run"));
case ThreadState.Aborted:
case ThreadState.AbortRequested:
return(null);
case ThreadState.Stopped:
case ThreadState.StopRequested:
return(false);
default:
throw new ArgumentException("unknown thread status: " + self.ThreadState.ToString());
}
}
public static MutableString Inspect(RubyContext /*!*/ context, IDictionary <object, object> /*!*/ self)
{
using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(self)) {
if (handle == null)
{
return(MutableString.Create("{...}"));
}
MutableString str = MutableString.CreateMutable();
str.Append('{');
foreach (KeyValuePair <object, object> pair in self)
{
if (str.Length != 1)
{
str.Append(", ");
}
str.Append(RubySites.Inspect(context, BaseSymbolDictionary.ObjToNull(pair.Key)));
str.Append("=>");
str.Append(RubySites.Inspect(context, pair.Value));
}
str.Append('}');
return(str);
}
}
public static RubyArray /*!*/ GetDefinedConstants(RubyModule /*!*/ self)
{
var visited = new Dictionary <string, bool>();
var result = new RubyArray();
bool hideGlobalConstants = !ReferenceEquals(self, self.Context.ObjectClass);
self.ForEachConstant(true, delegate(RubyModule /*!*/ module, string name, object value) {
if (name == null)
{
// terminate enumeration when Object is reached
return(hideGlobalConstants && ReferenceEquals(module, module.Context.ObjectClass));
}
if (!visited.ContainsKey(name))
{
visited.Add(name, true);
result.Add(MutableString.Create(name));
}
return(false);
});
return(result);
}
public MutableString /*!*/ Format()
{
_index = 0;
_buf = new StringBuilder();
_tainted = false;
int modIndex;
while ((modIndex = _format.IndexOf('%', _index)) != -1)
{
_buf.Append(_format, _index, modIndex - _index);
_index = modIndex + 1;
DoFormatCode();
}
_buf.Append(_format, _index, _format.Length - _index);
MutableString result = MutableString.Create(_buf.ToString());
if (_tainted)
{
KernelOps.Taint(_context, result);
}
return(result);
}
public static RubyArray /*!*/ GetNameList(RubyClass /*!*/ self)
{
var infos = Encoding.GetEncodings();
var result = new RubyArray(1 + infos.Length);
// Ruby specific:
result.Add(MutableString.CreateAscii(RubyEncoding.Binary.Name));
foreach (var info in infos)
{
result.Add(MutableString.Create(RubyEncoding.GetRubySpecificName(info.CodePage) ?? info.Name));
}
foreach (var alias in RubyEncoding.Aliases.Keys)
{
result.Add(MutableString.CreateAscii(alias));
}
result.Add(MutableString.CreateAscii("locale"));
result.Add(MutableString.CreateAscii("external"));
result.Add(MutableString.CreateAscii("filesystem"));
return(result);
}
public static MutableString /*!*/ GetPath(RubyFile /*!*/ self)
{
return(MutableString.Create(self.Path));
}
// Expand directory path - these cases exist:
//
// 1. Empty string or nil means return current directory
// 2. ~ with non-existent HOME directory throws exception
// 3. ~, ~/ or ~\ which expands to HOME
// 4. ~foo is left unexpanded
// 5. Expand to full path if path is a relative path
//
// No attempt is made to determine whether the path is valid or not
// Returned path is always canonicalized to forward slashes
private static MutableString /*!*/ ExpandPath(RubyContext /*!*/ context, MutableString /*!*/ path)
{
PlatformAdaptationLayer pal = context.DomainManager.Platform;
int length = path.Length;
try {
if (path == null || length == 0)
{
return(Glob.CanonicalizePath(MutableString.Create(Directory.GetCurrentDirectory())));
}
if (length == 1 && path.GetChar(0) == '~')
{
return(Glob.CanonicalizePath(MutableString.Create(Path.GetFullPath(pal.GetEnvironmentVariable("HOME")))));
}
if (path.GetChar(0) == '~' && (path.GetChar(1) == Path.DirectorySeparatorChar || path.GetChar(1) == Path.AltDirectorySeparatorChar))
{
string homeDirectory = pal.GetEnvironmentVariable("HOME");
return(Glob.CanonicalizePath(length < 3 ? MutableString.Create(homeDirectory) : MutableString.Create(Path.Combine(homeDirectory, path.GetSlice(2).ConvertToString()))));
}
else
{
return(Glob.CanonicalizePath(MutableString.Create(Path.GetFullPath(path.ConvertToString()))));
}
} catch (Exception e) {
// Re-throw exception as a reasonable Ruby exception
throw new Errno.InvalidError(path.ConvertToString(), e);
}
}
public static MutableString /*!*/ GetExtension(RubyClass /*!*/ self, [DefaultProtocol, NotNull] MutableString /*!*/ path)
{
return(MutableString.Create(Path.GetExtension(path.ConvertToString())).TaintBy(path));
}
public override MutableString /*!*/ GetPattern()
{
return(MutableString.Create(_pattern));
}
public static MutableString FileType(FileSystemInfo /*!*/ self)
{
string result = IsFile(self) ? "file" : "directory";
return(MutableString.Create(result));
}
public static object ToString(object self)
{
return(MutableString.Create(self.ToString()));
}
public static MutableString /*!*/ GetZone(DateTime /*!*/ self)
{
// TODO:
return(MutableString.Create("UTC"));
}
public static MutableString /*!*/ ToString(bool self)
{
Debug.Assert(self == false);
return(MutableString.Create("false"));
}
public static MutableString /*!*/ GetCurrentDirectory(object self)
{
return(MutableString.Create(NormalizePathSeparators(Directory.GetCurrentDirectory())));
}
public static MutableString /*!*/ GetName(RubyContext /*!*/ context, TypeGroup /*!*/ self)
{
return(MutableString.Create(self.Name, context.GetIdentifierEncoding()));
}
private static MutableString /*!*/ FrozenString(RubyContext /*!*/ context, object value)
{
return(MutableString.Create((string)value ?? "", context.GetPathEncoding()).Freeze());
}
public static MutableString Inspect(object self)
{
return(MutableString.Create("nil"));
}
public static MutableString Mangle(RubyClass /*!*/ self, [DefaultProtocol] string /*!*/ clrName)
{
var ruby = RubyUtils.TryMangleName(clrName);
return(ruby != null?MutableString.Create(ruby, self.Context.GetIdentifierEncoding()) : null);
}
public static MutableString /*!*/ ToString(object self)
{
Debug.Assert(self == null);
return(MutableString.Create(String.Empty));
}
public static MutableString /*!*/ GetRubyName(RubyContext /*!*/ context, ClrName /*!*/ self)
{
return(MutableString.Create(self.MangledName, context.GetIdentifierEncoding()));
}
public static MutableString /*!*/ ToString(DateTime self)
{
return(MutableString.Create(self.ToString("ddd MMM dd HH:mm:ss K yyyy")));
}
public static MutableString /*!*/ FormatTime(DateTime self, [DefaultProtocol, NotNull] MutableString /*!*/ format)
{
bool inEscape = false;
StringBuilder builder = new StringBuilder();
foreach (char c in format.ToString())
{
if (c == '%' && !inEscape)
{
inEscape = true;
continue;
}
if (inEscape)
{
string thisFormat = null;
DateTime firstDay;
int week;
switch (c)
{
case 'a':
thisFormat = "ddd";
break;
case 'A':
thisFormat = "dddd";
break;
case 'b':
thisFormat = "MMM";
break;
case 'B':
thisFormat = "MMMM";
break;
case 'c':
thisFormat = "g";
break;
case 'd':
thisFormat = "dd";
break;
case 'H':
thisFormat = "HH";
break;
case 'I':
thisFormat = "hh";
break;
case 'j':
builder.AppendFormat("{0:000}", self.DayOfYear);
break;
case 'm':
thisFormat = "MM";
break;
case 'M':
thisFormat = "mm";
break;
case 'p':
thisFormat = "tt";
break;
case 'S':
thisFormat = "ss";
break;
case 'U':
firstDay = self.AddDays(1 - self.DayOfYear);
DateTime firstSunday = firstDay.AddDays((7 - (int)firstDay.DayOfWeek) % 7);
week = 1 + (int)Math.Floor((self - firstSunday).Days / 7.0);
builder.AppendFormat("{0:00}", week);
break;
case 'W':
firstDay = self.AddDays(1 - self.DayOfYear);
DateTime firstMonday = firstDay.AddDays((8 - (int)firstDay.DayOfWeek) % 7);
week = 1 + (int)Math.Floor((self - firstMonday).Days / 7.0);
builder.AppendFormat("{0:00}", week);
break;
case 'w':
builder.Append((int)self.DayOfWeek);
break;
case 'x':
thisFormat = "d";
break;
case 'X':
thisFormat = "t";
break;
case 'y':
thisFormat = "yy";
break;
case 'Y':
thisFormat = "yyyy";
break;
case 'Z':
thisFormat = "%K";
break;
default:
builder.Append(c);
break;
}
if (thisFormat != null)
{
builder.Append(self.ToString(thisFormat));
}
inEscape = false;
}
else
{
builder.Append(c);
}
}
return(MutableString.Create(builder.ToString()));
}