opal-rspec 0.5.0.beta2 → 0.5.0.beta3

data/opal/opal/rspec/fixes/rspec/expectations.rb

@@ -0,0 +1,2 @@
+require_relative 'expectations/fail_with'
+require_relative 'expectations/syntax'

data/opal/opal/rspec/fixes/rspec/expectations/syntax.rb

@@ -0,0 +1,25 @@
+unless Opal::RSpec::Compatibility.undef_within_exec_works?
+  module ::RSpec::Expectations::Syntax
+    def disable_expect(syntax_host=::RSpec::Matchers)
+      return unless expect_enabled?(syntax_host)
+
+      # undef not working on Opal 0.8
+      # syntax_host.module_exec do
+      #   undef expect
+      # end
+      syntax_host.remove_method(:expect)
+    end
+
+    def disable_should(syntax_host=default_should_host)
+      return unless should_enabled?(syntax_host)
+
+      # undef not working on Opal 0.8
+      # syntax_host.module_exec do
+      #   undef should
+      #   undef should_not
+      # end
+      syntax_host.remove_method(:should)
+      syntax_host.remove_method(:should_not)
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/matchers.rb

@@ -0,0 +1,2 @@
+require_relative 'matchers/pretty'
+require_relative 'matchers/built_in'

data/opal/opal/rspec/fixes/rspec/matchers/built_in.rb

@@ -0,0 +1,4 @@
+require_relative 'built_in/yield'
+require_relative 'built_in/start_and_end_with'
+require_relative 'built_in/compound'
+require_relative 'built_in/all'

data/opal/opal/rspec/fixes/rspec/matchers/built_in/all.rb

@@ -0,0 +1,10 @@
+class ::RSpec::Matchers::BuiltIn::All
+  def indent_multiline_message(message)
+    # \z not supported in opal
+    #message = message.sub(/\n+\z/, '')
+    message = message.sub(/\n+$/, '')
+    message.lines.map do |line|
+      line =~ /\S/ ? '   ' + line : line
+    end.join
+  end
+end

data/opal/opal/rspec/fixes/rspec/matchers/built_in/compound.rb

@@ -0,0 +1,15 @@
+class ::RSpec::Matchers::BuiltIn::Compound
+  def multiline_message(message_1, message_2)
+    # \z and \A not supported in Opal
+    # [
+    #     indent_multiline_message(message_1.sub(/\n+\z/, '')),
+    #     "...#{conjunction}:",
+    #     indent_multiline_message(message_2.sub(/\A\n+/, ''))
+    # ].join("\n\n")
+    [
+        indent_multiline_message(message_1.sub(/\n+$/, '')),
+        "...#{conjunction}:",
+        indent_multiline_message(message_2.sub(/^\n+/, ''))
+    ].join("\n\n")
+  end
+end

data/opal/opal/rspec/fixes/rspec/matchers/built_in/start_and_end_with.rb

@@ -0,0 +1,42 @@
+module ::RSpec::Matchers::BuiltIn
+  class StartAndEndWith
+    def failure_message
+      msg = super
+      if @actual_does_not_have_ordered_elements
+        msg += ", but it does not have ordered elements"
+      elsif !actual.respond_to?(:[])
+        msg += ", but it cannot be indexed using #[]"
+      end
+      msg
+      # string mutation
+      # super.tap do |msg|
+      #   if @actual_does_not_have_ordered_elements
+      #     msg << ", but it does not have ordered elements"
+      #   elsif !actual.respond_to?(:[])
+      #     msg << ", but it cannot be indexed using #[]"
+      #   end
+      # end
+    end
+
+    # see StartWith and EndWith below
+    def check_ordered_element(actual)
+      # Opal arity checking off by default, will check it manually
+      arity = actual.method(:[]).arity
+      raise ArgumentError.new "wrong number of arguments (2 for #{arity})" unless arity == 2
+    end
+  end
+
+  class StartWith
+    def subset_matches?
+      check_ordered_element actual
+      values_match?(expected, actual[0, expected.length])
+    end
+  end
+
+  class EndWith
+    def subset_matches?
+      check_ordered_element actual
+      values_match?(expected, actual[-expected.length, expected.length])
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/matchers/built_in/yield.rb

@@ -0,0 +1,21 @@
+module ::RSpec::Matchers::BuiltIn
+  class YieldWithArgs
+    def description
+      desc = "yield with args"
+      # string mutation
+      # desc << "(#{expected_arg_description})" unless @expected.empty?
+      desc += "(#{expected_arg_description})" unless @expected.empty?
+      desc
+    end
+  end
+
+  class YieldSuccessiveArgs
+    def description
+      desc = "yield successive args"
+      # string mutation
+      # desc << "(#{expected_arg_description})"
+      desc += "(#{expected_arg_description})"
+      desc
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/mocks.rb

@@ -0,0 +1,4 @@
+require_relative 'mocks/space'
+require_relative 'mocks/error_generator'
+require_relative 'mocks/test_double'
+require_relative 'mocks/verifying_double'

data/opal/opal/rspec/fixes/rspec/mocks/error_generator.rb

@@ -0,0 +1,40 @@
+module ::RSpec::Mocks
+  unless Opal::RSpec::Compatibility.constant_resolution_works_right?
+    class MockExpectationError < Exception
+    end
+
+    # Raised when a test double is used after it has been torn
+    # down (typically at the end of an rspec-core example).
+    class ExpiredTestDoubleError < MockExpectationError
+    end
+
+    # Raised when doubles or partial doubles are used outside of the per-test lifecycle.
+    class OutsideOfExampleError < StandardError
+    end
+
+    # @private
+    class UnsupportedMatcherError < StandardError
+    end
+
+    # @private
+    class NegationUnsupportedError < StandardError
+    end
+
+    # @private
+    class VerifyingDoubleNotDefinedError < StandardError
+    end
+  end
+
+  class ErrorGenerator
+    def actual_method_call_args_description(count, args)
+      method_call_args_description(args) ||
+          if count > 0 && args.length > 0
+            # \A and \z not supported on Opal
+            # " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+            " with arguments: #{args.inspect.gsub(/^\[(.+)\]$/, '(\1)')}"
+          else
+            ""
+          end
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/mocks/space.rb

@@ -0,0 +1,37 @@
+# Opal does not support ObjectSpace, so force object __id__'s
+class RSpec::Mocks::Space
+  OPAL_NON_MOCKABLE_TYPES = [:String, :Number, :Numeric]
+
+  def id_for(object)
+    object.__id__
+  end
+
+  # originally had an alternate impl here due to Opal::RSpec::Compatibility.module_case_works_right?, now also doing checks
+  def proxy_not_found_for(id, object)
+    raise "#{object.class} #{object} cannot be used for mocking in Opal!" if OPAL_NON_MOCKABLE_TYPES.include?(object.class.name)
+    # case when SomeClass wasn't working properly
+    includes_test_double = [
+        InstanceVerifyingDouble,
+        ObjectVerifyingDouble,
+        ClassVerifyingDouble,
+        Double
+    ]
+    proxies[id] = if object.is_a?(NilClass)
+                    ProxyForNil.new(@expectation_ordering)
+                  elsif includes_test_double.any? { |klass| object.is_a? klass }
+                    object.__build_mock_proxy_unless_expired(@expectation_ordering)
+                  elsif object.is_a?(Class)
+                    if RSpec::Mocks.configuration.verify_partial_doubles?
+                      VerifyingPartialClassDoubleProxy.new(self, object, @expectation_ordering)
+                    else
+                      PartialClassDoubleProxy.new(self, object, @expectation_ordering)
+                    end
+                  else
+                    if RSpec::Mocks.configuration.verify_partial_doubles?
+                      VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
+                    else
+                      PartialDoubleProxy.new(object, @expectation_ordering)
+                    end
+                  end
+  end
+end

data/opal/opal/rspec/fixes/rspec/mocks/test_double.rb

@@ -0,0 +1,39 @@
+unless Opal::RSpec::Compatibility.multiple_module_include_super_works_right?
+  module ::RSpec::Mocks::TestDouble
+    # With multiple modules included in a class, Opal doesn't let module 2 (VerifyingDouble) invoke super from module 1 (TestDouble)
+    def call_method_missing(message, *args, &block)
+      proxy = __mock_proxy
+      proxy.record_message_received(message, *args, &block)
+
+      if proxy.null_object?
+        case message
+          when :to_int then
+            return 0
+          when :to_a, :to_ary then
+            return nil
+          when :to_str then
+            return to_s
+          else
+            return self
+        end
+      end
+
+      # Defined private and protected methods will still trigger `method_missing`
+      # when called publicly. We want ruby's method visibility error to get raised,
+      # so we simply delegate to `super` in that case.
+      # ...well, we would delegate to `super`, but there's a JRuby
+      # bug, so we raise our own visibility error instead:
+      # https://github.com/jruby/jruby/issues/1398
+      visibility = proxy.visibility_for(message)
+      if visibility == :private || visibility == :protected
+        ErrorGenerator.new(self, @name).raise_non_public_error(
+            message, visibility
+        )
+      end
+
+      # Required wrapping doubles in an Array on Ruby 1.9.2
+      raise NoMethodError if [:to_a, :to_ary].include? message
+      proxy.raise_unexpected_message_error(message, *args)
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/mocks/verifying_double.rb

@@ -0,0 +1,29 @@
+unless Opal::RSpec::Compatibility.multiple_module_include_super_works_right?
+  module Opal::RSpec::VerifyingDoubleFixes
+    def method_missing(message, *args, &block)
+      # Null object conditional is an optimization. If not a null object,
+      # validity of method expectations will have been checked at definition
+      # time.
+      if null_object?
+        if @__sending_message == message
+          __mock_proxy.ensure_implemented(message)
+        else
+          __mock_proxy.ensure_publicly_implemented(message, self)
+        end
+      end
+
+      call_method_missing message, *args, &block
+    end
+  end
+
+  module ::RSpec::Mocks
+    module VerifyingDouble
+      include ::Opal::RSpec::VerifyingDoubleFixes
+    end
+
+    # In Opala 0.9, this also
+    class ObjectVerifyingDouble
+      include ::Opal::RSpec::VerifyingDoubleFixes
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/support.rb

@@ -0,0 +1,4 @@
+require_relative 'support/encoded_string'
+require_relative 'support/recursive_const_methods'
+require_relative 'support/warnings'
+require_relative 'support/fuzzy_matcher'

data/opal/opal/rspec/fixes/rspec/support/encoded_string.rb

@@ -0,0 +1,10 @@
+# Opal doesn't support encoding
+class RSpec::Support::EncodedString
+  def initialize(string, encoding=nil)
+    @string = string
+  end
+  
+  def to_s
+    @string
+  end
+end

data/opal/opal/rspec/fixes/rspec/support/fuzzy_matcher.rb

@@ -0,0 +1,23 @@
+unless Opal::RSpec::Compatibility.lambda_zero_arg_throws_arg_error?
+  module ::RSpec::Support::FuzzyMatcher
+    def self.values_match?(expected, actual)
+      if Array === expected && Enumerable === actual && !(Struct === actual)
+        return arrays_match?(expected, actual.to_a)
+      elsif Hash === expected && Hash === actual
+        return hashes_match?(expected, actual)
+      elsif actual == expected
+        return true
+      elsif expected.is_a?(Proc)
+        return expected == actual
+      end
+
+      begin
+        expected === actual
+      rescue ArgumentError
+        # Some objects, like 0-arg lambdas on 1.9+, raise
+        # ArgumentError for `expected === actual`.
+        false
+      end
+    end
+  end
+end

data/opal/opal/rspec/fixes/rspec/support/recursive_const_methods.rb

@@ -0,0 +1,7 @@
+module ::RSpec::Support::RecursiveConstMethods
+  def normalize_const_name(const_name)
+    #const_name.sub(/\A::/, '')
+    # the \A, which means 'beginning of string' does not work in Opal/JS regex, ^ is beginning of line, which for constant names, should work OK
+    const_name.sub(/^::/, '')
+  end
+end

data/opal/opal/rspec/fixes/rspec/support/ruby_features.rb

@@ -0,0 +1,8 @@
+require 'rspec/support/ruby_features'
+
+module ::RSpec::Support::RubyFeatures
+  # Weird behavior when optional_and_splat_args_supported? is false (which is the case on Opal) and required_kw_args_supported? is true, so forcing this to false
+  def required_kw_args_supported?
+    false
+  end
+end

data/opal/opal/rspec/fixes/rspec/support/warnings.rb

@@ -0,0 +1,18 @@
+module ::RSpec
+  module Support
+    module Warnings
+      def warn_with(message, options={})
+        call_site = options.fetch(:call_site) { CallerFilter.first_non_rspec_line }
+        # mutable strings
+        # message << " Use #{options[:replacement]} instead." if options[:replacement]
+        message += " Use #{options[:replacement]} instead." if options[:replacement]
+        # message << " Called from #{call_site}." if call_site
+        message += " Called from #{call_site}." if call_site
+        ::Kernel.warn message
+      end
+
+      alias_method :support_warn_with, :warn_with
+    end
+  end
+  extend RSpec::Support::Warnings
+end

data/opal/opal/rspec/formatter/browser_formatter.rb

@@ -0,0 +1,38 @@
+require_relative 'document_io'
+require_relative 'html_printer'
+
+module Opal
+  module RSpec
+    class BrowserFormatter < ::RSpec::Core::Formatters::HtmlFormatter
+      ::RSpec::Core::Formatters.register self, :example_group_finished
+
+      def initialize(output)
+        super DocumentIO.new
+        @printer = Opal::RSpec::HtmlPrinter.new(@output)
+      end
+
+      def example_group_started(notification)
+        # Since we hook print_example_group_end, we override this method
+        @example_group_red = false
+        @example_group_number += 1
+
+        @printer.print_example_group_start(example_group_number, notification.group.description, notification.group.parent_groups.size)
+        @printer.flush
+      end
+
+      def example_group_finished(notification)
+        @printer.print_example_group_end
+      end
+
+      def start_dump(_notification)
+        # Don't need to call "print_example_group_end" like base does since we hook that event
+      end
+
+      def extra_failure_content(failure)
+        backtrace = failure.exception.backtrace.map { |line| ::RSpec.configuration.backtrace_formatter.backtrace_line(line) }
+        # No snippet extractor due to code ray dependency
+        "    <pre class=\"ruby\"><code>#{backtrace.compact}</code></pre>"
+      end
+    end
+  end
+end

data/opal/opal/rspec/formatter/document_io.rb

@@ -0,0 +1,27 @@
+module Opal
+  module RSpec
+    class DocumentIO < IO
+      include IO::Writable
+
+      def initialize
+        `document.open();`
+      end
+
+      def close
+        @closed = true
+        `document.close()`
+      end
+
+      def write(html)
+        if @closed
+          `console.error(#{"DOC closed, can't write #{html}" })`
+        else
+          `document.write(#{html})`
+        end
+      end
+
+      def flush
+      end
+    end
+  end
+end

data/opal/opal/rspec/formatter/element.rb

@@ -0,0 +1,88 @@
+module Opal
+  module RSpec
+    class Element
+      attr_reader :native
+
+      def self.id(id)
+        new(`document.getElementById(id)`)
+      end
+
+      def self.klass(klass)
+        new(`document.getElementsByClassName(#{klass})[0]`)
+      end
+
+      def self.from_string(str)
+        dummy_div = `document.createElement('div')`
+        `#{dummy_div}.innerHTML = #{str}`
+        new(`#{dummy_div}.children[0]`)
+      end
+
+      def initialize(el, attrs={})
+        if String === el
+          @native = `document.createElement(el)`
+        else
+          @native = el
+        end
+
+        attrs.each { |name, val| __send__ "#{name}=", val }
+      end
+
+      def class_name
+        `#@native.className`
+      end
+
+      def get_child_by_tag_name(tag)
+        Element.new(`#@native.getElementsByTagName(#{tag})[0]`)
+      end
+
+      def class_name=(name)
+        `#@native.className = #{name}`
+      end
+
+      def native
+        `#@native`
+      end
+
+      def outer_html
+        `#@native.outerHTML`
+      end
+
+      def html=(html)
+        `#@native.innerHTML = #{html}`
+      end
+
+      def text=(text)
+        self.html = text.gsub(/</, '&lt').gsub(/>/, '&gt')
+      end
+
+      def type=(type)
+        `#@native.type = #{type}`
+      end
+
+      def append(child)
+        `#@native.appendChild(#{child.native})`
+      end
+
+      alias << append
+
+      def css_text=(text)
+        %x{
+                    if (#@native.styleSheet) {
+                      #@native.styleSheet.cssText = #{text};
+                    }
+                    else {
+                      #@native.appendChild(document.createTextNode(#{text}));
+                    }
+                  }
+      end
+
+      def style(name, value)
+        `#@native.style[#{name}] = value`
+      end
+
+      def append_to_head
+        `document.getElementsByTagName('head')[0].appendChild(#@native)`
+      end
+    end
+  end
+end