opal-connect-rspec 0.5.0

data/opal/opal/rspec/fixes/opal/corelib.rb

@@ -0,0 +1,3 @@
+# struct is done in pre-require fixes
+require_relative 'corelib/regexp'
+require_relative 'corelib/error'

data/opal/opal/rspec/fixes/opal/corelib/error.rb

@@ -0,0 +1,61 @@
+unless Opal::RSpec::Compatibility.exception_inspect_matches?
+  # https://github.com/opal/opal/pull/1134 and https://github.com/opal/opal/pull/1151
+  # only doing this fix in the tests since it's actual uses of opal-rspec will probably not zero in on the failure
+  Exception.remove_method(:to_s)
+  class Exception
+    def message
+      to_s
+    end
+
+    def inspect
+      as_str = to_s
+      as_str.empty? ? self.class.to_s : "#<#{self.class.to_s}: #{to_s}>"
+    end
+
+    def to_s
+      (@message && @message.to_s) || self.class.to_s
+    end
+  end
+end
+
+# https://github.com/opal/opal/pull/1151 - should be fixed in Opal 0.9
+unless Opal::RSpec::Compatibility.exception_exception_method_works?
+  class Exception
+    def self.new(*args)
+      # undefined check can be removed if https://github.com/opal/opal/pull/1117 happens
+      %x{
+          var message = (args.length > 0 && args[0] !== undefined) ? args[0] : nil;
+          var err = new self.$$alloc(message);
+
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(err);
+          }
+
+          err.name = self.$$name;
+          err.$initialize.apply(err, args);
+          return err;
+        }
+    end
+
+    def self.exception(*args)
+      new(*args)
+    end
+
+    def initialize(*args)
+      # undefined check can be removed if https://github.com/opal/opal/pull/1117 happens
+      `self.message = (args.length > 0 && args[0] !== undefined) ? args[0] : nil`
+    end
+
+    def exception(str=nil)
+      %x{
+          if (str === nil || self === str) {
+            return self;
+          }
+
+          var cloned = #{self.clone};
+          cloned.message = str;
+          return cloned;
+        }
+    end
+  end
+end

data/opal/opal/rspec/fixes/opal/corelib/regexp.rb

@@ -0,0 +1,92 @@
+# https://github.com/opal/opal/pull/1129
+unless Opal::RSpec::Compatibility.multiline_regex_works? && Opal::RSpec::Compatibility.empty_regex_works?
+  class Regexp
+    # https://github.com/opal/opal/pull/1129
+    unless Opal::RSpec::Compatibility.empty_regex_works?
+      class << self
+        def allocate
+          allocated = super
+          `#{allocated}.un_initialized = true`
+          allocated
+        end
+      end
+
+      def options
+        %x{
+            if (self.un_initialized) {
+              #{raise TypeError, 'uninitialized Regexp'}
+            }
+            var result = 0;
+            // should be supported in IE6 according to https://msdn.microsoft.com/en-us/library/7f5z26w4(v=vs.94).aspx
+            if (self.multiline) {
+              result |= #{MULTILINE};
+            }
+            if (self.ignoreCase) {
+              result |= #{IGNORECASE};
+            }
+            return result;
+          }
+      end
+    end
+
+    # https://github.com/opal/opal/pull/1129
+    unless Opal::RSpec::Compatibility.regex_case_compare_works?
+      def ===(string)
+        `#{match(Opal.coerce_to?(string, String, :to_str))} !== nil`
+      end
+    end
+
+    unless Opal::RSpec::Compatibility.multiline_regex_works?
+      # https://github.com/opal/opal/pull/1129
+      def match(string, pos = undefined, &block)
+        %x{
+          if (self.un_initialized) {
+            #{raise TypeError, 'uninitialized Regexp'}
+          }
+
+          if (pos === undefined) {
+            pos = 0;
+          } else {
+            pos = #{Opal.coerce_to(pos, Integer, :to_int)};
+          }
+
+          if (string === nil) {
+            return #{$~ = nil};
+          }
+
+          string = #{Opal.coerce_to(string, String, :to_str)};
+
+          if (pos < 0) {
+            pos += string.length;
+            if (pos < 0) {
+              return #{$~ = nil};
+            }
+          }
+
+          var source = self.source;
+          var flags = 'g';
+          // m flag + a . in Ruby will match white space, but in JS, it only matches beginning/ending of lines, so we get the equivalent here
+          if (self.multiline) {
+            source = source.replace('.', "[\\s\\S]");
+            flags += 'm';
+          }
+
+          // global RegExp maintains state, so not using self/this
+          var md, re = new RegExp(source, flags + (self.ignoreCase ? 'i' : ''));
+
+          while (true) {
+            md = re.exec(string);
+            if (md === null) {
+              return #{$~ = nil};
+            }
+            if (md.index >= pos) {
+              #{$~ = MatchData.new(`re`, `md`)}
+              return block === nil ? #{$~} : #{block.call($~)};
+            }
+            re.lastIndex = md.index + 1;
+          }
+        }
+      end
+    end
+  end
+end

data/opal/opal/rspec/fixes/opal/corelib/struct.rb

@@ -0,0 +1,260 @@
+unless Opal::RSpec::Compatibility.is_struct_hash_correct?
+  module Opal
+    def self.valid_method_name?(method_name)
+      method_name = Opal.coerce_to!(method_name, String, :to_str)
+
+      `/^[a-zA-Z_][a-zA-Z0-9_]*?$/.test(method_name)`
+    end
+  end
+
+  # Struct was rewritten in Opal 0.9
+  # https://github.com/opal/opal/blob/1a33f23fdb4b07ff07b89f8077da060f1fdb635c/opal/corelib/struct.rb
+  # Then a hash fix for Struct (which keeps deprectation formatter from grouping properly) was submitted in https://github.com/opal/opal/pull/1123
+  # For simplicity's sake, cut and pasted entire Opal 0.9 struct class here
+
+  # Native monkey patches struct's initializer, so get it in first
+  require 'native'
+
+  class Struct
+    include Enumerable
+
+    def self.new(name = undefined, *args, &block)
+      return super unless self == Struct
+
+      if name[0] == name[0].upcase
+        Struct.const_set(name, new(*args))
+      else
+        args.unshift name
+
+        Class.new(self) {
+          args.each { |arg| define_struct_attribute arg }
+
+          instance_eval(&block) if block
+
+          class << self
+            def new(*args)
+              instance = allocate
+              `#{instance}.$$data = {};`
+              instance.initialize(*args)
+              instance
+            end
+
+            alias [] new
+          end
+        }
+      end
+    end
+
+    def self.define_struct_attribute(name)
+      if self == Struct
+        raise ArgumentError, 'you cannot define attributes to the Struct class'
+      end
+
+      members << name
+
+      define_method name do
+        self[name]
+      end
+
+      define_method "#{name}=" do |value|
+        self[name] = value
+      end
+    end
+
+    def self.members
+      if self == Struct
+        raise ArgumentError, 'the Struct class has no members'
+      end
+
+      @members ||= []
+    end
+
+    def self.inherited(klass)
+      members = @members
+
+      klass.instance_eval {
+        @members = members
+      }
+    end
+
+    def initialize(*args)
+      members.each_with_index { |name, index|
+        self[name] = args[index]
+      }
+    end
+
+    def members
+      self.class.members
+    end
+
+    def [](name)
+      if Integer === name
+        raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
+        raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+
+        name = members[name]
+      elsif String === name
+        raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+      else
+        raise TypeError, "no implicit conversion of #{name.class} into Integer"
+      end
+
+      name = Opal.coerce_to!(name, String, :to_str)
+      `self.$$data[name]`
+    end
+
+    def []=(name, value)
+      if Integer === name
+        raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
+        raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+
+        name = members[name]
+      elsif String === name
+        raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+      else
+        raise TypeError, "no implicit conversion of #{name.class} into Integer"
+      end
+
+      name = Opal.coerce_to!(name, String, :to_str)
+      `self.$$data[name] = value`
+    end
+
+    def ==(other)
+      return false unless other.instance_of?(self.class)
+
+      %x{
+          var recursed1 = {}, recursed2 = {};
+
+          function _eqeq(struct, other) {
+            var key, a, b;
+
+            recursed1[#{`struct`.__id__}] = true;
+            recursed2[#{`other`.__id__}] = true;
+
+            for (key in struct.$$data) {
+              a = struct.$$data[key];
+              b = other.$$data[key];
+
+              if (#{Struct === `a`}) {
+                if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
+                  if (!_eqeq(a, b)) {
+                    return false;
+                  }
+                }
+              } else {
+                if (!#{`a` == `b`}) {
+                  return false;
+                }
+              }
+            }
+
+            return true;
+          }
+
+          return _eqeq(self, other);
+        }
+    end
+
+    def hash
+      Hash.new(`self.$$data`).hash
+    end
+
+    def eql?(other)
+      return false unless other.instance_of?(self.class)
+
+      %x{
+          var recursed1 = {}, recursed2 = {};
+
+          function _eqeq(struct, other) {
+            var key, a, b;
+
+            recursed1[#{`struct`.__id__}] = true;
+            recursed2[#{`other`.__id__}] = true;
+
+            for (key in struct.$$data) {
+              a = struct.$$data[key];
+              b = other.$$data[key];
+
+              if (#{Struct === `a`}) {
+                if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
+                  if (!_eqeq(a, b)) {
+                    return false;
+                  }
+                }
+              } else {
+                if (!#{`a`.eql?(`b`)}) {
+                  return false;
+                }
+              }
+            }
+
+            return true;
+          }
+
+          return _eqeq(self, other);
+        }
+    end
+
+    def each
+      return enum_for(:each) { self.size } unless block_given?
+
+      members.each { |name| yield self[name] }
+      self
+    end
+
+    def each_pair
+      return enum_for(:each_pair) { self.size } unless block_given?
+
+      members.each { |name| yield [name, self[name]] }
+      self
+    end
+
+    def length
+      members.length
+    end
+
+    alias size length
+
+    def to_a
+      members.map { |name| self[name] }
+    end
+
+    alias values to_a
+
+    def inspect
+      result = "#<struct "
+
+      if self.class == Struct
+        result += "#{self.class} "
+      end
+
+      result += each_pair.map { |name, value|
+        "#{name}=#{value.inspect}"
+      }.join ", "
+
+      result += ">"
+
+      result
+    end
+
+    alias to_s inspect
+
+    def to_h
+      members.inject({}) { |h, name| h[name] = self[name]; h }
+    end
+
+    def values_at(*args)
+      args = args.map { |arg| `arg.$$is_range ? #{arg.to_a} : arg` }.flatten
+      %x{
+          var result = [];
+          for (var i = 0, len = args.length; i < len; i++) {
+            if (!args[i].$$is_number) {
+              #{raise TypeError, "no implicit conversion of #{`args[i]`.class} into Integer"}
+            }
+            result.push(#{self[`args[i]`]});
+          }
+          return result;
+        }
+    end
+  end
+end

data/opal/opal/rspec/fixes/opal/kernel.rb

@@ -0,0 +1,80 @@
+module Kernel
+  unless Opal::RSpec::Compatibility.clones_singleton_methods?
+    def copy_singleton_methods(other)
+      %x{
+            var name;
+            if (other.hasOwnProperty('$$meta')) {
+              var other_singleton_class_proto = Opal.get_singleton_class(other).$$proto;
+              var self_singleton_class_proto = Opal.get_singleton_class(self).$$proto;
+              for (name in other_singleton_class_proto) {
+                if (name.charAt(0) === '$' && other_singleton_class_proto.hasOwnProperty(name)) {
+                  self_singleton_class_proto[name] = other_singleton_class_proto[name];
+                }
+              }
+            }
+            for (name in other) {
+              if (name.charAt(0) === '$' && name.charAt(1) !== '$' && other.hasOwnProperty(name)) {
+                self[name] = other[name];
+              }
+            }
+          }
+    end
+
+    def clone
+      copy = self.class.allocate
+
+      copy.copy_instance_variables(self)
+      copy.copy_singleton_methods(self)
+      copy.initialize_clone(self)
+
+      copy
+    end
+  end
+
+  # RSpec tries to add context with this. something like this: https://github.com/stacktracejs/stacktrace.js would be better than this but
+  # avoiding adding an NPM dependency for now
+  def caller
+    %x{
+      function getErrorObject(){
+          try { throw Error('') } catch(err) { return err; }
+      }
+
+
+      var err = getErrorObject();
+    }
+    stack = `err.stack`
+    caller_lines = stack.split("\n")[4..-1]
+    caller_lines.reject! { |l| l.strip.empty? }
+
+    result_formatter = lambda do |filename, line, method=nil|
+      "#{filename}:#{line} in `(#{method ? method : 'unknown method'})'"
+    end
+
+    caller_lines.map do |raw_line|
+      if match = /\s*at (.*) \((\S+):(\d+):\d+/.match(raw_line)
+        method, filename, line = match.captures
+        result_formatter[filename, line, method]
+      elsif match = /\s*at (\S+):(\d+):\d+/.match(raw_line)
+        filename, line = match.captures
+        result_formatter[filename, line]
+        # catch phantom/no 2nd line/col #
+      elsif match = /\s*at (.*) \((\S+):(\d+)/.match(raw_line)
+        method, filename, line = match.captures
+        result_formatter[filename, line, method]
+      elsif match = /\s*at (.*):(\d+)/.match(raw_line)
+        filename, line = match.captures
+        result_formatter[filename, line]
+        # Firefox - Opal.modules["rspec/core/metadata"]/</</</</def.$populate@http://192.168.59.103:9292/assets/rspec/core/metadata.self.js?body=1:102:13
+      elsif match = /(.*?)@(\S+):(\d+):\d+/.match(raw_line)
+        method, filename, line = match.captures
+        result_formatter[filename, line, method]
+        # webkit - http://192.168.59.103:9292/assets/opal/rspec/sprockets_runner.js:45117:314
+      elsif match = /(\S+):(\d+):\d+/.match(raw_line)
+        filename, line = match.captures
+        result_formatter[filename, line]
+      else
+        "#{filename}:-1 in `(can't parse this stack trace)`"
+      end
+    end
+  end
+end