rsense-core 0.5.0

data/src/org/cx4a/rsense/ruby/RubyClass.java

@@ -0,0 +1,146 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+
+import org.cx4a.rsense.util.SourceLocation;
+import org.cx4a.rsense.ruby.Ruby;
+
+public class RubyClass extends RubyModule {
+    protected RubyClass superClass;
+
+    public static RubyClass newClass(Ruby runtime, String baseName, RubyClass superClass) {
+        return newClass(runtime, baseName, superClass, null);
+    }
+
+    public static RubyClass newClassWithLocation(Ruby runtime, String baseName, RubyClass superClass, SourceLocation location) {
+        return newClassWithLocation(runtime, baseName, superClass, null, location);
+    }
+    
+    public static RubyClass newClass(Ruby runtime, String baseName, RubyClass superClass, RubyModule parent) {
+        return newClassWithLocation(runtime, baseName, superClass, parent, null);
+    }
+    
+    public static RubyClass newClassWithLocation(Ruby runtime, String baseName, RubyClass superClass, RubyModule parent, SourceLocation location) {
+        if (superClass == null) {
+            superClass = runtime.getObject();
+        }
+        RubyClass klass = new RubyClass(runtime, superClass, parent, location);
+        klass.setBaseName(baseName);
+        klass.makeMetaClass(superClass.getMetaClass());
+        klass.setLocation(location);
+        return klass;
+    }
+
+    public static RubyClass newBootClass(Ruby runtime, String baseName, RubyClass superClass) {
+        RubyClass klass = new RubyClass(runtime, superClass);
+        klass.setBaseName(baseName);
+        return klass;
+    }
+
+    protected RubyClass(Ruby runtime, RubyClass superClass) {
+        this(runtime, superClass, null);
+    }
+    
+    protected RubyClass(Ruby runtime, RubyClass superClass, RubyModule parent) {
+        this(runtime, runtime.getClassClass(), superClass, parent, null);
+    }
+
+    protected RubyClass(Ruby runtime, RubyClass superClass, RubyModule parent, SourceLocation location) {
+        this(runtime, runtime.getClassClass(), superClass, parent, location);
+    }
+
+    protected RubyClass(Ruby runtime, RubyClass metaClass, RubyClass superClass, RubyModule parent, SourceLocation location) {
+        super(runtime, metaClass, parent, location);
+        this.superClass = superClass;
+    }
+
+    public RubyClass getRealClass() {
+        return this;
+    }
+    
+    public RubyClass getSuperClass() {
+        return superClass;
+    }
+
+    public void setSuperClass(RubyClass superClass) {
+        this.superClass = superClass;
+    }
+
+    public boolean isSingleton() {
+        return false;
+    }
+
+    public void addSubclass(RubyClass subclass) {
+        // FIXME
+    }
+
+    @Override
+    public IRubyObject getConstant(String name) {
+        IRubyObject constant = super.getConstant(name);
+        if (constant == null && superClass != null && this != getRuntime().getObject()) {
+            constant = superClass.getConstant(name);
+        }
+        return constant;
+    }
+
+    @Override
+    public Set<String> getConstants(boolean inheritedToo) {
+        Set<String> result = super.getConstants(inheritedToo);
+        RubyClass sclass = superClass;
+        while (sclass != null) {
+            result.addAll(sclass.getConstants(inheritedToo));
+            sclass = sclass.getSuperClass();
+        }
+        return result;
+    }
+
+    @Override
+    public RubyModule getConstantModule(String name) {
+        RubyModule module = super.getConstantModule(name);
+        RubyClass sclass = superClass;
+        while (module == null && sclass != null) {
+            module = sclass.getConstantModule(name);
+            sclass = sclass.getSuperClass();
+        }
+        return module;
+    }
+
+    @Override
+    public DynamicMethod searchMethod(String name) {
+        DynamicMethod method = getMethod(name);
+        if (method == null && superClass != null) {
+            method = superClass.searchMethod(name);
+        }
+        if (method == null) {
+            method = super.searchMethod(name);
+        }
+        return method;
+    }
+
+    @Override
+    public Set<String> getMethods(boolean inheritedToo) {
+        Set<String> result = super.getMethods(inheritedToo);
+        RubyClass sclass = superClass;
+        while (sclass != null) {
+            result.addAll(sclass.getPublicMethods(inheritedToo));
+            sclass = sclass.getSuperClass();
+        }
+        return result;
+    }
+
+    @Override
+    public List<RubyModule> getIncludes(boolean inheritedToo) {
+        List<RubyModule> result = super.getIncludes(inheritedToo);
+        if (inheritedToo) {
+            result = new ArrayList<RubyModule>(result);
+            RubyClass sclass = superClass;
+            while (sclass != null) {
+                result.addAll(sclass.getIncludes(inheritedToo));
+                sclass = sclass.getSuperClass();
+            }
+        }
+        return result;
+    }
+}

data/src/org/cx4a/rsense/ruby/RubyModule.java

@@ -0,0 +1,255 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.cx4a.rsense.util.Logger;
+import org.cx4a.rsense.util.SourceLocation;
+
+public class RubyModule extends RubyObject {
+    private String baseName;
+    private RubyModule parent;
+    private Map<String, DynamicMethod> methods;
+    private Map<String, IRubyObject> constants;
+    private Map<String, IRubyObject> classVars;
+    private List<RubyModule> includes;
+    private SourceLocation location;
+
+    public static RubyModule newModule(Ruby runtime, String baseName, RubyModule parent) {
+        return newModuleWithLocation(runtime, baseName, parent, null);
+    }
+    
+    public static RubyModule newModuleWithLocation(Ruby runtime, String baseName, RubyModule parent, SourceLocation location) {
+        RubyModule module = new RubyModule(runtime, parent);
+        module.setBaseName(baseName);
+        module.makeMetaClass(runtime.getModule());
+        return module;
+    }
+
+    protected RubyModule(Ruby runtime) {
+        this(runtime, null);
+    }
+    
+    protected RubyModule(Ruby runtime, RubyModule parent) {
+        this(runtime, runtime.getModule(), parent);
+    }
+    
+    protected RubyModule(Ruby runtime, RubyClass metaClass, RubyModule parent) {
+        this(runtime, runtime.getModule(), parent, null);
+    }
+
+    protected RubyModule(Ruby runtime, RubyClass metaClass, RubyModule parent, SourceLocation location) {
+        super(runtime, metaClass);
+        this.parent = parent;
+        this.methods = new HashMap<String, DynamicMethod>();
+        this.constants = new HashMap<String, IRubyObject>();
+        this.classVars = new HashMap<String, IRubyObject>();
+        this.includes = new ArrayList<RubyModule>();
+        this.location = location;
+    }
+
+    public String getBaseName() {
+        return baseName;
+    }
+
+    public void setBaseName(String baseName) {
+        this.baseName = baseName;
+    }
+
+    public RubyModule getParent() {
+        return parent;
+    }
+
+    public void setConstant(String name, IRubyObject constant) {
+        constants.put(name, constant);
+    }
+
+    public IRubyObject getConstant(String name) {
+        return getConstant(name, null);
+    }
+
+    private IRubyObject getConstant(String name, Set<RubyModule> seen) {
+        if (seen != null && seen.contains(this)) {
+            return null;
+        }
+
+        IRubyObject constant = getConstantUnder(name);
+        if (constant == null && parent != null) {
+            constant = parent.getConstant(name, seen);
+        }
+        if (constant == null) {
+            if (seen == null) {
+                seen = new HashSet<RubyModule>();
+            }
+            seen.add(this);
+            for (RubyModule module : includes) {
+                constant = module.getConstant(name, seen);
+                if (constant != null) {
+                    return constant;
+                }
+            }
+        }
+        return constant;
+    }
+
+    public IRubyObject getConstantUnder(String name) {
+        return constants.get(name);
+    }
+
+    public Set<String> getConstants(boolean inheritedToo) {
+        Set<String> result = new HashSet<String>(constants.keySet());
+        if (inheritedToo) {
+            for (RubyModule module : includes) {
+                result.addAll(module.getConstants(inheritedToo));
+            }
+        }
+        return result;
+    }
+
+    public RubyModule getConstantModule(String name) {
+        // FIXME return pairs at getConstants
+        if (constants.containsKey(name)) {
+            return this;
+        } else {
+            for (RubyModule module : includes) {
+                module = module.getConstantModule(name);
+                if (module != null) {
+                    return module;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean isConstantDefined(String name) {
+        return constants.containsKey(name);
+    }
+
+    public IRubyObject getClassVar(String name) {
+        return classVars.get(name);
+    }
+
+    public void setClassVar(String name, IRubyObject value) {
+        classVars.put(name, value);
+    }
+
+    public RubyModule defineOrGetClassUnder(String name, RubyClass superClass, SourceLocation location) {
+        if (isConstantDefined(name)) {
+            IRubyObject object = getConstant(name);
+            if (object instanceof RubyModule) {
+                return (RubyModule) object;
+            } else {
+                Logger.error("%s is not class", name);
+                return null;
+            }
+        } else {
+            RubyClass klass = RubyClass.newClassWithLocation(getRuntime(), name, superClass, this, location);
+            setConstant(name, klass);
+            return klass;
+        }
+    }
+
+    public RubyModule defineOrGetModuleUnder(String name, SourceLocation location) {
+        if (isConstantDefined(name)) {
+            IRubyObject object = getConstant(name);
+            if (object.getClass() == RubyModule.class) {
+                return (RubyModule) object;
+            } else {
+                Logger.error("%s is not module", name);
+                return null;
+            }
+        } else {
+            RubyModule module = RubyModule.newModuleWithLocation(getRuntime(), name, this, location);
+            setConstant(name, module);
+            return module;
+        }
+    }
+
+    public void addMethod(String name, DynamicMethod method) {
+        methods.put(name, method);
+    }
+
+    public DynamicMethod getMethod(String name) {
+        return methods.get(name);
+    }
+
+    public Set<String> getMethods(boolean inheritedToo) {
+        Set<String> result = new HashSet<String>(methods.keySet());
+        if (inheritedToo) {
+            for (RubyModule module : includes) {
+                result.addAll(module.getPublicMethods(inheritedToo));
+            }
+        }
+        return result;
+    }
+
+    public Set<String> getPublicMethods(boolean inheritedToo) {
+        Set<String> result = getVisibleMethods(Visibility.PUBLIC);
+        if (inheritedToo) {
+            for (RubyModule module : includes) {
+                result.addAll(module.getPublicMethods(inheritedToo));
+            }
+        }
+        return result;
+    }
+
+    private Set<String> getVisibleMethods(Visibility visibility) {
+        Set<String> result = new HashSet<String>();
+        for (Map.Entry<String, DynamicMethod> entry : methods.entrySet()) {
+            if (entry.getValue().getVisibility() == visibility) {
+                result.add(entry.getKey());
+            }
+        }
+        return result;
+    }
+
+    public DynamicMethod searchMethod(String name) {
+        DynamicMethod method = getMethod(name);
+        if (method == null) {
+            for (RubyModule module : includes) {
+                if ((method = module.searchMethod(name)) != null) {
+                    break;
+                }
+            }
+        }
+        return method;
+    }
+
+    public void includeModule(RubyModule module) {
+        includes.add(module);
+    }
+
+    public List<RubyModule> getIncludes(boolean inheritedToo) {
+        return includes;
+    }
+
+    public void setLocation(SourceLocation location) {
+        this.location = location;
+    }
+
+    public SourceLocation getLocation() {
+        return location;
+    }
+
+    public String getMethodPath(String name) {
+        String path = toString();
+        if (name != null)
+            path += "#" + name;
+        return path;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        if (parent != null && parent != getRuntime().getObject()) {
+            sb.append(parent.toString());
+            sb.append("::");
+        }
+        sb.append(baseName != null ? baseName : super.toString());
+        return sb.toString();
+    }
+}

data/src/org/cx4a/rsense/ruby/RubyObject.java

@@ -0,0 +1,94 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class RubyObject implements IRubyObject {
+    protected Ruby runtime;
+    protected RubyClass metaClass;
+    private Map<String, IRubyObject> instVars;
+    private Object tag;
+
+    protected RubyObject(Ruby runtime) {
+        this(runtime, null);
+    }
+
+    public RubyObject(Ruby runtime, RubyClass metaClass) {
+        this.runtime = runtime;
+        this.metaClass = metaClass;
+    }
+
+    public Ruby getRuntime() {
+        return runtime;
+    }
+
+    public RubyClass getMetaClass() {
+        return metaClass;
+    }
+    
+    public void setMetaClass(RubyClass metaClass) {
+        this.metaClass = metaClass;
+    }
+
+    public RubyClass getSingletonClass() {
+        RubyClass klass;
+        if (getMetaClass().isSingleton() && ((MetaClass) getMetaClass()).getAttached() == this) {
+            klass = getMetaClass();
+        } else {
+            klass = makeMetaClass(getMetaClass());
+        }
+        return klass;
+    }
+
+    public RubyClass makeMetaClass(RubyClass superClass) {
+        MetaClass klass = new MetaClass(runtime, superClass);
+        setMetaClass(klass);
+
+        klass.setAttached(this);
+        klass.setMetaClass(superClass.getRealClass().getMetaClass());
+
+        superClass.addSubclass(klass);
+
+        return klass;
+    }
+
+    public IRubyObject getInstVar(String name) {
+        return instVars == null ? null : instVars.get(name);
+    }
+
+    public void setInstVar(String name, IRubyObject value) {
+        if (instVars == null) {
+            instVars = new HashMap<String, IRubyObject>();
+        }
+        instVars.put(name, value);
+    }
+
+    public boolean isNil() {
+        return this == getRuntime().getNil();
+    }
+
+    public boolean isInstanceOf(RubyModule klass) {
+        return runtime.isInstanceOf(this, klass);
+    }
+
+    public boolean isKindOf(RubyModule klass) {
+        return runtime.isKindOf(this, klass);
+    }
+
+    public Object getTag() {
+        return tag;
+    }
+
+    public void setTag(Object tag) {
+        this.tag = tag;
+    }
+
+    public int hashCode(int depth) {
+        return hashCode();
+    }
+        
+    @Override
+    public String toString() {
+        return "<obj:" + metaClass.toString() + ">";
+    }
+}