rhodes 3.2.3 → 3.3.0.beta.1

data/platform/wp7/IronRuby/Languages/Ruby/Ruby/Runtime/RubyExceptionData.cs

@@ -0,0 +1,271 @@
+/* ****************************************************************************
+ *
+ * Copyright (c) Microsoft Corporation. 
+ *
+ * This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
+ * copy of the license can be found in the License.html file at the root of this distribution. If 
+ * you cannot locate the  Apache License, Version 2.0, please send an email to 
+ * ironruby@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
+ * by the terms of the Apache License, Version 2.0.
+ *
+ * You must not remove this notice, or any other, from this software.
+ *
+ *
+ * ***************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Security;
+using System.Security.Permissions;
+using System.Threading;
+using IronRuby.Builtins;
+using IronRuby.Runtime.Calls;
+using Microsoft.Scripting;
+using Microsoft.Scripting.Interpreter;
+using Microsoft.Scripting.Utils;
+using System.Globalization;
+
+namespace IronRuby.Runtime {
+    /// <summary>
+    /// Stores extra instance data associated with Ruby exceptions
+    /// </summary>
+    [Serializable]
+    public sealed class RubyExceptionData {
+        private static readonly object/*!*/ _DataKey = typeof(RubyExceptionData);
+
+        // An exception class can implement singleton method "new" that returns an arbitrary instance of an exception.
+        // This mapping needs to be applied on exceptions created in libraries as well (they should be created "dynamically").
+        // That would however need to pass RubyContext to every method that might throw an exception. Instead, we call
+        // "new" on the exception's class as soon as it gets to the first Ruby EH handler (rescue/ensure/else).
+        //
+        // True if the exception has already been handled by Ruby EH clause or if it was constructed "dynamically" via Class#new.
+        internal bool Handled { get; set; }
+
+        // Real exception begin propagated by the CLR. Needed for lazy initialization of message, backtrace
+        private Exception/*!*/ _exception;
+        // For asynchronous exceptions (Thread#raise), the user-visible exception (accessible via _visibleException)
+        // is wrapped in a TheadAbortException (accessible via _exception)
+        private Exception/*!*/ _visibleException;
+
+#if DEBUG
+#pragma warning disable 414 // msc: unused field
+        // For asynchronous exceptions, this is useful to figure out which thread raised the exception
+        [NonSerialized]
+        private Thread/*!*/ _throwingThread;
+#pragma warning restore 414
+#endif
+
+        // if this is set to null we need to initialize it
+        private object _message; 
+        
+        // can be set explicitly by the user (even to nil):
+        private RubyArray _backtrace;
+
+        //RHO
+        private static RubyArray m_orig_backtrace;
+        private static object m_orig_message; 
+        //RHO
+
+        [NonSerialized]
+        private CallSite<Func<CallSite, RubyContext, Exception, RubyArray, object>> _setBacktraceCallSite;
+
+        private RubyExceptionData(Exception/*!*/ exception) {
+            _exception = exception;
+            _visibleException = exception;
+#if DEBUG
+            _throwingThread = Thread.CurrentThread;
+#endif
+        }
+
+        public static RubyArray/*!*/ CreateBacktrace(RubyContext/*!*/ context, int skipFrames) {
+            return new RubyStackTraceBuilder(context, skipFrames).RubyTrace;
+        }
+
+        /// <summary>
+        /// Builds backtrace for the exception if it wasn't built yet. 
+        /// Captures a full stack trace starting with the current frame and combines it with the trace of the exception.
+        /// Called from compiled code.
+        /// </summary>
+        internal void CaptureExceptionTrace(RubyScope/*!*/ scope) {
+            if (_backtrace == null) {
+                StackTrace catchSiteTrace = RubyStackTraceBuilder.GetClrStackTrace(null);
+                _backtrace = new RubyStackTraceBuilder(scope.RubyContext, _exception, catchSiteTrace, scope.InterpretedFrame != null).RubyTrace;
+                DynamicSetBacktrace(scope.RubyContext, _backtrace);
+            }
+        }
+
+        /// <summary>
+        /// This is called by the IronRuby runtime to set the backtrace for an exception that has being raised. 
+        /// Note that the backtrace may be set directly by user code as well. However, that uses a different code path.
+        /// </summary>
+        private void DynamicSetBacktrace(RubyContext/*!*/ context, RubyArray backtrace) {
+            if (_setBacktraceCallSite == null) {
+                Interlocked.CompareExchange(ref _setBacktraceCallSite, CallSite<Func<CallSite, RubyContext, Exception, RubyArray, object>>.
+                    Create(RubyCallAction.MakeShared("set_backtrace", RubyCallSignature.WithImplicitSelf(1))), null);
+            }
+            _setBacktraceCallSite.Target(_setBacktraceCallSite, context, _exception, backtrace);
+        }
+
+        /// <summary>
+        /// Gets the instance data associated with the exception
+        /// </summary>
+        public static RubyExceptionData/*!*/ GetInstance(Exception/*!*/ e) {
+            RubyExceptionData result = TryGetInstance(e);
+            if (result == null) {
+                result = AssociateInstance(e);                
+            }
+            return result;
+        }
+
+        internal static RubyExceptionData/*!*/ AssociateInstance(Exception/*!*/ e) {
+            RubyExceptionData result;
+
+            Exception visibleException = RubyUtils.GetVisibleException(e);
+            if (e == visibleException || visibleException == null) {
+                result = new RubyExceptionData(e);
+            } else {
+                // Async exception
+
+                Debug.Assert(e is ThreadAbortException);
+                result = GetInstance(visibleException);
+
+                if (result._exception == visibleException) {
+                    // A different instance of ThreadAbortException is thrown at the end of every catch block (as long as
+                    // Thread.ResetAbort is not called). However, we only want to remember the first one 
+                    // as it will have the most complete stack trace.
+                    result._exception = e;
+                }
+            }
+
+            e.Data[_DataKey] = result;
+            return result;
+        }
+
+        internal static RubyExceptionData TryGetInstance(Exception/*!*/ e) {
+            return e.Data[_DataKey] as RubyExceptionData;
+        }
+        
+        public object Message {
+            get {
+                //RHO
+                if (m_orig_message != null)
+                    return m_orig_message;
+                //RHO
+
+                if (_message == null) {
+                    _message = MutableString.Create(_visibleException.Message, RubyEncoding.UTF8);
+                }
+                return _message;
+            }
+            set { 
+                ContractUtils.RequiresNotNull(value, "value"); 
+                _message = value; 
+            }
+        }
+
+        public RubyArray Backtrace {
+            get {
+                //RHO
+                if (m_orig_backtrace != null)
+                    return m_orig_backtrace;
+                //RHO
+                return _backtrace;
+            }
+            set {
+                //RHO
+                if (!_visibleException.Message.Equals("TargetInvocationException"))
+                {
+                    m_orig_backtrace = _backtrace;
+                    m_orig_message = _visibleException.Message;
+                }
+                //RHO
+                _backtrace = value;
+            }
+        }
+
+        public static string/*!*/ GetClrMessage(RubyContext/*!*/ context, object message) {
+            return Protocols.ToClrStringNoThrow(context, message);
+        }
+
+        public static string/*!*/ GetClrMessage(RubyClass/*!*/ exceptionClass, object message) {
+            return GetClrMessage(exceptionClass.Context, message ?? exceptionClass.Name);
+        }
+
+        public static Exception/*!*/ InitializeException(Exception/*!*/ exception, object message) {
+            RubyExceptionData data = RubyExceptionData.GetInstance(exception);
+            // only set it if message is non-null. Otherwise, let lazy initialization create the default message from CLR exception message
+            if (message != null) {
+                data.Message = message;
+            }
+
+            return exception;
+        }
+
+        internal static Exception/*!*/ HandleException(RubyContext/*!*/ context, Exception/*!*/ exception) {
+            // already handled:
+            var instanceData = GetInstance(exception);
+            if (instanceData.Handled) {
+                return exception;
+            }
+
+            RubyClass exceptionClass = context.GetClass(exception.GetType());
+
+            // new resolves to Class#new built-in method:
+            var newMethod = exceptionClass.ImmediateClass.ResolveMethod("new", VisibilityContext.AllVisible);
+            if (newMethod.Found && newMethod.Info.DeclaringModule == context.ClassClass && newMethod.Info is RubyCustomMethodInfo) {
+                // initialize resolves to a built-in method:
+                var initializeMethod = exceptionClass.ResolveMethod("initialize", VisibilityContext.AllVisible);
+                if (initializeMethod.Found && initializeMethod.Info is RubyLibraryMethodInfo) {
+                    instanceData.Handled = true;
+                    return exception;
+                }
+            }
+
+            var site = exceptionClass.NewSite;
+            Exception newException;
+            try {
+                newException = site.Target(site, exceptionClass, instanceData.Message) as Exception;
+            } catch (Exception e) {
+                // MRI: this can lead to stack overflow:
+                return HandleException(context, e);
+            }
+
+            // MRI doesn't handle this correctly, see http://redmine.ruby-lang.org/issues/show/1886:
+            if (newException == null) {
+                newException = RubyExceptions.CreateTypeError("exception object expected");
+            }
+
+            var newInstanceData = GetInstance(newException);
+            
+            newInstanceData.Handled = true;
+            newInstanceData._backtrace = instanceData._backtrace;
+            return newException;
+        }
+
+#if SILVERLIGHT // Thread.ExceptionState
+        public static void ActiveExceptionHandled(Exception visibleException) {}
+#else
+        public static void ActiveExceptionHandled(Exception visibleException) {
+            Debug.Assert(RubyUtils.GetVisibleException(visibleException) == visibleException);
+
+            RubyExceptionData data = RubyExceptionData.GetInstance(visibleException);
+            if (data._exception != visibleException) {
+                // The exception was raised asynchronously with Thread.Abort. We can not just catch and ignore 
+                // the ThreadAbortException as the CLR keeps trying to re-raise it unless ResetAbort is called.
+                //
+                // Note that ResetAbort can cause ThreadAbortException.ExceptionState to be cleared (though it may 
+                // not be cleared under some circustances), and we use that to squirrel away the Ruby exception 
+                // that the user is expecting. Hence, ResetAbort should only be called when 
+                // ThreadAbortException.ExceptionState no longer needs to be accessed. 
+                if ((Thread.CurrentThread.ThreadState & System.Threading.ThreadState.AbortRequested) != 0) {
+                    Thread.ResetAbort();
+                }
+            }
+        }
+#endif
+    }
+}

data/platform/wp7/IronRuby/Languages/Ruby/Ruby/Runtime/RubyUtils.cs

@@ -978,8 +978,10 @@ namespace IronRuby.Runtime {
 
             Type baseType = theclass.GetUnderlyingSystemType();
             object obj;
+#if SILVERLIGHT // serialization
+            if (typeof(ISerializable).IsAssignableFrom(baseType) && !typeof(RubyObject).IsAssignableFrom(baseType)) {
+#else
             if (typeof(ISerializable).IsAssignableFrom(baseType)) {
-#if !SILVERLIGHT // serialization
                 BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
                 ConstructorInfo ci = baseType.GetConstructor(bindingFlags, null, _serializableTypeSignature, null);
                 if (ci == null) {
@@ -1185,6 +1187,34 @@ namespace IronRuby.Runtime {
             return path[0] == '/';
         }
 
+        public static bool IsRelativeToCurrentDirectory(string path) {
+            if (String.IsNullOrEmpty(path)) {
+                return false;
+            }
+
+            if (path.Length == 1) {
+                return path[0] == '.';
+            }
+
+            if (path[0] != '.') {
+                return false;
+            }
+
+            if (path[1] == '/' || path[1] == '\\') {
+                return true;
+            }
+
+            if (path.Length == 2) {
+                return path[1] == '.';
+            }
+
+            if (path[2] == '/' || path[2] == '\\') {
+                return true;
+            }
+
+            return false;
+        }
+
         // Is path something like "c:/foo/bar" (on Windows)
         public static bool IsAbsoluteDriveLetterPath(string path) {
             if (String.IsNullOrEmpty(path)) {

data/platform/wp7/RhoRubyLib/common/RhoStd.cs

@@ -152,6 +152,12 @@ namespace rho.common
         {
             base.Insert(nPos, value);
         }
+
+        public int indexOf(TValue item)
+        {
+            return base.IndexOf(item);
+        }
+
     }
 
     public class Hashtable<TKey, TValue> : System.Collections.Generic.Dictionary<TKey, TValue>

data/platform/wp7/RhoRubyLib/common/RhodesApp.cs

@@ -261,18 +261,32 @@ namespace rho.common
 
         public void processInvokeScript(String strScript, int index)
         {
+            String[] arr = strScript.Split('(');
+            String[] arrParams = null;
+            if (arr.Length > 1)
+            {
+                arrParams = arr[1].Split(',');
+                if (arrParams.Length == 1)
+                {
+                    arrParams[0] = arrParams[0].Replace('"', ' ');
+                    arrParams[0] = arrParams[0].Replace(')', ' ');
+                    arrParams[0] = arrParams[0].Replace(';', ' ');
+                    arrParams[0] = arrParams[0].Trim();
+                }
+            }
+
             m_webBrowser.Dispatcher.BeginInvoke(() =>
             {
                 if (index > 0)
                 {
                     if (m_tabControl != null && m_tabControl.Items.Count > 0)
                     {
-                        ((RhoView)((TabItem)m_tabControl.Items[index]).Content).webBrowser1.InvokeScript(strScript);
+                        ((RhoView)((TabItem)m_tabControl.Items[index]).Content).webBrowser1.InvokeScript(arr[0], arrParams);
                     }
                 }
                 else
                 {
-                    m_webBrowser.InvokeScript(strScript);
+                    m_webBrowser.InvokeScript(arr[0], arrParams);
                 }
             });
         }

data/platform/wp7/RhoRubyLib/net/NetRequest.cs

@@ -32,6 +32,8 @@ using System.Text;
 using IronRuby.Runtime;
 using IronRuby.Builtins;
 using System.IO;
+using System.Text.RegularExpressions;
+
 
 namespace rho.net
 {

data/platform/wp7/RhoRubyLib/rubyext/RhoSyncEngine.cs

@@ -336,8 +336,7 @@ namespace rho.rubyext
             try
             {
                 SyncThread.stopSync();
-                SyncThread.getSyncEngine().stopSyncByUser();
-                SyncThread.getSyncEngine().logout();
+                SyncThread.getSyncEngine().logout_int();
             }
             catch (Exception ex)
             {

data/platform/wp7/RhoRubyLib/sync/SyncEngine.cs

@@ -907,7 +907,7 @@ namespace rho.sync
 	            /*bError = !*/syncOneSource(i);
 	        }
 
-	        if ( !isSchemaChanged() )
+            if (!isSchemaChanged() && getState() != SyncEngine.esStop )
 	    	    getNotify().fireSyncNotification(null, true, RhoAppAdapter.ERR_NONE, RhoAppAdapter.getMessageText("sync_completed"));
 	    }
 
@@ -1010,14 +1010,17 @@ namespace rho.sync
 	
 	    public void logout()
 	    {
-	        if(m_NetRequest!=null) 
-	            m_NetRequest.cancel();
-		
-		    getUserDB().executeSQL( "UPDATE client_info SET session = NULL");
-	        m_strSession = "";
-	
-	        //loadAllSources();
-	    }
+            stopSync();
+            logout_int();
+        }
+
+        public void logout_int()
+        {
+            getUserDB().executeSQL("UPDATE client_info SET session = NULL");
+            m_strSession = "";
+
+            //loadAllSources();
+        }
 	
 	    public void setSyncServer(String syncserver)
 	    {
@@ -1030,7 +1033,7 @@ namespace rho.sync
 			
 			    getUserDB().executeSQL("DELETE FROM client_info");
 
-			    logout();
+			    logout_int();
 		    }
 	    }
 	

data/platform/wp7/RhoRubyLib/sync/SyncSource.cs

@@ -48,7 +48,7 @@ namespace rho.sync
         public String m_strError = "", m_strServerError = "";
     
         int m_nRefreshTime = 0;
-        int m_nProgressStep = -1;
+        int m_nProgressStep = 0;
         boolean m_bSchemaSource;
     
         public class CAssociation
@@ -107,6 +107,7 @@ namespace rho.sync
             m_nID = 0;
         
             m_bTokenFromDB = true;
+            m_nProgressStep = 0;
 
             m_nCurPageCount = 0;
             m_nInserted = 0;
@@ -125,7 +126,8 @@ namespace rho.sync
             m_nID = id;
             m_strName = name;
             m_strSyncType = strSyncType;
-        
+            m_nProgressStep = 0;
+
             m_nCurPageCount = 0;
             m_nInserted = 0;
             m_nDeleted = 0;
@@ -470,7 +472,9 @@ namespace rho.sync
 	                oItem.m_strContentType = "application/octet-stream";
 	                oItem.m_strName = strAttrib + "-" + strObject;
 
-	                m_arBlobAttrs.addElement(strAttrib);
+                    if (m_arBlobAttrs.indexOf(strAttrib) == -1)
+	                    m_arBlobAttrs.addElement(strAttrib);
+
 	                m_arMultipartItems.addElement(oItem);
 	            }
 
@@ -825,18 +829,36 @@ namespace rho.sync
 	        
 	            if ( bCheckUIRequest )
 	            {
-		            int nSyncObjectCount  = getNotify().incLastSyncObjectCount(getID());
-		            if ( getProgressStep() > 0 && (nSyncObjectCount%getProgressStep() == 0) )
-		                getNotify().fireSyncNotification(this, false, RhoAppAdapter.ERR_NONE, "");
-		        
 		            if ( getDB().isUIWaitDB() )
 		            {
 			            LOG.INFO("Commit transaction because of UI request.");
 		                getDB().endTransaction();
+
+                        checkProgressStepNotify(false);
+
 		                SyncThread.sleep(1000);
 		                getDB().startTransaction();
-		            }
+		            }else
+                        checkProgressStepNotify(true);
+	            }
+	        }
+	    }
+
+	    void checkProgressStepNotify(boolean bEndTransaction)//throws Exception
+	    {
+	        int nSyncObjectCount  = getNotify().incLastSyncObjectCount(getID());
+	        if ( getProgressStep() > 0 && (nSyncObjectCount%getProgressStep() == 0) )
+	        {
+	            if ( bEndTransaction )
+	            {
+	                LOG.INFO("Commit transaction because of Sync Progress notification.");
+	                getDB().endTransaction();
 	            }
+
+	            getNotify().fireSyncNotification(this, false, RhoAppAdapter.ERR_NONE, "");
+
+	            if ( bEndTransaction )
+	                getDB().startTransaction();
 	        }
 	    }