opal 0.11.4 → 1.0.0.beta1

data/bin/opal-build

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-exec "#{__dir__}/../exe/#{File.basename($0)}", *ARGV

data/exe/opal-mspec

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-specs = ARGV.map do |s|
-  s.end_with?('.rb') ? s : "#{s}/**/*_spec.rb"
-end
-pattern = %Q{MSPEC_PATTERN="{#{specs.join(',')}}"} if specs.any?
-command = [pattern, 'rake mspec'].compact.join(' ')
-exec command
-
-# RUBYOPT="-rbundler/setup -rmspec/opal/special_calls" bundle exec mspec run -t opal -pspec/ruby/spec_helper spec/ruby/core/true/*

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/base'
-
-module Opal
-  module Nodes
-    # An abstract node responsible for validating
-    # keyword arguments in the post-splat list of arguments.
-    #
-    # @see PostArgsNode
-    #
-    class InitializeKwargsNode < Base
-      def initialize_kw_args_if_needed
-        return if scope.kwargs_initialized
-
-        helper :hash2
-
-        line "if ($kwargs == null || !$kwargs.$$is_hash) {"
-        line "  if ($kwargs == null) {"
-        line "    $kwargs = $hash2([], {});"
-        line "  } else {"
-        line "    throw Opal.ArgumentError.$new('expected kwargs');"
-        line "  }"
-        line "}"
-
-        scope.kwargs_initialized = true
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/args/initialize_kwargs'
-
-module Opal
-  module Nodes
-    # A node responsible for extracting a
-    # single *required* keyword argument
-    #
-    # def m(kw: )
-    #
-    class KwargNode < InitializeKwargsNode
-      handle :kwarg
-      children :lvar_name
-
-      def compile
-        key_name = @sexp.meta[:arg_name]
-
-        initialize_kw_args_if_needed
-
-        add_temp lvar_name
-
-        line "if (!Opal.hasOwnProperty.call($kwargs.$$smap, '#{key_name}')) {"
-        line "  throw Opal.ArgumentError.$new('missing keyword: #{key_name}');"
-        line "}"
-        line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
-
-        scope.used_kwargs << key_name
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/args/initialize_kwargs'
-
-module Opal
-  module Nodes
-    # A node responsible for extracting a
-    # single *optional* keyword argument
-    #
-    # def m(kw: 1)
-    #
-    class KwoptArgNode < InitializeKwargsNode
-      handle :kwoptarg
-      children :lvar_name, :default_value
-
-      def compile
-        key_name = @sexp.meta[:arg_name]
-
-        initialize_kw_args_if_needed
-
-        add_temp lvar_name
-
-        line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
-
-        scope.used_kwargs << key_name
-
-        return if default_value.children[1] == :undefined
-
-        line "if (#{lvar_name} == null) {"
-        line "  #{lvar_name} = ", expr(default_value)
-        line "}"
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/args/initialize_kwargs'
-
-module Opal
-  module Nodes
-    # A node responsible for extracting a
-    # keyword splat argument
-    #
-    # def m(**kwrest)
-    # def m(**)
-    #
-    class KwrestArgNode < InitializeKwargsNode
-      handle :kwrestarg
-      children :name
-
-      def compile
-        initialize_kw_args_if_needed
-
-        extract_code = "Opal.kwrestargs($kwargs, #{used_kwargs});"
-
-        # kwrestarg can be blank def m(**) end
-        # we need to perform assignment only for named kwrestarg
-        if name
-          add_temp name
-
-          line "#{name} = #{extract_code}"
-        end
-      end
-
-      def used_kwargs
-        args = scope.used_kwargs.map do |arg_name|
-          "'#{arg_name}': true"
-        end
-
-        "{#{args.join ','}}"
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/base'
-
-module Opal
-  module Nodes
-    # A node responsible for extracting a
-    # single MLHS argument
-    #
-    # MLHS argument is the left hand side
-    # of a multiple assignment (Multiple Left Hand Side)
-    #
-    # def m((a, b))
-    # def m((a, *b))
-    #
-    # MLHS can include simple arguments (see NormargNode)
-    # and rest arguments (see RestargNode)
-    #
-    class MlhsArgNode < Base
-      handle :mlhs
-
-      def compile
-        args_sexp = s(:post_args, *children)
-
-        if @sexp.meta[:post]
-          # In this case source is an item in the current scope.working_arguments
-          # First we should extract mlhs as a simple argument
-          mlhs_sexp = s(:arg, mlhs_name)
-          mlhs_sexp.meta[:post] = true
-          scope.with_inline_args([]) do
-            push process(mlhs_sexp)
-          end
-          var_name = args_sexp.meta[:js_source] = mlhs_name
-        else
-          # Otherwise we already have it in our scope.working_arguments
-          # (of course, in this case scope.working_arguments = 'arguments')
-          var_name = args_sexp.meta[:js_source] = scope.mlhs_mapping[@sexp]
-        end
-
-        line "if (#{var_name} == null) {"
-        line "  #{var_name} = nil;"
-        line "}"
-
-        line "#{var_name} = Opal.to_ary(#{var_name});"
-
-        scope.with_inline_args([]) do
-          scope.in_mlhs do
-            push process(args_sexp)
-          end
-        end
-      end
-
-      def mlhs_name
-        @mlhs_name ||= begin
-          if @sexp.meta[:post]
-            result = ["$mlhs_of"]
-
-            children.each do |child|
-              case child.type
-              when :arg
-                result << child.children[0]
-              when :mlhs
-                result << 'mlhs'
-              end
-            end
-
-            result.join("_")
-          else
-            @sexp.children[0].to_s
-          end
-        end
-      end
-
-      def inline_args
-        @inline_args ||= children.take_while { |arg| arg.type != :restarg && arg.type != :optarg }
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/base'
-
-module Opal
-  module Nodes
-    # A ndoe responsible for extracting
-    # a single argument
-    #
-    # def m(a)
-    #
-    class NormargNode < Base
-      handle :arg
-      children :name
-
-      def compile
-        if @sexp.meta[:post]
-          add_temp name
-          line "#{name} = #{scope.working_arguments}.splice(0,1)[0];"
-        end
-
-        if scope.in_mlhs?
-          line "if (#{name} == null) {"
-          line "  #{name} = nil;"
-          line "}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/base'
-
-module Opal
-  module Nodes
-    # A node responsible for extracting a single
-    # optional argument
-    #
-    # def m(a=1)
-    #
-    class OptargNode < Base
-      handle :optarg
-      children :name, :default_value
-
-      def compile
-        return if default_value.children[1] == :undefined
-
-        line "if (#{name} == null) {"
-        line "  #{name} = ", expr(default_value)
-        push ";"
-        line "}"
-      end
-    end
-  end
-end

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

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-require 'opal/nodes/base'
-
-module Opal
-  module Nodes
-    # Node responsible for extracting post-splat args
-    # 1. There can be some arguments after the splat, this is why this node exist.
-    #    In this case if:
-    #     a. JS arguments length > args sexp length - then our splat has some items
-    #        and we know how many of them should come to splat
-    #     b. JS arguments length < args sexp length - then our splat is blank
-    #
-    # 2. Super important:
-    #    a) optional arg always goes BEFORE the rest arg
-    #    b) optional args always appear in the sequence (i.e. you can't have def m(a=1,b,c=1))
-    #    c) precedence order:
-    #         1. required arg (norm arg, mlhs arg)
-    #         2. optional argument (optarg)
-    #         3. splat/rest argument (restarg)
-    #    These statements simplify everything, keep them in mind.
-    # 3. post_args here _always_ have the same structure:
-    #    1. list of required arguments (only for mlhs, can be blank)
-    #    2. list of optargs (only for post-args, can be blank)
-    #    3. restarg (for both mlhs/post-args, can be nil)
-    #    4. list of required args (for both mlhs/post-args, can be blank)
-    #
-    class PostArgsNode < Base
-      handle :post_args
-
-      # kwargs contains the list of all post-kw* arguments
-      # all of them can be processed in the first oder
-      attr_reader :kwargs
-
-      # required_left_args contains the list of required post args
-      # like normarg or mlhs
-      # For post-args: always blank (post args always start with optarg/restarg)
-      # For mlhs: can be provided from
-      #   mlhs = (a, b, c)
-      #   required_left_args = [(:arg, :a), (:arg, :b)]
-      attr_reader :required_left_args
-
-      # optargs contains the list of optarg arguments
-      # all of them must be populated depending on the "arguments.length"
-      # if we have enough arguments - we fill them,
-      # if not - we populate it with its default value
-      # For post-args: can be provided from
-      #   def m(a=1, *b)
-      #   post-args = [(:optarg, :a, (:int, 1)), (:restarg, :b)]
-      #   optargs = [(:optarg, :a, (:int, 1))]
-      # For mlhs: always blank
-      attr_reader :optargs
-
-      # returns a restarg sexp
-      # if we have enough "arguments" - we fill it
-      # if not - we populate it with "[]"
-      # For post-args: can be provided from
-      #   def m(a=1, *b)
-      #   post-args = [(:optarg, :a, (:int, 1)), (:restarg, :b)]
-      #   restarg (:restarg, :b)
-      attr_reader :restarg
-
-      # required_right_args contains the list of required post args
-      # like normarg and mlhs arg
-      # For post-args: can be provided from
-      #   def m(a=1,*b,c)
-      #   post-args = [(:optarg, :a, (:int, 1)), (:restarg, :b), (:arg, :c)]
-      #   required_right_args = [(:arg, :c)]
-      # For mlhs: can be provided from
-      #   (*a, b)
-      #   required_right_args = [(:arg, :b)]
-      attr_reader :required_right_args
-
-      def initialize(*)
-        super
-
-        @kwargs = []
-        @required_left_args = []
-        @optargs = []
-        @restarg = nil
-        @required_right_args = []
-      end
-
-      def extract_arguments
-        found_opt_or_rest = false
-
-        children.each do |arg|
-          arg.meta[:post] = true
-
-          case arg.type
-          when :kwarg, :kwoptarg, :kwrestarg
-            @kwargs << arg
-          when :restarg
-            @restarg = arg
-            found_opt_or_rest = true
-          when :optarg
-            @optargs << arg
-            found_opt_or_rest = true
-          when :arg, :mlhs
-            if found_opt_or_rest
-              @required_right_args << arg
-            else
-              @required_left_args << arg
-            end
-          end
-        end
-      end
-
-      def compile
-        return if children.empty?
-
-        old_working_arguments = scope.working_arguments
-
-        if @sexp.meta[:js_source]
-          js_source = @sexp.meta[:js_source]
-          scope.working_arguments = "#{js_source}_args"
-        else
-          js_source = "arguments"
-          scope.working_arguments = "$post_args"
-        end
-
-        add_temp "#{scope.working_arguments}"
-        line "#{scope.working_arguments} = Opal.slice.call(#{js_source}, #{scope.inline_args.size}, #{js_source}.length);"
-
-        extract_arguments
-
-        push process(kwargs_sexp)
-
-        required_left_args.each do |arg|
-          compile_required_arg(arg)
-        end
-
-        optargs.each do |optarg|
-          compile_optarg(optarg)
-        end
-
-        compile_restarg
-
-        required_right_args.each do |arg|
-          compile_required_arg(arg)
-        end
-
-        scope.working_arguments = old_working_arguments
-      end
-
-      def compile_optarg(optarg)
-        var_name, _ = *optarg
-        add_temp var_name
-
-        line "if (#{required_right_args.size} < #{scope.working_arguments}.length) {"
-        indent do
-          line "#{var_name} = #{scope.working_arguments}.splice(0,1)[0];"
-        end
-        line "}"
-        push process(optarg)
-      end
-
-      def compile_required_arg(arg)
-        push process(arg)
-      end
-
-      def compile_restarg
-        return unless restarg
-
-        line "if (#{required_right_args.size} < #{scope.working_arguments}.length) {"
-          indent do
-            # there are some items coming to the splat, extracting them
-            extract_restarg
-          end
-        line "} else {"
-          indent do
-            # splat is empty
-            extract_blank_restarg
-          end
-        line "}"
-      end
-
-      def extract_restarg
-        extract_code = "#{scope.working_arguments}.splice(0, #{scope.working_arguments}.length - #{required_right_args.size});"
-        var_name, _ = *restarg
-        if var_name
-          add_temp var_name
-          line "#{var_name} = #{extract_code}"
-        else
-          line extract_code
-        end
-      end
-
-      def extract_blank_restarg
-        var_name, _ = *restarg
-        if var_name
-          add_temp var_name
-          line "#{var_name} = [];"
-        end
-      end
-
-      def kwargs_sexp
-        s(:post_kwargs, *kwargs)
-      end
-    end
-  end
-end