rhodes 2.2.6 → 2.3.0.beta.1

data/platform/bb/RubyVM/src/com/xruby/runtime/builtin/RubyString.java

@@ -26,7 +26,7 @@ public class RubyString extends RubyBasic {
     
     RubyString(RubyClass c, String s) {
         super(c);
-        sb_ = new StringBuffer(s);
+        sb_ = new StringBuffer(s != null ? s : "");
     }
 
     public RubyString(String s) {
@@ -53,8 +53,14 @@ public class RubyString extends RubyBasic {
         return sb_.toString();
     }
 
-    public int toInt() {
-        return Integer.parseInt(sb_.toString());
+    public int toInt() 
+    {
+    	try {
+    		return Integer.parseInt(sb_.toString());
+    	}catch(NumberFormatException exc)
+    	{
+    		throw new RubyException(RubyRuntime.TypeErrorClass, "can't convert " + this.getRubyClass().getName() + " into Integer");
+    	}
     }
     public long toLong() {
         return Long.parseLong(sb_.toString());
@@ -265,16 +271,19 @@ public class RubyString extends RubyBasic {
         if (end < 0) {
             end = string.length() + end;
         }
-
+        if (end < 0)
+        	return ObjectFactory.createString(getRubyClass(), "");
+        
         if (!isExcludeEnd) {
             ++end;
         }
 
         if (begin < 0 || end < 0 || begin > end || begin > string.length() || end > string.length()) {
             return RubyConstant.QNIL;
+        	//return ObjectFactory.createString(getRubyClass(), "");        	
         }
 
-        return ObjectFactory.createString(string.substring(begin, end));
+        return ObjectFactory.createString(getRubyClass(), string.substring(begin, end));
     }
 
     private RubyString gsub(RubyString g, RubyArray args) {
@@ -356,11 +365,11 @@ public class RubyString extends RubyBasic {
     }
 
     private Collection/*<String>*/ split(RubyString g, RubyRegexp r, RubyArray args) {
-        if (args.size() <= 1) {
+        if (args == null || args.size() <= 1) {
             return r.split(g.toString(), 0);
         } else {
-            RubyFixnum i = (RubyFixnum) args.get(1);
-            return r.split(g.toString(), i.toInt());
+            int i = args.get(1).toInt();
+            return r.split(g.toString(), i);
         }
     }
 
@@ -410,6 +419,8 @@ public class RubyString extends RubyBasic {
         if (this == v) {
             return RubyConstant.QTRUE;
         }
+    	if ( v == null || v == RubyConstant.QNIL )
+    		return RubyConstant.QFALSE;
 
         if (v instanceof RubyString) {
             RubyString str = ((RubyString)v);
@@ -424,6 +435,8 @@ public class RubyString extends RubyBasic {
     //@RubyLevelMethod(name="end_with?")
     public RubyValue opEndWith(RubyArray v) 
     {
+    	if ( v == null )
+    		return RubyConstant.QFALSE;
     	
     	for( int i = 0; i < v.size(); i++ )
     	{
@@ -434,6 +447,40 @@ public class RubyString extends RubyBasic {
         return RubyConstant.QFALSE;
     }
 
+    //@RubyLevelMethod(name="start_with?")
+    public RubyValue opStartWith(RubyValue v) {
+        if (this == v) {
+            return RubyConstant.QTRUE;
+        }
+
+    	if ( v == null || v == RubyConstant.QNIL )
+    		return RubyConstant.QFALSE;
+        
+        if (v instanceof RubyString) {
+            RubyString str = ((RubyString)v);
+            
+            return this.sb_.toString().startsWith(str.toStr()) ? RubyConstant.QTRUE :
+            	RubyConstant.QFALSE; 
+        }
+
+        return RubyConstant.QFALSE;
+    }
+
+    //@RubyLevelMethod(name="start_with?")
+    public RubyValue opStartWith(RubyArray v) 
+    {
+    	if ( v == null )
+    		return RubyConstant.QFALSE;
+    	
+    	for( int i = 0; i < v.size(); i++ )
+    	{
+    		RubyValue res = opStartWith(v.get(i));
+    		if ( res == RubyConstant.QTRUE )
+    			return RubyConstant.QTRUE;
+    	}
+        return RubyConstant.QFALSE;
+    }
+    
     //@RubyLevelMethod(name="ord")
     public RubyValue ord() 
     {
@@ -448,6 +495,22 @@ public class RubyString extends RubyBasic {
         return ObjectFactory.createString(sb_.toString().trim());
     }
 
+  //@RubyLevelMethod(name="replace")
+    public RubyValue replace(RubyValue arg) 
+    {
+    	if ( arg == null || arg == RubyConstant.QNIL )
+    		sb_ = new StringBuffer("");
+    	else
+    	{
+	        RubyString anotherString = arg.toRubyString();
+	        if(this == anotherString)
+	            return this;
+	
+	        sb_ = new StringBuffer(anotherString.toString());
+    	}
+        return this;
+    }
+    
     //@RubyLevelMethod(name="strip!")
     public RubyValue stripBang() {
         String str = this.sb_.toString();
@@ -1111,11 +1174,22 @@ public class RubyString extends RubyBasic {
 
     //@RubyLevelMethod(name="split")
     public RubyValue split(RubyArray args) {
-        RubyValue r = (null == args) ? GlobalVariables.get("$;") : args.get(0);
+        RubyValue r = null; 
+        	
+        if (null == args || args.size() == 0) 
+        	r = GlobalVariables.get("$;");
+        else if (args.size() > 0 && (args.get(0) == null || args.get(0) == RubyConstant.QNIL))
+        	r = GlobalVariables.get("$;");
+        else
+        	r = args.get(0);
+        
         int nLimit = 0;
         if ( args != null && args.size() > 1 )
         	nLimit = args.get(1).toInt();
         
+//        if ( nLimit < 0 )
+//        	nLimit = 0;
+        
         Collection/*<String>*/ splitResult;
         boolean bSkipFirstEmptyItem = false;
         if (r == RubyConstant.QNIL) {
@@ -1144,11 +1218,31 @@ public class RubyString extends RubyBasic {
             	//if (str == null)
             	//	a.add(RubyConstant.QNIL);
             	//else
-            		a.add(ObjectFactory.createString(str));
+            		a.add(ObjectFactory.createString(getRubyClass(), str));
             }
             ++i;
         }
         
+        if (r instanceof RubyString )
+        {
+        	String str = ((RubyString) r).toString();
+        	if ( str != null && str.length() == 1 && CharacterMe.isWhitespace(str.charAt(0) ) )
+        	{
+        		boolean bDelete = false;
+    	        for( i = a.size()-1; i >=0 ;i--)
+    	        {
+    	        	if ( ((RubyString)a.get(i)).length()>0 )
+    	        	{
+    	        		bDelete = true;
+    	        		continue;
+    	        	}
+    	        	
+    	        	if (bDelete)
+    	        		a.delete_at(i);
+    	        }
+        	}
+        }
+        
         if ( nLimit == 0 )
         {
 	        for( i = a.size()-1; i >=0 ;i--)
@@ -1158,6 +1252,13 @@ public class RubyString extends RubyBasic {
 	        	
 	        	a.delete_at(i);
 	        }
+        }else if ( a.size() < nLimit )
+        {
+        	int nAdd = nLimit - a.size();  
+        	for( i = 0; i < nAdd ;i++)
+        	{
+        		a.add(ObjectFactory.createString(this.getRubyClass(), ""));
+        	}
         }
         
         return a;
@@ -1247,7 +1348,7 @@ public class RubyString extends RubyBasic {
             if (arg instanceof RubyString) {
                 String str = ((RubyString) arg).toString();
                 if (string.indexOf(str) >= 0) {
-                    return ObjectFactory.createString(str);
+                    return ObjectFactory.createString(arg.getRubyClass(), str);
                 } else {
                     return RubyConstant.QNIL;
                 }
@@ -1260,7 +1361,7 @@ public class RubyString extends RubyBasic {
                 RubyRegexp regexp = (RubyRegexp) arg;
                 RubyMatchData match = regexp.match(string);
                 if (match != null) {
-                    return ObjectFactory.createString(match.toString());
+                    return ObjectFactory.createString(getRubyClass(), match.toString());
                 } else {
                     return RubyConstant.QNIL;
                 }
@@ -1274,14 +1375,26 @@ public class RubyString extends RubyBasic {
                     return RubyConstant.QNIL;
                 } else 
                 {
-                	return ObjectFactory.createString(string.substring(index, index+1));
+                	return ObjectFactory.createString(getRubyClass(), string.substring(index, index+1));
                 }
             }
         } else {
             int start = args.get(0).toInt();
-            int length = args.get(1).toInt() - 1;
+            int length = args.get(1).toInt();
 
-            return substring(string, start, start + length, false);
+            if (start < 0) {
+            	start = string.length() + start;
+            }
+            if ( start + length > string.length() )
+            	length = string.length() - start;
+            
+            int end = start + length;
+            if (start < 0 || end < 0 || start > end || start > string.length() || end > string.length()) {
+                return RubyConstant.QNIL;
+            	//return ObjectFactory.createString(getRubyClass(), "");        	
+            }
+            
+            return substring(string, start, end, true);
         }
     }
 
@@ -1290,8 +1403,8 @@ public class RubyString extends RubyBasic {
         String string = toString();
         String replacement;
 
-        int start, end;
-
+        int start = 0, end = 0;
+        boolean isExcludeEnd = true;
         if (args.size() == 2) {
             RubyValue arg = args.get(0);
             replacement = ((RubyString) args.get(1)).toString();
@@ -1308,9 +1421,11 @@ public class RubyString extends RubyBasic {
                 RubyRange range = (RubyRange) arg;
                 start = range.getLeft().toInt();
                 end = range.getRight().toInt();
-                if (start >= string.length()) {
-                    throw new RubyException(RubyRuntime.RangeClass, range.toString() + " out of range");
-                }
+                
+                isExcludeEnd = range.isExcludeEnd(); 
+                //if (start >= string.length()) {
+                //    throw new RubyException(RubyRuntime.RangeClass, range.toString() + " out of range");
+                //}
             } else if (arg instanceof RubyRegexp) {
                 RubyRegexp regexp = (RubyRegexp) arg;
                 RubyMatchData match = regexp.match(string);
@@ -1329,12 +1444,37 @@ public class RubyString extends RubyBasic {
             replacement = ((RubyString) args.get(2)).toString();
 
             start = args.get(0).toInt();
-            end = args.get(1).toInt() + start;
-            if (start >/*=*/ string.length()) {
-                throw new RubyException(RubyRuntime.RangeClass, 
-                		"Index '" + start + "' out of string:" + string +";end: '" + end + "';replacement:"+replacement+"" );
-            }
+            if (start < 0) {
+            	start = string.length() + start;
+            	
+                end = args.get(1).toInt() + start;
+                
+                if ( end >= string.length() )
+                	end = string.length();
+            }else
+            	end = args.get(1).toInt() + start;
+            
+        }
+        
+        if (start < 0) {
+        	start = string.length() + start;
+        }
+
+        if (end < 0) {
+            end = string.length() + end;
         }
+        
+        end += isExcludeEnd ? 0 : 1;
+        if (start < 0) {
+            return RubyConstant.QNIL;
+        	//return ObjectFactory.createString(getRubyClass(), "");        	
+        }
+        
+        if (start >/*=*/ string.length()) {
+            throw new RubyException(RubyRuntime.RangeClass, 
+            		"Index '" + start + "' out of string:" + string +";end: '" + end + "';replacement:"+replacement+"" );
+        }
+        
         setString(replace(string, start, end, replacement));
         return ObjectFactory.createString(replacement);
     }
@@ -1561,5 +1701,48 @@ public class RubyString extends RubyBasic {
     	m_valEncoding = arg;
         return this;
     }
+
+    public RubyValue binary_encode() 
+    {
+    	StringBuffer res = new StringBuffer(sb_.length());
+    	
+    	for( int i = 0; i < sb_.length(); i++ )
+    	{
+    		char ch = sb_.charAt(i);
+    		if ( ch == 0 )
+    			res.append('\u0001');
+    		else if ( ch == 1 )
+    		{
+    			res.append('\u0001');
+    			res.append('\u0001');
+    		}else
+    			res.append(ch);
+    	}
+    	
+        return new RubyString(res);
+    }
+
+    public RubyValue binary_decode() 
+    {
+    	StringBuffer res = new StringBuffer(sb_.length());
+    	
+    	for( int i = 0; i < sb_.length(); i++ )
+    	{
+    		char ch = sb_.charAt(i);
+    		if ( ch == 1 )
+    		{
+    			if ( i + 1 < sb_.length() && sb_.charAt(i+1) == 1)
+    			{
+    				res.append('\u0001');
+    				i++;
+    			}else
+    				res.append('\u0000');
+    		}
+    		else
+    			res.append(ch);
+    	}
+    	
+        return new RubyString(res);
+    }
     
 }

data/platform/bb/RubyVM/src/com/xruby/runtime/builtin/RubyTime.java

@@ -44,7 +44,9 @@ public class RubyTime extends RubyBasic {
     }
     //@RubyAllocMethod
     public static RubyTime alloc(RubyValue receiver) {
-        return ObjectFactory.createTime();
+    	RubyTime res = new RubyTime();
+    	res.setRubyClass((RubyClass) receiver);
+        return res;
     }
 
     //RHO_COMMENT : initialize

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RhoSupport.java

@@ -7,6 +7,8 @@ import com.rho.RhoLogger;
 import com.rho.RhodesApp;
 import com.xruby.runtime.builtin.ObjectFactory;
 import com.xruby.runtime.builtin.RubyArray;
+import com.xruby.runtime.builtin.RubyRegexp;
+
 import j2me.lang.StringMe;
 import com.rho.RhoConf;
 
@@ -63,7 +65,9 @@ public class RhoSupport {
 	    }
 		
 	    public static RhoLog alloc(RubyValue receiver) {
-	        return new RhoLog();
+	    	RhoLog res = new RhoLog();
+	    	res.setRubyClass((RubyClass) receiver);
+	        return res;
 	    }
 
 	    public RhoLog initialize() {

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RubyAPI.java

@@ -579,7 +579,7 @@ public class RubyAPI {
                     }
                 }
             }*/
-            throwUninitializedConstant(receiver, name);
+            return callUninitializedConstant(receiver, name);
         }
 
         return v;
@@ -600,7 +600,7 @@ public class RubyAPI {
         RubyModule m = (RubyModule) receiver;
         RubyValue v = m.getConstant(name);
         if (null == v) {
-            throwUninitializedConstant(m, name);
+            return callUninitializedConstant(m, name);
         }
 
         return v;
@@ -618,10 +618,17 @@ public class RubyAPI {
         return RubyConstant.QTRUE;
     }
     
-    private static void throwUninitializedConstant(RubyModule m, String name) {
+    private static RubyValue callUninitializedConstant(RubyModule module, String name) 
+    {
+        RubyMethod m = module.findMethod(RubyID.constMissingId);
+        if (null != m && !UndefMethod.isUndef(m)) {
+           	RubyArray args = new RubyArray(ObjectFactory.createSymbol(name));
+            return m.invoke(module, args, (RubyBlock)null);
+        }
+    	
         RubyString str = ObjectFactory.createString();
-        if (m != RubyRuntime.ObjectClass) {
-            m.to_s(str);
+        if (module != RubyRuntime.ObjectClass) {
+        	module.to_s(str);
             if (str.length() > 0) {
                 str.appendString("::");
             }

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RubyID.java

@@ -76,6 +76,7 @@ public class RubyID {
 
     public static final RubyID methodAddedID = intern("method_added");
     public static final RubyID methodMissingId = intern("method_missing");
+    public static final RubyID constMissingId = intern("const_missing");    
     public static final RubyID extendObjectID = intern("extend_object");
 
     public static final RubyID RESPOND_TO_P = intern("respond_to?");

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RubyKernelModule.java

@@ -657,6 +657,22 @@ public class RubyKernelModule {
     }
     
     //@RubyLevelMethod(name="method_missing", module=true)
+    public static RubyValue constMissing(RubyValue receiver, RubyValue arg) 
+    {
+        RubySymbol const_name = (RubySymbol)arg;
+    	
+        RubyString str = ObjectFactory.createString();
+        if (receiver != RubyRuntime.ObjectClass) {
+        	((RubyModule)receiver).to_s(str);
+            if (str.length() > 0) {
+                str.appendString("::");
+            }
+        }
+        str.appendString(const_name);
+        throw new RubyException(RubyRuntime.NameErrorClass, "uninitialized constant " + str.toString());
+    }
+
+    //@RubyLevelMethod(name="const_missing", module=true)
     public static RubyValue methodMissing(RubyValue receiver, RubyArray args) {
         RubySymbol method_name = (RubySymbol)args.get(0);
         RubyClass klass = receiver.getRubyClass();

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RubyKernelModule_Methods.java

@@ -138,6 +138,11 @@ klass.defineModuleMethod( "method_missing", new RubyVarArgMethod(){
 	protected RubyValue run(RubyValue receiver, RubyArray args, RubyBlock block ){
 		return RubyKernelModule.methodMissing(receiver, args);}
 });
+klass.defineModuleMethod( "const_missing", new RubyOneArgMethod(){ 
+	protected RubyValue run(RubyValue receiver, RubyValue arg, RubyBlock block ){
+		return RubyKernelModule.constMissing(receiver, arg);}
+});
+
 klass.defineModuleMethod( "binding", new RubyVarArgMethod(){ 
 	protected RubyValue run(RubyValue receiver, RubyArray args, RubyBlock block ){
 		return RubyKernelModule.binding(receiver, args);}

data/platform/bb/RubyVM/src/com/xruby/runtime/lang/RubyValue.java

@@ -285,7 +285,7 @@ public abstract class RubyValue extends BlockCallStatus implements Cloneable {
 
         RubyClass theClass = this.getRubyClass();
         if (!this.respondTo(id)) {
-            throw new RubyException("can't convert " + this.getRubyClass().getName() + " into " + klass.getName());
+            throw new RubyException(RubyRuntime.TypeErrorClass, "can't convert " + this.getRubyClass().getName() + " into " + klass.getName());
         }
 
         RubyValue v = RubyAPI.callNoArgMethod(this, null, id);

data/platform/bb/RubyVM/src/com/xruby/runtime/stdlib/RubyStringIO.java

@@ -9,6 +9,7 @@ import java.io.IOException;
 
 import com.xruby.runtime.builtin.ObjectFactory;
 import com.xruby.runtime.builtin.RubyArray;
+import com.xruby.runtime.builtin.RubyRegexp;
 import com.xruby.runtime.builtin.RubyString;
 import com.xruby.runtime.lang.*;
 
@@ -28,7 +29,9 @@ public class RubyStringIO extends RubyBasic {
     
     //@RubyAllocMethod
     public static RubyStringIO alloc(RubyValue receiver) {
-        return new RubyStringIO();
+    	RubyStringIO res = new RubyStringIO();
+    	res.setRubyClass((RubyClass) receiver);
+        return res;
     }
 
     //@RubyLevelMethod(name="initialize")

data/platform/bb/{Hsqldb → RubyVM}/src/j2me/math/Number.java

@@ -20,6 +20,17 @@ public class Number{
     		return ((Short)obj).shortValue();
     	else if ( obj instanceof Byte )
     		return ((Byte)obj).byteValue();
+    	else if ( obj instanceof byte[] )
+    	{
+			String strRes = "";
+			try{
+				strRes = new String( ((byte[])obj), "UTF-8");
+       		}catch(java.io.UnsupportedEncodingException exc)
+       		{
+       		}
+    		
+        	return strRes==null || strRes.length() == 0 ? 0 : Integer.parseInt(strRes);
+    	}
     	
     	String strRes = obj.toString();
     	return strRes==null || strRes.length() == 0 ? 0 : Integer.parseInt(strRes);
@@ -34,6 +45,17 @@ public class Number{
     		return ((Short)obj).shortValue();
     	else if ( obj instanceof Byte )
     		return ((Byte)obj).byteValue();
+    	else if ( obj instanceof byte[] )
+    	{
+			String strRes = "";
+			try{
+				strRes = new String( ((byte[])obj), "UTF-8");
+       		}catch(java.io.UnsupportedEncodingException exc)
+       		{
+       		}
+    		
+        	return strRes==null || strRes.length() == 0 ? 0 : Long.parseLong(strRes);
+    	}
     	
     	String strRes = obj.toString();
     	return strRes==null || strRes.length() == 0 ? 0 : Long.parseLong(strRes);
@@ -52,6 +74,17 @@ public class Number{
     		return ((Short)obj).shortValue();
     	else if ( obj instanceof Byte )
     		return ((Byte)obj).byteValue();
+    	else if ( obj instanceof byte[] )
+    	{
+			String strRes = "";
+			try{
+				strRes = new String( ((byte[])obj), "UTF-8");
+       		}catch(java.io.UnsupportedEncodingException exc)
+       		{
+       		}
+    		
+       		return strRes==null || strRes.length() == 0 ? 0 : Double.parseDouble(strRes);
+    	}
     	
     	String strRes = obj.toString();
     	return strRes==null || strRes.length() == 0 ? 0 : Double.parseDouble(strRes);

data/platform/bb/build/RubyVM_build.files

@@ -11,6 +11,8 @@ platform/bb/RubyVM/src/com/rho/file/IFileAccess.java
 platform/bb/RubyVM/src/com/rho/file/IRAFile.java
 platform/bb/RubyVM/src/com/rho/file/SimpleFile.java
 platform/bb/RubyVM/src/com/rho/file/RandomAccessFile.java
+platform/bb/RubyVM/src/com/rho/file/FileAccessBB.java
+platform/bb/RubyVM/src/com/rho/file/RhoFile.java
 platform/bb/RubyVM/src/com/rho/IRhoLogSink.java
 platform/bb/RubyVM/src/com/rho/IRhoRubyHelper.java
 platform/bb/RubyVM/src/com/rho/Mutex.java
@@ -254,6 +256,7 @@ platform/bb/RubyVM/src/j2me/lang/UnsupportedOperationException.java
 platform/bb/RubyVM/src/j2me/math/HugeDigit.java
 platform/bb/RubyVM/src/j2me/math/HugeInt.java
 platform/bb/RubyVM/src/j2me/math/HugeIntHelper.java
+platform/bb/RubyVM/src/j2me/math/Number.java
 platform/bb/RubyVM/src/j2me/nio/Buffer.java
 platform/bb/RubyVM/src/j2me/nio/BufferUnderflowException.java
 platform/bb/RubyVM/src/j2me/nio/ByteBuffer.java