opal 1.0.1 → 1.1.0.rc1

data/test/nodejs/test_file.rb

@@ -0,0 +1,206 @@
+# Copied from cruby and modified to skip unsupported syntaxes
+require 'test/unit'
+require 'nodejs'
+require 'nodejs/file'
+
+class TestNodejsFile < Test::Unit::TestCase
+  def tmpdir
+    `require('os').tmpdir()`
+  end
+
+  def self.windows_platform?
+    `process.platform`.start_with?('win')
+  end
+
+  def test_instantiate_without_open_mode
+    # By default the open mode is 'r' (read only)
+    File.write('tmp/quz', "world")
+    file = File.new('tmp/quz')
+    assert_equal('tmp/quz', file.path)
+  end
+
+  def test_mtime
+    File.write('tmp/qix', "hello")
+    file = 'tmp/qix'
+    File.new(file, 'r')
+
+    t1 = File.mtime(file)
+    t2 = File.open(file) {|f| f.mtime}
+    assert_kind_of(Time, t1)
+    assert_kind_of(Time, t2)
+    assert_equal(t1, t2)
+    assert_raise(Errno::ENOENT) { File.mtime('nofile') }
+  end
+
+  def test_write_read
+    path = tmpdir + "/testing_nodejs_file_implementation_#{Time.now.to_i}"
+    contents = 'foobar'
+    assert !File.exist?(path)
+    File.write path, contents
+
+    assert_equal(contents, File.read(path))
+  end
+
+  def test_read_file
+    File.write('tmp/foo', 'bar')
+    assert_equal('bar', File.read('tmp/foo'))
+  end
+
+  def test_read_binary_image
+    assert_match(/^\u0089PNG\r\n\u001A\n\u0000\u0000\u0000\rIHDR.*/, File.open('./test/nodejs/fixtures/cat.png', 'rb') {|f| f.read })
+  end
+
+  def test_read_binary_utf8_file
+    binary_text = ::File.open('./test/nodejs/fixtures/utf8.txt', 'rb') {|f| f.read}
+    assert_equal(binary_text.encoding, Encoding::UTF_8)
+    assert_match(/^\u00E7\u00E9\u00E0/, binary_text)
+    utf8_text = binary_text.force_encoding('utf-8')
+    assert_equal("çéà", utf8_text)
+  end
+
+  def test_read_binary_iso88591_file
+    binary_text = ::File.open('./test/nodejs/fixtures/iso88591.txt', 'rb') {|f| f.read}
+    assert_equal(binary_text.encoding, Encoding::UTF_8)
+    assert_match(/^\u00E7\u00E9\u00E0/, binary_text)
+    utf8_text = binary_text.force_encoding('utf-8')
+    assert_equal("çéà", utf8_text)
+  end
+
+  def test_read_binary_win1258_file
+    binary_text = ::File.open('./test/nodejs/fixtures/win1258.txt', 'rb') {|f| f.read}
+    assert_equal(binary_text.encoding, Encoding::UTF_8)
+    assert_match(/^\u00E7\u00E9\u00E0/, binary_text)
+    utf8_text = binary_text.force_encoding('utf-8')
+    assert_equal("çéà", utf8_text)
+  end
+
+  def test_read_each_line
+    File.write('tmp/bar', "one\ntwo")
+    file = File.new('tmp/bar', 'r')
+    lines = []
+    file.each_line do |line|
+      lines << line
+    end
+    assert_equal(2, lines.length)
+    assert_equal("one\n", lines[0])
+    assert_equal('two', lines[1])
+  end
+
+  def test_readlines
+    File.write('tmp/quz', "one\ntwo")
+    file = File.new('tmp/quz', 'r')
+    lines = file.readlines
+    assert_equal(2, lines.length)
+    assert_equal("one\n", lines[0])
+    assert_equal('two', lines[1])
+  end
+
+  def test_readlines_separator
+    File.write('tmp/qux', "one-two")
+    file = File.new('tmp/qux', 'r')
+    lines = file.readlines '-'
+    assert_equal(2, lines.length)
+    assert_equal('one-', lines[0])
+    assert_equal('two', lines[1])
+  end
+
+  def test_read_noexistent_should_raise_io_error
+    assert_raise Errno::ENOENT do
+      File.read('tmp/nonexistent')
+    end
+  end
+
+  def test_mtime_noexistent_should_raise_io_error
+    assert_raise(Errno::ENOENT) { File.mtime('tmp/nonexistent') }
+  end
+
+  def test_current_directory_should_be_a_directory
+    assert(File.directory?('.'))
+  end
+
+  def test_current_directory_should_be_a_directory_using_pathname
+    current_dir = Pathname.new('.')
+    assert(current_dir.directory?)
+  end
+
+  def test_directory_check
+    refute(File.directory?('test/nodejs/fixtures/non-existent'),          'test/nodejs/fixtures/non-existent should not be a directory')
+    assert(File.directory?('test/nodejs/fixtures/'),                      'test/nodejs/fixtures/ should be a directory')
+    assert(File.directory?('test/nodejs/fixtures'),                       'test/nodejs/fixtures should be a directory')
+    refute(File.directory?('test/nodejs/fixtures/hello.rb'),              'test/nodejs/fixtures/hello.rb should not be a directory')
+  end
+
+  def test_directory_check_with_symlinks
+    assert(File.directory?('test/nodejs/fixtures/symlink-to-directory'),  'test/nodejs/fixtures/symlink-to-directory should be a directory')
+    assert(File.directory?('test/nodejs/fixtures/symlink-to-directory/'), 'test/nodejs/fixtures/symlink-to-directory/ should be a directory')
+    refute(File.directory?('test/nodejs/fixtures/symlink-to-file'),       'test/nodejs/fixtures/symlink-to-file should not be a directory')
+  end unless windows_platform?
+
+  def test_file_check
+    refute(File.file?('test/nodejs/fixtures/non-existent'),          'test/nodejs/fixtures/non-existent should not be a file')
+    refute(File.file?('test/nodejs/fixtures/'),                      'test/nodejs/fixtures/ should not be a file')
+    refute(File.file?('test/nodejs/fixtures'),                       'test/nodejs/fixtures should not be a file')
+    assert(File.file?('test/nodejs/fixtures/hello.rb'),              'test/nodejs/fixtures/hello.rb should be a file')
+  end
+
+  def test_file_check_with_symlinks
+    refute(File.file?('test/nodejs/fixtures/symlink-to-directory'),  'test/nodejs/fixtures/symlink-to-directory should not be a file')
+    refute(File.file?('test/nodejs/fixtures/symlink-to-directory/'), 'test/nodejs/fixtures/symlink-to-directory/ should not be a file')
+    assert(File.file?('test/nodejs/fixtures/symlink-to-file'),       'test/nodejs/fixtures/symlink-to-file should be a file')
+  end unless windows_platform?
+
+  def test_file_symlink?
+    assert(File.symlink?('test/nodejs/fixtures/symlink-to-file'))
+    assert(File.symlink?('test/nodejs/fixtures/symlink-to-directory'))
+    refute(File.symlink?('test/nodejs/fixtures'))
+    refute(File.symlink?('test/nodejs/fixtures/hello.rb'))
+  end unless windows_platform?
+
+  def test_file_readable
+    assert !File.readable?('tmp/nonexistent')
+    File.write('tmp/fuz', "hello")
+    assert File.readable?('tmp/fuz')
+  end
+
+  def test_linux_separators
+    assert_equal('/', File::SEPARATOR)
+    assert_equal('/', File::Separator)
+    assert_equal(nil, File::ALT_SEPARATOR)
+  end unless windows_platform?
+
+  def test_windows_separators
+    assert_equal('/', File::SEPARATOR)
+    assert_equal('/', File::Separator)
+    assert_equal('\\', File::ALT_SEPARATOR)
+  end if windows_platform?
+
+  def test_windows_file_expand_path
+    drive_letter = Dir.pwd.slice(0, 2)
+    assert_equal(Dir.pwd + '/foo/bar.js', File.expand_path('./foo/bar.js'))
+    assert_equal(drive_letter + '/foo/bar.js', File.expand_path('/foo/bar.js'))
+    assert_equal('c:/foo/bar.js', File.expand_path('c:/foo/bar.js'))
+    assert_equal('c:/foo/bar.js', File.expand_path('c:\\foo\\bar.js'))
+    assert_equal('c:/foo/bar.js', File.expand_path('bar.js', 'c:\\foo'))
+    assert_equal('c:/baz/bar.js', File.expand_path('\\baz\\bar.js', 'c:\\foo'))
+    assert_equal('c:/bar.js', File.expand_path('\\..\\bar.js', 'c:\\foo\\baz'))
+    assert_equal('c:/bar.js', File.expand_path('\\..\\bar.js', 'c:\\foo\\baz\\'))
+    assert_equal('c:/foo/baz/bar.js', File.expand_path('baz\\bar.js', 'c:\\foo'))
+    assert_equal('c:/baz/bar.js', File.expand_path('baz\\bar.js', 'c:\\foo\\..'))
+    assert_equal('d:/', File.expand_path('d:'), 'should add a trailing slash when the path is d:')
+    assert_equal('d:/', File.expand_path('d:/'), 'should preserve the trailing slash when the path d:/')
+    assert_equal(Dir.pwd, File.expand_path(drive_letter), 'should expand to the current directory when the path is c: (and the current directory is located in the c drive)')
+    assert_equal(drive_letter + '/', drive_letter + '/', 'should return c:/ when the path is c:/ because the path is absolute')
+  end if windows_platform?
+
+  def test_linux_file_expand_path
+    assert_equal(Dir.pwd + '/foo/bar.js', File.expand_path('./foo/bar.js'))
+    assert_equal(Dir.home + '/foo/bar.js', File.expand_path('~/foo/bar.js'))
+    assert_equal(Dir.home + '/foo/bar.js', File.expand_path('~/foo/bar.js', '/base/dir'))
+    assert_equal('/base/dir/foo/bar.js', File.expand_path('./foo/bar.js', '/base/dir'))
+    assert_equal(Dir.home + '/workspace/foo/bar.js', File.expand_path('./foo/bar.js', '~/workspace'))
+  end unless windows_platform?
+
+  def test_join
+    assert_equal('usr/bin', File.join('usr', 'bin'))
+  end
+end

data/test/nodejs/test_file_encoding.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'nodejs'
+require 'nodejs/file'
+
+class TestNodejsFileEncoding < Test::Unit::TestCase
+
+  def test_force_encoding_raw_text_to_utf8
+    raw_text = 'çéà'
+    assert_equal(raw_text.encoding, Encoding::UTF_8)
+    utf8_text = raw_text.force_encoding('utf-8')
+    assert_equal("çéà", utf8_text)
+  end
+
+  def test_force_encoding_from_binary_to_utf8
+    raw_text = "\xC3\xA7\xC3\xA9\xC3\xA0"
+    assert_equal(raw_text.encoding, Encoding::UTF_8)
+    utf8_text = raw_text.force_encoding('utf-8')
+    assert_equal("çéà", utf8_text)
+  end
+end

data/test/nodejs/test_io.rb

@@ -0,0 +1,18 @@
+# Copied from cruby and modified to skip unsupported syntaxes
+require 'test/unit'
+require 'nodejs'
+require 'nodejs/io'
+
+class TestNodejsIO < Test::Unit::TestCase
+
+  def test_binread
+    File.write('tmp/foo', 'bar')
+    assert_equal("bar", IO.binread('tmp/foo'))
+  end
+
+  def test_binread_noexistent_should_raise_io_error
+    assert_raise IOError do
+      IO.binread('tmp/nonexistent')
+    end
+  end
+end

data/test/nodejs/test_opal_builder.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'nodejs'
+require 'opal-builder'
+
+class TestNodejsOpalBuilder < Test::Unit::TestCase
+
+  def test_should_build_simple_ruby_file
+    builder = Opal::Builder.new
+    result = builder.build('test/nodejs/fixtures/hello.rb')
+    assert(/self\.\$puts\("Hello world"\)/.match(result.to_s))
+  end
+end

data/test/nodejs/test_pathname.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'nodejs'
+
+class TestNodejsPathname < Test::Unit::TestCase
+  def self.windows_platform?
+    `process.platform`.start_with?('win')
+  end
+
+  def test_windows_pathname_absolute
+    assert_equal(true, Pathname.new('c:/foo').absolute?)
+    assert_equal(true, Pathname.new('/foo').absolute?)
+    assert_equal(true, Pathname.new('\\foo').absolute?)
+    assert_equal(false, Pathname.new('.').absolute?)
+    assert_equal(false, Pathname.new('foo').absolute?)
+  end if windows_platform?
+end

data/test/opal/http_server.rb

@@ -0,0 +1,52 @@
+require 'sinatra'
+
+cat_image = File.open(File.join(File.dirname(__FILE__), 'cat.png'), 'rb').read
+
+get '/' do
+  'Ready!'
+end
+
+get '/plain_text' do
+  status 200
+  headers \
+    'Content-Type' => 'text/plain'
+  body 'plain text'
+end
+
+
+get '/no_header' do
+  status 200
+  headers \
+    'Content-Type' =>  ''
+  body 'no header'
+end
+
+get '/html' do
+  status 200
+  headers \
+    'Content-Type' => 'text/html; charset=utf-8'
+  body '<body>'
+end
+
+get '/png' do
+  status 200
+  headers \
+    'Content-Type' => 'image/png'
+  body cat_image
+end
+
+get '/404' do
+  status 404
+end
+
+get '/500' do
+  status 500
+end
+
+get '/last_modified' do
+  status 200
+  headers \
+    'Content-Type' => 'text/plain',
+    'Last-Modified' => 'Wed, 21 Oct 2015 07:28:00 GMT'
+  body 'Look Ma, I have a Last-Modified header'
+end

data/test/opal/test_base64.rb

@@ -0,0 +1,115 @@
+# coding: ascii-8bit
+# frozen_string_literal: false
+require "test/unit"
+require "base64"
+
+class TestBase64 < Test::Unit::TestCase
+  def test_sample
+    assert_equal("U2VuZCByZWluZm9yY2VtZW50cw==\n", Base64.encode64('Send reinforcements'))
+    assert_equal('Send reinforcements', Base64.decode64("U2VuZCByZWluZm9yY2VtZW50cw==\n"))
+    assert_equal(
+      "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g\nUnVieQ==\n",
+      Base64.encode64("Now is the time for all good coders\nto learn Ruby"))
+    assert_equal(
+      "Now is the time for all good coders\nto learn Ruby",
+      Base64.decode64("Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g\nUnVieQ==\n"))
+    assert_equal(
+      "VGhpcyBpcyBsaW5lIG9uZQpUaGlzIGlzIGxpbmUgdHdvClRoaXMgaXMgbGlu\nZSB0aHJlZQpBbmQgc28gb24uLi4K\n",
+      Base64.encode64("This is line one\nThis is line two\nThis is line three\nAnd so on...\n"))
+    assert_equal(
+      "This is line one\nThis is line two\nThis is line three\nAnd so on...\n",
+      Base64.decode64("VGhpcyBpcyBsaW5lIG9uZQpUaGlzIGlzIGxpbmUgdHdvClRoaXMgaXMgbGluZSB0aHJlZQpBbmQgc28gb24uLi4K"))
+  end
+
+  def test_encode64
+    assert_equal("", Base64.encode64(""))
+    assert_equal("AA==\n", Base64.encode64("\0"))
+    assert_equal("AAA=\n", Base64.encode64("\0\0"))
+    assert_equal("AAAA\n", Base64.encode64("\0\0\0"))
+    assert_equal("/w==\n", Base64.encode64("\377"))
+    assert_equal("//8=\n", Base64.encode64("\377\377"))
+    assert_equal("////\n", Base64.encode64("\377\377\377"))
+    assert_equal("/+8=\n", Base64.encode64("\xff\xef"))
+  end
+
+  def test_decode64
+    assert_equal("", Base64.decode64(""))
+    assert_equal("\0", Base64.decode64("AA==\n"))
+    assert_equal("\0\0", Base64.decode64("AAA=\n"))
+    assert_equal("\0\0\0", Base64.decode64("AAAA\n"))
+    assert_equal("\377", Base64.decode64("/w==\n"))
+    assert_equal("\377\377", Base64.decode64("//8=\n"))
+    assert_equal("\377\377\377", Base64.decode64("////\n"))
+    assert_equal("\xff\xef", Base64.decode64("/+8=\n"))
+  end
+
+  def test_strict_encode64
+    assert_equal("", Base64.strict_encode64(""))
+    assert_equal("AA==", Base64.strict_encode64("\0"))
+    assert_equal("AAA=", Base64.strict_encode64("\0\0"))
+    assert_equal("AAAA", Base64.strict_encode64("\0\0\0"))
+    assert_equal("/w==", Base64.strict_encode64("\377"))
+    assert_equal("//8=", Base64.strict_encode64("\377\377"))
+    assert_equal("////", Base64.strict_encode64("\377\377\377"))
+    assert_equal("/+8=", Base64.strict_encode64("\xff\xef"))
+  end
+
+  def test_strict_decode64
+    assert_equal("", Base64.strict_decode64(""))
+    assert_equal("\0", Base64.strict_decode64("AA=="))
+    assert_equal("\0\0", Base64.strict_decode64("AAA="))
+    assert_equal("\0\0\0", Base64.strict_decode64("AAAA"))
+    assert_equal("\377", Base64.strict_decode64("/w=="))
+    assert_equal("\377\377", Base64.strict_decode64("//8="))
+    assert_equal("\377\377\377", Base64.strict_decode64("////"))
+    assert_equal("\xff\xef", Base64.strict_decode64("/+8="))
+
+    assert_raise(ArgumentError) { Base64.strict_decode64("^") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("A") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("A^") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AA") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AA=") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AA===") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AA=x") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AAA") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AAA^") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AB==") }
+    assert_raise(ArgumentError) { Base64.strict_decode64("AAB=") }
+  end
+
+  def test_urlsafe_encode64
+    assert_equal("", Base64.urlsafe_encode64(""))
+    assert_equal("AA==", Base64.urlsafe_encode64("\0"))
+    assert_equal("AAA=", Base64.urlsafe_encode64("\0\0"))
+    assert_equal("AAAA", Base64.urlsafe_encode64("\0\0\0"))
+    assert_equal("_w==", Base64.urlsafe_encode64("\377"))
+    assert_equal("__8=", Base64.urlsafe_encode64("\377\377"))
+    assert_equal("____", Base64.urlsafe_encode64("\377\377\377"))
+    assert_equal("_-8=", Base64.urlsafe_encode64("\xff\xef"))
+  end
+
+  def test_urlsafe_encode64_unpadded
+    assert_equal("", Base64.urlsafe_encode64("", padding: false))
+    assert_equal("AA", Base64.urlsafe_encode64("\0", padding: false))
+    assert_equal("AAA", Base64.urlsafe_encode64("\0\0", padding: false))
+    assert_equal("AAAA", Base64.urlsafe_encode64("\0\0\0", padding: false))
+  end
+
+  def test_urlsafe_decode64
+    assert_equal("", Base64.urlsafe_decode64(""))
+    assert_equal("\0", Base64.urlsafe_decode64("AA=="))
+    assert_equal("\0\0", Base64.urlsafe_decode64("AAA="))
+    assert_equal("\0\0\0", Base64.urlsafe_decode64("AAAA"))
+    assert_equal("\377", Base64.urlsafe_decode64("_w=="))
+    assert_equal("\377\377", Base64.urlsafe_decode64("__8="))
+    assert_equal("\377\377\377", Base64.urlsafe_decode64("____"))
+    assert_equal("\xff\xef", Base64.urlsafe_decode64("_+8="))
+  end
+
+  def test_urlsafe_decode64_unpadded
+    assert_equal("\0", Base64.urlsafe_decode64("AA"))
+    assert_equal("\0\0", Base64.urlsafe_decode64("AAA"))
+    assert_equal("\0\0\0", Base64.urlsafe_decode64("AAAA"))
+    assert_raise(ArgumentError) { Base64.urlsafe_decode64("AA=") }
+  end
+end