opal 0.10.6 → 0.11.0.rc1

data/lib/opal/rewriters/js_reserved_words.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+require 'opal/regexp_anchors'
+
+module Opal
+  module Rewriters
+    class JsReservedWords < Base
+      # Reserved javascript keywords - we cannot create variables with the
+      # same name (ref: http://stackoverflow.com/a/9337272/601782)
+      ES51_RESERVED_WORD = /#{REGEXP_START}(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)#{REGEXP_END}/
+
+      # ES3 reserved words that aren’t ES5.1 reserved words
+      ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/
+
+      # Prototype special properties.
+      PROTO_SPECIAL_PROPS = /#{REGEXP_START}(?:constructor|displayName|__proto__|__parent__|__noSuchMethod__|__count__)#{REGEXP_END}/
+
+      # Prototype special methods.
+      PROTO_SPECIAL_METHODS = /#{REGEXP_START}(?:hasOwnProperty|valueOf)#{REGEXP_END}/
+
+      # Immutable properties of the global object
+      IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/
+
+      # Doesn't take in account utf8
+      BASIC_IDENTIFIER_RULES = /#{REGEXP_START}[$_a-z][$_a-z\d]*#{REGEXP_END}/i
+
+      # Defining a local function like Array may break everything
+      RESERVED_FUNCTION_NAMES = /#{REGEXP_START}(?:Array)#{REGEXP_END}/
+
+      def self.valid_name?(name)
+        BASIC_IDENTIFIER_RULES =~ name and not(
+          ES51_RESERVED_WORD          =~ name or
+          ES3_RESERVED_WORD_EXCLUSIVE =~ name or
+          IMMUTABLE_PROPS             =~ name
+        )
+      end
+
+      def self.valid_ivar_name?(name)
+        not (PROTO_SPECIAL_PROPS =~ name or PROTO_SPECIAL_METHODS =~ name)
+      end
+
+      def fix_var_name(name)
+        self.class.valid_name?(name) ? name : "#{name}$".to_sym
+      end
+
+      def fix_ivar_name(name)
+        self.class.valid_ivar_name?(name.to_s[1..-1]) ? name : "#{name}$".to_sym
+      end
+
+      def on_lvar(node)
+        name, _ = *node
+        node = node.updated(nil, [fix_var_name(name)])
+        super(node)
+      end
+
+      def on_lvasgn(node)
+        name, value = *node
+
+        if value
+          node = node.updated(nil, [fix_var_name(name), value])
+        else
+          node = node.updated(nil, [fix_var_name(name)])
+        end
+
+        super(node)
+      end
+
+      def on_ivar(node)
+        name, _ = *node
+        node = node.updated(nil, [fix_ivar_name(name)])
+        super(node)
+      end
+
+      def on_ivasgn(node)
+        name, value = *node
+
+        if value
+          node = node.updated(nil, [fix_ivar_name(name), value])
+        else
+          node = node.updated(nil, [fix_ivar_name(name)])
+        end
+        super(node)
+      end
+
+      # Restarg is a special case
+      # because it may have no name
+      # def m(*); end
+      def on_restarg(node)
+        name, _ = *node
+
+        if name
+          node = node.updated(nil, [fix_var_name(name)])
+        end
+
+        node
+      end
+
+      def on_argument(node)
+        name, value = *node
+
+        if value
+          node = node.updated(nil, [fix_var_name(name), value])
+        else
+          node = node.updated(nil, [fix_var_name(name)])
+        end
+
+        super(node)
+      end
+    end
+  end
+end

data/lib/opal/rewriters/logical_operator_assignment.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class LogicalOperatorAssignment < Base
+      def self.reset_tmp_counter!
+        @@counter = 0
+      end
+
+      def self.new_temp
+        @@counter ||= 0
+        @@counter += 1
+        :"$logical_op_recvr_tmp_#{@@counter}"
+      end
+
+      GET_SET = ->(get_type, set_type) {
+
+        ->(lhs, rhs, root_type) {
+          get_node = lhs.updated(get_type) # lhs
+          condition_node = s(root_type, get_node, rhs) # lhs || rhs
+
+          lhs.updated(set_type, [*lhs, condition_node]) # lhs = lhs || rhs
+        }
+
+      }
+
+      # Takes    `lhs ||= rhs`
+      # Produces `lhs = lhs || rhs`
+      LocalVariableHandler = GET_SET[:lvar, :lvasgn]
+
+      # Takes    `@lhs ||= rhs`
+      # Produces `@lhs = @lhs || rhs`
+      InstanceVariableHandler = GET_SET[:ivar, :ivasgn]
+
+      # Takes    `LHS ||= rhs`
+      # Produces `LHS = LHS || rhs`
+      ConstantHandler = GET_SET[:const, :casgn]
+
+      # Takes    `$lhs ||= rhs`
+      # Produces `$lhs = $lhs || rhs`
+      GlobalVariableHandler = GET_SET[:gvar, :gvasgn]
+
+      # Takes    `@@lhs ||= rhs`
+      # Produces `@@lhs = @@lhs || rhs`
+      ClassVariableHandler = GET_SET[:cvar, :cvasgn]
+
+      # Takes    `recvr.meth ||= rhs`
+      # Produces `recvr.meth || recvr.meth = rhs`
+      # (lhs is a recvr.meth)
+      class SendHandler < self
+        def self.call(lhs, rhs, root_type)
+          recvr, reader_method, *args = *lhs
+
+          # If recvr is a complex expression it must be cached.
+          # MRI calls recvr in `recvr.meth ||= rhs` only once.
+          if recvr && recvr.type == :send
+            recvr_tmp = new_temp
+            cache_recvr = s(:lvasgn, recvr_tmp, recvr)                         # $tmp = recvr
+            recvr = s(:js_tmp, recvr_tmp)
+          end
+
+          writer_method = :"#{reader_method}="
+
+          call_reader = lhs.updated(:send, [recvr, reader_method, *args])      # $tmp.meth
+          call_writer = lhs.updated(:send, [recvr, writer_method, *args, rhs]) # $tmp.meth = rhs
+          get_or_set = s(root_type, call_reader, call_writer)
+
+          if cache_recvr
+            s(:begin, cache_recvr, get_or_set)
+          else
+            get_or_set
+          end
+        end
+      end
+
+      # Takes    `recvr&.meth ||= rhs`
+      # Produces `recvr.nil? ? nil : recvr.meth ||= rhs`
+      #   NOTE: Later output of this handler gets post-processed by this rewriter again
+      #   using SendHandler to `recvr.nil? ? nil : (recvr.meth || recvr.meth = rhs)`
+      class ConditionalSendHandler < self
+        def self.call(lhs, rhs, root_type)
+          root_type = :"#{root_type}_asgn"
+
+          recvr, meth, *args = *lhs
+
+          recvr_tmp = new_temp
+          cache_recvr = s(:lvasgn, recvr_tmp, recvr)          # $tmp = recvr
+          recvr = s(:js_tmp, recvr_tmp)
+
+          recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
+          nil_node = s(:nil)                                    # nil
+          plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
+          plain_or_asgn = s(root_type, plain_send, rhs)         # recvr.meth ||= rhs
+
+          s(:begin,
+            cache_recvr,
+            s(:if, recvr_is_nil,                          # if recvr.nil?
+              s(:nil),                                    #   nil
+                                                          # else
+              plain_or_asgn))                             #   recvr.meth ||= rhs
+                                                          # end
+        end
+      end
+
+      HANDLERS = {
+        lvasgn: LocalVariableHandler,
+        ivasgn: InstanceVariableHandler,
+        casgn:  ConstantHandler,
+        gvasgn: GlobalVariableHandler,
+        cvasgn: ClassVariableHandler,
+        send:   SendHandler,
+        csend:  ConditionalSendHandler
+      }
+
+      # lhs ||= rhs
+      def on_or_asgn(node)
+        lhs, rhs = *node
+
+        result = HANDLERS
+          .fetch(lhs.type) { raise NotImplementedError }
+          .call(lhs, rhs, :or)
+
+        process(result)
+      end
+
+      # lhs &&= rhs
+      def on_and_asgn(node)
+        lhs, rhs = *node
+
+        result = HANDLERS
+          .fetch(lhs.type) { raise NotImplementedError }
+          .call(lhs, rhs, :and)
+
+        process(result)
+      end
+
+      ASSIGNMENT_STRING_NODE = s(:str, 'assignment')
+
+      # Rewrites any or_asgn and and_asgn node like
+      #   `defined?(a ||= 1)`
+      # and
+      #   `defined?(a &&= 1)`
+      # to a static "assignment" string node
+      def on_defined?(node)
+        inner, _ = *node
+        if [:or_asgn, :and_asgn].include?(inner.type)
+          ASSIGNMENT_STRING_NODE
+        else
+          super(node)
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/opal_engine_check.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class OpalEngineCheck < Base
+      def on_if(node)
+        test, true_body, false_body = *node.children
+
+        if skip_check_present?(test)
+          false_body = s(:nil)
+        end
+
+        if skip_check_present_not?(test)
+          true_body = s(:nil)
+        end
+
+        node.updated(nil, process_all([test, true_body, false_body]))
+      end
+
+      def skip_check_present?(test)
+        test == RUBY_ENGINE_CHECK or test == RUBY_PLATFORM_CHECK
+      end
+
+      def skip_check_present_not?(test)
+        test == RUBY_ENGINE_CHECK_NOT or test == RUBY_PLATFORM_CHECK_NOT
+      end
+
+      RUBY_ENGINE_CHECK = s(:send, s(:const, nil, :RUBY_ENGINE),
+                              :==, s(:str, "opal"))
+
+      RUBY_ENGINE_CHECK_NOT = s(:send, s(:const, nil, :RUBY_ENGINE),
+                              :!=, s(:str, "opal"))
+
+      RUBY_PLATFORM_CHECK = s(:send, s(:const, nil, :RUBY_PLATFORM),
+                              :==, s(:str, "opal"))
+
+      RUBY_PLATFORM_CHECK_NOT = s(:send, s(:const, nil, :RUBY_PLATFORM),
+                              :!=, s(:str, "opal"))
+    end
+  end
+end

data/lib/opal/rewriters/rubyspec/filters_rewriter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rubyspec
+    class FiltersRewriter < Opal::Rewriters::Base
+      class << self
+        def filters
+          @filters ||= []
+        end
+
+        def filter(spec_name)
+          filters << spec_name
+        end
+
+        alias fails filter
+        alias fails_badly filter
+
+        def filtered?(spec_name)
+          filters.include?(spec_name)
+        end
+
+        def clear_filters!
+          @filters = []
+        end
+      end
+
+      def initialize
+        @specs_stack = []
+      end
+
+      RUBYSPEC_DSL = [:describe, :it, :context]
+
+      def on_send(node)
+        _recvr, method_name, *args = *node
+
+        if rubyspec_dsl?(method_name)
+          spec_name, _ = *args.first
+          begin
+            @specs_stack.push(spec_name)
+            if skip?
+              s(:nil)
+            else
+              super
+            end
+          ensure
+            @specs_stack.pop
+          end
+        else
+          super
+        end
+      end
+
+      def skip?
+        self.class.filtered?(current_spec_name)
+      end
+
+      def rubyspec_dsl?(method_name)
+        RUBYSPEC_DSL.include?(method_name)
+      end
+
+      def current_spec_name
+        @specs_stack.join(" ")
+      end
+    end
+  end
+end

data/lib/opal/server.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+Opal.deprecation "`require 'opal/server` and `Opal::Server` are deprecated in favor of `require 'opal/sprockets/server'` and `Opal::Sprockets::Server` (now part of the opal-sprockets gem)."
+require 'opal/sprockets/server'
+Opal::Server = Opal::Sprockets::Server

data/lib/opal/simple_server.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require 'opal/deprecations'
+
+# Opal::SimpleServer is a very basic Rack server for Opal assets, it relies on
+# Opal::Builder and Ruby corelib/stdlib. It's meant to be used just for local
+# development.
+#
+# For a more complete implementation see opal-sprockets (Rubygems) or
+# opal-webpack (NPM).
+#
+# @example (CLI)
+#   rackup -ropal -ropal/simple_server -b 'Opal.append_path("app"); run Opal::SimpleServer.new'
+class Opal::SimpleServer
+  require 'set'
+  require 'erb'
+
+  def initialize(options = {})
+    @prefix = options.fetch(:prefix, 'assets')
+    @main = options.fetch(:main, 'application')
+    yield self if block_given?
+    freeze
+  end
+
+  attr_accessor :main, :index_path
+
+  # @deprecated
+  # It's here for compatibility with Opal::Sprockets::Server
+  def append_path(path)
+    Opal.deprecation 'Please use `Opal.append_path(path)` instead.'
+    Opal.append_path path
+  end
+
+  def call(env)
+    case env['PATH_INFO']
+    when %r{\A/#{@prefix}/(.*)\.map\z}
+      path, cache_invalidator = $1.split('?', 2)
+      call_map(path)
+    when %r{\A/#{@prefix}/(.*)\z}
+      path, cache_invalidator = $1.split('?', 2)
+      call_asset(path)
+    else call_index
+    end
+  end
+
+  def call_asset(path)
+    asset = fetch_asset(path)
+    [
+      200,
+      { 'Content-Type' => 'application/javascript',
+        'X-SourceMap' => "/#{@prefix}/#{path}.map#{cache_invalidator}}" },
+      [asset[:data]]
+    ]
+  end
+
+  def call_map(path)
+    asset = fetch_asset(path)
+    [
+      200,
+      { 'Content-Type' => 'application/json' },
+      [asset[:map]]
+    ]
+  end
+
+  def fetch_asset(path)
+    builder = Opal::Builder.new
+    builder.build(path.gsub(/(\.(?:rb|js|opal))*\z/, ''))
+    {
+      data: builder.to_s,
+      map: builder.source_map.to_json
+    }
+  end
+
+  def javascript_include_tag(path)
+    %{<script src="/#{@prefix}/#{path}.js#{cache_invalidator}"></script>}
+  end
+
+  def cache_invalidator
+    "?#{Time.now.to_i}"
+  end
+
+  def call_index
+    if @index_path
+      contents = File.read(@index_path)
+      html = ERB.new(contents).result binding
+    else
+      html = <<-HTML
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf8">
+          #{javascript_include_tag(main)}
+        </head>
+        <body></body>
+      </html>
+      HTML
+    end
+    [200, {'Content-Type' => 'text/html'}, [html]]
+  end
+end
+