opal-rspec-cj 0.4.4

data/opal/opal/rspec/fixes.rb

@@ -0,0 +1,116 @@
+require 'encoding'
+
+# This breaks on 2.0.0, so it is here ready for when opal bumps to 2.0.0
+class RSpec::CallerFilter
+  def self.first_non_rspec_line
+    ""
+  end
+end
+
+# Opal does not support mutable strings
+module RSpec
+  module Matchers
+    module Pretty
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s
+        word = word.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word = word.gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        word = word.tr("-", "_")
+        word = word.downcase
+        word
+      end
+    end
+  end
+end
+
+module RSpec::ExampleGroups
+  # opal cannot use mutable strings AND opal doesnt support `\A` or `\z` anchors
+  def self.base_name_for(group)
+    return "Anonymous" if group.description.empty?
+
+    # convert to CamelCase
+    name = ' ' + group.description
+    name = name.gsub(/[^0-9a-zA-Z]+([0-9a-zA-Z])/) { |m| m[1].upcase }
+
+    name = name.lstrip         # Remove leading whitespace
+    name = name.gsub(/\W/, '') # JRuby, RBX and others don't like non-ascii in const names
+
+    # Ruby requires first const letter to be A-Z. Use `Nested`
+    # as necessary to enforce that.
+    name = name.gsub(/^([^A-Z]|$)/, 'Nested\1')
+
+    name
+  end
+
+  # opal cannot use mutable strings
+  def self.disambiguate(name, const_scope)
+    return name unless const_scope.const_defined?(name)
+
+    # Add a trailing number if needed to disambiguate from an existing constant.
+    name = name + "_2"
+    while const_scope.const_defined?(name)
+      name = name.next
+    end
+
+    name
+  end
+end
+
+# Opal does not support ObjectSpace, so force object __id__'s
+class RSpec::Mocks::Space
+  def id_for(object)
+    object.__id__
+  end
+end
+
+# Buggy under Opal?
+class RSpec::Mocks::MethodDouble
+  def save_original_method!
+    @original_method ||= @method_stasher.original_method
+  end
+end
+
+# Missing on vendored rspec version
+module RSpec
+  module Core
+    module MemoizedHelpers
+      def is_expected
+        expect(subject)
+      end
+    end
+  end
+end
+
+RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage.class_eval do
+  def to_s
+    msg =  "#{@data[:deprecated]} is deprecated."
+    msg += " Use #{@data[:replacement]} instead." if @data[:replacement]
+    msg += " Called from #{@data[:call_site]}." if @data[:call_site]
+    msg
+  end
+
+  def too_many_warnings_message
+    msg = "Too many uses of deprecated '#{type}'."
+    msg += " Set config.deprecation_stream to a File for full output."
+    msg
+  end
+end
+
+def (RSpec::Expectations).fail_with(message, expected=nil, actual=nil)
+  if !message
+    raise ArgumentError, "Failure message is nil. Does your matcher define the " +
+                         "appropriate failure_message_for_* method to return a string?"
+  end
+
+  if actual && expected
+    if all_strings?(actual, expected)
+      if any_multiline_strings?(actual, expected)
+        message # + "\nDiff:" + differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
+      end
+    elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+      message # + "\nDiff:" + differ.diff_as_object(actual, expected)
+    end
+  end
+
+  raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+end

data/opal/opal/rspec/requires.rb

@@ -0,0 +1,45 @@
+require 'corelib/dir'
+require 'thread'
+
+require 'set'
+require 'time'
+require 'rbconfig'
+require 'pathname'
+
+# TODO: still needed? meh..
+require 'rspec/core/version'
+require 'rspec/core/flat_map'
+require 'rspec/core/filter_manager'
+require 'rspec/core/dsl'
+require 'rspec/core/reporter'
+require 'rspec/core/hooks'
+require 'rspec/core/memoized_helpers'
+require 'rspec/core/metadata'
+require 'rspec/core/pending'
+require 'rspec/core/formatters'
+require 'rspec/core/ordering'
+require 'rspec/core/world'
+require 'rspec/core/configuration'
+require 'rspec/core/option_parser'
+require 'rspec/core/configuration_options'
+require 'rspec/core/command_line'
+require 'rspec/core/runner'
+require 'rspec/core/example'
+require 'rspec/core/shared_example_group/collection'
+require 'rspec/core/shared_example_group'
+require 'rspec/core/example_group'
+
+require 'rspec/core/mocking/with_rspec'
+
+require 'rspec/support'
+require 'rspec/core'
+require 'rspec/expectations'
+require 'rspec/mocks'
+require 'rspec'
+
+# FIXME: still needed?
+require 'rspec/core/formatters/base_text_formatter'
+require 'rspec/core/formatters/html_printer'
+require 'rspec/matchers/pretty'
+require 'rspec/matchers/built_in/base_matcher'
+require 'rspec/matchers/built_in/be'

data/opal/opal/rspec/runner.rb

@@ -0,0 +1,69 @@
+module Opal
+  module RSpec
+    class Runner
+
+      class << self
+        def browser?
+          `typeof(document) !== "undefined"`
+        end
+
+        def phantom?
+          `typeof(phantom) !== 'undefined' || typeof(OPAL_SPEC_PHANTOM) !== 'undefined'`
+        end
+
+        def default_formatter
+          if phantom?
+            TextFormatter
+          else # browser
+            BrowserFormatter
+          end
+        end
+
+        def autorun
+          if browser?
+            `setTimeout(function() { #{Runner.new.run} }, 0)`
+          else # phantom
+            Runner.new.run
+          end
+        end
+      end
+
+      def initialize(options = {})
+        @options = options
+        @world = ::RSpec.world
+        @configuration = ::RSpec.configuration
+      end
+
+      def run(err=$stdout, out=$stdout)
+        @configuration.error_stream = err
+        @configuration.output_stream ||= out
+
+        self.start
+        run_examples
+
+        run_async_examples do
+          self.finish
+        end
+      end
+
+      def run_examples
+        @world.example_groups.map { |g| g.run(@reporter) }.all?
+      end
+
+      def run_async_examples(&block)
+        AsyncRunner.new(self, @reporter, block).run
+      end
+
+      def start
+        @reporter = @configuration.reporter
+        @reporter.start(@world.example_count)
+        @configuration.run_hook(:before, :suite)
+      end
+
+      def finish
+        @configuration.run_hook(:after, :suite)
+        @reporter.finish
+      end
+    end
+  end
+end

data/opal/opal/rspec/sprockets_runner.rb.erb

@@ -0,0 +1,11 @@
+# This file is used by Opal::Server to basically load all spec files that
+# can be found in the spec/ directory.
+
+require 'opal'
+require 'opal-rspec'
+
+<% Dir.glob('spec/**/*_spec.{rb,opal}').each do |s| %>
+require <%= s.sub(/^spec\//, '').sub(/\.(rb|opal)$/, '').inspect %>
+<% end %>
+
+Opal::RSpec::Runner.autorun

data/opal/opal/rspec/text_formatter.rb

@@ -0,0 +1,74 @@
+module Opal
+  module RSpec
+    class TextFormatter < ::RSpec::Core::Formatters::BaseFormatter
+
+      def dump_failures
+        if failed_examples.empty?
+          puts "\nFinished"
+        else
+          puts "\nFailures:"
+          failed_examples.each_with_index do |example, index|
+            puts "\n"
+            dump_failure(example, index)
+          end
+        end
+      end
+
+      def dump_failure(example, index)
+        puts "#{short_padding}#{index.next}) #{example.full_description}"
+        dump_failure_info(example)
+      end
+
+      def dump_failure_info(example)
+        exception = example.execution_result[:exception]
+        exception_class_name = exception.class.name.to_s
+        red "#{long_padding}#{exception_class_name}:"
+        exception.message.to_s.split("\n").each { |line| red "#{long_padding}  #{line}" }
+      end
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        @duration = duration
+        @example_count = example_count
+        @failure_count = failure_count
+        @pending_count = pending_count
+
+        msg = "\n#{example_count} examples, #{failure_count} failures (time taken: #{duration})"
+
+        if failure_count == 0
+          green msg
+          finish_with_code(0)
+        else
+          red msg
+          finish_with_code(1)
+        end
+      end
+
+      def finish_with_code(code)
+        %x{
+          if (typeof(phantom) !== "undefined") {
+            phantom.exit(code);
+          }
+          else {
+            Opal.global.OPAL_SPEC_CODE = code;
+          }
+        }
+      end
+
+      def green(str)
+        `console.log('\033[32m' + str + '\033[0m')`
+      end
+
+      def red(str)
+        `console.log('\033[31m' + str + '\033[0m')`
+      end
+
+      def short_padding
+        '  '
+      end
+
+      def long_padding
+        '     '
+      end
+    end
+  end
+end

data/spec/async_spec.rb

@@ -0,0 +1,38 @@
+describe "Asynchronous helpers" do
+  let(:foo) { 100 }
+
+  before do
+    @model = Object.new
+  end
+
+  async "can run examples async" do
+    async do
+      1.should == 1
+    end
+  end
+
+  async "can access let() helpers and before() helpers" do
+    async do
+      foo.should eq(100)
+      @model.should be_kind_of(Object)
+    end
+  end
+
+  async "can finish running after a long delay" do
+    obj = [1, 2, 3, 4]
+
+    delay(1) do
+      async { obj.should == [1, 2, 3, 4] }
+    end
+  end
+
+  async "should make example fail before async block reached" do
+    expect {
+      expect(:foo).to eq(:baz)
+    }.to raise_error(Exception)
+
+    delay(0) do
+      async { expect(42).to eq(42) }
+    end
+  end
+end

data/spec/example_spec.rb

@@ -0,0 +1,163 @@
+module SomeHelpers
+  def opal_rspec_helper
+    let(:defined_opal_helper) { :it_works }
+  end
+end
+
+module SomeMoreHelpers
+  def opal_rspec_include_helper
+    42
+  end
+end
+
+RSpec.configure do |c|
+  c.extend SomeHelpers
+  c.include SomeMoreHelpers
+end
+
+describe "RSpec include and extend" do
+  opal_rspec_helper
+
+  it "works for extend" do
+    defined_opal_helper.should == :it_works
+  end
+
+  it "works for include" do
+    opal_rspec_include_helper.should == 42
+  end
+end
+
+$count = 0
+
+describe "let" do
+  let(:count) { $count += 1 }
+
+  it "memoizes the value" do
+    count.should eq(1)
+    count.should eq(1)
+  end
+
+  it "is not cached across examples" do
+    count.should eq(2)
+  end
+end
+
+describe "helper methods" do
+  def some_helper
+    :present
+  end
+
+  it "should be available" do
+    some_helper.should eq(:present)
+  end
+
+  describe "nested group" do
+    it "should work in nested groups" do
+      some_helper.should eq(:present)
+    end
+  end
+end
+
+describe "nested describes" do
+  it "works in multiple places" do
+    1.should eq(1)
+  end
+
+  describe "nested" do
+    it "and here" do
+      1.should_not eq(2)
+    end
+  end
+end
+
+describe "subject" do
+  subject { [1, 2, 3] }
+
+  it "a new instance should be the subject" do
+    subject.should be_kind_of(Array)
+  end
+
+  describe "nested subjects" do
+    before { subject << 4 }
+
+    it "should work with before and example" do
+      subject.should == [1, 2, 3, 4]
+    end
+  end
+end
+
+describe Hash do
+  it "should create a new instance of subject for classes" do
+    subject.should == {}
+  end
+
+  it "provides the subject as the described_class" do
+    expect(described_class).to eq(Hash)
+  end
+end
+
+describe [1, 2, 3] do
+  it "can use an object instance as a subject" do
+    expect(subject).to eq([1, 2, 3])
+  end
+end
+
+describe "Simple expectations" do
+  before do
+    @bar = 200
+  end
+
+  it "should eat" do
+    @bar.should == 200
+  end
+
+  after do
+    @bar.class
+  end
+end
+
+describe "should syntax" do
+  it "should work for positive" do
+    [1, 2, 3].should == [1, 2, 3]
+  end
+
+  it "should work for negative" do
+    [1, 2, 3].should_not == [4, 5, 6]
+  end
+end
+
+describe "expect syntax" do
+  it "positive expectation" do
+    expect(100).to eq(100)
+  end
+
+  it "negative expectation" do
+    expect(100).to_not eq(300)
+  end
+end
+
+describe "Normal errors" do
+  it "should still work" do
+    lambda { raise "wtf son" }.should raise_error(Exception)
+  end
+end
+
+describe "let on an inner scope" do
+  describe "inner context" do
+    let(:foo) { :bar }
+
+    it "should still work" do
+      foo.should eq(:bar)
+    end
+  end
+end
+
+describe "#context" do
+  context "inner context" do
+    let(:foo) { :bar }
+
+    it "should still work" do
+      foo.should eq(:bar)
+    end
+  end
+end