opal-wedge 0.9.0.dev

data/lib/mspec/opal/new.html.erb

@@ -0,0 +1 @@
+

data/lib/mspec/opal/rake_task.rb

@@ -0,0 +1,248 @@
+require 'opal'
+require 'rack'
+require 'webrick'
+require 'mspec/opal/special_calls'
+
+module MSpec
+  module Opal
+    DEFAULT_BASEDIR = 'spec'
+
+    require 'rake'
+    require 'rake/tasklib'
+    class RakeTask < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      def initialize(name, &task_block)
+        namespace name do
+          desc 'Run MSpec::Opal code examples' unless ::Rake.application.last_comment
+          task :default do
+            puts 'Starting MSpec Runner...'
+            runner = Runner.new(&task_block)
+            runner.run
+          end
+
+          desc 'Build specs to build/specs.js and build/specs.min.js'
+          task :build do
+            require 'opal/util'
+            path = './build/specs.js'
+            min_path = './build/specs.min.js'
+            Environment.new.build_specs(path)
+            min = ::Opal::Util.uglify File.read(path)
+            File.open(min_path, 'w') { |f| f << min }
+          end
+        end
+
+        task name => "#{name}:default"
+      end
+    end
+
+    class Runner
+      def initialize
+        @app = Rack::Builder.new do
+          ::Opal::Processor.arity_check_enabled = true
+          ::Opal::Processor.dynamic_require_severity = :error
+
+          use Rack::ShowExceptions
+          use Rack::ShowStatus
+          use MSpec::Opal::Index
+          run MSpec::Opal::Environment.new
+        end
+
+        @port = 9999
+      end
+
+      attr_reader :app, :server
+      attr_accessor :port
+
+      def passed?
+        @passed
+      end
+
+      def run
+        start_server
+        start_phantomjs
+
+        exit 1 unless passed?
+      rescue => e
+        puts e.message
+      ensure
+        stop_server if server
+      end
+
+      def stop_server
+        server.kill
+      end
+
+      require 'opal/util'
+      class PhantomJS < ::Opal::Util::Command
+        require 'shellwords'
+
+        def initialize(runner, url)
+          runner = runner.shellescape
+          url    = url.shellescape
+          super 'phantomjs', "#{runner} #{url}", '. Please install PhantomJS'
+        end
+
+        def run
+          system "#{command} #{options}"
+        end
+      end
+
+      def start_phantomjs
+        runner  = File.expand_path('../sprockets.js', __FILE__).shellescape
+        url     = "http://localhost:#{port}/".shellescape
+        command = PhantomJS.new(runner, url)
+        @passed = command.run
+      end
+
+      def start_server
+        @server = Thread.new { Rack::Server.start(:app => app, :Port => port) }
+      end
+    end
+
+    class Environment < ::Sprockets::Environment
+      attr_reader :basedir, :pattern
+
+      def initialize(basedir = nil, pattern = nil)
+        @pattern = pattern
+        @basedir = basedir = File.expand_path(basedir || DEFAULT_BASEDIR)
+
+        ::Opal.append_path basedir
+        ::Opal.use_gem 'mspec'
+
+        stubs.each do |asset|
+          ::Opal::Processor.stub_file asset
+        end
+
+        ENV['OPAL_SPEC'] ||= files_to_run(pattern).join(',')
+
+        super()
+
+        ::Opal.paths.each { |p| append_path p }
+      end
+
+      def stubs
+        # missing stdlib
+        stubs = %w[fileutils iconv yaml]
+
+        # use x-strings which generate bad javascript
+        stubs << 'mspec/helpers/tmp'
+        stubs << 'mspec/helpers/environment'
+        stubs << 'mspec/guards/block_device'
+        stubs << 'mspec/guards/endian'
+
+        stubs
+      end
+
+      def specs
+        @specs ||= self['mspec/opal/main'] || raise("Cannot find mspec/opal/main inside #{paths.inspect}")
+      end
+
+      def build_min file = "#{basedir}/build/specs.min.js"
+        require 'opal/util'
+        build ::Opal::Util.uglify(specs.to_s), file
+      end
+
+      def files
+        @files ||= []
+      end
+
+      def add_files specs, tag = ''
+        tag = "[#{tag}] "
+        puts "#{tag}Adding #{specs.size} spec files..."
+        specs = specs.flatten.map do |path|
+          dirname = File.join([basedir, path])
+          if File.directory? dirname
+            rubyspec_paths_in_dir(dirname, path)
+          else
+            path
+          end
+        end.flatten
+        files.concat specs
+      end
+
+      def paths_from_glob pattern
+        Dir.glob(File.expand_path(pattern)).map do |s|
+          s.sub(/\A#{basedir}\//, '').sub(/\.rb\z/, '')
+        end
+      end
+
+      def rubyspec_paths_in_dir(dirname, path)
+        Dir.entries(dirname).select do |spec|
+          spec.end_with? '.rb'
+        end.map do |spec|
+          File.join path, spec
+        end
+      end
+
+      def rubyspec_white_list
+        File.read("#{basedir}/rubyspecs").split("\n").reject do |line|
+          line.sub(/#.*/, '').strip.empty? ||
+            (line.start_with?('!') && rubyspec_black_list.push(line.sub('!', '') + '.rb'))
+        end
+      end
+
+      def rubyspec_black_list
+        @rubyspec_black_list ||= []
+      end
+
+      def files_to_run(pattern=nil)
+        # add any filters in spec/filters of specs we dont want to run
+        add_files paths_from_glob("#{basedir}/filters/**/*.rb"), :filters
+
+        if pattern
+          # add custom opal specs from spec/
+          add_files paths_from_glob(pattern) & rubyspec_white_list, :rubyspec_custom
+          add_files paths_from_glob(pattern).grep(/(?!spec\/(rubyspec|stdlib)\/)/), :other_custom
+
+        else
+          # add opal specific specs
+          add_files paths_from_glob("#{basedir}/opal/**/*_spec.rb"),       :shared
+          add_files paths_from_glob("#{basedir}/lib/lexer_spec.rb"),       :lexer
+          add_files paths_from_glob("#{basedir}/lib/parser/**/*_spec.rb"), :parser
+
+          # add any rubyspecs we want to run (defined in spec/rubyspecs)
+          add_files rubyspec_white_list, :rubyspecs
+        end
+
+        files - rubyspec_black_list
+      end
+
+      def build_specs file = "#{basedir}/build/specs.js"
+        code = specs.to_s
+        FileUtils.mkdir_p File.dirname(file)
+        puts "Building #{file}..."
+        File.open(file, 'w+') { |o| o << code }
+      end
+    end
+
+    class Index
+      HTML = <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8" />
+          <title>Opal Specs</title>
+        </head>
+        <body>
+          <script src="/mspec/opal/main.js"></script>
+          <script>Opal.load('mspec/opal/main');</script>
+        </body>
+      </html>
+      HTML
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if %w[/ /index.html].include? env['PATH_INFO']
+          [200, { 'Content-Type' => 'text/html' }, [HTML]]
+        else
+          @app.call env
+        end
+      end
+    end
+
+  end
+end

data/lib/mspec/opal/runner.rb

@@ -0,0 +1,281 @@
+class OSpecFilter
+  def self.main
+    @main ||= self.new
+  end
+
+  def initialize
+    @filters = Set.new
+  end
+
+  def register
+    MSpec.register :exclude, self
+  end
+
+  def ===(description)
+    @filters.include? description
+  end
+
+  def register_filters(description, block)
+    instance_eval(&block)
+  end
+
+  def fails(description)
+    @filters << description
+  end
+end
+
+class Object
+  def opal_filter(description, &block)
+    OSpecFilter.main.register_filters(description, block)
+  end
+end
+
+class BrowserFormatter
+  def initialize(out=nil)
+    @exception = @failure = false
+    @exceptions = []
+    @count = 0
+    @examples = 0
+
+    @current_state = nil
+  end
+
+  def register
+    MSpec.register :exception, self
+    MSpec.register :before,    self
+    MSpec.register :after,     self
+    MSpec.register :start,     self
+    MSpec.register :finish,    self
+    MSpec.register :abort,     self
+    MSpec.register :enter,     self
+  end
+
+  def green(str)
+    `console.info(str)`
+  end
+
+  def red(str)
+    `console.error(str)`
+  end
+
+  def log(str)
+    `console.log(str)`
+  end
+
+  def exception?
+    @exception
+  end
+
+  def failure?
+    @failure
+  end
+
+  def enter(describe); end
+
+  def before(state=nil)
+    @current_state = nil
+    @failure = @exception = false
+  end
+
+  def exception(exception)
+    @count += 1
+    @failure = @exception ? @failure && exception.failure? : exception.failure?
+    @exception = true
+    @exceptions << exception
+  end
+
+  def after(state = nil)
+    @current_state = nil
+    @examples += 1
+  end
+
+  def start
+    @start_time = Time.now.to_f
+  end
+
+  def finish
+    time = Time.now.to_f - @start_time
+
+    if @exceptions.empty?
+      log "\nFinished"
+      green "#{@examples} examples, #{@count} failures (time taken: #{time})"
+
+      finish_with_code 0
+    else
+      log "\nFailures:"
+
+      @exceptions.each_with_index do |exception, idx|
+        log "\n  #{idx + 1}. #{exception.description}"
+        red "\n    #{exception.message}"
+        log "\n    #{`#{exception.exception}.stack`}\n"
+      end
+
+      log "\nFinished"
+      red "#{@examples} examples, #{@count} failures (time taken: #{time})"
+
+      finish_with_code(1)
+    end
+  end
+
+  def finish_with_code(code)
+    `window.OPAL_SPEC_CODE = code;`
+  end
+end
+
+class PhantomFormatter < BrowserFormatter
+  def green(str)
+    `console.log('\033[32m' + str + '\033[0m')`
+  end
+
+  def red(str)
+    `console.log('\033[31m' + str + '\033[0m')`
+  end
+
+  def log(str)
+    `console.log(str)`
+  end
+
+  def after(state)
+    super
+    unless exception?
+      print '.'
+    else
+      print failure? ? 'F' : 'E'
+    end
+  end
+end
+
+class NodeJSFormatter < BrowserFormatter
+  def green(str)
+    `process.stdout.write("\033[32m"+#{str}+"\033[0m")`
+  end
+
+  def red(str)
+    `process.stdout.write("\033[31m"+#{str}+"\033[0m")`
+  end
+
+  def log(str)
+    puts str
+  end
+
+  def after(state)
+    super
+    print_example(state)
+  end
+
+  def print_example(state)
+    unless exception?
+      green('.')
+    else
+      red(failure? ? 'F' : 'E')
+    end
+  end
+
+  def finish_with_code(code)
+    puts "\n\n"
+    exit(code)
+  end
+end
+
+class PhantomDocFormatter < PhantomFormatter
+  def after(state = nil)
+    (@exception && state) ? red(state.description) : green(state.description)
+    super
+  end
+end
+
+class NodeJSDocFormatter < NodeJSFormatter
+  def print_example(state)
+    (@exception && state) ? red(state.description+"\n") : green(state.description+"\n")
+  end
+end
+
+module MSpec
+  def self.opal_runner
+    @env = Object.new
+    @env.extend MSpec
+  end
+end
+
+class OSpecRunner
+  def self.main(formatter_class = BrowserFormatter)
+    @main ||= self.new formatter_class
+  end
+
+  def initialize(formatter_class)
+    @formatter_class = formatter_class
+    register
+    run
+  end
+
+  def register
+    formatter = @formatter_class.new
+    formatter.register
+
+    OSpecFilter.main.register
+  end
+
+  def run
+    MSpec.opal_runner
+  end
+
+  def will_start
+    MSpec.actions :start
+  end
+
+  def bm!(repeat, bm_filepath)
+    `self.bm = {}`
+    `self.bm_filepath = bm_filepath`
+    MSpec.repeat = repeat
+    MSpec.register :before, self
+    MSpec.register :after,  self
+  end
+
+  def before(state = nil)
+    %x{
+      if (self.bm && !self.bm.hasOwnProperty(state.description)) {
+        self.bm[state.description] = {started: Date.now()};
+      }
+    }
+  end
+
+  def after(state = nil)
+    %x{
+      if (self.bm) {
+        self.bm[state.description].stopped = Date.now();
+      }
+    }
+  end
+
+  def did_finish
+    %x{
+      var obj = self.bm, key, val, report = '';
+      if (obj) {
+        for (key in obj) {
+          if (obj.hasOwnProperty(key)) {
+            val = obj[key];
+            report += key.replace(/\s/g, '_') + ' ' + ((val.stopped - val.started) / 1000) + '\n';
+          }
+        }
+        require('fs').writeFileSync(self.bm_filepath, report);
+      }
+    }
+    MSpec.actions :finish
+  end
+end
+
+module OutputSilencer
+  def silence_stdout
+    original_stdout = $stdout
+    new_stdout = IO.new
+    new_stdout.extend IO::Writable
+    new_stdout.write_proc = ->s{}
+
+    begin
+      $stdout = new_stdout
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+  end
+end