opal-rspec 0.0.1.beta1

data/opal/opal/rspec/fixes.rb

@@ -0,0 +1,62 @@
+# String#<< is not supported by Opal
+module RSpec::Expectations
+  def self.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
+
+    raise RSpec::Expectations::ExpectationNotMetError.new(message)
+  end
+end
+
+# Opal does not support mutable strings
+module RSpec::Matchers::Pretty
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    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
+
+# Opal does not yet support $1..$9 backrefs
+class RSpec::Matchers::BuiltIn::BePredicate
+  def prefix_and_expected(symbol)
+    symbol.to_s =~ /^(be_(an?_)?)(.*)/
+    return $~[1], $~[3]
+  end
+end
+
+module RSpec::ExampleGroups
+  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([^A-Z]|\z)/, 'Nested$1')
+
+    name
+  end
+
+  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

data/opal/opal/rspec/runner.rb

@@ -0,0 +1,52 @@
+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={}, configuration=::RSpec::configuration, world=::RSpec::world)
+        @options = options
+        @configuration = configuration
+        @world = world
+      end
+
+      def run(err=$stdout, out=$stdout)
+        @configuration.error_stream = err
+        @configuration.output_stream ||= out
+
+        @configuration.reporter.report(@world.example_count) do |reporter|
+          begin
+            @configuration.run_hook(:before, :suite)
+            @world.example_groups.map {|g| g.run(reporter) }.all? ? 0 : @configuration.failure_exit_code
+          ensure
+            @configuration.run_hook(:after, :suite)
+          end
+        end
+      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_asset 'opal' %>
+<% require_asset 'opal-rspec' %>
+
+<% Dir.glob('spec/**/*_spec.{rb,opal}').each do |s| %>
+<% require_asset s.sub(/^spec\//, '').sub(/\.(rb|opal)$/, '') %>
+<% 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/example_spec.rb

@@ -0,0 +1,143 @@
+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
+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

data/spec/matchers_spec.rb

@@ -0,0 +1,181 @@
+describe "be_truthy" do
+  it "passes with truthy values" do
+    expect(true).to be_truthy
+    expect(1.0).to be_truthy
+    expect([]).to be_truthy
+  end
+
+  it "fails with falsey values" do
+    expect {
+      expect(false).to be_truthy
+    }.to raise_error(Exception)
+
+    expect {
+      expect(nil).to be_truthy
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_falsey" do
+  it "passes with falsey values" do
+    expect(false).to be_falsey
+    expect(nil).to be_falsey
+  end
+
+  it "fails with truthy values" do
+    expect {
+      expect(true).to be_falsey
+    }.to raise_error(Exception)
+
+    expect {
+      expect({}).to be_falsey
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_nil" do
+  it "passes when object is nil" do
+    expect(nil).to be_nil
+  end
+
+  it "fails with any other object" do
+    expect {
+      expect(false).to be_nil
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).to be_nil
+    }.to raise_error(Exception)
+  end
+end
+
+describe "be_kind_of" do
+  it "passes if actual is kind of expected class" do
+    expect("foo").to be_kind_of(String)
+    expect("foo").to_not be_kind_of(Numeric)
+  end
+
+  it "passes if actual is kind of superclass of expected class" do
+    expect([]).to be_kind_of(Object)
+  end
+
+  it "fails if expected is not a kind of expected" do
+    expect {
+      expect("foo").to be_kind_of(Integer)
+    }.to raise_error(Exception)
+
+    expect {
+      expect("foo").to_not be_kind_of(String)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eq" do
+  it "matches when actual == expected" do
+    expect(:foo).to eq(:foo)
+  end
+
+  it "does not match when actual != expected" do
+    expect(:foo).not_to eq(42)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(:foo).to eq(42)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(:foo).not_to eq(:foo)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "eql" do
+  it "matches when expected.eql?(actual)" do
+    expect(1).to eql(1)
+  end
+
+  it "does not match when !expected.eql?(actual)" do
+    expect(1).to_not eql(:foo)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect(1).to eql(:bar)
+    }.to raise_error(Exception)
+
+    expect {
+      expect(2).to_not eql(2)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "include" do
+  it "matches if actual includes expected" do
+    expect("foo").to include("f")
+    expect([:foo, :bar, :baz]).to include(:baz)
+    expect({ :yellow => 'lorry' }).to include(:yellow)
+  end
+
+  it "does not match if actual does not inlcude expected" do
+    expect("foo").to_not include("b")
+    expect([:foo, :bar, :baz]).to_not include(:kapow)
+    expect({ :yellow => 'lorry' }).to_not include(:red)
+  end
+
+  it "fails if matcher does not match" do
+    expect {
+      expect("bar").to include("z")
+    }.to raise_error(Exception)
+  end
+end
+
+describe "respond_to" do
+  it "matches if actual responds to sym" do
+    expect("foo").to respond_to(:upcase)
+  end
+
+  it "does not match if actual does not respond to sym" do
+    expect(Object.new).to_not respond_to(:upcase)
+  end
+
+  it "fails if actual does not respond to sym" do
+    expect {
+      expect(Object.new).to respond_to(:upcase)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "match" do
+  it "matches if actual matches expected" do
+    expect("foobar").to match(/ar/)
+    expect("foobar").to match("oob")
+  end
+
+  it "does not match if actual does not match expected" do
+    expect("foobar").to_not match(/baz/)
+    expect("foobar").to_not match("woosh")
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      exprct("hello").to match(/world/)
+    }.to raise_error(Exception)
+  end
+end
+
+describe "operator ==" do
+  it "matches if actual == expected" do
+    "hello".should == "hello"
+  end
+
+  it "does not match when actual does not == expected" do
+    "hello".should_not == "world"
+  end
+
+  it "fails unless matcher matches" do
+    expect {
+      "hello".should == "world"
+    }.to raise_error(Exception)
+  end
+end