rhodes 2.3.2 → 2.4.0.beta.1

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

@@ -0,0 +1,64 @@
+using System;
+using rho.common;
+
+namespace rho.net
+{
+    public class NetResponse
+    {
+        private String m_strData = null;
+        private int m_nRespCode;
+        private String m_strCookies = "";
+
+        //	public NetResponse( String strData ){ m_strData = strData; m_nRespCode = -1; }
+        public NetResponse(String strData, int nRespCode) { m_strData = strData; m_nRespCode = nRespCode; }
+
+        public String getCharData()
+        {
+            return m_strData;
+        }
+        public void setCharData(String strData)
+        {
+            m_strData = strData;
+        }
+
+        public int getDataSize()
+        {
+            return m_strData != null ? m_strData.length() : 0;
+        }
+
+        public int getRespCode()
+        {
+            return m_nRespCode;
+        }
+
+        public boolean isOK()
+        {
+            return m_nRespCode == 200 || m_nRespCode == 206;
+        }
+
+        public boolean isUnathorized()
+        {
+            return m_nRespCode == 401;
+        }
+
+        public boolean isRedirect()
+        {
+            return getRespCode() == 301 || getRespCode() == 302;
+        }
+
+        public boolean isSuccess()
+        {
+            return m_nRespCode > 0 && m_nRespCode < 400;
+        }
+
+        public void setCookies(String s)
+        {
+            m_strCookies = s;
+        }
+
+        public String getCookies()
+        {
+            return m_strCookies;
+        }
+    }
+}

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

@@ -0,0 +1,187 @@
+using System;
+using rho.common;
+
+namespace rho.net
+{
+    public class URI
+    {
+        public static String parseCookie(String value)
+        {
+            String strRes = "";
+            Tokenizer stringtokenizer = new Tokenizer(value, ";");
+            while (stringtokenizer.hasMoreTokens())
+            {
+                String tok = stringtokenizer.nextToken();
+                tok = tok.trim();
+                if (tok.length() == 0)
+                {
+                    continue;
+                }
+
+                //expires=Thu, 01 Jan 1970 00:00:00 GMT, auth_token=
+                int nExp = tok.indexOf("expires=");
+                if (nExp >= 0)
+                {
+                    int nEnd = tok.indexOf(',', nExp);
+                    if (nEnd >= 0)
+                    {
+                        int nEnd1 = tok.indexOf(',', nEnd + 1);
+                        if (nEnd1 >= 0)
+                            nEnd = nEnd1;
+                        else
+                            nEnd = tok.length() - 1;
+                    }
+
+                    tok = tok.substring(0, nExp) + tok.substring(nEnd + 1);
+                    tok = tok.trim();
+                }
+
+                int nEq = tok.indexOf('=');
+                if (nEq < 0)
+                    continue;
+
+                strRes += tok + ";";
+            }
+
+            return strRes;
+        }
+
+        public static String urlEncode(String fullPath)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            int len = fullPath.length();
+
+            char c;
+            for (int index = 0; index < len; index++)
+            {
+                c = fullPath.charAt(index);
+                if (c == '^' || c == '_'
+                       || c == '\\' || c == '-'
+                       || c == '.'
+                       || (c >= 'A' && c <= 'Z')
+                       || (c >= 'a' && c <= 'z')
+                       || (c >= '0' && c <= '9'))
+                {
+                    sb.Append(c);
+                }
+                else
+                {
+                    sb.Append('%');
+                    sb.Append(String.Format("{0:X2}", (int)c));
+                }
+
+            }
+            return sb.ToString();
+        }
+
+        public static String urlDecode(String fullPath)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            int len = fullPath.length();
+
+            for (int index = 0; index < len; index++)
+            {
+                char c1 = fullPath.charAt(index);
+                if (c1 != '%')
+                {
+                    sb.Append(c1);
+                    continue;
+                }
+                index++;
+                c1 = fullPath.charAt(index);
+
+                if (c1 >= '0' && c1 <= '9')
+                    c1 = (char)(c1 - '0');
+                else if (c1 >= 'a' && c1 <= 'f')
+                    c1 = (char)(c1 - 'a' + 10);
+                else if (c1 >= 'A' && c1 <= 'F')
+                    c1 = (char)(c1 - 'A' + 10);
+                else
+                    break;
+
+                index++;
+                char c2 = fullPath.charAt(index);
+                if (c2 >= '0' && c2 <= '9')
+                    c2 = (char)(c2 - '0');
+                else if (c2 >= 'a' && c2 <= 'f')
+                    c2 = (char)(c2 - 'a' + 10);
+                else if (c2 >= 'A' && c2 <= 'F')
+                    c2 = (char)(c2 - 'A' + 10);
+                else
+                    break;
+
+                char c = (char)((c1 << 4) | c2);
+                sb.Append(c);
+            }
+
+            return sb.ToString();
+        }
+
+        static public String urlEscapeSymbols(String fullPath)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            int len = fullPath.length();
+
+            char c;
+            for (int index = 0; index < len; index++)
+            {
+                c = fullPath.charAt(index);
+                if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+                     c == '_' || c == '.')
+                {
+                    sb.Append(c);
+                }
+                else
+                {
+                    sb.Append('_');
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        static public String ampEncode(String fullPath)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            int len = fullPath.length();
+
+            char c;
+            for (int index = 0; index < len; index++)
+            {
+                c = fullPath.charAt(index);
+                if (c == '&')
+                    sb.Append("&amp;");
+                else
+                    sb.Append(c);
+            }
+
+            return sb.ToString();
+        }
+
+        public static String getQueryString(String strUrl)
+        {
+            int nQuest = strUrl.indexOf('?');
+            if (nQuest < 0 )
+                return "";
+
+            return strUrl.substring(nQuest + 1);
+        }
+
+        public static String getLastNamePart(String strUrl)
+        {
+            int nQuest = strUrl.lastIndexOf('?');
+            String strRes = strUrl;
+            if (nQuest>=0)
+                strRes = strUrl.substring(0, nQuest);
+
+            int nSlash = strRes.lastIndexOf('/');
+            if ( nSlash < 0 )
+                nSlash = strRes.lastIndexOf('\\');
+
+            if ( nSlash >= 0 )
+                strRes = strRes.substring(nSlash+1);
+    
+            return strRes;
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Runtime.InteropServices;
+using rho.common;
+using rho.net;
+
+namespace rho.rubyext
+{
+    [RubyModule("Rho")]
+    public static class RhoRoot
+    {
+        [RubyModule("AsyncHttp")]
+        public static class RhoAsyncHttp
+        {
+
+            #region Private Implementation Details
+
+            #endregion
+
+            #region Private Instance & Singleton Methods
+
+            [RubyMethodAttribute("cancel", RubyMethodAttributes.PublicSingleton)]
+            public static void Cancel(RubyModule/*!*/ self, [NotNull]String cancelCallback)
+            {
+                if (CAsyncHttp.getInstance() != null)
+                    CAsyncHttp.getInstance().cancelRequest(cancelCallback);
+            }
+
+            [RubyMethodAttribute("do_request", RubyMethodAttributes.PublicSingleton)]
+            public static MutableString doRequest(RubyModule/*!*/ self, [NotNull]String command, Hash args)
+            {
+                CAsyncHttp.Create();
+                RhoParams p = new RhoParams(args);
+                return CAsyncHttp.getInstance().addHttpCommand(new CAsyncHttp.HttpCommand(command, p));
+            }
+
+            #endregion
+        }
+    }
+}

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

@@ -0,0 +1,177 @@
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Collections.Generic;
+using rho.db;
+using rho.common;
+
+namespace rho.rubyext
+{
+    [RubyModule("SQLite3")]
+    public static class RhoSQLite3
+    {
+        [RubyClass("Database")]
+        public class RhoDatabase
+        {
+            static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+
+            DBAdapter m_db;
+            RhoDatabase() { }
+
+            #region Construction
+
+            [RubyConstructor]
+            public static RhoDatabase/*!*/ Create(RubyClass/*!*/ self, [NotNull]MutableString/*!*/ dbName, [NotNull]MutableString/*!*/ dbPartition)
+            {
+                RhoDatabase rbDB = new RhoDatabase();
+                rbDB.m_db = new DBAdapter();
+                rbDB.m_db.rb_open(dbName.ToString(), dbPartition.ToString());
+
+                return rbDB;
+            }
+
+            #endregion
+
+            #region Public Instance Methods
+
+            [RubyMethod("close")]
+            public static void Close(RhoDatabase/*!*/ self)
+            {
+                self.m_db.close();
+            }
+
+            [RubyMethod("commit")]
+            public static void Commit(RhoDatabase/*!*/ self)
+            {
+                self.m_db.commit();
+
+            }
+
+            [RubyMethod("destroy_tables")]
+            public static void destroyTables(RhoDatabase/*!*/ self, RubyArray arInclude, RubyArray arExclude)
+            {
+                Vector<String> vecIncludes = RhoRuby.makeVectorStringFromArray(arInclude);
+                Vector<String> vecExcludes = RhoRuby.makeVectorStringFromArray(arExclude);
+
+                self.m_db.rb_destroy_tables(vecIncludes, vecExcludes);
+
+                //throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+                //TODO: threw ruby exception
+
+            }
+
+            [RubyMethod("execute")]
+            public static RubyArray Execute(RhoDatabase/*!*/ self, MutableString/*!*/ sqlStatement, Boolean isBatch, RubyArray args)
+            {
+                try
+                {
+                    RubyArray retArr = new RubyArray();
+
+                    if (isBatch)
+                    {
+                        self.m_db.executeBatchSQL(sqlStatement.ToString());
+                    }
+                    else
+                    {
+                        Object[] values = null;
+                        if (args != null && args.Count > 0)
+                        {
+                            if (args[0] != null && args[0] is RubyArray)
+                                values = ((RubyArray)args[0]).ToArray();
+                            else
+                                values = args.ToArray();
+                        }
+
+                        try
+                        {
+                            self.m_db.Lock();
+                            using (IDBResult rows = self.m_db.executeSQL(sqlStatement.ToString(), values, true))
+                            {
+                                if (rows != null)
+                                {
+                                    MutableString[] colNames = null;
+                                    for (; !rows.isEnd(); rows.next())
+                                    {
+                                        IDictionary<object, object> map = new Dictionary<object, object>();
+                                        Hash row = new Hash(map);
+                                        for (int nCol = 0; nCol < rows.getColCount(); nCol++)
+                                        {
+                                            if (colNames == null)
+                                                colNames = getOrigColNames(rows);
+
+                                            row.Add(colNames[nCol], rows.getRubyValueByIdx(nCol));
+                                        }
+                                        retArr.Add(row);
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            self.m_db.Unlock();
+                        }
+                    }
+
+                    return retArr;
+                }catch (Exception exc)
+                {
+                    //TODO: throw ruby exception
+                    throw exc;
+                }
+            }
+
+            [RubyMethod("is_ui_waitfordb")]
+            public static Boolean isUiWaitForDb(RhoDatabase/*!*/ self)
+            {
+                return self.m_db.isUIWaitDB();
+            }
+
+            [RubyMethod("lock_db")]
+            public static void Lock(RhoDatabase/*!*/ self)
+            {
+                self.m_db.Lock();
+            }
+
+            [RubyMethod("rollback")]
+            public static void Rollback(RhoDatabase/*!*/ self)
+            {
+                self.m_db.rollback();
+            }
+
+            [RubyMethod("start_transaction")]
+            public static void startTransaction(RhoDatabase/*!*/ self)
+            {
+                self.m_db.startTransaction();
+            }
+
+            [RubyMethod("table_exist?")]
+            public static Boolean isTableExist(RhoDatabase/*!*/ self, MutableString/*!*/ tblName)
+            {
+                return self.m_db.isTableExist( tblName.ToString() );
+            }
+
+            [RubyMethod("unlock_db")]
+            public static void Unlock(RhoDatabase/*!*/ self)
+            {
+                self.m_db.Unlock();
+            }
+
+            #endregion
+
+            #region Helpers
+
+            private static MutableString[] getOrigColNames(IDBResult rows)
+            {
+                MutableString[] colNames = new MutableString[rows.getColCount()];
+                for (int nCol = 0; nCol < rows.getColCount(); nCol++)
+                    colNames[nCol] = MutableString.Create(rows.getOrigColName(nCol));
+
+                return colNames;
+            }
+
+            #endregion
+        }
+    }
+}