opal 0.7.0.beta3 → 0.7.0.rc1

data/lib/opal/parser/grammar.y

@@ -15,7 +15,7 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       tLCURLY tRCURLY tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
       tWORDS_BEG tAWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
       tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG
-      tLBRACK2 tLBRACK
+      tLBRACK2 tLBRACK tDSTAR
 
 prechigh
   right    tBANG tTILDE tUPLUS
@@ -1458,35 +1458,97 @@ xstring_contents: none
                       result = val[0]
                     }
 
-          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_f_block_arg
+     kwrest_mark: tPOW
+                | tDSTAR
+
+        f_kwrest: kwrest_mark tIDENTIFIER
+                    {
+                      result = new_kwrestarg(val[1])
+                    }
+                | kwrest_mark
+                    {
+                      result = new_kwrestarg()
+                    }
+
+         f_label: tLABEL
+                    {
+                      result = new_sym(val[0])
+                    }
+
+            f_kw: f_label arg_value
+                    {
+                      result = new_kwoptarg(val[0], val[1])
+                    }
+                | f_label
+                    {
+                      result = new_kwarg(val[0])
+                    }
+
+         f_kwarg: f_kw
+                    {
+                      result = [val[0]]
+                    }
+                | f_kwarg tCOMMA f_kw
+                    {
+                      result = val[0]
+                      result << val[2]
+                    }
+
+       args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
+                    {
+                      result = new_args_tail(val[0], val[2], val[3])
+                    }
+                | f_kwarg opt_f_block_arg
+                    {
+                      result = new_args_tail(val[0], nil, val[1])
+                    }
+                | f_kwrest opt_f_block_arg
+                    {
+                      result = new_args_tail(nil, val[0], val[1])
+                    }
+                | f_block_arg
+                    {
+                      result = new_args_tail(nil, nil, val[0])
+                    }
+
+   opt_args_tail: tCOMMA args_tail
+                    {
+                      result = val[1]
+                    }
+                | # none
+                    {
+                      result = new_args_tail(nil, nil, nil)
+                    }
+
+          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_args_tail
                     {
                       result = new_args(val[0], val[2], val[4], val[5])
                     }
-                | f_arg tCOMMA f_optarg opt_f_block_arg
+                | f_arg tCOMMA f_optarg opt_args_tail
                     {
                       result = new_args(val[0], val[2], nil, val[3])
                     }
-                | f_arg tCOMMA f_rest_arg opt_f_block_arg
+                | f_arg tCOMMA f_rest_arg opt_args_tail
                     {
                       result = new_args(val[0], nil, val[2], val[3])
                     }
-                | f_arg opt_f_block_arg
+                | f_arg opt_args_tail
                     {
                       result = new_args(val[0], nil, nil, val[1])
                     }
-                | f_optarg tCOMMA f_rest_arg opt_f_block_arg
+                | f_optarg tCOMMA f_rest_arg opt_args_tail
                     {
                       result = new_args(nil, val[0], val[2], val[3])
                     }
-                | f_optarg opt_f_block_arg
+                | f_optarg opt_args_tail
                     {
                       result = new_args(nil, val[0], nil, val[1])
                     }
-                | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_args_tail
                     {
                       result = new_args(nil, nil, val[0], val[1])
                     }
-                | f_block_arg
+                | args_tail
                     {
                       result = new_args(nil, nil, nil, val[0])
                     }

data/lib/opal/parser/lexer.rb

@@ -2,6 +2,23 @@ require 'strscan'
 require 'opal/parser/keywords'
 
 module Opal
+  # {Opal::Lexer} is used by {Opal::Parser} to step through ruby code, and
+  # returning tokens representing each chunk of ruby code.
+  #
+  # Tokens are in the form:
+  #
+  #     [token, [value, location]]
+  #
+  # where `location` is in the form `[line_number, column_number]`. The location
+  # data can be used to produce source maps in the compiler. Tokens are
+  # generally ruby symbols, and the value will always be a string value.
+  #
+  # The main method used by the parser is {#next_token}, which is called
+  # repeatedly until a token of value `false` is returned, which indicated the
+  # EOF has been reached.
+  #
+  # Generally this class is only used by {Opal::Parser} directly.
+  #
   class Lexer
 
     STR_FUNC_ESCAPE = 0x01
@@ -31,6 +48,13 @@ module Opal
     attr_accessor :yylval
     attr_accessor :parser
 
+    # Create a new instance using the given ruby code and filename for
+    # reference.
+    #
+    #     Opal::Lexer.new("ruby code", "my_file.rb")
+    #
+    # @param source [String] ruby code to lex
+    # @param file [String] filename of given ruby code
     def initialize(source, file)
       @lex_state  = :expr_beg
       @cond       = 0
@@ -48,6 +72,25 @@ module Opal
       @start_of_lambda = nil
     end
 
+    # Returns next token from source input stream.
+    #
+    # Token in form:
+    #
+    #     [token, [value, [source_line, source_column]]]
+    #
+    # @return [Array]
+    def next_token
+      token     = self.yylex
+      value     = self.yylval
+      location  = [@tok_line, @tok_column]
+
+      # once location is stored, ensure next token starts in correct place
+      @tok_column = @column
+      @tok_line = @line
+
+      [token, [value, location]]
+    end
+
     def has_local?(local)
       parser.scope.has_local?(local.to_sym)
     end
@@ -151,18 +194,6 @@ module Opal
       @line = @tok_line = line
     end
 
-    def next_token
-      token     = self.yylex
-      value     = self.yylval
-      location  = [@tok_line, @tok_column]
-
-      # once location is stored, ensure next token starts in correct place
-      @tok_column = @column
-      @tok_line = @line
-
-      [token, [value, location]]
-    end
-
     def new_strterm(func, term, paren)
       { :type => :string, :func => func, :term => term, :paren => paren }
     end
@@ -600,6 +631,7 @@ module Opal
       return matched =~ /^[A-Z]/ ? :tCONSTANT : :tIDENTIFIER
     end
 
+    # Does the heavy lifting for `next_token`.
     def yylex
       @yylval = ''
       @space_seen = false

data/lib/opal/parser/parser_scope.rb

@@ -6,6 +6,9 @@ module Opal
     attr_reader :locals
     attr_accessor :parent
 
+    # Create new parse scope. Valid types are :block, :class, :module, :def.
+    #
+    # @param type [Symbol] scope type
     def initialize(type)
       @block  = type == :block
       @locals = []

data/lib/opal/parser/sexp.rb

@@ -1,4 +1,11 @@
 module Opal
+  # [Opal::Sexp] is used to build up the syntax tree inside [Opal::Parser]. The
+  # compiler then steps through the sexp trees to generate the javascript code.
+  #
+  # For example, an array of integers `[1, 2]` might be represented by:
+  #
+  #     s(:array, s(:int, 1), s(:int, 2))
+  #
   class Sexp
 
     attr_reader :array
@@ -72,4 +79,3 @@ module Opal
     alias to_s inspect
   end
 end
-

data/lib/opal/paths.rb

@@ -19,19 +19,19 @@ module Opal
     paths << path
   end
 
-  def self.use_gem(gem_name, include_dependecies = true)
-    require_paths_for_gem(gem_name, include_dependecies).each do |path|
+  def self.use_gem(gem_name, include_dependencies = true)
+    require_paths_for_gem(gem_name, include_dependencies).each do |path|
       append_path path
     end
   end
 
-  def self.require_paths_for_gem(gem_name, include_dependecies)
+  def self.require_paths_for_gem(gem_name, include_dependencies)
     paths = []
     spec = Gem::Specification.find_by_name(gem_name)
 
     spec.runtime_dependencies.each do |dependency|
-      paths += require_paths_for_gem(dependency.name, include_dependecies)
-    end if include_dependecies
+      paths += require_paths_for_gem(dependency.name, include_dependencies)
+    end if include_dependencies
 
     gem_dir = spec.gem_dir
     spec.require_paths.map do |path|

data/lib/opal/sprockets/environment.rb

@@ -3,20 +3,12 @@ require 'opal/sprockets/processor'
 require 'opal/sprockets/erb'
 
 module Opal
-  # Proccess using Sprockets
-  #
-  #   Opal.process('opal-jquery')   # => String
+  # @deprecated
   def self.process asset
     Environment.new[asset].to_s
   end
 
-  # Environment is a subclass of Sprockets::Environment which already has our opal
-  # load paths loaded. This makes it easy for stand-alone rack apps, or test runners
-  # that have opal load paths ready to use. You can also add an existing gem's lib
-  # directory to our load path to use real gems inside your opal environment.
-  #
-  # If you are running rails, then you just need opal-rails instead, which will
-  # do this for you.
+  # @deprecated
   class Environment < ::Sprockets::Environment
     def initialize *args
       warn "WARNING: Opal::Sprockets::Environment is deprecated. "\

data/lib/opal/sprockets/path_reader.rb

@@ -10,7 +10,7 @@ module Opal
       def read path
         if path.end_with? '.js'
           context.depend_on_asset(path)
-          env[path].to_s
+          env[path, bundle: true].to_s
         else
           context.depend_on(path)
           File.read(expand(path))

data/lib/opal/sprockets/processor.rb

@@ -60,6 +60,7 @@ module Opal
     self.dynamic_require_severity    = :error # :error, :warning or :ignore
     self.source_map_enabled          = true
     self.irb_enabled                 = false
+    self.inline_operators_enabled    = false
 
     self.source_map_register         = $OPAL_SOURCE_MAPS
 

data/lib/opal/sprockets/server.rb

@@ -36,6 +36,8 @@ module Opal
 
         # "logical_name" of a BundledAsset keeps the .js extension
         source = register[asset.logical_path.sub(/\.js$/, '')]
+        return not_found(asset) if source.nil?
+
         map = JSON.parse(source)
         map['sources'] = map['sources'].map {|s| "#{prefix}/#{s}"}
         source = map.to_json

data/lib/opal/util.rb

@@ -2,13 +2,18 @@ module Opal
   module Util
     extend self
 
-    # Used for uglifying source to minify
+    # Used for uglifying source to minify.
+    #
+    #     Opal::Util.uglify("javascript contents")
+    #
+    # @param str [String] string to minify
+    # @return [String]
     def uglify(str)
       uglifyjs = DigestSourceCommand.new(:uglifyjs, nil, ' (install with: "npm install -g uglify-js")')
       uglifyjs.digest(str)
     end
 
-    # Gzip code to check file size
+    # Gzip code to check file size.
     def gzip(str)
       gzip = DigestSourceCommand.new(:gzip, '-f', ', it is required to produce the .gz version')
       gzip.digest(str)

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = '0.7.0.beta3'
+  VERSION = '0.7.0.rc1'
 end

data/opal.gemspec

@@ -33,4 +33,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bundler', '~> 1.5'
   s.add_development_dependency 'yard', '~> 0.8.7'
   s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'opal-minitest'
 end

data/opal/README.md

@@ -3,4 +3,4 @@
 This is the Opal corelib implementation API documentation.
 The whole corelib is loaded upon `require 'opal'`.
 
-The `runtime.js` documentation is [availble here](runtime.js.html)
+The `runtime.js` documentation is [available here](runtime.js.html)

data/opal/corelib/dir.rb

@@ -9,7 +9,7 @@ class Dir
     end
 
     def pwd
-      `Opal.current_dir` || '.'
+      `Opal.current_dir || '.'`
     end
     alias getwd pwd
 

data/opal/corelib/enumerable.rb

@@ -1079,7 +1079,9 @@ module Enumerable
   end
 
   def sort(&block)
-    raise NotImplementedError
+    ary = to_a
+    block = -> a,b {a <=> b} unless block_given?
+    return `ary.sort(block)`
   end
 
   def sort_by(&block)

data/opal/corelib/error.rb

@@ -48,6 +48,9 @@ class LoadError           < ScriptError; end
 class NotImplementedError < ScriptError; end
 
 class SystemExit        < Exception; end
+class NoMemoryError     < Exception; end
+class SignalException   < Exception; end
+class Interrupt         < Exception; end
 
 class StandardError     < Exception; end
 class NameError           < StandardError; end

data/opal/corelib/file.rb

@@ -1,5 +1,7 @@
 class File < IO
   Separator = SEPARATOR = '/'
+  ALT_SEPARATOR = nil
+  PATH_SEPARATOR = ':'
 
   class << self
     def expand_path(path, basedir = nil)

data/opal/corelib/hash.rb

@@ -3,6 +3,9 @@ require 'corelib/enumerable'
 class Hash
   include Enumerable
 
+  # Mark all hash instances as valid hashes (used to check keyword args, etc)
+  `def.$$is_hash = true`
+
   def self.[](*objs)
     `Opal.hash.apply(null, objs)`
   end

data/opal/corelib/io.rb

@@ -3,6 +3,14 @@ class IO
   SEEK_CUR = 1
   SEEK_END = 2
 
+  def tty?
+    @tty
+  end
+
+  def closed?
+    @closed
+  end
+
   attr_accessor :write_proc
 
   def write(string)
@@ -10,6 +18,8 @@ class IO
     string.size
   end
 
+  attr_accessor :sync
+
   module Writable
     def <<(string)
       write(string)
@@ -23,7 +33,11 @@ class IO
 
     def puts(*args)
       newline = $/
-      write args.map { |arg| String(arg).chomp }.concat([nil]).join(newline)
+      if args.empty?
+        write $/
+      else
+        write args.map { |arg| String(arg).chomp }.concat([nil]).join(newline)
+      end
       nil
     end
   end

data/opal/corelib/kernel.rb

@@ -71,6 +71,11 @@ module Kernel
     }
   end
 
+  def at_exit(&block)
+    $__at_exit__ ||= []
+    $__at_exit__ << block
+  end
+
   # Opal does not support #caller, but we stub it as an empty array to not
   # break dependant libs
   def caller
@@ -405,6 +410,7 @@ module Kernel
   end
 
   def load(file)
+    file = Opal.coerce_to!(file, String, :to_str)
     `Opal.load(Opal.normalize_loadable_path(#{file}))`
   end
 
@@ -521,10 +527,12 @@ module Kernel
   end
 
   def require(file)
+    file = Opal.coerce_to!(file, String, :to_str)
     `Opal.require(Opal.normalize_loadable_path(#{file}))`
   end
 
   def require_relative(file)
+    Opal.try_convert!(file, String, :to_str)
     file = File.expand_path File.join(`Opal.current_file`, '..', file)
 
     `Opal.require(Opal.normalize_loadable_path(#{file}))`