Exemple #1
0
  // @RubyLevelMethod(name="downcase")
  public RubyString downcase() {
    int length = this.sb_.length();
    if (length == 0) {
      return ObjectFactory.createString();
    }

    char[] ca = new char[length];
    this.sb_.getChars(0, length, ca, 0);

    for (int i = 0; i < ca.length; i++) {
      ca[i] = Character.toLowerCase(ca[i]);
    }

    return ObjectFactory.createString(new StringBuffer().append(ca));
  }
Exemple #2
0
 // @RubyLevelMethod(name="tr_s")
 public RubyValue tr_s(RubyValue arg1, RubyValue arg2) {
   RubyString string = ObjectFactory.createString(toString());
   RubyString from = (RubyString) arg1;
   RubyString to = (RubyString) arg2;
   string.tr_s(from.toString(), to.toString());
   return string;
 }
Exemple #3
0
  private RubyString sub(RubyString g, RubyArray args) {
    if (null == args || args.size() != 2) {
      int actual_argc = (null == args) ? 0 : args.size();
      throw new RubyException(
          RubyRuntime.ArgumentErrorClass,
          "in `sub': wrong number of arguments (" + actual_argc + " for 2)");
    }

    if (!(args.get(1) instanceof RubyString)) {
      throw new RubyException(
          RubyRuntime.ArgumentErrorClass,
          "can't convert " + args.get(1).getRubyClass().getName() + " into String");
    }

    RubyString s = (RubyString) args.get(1);

    if (args.get(0) instanceof RubyRegexp) {
      RubyRegexp r = (RubyRegexp) args.get(0);
      return r.sub(g, s);
    } else if (args.get(0) instanceof RubyString) {
      RubyString r = (RubyString) args.get(0);
      String result = StringMe.replaceFirst(g.toString(), r.toString(), s.toString());
      return ObjectFactory.createString(result);
    } else {
      throw new RubyException(
          RubyRuntime.ArgumentErrorClass,
          "wrong argument type " + args.get(0).getRubyClass().getName() + " (expected Regexp)");
    }
  }
Exemple #4
0
  // @RubyLevelMethod(name="split")
  public RubyValue split(RubyArray args) {
    RubyValue r = (null == args) ? GlobalVariables.get("$;") : args.get(0);

    Collection /*<String>*/ splitResult;
    boolean bSkipFirstEmptyItem = false;
    if (r == RubyConstant.QNIL) {
      splitResult = split(this, " ");
    } else if (r instanceof RubyRegexp) {
      RubyRegexp reg = (RubyRegexp) r;
      splitResult = split(this, reg, args);

      if (reg.getPattern().getPattern().startsWith("(?=")) bSkipFirstEmptyItem = true;
    } else if (r instanceof RubyString) {
      splitResult = split(this, ((RubyString) r).toString());
    } else {
      throw new RubyException(
          RubyRuntime.ArgumentErrorClass,
          "wrong argument type " + r.getRubyClass() + " (expected Regexp)");
    }

    RubyArray a = new RubyArray(splitResult.size());
    int i = 0;
    //        for (String str : splitResult) {
    for (Iterator iter = splitResult.iterator(); iter.hasNext(); ) {
      String str = (String) iter.next();
      if (!(bSkipFirstEmptyItem && 0 == i && (str == null || str.equals("")))) {
        // To conform ruby's behavior, discard the first empty element
        a.add(ObjectFactory.createString(str));
      }
      ++i;
    }
    return a;
  }
Exemple #5
0
  @RubyLevelMethod(name = "to_s")
  public RubyString to_s(RubyValue v) {
    int radix = v.toInt();
    if (radix < 2 || radix > 36) {
      throw new RubyException(RubyRuntime.ArgumentErrorClass, "illegal radix " + radix);
    }

    return ObjectFactory.createString(this.toString(radix));
  }
Exemple #6
0
  public RubyValue post_match() {
    String res = "";
    int nMatchEnd = result_.endOffset(result_.groups() - 1);
    if (nMatchEnd >= 0 && nMatchEnd + 1 < str_.length()) res = str_.substring(nMatchEnd);

    if (res == null) return RubyConstant.QNIL;

    return ObjectFactory.createString(res);
  }
Exemple #7
0
  public RubyValue pre_match() {
    String res = "";
    int nMatchEnd = result_.beginOffset(0);
    if (nMatchEnd >= 0 && nMatchEnd < str_.length()) res = str_.substring(0, nMatchEnd);

    if (res == null) return RubyConstant.QNIL;

    return ObjectFactory.createString(res);
  }
Exemple #8
0
  RubyValue getRetValue() {
    RubyValue ret = RubyConstant.QNIL;
    if (isNoThreadedMode()) {
      ret = ObjectFactory.createString(getSyncEngine().getNotify().getNotifyBody());
      getSyncEngine().getNotify().cleanNotifyBody();
    }

    return ret;
  }
Exemple #9
0
  // @RubyLevelMethod(name="delete")
  public RubyValue delete(RubyArray args) {
    if (null == args) {
      throw new RubyException(RubyRuntime.ArgumentErrorClass, "wrong number of arguments");
    }

    RubyString string = ObjectFactory.createString(toString());
    String arg = ((RubyString) args.get(0)).toString();
    string.delete(arg);
    return string;
  }
Exemple #10
0
  public RubyString appendString(RubyValue v) {
    if (v instanceof RubyString) {
      return appendString((RubyString) v);
    } else {
      RubyValue r = RubyAPI.callPublicNoArgMethod(v, null, RubyID.toSID);
      if (r instanceof RubyString) return appendString((RubyString) r);

      return ObjectFactory.createString(r.toString());
    }
  }
 @RubyLevelMethod(name = "gets", module = true)
 public static RubyValue gets(RubyValue receiver) {
   String s = null;
   try {
     s = in_.readLine();
   } catch (IOException e) {
   }
   GlobalVariables.set((null == s ? RubyConstant.QNIL : ObjectFactory.createString(s)), "$_");
   return GlobalVariables.get("$_");
 }
Exemple #12
0
  // @RubyLevelMethod(name="[]")
  public RubyValue array_access(RubyArray args) {
    String string = toString();
    if (args.size() == 1) {
      RubyValue arg = args.get(0);
      if (arg instanceof RubyString) {
        String str = ((RubyString) arg).toString();
        if (string.indexOf(str) >= 0) {
          return ObjectFactory.createString(str);
        } else {
          return RubyConstant.QNIL;
        }
      } else if (arg instanceof RubyRange) {
        RubyRange range = (RubyRange) arg;
        int start = range.getLeft().toInt();
        int end = range.getRight().toInt();
        return substring(string, start, end, range.isExcludeEnd());
      } else if (arg instanceof RubyRegexp) {
        RubyRegexp regexp = (RubyRegexp) arg;
        RubyMatchData match = regexp.match(string);
        if (match != null) {
          return ObjectFactory.createString(match.toString());
        } else {
          return RubyConstant.QNIL;
        }
      } else {
        int index = arg.toInt();
        if (index < 0) {
          index = string.length() + index;
        }

        if (index < 0 || index >= string.length()) {
          return RubyConstant.QNIL;
        } else {
          return ObjectFactory.createFixnum(string.charAt(index));
        }
      }
    } else {
      int start = args.get(0).toInt();
      int length = args.get(1).toInt() - 1;

      return substring(string, start, start + length, false);
    }
  }
Exemple #13
0
  public RubyValue captures() {
    RubyArray ar = new RubyArray();
    for (int i = 1; i < result_.groups(); i++) {
      String res = result_.group(i);
      if (res == null) ar.add(RubyConstant.QNIL);
      else ar.add(ObjectFactory.createString(res));
    }

    return ar;
  }
 @RubyLevelMethod(name = "sprintf", module = true)
 public static RubyValue sprintf(RubyValue receiver, RubyArray args) {
   String fmt = args.get(0).toStr();
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   PrintStream ps = new PrintStream(baos);
   ps.printf(fmt, RubyKernelModule.buildFormatArg(args, 1));
   ps.flush();
   ps.close();
   return ObjectFactory.createString(baos.toString());
 }
Exemple #15
0
  public RubyValue to_a() {
    RubyArray ar = new RubyArray();
    for (int i = 0; i < result_.groups(); i++) {
      String str = result_.group(i);
      if (str != null) ar.add(ObjectFactory.createString(str));
      else ar.add(RubyConstant.QNIL);
    }

    return ar;
  }
Exemple #16
0
  // @RubyLevelMethod(name="swapcase")
  public RubyString swapcase() {
    int length = this.sb_.length();
    if (length == 0) {
      return ObjectFactory.createString();
    }

    char[] ca = new char[length];
    this.sb_.getChars(0, length, ca, 0);

    for (int i = 0; i < length; i++) {
      char c = ca[i];
      if (Character.isUpperCase(c)) {
        ca[i] = Character.toLowerCase(c);
      } else if (Character.isLowerCase(c)) {
        ca[i] = Character.toUpperCase(c);
      }
    }

    return ObjectFactory.createString(new StringBuffer().append(ca));
  }
Exemple #17
0
 // @RubyLevelMethod(name="*")
 public RubyValue operator_star(RubyValue arg) {
   String string = toString();
   int count = arg.toInt();
   if (count < 0) {
     throw new RubyException(RubyRuntime.ArgumentErrorClass, "negative argument");
   }
   StringBuffer result = new StringBuffer();
   for (int i = 0; i < count; ++i) {
     result.append(string);
   }
   return ObjectFactory.createString(result);
 }
Exemple #18
0
 // @RubyLevelMethod(name="%")
 public RubyValue format(RubyValue arg) {
   String format = toString();
   String s;
   // RHO_MOBILE
   if (arg instanceof RubyArray) {
     // s = StringMe.format(format,
     // com.xruby.runtime.lang.RubyKernelModule.buildFormatArg((RubyArray)arg, 0));
     s = StringMe.format(format, (RubyArray) arg);
   } else {
     // s = StringMe.format(format, com.xruby.runtime.lang.RubyKernelModule.buildFormatArg(new
     // RubyArray(arg), 0));
     RubyArray args = new RubyArray(arg);
     s = StringMe.format(format, args);
   }
   return ObjectFactory.createString(s);
 }
Exemple #19
0
  // @RubyLevelMethod(name="[]")
  public RubyValue aref(RubyValue arg) {
    if (arg instanceof RubyFixnum) {
      int index = arg.toInt();
      if (index < 0) index += result_.groups();

      String res = result_.group(index);
      if (res == null) return RubyConstant.QNIL;

      return ObjectFactory.createString(res);
    } else if (arg instanceof RubyString) {
      // TODO: implement m = /(?<foo>a+)b/.match("ccaaab"); m["foo"]   #=> "aaa"
      throw new RuntimeException("Not implemented");
    }

    RubyArray ar = (RubyArray) to_a();
    return ar.aref(arg);
  }
Exemple #20
0
  private RubyValue substring(String string, int begin, int end, boolean isExcludeEnd) {

    if (begin < 0) {
      begin = string.length() + begin;
    }

    if (end < 0) {
      end = string.length() + end;
    }

    if (!isExcludeEnd) {
      ++end;
    }

    if (begin < 0 || end < 0 || begin > end || begin > string.length() || end > string.length()) {
      return RubyConstant.QNIL;
    }

    return ObjectFactory.createString(string.substring(begin, end));
  }
 @RubyLevelMethod(name = "to_s")
 public static RubyValue anyObjToS(RubyValue receiver) {
   String className = receiver.getRubyClass().getName();
   return ObjectFactory.createString(
       "#<" + className + ":0x" + Integer.toHexString(receiver.hashCode()) + "x>");
 }
 @RubyLevelMethod(name = "inspect")
 public static RubyValue objInsepct(RubyValue receiver) {
   return ObjectFactory.createString(receiver.inspect());
 }
Exemple #23
0
 // @RubyLevelMethod(name="+")
 public RubyString plus(RubyValue v) {
   StringBuffer sb = new StringBuffer();
   sb.append(this.sb_);
   sb.append(v.toRubyString().sb_);
   return ObjectFactory.createString(sb);
 }
Exemple #24
0
 @RubyLevelMethod(name = "to_s")
 public RubyString to_s() {
   return ObjectFactory.createString(this.toString());
 }
Exemple #25
0
 // @RubyAllocMethod
 public static RubyString alloc(RubyValue receiver) {
   return ObjectFactory.createString((RubyClass) receiver, "");
 }
Exemple #26
0
 // @RubyLevelMethod(name="to_s")
 public RubyString to_s() {
   return ObjectFactory.createString(this.sb_.toString());
 }
Exemple #27
0
 // @RubyLevelMethod(name="to_s")
 public RubyString to_s() {
   return ObjectFactory.createString(result_.toString());
 }
Exemple #28
0
 // @RubyLevelMethod(name="strip")
 public RubyString strip() {
   return ObjectFactory.createString(sb_.toString().trim());
 }
Exemple #29
0
 // @RubyLevelMethod(name="pack")
 public RubyValue pack(RubyValue arg) {
   String format = ((RubyString) arg).toString();
   return ObjectFactory.createString(ArrayPacker.pack(this, format));
 }
Exemple #30
0
 // @RubyLevelMethod(name="dump")
 public RubyString rubyDump() {
   return ObjectFactory.createString(this.dump());
 }