jruby · Nov 28, 2014 · Nov 28, 2014 · Nov 28, 2014 · Nov 28, 2014 · Nov 28, 2014
diff --git a/core/src/main/java/org/jruby/ast/ComplexNode.java b/core/src/main/java/org/jruby/ast/ComplexNode.java
@@ -41,4 +41,8 @@ public NodeType getNodeType() {
     public Node getNumber() {
         return y;
     }
+
+    public void setNumber(Node y) {
+        this.y = y;
+    }
 }
diff --git a/core/src/main/java/org/jruby/parser/ParserSupport.java b/core/src/main/java/org/jruby/parser/ParserSupport.java
@@ -1037,6 +1037,18 @@ public FloatNode negateFloat(FloatNode floatNode) {
 
         return floatNode;
     }
+
+    public ComplexNode negateComplexNode(ComplexNode complexNode) {
+        complexNode.setNumber(negateNumeric(complexNode.getPosition(), complexNode.getNumber()));
+
+        return complexNode;
+    }
+
+    public RationalNode negateRational(RationalNode rationalNode) {
+        return new RationalNode(rationalNode.getPosition(),
+                                -rationalNode.getNumerator(),
+                                rationalNode.getDenominator());
+    }
 
     public Node unwrapNewlineNode(Node node) {
     	if(node instanceof NewlineNode) {
@@ -1414,10 +1426,12 @@ public Node negateNumeric(ISourcePosition position, Node node) {
             case FIXNUMNODE:
             case BIGNUMNODE:
                 return negateInteger(node);
-            case COMPLEXNODE: // FIXME: impl
-                // COMPLEX
+            case COMPLEXNODE:
+                return negateComplexNode((ComplexNode) node);
             case FLOATNODE:
                 return negateFloat((FloatNode) node);
+            case RATIONALNODE:
+                return negateRational((RationalNode) node);
         }
 
         yyerror("Invalid or unimplemented numeric to negate: " + node.toString());

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java
@@ -635,13 +635,15 @@ public Object getObject(RubyArray array, int index, int length) {
         public Object getObject(RubyArray array, RubyRange.IntegerFixnumRange range, UndefinedPlaceholder undefined) {
             notDesignedForCompilation();
 
-            int normalisedIndex = array.normaliseIndex(range.getBegin());
-            int length = array.normaliseExclusiveIndex(range.getExclusiveEnd()) - normalisedIndex;
+            final int normalisedIndex = array.normaliseIndex(range.getBegin());
 
             if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
                 return getContext().getCoreLibrary().getNilObject();
             } else {
-                return new RubyArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOfRange((Object[]) array.getStore(), normalisedIndex, normalisedIndex + length), length);
+                final int end = array.normaliseIndex(range.getEnd());
+                final int excludingEnd = array.clampExclusiveIndex(range.doesExcludeEnd() ? end : end+1);
+
+                return new RubyArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOfRange((Object[]) array.getStore(), normalisedIndex, excludingEnd), excludingEnd - normalisedIndex);
             }
         }
 
@@ -2069,7 +2071,7 @@ public RubyString inspect(VirtualFrame frame, RubyArray array) {
 
     }
 
-    @CoreMethod(names = "join", required = 1)
+    @CoreMethod(names = "join", optional = 1)
     public abstract static class JoinNode extends ArrayCoreMethodNode {
 
         public JoinNode(RubyContext context, SourceSection sourceSection) {
@@ -2080,6 +2082,20 @@ public JoinNode(JoinNode prev) {
             super(prev);
         }
 
+        @Specialization
+        public RubyString join(RubyArray array, UndefinedPlaceholder unused) {
+            Object separator = getContext().getCoreLibrary().getGlobalVariablesObject().getInstanceVariable("$,");
+            if (separator == getContext().getCoreLibrary().getNilObject()) {
+                separator = getContext().makeString("");
+            }
+
+            if (separator instanceof RubyString) {
+                return join(array, (RubyString) separator);
+            } else {
+                throw new UnsupportedOperationException();
+            }
+        }
+
         @Specialization
         public RubyString join(RubyArray array, RubyString separator) {
             notDesignedForCompilation();

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/RegexpNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/RegexpNodes.java
@@ -9,10 +9,12 @@
  */
 package org.jruby.truffle.nodes.core;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.source.*;
 import com.oracle.truffle.api.dsl.*;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import org.jruby.runtime.Visibility;
+import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNode;
 import org.jruby.truffle.runtime.*;
 import org.jruby.truffle.runtime.core.*;
@@ -21,6 +23,27 @@
 @CoreClass(name = "Regexp")
 public abstract class RegexpNodes {
 
+    public abstract static class EscapingNode extends CoreMethodNode {
+
+        @Child protected EscapeNode escapeNode;
+
+        public EscapingNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EscapingNode(EscapingNode prev) {
+            super(prev);
+        }
+
+        protected RubyString escape(VirtualFrame frame, RubyString string) {
+            if (escapeNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                escapeNode = insert(RegexpNodesFactory.EscapeNodeFactory.create(getContext(), getSourceSection(), new RubyNode[]{null}));
+            }
+            return escapeNode.executeEscape(frame, string);
+        }
+    }
+
     @CoreMethod(names = "==", required = 1)
     public abstract static class EqualNode extends CoreMethodNode {
 
@@ -103,8 +126,10 @@ public EscapeNode(EscapeNode prev) {
             super(prev);
         }
 
+        public abstract RubyString executeEscape(VirtualFrame frame, RubyString pattern);
+
         @Specialization
-        public RubyString sqrt(RubyString pattern) {
+        public RubyString escape(RubyString pattern) {
             notDesignedForCompilation();
 
             return getContext().makeString(org.jruby.RubyRegexp.quote19(new ByteList(pattern.getBytes()), true).toString());

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java
@@ -10,6 +10,7 @@
 package org.jruby.truffle.nodes.core;
 
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -26,7 +27,9 @@
 import org.jruby.util.ByteList;
 import org.jruby.util.Pack;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.regex.Pattern;
 
 @CoreClass(name = "String")
@@ -185,15 +188,15 @@ public GetIndexNode(GetIndexNode prev) {
             super(prev);
         }
 
-        @Specialization(rewriteOn=UnexpectedResultException.class)
+        @Specialization(rewriteOn = UnexpectedResultException.class)
         public RubyString getIndexInBounds(RubyString string, int index, UndefinedPlaceholder undefined) throws UnexpectedResultException {
             final int normalisedIndex = string.normaliseIndex(index);
             final ByteList bytes = string.getBytes();
 
-            if (normalisedIndex < 0 || normalisedIndex + 1 >= bytes.length()) {
+            if (normalisedIndex < 0 || normalisedIndex >= bytes.length()) {
                 throw new UnexpectedResultException(getContext().getCoreLibrary().getNilObject());
             } else {
-                return new RubyString(getContext().getCoreLibrary().getStringClass(), (ByteList) bytes.subSequence(index, index + 1));
+                return getContext().makeString(bytes.charAt(normalisedIndex));
             }
         }
 
@@ -202,27 +205,27 @@ public Object getIndex(RubyString string, int index, UndefinedPlaceholder undefi
             int normalisedIndex = string.normaliseIndex(index);
             final ByteList bytes = string.getBytes();
 
-            if (normalisedIndex < 0 || normalisedIndex + 1 >= bytes.length()) {
+            if (normalisedIndex < 0 || normalisedIndex >= bytes.length()) {
                 return getContext().getCoreLibrary().getNilObject();
             } else {
-                return new RubyString(getContext().getCoreLibrary().getStringClass(), (ByteList) bytes.subSequence(index, index + 1));
+                return getContext().makeString(bytes.charAt(normalisedIndex));
             }
         }
 
         @Specialization
-        public RubyString getIndex(RubyString string, RubyRange.IntegerFixnumRange range, UndefinedPlaceholder undefined) {
+        public Object getIndex(RubyString string, RubyRange.IntegerFixnumRange range, UndefinedPlaceholder undefined) {
             notDesignedForCompilation();
 
             final String javaString = string.toString();
+            final int begin = string.normaliseIndex(range.getBegin());
 
-            if (range.doesExcludeEnd()) {
-                final int begin = string.normaliseIndex(range.getBegin());
-                final int exclusiveEnd = string.normaliseExclusiveIndex(range.getExclusiveEnd());
-                return getContext().makeString(javaString.substring(begin, exclusiveEnd));
+            if (begin < 0 || begin >= javaString.length()) {
+                return getContext().getCoreLibrary().getNilObject();
             } else {
-                final int begin = string.normaliseIndex(range.getBegin());
-                final int inclusiveEnd = string.normaliseIndex(range.getInclusiveEnd());
-                return getContext().makeString(javaString.substring(begin, inclusiveEnd + 1));
+                final int end = string.normaliseIndex(range.getEnd());
+                final int excludingEnd = string.clampExclusiveIndex(range.doesExcludeEnd() ? end : end+1);
+
+                return getContext().makeString(javaString.substring(begin, excludingEnd));
             }
         }
 
@@ -231,7 +234,7 @@ public RubyString getIndex(RubyString string, int start, int length) {
             // TODO(CS): not sure if this is right - encoding
             // TODO(CS): why does subSequence return CharSequence?
             final int begin = string.normaliseIndex(start);
-            final int exclusiveEnd = string.normaliseExclusiveIndex(start + length);
+            final int exclusiveEnd = string.normaliseIndex(start + length);
             return new RubyString(getContext().getCoreLibrary().getStringClass(), (ByteList) string.getBytes().subSequence(begin, exclusiveEnd - begin));
         }
 
@@ -359,6 +362,45 @@ public RubyString downcase(RubyString string) {
         }
     }
 
+    @CoreMethod(names = "each_line")
+    public abstract static class EachLineNode extends YieldingCoreMethodNode {
+
+        public EachLineNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EachLineNode(EachLineNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public RubyArray eachLine(RubyString string) {
+            notDesignedForCompilation();
+
+            final List<Object> lines = new ArrayList<>();
+
+            String str = string.toString();
+            int start = 0;
+
+            while (start < str.length()) {
+                int end = str.indexOf('\n', start);
+
+                if (end == -1) {
+                    lines.add(getContext().makeString(str.substring(start)));
+                    break;
+                }
+
+                String line = str.substring(start, end+1);
+                start = end+1;
+
+                lines.add(getContext().makeString(line));
+            }
+
+            return RubyArray.fromObjects(getContext().getCoreLibrary().getArrayClass(), lines.toArray(new Object[lines.size()]));
+        }
+
+    }
+
     @CoreMethod(names = "empty?")
     public abstract static class EmptyNode extends CoreMethodNode {
 
@@ -440,7 +482,7 @@ public RubyString forceEncoding(RubyString string, RubyString encodingName) {
     }
 
     @CoreMethod(names = "gsub", required = 2)
-    public abstract static class GsubNode extends CoreMethodNode {
+    public abstract static class GsubNode extends RegexpNodes.EscapingNode {
 
         public GsubNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
@@ -451,10 +493,10 @@ public GsubNode(GsubNode prev) {
         }
 
         @Specialization
-        public RubyString gsub(RubyString string, RubyString regexpString, RubyString replacement) {
+        public RubyString gsub(VirtualFrame frame, RubyString string, RubyString regexpString, RubyString replacement) {
             notDesignedForCompilation();
 
-            final RubyRegexp regexp = new RubyRegexp(this, getContext().getCoreLibrary().getRegexpClass(), regexpString.toString(), Option.DEFAULT);
+            final RubyRegexp regexp = new RubyRegexp(this, getContext().getCoreLibrary().getRegexpClass(), escape(frame, regexpString).toString(), Option.DEFAULT);
             return gsub(string, regexp, replacement);
         }
 
@@ -634,6 +676,32 @@ public RubyString rjust(RubyString string, int length, RubyString padding) {
 
     }
 
+    @CoreMethod(names = "rstrip")
+    public abstract static class RStripNode extends CoreMethodNode {
+
+        public RStripNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public RStripNode(RStripNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public RubyString rstrip(RubyString string) {
+            notDesignedForCompilation();
+
+            String str = string.toString();
+            int last = str.length()-1;
+            while (last >= 0 && " \r\n\t".indexOf(str.charAt(last)) != -1) {
+                last--;
+            }
+
+            return getContext().makeString(str.substring(0, last+1));
+        }
+
+    }
+
     @CoreMethod(names = "scan", required = 1)
     public abstract static class ScanNode extends CoreMethodNode {
 
@@ -751,6 +819,33 @@ public boolean endWith(RubyString string, RubyString b) {
         }
     }
 
+    @CoreMethod(names = "sub", required = 2)
+    public abstract static class SubNode extends RegexpNodes.EscapingNode {
+
+        public SubNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public SubNode(SubNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public RubyString sub(VirtualFrame frame, RubyString string, RubyString regexpString, RubyString replacement) {
+            notDesignedForCompilation();
+
+            final RubyRegexp regexp = new RubyRegexp(this, getContext().getCoreLibrary().getRegexpClass(), escape(frame, regexpString).toString(), Option.DEFAULT);
+            return sub(string, regexp, replacement);
+        }
+
+        @Specialization
+        public RubyString sub(RubyString string, RubyRegexp regexp, RubyString replacement) {
+            notDesignedForCompilation();
+
+            return regexp.sub(string.toString(), replacement.toString());
+        }
+    }
+
     @CoreMethod(names = "sum")
     public abstract static class SumNode extends CoreMethodNode {
 

diff --git a/core/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java b/core/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
@@ -247,6 +247,7 @@ public void initialize() {
         globalVariablesObject.setInstanceVariable("$LOADED_FEATURES", new RubyArray(arrayClass));
         globalVariablesObject.setInstanceVariable("$:", globalVariablesObject.getInstanceVariable("$LOAD_PATH"));
         globalVariablesObject.setInstanceVariable("$\"", globalVariablesObject.getInstanceVariable("$LOADED_FEATURES"));
+        globalVariablesObject.setInstanceVariable("$,", nilObject);
 
         initializeEncodingConstants();