示例#1
0
        /// <summary>
        /// ランタイムのグローバルスコープから現在のクラス定義を取得する。
        /// </summary>
        /// <param name="runtime">ScriptRuntimeのインスタンス。</param>
        /// <param name="engine">ScriptEngineのインスタンス。</param>
        /// <returns>クラス定義の一覧。</returns>
        public static List<RubyDefinition> GetDefinitions(RubyHost scriptHost)
        {
            var ret = new List<RubyDefinition>();

            foreach (var obj in scriptHost.Runtime.Globals.GetItems())
            {
                ret.Add(RubyDefinition.Create(scriptHost, obj.Key, obj.Key, obj.Value));
            }

            // 結果のソート
            ret.Sort((a, b) => {
                string aName;
                string bName;

                if (a is RubyObjectDefinition)
                {
                    aName = ((RubyObjectDefinition)a).FullName;
                }
                else
                {
                    aName = a.Name;
                }

                if (b is RubyObjectDefinition)
                {
                    bName = ((RubyObjectDefinition)b).FullName;
                }
                else
                {
                    bName = b.Name;
                }

                return String.Compare(aName, bName);
            });

            return ret;
        }
示例#2
0
        /// <summary>
        /// Ruby定義情報を作成する。
        /// </summary>
        /// <param name="engine">ScriptEngineのインスタンス。</param>
        /// <param name="fullName">オブジェクトのフル名称。</param>
        /// <param name="name">オブジェクトの名称。</param>
        /// <param name="constant">作成元のRubyオブジェクト。</param>
        /// <returns>Ruby定義情報のインスタンス。</returns>
        private static RubyDefinition Create(
            RubyHost scriptHost,
            string fullName,
            string name,
            dynamic constant)
        {
            RubyDefinition definition;

            if (constant is RubyModule)
            {
                // モジュールもしくはクラス
                var moduleConstant = (RubyModule)constant;

                if (constant is RubyClass)
                {
                    // クラス
                    var classDefinition = new RubyClassDefinition();
                    definition = classDefinition;

                    RubyClass superClass = constant.SuperClass;
                    if (superClass != null)
                    {
                        classDefinition.SuperClassName = superClass.Name;
                    }
                }
                else
                {
                    // モジュール
                    var moduleDefinition = new RubyModuleDefinition();
                    definition = moduleDefinition;
                }
                RubyObjectDefinition objectDefinition = (RubyObjectDefinition)definition;
                objectDefinition.FullName = fullName;

                // 定数・クラスを走査
                foreach (RubySymbol childSymbol in constant.constants())
                {
                    var childName = childSymbol.String.ToString();
                    var childFullName = String.Format("{0}::{1}", fullName, childName);

                    var childConstant = scriptHost.Engine.Execute(String.Format("{0}", childFullName));
                    var childDefinition = RubyDefinition.Create(scriptHost, childFullName, childName, childConstant);

                    if (childDefinition is RubyObjectDefinition)
                    {
                        objectDefinition.Children.Add(childDefinition);
                    }
                    else if (childDefinition is RubyConstantDefinition)
                    {
                        objectDefinition.Constants.Add(childDefinition);
                    }
                }

                // シングルトンメソッドを取得
                GetMethodDefinitions(moduleConstant.GetOrCreateSingletonClass(),  RubyMethodAttributes.Singleton, objectDefinition, true);

                // インスタンスメソッドを取得
                GetMethodDefinitions(moduleConstant, RubyMethodAttributes.Instance, objectDefinition, false);

                // 各要素のソート
                objectDefinition.Children.Sort((a, b) => { return String.Compare(a.FullName, b.FullName); });
                objectDefinition.Constants.Sort((a, b) => { return String.Compare(a.Name, b.Name); });
                objectDefinition.Methods.Sort((a, b) => { return String.Compare(a.Name, b.Name); });
                objectDefinition.Accessors.Sort((a, b) => { return String.Compare(a.Name, b.Name); });
            }
            else
            {
                // クラスとモジュール以外は定数とみなす
                definition = new RubyConstantDefinition();

                var constantDefinition = (RubyConstantDefinition)definition;
                constantDefinition.Value = WarlockDatabase.DecodeRubyObject(constant);
            }

            definition.Name = name;

            return definition;
        }
示例#3
0
 /// <summary>
 /// Rubyオブジェクト定義の情報を更新する。
 /// </summary>
 public void RefreshObjectDefinition()
 {
     _ScriptHost = new RubyHost(this);
     _ObjectDefinitions = GetObjectDefinitions();
     _ObjectDefinitionMap = CreateObjectDefinitionMap(_ObjectDefinitions);
 }