public static double ConvertStringToFloat(RubyContext context, MutableString value) { try { return(double.Parse(value.ConvertToString(), System.Globalization.CultureInfo.InvariantCulture.NumberFormat)); } catch (FormatException x) { MutableString valueString = RubySites.Inspect(context, value); throw RubyExceptions.CreateArgumentError("invalid value for Float(): " + valueString.ConvertToString(), x); } }
public static MutableString Inspect(RubyContext /*!*/ context, YamlStream /*!*/ self) { MutableString result = MutableString.CreateMutable("#<YAML::Stream:"); RubyUtils.AppendFormatHexObjectId(result, RubyUtils.GetObjectId(context, self)) .Append(" @documents=") .Append(RubySites.Inspect(context, self.Documents)) .Append(", options=") .Append(RubySites.Inspect(context, self.Options)) .Append('>'); return(result); }
public static MutableString /*!*/ ObjectToMutableString(RubyContext /*!*/ context, object obj) { using (IDisposable handle = RubyUtils.InfiniteInspectTracker.TrackObject(obj)) { if (handle == null) { return(MutableString.Create("...")); } MutableString str = MutableString.CreateMutable(); str.Append("#<"); str.Append(context.GetClassOf(obj).Name); // Ruby prints 2*object_id for objects str.Append(':'); AppendFormatHexObjectId(str, GetObjectId(context, obj)); // display instance variables RubyInstanceData data = context.TryGetInstanceData(obj); if (data != null) { var vars = data.GetInstanceVariablePairs(); bool first = true; foreach (KeyValuePair <string, object> var in vars) { if (first) { str.Append(" "); first = false; } else { str.Append(", "); } str.Append(var.Key); str.Append("="); str.Append(RubySites.Inspect(context, var.Value)); } } str.Append(">"); return(str); } }
/// <summary> /// Casts to symbol. Note that this doesn't actually use to_sym -- it uses to_str. /// That's just how Ruby does it. /// /// Another fun detail: you can pass Fixnums as Symbols. If you pass a Fixnum that /// doesn't map to a Symbol (i.e. Fixnum#to_sym returns nil), you get an ArgumentError /// instead of a TypeError. At least it produces a warning about using Fixnums as Symbols /// </summary> public static string /*!*/ CastToSymbol(RubyContext /*!*/ context, object obj) { if (obj is SymbolId) { return(SymbolTable.IdToString((SymbolId)obj)); } if (obj is int) { return(RubyOps.ConvertFixnumToSymbol(context, (int)obj)); } else { MutableString str = AsString(context, obj); if (str != null) { return(RubyOps.ConvertMutableStringToSymbol(str)); } } throw RubyExceptions.CreateTypeError(String.Format("{0} is not a symbol", RubySites.Inspect(context, obj))); }
public static Node ToYaml(object self, [NotNull] RubyRepresenter /*!*/ rep) { return(rep.Scalar(self, RubySites.Inspect(rep.Context, self))); }
public static Exception /*!*/ InvalidValueForType(RubyContext /*!*/ context, object obj, string type) { return(CreateArgumentError(String.Format("invalid value for {0}: {1}", type, RubySites.Inspect(context, obj).ConvertToString()))); }