opal 0.10.0 → 0.11.0

data/spec/lib/sprockets/erb_spec.rb

@@ -1,38 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/sprockets/erb'
-
-describe Opal::ERB::Processor do
-  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .erb .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
-    filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
-  let(:required_assets) { [] }
-  let(:template) { described_class.new { |t| %Q{<% print("") %><a href="<%= url %>"><%= name %></a>} } }
-  before { sprockets_context.stub(:require_asset) {|asset| required_assets << asset } }
-
-  let(:ext) { 'opalerb' }
-
-  it "is registered for '.opalerb' files" do
-    expect(Tilt["test.#{ext}"]).to eq(described_class)
-  end
-
-  it 'renders the template' do
-    expect(template.render(sprockets_context)).to include('"<a href=\""')
-  end
-
-  it 'implicitly requires "erb"' do
-    template.render(sprockets_context)
-    expect(required_assets).to eq(['erb'])
-  end
-end

data/spec/lib/sprockets/path_reader_spec.rb

@@ -1,41 +0,0 @@
-require 'lib/spec_helper'
-require 'lib/shared/path_reader_shared'
-require 'opal/sprockets/path_reader'
-
-describe Opal::Sprockets::PathReader do
-  let(:env) { Sprockets::Environment.new }
-  let(:context) { double('context', depend_on: nil, depend_on_asset: nil) }
-  let(:contents) { File.read(full_path) }
-  let(:full_path) { fixtures_dir.join(logical_path+'.js.rb') }
-  let(:logical_path) { 'sprockets_file' }
-  let(:fixtures_dir) { Pathname('../../fixtures/').expand_path(__FILE__) }
-
-  subject(:path_reader) { described_class.new(env, context) }
-
-  before do
-    Opal.paths.each {|p| env.append_path(p)}
-    env.append_path fixtures_dir
-  end
-
-  include_examples :path_reader do
-    let(:path) { logical_path }
-  end
-
-  it 'can read stuff from sprockets env' do
-    expect(path_reader.read(logical_path)).to eq(contents)
-  end
-
-  it 'reads js files processing their directives' do
-    path              = 'file_with_directives.js'
-    full_path         = fixtures_dir.join(path)
-    required_contents = File.read(fixtures_dir.join('required_file.js')).strip
-    read_contents     = path_reader.read(path)
-    actual_contents   = full_path.read
-
-    expect(actual_contents).to include('//= require')
-    expect(read_contents).not_to include('//= require')
-
-    expect(read_contents).to include(required_contents)
-    expect(actual_contents).not_to include(required_contents)
-  end
-end

data/spec/lib/sprockets/processor_spec.rb

@@ -1,79 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/sprockets/processor'
-
-describe Opal::Processor do
-  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
-    filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
-
-  %w[.rb .opal].each do |ext|
-    let(:ext) { ext }
-
-    describe %Q{with extension "#{ext}"} do
-      it "is registered for '#{ext}' files" do
-        expect(Sprockets.engines[ext]).to eq(described_class)
-      end
-
-      it "compiles and evaluates the template on #render" do
-        template = described_class.new { |t| "puts 'Hello, World!'\n" }
-        expect(template.render(sprockets_context)).to include('"Hello, World!"')
-      end
-    end
-  end
-
-  describe '.stubbed_files' do
-    around do |e|
-      config.stubbed_files.clear
-      e.run
-      config.stubbed_files.clear
-    end
-
-    let(:stubbed_file) { 'foo' }
-    let(:template) { described_class.new { |t| "require #{stubbed_file.inspect}" } }
-    let(:config) { Opal::Config }
-
-    it 'usually require files' do
-      sprockets_context.should_receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
-
-    it 'skips require of stubbed file' do
-      config.stubbed_files << stubbed_file.to_s
-      sprockets_context.should_not_receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
-
-    it 'marks a stubbed file as loaded' do
-      config.stubbed_files << stubbed_file.to_s
-      asset = double(dependencies: [], pathname: Pathname('bar'), logical_path: 'bar')
-      environment.stub(:[]).with('bar.js') { asset }
-      environment.stub(:engines) { {'.rb' => described_class, '.opal' => described_class} }
-
-      code = ::Opal::Sprockets.load_asset('bar', environment)
-      code.should match stubbed_file
-    end
-  end
-
-  describe '.cache_key' do
-    it 'can be reset' do
-      Opal::Config.arity_check_enabled = true
-      old_cache_key = described_class.cache_key
-      Opal::Config.arity_check_enabled = false
-      expect(described_class.cache_key).to eq(old_cache_key)
-      described_class.reset_cache_key!
-      expect(described_class.cache_key).not_to eq(old_cache_key)
-    end
-  end
-end

data/spec/lib/sprockets/server_spec.rb

@@ -1,102 +0,0 @@
-require 'lib/spec_helper'
-require 'sourcemap'
-require 'rack/test'
-
-describe Opal::Server do
-  include Rack::Test::Methods
-
-  let(:maps_prefix) { described_class::SOURCE_MAPS_PREFIX_PATH }
-
-  def app
-    described_class.new { |s|
-      s.main = 'opal'
-      s.debug = false
-      s.append_path File.expand_path('../../fixtures', __FILE__)
-      s.sprockets.logger = Logger.new(nil)
-    }
-  end
-
-  it 'serves assets from /assets' do
-    get '/assets/opal.js'
-    expect(last_response).to be_ok
-  end
-
-  it 'serves assets with complex sprockets requires' do
-    asset = app.sprockets['complex_sprockets']
-    expect(asset).to be_truthy
-
-    assets = asset.to_a.map do |sub_asset|
-      sub_asset.logical_path.gsub(/\.self\.js$/, '.js')
-    end
-
-    %w[
-      no_requires.js
-      jst_file.js
-      required_tree_test/required_file1.js
-      required_tree_test/required_file2.js
-      file_with_directives.js
-    ].each do |logical_path|
-      expect(assets).to include(logical_path)
-    end
-  end
-
-  describe 'source maps' do
-    it 'serves map on a top level file' do
-      get '/assets/source_map.js'
-      expect(last_response).to be_ok
-
-      get maps_prefix+'/source_map.self.map'
-      expect(last_response).to be_ok
-    end
-
-    it 'serves map on a subfolder file' do
-      js_path = '/assets/source_map/subfolder/other_file.self.js'
-      map_path = maps_prefix+'/source_map/subfolder/other_file.self.map'
-
-      get js_path
-
-      expect(last_response).to be_ok
-      received_map_path = extract_map_path(last_response)
-      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
-
-      get maps_prefix+'/source_map/subfolder/other_file.self.map'
-      expect(last_response).to be_ok
-    end
-
-    it 'serves map on a subfolder file' do
-      js_path = '/assets/source_map/subfolder/other_file.self.js'
-      map_path = maps_prefix+'/source_map/subfolder/other_file.self.map'
-
-      get js_path
-
-      expect(last_response).to be_ok
-      received_map_path = extract_map_path(last_response)
-      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
-
-      get maps_prefix+'/source_map/subfolder/other_file.self.map'
-      expect(last_response).to be_ok
-      map = ::SourceMap::Map.from_json(last_response.body)
-      expect(map.sources).to include(maps_prefix+'/source_map/subfolder/other_file.rb')
-    end
-  end
-
-  def extract_map_path(response)
-    source_map_comment_regexp = %r{//# sourceMappingURL=(.*)$}
-
-    case
-    when response.body =~ source_map_comment_regexp
-      body.scan(source_map_comment_regexp).first.first
-    when response.headers['X-SourceMap']
-      response.headers['X-SourceMap']
-    else
-      raise "cannot find source map in response: #{response.inspect}"
-    end
-  end
-
-  def expand_path(file_name, dir_string)
-    path = File.expand_path(file_name, dir_string)
-    # Remove Windows letter and colon (eg. C:) from path
-    path = path[2..-1] if !(RUBY_PLATFORM =~ /mswin|mingw/).nil?
-    path
-  end
-end

data/spec/lib/sprockets_spec.rb

@@ -1,32 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/sprockets'
-
-describe Opal::Sprockets do
-  let(:env) { Sprockets::Environment.new }
-  before { Opal.paths.each { |path| env.append_path path } }
-
-  describe '.load_asset' do
-    it 'loads the main asset' do
-      code = described_class.load_asset('console', env)
-      expect(code).to include('Opal.load("console");')
-    end
-
-    it 'marks as loaded "opal" plus all non opal assets' do
-      code = described_class.load_asset('corelib/runtime', env)
-      expect(code).to include('Opal.loaded(["opal","corelib/runtime"]);')
-    end
-
-    it 'returns an empty string if the asset is not found' do
-      code = described_class.load_asset('foo', env)
-      expect(code).to eq('')
-    end
-  end
-
-  describe '.javascript_include_tag' do
-    it 'works with trailing / in the prefix' do
-      code = described_class.javascript_include_tag('corelib/runtime', prefix: '/', sprockets: env, debug: false)
-      expect(code).to include('src="/corelib/runtime.')
-      expect(code).not_to include('//')
-    end
-  end
-end

data/spec/lib/tilt/opal_spec.rb

@@ -1,37 +0,0 @@
-require 'lib/spec_helper'
-require 'tilt/opal'
-
-describe Opal::TiltTemplate do
-  %w[rb js.rb opal js.opal].each do |ext|
-    let(:ext) { ext }
-
-    describe %Q{with extension ".#{ext}"} do
-      it "is registered for '.#{ext}' files" do
-        expect(Tilt["test.#{ext}"]).to be <= described_class
-      end
-
-      it "compiles and evaluates the template on #render" do
-        template = described_class.new('file') { |t| "puts 'Hello, World!'\n" }
-        expect(template.render(Object.new)).to include('"Hello, World!"')
-      end
-    end
-  end
-
-  it "support :build option" do
-    template = described_class.new('./spec/lib/fixtures/opal_file.rb', :build=>true)
-    output = template.render
-    expect(output).to include('"hi from opal!"')
-    expect(output).to include('self.$require("corelib/runtime");')
-  end
-
-  it "support :builder option" do
-    builder = Opal::Builder.new(:stubs=>['opal'])
-    template = described_class.new('./spec/lib/fixtures/opal_file.rb', :builder=>builder)
-
-    2.times do
-      output = template.render
-      expect(output.scan(/hi from opal!/).length).to eql(1)
-      expect(output).not_to include('self.$require("corelib/runtime");')
-    end
-  end
-end

data/spec/mspec-opal/formatters.rb

@@ -1,188 +0,0 @@
-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)
-    exit(code)
-  end
-end
-
-class PhantomFormatter < BrowserFormatter
-  def green(str)
-    `console.log('\u001b[32m' + str + '\u001b[0m')`
-  end
-
-  def red(str)
-    `console.log('\u001b[31m' + str + '\u001b[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("\u001b[32m"+#{str}+"\u001b[0m")`
-  end
-
-  def red(str)
-    `process.stdout.write("\u001b[31m"+#{str}+"\u001b[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)
-    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
-
-class InvertedFormatter < DottedFormatter
-  def initialize(out=nil)
-    super
-    @actually_passing = []
-  end
-
-  def register
-    MSpec.register :before, self
-    MSpec.register :exception, self
-    MSpec.register :after, self
-    MSpec.register :finish, self
-  end
-
-  def after(state=nil)
-    unless exception?
-      @actually_passing << @current_state
-    end
-
-    super
-  end
-
-  def finish
-    puts "\n\nExpected to fail:\n"
-    @actually_passing.each_with_index do |example, idx|
-      puts "  #{idx + 1}) #{example.description.inspect}"
-    end
-    puts "\n"
-  end
-end

data/spec/mspec-opal/runner.rb

@@ -1,193 +0,0 @@
-class OSpecFilter
-  def self.main
-    @main ||= self.new
-  end
-
-  def initialize
-    @filters = Set.new
-    @seen = Set.new
-  end
-
-  def register
-    if ENV['INVERT_RUNNING_MODE']
-      MSpec.register :include, self
-    else
-      MSpec.register :exclude, self
-    end
-  end
-
-  def ===(description)
-    @seen << description
-    @filters.include?(description)
-  end
-
-  def register_filters(description, block)
-    instance_eval(&block)
-  end
-
-  def fails(description)
-    @filters << description
-  end
-
-  def unused_filters_message(list: false)
-    unused = @filters - @seen
-    return if unused.size == 0
-
-    if list
-      puts
-      puts "Unused filters:"
-      unused.each {|u| puts "- #{u}".gsub("\n", "\\n")}
-      puts
-    else
-      warn "\nThere are #{unused.size} unused filters, re-run with ENV['LIST_UNUSED_FILTERS'] = true to list them\n\n"
-    end
-  end
-end
-
-class Object
-  def opal_filter(description, &block)
-    OSpecFilter.main.register_filters(description, block)
-  end
-
-  # Copyed from MSpec, with changes.
-  def with_timezone(name, offset = nil, daylight_saving_zone = "")
-    zone = name.dup
-
-    if offset
-      # TZ convention is backwards
-      offset = -offset
-
-      zone += offset.to_s
-      zone += ":00:00"
-    end
-    zone += daylight_saving_zone
-
-    # WAS:
-    #
-    #   old = ENV["TZ"]
-    #   ENV["TZ"] = zone
-    #
-    #   begin
-    #     yield
-    #   ensure
-    #     ENV["TZ"] = old
-    #   end
-    #
-    if ENV["TZ"] == zone
-      yield
-    else
-      1.should == 1 # MSpec will get mad if the example has no expectations.
-      warn "Skipped spec for TZ=#{zone} as it's not supported"
-    end
-  end
-end
-
-module MSpec
-  def self.opal_runner
-    @env = Object.new
-    @env.extend MSpec
-  end
-end
-
-class OSpecFormatter
-  def self.main
-    @main ||= self.new
-  end
-
-  def default_formatter
-    return InvertedFormatter if ENV['INVERT_RUNNING_MODE']
-
-    # Uncomment one of the following to use a different formatter:
-    #
-    # BrowserFormatter
-    # NodeJSFormatter
-    # NodeJSDocFormatter
-    # PhantomFormatter
-    # PhantomDocFormatter
-    DottedFormatter
-  end
-
-  def register(formatter_class = default_formatter)
-    formatter_class.new.register
-  end
-end
-
-class OSpecRunner
-  def self.main
-    @main ||= self.new
-  end
-
-  def initialize
-    register
-    run
-  end
-
-  def register
-    OSpecFormatter.main.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