rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("RhoRubyLib")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RhoRuby")]
+[assembly: AssemblyCopyright("Copyright ©  2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("17e5f602-957a-4c26-9b4b-5b8a2bb3cd02")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

data/platform/wp7/RhoRubyLib/RhoAppAdapter.cs

@@ -0,0 +1,96 @@
+using System;
+using rho.net;
+using rho.common;
+
+namespace rho
+{
+    public class RhoAppAdapter
+    {
+        public static int ERR_NONE = 0;
+        public static int ERR_NETWORK = 1;
+        public static int ERR_REMOTESERVER = 2;
+        public static int ERR_RUNTIME = 3;
+        public static int ERR_UNEXPECTEDSERVERRESPONSE = 4;
+        public static int ERR_DIFFDOMAINSINSYNCSRC = 5;
+        public static int ERR_NOSERVERRESPONSE = 6;
+        public static int ERR_CLIENTISNOTLOGGEDIN = 7;
+        public static int ERR_CUSTOMSYNCSERVER = 8;
+        public static int ERR_UNATHORIZED = 9;
+        public static int ERR_CANCELBYUSER = 10;
+        public static int ERR_SYNCVERSION = 11;
+        public static int ERR_GEOLOCATION = 12;
+
+        /*	
+        public static final RubyID loadServerSources_mid = RubyID.intern("load_server_sources");
+        public static final RubyID loadAllSyncSources_mid = RubyID.intern("load_all_sync_sources");
+        public static final RubyID resetDBOnSyncUserChanged_mid = RubyID.intern("reset_db_on_sync_user_changed");
+	
+        static RubyClass m_classRhoError;
+        static RubyMethod m_RhoError_err_message;
+        static RubyClass m_classRhoMessages;
+        static RubyMethod m_RhoMessages_get_message;
+        */
+		
+        public static int getNetErrorCode(Exception exc)
+        {
+            if ( exc != null ) //instanceof IOException )
+            {
+                String strMsg = exc.Message; 
+			
+                return strMsg != null && (strMsg.indexOf("timed out") >= 0 || strMsg.indexOf("Timed out") >= 0)
+                    ? ERR_NOSERVERRESPONSE : ERR_NETWORK;	    	
+            }
+		
+            return ERR_NONE;
+        }
+
+        public static int getErrorCode(Exception exc)
+	    {
+		    return ERR_RUNTIME; 
+	    }
+	
+	    public static int  getErrorFromResponse(NetResponse resp)
+	    {
+	        if ( resp.isUnathorized() )
+	    	    return ERR_UNATHORIZED;
+
+	        if ( !resp.isOK() )
+	    	    return ERR_REMOTESERVER;
+
+	        return ERR_NONE;
+	    }
+
+	    public static String getErrorText(int nError)
+	    {
+/*		    if ( nError == ERR_NONE )
+			    return "";
+		
+		    if ( m_classRhoError == null )
+		    {
+			    RubyModule modRho = (RubyModule)RubyRuntime.ObjectClass.getConstant("Rho");
+			    m_classRhoError = (RubyClass)modRho.getConstant("RhoError");
+			    m_RhoError_err_message = m_classRhoError.findMethod( RubyID.intern("err_message") );
+		    }
+		
+		    RubyValue res = m_RhoError_err_message.invoke( m_classRhoError, ObjectFactory.createInteger(nError), null );
+		
+		    return res.toStr();*/
+            return "";
+	    }
+
+	    public static String getMessageText(String strName)
+	    {
+/*		    if ( m_classRhoMessages == null )
+		    {
+			    RubyModule modRho = (RubyModule)RubyRuntime.ObjectClass.getConstant("Rho");
+			    m_classRhoMessages = (RubyClass)modRho.getConstant("RhoMessages");
+			    m_RhoMessages_get_message = m_classRhoMessages.findMethod( RubyID.intern("get_message") );
+		    }
+		
+		    RubyValue res = m_RhoMessages_get_message.invoke( m_classRhoMessages, ObjectFactory.createString(strName), null );
+		
+		    return res.toStr();*/
+            return "";
+	    }
+    }
+}

data/platform/wp7/RhoRubyLib/RhoRuby.cs

@@ -0,0 +1,296 @@
+using System;
+using Microsoft.Scripting.Hosting;
+using Microsoft.Scripting;
+using IronRuby.Builtins;
+using IronRuby.Runtime;
+using IronRuby.Runtime.Calls;
+using System.Windows.Resources;
+using System.Windows;
+using System.IO;
+using Microsoft.Phone.Controls;
+using rho.common;
+using System.Collections.Generic;
+using rho.rubyext;
+
+namespace rho
+{
+    public class CRhoRuby
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+            new RhoLogger("CRhoRuby");
+
+        RhoConf RHOCONF() { return RhoConf.getInstance(); }
+
+        private static readonly CRhoRuby m_instance = new CRhoRuby();
+        public static CRhoRuby Instance { get { return m_instance; } }
+
+        private WebBrowser m_webBrowser;
+        private ScriptRuntime m_runtime;
+        private ScriptEngine m_engine;
+        RubyContext m_context;
+        private object m_rhoframework;
+
+        public WebBrowser WebBrowser{ get { return m_webBrowser; } }
+
+        public void Init(WebBrowser browser)
+        {
+            m_webBrowser = browser;
+            initRuby();
+            createRhoFramework();
+        }
+        
+        public class RhoHost : ScriptHost
+        {
+            private readonly PlatformAdaptationLayer/*!*/ _pal;
+
+            public RhoHost()
+            {
+                _pal = new WP_PlatformAdaptationLayer();
+            }
+
+            public override PlatformAdaptationLayer PlatformAdaptationLayer
+            {
+                get { return _pal; }
+            }
+        }
+
+        private void initRuby()
+        {
+            ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
+            var languageSetup = IronRuby.RubyHostingExtensions.AddRubySetup(runtimeSetup);
+
+            runtimeSetup.DebugMode = false;
+            runtimeSetup.PrivateBinding = false;
+            runtimeSetup.HostType = typeof(RhoHost);
+
+            languageSetup.Options["NoAdaptiveCompilation"] = false;
+            languageSetup.Options["CompilationThreshold"] = 0;
+            languageSetup.Options["Verbosity"] = 2;
+
+            m_runtime = IronRuby.Ruby.CreateRuntime(runtimeSetup);
+            m_engine = IronRuby.Ruby.GetEngine(m_runtime);
+            m_context = (RubyContext)Microsoft.Scripting.Hosting.Providers.HostingHelpers.GetLanguageContext(m_engine);
+
+            m_context.ObjectClass.SetConstant("RHO_WP7", 1);
+            m_context.ObjectClass.AddMethod(m_context, "__rhoGetCallbackObject", new RubyLibraryMethodInfo(
+                new[] { LibraryOverload.Create(new Func<System.Object, System.Int32, System.Object>(RhoKernelOps.__rhoGetCallbackObject), false, 0, 0) },
+                RubyMethodVisibility.Public,
+                m_context.ObjectClass
+            ));
+            m_context.Loader.LoadAssembly("RhoRubyLib", "rho.rubyext.rubyextLibraryInitializer", true, true);
+
+            System.Collections.ObjectModel.Collection<string> paths = new System.Collections.ObjectModel.Collection<string>();
+            paths.Add("lib");
+            paths.Add("apps/app");
+            m_engine.SetSearchPaths(paths);
+        }
+
+        private void createRhoFramework()
+        {
+            string code = "def foo; 'haha'; end; foo()";
+            //string code = "class MyClass; def initialize(arg1); end; end; MyClass.new('');";
+            //m_engine.Execute("class MyClass < Exception; def initialize(arg1); end; end; MyClass.new('');");
+            //m_engine.Execute("def test; while false; end; end; test();");
+            //m_engine.Execute("class RecordNotFound < StandardError;end; raise RecordNotFound;");
+            //m_engine.Execute("test = {}; test.__id__;");
+
+            StreamResourceInfo sr = Application.GetResourceStream(new Uri("lib/rhoframework.rb", UriKind.Relative));
+
+            using (System.IO.BinaryReader br = new BinaryReader(sr.Stream))
+            {
+                char[] str = br.ReadChars((int)sr.Stream.Length);
+                code = new string(str);
+            }
+
+            ScriptSource src = m_engine.CreateScriptSourceFromString(code);
+            if (src == null)
+                return;
+
+            m_rhoframework = src.Execute(m_engine.CreateScope());
+        }
+
+        public void InitApp()
+        {
+            if (m_rhoframework == null)
+                return;
+
+            m_engine.Operations.InvokeMember(m_rhoframework, "init_app");
+            m_engine.Operations.InvokeMember(m_rhoframework, "ui_created");
+        }
+
+        public void Stop()
+        {
+            m_runtime.Shutdown();
+        }
+
+        public Object callServeIndex(String indexPath, Object req)
+        {
+            m_context.ObjectClass.SetConstant("RHO__wp_index_path", indexPath);
+            m_context.ObjectClass.SetConstant("RHO__wp_headers", req);
+
+            return m_engine.Execute("RHO_FRAMEWORK.serve_index_hash(RHO__wp_index_path, RHO__wp_headers)");
+        }
+
+        public Object callServe(Object req)
+        {
+            m_context.ObjectClass.SetConstant("RHO__wp_headers", req);
+
+            return m_engine.Execute("RHO_FRAMEWORK.serve_hash(RHO__wp_headers)");
+        }
+
+        public byte[] getBytesFromString(Object body)
+        {
+            if (body != null && body.GetType() == typeof(MutableString))
+                return ((MutableString)body).ToByteArray();
+
+            return new byte[0];
+        }
+
+        public String getStringFromObject(Object body)
+        {
+            if (body != null && body.GetType() == typeof(MutableString))
+                return ((MutableString)body).ToString();
+
+            return String.Empty;
+        }
+
+        public object createString(String str)
+        {
+            return MutableString.Create(str);
+        }
+
+        public RubyArray createArray()
+        {
+            return new IronRuby.Builtins.RubyArray();
+        }
+
+        public Hash createHash()
+        {
+            return new Hash(m_context);
+        }
+
+        public void hashAdd(Object hash, Object key, Object value)
+        {
+            if (key is String)
+                key = createString(key as String);
+            if (value is String)
+                value = createString(value as String);
+
+            ((Hash)hash).Add(key, value);
+        }
+
+        public Object hashGet(Object hash, Object key)
+        {
+            return ((Hash)hash)[key];
+        }
+
+        public int hashGetInt(Object hash, Object key)
+        {
+            Object value = hashGet(hash, key);
+            if (value != null && value.GetType() == typeof(System.Int32))
+                return ((System.Int32)value);
+
+            return 0;
+        }
+
+        public String hashGetString(Object hash, Object key)
+        {
+            Object value = hashGet(hash, key);
+
+            if (value != null && value is MutableString)
+                return ((MutableString)value).ToString();
+
+            return String.Empty;
+        }
+
+        public Vector<String> makeVectorStringFromArray(RubyArray ar)
+        {
+            Vector<String> arRes = new Vector<String>();
+            for (int i = 0; ar != null && i < ar.Count; i++)
+            {
+                Object item = ar[i];
+                if (item != null && item is MutableString)
+                    arRes.Add( ((MutableString)item).ToString() );
+                else
+                    arRes.Add(String.Empty);
+            }
+
+            return arRes;
+        }
+
+        public String getRhoDBVersion()
+        {
+            String strVer = "";
+
+            object val = m_engine.Execute("Rhodes::DBVERSION");
+
+            if (val != null && val.GetType() == typeof(MutableString))
+                strVer = ((MutableString)val).ToString();
+		
+	        return strVer;        
+        }
+
+        public void call_config_conflicts()
+        {
+            //TODO: call_config_conflicts
+            /*RubyHash hashConflicts = RHOCONF().getRubyConflicts();
+            if (hashConflicts.size().toInt() == 0)
+                return;
+
+            m_engine.Operations.InvokeMember(m_rhoframework, "on_config_conflicts", hashConflicts);*/
+        }
+
+        public void raise_RhoError(int errCode)
+        {
+            m_engine.Operations.InvokeMember(m_rhoframework, "raise_rhoerror", errCode);
+        }
+
+        public void loadServerSources(String strData)
+        {
+            MutableString strParam = MutableString.Create(strData);
+            m_engine.Operations.InvokeMember(m_rhoframework, "load_server_sources", strParam);
+        }
+
+        public void loadAllSyncSources()
+        {
+            m_engine.Operations.InvokeMember(m_rhoframework, "load_all_sync_sources");
+        }
+
+        public void resetDBOnSyncUserChanged()
+        {
+            m_engine.Operations.InvokeMember(m_rhoframework, "reset_db_on_sync_user_changed");
+        }
+
+        public String getStartPage()
+        {
+            return RhoConf.getInstance().getString("start_path");
+        }
+
+        public String getOptionsPage()
+        {
+            return RhoConf.getInstance().getString("options_path");
+        }
+
+        public static MutableString create_string(String str)
+        {
+            return MutableString.Create(str);
+        }
+
+        public static Hashtable<String, String> enum_strhash(Object valHash)
+        {
+            Hashtable<String, String> hash = new Hashtable<String, String>();
+
+            if (valHash == null || valHash == null)
+                return hash;
+
+            Hash items = (Hash)valHash;
+
+            foreach (KeyValuePair<object, object> kvp in items)
+            {
+                hash.put(kvp.Key.ToString(), kvp.Value.ToString());
+            }
+
+            return hash;
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/RhoRubyLib.csproj

@@ -0,0 +1,155 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>10.0.20506</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{9CAF724B-1466-4A76-9251-5ADB132F636F}</ProjectGuid>
+    <ProjectTypeGuids>{C089C8C0-30E0-4E22-80C0-CE093F111A43};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>RhoRubyLib</RootNamespace>
+    <AssemblyName>RhoRubyLib</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <SilverlightVersion>$(TargetFrameworkVersion)</SilverlightVersion>
+    <TargetFrameworkProfile>WindowsPhone</TargetFrameworkProfile>
+    <TargetFrameworkIdentifier>Silverlight</TargetFrameworkIdentifier>
+    <SilverlightApplication>false</SilverlightApplication>
+    <ValidateXaml>true</ValidateXaml>
+    <ThrowErrorsInValidation>true</ThrowErrorsInValidation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\bin\$(RootNamespace)\$(Configuration)</OutputPath>
+    <BaseIntermediateOutputPath>..\bin\$(RootNamespace)</BaseIntermediateOutputPath>
+    <IntermediateOutputPath>..\bin\$(RootNamespace)\$(Configuration)</IntermediateOutputPath>
+    <DefineConstants>TRACE;DEBUG;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\bin\$(RootNamespace)\$(Configuration)</OutputPath>
+    <BaseIntermediateOutputPath>..\bin\$(RootNamespace)</BaseIntermediateOutputPath>
+    <IntermediateOutputPath>..\bin\$(RootNamespace)\$(Configuration)</IntermediateOutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="IronRuby">
+      <HintPath>..\..\..\..\ironruby\bin\Silverlight3$(Configuration)\IronRuby.dll</HintPath>
+    </Reference>
+    <Reference Include="IronRuby.Libraries">
+      <HintPath>..\..\..\..\ironruby\bin\Silverlight3$(Configuration)\IronRuby.Libraries.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Phone" />
+    <Reference Include="Microsoft.Phone.Interop" />
+    <Reference Include="Microsoft.Scripting">
+      <HintPath>..\..\..\..\ironruby\bin\Silverlight3$(Configuration)\Microsoft.Scripting.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Scripting.Core">
+      <HintPath>..\..\..\..\ironruby\bin\Silverlight3$(Configuration)\Microsoft.Scripting.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Dynamic">
+      <HintPath>..\..\..\..\ironruby\bin\Silverlight3$(Configuration)\Microsoft.Dynamic.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Windows" />
+    <Reference Include="system" />
+    <Reference Include="system.Core" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Net" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="common\IInputStream.cs" />
+    <Compile Include="common\RhoParamArray.cs" />
+    <Compile Include="common\RhoParams.cs" />
+    <Compile Include="common\TimeInterval.cs" />
+    <Compile Include="common\RhoEmptyProfiler.cs" />
+    <Compile Include="common\RhoProfiler.cs" />
+    <Compile Include="db\SqliteCopyResult.cs" />
+    <Compile Include="json\JsonParser.cs" />
+    <Compile Include="json\RJSONTokener.cs" />
+    <Compile Include="net\AsyncHttp.cs" />
+    <Compile Include="RhoAppAdapter.cs" />
+    <Compile Include="common\Mutex.cs" />
+    <Compile Include="common\RhoThread.cs" />
+    <Compile Include="common\ThreadQueue.cs" />
+    <Compile Include="db\SqliteResult.cs" />
+    <Compile Include="logging\RhoLogFileSink.cs" />
+    <Compile Include="logging\IRhoLogSink.cs" />
+    <Compile Include="logging\RhoLogConf.cs" />
+    <Compile Include="common\RhoConf.cs" />
+    <Compile Include="common\RhodesApp.cs" />
+    <Compile Include="common\RhoFile.cs" />
+    <Compile Include="common\RhoFilePath.cs" />
+    <Compile Include="logging\RhoLogger.cs" />
+    <Compile Include="common\RhoResourceMap.cs" />
+    <Compile Include="common\RhoStd.cs" />
+    <Compile Include="common\Tokenizer.cs" />
+    <Compile Include="db\DBAdapter.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="db\DBAttrManager.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="db\DBException.cs" />
+    <Compile Include="db\IDBCallback.cs" />
+    <Compile Include="db\IDBResult.cs" />
+    <Compile Include="db\IDBStorage.cs" />
+    <Compile Include="db\SqliteStorage.cs" />
+    <Compile Include="Initializers.Generated.cs" />
+    <Compile Include="net\NetResponse.cs" />
+    <Compile Include="net\URI.cs" />
+    <Compile Include="net\NetRequest.cs" />
+    <Compile Include="net\HttpServer.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="rubyext\RhoAsyncHttp.cs" />
+    <Compile Include="rubyext\RhoDatabase.cs" />
+    <Compile Include="RhoRuby.cs" />
+    <Compile Include="rubyext\RhoJSON.cs" />
+    <Compile Include="rubyext\RhoKernelOps.cs" />
+    <Compile Include="rubyext\RhoNativeBar.cs" />
+    <Compile Include="rubyext\RhoSyncEngine.cs" />
+    <Compile Include="rubyext\RhoWebView.cs" />
+    <Compile Include="json\JSONStructIterator.cs" />
+    <Compile Include="json\JSONArrayIterator.cs" />
+    <Compile Include="json\JSONEntry.cs" />
+    <Compile Include="sync\SyncSource.cs" />
+    <Compile Include="sync\SyncProtocol_3.cs" />
+    <Compile Include="sync\ISyncProtocol.cs" />
+    <Compile Include="sync\SyncEngine.cs" />
+    <Compile Include="sync\SyncNotify.cs" />
+    <Compile Include="sync\ClientRegister.cs" />
+    <Compile Include="sync\ISyncStatusListener.cs" />
+    <Compile Include="sync\SyncThread.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="WP_PlatformAdaptationLayer.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\sqlite3\sqlite3.csproj">
+      <Project>{527EEB7D-2879-498D-90AE-05C97D0A0B0F}</Project>
+      <Name>sqlite3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.$(TargetFrameworkProfile).Overrides.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight for Phone\$(TargetFrameworkVersion)\Microsoft.Silverlight.CSharp.targets" />
+  <ProjectExtensions />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>