private static void LoadMyIronRubyModule__MyClass_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "foo_bar?", 0x11, 
         0x00000000U, 
         new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Boolean>(AppendixB.MyModule.TheLandOfChocolate.IsFooBar)
     );
     
 }
Пример #2
0
 private static void LoadIronRuby__Builtins__MutableString_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "json_create", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.IntegerValue>, IronRuby.Builtins.RubyClass, IronRuby.Builtins.Hash, IronRuby.Builtins.MutableString>(IronRuby.JsonExt.MutableStringOps.JsonCreate)
     );
     
 }
Пример #3
0
 private static void LoadIronRuby__Builtins__Hash_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "to_json", 0x11, 
         0x00000000U, 
         new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Builtins.Hash, IronRuby.JsonExt.GeneratorState, System.Int32, IronRuby.Builtins.MutableString>(IronRuby.JsonExt.HashOps.ToJson)
     );
     
 }
Пример #4
0
 private static void LoadIronRuby__Builtins__FalseClass_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "to_json", 0x11, 
         0x00000000U, 
         new Func<System.Boolean, IronRuby.JsonExt.GeneratorState, System.Int32, IronRuby.Builtins.MutableString>(IronRuby.JsonExt.FalseOps.ToJson)
     );
     
 }
Пример #5
0
 private static void LoadAlert_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "hide_popup", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoAlert.HidePopup)
     );
     
     DefineLibraryMethod(module, "play_file", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.String>(rho.rubyext.RhoAlert.PlayFile)
     );
     
     DefineLibraryMethod(module, "show_popup", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, IronRuby.Builtins.Hash>(rho.rubyext.RhoAlert.ShowPopup)
     );
     
     DefineLibraryMethod(module, "show_status", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.String, System.String>(rho.rubyext.RhoAlert.ShowStatus)
     );
     
     DefineLibraryMethod(module, "vibrate", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoAlert.Vibrate)
     );
     
 }
Пример #6
0
        public override void Compile(Compiler compiler, IronRuby.Compiler.Ast.Node node, NodeParent parent)
        {
            var sae = (SimpleAssignmentExpression)node;

            // substitute a method call of []= rather than the crap that ironruby's parser produces:
            switch (sae.Left.NodeType)
            {
                case NodeTypes.ArrayItemAccess:
                    var aia = (ArrayItemAccess)sae.Left;
                    compiler.CompileNode(new MethodCall(aia.Array, "[]=", new Arguments(aia.Arguments.Expressions.Concat(new[] { sae.Right }).ToArray()), sae.Location), parent.CreateChild(node));
                    return;
                case NodeTypes.AttributeAccess:
                    var aa = (AttributeAccess)sae.Left;
                    compiler.CompileNode(new MethodCall(aa.Qualifier, aa.Name, new Arguments(sae.Right), aa.Location), parent.CreateChild(node));
                    return;
            }

            compiler.CompileNode(sae.Right, parent.CreateChild(node));
            if (sae.Operation != null)
            {
                compiler.AppendLine("$_stack[] = {0};", assignmentVar(sae.Left, parent));
                compiler.AppendLine("$_stack[] = array_pop($_stack)->{0}(NULL, array_pop($_stack));", Mangling.RubyMethodToPHP(sae.Operation));
            }
            compiler.AppendLine("{0} = $_stack[count($_stack)-1];", assignmentVar(sae.Left, parent));
        }
 private static void LoadMyIronRubyModule_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "Foo", 0x11, 
         0x00000000U, 
         new Action<System.Object>(AppendixB.MyModule.Foo)
     );
     
 }
 private static void OompaLoompa_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "make_chocolate", 0x11, 
         new Func<IronRuby.Builtins.RubyClass, System.String, System.String, Chapter12.TheLandOfChocolate.Chocolate>(Chapter12.TheLandOfChocolate.OompaLoompa.MakeChocolate)
     );
     
     DefineLibraryMethod(module, "make_peppermint_chocolate", 0x11, 
         new Func<IronRuby.Builtins.RubyClass, System.String, Chapter12.TheLandOfChocolate.Chocolate>(Chapter12.TheLandOfChocolate.OompaLoompa.MakePepermintChocolate)
     );
     
 }
Пример #9
0
 private static void LoadIronRuby__Builtins__FalseClass_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlFalseOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x11, 
         new System.Func<System.Object, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlFalseOps.ToYaml)
     );
     
 }
Пример #10
0
 private static void LoadIronRuby__Builtins__Hash_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlHashOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x12, 
         new System.Func<IronRuby.Builtins.Hash, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlHashOps.ToYamlNode)
     );
     
 }
Пример #11
0
 private static void LoadIronRuby__Builtins__Integer_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlIntegerOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x12, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, System.Object, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlIntegerOps.ToYaml)
     );
     
 }
Пример #12
0
 private void LoadIronRuby__Builtins__Integer_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     
     module.DefineLibraryMethod("taguri", 0x11, new System.Delegate[] {
         new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlIntegerOps.TagUri),
     });
     
     module.DefineLibraryMethod("to_yaml_node", 0x11, new System.Delegate[] {
         new System.Func<System.Object, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlIntegerOps.ToYaml),
     });
     
 }
Пример #13
0
 private static void LoadCamera_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "choose_picture", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoCamera.choosePicture)
     );
     
     DefineLibraryMethod(module, "take_picture", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoCamera.takePicture)
     );
     
 }
Пример #14
0
 private static void LoadIronRuby__Builtins__FalseClass_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "taguri", 0x11, 
         0x00000000U, 
         new Func<System.Boolean, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlFalseOps.TagUri)
     );
     
     DefineLibraryMethod(module, "to_yaml_node", 0x12, 
         0x00000004U, 
         new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, System.Boolean, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlFalseOps.ToYaml)
     );
     
 }
Пример #15
0
        public void Render()
        {
            var         scriptEngine = IronRuby.GetEngine(_scriptRuntime);
            ScriptScope scope        = scriptEngine.CreateScope();

            scope.SetVariable("output_buffer", _output);

            TemplateParser = new RubyTemplateParser(ViewSource);
            TemplateParser.AddRequire("System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");

            StringBuilder script      = new StringBuilder();
            var           methodNames = new Stack <string>();

            BuildScript(script, methodNames);
            var methodsCounter = methodNames.Count;

            while (methodNames.Count > 0)
            {
                script.Append(methodNames.Pop());
                if (methodNames.Count > 0)
                {
                    script.Append(" { ");
                }
            }
            if (methodsCounter > 1)
            {
                script.Append(new String('}', methodsCounter - 1));
            }
            script.AppendLine();

            try
            {
                Debug.WriteLine(script.ToString());
                ScriptSource source = scriptEngine.CreateScriptSourceFromString(script.ToString());
                source.Execute(scope);
            }
            catch (Exception e)
            {
                throw new MonoRailException(script.ToString(), e);
            }
            finally
            {
                // TODO : check if remove variable isnt faster.
                scope.ClearVariables();
                scriptEngine.Shutdown();
            }
        }
Пример #16
0
 private static void LoadIronRuby__Builtins__MutableString_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "to_json", 0x11, 
         0x00000000U, 
         new Func<IronRuby.Builtins.MutableString, IronRuby.JsonExt.GeneratorState, System.Int32, IronRuby.Builtins.MutableString>(IronRuby.JsonExt.MutableStringOps.ToJson)
     );
     
     DefineLibraryMethod(module, "to_json_raw", 0x11, 
         0x00000000U, 
         new Func<IronRuby.Runtime.RubyScope, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString>(IronRuby.JsonExt.MutableStringOps.ToJsonRaw)
     );
     
     DefineLibraryMethod(module, "to_json_raw_object", 0x11, 
         0x00000000U, 
         new Func<IronRuby.Runtime.RubyScope, IronRuby.Builtins.MutableString, IronRuby.Builtins.Hash>(IronRuby.JsonExt.MutableStringOps.ToJsonRawObject)
     );
     
 }
Пример #17
0
 private static void LoadIronRuby__Builtins__MutableString_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("is_binary_data?", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.MutableString, System.Object>(IronRuby.StandardLibrary.Yaml.YamlStringOps.IsBinaryData)
     );
     
     module.DefineLibraryMethod("is_complex_yaml?", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.MutableString, System.Boolean>(IronRuby.StandardLibrary.Yaml.YamlStringOps.IsComplexYaml)
     );
     
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlStringOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x11, 
         new System.Func<IronRuby.Builtins.MutableString, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlStringOps.ToYamlNode)
     );
     
 }
 private static void LoadTheLandOfChocolate__Chocolate_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "dark?", 0x11, 
         new Func<Chapter12.TheLandOfChocolate.Chocolate, System.Boolean>(Chapter12.TheLandOfChocolate.Chocolate.IsDark)
     );
     
     DefineLibraryMethod(module, "eat!", 0x11, 
         new Action<Chapter12.TheLandOfChocolate.Chocolate>(Chapter12.TheLandOfChocolate.Chocolate.Eat)
     );
     
     DefineLibraryMethod(module, "milk?", 0x11, 
         new Func<Chapter12.TheLandOfChocolate.Chocolate, System.Boolean>(Chapter12.TheLandOfChocolate.Chocolate.IsMilk)
     );
     
     DefineLibraryMethod(module, "white?", 0x11, 
         new Func<Chapter12.TheLandOfChocolate.Chocolate, System.Boolean>(Chapter12.TheLandOfChocolate.Chocolate.IsWhite)
     );
     
 }
Пример #19
0
 private static void LoadHpricot_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "buffer_size", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Nullable<System.Int32>>(IronRuby.Hpricot.Hpricot.GetBufferSize)
     );
     
     DefineLibraryMethod(module, "buffer_size=", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(IronRuby.Hpricot.Hpricot.SetBufferSize)
     );
     
     DefineLibraryMethod(module, "css", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object>(IronRuby.Hpricot.Hpricot.Css)
     );
     
     DefineLibraryMethod(module, "scan", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, IronRuby.Builtins.Hash, System.Object>(IronRuby.Hpricot.Hpricot.Scan)
     );
     
 }
Пример #20
0
 private static void LoadNativeBar_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "create", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.Object>(rho.rubyext.RhoNativeBar.Create)
     );
     
     DefineLibraryMethod(module, "create_native_tabbar", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.Object>(rho.rubyext.RhoNativeBar.createNativeTabBar)
     );
     
     DefineLibraryMethod(module, "create_native_toolbar", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.Object>(rho.rubyext.RhoNativeBar.createNativeToolBar)
     );
     
     DefineLibraryMethod(module, "native_tabbar_get_current_tab", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoNativeBar.nativeTabBarGetCurrentTab)
     );
     
     DefineLibraryMethod(module, "native_tabbar_set_tab_badge", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, IronRuby.Builtins.MutableString>(rho.rubyext.RhoNativeBar.nativeTabBarSetTabBadge)
     );
     
     DefineLibraryMethod(module, "native_tabbar_switch_tab", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoNativeBar.nativeTabBarSwitchTab)
     );
     
     DefineLibraryMethod(module, "remove", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoNativeBar.Remove)
     );
     
     DefineLibraryMethod(module, "remove_native_tabbar", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoNativeBar.removeNativeTabBar)
     );
     
     DefineLibraryMethod(module, "remove_native_toolbar", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoNativeBar.removeNativeToolBar)
     );
     
     DefineLibraryMethod(module, "set_tab_badge", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, IronRuby.Builtins.MutableString>(rho.rubyext.RhoNativeBar.setTabBadge)
     );
     
     DefineLibraryMethod(module, "started", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoNativeBar.isStarted)
     );
     
     DefineLibraryMethod(module, "switch_tab", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoNativeBar.switchTab)
     );
     
 }
Пример #21
0
 private static void LoadWebView_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "current_location", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoWebView.currentLocation)
     );
     
     DefineLibraryMethod(module, "execute_js", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.Int32>(rho.rubyext.RhoWebView.execute_js)
     );
     
     DefineLibraryMethod(module, "navigate", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.Int32>(rho.rubyext.RhoWebView.Navigate)
     );
     
     DefineLibraryMethod(module, "refresh", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoWebView.Refresh)
     );
     
     DefineLibraryMethod(module, "set_menu_items", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, IronRuby.Builtins.Hash>(rho.rubyext.RhoWebView.setMenuItems)
     );
     
 }
Пример #22
0
 private static void LoadSystem_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "app_install", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.app_install)
     );
     
     DefineLibraryMethod(module, "app_installed?", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Boolean>(rho.rubyext.RhoSystem.is_app_installed)
     );
     
     DefineLibraryMethod(module, "app_uninstall", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.app_uninstall)
     );
     
     DefineLibraryMethod(module, "exit", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoSystem.exit)
     );
     
     DefineLibraryMethod(module, "get_locale", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.get_locale)
     );
     
     DefineLibraryMethod(module, "get_property", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Object>(rho.rubyext.RhoSystem.get_property_by_name)
     );
     
     DefineLibraryMethod(module, "get_screen_height", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoSystem.get_screen_height)
     );
     
     DefineLibraryMethod(module, "get_screen_width", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoSystem.get_screen_width)
     );
     
     DefineLibraryMethod(module, "get_start_params", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.String>(rho.rubyext.RhoSystem.get_start_params)
     );
     
     DefineLibraryMethod(module, "has_network", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoSystem.has_network)
     );
     
     DefineLibraryMethod(module, "open_url", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.open_url)
     );
     
     DefineLibraryMethod(module, "run_app", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.String>(rho.rubyext.RhoSystem.run_app)
     );
     
     DefineLibraryMethod(module, "set_push_notification", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.String>(rho.rubyext.RhoSystem.set_push_notification)
     );
     
     DefineLibraryMethod(module, "set_screen_rotation_notification", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.String>(rho.rubyext.RhoSystem.set_screen_rotation_notification)
     );
     
     DefineLibraryMethod(module, "set_sleeping", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoSystem.set_sleeping)
     );
     
     DefineLibraryMethod(module, "start_timer", 0x21, 
         0x00000004U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.String, System.String>(rho.rubyext.RhoSystem.start_timer)
     );
     
     DefineLibraryMethod(module, "stop_timer", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.stop_timer)
     );
     
     DefineLibraryMethod(module, "unzip_file", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSystem.unzip_file)
     );
     
 }
Пример #23
0
 private static void LoadSyncEngine_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "add_objectnotify", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.String>(rho.rubyext.RhoSyncEngine.add_objectnotify)
     );
     
     DefineLibraryMethod(module, "clean_objectnotify", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoSyncEngine.clean_objectnotify)
     );
     
     DefineLibraryMethod(module, "dosearch", 0x21, 
         0x000000feU, 
         new Func<IronRuby.Builtins.RubyModule, IronRuby.Builtins.RubyArray, System.String, System.String, System.Boolean, System.Int32, System.String, System.String, System.Object>(rho.rubyext.RhoSyncEngine.dosearch)
     );
     
     DefineLibraryMethod(module, "dosync", 0x21, 
         0x00000000U, 0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Object>(rho.rubyext.RhoSyncEngine.dosync), 
         new Func<IronRuby.Builtins.RubyModule, System.Boolean, System.Object>(rho.rubyext.RhoSyncEngine.dosync)
     );
     
     DefineLibraryMethod(module, "dosync_source", 0x21, 
         0x00000002U, 0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.Object, System.Object>(rho.rubyext.RhoSyncEngine.dosync_source), 
         new Func<IronRuby.Builtins.RubyModule, System.Object, System.Boolean, System.Object>(rho.rubyext.RhoSyncEngine.dosync_source)
     );
     
     DefineLibraryMethod(module, "enable_status_popup", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoSyncEngine.enable_status_popup)
     );
     
     DefineLibraryMethod(module, "is_blob_attr", 0x21, 
         0x0000000eU, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Int32, System.String, System.Boolean>(rho.rubyext.RhoSyncEngine.is_blob_attr)
     );
     
     DefineLibraryMethod(module, "is_syncing", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoSyncEngine.is_syncing)
     );
     
     DefineLibraryMethod(module, "logged_in", 0x21, 
         0x00000000U, 
         new Func<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoSyncEngine.logged_in)
     );
     
     DefineLibraryMethod(module, "login", 0x21, 
         0x0000000eU, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.String, System.String, System.Object>(rho.rubyext.RhoSyncEngine.login)
     );
     
     DefineLibraryMethod(module, "logout", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoSyncEngine.logout)
     );
     
     DefineLibraryMethod(module, "set_notification", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.String, System.String>(rho.rubyext.RhoSyncEngine.set_notification)
     );
     
     DefineLibraryMethod(module, "set_objectnotify_url", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSyncEngine.set_objectnotify_url)
     );
     
     DefineLibraryMethod(module, "set_pollinterval", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.Int32, System.Int32>(rho.rubyext.RhoSyncEngine.set_pollinterval)
     );
     
     DefineLibraryMethod(module, "set_source_property", 0x21, 
         0x0000000eU, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32, System.String, System.String>(rho.rubyext.RhoSyncEngine.set_source_property)
     );
     
     DefineLibraryMethod(module, "set_syncserver", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoSyncEngine.set_syncserver)
     );
     
     DefineLibraryMethod(module, "set_threaded_mode", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.Boolean>(rho.rubyext.RhoSyncEngine.set_threaded_mode)
     );
     
     DefineLibraryMethod(module, "stop_sync", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoSyncEngine.stop_sync)
     );
     
     DefineLibraryMethod(module, "update_blob_attribs", 0x21, 
         0x00000006U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.Int32>(rho.rubyext.RhoSyncEngine.update_blob_attribs)
     );
     
 }
Пример #24
0
 private static void LoadSQLite3__Database_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "close", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.Close)
     );
     
     DefineLibraryMethod(module, "commit", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.Commit)
     );
     
     DefineLibraryMethod(module, "destroy_tables", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase, IronRuby.Builtins.RubyArray, IronRuby.Builtins.RubyArray>(rho.rubyext.RhoSQLite3.RhoDatabase.destroyTables)
     );
     
     DefineLibraryMethod(module, "execute", 0x11, 
         0x00000000U, 
         new Func<rho.rubyext.RhoSQLite3.RhoDatabase, IronRuby.Builtins.MutableString, System.Boolean, IronRuby.Builtins.RubyArray, IronRuby.Builtins.RubyArray>(rho.rubyext.RhoSQLite3.RhoDatabase.Execute)
     );
     
     DefineLibraryMethod(module, "is_ui_waitfordb", 0x11, 
         0x00000000U, 
         new Func<rho.rubyext.RhoSQLite3.RhoDatabase, System.Boolean>(rho.rubyext.RhoSQLite3.RhoDatabase.isUiWaitForDb)
     );
     
     DefineLibraryMethod(module, "lock_db", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.Lock)
     );
     
     DefineLibraryMethod(module, "rollback", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.Rollback)
     );
     
     DefineLibraryMethod(module, "start_transaction", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.startTransaction)
     );
     
     DefineLibraryMethod(module, "table_exist?", 0x11, 
         0x00000000U, 
         new Func<rho.rubyext.RhoSQLite3.RhoDatabase, IronRuby.Builtins.MutableString, System.Boolean>(rho.rubyext.RhoSQLite3.RhoDatabase.isTableExist)
     );
     
     DefineLibraryMethod(module, "unlock_db", 0x11, 
         0x00000000U, 
         new Action<rho.rubyext.RhoSQLite3.RhoDatabase>(rho.rubyext.RhoSQLite3.RhoDatabase.Unlock)
     );
     
 }
Пример #25
0
 private static void LoadRhoConf_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "clean_log", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoConfig.clean_log)
     );
     
     DefineLibraryMethod(module, "get_property_by_name", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Object>(rho.rubyext.RhoConfig.get_property_by_name)
     );
     
     DefineLibraryMethod(module, "is_property_exists", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Boolean>(rho.rubyext.RhoConfig.is_property_exists)
     );
     
     DefineLibraryMethod(module, "read_log", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.Int32>(rho.rubyext.RhoConfig.read_log)
     );
     
     DefineLibraryMethod(module, "send_log", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoConfig.send_log)
     );
     
     DefineLibraryMethod(module, "set_property_by_name", 0x21, 
         0x00000002U, 
         new Action<IronRuby.Builtins.RubyModule, System.String, System.Object>(rho.rubyext.RhoConfig.set_property_by_name)
     );
     
     DefineLibraryMethod(module, "show_log", 0x21, 
         0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoConfig.show_log)
     );
     
 }
Пример #26
0
 private static void LoadRho__JSON_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "parse", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Object>(rho.rubyext.Rho.RhoJSON.parse)
     );
     
     DefineLibraryMethod(module, "quote_value", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, System.Object>(rho.rubyext.Rho.RhoJSON.quote_value)
     );
     
 }
Пример #27
0
 private static void LoadRho__AsyncHttp_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     DefineLibraryMethod(module, "cancel", 0x21, 
         0x00000002U, 0x00000000U, 
         new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoRoot.RhoAsyncHttp.Cancel), 
         new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoRoot.RhoAsyncHttp.Cancel)
     );
     
     DefineLibraryMethod(module, "do_request", 0x21, 
         0x00000002U, 
         new Func<IronRuby.Builtins.RubyModule, System.String, IronRuby.Builtins.Hash, IronRuby.Builtins.MutableString>(rho.rubyext.RhoRoot.RhoAsyncHttp.doRequest)
     );
     
 }
Пример #28
0
 public RubyViewEngine()
 {
     _scriptRuntime = IronRuby.CreateRuntime();
 }
Пример #29
0
 private static void LoadYAML__Stream_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("[]", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Int32, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.GetDocument)
     );
     
     module.DefineLibraryMethod("add", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.Add)
     );
     
     module.DefineLibraryMethod("documents", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.GetDocuments)
     );
     
     module.DefineLibraryMethod("documents=", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.RubyArray, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.SetDocuments)
     );
     
     module.DefineLibraryMethod("edit", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Int32, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.EditDocument)
     );
     
     module.DefineLibraryMethod("emit", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.RubyIO, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.Emit)
     );
     
     module.DefineLibraryMethod("inspect", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.Inspect)
     );
     
     module.DefineLibraryMethod("options", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.Hash>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.GetOptions)
     );
     
     module.DefineLibraryMethod("options=", 0x11, 
         new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, IronRuby.Builtins.Hash, IronRuby.Builtins.Hash>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.SetOptions)
     );
     
 }
Пример #30
0
 private static void LoadYAML_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("add_domain_type", 0x21, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.AddDomainType), 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyRegex, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.AddDomainType)
     );
     
     module.DefineLibraryMethod("dump", 0x21, 
         new System.Func<IronRuby.Builtins.RubyModule, System.Object, IronRuby.Builtins.RubyIO, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.Dump)
     );
     
     module.DefineLibraryMethod("dump_all", 0x21, 
         new System.Func<IronRuby.Builtins.RubyModule, System.Collections.IEnumerable, IronRuby.Builtins.RubyIO, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.DumpAll)
     );
     
     module.DefineLibraryMethod("dump_stream", 0x21, 
         new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, System.Object[], System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.DumpStream)
     );
     
     module.DefineLibraryMethod("each_document", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.RubyScope, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.EachDocument)
     );
     
     module.DefineLibraryMethod("each_node", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.ParseDocuments)
     );
     
     module.DefineLibraryMethod("load", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.Load)
     );
     
     module.DefineLibraryMethod("load_documents", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.RubyScope, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.EachDocument)
     );
     
     module.DefineLibraryMethod("load_file", 0x21, 
         new System.Func<IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.LoadFile)
     );
     
     module.DefineLibraryMethod("load_stream", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.LoadStream)
     );
     
     module.DefineLibraryMethod("parse", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.Parse)
     );
     
     module.DefineLibraryMethod("parse_documents", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.RespondToStorage, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.ParseDocuments)
     );
     
     module.DefineLibraryMethod("parse_file", 0x21, 
         new System.Func<IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.ParseFile)
     );
     
     module.DefineLibraryMethod("quick_emit", 0x21, 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, IronRuby.Builtins.Hash, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.QuickEmit), 
         new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.RubyYaml.QuickEmit)
     );
     
     module.DefineLibraryMethod("quick_emit_node", 0x21, 
         new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyModule, System.Object, System.Object[], System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.QuickEmitNode)
     );
     
     module.DefineLibraryMethod("tag_class", 0x21, 
         new System.Func<IronRuby.Builtins.RubyModule, System.Object, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.TagClass)
     );
     
     module.DefineLibraryMethod("tagged_classes", 0x21, 
         new System.Func<IronRuby.Builtins.RubyModule, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.GetTaggedClasses)
     );
     
     module.DefineLibraryMethod("tagurize", 0x21, 
         new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Builtins.RubyModule, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.Tagurize)
     );
     
 }
Пример #31
0
 private static void LoadSystem__Object_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlObjectOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object[], System.Object>(IronRuby.StandardLibrary.Yaml.YamlObjectOps.ToYaml)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x12, 
         new System.Func<System.Object, IronRuby.StandardLibrary.Yaml.RubyRepresenter, System.Object>(IronRuby.StandardLibrary.Yaml.YamlObjectOps.ToYamlProperties)
     );
     
     module.DefineLibraryMethod("to_yaml_properties", 0x11, 
         new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.YamlObjectOps.ToYamlProperties)
     );
     
     module.DefineLibraryMethod("to_yaml_style", 0x11, 
         new System.Func<System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.YamlObjectOps.ToYamlStyle)
     );
     
 }
Пример #32
0
 private static void LoadSystem__Exception_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
     module.DefineLibraryMethod("taguri", 0x11, 
         new System.Func<IronRuby.Runtime.RubyContext, System.Object, IronRuby.Builtins.MutableString>(IronRuby.StandardLibrary.Yaml.YamlExceptionOps.TagUri)
     );
     
     module.DefineLibraryMethod("to_yaml_node", 0x12, 
         new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, System.Exception, System.Object>>, System.Exception, IronRuby.StandardLibrary.Yaml.RubyRepresenter, IronRuby.StandardLibrary.Yaml.Node>(IronRuby.StandardLibrary.Yaml.YamlExceptionOps.ToYamlNode)
     );
     
 }