opal 0.10.0 → 0.11.0

data/lib/opal/compiler.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 require 'set'
 require 'opal/parser'
 require 'opal/fragment'
 require 'opal/nodes'
+require 'opal/eof_content'
 
 module Opal
   # Compile a string of ruby code into javascript.
@@ -106,7 +108,7 @@ module Opal
     # @!method dynamic_require_severity
     #
     # how to handle dynamic requires (:error, :warning, :ignore)
-    compiler_option :dynamic_require_severity, :warning, :valid_values => [:error, :warning, :ignore]
+    compiler_option :dynamic_require_severity, :ignore, :valid_values => [:error, :warning, :ignore]
 
     # @!method requirable?
     #
@@ -120,6 +122,16 @@ module Opal
 
     compiler_option :eval, false, as: :eval?
 
+    # @!method enable_source_location?
+    #
+    # Adds source_location for every method definition
+    compiler_option :enable_source_location, false, :as => :enable_source_location?
+
+    # @!method parse_comments?
+    #
+    # Adds comments for every method definition
+    compiler_option :parse_comments, false, :as => :parse_comments?
+
     # @return [String] The compiled ruby code
     attr_reader :result
 
@@ -135,34 +147,44 @@ module Opal
     # Any content in __END__ special construct
     attr_reader :eof_content
 
+    # Comments from the source code
+    attr_reader :comments
+
     def initialize(source, options = {})
       @source = source
       @indent = ''
       @unique = 0
       @options = options
+      @comments = Hash.new([])
+      @case_stmt = nil
     end
 
     # Compile some ruby code to a string.
     #
     # @return [String] javascript code
     def compile
-      @parser = Parser.new
-
-      parsed = begin
-        @parser.parse(@source, self.file)
-      rescue => error
-        raise SyntaxError, error.message, error.backtrace
-      end
-
-      @sexp = s(:top, parsed || s(:nil))
-      @eof_content = @parser.lexer.eof_content
+      parse
 
       @fragments = process(@sexp).flatten
 
       @result = @fragments.map(&:code).join('')
-    rescue Exception => error
-      message = "An error occurred while compiling: #{self.file}\n#{error.message}"
-      raise error.class, message, error.backtrace
+    end
+
+    def parse
+      @buffer = ::Opal::Source::Buffer.new(file, 1)
+      @buffer.source = @source
+
+      @parser = Opal::Parser.default_parser
+
+      begin
+        sexp, comments, tokens = @parser.tokenize(@buffer)
+      rescue ::Parser::SyntaxError => error
+        raise ::SyntaxError, error.message, error.backtrace
+      end
+
+      @sexp = s(:top, sexp || s(:nil))
+      @comments = ::Parser::Source::Comment.associate_locations(sexp, comments)
+      @eof_content = EofContent.new(tokens, @source).eof
     end
 
     # Returns a source map that can be used in the browser to map back to
@@ -217,8 +239,8 @@ module Opal
     # Create a new sexp using the given parts. Even though this just
     # returns an array, it must be used incase the internal structure
     # of sexps does change.
-    def s(*parts)
-      Sexp.new(parts)
+    def s(type, *children)
+      ::Opal::AST::Node.new(type, children)
     end
 
     def fragment(str, scope, sexp = nil)
@@ -227,8 +249,19 @@ module Opal
 
     # Used to generate a unique id name per file. These are used
     # mainly to name method bodies for methods that use blocks.
-    def unique_temp
-      "TMP_#{@unique += 1}"
+    def unique_temp(name)
+      name = name.to_s
+      if name && !name.empty?
+        name = "_#{name}"
+          .gsub('?', '$q')
+          .gsub('!', '$B')
+          .gsub('=', '$eq')
+          .gsub('<', '$lt')
+          .gsub('>', '$gt')
+          .gsub(/[^\w\$]/, '$')
+      end
+      unique = (@unique += 1)
+      "TMP#{name}_#{unique}"
     end
 
     # Use the given helper
@@ -266,14 +299,14 @@ module Opal
     def in_while
       return unless block_given?
       @while_loop = @scope.push_while
-      result = yield
+      result = indent { yield }
       @scope.pop_while
-
       result
     end
 
     def in_ensure
       return unless block_given?
+
       @in_ensure = true
       result = yield
       @in_ensure = false
@@ -282,31 +315,7 @@ module Opal
     end
 
     def in_ensure?
-      @in_ensure
-    end
-
-    # With a block will detect a break in the sexp processed from within
-    # the block (see BreakNode).
-    #
-    # Without a block (but inside a `#has_break?(&block)` call) returns the
-    # current result.
-    #
-    # Works in conjunction with #has_break!
-    #
-    # @return [Boolean] whether a block has been detected
-    def has_break?
-      return @break_detected unless block_given?
-      @break_detected = false
-      result = yield
-      detected = @break_detected
-      @break_detected = nil
-      detected
-    end
-
-    # Marks the current block has having detected a break, but only from inside
-    # a `#has_break?(&block)` block.
-    def has_break!
-      @break_detected = true if @break_detected == false
+      !!@in_ensure
     end
 
     def in_case
@@ -331,7 +340,7 @@ module Opal
       if handler = handlers[sexp.type]
         return handler.new(sexp, level, self).compile_to_fragments
       else
-        raise "Unsupported sexp: #{sexp.type}"
+        error "Unsupported sexp: #{sexp.type}"
       end
     end
 
@@ -365,69 +374,101 @@ module Opal
       return returns s(:nil) unless sexp
 
       case sexp.type
-      # Undefs go from 1 ruby undef a,b,c to multiple JS Opal.udef() calls, so need to treat them as individual statements
-      # and put the return on the last one
       when :undef
-        last = sexp.pop
-        sexp << returns(last)
+        # undef :method_name always returns nil
+        returns s(:begin, sexp, s(:nil))
       when :break, :next, :redo
         sexp
       when :yield
-        sexp[0] = :returnable_yield
-        sexp
-      when :scope
-        sexp[1] = returns sexp[1]
-        sexp
-      when :block
-        if sexp.length > 1
-          sexp[-1] = returns sexp[-1]
-        else
-          sexp << returns(s(:nil))
-        end
-        sexp
+        sexp.updated(:returnable_yield, nil)
       when :when
-        sexp[2] = returns(sexp[2])
-        sexp
+        *when_sexp, then_sexp = *sexp
+        sexp.updated(nil,
+          [*when_sexp, returns(then_sexp)]
+        )
       when :rescue
-        sexp[1] = returns sexp[1]
+        body_sexp, *resbodies, else_sexp = *sexp
 
-        if sexp[2] and sexp[2][0] == :resbody
-          if sexp[2][2]
-            sexp[2][2] = returns sexp[2][2]
-          else
-            sexp[2][2] = returns s(:nil)
-          end
+        resbodies = resbodies.map do |resbody|
+          returns(resbody)
         end
-        sexp
+
+        if else_sexp
+          else_sexp = returns(else_sexp)
+        end
+
+        sexp.updated(nil, [
+          returns(body_sexp),
+          *resbodies,
+          else_sexp
+        ])
+      when :resbody
+        klass, lvar, body = *sexp
+        sexp.updated(nil, [klass, lvar, returns(body)])
       when :ensure
-        sexp[1] = returns sexp[1]
-        sexp
-      when :begin
-        sexp[1] = returns sexp[1]
+        rescue_sexp, ensure_body = *sexp
+        sexp = sexp.updated(nil,
+          [returns(rescue_sexp), ensure_body]
+        )
+        s(:js_return, sexp)
+      when :begin, :kwbegin
+        # Wrapping last expression with s(:js_return, ...)
+        *rest, last = *sexp
+        sexp.updated(
+          nil,
+          [*rest, returns(last)]
+        )
+      when :while, :until, :while_post, :until_post
         sexp
-      when :rescue_mod
-        sexp[1] = returns sexp[1]
-        sexp[2] = returns sexp[2]
-        sexp
-      when :while
-        # sexp[2] = returns(sexp[2])
-        sexp
-      when :return, :js_return
+      when :return, :js_return, :returnable_yield
         sexp
       when :xstr
-        sexp[1] = "return #{sexp[1]};" unless /return|;/ =~ sexp[1]
-        sexp
-      when :dxstr
-        sexp[1] = "return #{sexp[1]}" unless /return|;|\n/ =~ sexp[1]
-        sexp
+        if sexp.children.any?
+          strs = sexp.
+            children.
+            select { |child| child.type == :str }.
+            map { |child| child.children[0] }
+
+          multiline = strs.any? { |str| str.end_with?(";\n") }
+
+          first_child, *rest_children = *sexp
+
+          if multiline
+            # xstr starts with interpolation
+            # then it must contain js_return inside
+            sexp
+          else
+            if first_child.type == :str
+              old_value = first_child.children[0]
+              if old_value.include?('return')
+                # 'return' is already there
+                sexp
+              else
+                first_child = s(:js_return, first_child)
+                sexp.updated(nil, [first_child, *rest_children])
+              end
+            else
+              s(:js_return, sexp)
+            end
+          end
+        else
+          returns s(:str, '')
+        end
       when :if
-        sexp[2] = returns(sexp[2] || s(:nil))
-        sexp[3] = returns(sexp[3] || s(:nil))
-        sexp
+        cond, true_body, false_body = *sexp
+        sexp.updated(
+          nil, [
+            cond,
+            returns(true_body),
+            returns(false_body)
+          ]
+        )
       else
-        return_sexp = s(:js_return, sexp)
-        return_sexp.source = sexp.source
-        return_sexp
+        s(:js_return, sexp).updated(
+          nil,
+          nil,
+          location: sexp.loc
+        )
       end
     end
 

data/lib/opal/config.rb

@@ -1,54 +1,132 @@
+# frozen_string_literal: true
 require 'set'
 
 module Opal
   module Config
-    def self.default_config
-      {
-        method_missing_enabled:    true,
-        arity_check_enabled:       false,
-        freezing_stubs_enabled:    true,
-        tainting_stubs_enabled:    true,
-        const_missing_enabled:     true,
-        dynamic_require_severity:  :warning, # :error, :warning or :ignore
-        irb_enabled:               false,
-        inline_operators_enabled:  true,
-        source_map_enabled:        true,
-        stubbed_files:             Set.new,
-      }
+    extend self
+
+    private
+
+    def config_options
+      @config_options ||= {}
     end
 
-    def self.config
-      @config ||= default_config
+    # Defines a new configuration option
+    #
+    # @param [String] name the option name
+    # @param [Object] default_value the option's default value
+    # @!macro [attach] property
+    #   @!attribute [rw] $1
+    def config_option(name, default_value, options = {})
+      compiler      = options.fetch(:compiler_option, nil)
+      valid_values  = options.fetch(:valid_values , [true, false])
+
+      config_options[name] = {
+        default: default_value,
+        compiler: compiler,
+      }
+
+      define_singleton_method(name) { config.fetch(name, default_value) }
+      define_singleton_method("#{name}=") do |value|
+        unless valid_values.any? { |valid_value| valid_value === value }
+          raise ArgumentError, "Not a valid value for option #{self}.#{name}, provided #{value.inspect}. "\
+                               "Must be #{valid_values.inspect} === #{value.inspect}"
+        end
+
+        config[name] = value
+      end
     end
 
-    def self.reset!
-      @config = nil
+    public
+
+    # @return [Hash] the default configuration
+    def default_config
+      default_config = {}
+      config_options.each do |name, options|
+        default_value = options.fetch(:default)
+        default_value = Proc === default_value ? default_value.call : default_value
+        default_config[name] = default_value
+      end
+      default_config
     end
 
-    COMPILER_KEYS = {
-      # Compiler option name:   # Config option name
-      method_missing:           :method_missing_enabled,
-      arity_check:              :arity_check_enabled,
-      freezing:                 :freezing_stubs_enabled,
-      tainting:                 :tainting_stubs_enabled,
-      const_missing:            :const_missing_enabled,
-      dynamic_require_severity: :dynamic_require_severity,
-      irb:                      :irb_enabled,
-      inline_operators:         :inline_operators_enabled,
-    }
-
-    def self.compiler_options
-      config = self.config
+    # @return [Hash] the configuration for Opal::Compiler
+    def compiler_options
       compiler_options = {}
-      COMPILER_KEYS.each do |compiler_option_name, option_name|
-        compiler_options[compiler_option_name] = config[option_name]
+      config_options.each do |name, options|
+        compiler_option_name = options.fetch(:compiler)
+        compiler_options[compiler_option_name] = config.fetch(name)
       end
       compiler_options
     end
 
-    default_config.keys.each do |config_option|
-      define_singleton_method(config_option) { config[config_option] }
-      define_singleton_method("#{config_option}=") { |value| config[config_option] = value }
+    # @return [Hash] the current configuration, defaults to #default_config
+    def config
+      @config ||= default_config
     end
+
+    # Resets the config to its default value
+    #
+    # @return [void]
+    def reset!
+      @config = nil
+    end
+
+
+    # Enable method_missing support.
+    #
+    # @return [true, false]
+    config_option :method_missing_enabled, true, compiler_option: :method_missing
+
+    # Enable const_missing support.
+    #
+    # @return [true, false]
+    config_option :const_missing_enabled, true, compiler_option: :const_missing
+
+    # Enable arity check on the arguments passed to methods, procs and lambdas.
+    #
+    # @return [true, false]
+    config_option :arity_check_enabled, false, compiler_option: :arity_check
+
+    # Add stubs for methods related to freezing objects (for compatibility).
+    #
+    # @return [true, false]
+    config_option :freezing_stubs_enabled, true, compiler_option: :freezing
+
+    # Add stubs for methods related to tainting objects (for compatibility).
+    #
+    # @return [true, false]
+    config_option :tainting_stubs_enabled, true, compiler_option: :tainting
+
+    # Set the error severity for when a require can't be solved at compile time.
+    #
+    # - `:error` will raise an error at compile time
+    # - `:warning` will print a warning on stderr at compile time
+    # - `:ignore` will skip the require silently at compile time
+    #
+    # @return [:error, :warning, :ignore]
+    config_option :dynamic_require_severity, :warning, compiler_option: :dynamic_require_severity, valid_values: [:error, :warning, :ignore]
+
+    # Enable IRB support for making local variables across multiple compilations.
+    #
+    # @return [true, false]
+    config_option :irb_enabled, false, compiler_option: :irb
+
+    # Enable for inline operators optimizations.
+    #
+    # @return [true, false]
+    config_option :inline_operators_enabled, true, compiler_option: :inline_operators
+
+    # Enable source maps support.
+    #
+    # @return [true, false]
+    config_option :source_map_enabled, true
+
+    # A set of stubbed files that will be marked as loaded and skipped during
+    # compilation. The value is expected to be mutated but it's ok to replace
+    # it.
+    #
+    # @return [Set]
+    config_option :stubbed_files, -> { Set.new }, valid_values: [Set]
   end
 end

data/lib/opal/deprecations.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Opal
+  module Deprecations
+    attr_accessor :raise_on_deprecation
+
+    def deprecation message
+      message = "DEPRECATION WARNING: #{message}"
+      if defined?(@raise_on_deprecation) && @raise_on_deprecation
+        raise message
+      else
+        warn message
+      end
+    end
+  end
+
+  extend Deprecations
+  self.raise_on_deprecation = false
+end

data/lib/opal/eof_content.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Opal
+  class EofContent
+    DATA_SEPARATOR = "__END__\n"
+
+    def initialize(tokens, source)
+      @tokens = tokens
+      @source = source
+    end
+
+    def eof
+      return nil if @tokens.empty?
+
+      eof_content = @source[last_token_position..-1]
+      return nil unless eof_content
+
+      eof_content = eof_content.lines.drop_while { |line| line == "\n" }
+
+      if eof_content[0] == "__END__\n"
+        eof_content = eof_content[1..-1] || []
+        eof_content.join
+      elsif eof_content == ["__END__"]
+        ""
+      end
+    end
+
+    private
+
+    def last_token_position
+      _, last_token_info = @tokens.last
+      _, last_token_range = last_token_info
+      last_token_range.end_pos
+    end
+  end
+end

data/lib/opal/erb.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/compiler'
 
 module Opal

data/lib/opal/errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Opal
   # raised if Gem not found in Opal#use_gem
   class GemNotFound < StandardError

data/lib/opal/fragment.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Opal
   # A fragment holds a string of generated javascript that will be written
   # to the destination. It also keeps hold of the original sexp from which

data/lib/opal/nodes/arglist.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -10,7 +11,7 @@ module Opal
         code, work = [], []
 
         children.each do |current|
-          splat = current.first == :splat
+          splat = current.type == :splat
           arg = expr(current)
 
           if splat

data/lib/opal/nodes/args/initialize_kwargs.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal

data/lib/opal/nodes/args/kwarg.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/args/initialize_kwargs'
 
 module Opal
@@ -9,20 +10,21 @@ module Opal
     #
     class KwargNode < InitializeKwargsNode
       handle :kwarg
+      children :lvar_name
 
       def compile
+        key_name = @sexp.meta[:arg_name]
+
         initialize_kw_args_if_needed
 
-        kwarg_name = @sexp[1].to_sym
-        var_name = variable(kwarg_name)
-        add_temp var_name
+        add_temp lvar_name
 
-        line "if (!$kwargs.$$smap.hasOwnProperty('#{kwarg_name}')) {"
-        line "  throw Opal.ArgumentError.$new('missing keyword: #{kwarg_name}');"
+        line "if (!Opal.hasOwnProperty.call($kwargs.$$smap, '#{key_name}')) {"
+        line "  throw Opal.ArgumentError.$new('missing keyword: #{key_name}');"
         line "}"
-        line "#{var_name} = $kwargs.$$smap['#{kwarg_name}'];"
+        line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
 
-        scope.used_kwargs << kwarg_name
+        scope.used_kwargs << key_name
       end
     end
   end

data/lib/opal/nodes/args/kwoptarg.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/args/initialize_kwargs'
 
 module Opal
@@ -9,20 +10,24 @@ module Opal
     #
     class KwoptArgNode < InitializeKwargsNode
       handle :kwoptarg
+      children :lvar_name, :default_value
 
       def compile
+        key_name = @sexp.meta[:arg_name]
+
         initialize_kw_args_if_needed
 
-        kwoptarg_name = @sexp[1].to_sym
-        default_value = @sexp[2]
-        var_name = variable(kwoptarg_name)
-        add_temp var_name
+        add_temp lvar_name
 
-        line "if ((#{var_name} = $kwargs.$$smap['#{kwoptarg_name}']) == null) {"
-        line "  #{var_name} = ", expr(default_value)
-        line "}"
+        line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
+
+        scope.used_kwargs << key_name
 
-        scope.used_kwargs << kwoptarg_name
+        return if default_value.children[1] == :undefined
+
+        line "if (#{lvar_name} == null) {"
+        line "  #{lvar_name} = ", expr(default_value)
+        line "}"
       end
     end
   end