opal 1.0.1 → 1.1.0.rc1

data/spec/opal/core/string/to_sym_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'String#to_sym' do
+  it 'returns a string literal' do
+    str = "string"
+    sym = str.to_sym
+    `typeof(sym)`.should == 'string'
+  end
+end

data/spec/opal/core/string_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Encoding' do
+  it 'supports US-ASCII' do
+    "è".encoding.name.should == 'UTF-8'
+    "è".force_encoding('ASCII').should == "\xC3\xA8"
+    "è".force_encoding('ascii').should == "\xC3\xA8"
+    "è".force_encoding('US-ASCII').should == "\xC3\xA8"
+    "è".force_encoding('us-ascii').should == "\xC3\xA8"
+    "è".force_encoding('ASCII-8BIT').should == "\xC3\xA8"
+    "è".force_encoding('ascii-8bit').should == "\xC3\xA8"
+    "è".force_encoding('BINARY').should == "\xC3\xA8"
+    "è".force_encoding('binary').should == "\xC3\xA8"
+  end
+
+  describe '.find' do
+    it 'finds the encoding regardless of the case' do
+      Encoding.find('ASCII').should == Encoding::ASCII
+      Encoding.find('ascii').should == Encoding::ASCII
+      Encoding.find('US-ASCII').should == Encoding::ASCII
+      Encoding.find('us-ascii').should == Encoding::ASCII
+      Encoding.find('ASCII-8BIT').should == Encoding::ASCII
+      Encoding.find('ascii-8bit').should == Encoding::ASCII
+      Encoding.find('BINARY').should == Encoding::ASCII
+      Encoding.find('binary').should == Encoding::ASCII
+    end
+  end
+end

data/spec/opal/core/struct/dup_spec.rb

@@ -0,0 +1,11 @@
+describe "Struct#dup" do
+  it "should return another struct instance" do
+    klass = Struct.new("Klass", :foo)
+    a = klass.new(1)
+    b = a.dup
+    b.foo = 2
+
+    a.foo.should == 1
+    b.foo.should == 2
+  end
+end

data/spec/opal/core/time_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'time'
+
+# rubyspec does not have specs for these listed methods
+describe Time do
+  describe '<=>' do
+    it 'returns -1 when self is less than other' do
+      (Time.new(2015, 1, 1) <=> Time.new(2015, 1, 2)).should == -1
+    end
+
+    it 'returns 0 when self is equal to other' do
+      (Time.new(2015, 1, 1) <=> Time.new(2015, 1, 1)).should == 0
+    end
+
+    it 'returns 1 when self is greater than other' do
+      (Time.new(2015, 1, 2) <=> Time.new(2015, 1, 1)).should == 1
+    end
+
+    it 'returns nil when compared to non-Time objects' do
+      (Time.new <=> nil).should == nil
+    end
+  end
+
+  describe "#==" do
+    it "returns true if self is equal to other date" do
+      (Time.new(2013, 9, 13) == Time.new(2013, 9, 13)).should == true
+    end
+
+    it "returns false if self is not equal to other date" do
+      (Time.new(2013, 10, 2) == Time.new(2013, 10, 11)).should == false
+    end
+
+    it 'returns false when compared to non-Time objects' do
+      (Time.new == nil).should == false
+      (Time.new == Object.new).should == false
+    end
+  end
+
+  describe '#zone' do
+    context 'with different TZs on Tue Jun 20 20:50:08 UTC 2017' do
+      it 'zone is +12' do
+        time = Time.now
+
+        # export TZ="/usr/share/zoneinfo/Pacific/Fiji"; node -e 'console.log(new Date().toString())'
+        time.JS[:toString] = -> { 'Wed Jun 21 2017 08:42:01 GMT+1200 (+12)' }
+        time.zone.should == '+12'
+
+        # export TZ="/usr/share/zoneinfo/Europe/Rome"; node -e 'console.log(new Date().toString())'
+        time.JS[:toString] = -> { 'Tue Jun 20 2017 22:52:57 GMT+0200 (CEST)' }
+        time.zone.should == 'CEST'
+
+        # export TZ="/usr/share/zoneinfo/Europe/Rome"; node -e 'console.log(new Date().toString())'
+        time.JS[:toString] = -> { 'Tue Jun 20 2017 23:56:54 GMT+0300 (MSK)' }
+        time.zone.should == 'MSK'
+
+        # https://github.com/opal/opal/issues/403
+        time.JS[:toString] = -> { 'Wed May 07 2014 11:59:05 GMT+0300 (Финляндия (лето))' }
+        time.zone.should == 'Финляндия (лето)'
+      end
+    end
+  end
+
+  describe '#utc_offset' do
+    it 'returns 0 if the date is UTC' do
+      Time.new.utc.utc_offset.should == 0
+    end
+  end
+end

data/spec/opal/stdlib/erb/erb_spec.rb

@@ -0,0 +1,30 @@
+require 'erb'
+require File.expand_path('../simple', __FILE__)
+require File.expand_path('../quoted', __FILE__)
+require File.expand_path('../inline_block', __FILE__)
+
+describe "ERB files" do
+  before :each do
+    @simple = Template['opal/stdlib/erb/simple']
+    @quoted = Template['opal/stdlib/erb/quoted']
+    @inline_block = Template['opal/stdlib/erb/inline_block']
+  end
+
+  it "should be defined by their filename on Template namespace" do
+    @simple.should be_kind_of(Template)
+  end
+
+  it "calling the block with a context should render the block" do
+    @some_data = "hello"
+    @simple.render(self).should == "<div>hello</div>\n"
+  end
+
+  it "should accept quotes in strings" do
+    @name = "adam"
+    @quoted.render(self).should == "<div class=\"foo\">hello there adam</div>\n"
+  end
+
+  it "should be able to handle inline blocks" do
+    @inline_block.should be_kind_of(Template)
+  end
+end

data/spec/opal/stdlib/erb/inline_block.opalerb

@@ -0,0 +1,3 @@
+<%= some_helper do %>
+  <h1>Hi there</h1>
+<% end %>

data/spec/opal/stdlib/erb/quoted.opalerb

@@ -0,0 +1 @@
+<div class="foo">hello <%= "there" + " #{@name}" %></div>

data/spec/opal/stdlib/erb/simple.opalerb

@@ -0,0 +1 @@
+<div><%= @some_data %></div>

data/spec/opal/stdlib/js_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'js'
+
+describe 'javascript operations using JS module' do
+  it 'JS.typeof uses typeof to return underlying javascript type' do
+    [1, `null`, `undefined`, Object.new, [], ""].each do |v|
+      JS.typeof(v).should == `typeof #{v}`
+    end
+  end
+
+  it 'JS.new uses new to create new instance' do
+    f = `function(){}`
+    f.JS[:prototype].JS[:color] = 'black'
+    JS.new(f).JS[:color].should == 'black'
+  end
+
+  it 'JS.new handles blocks' do
+    f = `function(a){this.a = a}`
+    JS.new(f){1}.JS.a.should == 1
+  end
+
+  it 'JS.instanceof uses instanceof to check if value is an instance of a function' do
+    f = `function(){}`
+    JS.instanceof(JS.new(f), f).should == true
+    JS.instanceof(JS.new(f), `function(){}`).should == false
+  end
+
+  it 'JS.delete uses delete to remove properties from objects' do
+    f = `{a:1}`
+    f.JS[:a].should == 1
+    JS.delete(f, :a)
+    `#{f.JS[:a]} === undefined`.should == true
+  end
+
+  it 'JS.in uses in to check for properties in objects' do
+    f = `{a:1}`
+    JS.in(:a, f).should == true
+    JS.in(:b, f).should == false
+  end
+
+  it 'JS.void returns undefined' do
+    f = 1
+    `#{JS.void(f += 1)} === undefined`.should == true
+    f.should == 2
+  end
+
+  it 'JS.call calls global javascript methods' do
+    JS.call(:parseFloat, '1.0').should == 1
+    JS.call(:parseInt, '1').should == 1
+    JS.call(:eval, "({a:1})").JS[:a].should == 1
+  end
+
+  it 'JS.method_missing calls global javascript methods' do
+    JS.parseFloat('1.0').should == 1
+    JS.parseInt('1').should == 1
+  end
+
+  it 'JS.call calls global javascript methods with blocks' do
+    begin
+      JS.global.JS[:_test_global_function] = lambda{|pr| pr.call + 1}
+      JS._test_global_function{1}.should == 2
+    ensure
+      JS.delete(JS.global, :_test_global_function)
+    end
+  end
+
+  it 'JS.<METHOD> supports complex method calls' do
+    obj = `{ foo: function(){return "foo"} }`
+    args = [1,2,3]
+    obj.JS.foo(*args).should == :foo
+  end
+end

data/spec/opal/stdlib/json/ext_spec.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+describe "Hash#to_json" do
+  it "returns a string of all key and value pairs" do
+    {}.to_json.should == "{}"
+    {"a" => 1, "b" => 2}.to_json.should == '{"a":1, "b":2}'
+
+    hash = {"a" => 1, "b" => false, "c" => nil, "d" => true}
+    JSON.parse(hash.to_json).should == hash
+  end
+end
+
+describe "Array#to_json" do
+  it "returns a string of all array elements converted to json" do
+    [].to_json.should == "[]"
+    [1, 2, 3].to_json.should == "[1, 2, 3]"
+    [true, nil, false, "3", 42].to_json.should == '[true, null, false, "3", 42]'
+  end
+end
+
+describe "Boolean#to_json" do
+  it "returns 'true' when true" do
+    true.to_json.should == "true"
+  end
+
+  it "returns 'false' when false" do
+    false.to_json.should == "false"
+  end
+end
+
+describe "Kernel#to_json" do
+  it "returns an escaped #to_s of the receiver" do
+    self.to_json.should be_kind_of(String)
+  end
+end
+
+describe "NilClass#to_json" do
+  it "returns 'null'" do
+    nil.to_json.should == "null"
+  end
+end
+
+describe "String#to_json" do
+  it "returns an escaped string" do
+    "foo".to_json.should == "\"foo\""
+    "bar\nbaz".to_json.should == "\"bar\\nbaz\""
+  end
+end
+
+describe "Numeric#to_json" do
+  it "returns a string representing the number" do
+    42.to_json.should == "42"
+    3.142.to_json.should == "3.142"
+  end
+end

data/spec/opal/stdlib/json/parse_spec.rb

@@ -0,0 +1,37 @@
+require 'json'
+
+describe "JSON.parse" do
+  it "parses null into nil" do
+    JSON.parse("null").should be_nil
+  end
+
+  it "parses true into true" do
+    JSON.parse("true").should be_true
+  end
+
+  it "parses false into false" do
+    JSON.parse("false").should be_false
+  end
+
+  it "parses numbers into numbers" do
+    JSON.parse("42").should == 42
+    JSON.parse("3.142").should == 3.142
+  end
+
+  it "parses arrays into ruby arrays" do
+    JSON.parse("[]").should == []
+    JSON.parse("[1, 2, 3]").should == [1, 2, 3]
+    JSON.parse("[[1, 2, 3], [4, 5]]").should == [[1, 2, 3], [4, 5]]
+    JSON.parse("[null, true, false]").should == [nil, true, false]
+  end
+
+  it "parses object literals into ruby hashes" do
+    JSON.parse("{}").should == {}
+    JSON.parse('{"a": "b"}').should == {"a" => "b"}
+    JSON.parse('{"a": null, "b": 10, "c": [true, false]}').should == {"a" => nil, "b" => 10, "c" => [true, false]}
+  end
+
+  it "raises ParserError for invalid JSON" do
+    lambda { JSON.parse("invalid_json") }.should raise_error(JSON::ParserError)
+  end
+end

data/spec/opal/stdlib/logger/logger_spec.rb

@@ -0,0 +1,308 @@
+require 'logger'
+require 'stringio'
+
+# Our implementation of Logger only supports StringIO pipes.
+# Since we can't portably write a log file, nothing in rubyspec will run.
+describe Logger do
+  before do
+    @pipe = StringIO.new
+    @logger = Logger.new @pipe
+  end
+
+  describe "level" do
+    it "should set the level to DEBUG by default" do
+      @logger.level.should == Logger::Severity::DEBUG
+    end
+
+    it "should allow the level to be changed using an integer of a known level" do
+      @logger.level = Logger::Severity::INFO
+      @logger.level.should == Logger::Severity::INFO
+    end
+
+    it "should allow the level to be changed to an arbitrary integer value" do
+      @logger.level = 1000
+      @logger.level.should == 1000
+    end
+
+    it "should allow the level to be set using a case-insensitive level name" do
+      @logger.level = 'WaRn'
+      @logger.level.should == Logger::Severity::WARN
+    end
+
+    it "should raise an ArgumentError if the level is set to an unknown name" do
+      lambda { @logger.level = 'foobar' }.should raise_error(ArgumentError)
+    end
+
+    it "should report when debug level is enabled" do
+      @logger.debug?.should == true
+    end
+
+    it "should report when debug level is not enabled" do
+      @logger.level = Logger::Severity::DEBUG + 1
+      @logger.debug?.should == false
+    end
+
+    it "should report when info level is enabled" do
+      @logger.level = Logger::Severity::INFO
+      @logger.info?.should == true
+    end
+
+    it "should report when debug level is not enabled" do
+      @logger.level = Logger::Severity::INFO + 1
+      @logger.info?.should == false
+    end
+
+    it "should report when warn level is enabled" do
+      @logger.level = Logger::Severity::WARN
+      @logger.warn?.should == true
+    end
+
+    it "should report when warn level is not enabled" do
+      @logger.level = Logger::Severity::WARN + 1
+      @logger.warn?.should == false
+    end
+
+    it "should report when error level is enabled" do
+      @logger.level = Logger::Severity::ERROR
+      @logger.error?.should == true
+    end
+
+    it "should report when error level is not enabled" do
+      @logger.level = Logger::Severity::ERROR + 1
+      @logger.error?.should == false
+    end
+
+    it "should report when fatal level is enabled" do
+      @logger.level = Logger::Severity::FATAL
+      @logger.fatal?.should == true
+    end
+
+    it "should report when fatal level is not enabled" do
+      @logger.level = Logger::Severity::FATAL + 1
+      @logger.fatal?.should == false
+    end
+  end
+
+  describe "add" do
+    it "should not add a message to the log output if level is not enabled" do
+      @logger.level = Logger::Severity::INFO
+      @logger.add(Logger::Severity::DEBUG, 'message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should add a message to the log output if level is enabled" do
+      @logger.add(Logger::Severity::DEBUG, 'message').should == true
+      @pipe.string.should_not == ''
+    end
+
+    it "should coerce severity to UNKNOWN if falsy" do
+      @logger.level = Logger::Severity::UNKNOWN
+      @logger.add(nil, 'message').should == true
+      @pipe.string.should_not == ''
+    end
+
+    it "should format message using default formatter" do
+      @logger.add(Logger::Severity::DEBUG, 'message', 'program').should == true
+      @pipe.string.should =~ /^D, \[.+?\] +DEBUG -- program: message\n/
+    end
+
+    it "should log debug message if debug level is enabled" do
+      @logger.debug('message').should == true
+      @pipe.string.should =~ /^D, .*: message\n/
+    end
+
+    it "should not log debug message if debug level is not enabled" do
+      @logger.level = Logger::Severity::DEBUG + 1
+      @logger.debug('message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should log info message if info level is enabled" do
+      @logger.level = Logger::Severity::INFO
+      @logger.info('message').should == true
+      @pipe.string.should =~ /^I, .*: message\n/
+    end
+
+    it "should not log info message if info level is not enabled" do
+      @logger.level = Logger::Severity::INFO + 1
+      @logger.info('message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should log error message if info level is enabled" do
+      @logger.level = Logger::Severity::ERROR
+      @logger.error('message').should == true
+      @pipe.string.should =~ /^E, .*: message\n/
+    end
+
+    it "should not log error message if error level is not enabled" do
+      @logger.level = Logger::Severity::ERROR + 1
+      @logger.error('message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should log fatal message if fatal level is enabled" do
+      @logger.level = Logger::Severity::FATAL
+      @logger.fatal('message').should == true
+      @pipe.string.should =~ /^F, .*: message\n/
+    end
+
+    it "should not log fatal message if fatal level is not enabled" do
+      @logger.level = Logger::Severity::FATAL + 1
+      @logger.fatal('message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should log unknown message if unknown level is enabled" do
+      @logger.level = Logger::Severity::UNKNOWN
+      @logger.unknown('message').should == true
+      @pipe.string.should =~ /^U, .*: message\n/
+    end
+
+    it "should not log unknown message if unknown level is not enabled" do
+      @logger.level = Logger::Severity::UNKNOWN + 1
+      @logger.unknown('message').should == true
+      @pipe.string.should == ''
+    end
+
+    it "should use level name ANY in message if level is not known" do
+      @logger.add(1000, 'message', 'program').should == true
+      @pipe.string.should =~ /^A, \[.+?\] +ANY -- program: message\n/
+    end
+
+    it "should use message from block passed to add if block is given" do
+      @logger.add(Logger::Severity::DEBUG, nil, 'program') { 'message' }.should == true
+      @pipe.string.should include(' -- program: message')
+    end
+
+    it "should only require severity argument when calling add" do
+      @logger.add(Logger::Severity::DEBUG).should == true
+      @pipe.string.should include('DEBUG -- : nil')
+    end
+
+    it "should not require any arguments when calling level method" do
+      @logger.debug.should == true
+      @pipe.string.should include('DEBUG -- : nil')
+    end
+  end
+
+  describe "progname" do
+    it "should set progname to nil by default" do
+      @logger.progname.should be_nil
+    end
+
+    it "should leave progname blank in message by default" do
+      @logger.add(Logger::Severity::DEBUG, 'message').should == true
+      @pipe.string.should include(' DEBUG -- : message')
+    end
+
+    it "should allow the progname to be set" do
+      @logger.progname = 'program'
+      @logger.progname.should == 'program'
+    end
+
+    it "should use the progname from the logger in the message" do
+      @logger.progname = 'program'
+      @logger.add(Logger::Severity::DEBUG, 'message').should == true
+      @pipe.string.should include(' DEBUG -- program: message')
+    end
+
+    it "should allow the progname to be overridden when using add to log a message" do
+      @logger.progname = 'program'
+      @logger.add(Logger::Severity::DEBUG, 'message', 'app').should == true
+      @pipe.string.should include(' DEBUG -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of debug method" do
+      @logger.progname = 'program'
+      @logger.debug('app') { 'message' }.should == true
+      @pipe.string.should include(' DEBUG -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of info method" do
+      @logger.level = Logger::Severity::INFO
+      @logger.progname = 'program'
+      @logger.info('app') { 'message' }.should == true
+      @pipe.string.should include(' INFO -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of warn method" do
+      @logger.level = Logger::Severity::WARN
+      @logger.progname = 'program'
+      @logger.warn('app') { 'message' }.should == true
+      @pipe.string.should include(' WARN -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of error method" do
+      @logger.level = Logger::Severity::ERROR
+      @logger.progname = 'program'
+      @logger.error('app') { 'message' }.should == true
+      @pipe.string.should include(' ERROR -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of fatal method" do
+      @logger.level = Logger::Severity::FATAL
+      @logger.progname = 'program'
+      @logger.fatal('app') { 'message' }.should == true
+      @pipe.string.should include(' FATAL -- app: message')
+    end
+
+    it "should allow the progname to be overridden when using block form of unknown method" do
+      @logger.level = Logger::Severity::UNKNOWN
+      @logger.progname = 'program'
+      @logger.unknown('app') { 'message' }.should == true
+      @pipe.string.should include(' UNKNOWN -- app: message')
+    end
+  end
+
+  describe "formatter" do
+    it "should use the default formatter by default" do
+      @logger.formatter.should_not be_nil
+      @logger.formatter.should be_kind_of(Logger::Formatter)
+    end
+
+    it "should allow the formatter to be changed" do
+      MyFormatter = Class.new
+      @logger.formatter = MyFormatter.new
+      @logger.formatter.should be_kind_of(MyFormatter)
+    end
+
+    it "should invoke call method on the custom formatter to log a message" do
+      @logger.progname = 'app'
+      @logger.formatter = proc { |severity, time, progname, msg|
+        "#{severity} - #{time.to_i} - #{progname} - #{msg}\n"
+      }
+      @logger.debug('message').should == true
+      @pipe.string.should =~ /^DEBUG - \d+ - app - message\n$/
+    end
+  end
+
+  describe "message types" do
+    it "should allow message to be specified as a Hash" do
+      @logger.debug(text: 'message', context: 'account').should == true
+      @pipe.string.should include({ text: 'message', context: 'account' }.inspect)
+    end
+
+    it "should invoke inspect method to convert object message to string" do
+      message = { text: 'message', context: 'account' }
+      class << message
+        def inspect
+          "#{self[:text]} [#{self[:context]}]"
+        end
+      end
+      @logger.debug(message).should == true
+      @pipe.string.should include('message [account]')
+    end
+
+    it "should convert exception message to string" do
+      message = nil
+      begin
+        raise ArgumentError, 'message'
+      rescue => e
+        message = e
+      end
+      @logger.debug(message).should == true
+      @pipe.string.should =~ / message \(ArgumentError\)\nArgumentError: message\n  from /
+    end
+  end
+end