opal · Nov 13, 2013 · Nov 13, 2013 · Nov 13, 2013 · Nov 13, 2013 · Nov 13, 2013
Showing with 124 additions and 120 deletions.

+83 −0 opal/core/helpers.rb

+2 −8 opal/core/regexp.rb

+33 −24 opal/core/string.rb

+1 −84 opal/opal.rb

+2 −3 spec/filters/bugs/string.rb

+3 −1 tasks/mspec.rake
diff --git a/opal/core/helpers.rb b/opal/core/helpers.rb
@@ -0,0 +1,83 @@
+module Opal
+  def self.coerce_to(object, type, method)
+    return object if type === object
+
+    unless object.respond_to? method
+      raise TypeError, "no implicit conversion of #{object.class} into #{type}"
+    end
+
+    object.__send__ method
+  end
+
+  def self.coerce_to!(object, type, method)
+    coerced = coerce_to(object, type, method)
+
+    unless type === coerced
+      raise TypeError, "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+    end
+
+    coerced
+  end
+
+  def self.try_convert(object, type, method)
+    return object if type === object
+
+    if object.respond_to? method
+      object.__send__ method
+    end
+  end
+
+  def self.compare(a, b)
+    compare = a <=> b
+
+    if `compare === nil`
+      raise ArgumentError, "comparison of #{a.class.name} with #{b.class.name} failed"
+    end
+
+    compare
+  end
+
+  def self.fits_fixnum!(value)
+    # since we have Fixnum#size as 32 bit, this is based on the int limits
+    if `value > 2147483648`
+      raise RangeError, "bignum too big to convert into `long'"
+    end
+  end
+
+  def self.fits_array!(value)
+    # this is the computed ARY_MAX_SIZE for 32 bit
+    if `value >= 536870910`
+      raise ArgumentError, "argument too big"
+    end
+  end
+
+  def self.truthy?(value)
+    if value
+      true
+    else
+      false
+    end
+  end
+
+  def self.falsy?(value)
+    if value
+      false
+    else
+      true
+    end
+  end
+
+  def self.destructure(args)
+    %x{
+      if (args.length == 1) {
+        return args[0];
+      }
+      else if (args._isArray) {
+        return args;
+      }
+      else {
+        return $slice.call(args);
+      }
+    }
+  end
+end
diff --git a/opal/core/regexp.rb b/opal/core/regexp.rb
@@ -2,7 +2,7 @@ class Regexp
   `def._isRegexp = true`
 
   def self.escape(string)
-    `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\|]/g, '\\\\$&')`
+    `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\| ]/g, '\\\\$&')`
   end
 
   def self.union(*parts)
@@ -36,13 +36,7 @@ def =~(string)
       return
     end
 
-    if `string._isString == null`
-      unless string.respond_to? :to_str
-        raise TypeError, "no implicit conversion of #{string.class} into String"
-      end
-
-      string = string.to_str
-    end
+    string = Opal.coerce_to(string, String, :to_str).to_s
 
     %x{
       var re = self;

diff --git a/opal/core/string.rb b/opal/core/string.rb
@@ -323,44 +323,53 @@ def include?(other)
   end
 
   def index(what, offset = nil)
-    %x{
-      if (!(what._isString || what._isRegexp)) {
-        #{raise TypeError, "type mismatch: #{what.class} given"};
-      }
+    if String === what
+      what = what.to_s
+    elsif what.respond_to? :to_str
+      what = what.to_str.to_s
+    elsif not Regexp === what
+      raise TypeError, "type mismatch: #{what.class} given"
+    end
 
-      var result = -1;
+    result = -1
+
+    if offset
+      offset = Opal.coerce_to offset, Integer, :to_int
+
+      %x{
+        var size = self.length;
 
-      if (offset !== nil) {
         if (offset < 0) {
-          offset = offset + self.length;
+          offset = offset + size;
         }
 
-        if (offset > self.length) {
+        if (offset > size) {
           return nil;
         }
+      }
 
-        if (what._isRegexp) {
-          result = #{(what =~ `self.substr(offset)`) || -1}
-        }
-        else {
-          result = self.substr(offset).indexOf(what);
-        }
+      if Regexp === what
+        result = (what =~ `self.substr(offset)`) || -1
+      else
+        result = `self.substr(offset).indexOf(what)`
+      end
 
+      %x{
         if (result !== -1) {
           result += offset;
         }
       }
-      else {
-        if (what._isRegexp) {
-          result = #{(what =~ self) || -1}
-        }
-        else {
-          result = self.indexOf(what);
-        }
-      }
+    else
+      if Regexp === what
+        result = (what =~ self) || -1
+      else
+        result = `self.indexOf(what)`
+      end
+    end
 
-      return result === -1 ? nil : result;
-    }
+    unless `result === -1`
+      result
+    end
   end
 
   def inspect

diff --git a/opal/opal.rb b/opal/opal.rb
@@ -1,4 +1,5 @@
 require 'core/runtime'
+require 'core/helpers'
 require 'core/module'
 require 'core/class'
 require 'core/basic_object'
@@ -48,87 +49,3 @@
 RUBY_VERSION        = '2.0.0'
 RUBY_ENGINE_VERSION = '0.5.2'
 RUBY_RELEASE_DATE   = '2013-11-11'
-
-module Opal
-  def self.coerce_to(object, type, method)
-    return object if type === object
-
-    unless object.respond_to? method
-      raise TypeError, "no implicit conversion of #{object.class} into #{type}"
-    end
-
-    object.__send__ method
-  end
-
-  def self.coerce_to!(object, type, method)
-    coerced = coerce_to(object, type, method)
-
-    unless type === coerced
-      raise TypeError, "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
-    end
-
-    coerced
-  end
-
-  def self.try_convert(object, type, method)
-    return object if type === object
-
-    if object.respond_to? method
-      object.__send__ method
-    end
-  end
-
-  def self.compare(a, b)
-    compare = a <=> b
-
-    if `compare === nil`
-      raise ArgumentError, "comparison of #{a.class.name} with #{b.class.name} failed"
-    end
-
-    compare
-  end
-
-  def self.fits_fixnum!(value)
-    # since we have Fixnum#size as 32 bit, this is based on the int limits
-    if `value > 2147483648`
-      raise RangeError, "bignum too big to convert into `long'"
-    end
-  end
-
-  def self.fits_array!(value)
-    # this is the computed ARY_MAX_SIZE for 32 bit
-    if `value >= 536870910`
-      raise ArgumentError, "argument too big"
-    end
-  end
-
-  def self.truthy?(value)
-    if value
-      true
-    else
-      false
-    end
-  end
-
-  def self.falsy?(value)
-    if value
-      false
-    else
-      true
-    end
-  end
-
-  def self.destructure(args)
-    %x{
-      if (args.length == 1) {
-        return args[0];
-      }
-      else if (args._isArray) {
-        return args;
-      }
-      else {
-        return $slice.call(args);
-      }
-    }
-  end
-end
diff --git a/spec/filters/bugs/string.rb b/spec/filters/bugs/string.rb
@@ -8,12 +8,11 @@
   fails "String#size returns the length of self"
   fails "String#length returns the length of self"
 
-  fails "String#index with Regexp converts start_offset to an integer via to_int"
+  # we need regexp rewriting for these
   fails "String#index with Regexp supports \\G which matches at the given start offset"
   fails "String#index with Regexp starts the search at the given offset"
   fails "String#index with Regexp returns the index of the first match of regexp"
-  fails "String#index calls #to_int to convert the second argument"
-  fails "String#index calls #to_str to convert the first argument"
+
   fails "String#index raises a TypeError if passed a Symbol"
 
   fails "String#intern special cases +(binary) and -(binary)"

diff --git a/tasks/mspec.rake b/tasks/mspec.rake
@@ -102,7 +102,9 @@ class RunSpec
     specs << (file.nil? ? Dir.glob("#{Dir.pwd}/spec/**/*_spec.{rb,opal}") : file)
 
     # add any rubyspecs we want to run (defined in spec/rubyspecs)
-    specs.push File.read('spec/rubyspecs').split("\n").reject(&:empty?)
+    specs.push File.read('spec/rubyspecs').split("\n").reject {|line|
+      line.empty? || line.start_with?('#')
+    }
 
     specs.flatten
   end