opal-spec 0.2.8 → 0.2.9

data/lib/assets/javascripts/opal/spec/example_group.rb

@@ -1,94 +1,92 @@
-module Opal
-  module Spec
-    class ExampleGroup
-      @example_groups = []
-      def self.example_groups
-        @example_groups
-      end
+module Spec
+  class ExampleGroup
+    @example_groups = []
+    def self.example_groups
+      @example_groups
+    end
 
-      @stack = []
-      def self.create desc, block
-        group = self.new desc, @stack.last
-        @example_groups << group
+    @stack = []
+    def self.create desc, block
+      group = self.new desc, @stack.last
+      @example_groups << group
 
-        @stack << group
-        group.instance_eval &block
-        @stack.pop
-      end
+      @stack << group
+      group.instance_eval &block
+      @stack.pop
+    end
 
-      def initialize desc, parent
-        @desc     = desc.to_s
-        @parent   = parent
-        @examples = []
+    def initialize desc, parent
+      @desc     = desc.to_s
+      @parent   = parent
+      @examples = []
 
-        @before_hooks = []
-        @after_hooks  = []
-      end
+      @before_hooks = []
+      @after_hooks  = []
+    end
 
-      def it(desc, &block)
-        @examples << Example.new(self, desc, block)
-      end
+    def it(desc, &block)
+      @examples << Example.new(self, desc, block)
+    end
 
-      def async(desc, &block)
-        example = Example.new(self, desc, block)
-        example.asynchronous = true
-        @examples << example
-      end
+    def async(desc, &block)
+      example = Example.new(self, desc, block)
+      example.asynchronous = true
+      @examples << example
+    end
 
-      def it_behaves_like(*objs)
-      end
+    def it_behaves_like(*objs)
+    end
 
-      def before type = :each, &block
-        raise "unsupported before type: #{type}" unless type == :each
-        @before_hooks << block
-      end
+    def before type = :each, &block
+      raise "unsupported before type: #{type}" unless type == :each
+      @before_hooks << block
+    end
 
-      def after type = :each, &block
-        raise "unsupported after type: #{type}" unless type == :each
-        @after_hooks << block
-      end
+    def after type = :each, &block
+      raise "unsupported after type: #{type}" unless type == :each
+      @after_hooks << block
+    end
 
-      def before_hooks
-        @parent ? [].concat(@parent.before_hooks).concat(@before_hooks) : @before_hooks
-      end
+    def before_hooks
+      @parent ? [].concat(@parent.before_hooks).concat(@before_hooks) : @before_hooks
+    end
 
-      def after_hooks
-        @parent ? [].concat(@parent.after_hooks).concat(@after_hooks) : @after_hooks
-      end
+    def after_hooks
+      @parent ? [].concat(@parent.after_hooks).concat(@after_hooks) : @after_hooks
+    end
 
-      def run(runner)
-        @runner = runner
-        @runner.example_group_started self
+    def run(runner)
+      @runner = runner
+      @runner.example_group_started self
 
-        @running_examples = @examples.dup
-        run_next_example
-      end
+      @running_examples = @examples.dup
+      run_next_example
+    end
 
-      def run_next_example
-        if @running_examples.empty?
-          @runner.example_group_finished self
-        else
-          @running_examples.shift.run
-        end
+    def run_next_example
+      if @running_examples.empty?
+        @runner.example_group_finished self
+      else
+        @running_examples.shift.run
       end
+    end
 
-      def example_started(example)
-        @runner.example_started(example)
-      end
+    def example_started(example)
+      @runner.example_started(example)
+    end
 
-      def example_passed(example)
-        @runner.example_passed(example)
-        run_next_example
-      end
+    def example_passed(example)
+      @runner.example_passed(example)
+      run_next_example
+    end
 
-      def example_failed(example)
-        @runner.example_failed(example)
-        run_next_example
-      end
+    def example_failed(example)
+      @runner.example_failed(example)
+      run_next_example
+    end
 
-      def description
-        @parent ? "#{@parent.description} #{@desc}" : @desc
-      end
+    def description
+      @parent ? "#{@parent.description} #{@desc}" : @desc
     end
   end
 end

data/lib/assets/javascripts/opal/spec/expectations.rb

@@ -1,55 +1,54 @@
-module Opal
-  module Spec
-    class ExpectationNotMetError < StandardError; end
-
-    module Expectations
-      def should matcher = nil
-        if matcher
-          matcher.match self
-        else
-          Opal::Spec::PositiveOperatorMatcher.new self
-        end
-      end
 
-      def should_not matcher = nil
-        if matcher
-          matcher.not_match self
-        else
-          Opal::Spec::NegativeOperatorMatcher.new self
-        end
-      end
+module Spec
+  class ExpectationNotMetError < StandardError; end
 
-      def be_kind_of expected
-        Opal::Spec::BeKindOfMatcher.new expected
+  module Expectations
+    def should matcher = nil
+      if matcher
+        matcher.match self
+      else
+        Spec::PositiveOperatorMatcher.new self
       end
+    end
 
-      def be_nil
-        Opal::Spec::BeNilMatcher.new nil
+    def should_not matcher = nil
+      if matcher
+        matcher.not_match self
+      else
+        Spec::NegativeOperatorMatcher.new self
       end
+    end
 
-      def be_true
-        Opal::Spec::BeTrueMatcher.new true
-      end
+    def be_kind_of expected
+      Spec::BeKindOfMatcher.new expected
+    end
 
-      def be_false
-        Opal::Spec::BeFalseMatcher.new false
-      end
+    def be_nil
+      Spec::BeNilMatcher.new nil
+    end
 
-      def eq(expected)
-        Opal::Spec::EqlMatcher.new expected
-      end
+    def be_true
+      Spec::BeTrueMatcher.new true
+    end
 
-      def equal expected
-        Opal::Spec::EqualMatcher.new expected
-      end
+    def be_false
+      Spec::BeFalseMatcher.new false
+    end
 
-      def raise_error expected
-        Opal::Spec::RaiseErrorMatcher.new expected
-      end
+    def eq(expected)
+      Spec::EqlMatcher.new expected
+    end
+
+    def equal expected
+      Spec::EqualMatcher.new expected
+    end
+
+    def raise_error expected
+      Spec::RaiseErrorMatcher.new expected
     end
   end
 end
 
 class Object
-  include Opal::Spec::Expectations
+  include Spec::Expectations
 end

data/lib/assets/javascripts/opal/spec/kernel.rb

@@ -1,9 +1,9 @@
 module Kernel
-  def describe desc, &block
-    Opal::Spec::ExampleGroup.create desc, block
+  def describe(desc, &block)
+    Spec::ExampleGroup.create desc, block
   end
 
-  def mock obj
+  def mock(obj)
     Object.new
   end
 end

data/lib/assets/javascripts/opal/spec/matchers.rb

@@ -1,105 +1,103 @@
-module Opal
-  module Spec
-    class Matcher
-      def initialize actual
-        @actual = actual
-      end
+module Spec
+  class Matcher
+    def initialize(actual)
+      @actual = actual
+    end
 
-      def failure message
-        raise Opal::Spec::ExpectationNotMetError, message
-      end
+    def failure(message)
+      raise Spec::ExpectationNotMetError, message
     end
+  end
 
-    class PositiveOperatorMatcher < Matcher
-      def == expected
-        if @actual == expected
-          true
-        else
-          failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
-        end
+  class PositiveOperatorMatcher < Matcher
+    def == expected
+      if @actual == expected
+        true
+      else
+        failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
       end
     end
+  end
 
-    class NegativeOperatorMatcher < Matcher
-      def == expected
-        if @actual == expected
-          failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
-        end
+  class NegativeOperatorMatcher < Matcher
+    def == expected
+      if @actual == expected
+        failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
       end
     end
+  end
 
-    class BeKindOfMatcher < Matcher
-      def match expected
-        unless expected.kind_of? @actual
-          failure "expected #{expected.inspect} to be a kind of #{@actual.name}, not #{expected.class.name}."
-        end
+  class BeKindOfMatcher < Matcher
+    def match expected
+      unless expected.kind_of? @actual
+        failure "expected #{expected.inspect} to be a kind of #{@actual.name}, not #{expected.class.name}."
       end
     end
+  end
 
-    class BeNilMatcher < Matcher
-      def match expected
-        unless expected.nil?
-          failure "expected #{expected.inspect} to be nil."
-        end
+  class BeNilMatcher < Matcher
+    def match expected
+      unless expected.nil?
+        failure "expected #{expected.inspect} to be nil."
       end
     end
+  end
 
-    class BeTrueMatcher < Matcher
-      def match expected
-        unless expected == true
-          failure "expected #{expected.inspect} to be true."
-        end
+  class BeTrueMatcher < Matcher
+    def match expected
+      unless expected == true
+        failure "expected #{expected.inspect} to be true."
       end
     end
+  end
 
-    class BeFalseMatcher < Matcher
-      def match expected
-        unless expected == false
-          failure "expected #{expected.inspect} to be false."
-        end
+  class BeFalseMatcher < Matcher
+    def match expected
+      unless expected == false
+        failure "expected #{expected.inspect} to be false."
       end
     end
+  end
 
-    class EqlMatcher < Matcher
-      def match(expected)
-        unless expected == @actual
-          failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
-        end
+  class EqlMatcher < Matcher
+    def match(expected)
+      unless expected == @actual
+        failure "expected: #{expected.inspect}, got: #{@actual.inspect} (using ==)."
       end
+    end
 
-      def not_match(expected)
-        if expected.equal? @actual
-          failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
-        end
+    def not_match(expected)
+      if expected.equal? @actual
+        failure "expected: #{expected.inspect} not to be #{@actual.inspect} (using ==)."
       end
     end
+  end
 
-    class EqualMatcher < Matcher
-      def match expected
-        unless expected.equal? @actual
-          failure "expected #{@actual.inspect} to be the same as #{expected.inspect}."
-        end
+  class EqualMatcher < Matcher
+    def match expected
+      unless expected.equal? @actual
+        failure "expected #{@actual.inspect} to be the same as #{expected.inspect}."
       end
+    end
 
-      def not_match expected
-        if expected.equal? @actual
-          failure "expected #{@actual.inspect} not to be equal to #{expected.inspect}."
-        end
+    def not_match expected
+      if expected.equal? @actual
+        failure "expected #{@actual.inspect} not to be equal to #{expected.inspect}."
       end
     end
+  end
 
-    class RaiseErrorMatcher < Matcher
-      def match block
-        should_raise = false
-        begin
-          block.call
-          should_raise = true
-        rescue => e
-        end
+  class RaiseErrorMatcher < Matcher
+    def match block
+      should_raise = false
+      begin
+        block.call
+        should_raise = true
+      rescue => e
+      end
 
-        if should_raise
-          failure "expected #{@actual} to be raised, but nothing was."
-        end
+      if should_raise
+        failure "expected #{@actual} to be raised, but nothing was."
       end
     end
   end

data/lib/assets/javascripts/opal/spec/phantom_formatter.rb

@@ -1,93 +1,91 @@
-module Opal
-  module Spec
-    class PhantomFormatter
-      def initialize
-        @examples        = []
-        @failed_examples = []
-      end
+module Spec
+  class PhantomFormatter
+    def initialize
+      @examples        = []
+      @failed_examples = []
+    end
 
-      def log_green(str)
-        `console.log('\\033[32m' + str + '\\033[0m')`
-      end
+    def log_green(str)
+      `console.log('\\033[32m' + str + '\\033[0m')`
+    end
 
-      def log_red(str)
-        `console.log('\\033[31m' + str + '\\033[0m')`
-      end
+    def log_red(str)
+      `console.log('\\033[31m' + str + '\\033[0m')`
+    end
 
-      def log(str)
-        `console.log(str)`
-      end
+    def log(str)
+      `console.log(str)`
+    end
 
-      def start
-        @start_time = Time.now.to_f
-      end
+    def start
+      @start_time = Time.now.to_f
+    end
 
-      def finish
-        time = Time.now.to_f - @start_time
-        if @failed_examples.empty?
-          log "\nFinished"
-          log_green "#{example_count} examples, 0 failures (time taken: #{time})"
-          finish_with_code(0)
-        else
-          log "\nFailures:"
-          @failed_examples.each_with_index do |example, idx|
-            log "\n  #{idx+1}. #{example.example_group.description} #{example.description}"
+    def finish
+      time = Time.now.to_f - @start_time
+      if @failed_examples.empty?
+        log "\nFinished"
+        log_green "#{example_count} examples, 0 failures (time taken: #{time})"
+        finish_with_code(0)
+      else
+        log "\nFailures:"
+        @failed_examples.each_with_index do |example, idx|
+          log "\n  #{idx+1}. #{example.example_group.description} #{example.description}"
 
-            exception = example.exception
-            case exception
-            when Opal::Spec::ExpectationNotMetError
-              output  = exception.message
-            else
-              output  = "#{exception.class.name}: #{exception.message}\n"
-              output += "      #{exception.backtrace.join "\n      "}\n"
-            end
-            log_red "    #{output}"
+          exception = example.exception
+          case exception
+          when Spec::ExpectationNotMetError
+            output  = exception.message
+          else
+            output  = "#{exception.class.name}: #{exception.message}\n"
+            output += "      #{exception.backtrace.join "\n      "}\n"
           end
-
-          log "\nFinished"
-          log_red "#{example_count} examples, #{@failed_examples.size} failures (time taken: #{time})"
-          finish_with_code(1)
+          log_red "    #{output}"
         end
+
+        log "\nFinished"
+        log_red "#{example_count} examples, #{@failed_examples.size} failures (time taken: #{time})"
+        finish_with_code(1)
       end
+    end
       
-      def finish_with_code(code)
-        %x{
-          if (typeof(phantom) !== 'undefined') {
-            return phantom.exit(code);
-          }
-          else {
-            window.OPAL_SPEC_CODE = code;
-          }
+    def finish_with_code(code)
+      %x{
+        if (typeof(phantom) !== 'undefined') {
+          return phantom.exit(code);
         }
-      end
+        else {
+          window.OPAL_SPEC_CODE = code;
+        }
+      }
+    end
 
-      def example_group_started group
-        @example_group = group
-        @example_group_failed = false
-        log "\n#{group.description}"
-      end
+    def example_group_started group
+      @example_group = group
+      @example_group_failed = false
+      log "\n#{group.description}"
+    end
 
-      def example_group_finished group
-      end
+    def example_group_finished group
+    end
 
-      def example_started example
-        @examples << example
-        @example = example
-      end
+    def example_started example
+      @examples << example
+      @example = example
+    end
 
-      def example_failed example
-        @failed_examples << example
-        @example_group_failed = true
-        log_red "  #{example.description}"
-      end
+    def example_failed example
+      @failed_examples << example
+      @example_group_failed = true
+      log_red "  #{example.description}"
+    end
 
-      def example_passed example
-        log_green "  #{example.description}"
-      end
+    def example_passed example
+      log_green "  #{example.description}"
+    end
 
-      def example_count
-        @examples.size
-      end
+    def example_count
+      @examples.size
     end
   end
 end