opal 1.2.0.beta1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a574a86358acd4f97b91deecaa9395068503a2198c6a8b646ee5b9df35a8d5c
-  data.tar.gz: 800255837fc95ecbfa4268c4a4b21df99ad1fb427fe4b90a5100bbed75833791
+  metadata.gz: f13610ebfa130a3b3379a2d23f3fc077de87e4fd69c33248a87bdf23e144686a
+  data.tar.gz: 275fa37ed3f201f2c716bcf8f05cc5fcd5ff42dec5aaae1b4753c126a629d5c1
 SHA512:
-  metadata.gz: 471561bdda1f595110d95be228b6caad444b0064e84b13d37c250c70b1e505e897c6f9f69c93afa11b13a268b98acef4d62508ba19ac1304d3c5d8178563b10f
-  data.tar.gz: 4620c4fc0ee08df1840300b1b03fe3cedabee19dc22c986b7151538b211da69046c4b164c8bd4145c16e4d54307376314a4514b9b95fb540fc0e37fdb8671511
+  metadata.gz: b5a9d1f1494542fd5d1669bb16548b5a335777398a3d84945dbabb8477cedd79f1fd1fc251f663e9f22a518a9a7c3d361f83fb14c860bc3cb36b79c7cd6c40b8
+  data.tar.gz: 90f237673bc19937ee643fbe5562cd348476f975a90348c95138785457a6da342b4df98a48d14b223a938e9c91ac603fde0d2c5cbe18982ec1bcc3c1e6d4c375

data/.rubocop.yml

@@ -107,8 +107,9 @@ Layout/SpaceAroundOperators:
 
 Lint/BooleanSymbol:
   Exclude:
-    # There are AST nodes with types :true and :false
+    # There are AST nodes and rewriters with types :true and :false
     - 'lib/opal/nodes/**/*.rb'
+    - 'lib/opal/rewriters/**/*.rb'
 
 Lint/InheritException:
   Exclude:

data/CHANGELOG.md

@@ -15,6 +15,59 @@ Changes are grouped as follows:
 
 
 
+## [1.2.0](https://github.com/opal/opal/compare/v1.1.1...1.2.0) - 2021-07-28
+
+
+### Added
+
+- Support for multiple arguments in Hash#{merge, merge!, update} ([#2187](https://github.com/opal/opal/pull/2187))
+- Support for Ruby 3.0 forward arguments: `def a(...) puts(...) end` ([#2153](https://github.com/opal/opal/pull/2153))
+- Support for beginless and endless ranges: `(1..)`, `(..1)` ([#2150](https://github.com/opal/opal/pull/2150))
+- Preliminary support for `**nil` argument - see #2240 to note limitations ([#2152](https://github.com/opal/opal/pull/2152))
+- Support for `Random::Formatters` which add methods `#{hex,base64,urlsafe_base64,uuid,random_float,random_number,alphanumeric}` to `Random` and `SecureRandom` ([#2218](https://github.com/opal/opal/pull/2218))
+- Basic support for ObjectSpace finalizers and ObjectSpace::WeakMap ([#2247](https://github.com/opal/opal/pull/2247))
+- A more robust support for encodings (especially binary strings) ([#2235](https://github.com/opal/opal/pull/2235))
+- Support for `"\x80"` syntax in String literals ([#2235](https://github.com/opal/opal/pull/2235))
+- Added `String#+@`, `String#-@` ([#2235](https://github.com/opal/opal/pull/2235))
+- Support for `begin <CODE> end while <CONDITION>` ([#2255](https://github.com/opal/opal/pull/2255))
+
+### Fixed
+
+- Encoding lookup was working only with uppercase names, not giving any errors for wrong ones (#2181, #2183, #2190)
+- Fix `Number#to_i` with huge number ([#2191](https://github.com/opal/opal/pull/2191))
+- Add regexp support to `String#start_with` ([#2198](https://github.com/opal/opal/pull/2198))
+- `String#bytes` now works in strict mode ([#2194](https://github.com/opal/opal/pull/2194))
+- Fix nested module inclusion ([#2053](https://github.com/opal/opal/pull/2053))
+- SecureRandom is now cryptographically secure on most platforms (#2218, #2170)
+- Fix performance regression for `Array#unshift` on v8 > 7.1 ([#2116](https://github.com/opal/opal/pull/2116))
+- String subclasses now call `#initialize` with multiple arguments correctly (with a limitation caused by the String immutability issue, that a source string must be the first argument and `#initialize` can't change its value) (#2238, #2185)
+- Number#step is moved to Numeric ([#2100](https://github.com/opal/opal/pull/2100))
+- Fix class Class < superclass for invalid superclasses ([#2123](https://github.com/opal/opal/pull/2123))
+- Fix `String#unpack("U*")` on binary strings with latin1 high characters, fix performance regression on that call (#2235, #2189, #2129, #2099, #2094, #2000, #2128)
+- Fix `String#to_json` output on some edge cases ([#2235](https://github.com/opal/opal/pull/2235))
+- Rework class variables to support inheritance correctly ([#2251](https://github.com/opal/opal/pull/2251))
+- ISO-8859-1 and US-ASCII encodings are now separated as in MRI ([#2235](https://github.com/opal/opal/pull/2235))
+- `String#b` no longer modifies object strings in-place ([#2235](https://github.com/opal/opal/pull/2235))
+
+### Changed
+
+- `String#unpack`, `Array#pack`, `String#chars`, `String#length`, `Number#chr`, and (only partially) `String#+` are now encoding aware ([#2235](https://github.com/opal/opal/pull/2235))
+- `String#inspect` now uses `\x` for binary stirngs ([#2235](https://github.com/opal/opal/pull/2235))
+- `if RUBY_ENGINE == "opal"` and friends are now outputing less JS code (#2159, #1965)
+- `Array`: `to_a`, `slice`/`[]`, `uniq`, `*`, `difference`/`-`, `intersection`/`&`, `union`/`|`, flatten now return Array, not a subclass, as Ruby 3.0 does ([#2237](https://github.com/opal/opal/pull/2237))
+- `Array`: `difference`, `intersection`, `union` now accept multiple arguments ([#2237](https://github.com/opal/opal/pull/2237))
+
+### Deprecated
+
+- Stopped testing Opal on Ruby 2.5 since it reached EOL.
+
+### Removed
+
+- Removed support for the outdated `c_lexer`, it was optional and didn't work for the last few releases of parser ([#2235](https://github.com/opal/opal/pull/2235))
+
+
+
+
 ## [1.1.1](https://github.com/opal/opal/compare/v1.1.0...v1.1.1) - 2021-02-23
 
 

data/UNRELEASED.md

@@ -1,4 +1,3 @@
-### Added
 
 - Support for multiple arguments in Hash#{merge, merge!, update} (#2187)
 - Support for Ruby 3.0 forward arguments: `def a(...) puts(...) end` (#2153)
@@ -10,6 +9,10 @@
 - Support for `"\x80"` syntax in String literals (#2235)
 - Added `String#+@`, `String#-@` (#2235)
 - Support for `begin <CODE> end while <CONDITION>` (#2255)
+- Added Hash#except and `Hash#except!` (#2243)
+- Parser 3.0: Implement pattern matching (as part of this `{Array,Hash,Struct}#{deconstruct,deconstruct_keys} methods were added)` (#2243)
+- [experimental] Reimplement Promise to make it bridged with JS native Promise, this new implementation can be used by requiring `promise/v2` (#2220)
+
 
 ### Fixed
 
@@ -28,6 +31,7 @@
 - Rework class variables to support inheritance correctly (#2251)
 - ISO-8859-1 and US-ASCII encodings are now separated as in MRI (#2235)
 - `String#b` no longer modifies object strings in-place (#2235)
+- Parser::Builder::Default.check_lvar_name patch (#2195)
 
 ### Changed
 

data/lib/opal/parser/patch.rb

@@ -38,6 +38,16 @@ if RUBY_ENGINE == 'opal'
       end
     end
   end
+
+  class Parser::Builders::Default
+    def check_lvar_name(name, loc)
+      if name =~ `/^[\p{Ll}|_][\p{L}\p{Nl}\p{Nd}_]*$/u`
+        # OK
+      else
+        diagnostic :error, :lvar_name, { name: name }, loc
+      end
+    end
+  end
 end
 
 module AST::Processor::Mixin

data/lib/opal/rewriter.rb

@@ -6,6 +6,7 @@ require 'opal/rewriters/explicit_writer_return'
 require 'opal/rewriters/js_reserved_words'
 require 'opal/rewriters/block_to_iter'
 require 'opal/rewriters/dot_js_syntax'
+require 'opal/rewriters/pattern_matching'
 require 'opal/rewriters/logical_operator_assignment'
 require 'opal/rewriters/binary_operator_assignment'
 require 'opal/rewriters/hashes/key_duplicates_rewriter'
@@ -49,6 +50,7 @@ module Opal
     use Rewriters::ForwardArgs
     use Rewriters::BlockToIter
     use Rewriters::DotJsSyntax
+    use Rewriters::PatternMatching
     use Rewriters::JsReservedWords
     use Rewriters::LogicalOperatorAssignment
     use Rewriters::BinaryOperatorAssignment

data/lib/opal/rewriters/pattern_matching.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class PatternMatching < Base
+      def initialize
+        @depth = 0
+        super
+      end
+
+      # a => b
+      def on_match_pattern(node)
+        from, pat = *node
+
+        s(:begin,
+          s(:lvasgn, :"$pmvar", from),
+          s(:if,
+            convert_full_pattern(from, pat),
+            nil,
+            raise_no_matching_pattern_error(:"$pmvar")
+          )
+        )
+      end
+
+      # a in b
+      def on_match_pattern_p(node)
+        from, pat = *node
+
+        s(:if,
+          convert_full_pattern(from, pat),
+          s(:true),
+          s(:false)
+        )
+      end
+
+      # case a; in b; end
+      def on_case_match(node)
+        @depth += 1
+
+        cmvar = :"$cmvar#{@depth}"
+
+        from, *cases, els = *node
+
+        if els
+          process els
+        else
+          els = raise_no_matching_pattern_error(cmvar)
+        end
+
+        s(:begin,
+          s(:lvasgn, cmvar, from),
+          single_case_match(cmvar, *cases, els)
+        )
+      end
+
+      private
+
+      # raise NoMatchingPatternError, from
+      def raise_no_matching_pattern_error(from)
+        s(:send, nil, :raise,
+          s(:const, nil, :NoMatchingPatternError),
+          s(:lvar, from)
+        )
+      end
+
+      # in b
+      def single_case_match(from, *cases, els)
+        cas = cases.shift
+        pat, if_guard, body = *cas
+
+        pat = convert_full_pattern(from, pat)
+        if if_guard
+          guard, = *if_guard
+          case if_guard.type
+          when :if_guard
+            pat = s(:and, pat, guard)
+          when :unless_guard
+            pat = s(:and, pat, s(:send, guard, :!))
+          end
+        end
+
+        s(:if,
+          pat,
+          process(body),
+          if !cases.empty?
+            single_case_match(from, *cases, els)
+          elsif els != s(:empty_else)
+            els
+          end
+        )
+      end
+
+      def convert_full_pattern(from, pat)
+        if from.class == Symbol
+          from = s(:lvar, from)
+        end
+
+        converter = PatternConverter.new(pat)
+        converter.run!
+
+        # a, b, c = ::PatternMatching.(from, [...])
+        s(:masgn,
+          s(:mlhs,
+            *converter.variables
+          ),
+          s(:send,
+            s(:const, s(:cbase), :PatternMatching),
+            :call,
+            from,
+            converter.pattern,
+          )
+        )
+      end
+
+      class PatternConverter < ::Opal::Rewriters::Base
+        def initialize(pat)
+          @pat = pat
+          @variables = []
+        end
+
+        def run!
+          @outpat = process(@pat)
+        end
+
+        def pattern
+          @outpat
+        end
+
+        def variables
+          @variables.map { |i| s(:lvasgn, i) }
+        end
+
+        # a
+        def on_match_var(node)
+          var, = *node
+
+          @variables << var
+
+          s(:sym, :var)
+        end
+
+        # [...] => a
+        def on_match_as(node)
+          pat, save = *node
+
+          process(save)
+          array(s(:sym, :save), process(pat))
+        end
+
+        def on_literal(node)
+          array(s(:sym, :lit), node)
+        end
+
+        alias on_int on_literal
+        alias on_float on_literal
+        alias on_complex on_literal
+        alias on_rational on_literal
+        alias on_array on_literal
+        alias on_str on_literal
+        alias on_dstr on_literal
+        alias on_xstr on_literal
+        alias on_sym on_literal
+        alias on_irange on_literal
+        alias on_erange on_literal
+        alias on_const on_literal
+        alias on_regexp on_literal
+        alias on_lambda on_literal
+        alias on_begin on_literal
+
+        # ^a
+        def on_pin(node)
+          on_literal(node.children.first)
+        end
+
+        # *
+        def on_match_rest(node)
+          if node.children.empty?
+            array(s(:sym, :rest))
+          else
+            array(s(:sym, :rest), process(node.children.first))
+          end
+        end
+
+        # {} | []
+        def on_match_alt(node)
+          array(s(:sym, :any), *node.children.map(&method(:process)))
+        end
+
+        # MyStructName
+        def on_const_pattern(node)
+          array(s(:sym, :all), *node.children.map(&method(:process)))
+        end
+
+        # [0, 1, 2] or [*, 0, 1] or [0, 1, *]
+        def on_array_pattern(node, tail = false)
+          children = *node
+          children << s(:match_rest) if tail
+
+          fixed_size = true
+          array_size = 0
+
+          children = children.each do |i|
+            case i.type
+            when :match_rest
+              fixed_size = false
+            else
+              array_size += 1
+            end
+          end
+
+          array(
+            s(:sym, :array),
+            to_ast(fixed_size),
+            to_ast(array_size),
+            to_ast(children.map(&method(:process)))
+          )
+        end
+
+        # [0, 1, 2,]
+        def on_array_pattern_with_tail(node)
+          on_array_pattern(node, true)
+        end
+
+        # {a:, b:}
+        def on_hash_pattern(node)
+          children = *node
+
+          any_size = children.empty? ? to_ast(false) : to_ast(true)
+
+          children = children.map do |i|
+            case i.type
+            when :pair
+              array(i.children[0], process(i.children[1]))
+            when :match_var
+              array(s(:sym, i.children[0]), process(i))
+            when :match_nil_pattern
+              any_size = to_ast(false)
+              nil
+            when :match_rest
+              # Capturing rest?
+              if i.children.first
+                any_size = process(i.children.first)
+              else
+                any_size = to_ast(true)
+              end
+              nil
+            end
+          end.compact
+
+          array(s(:sym, :hash), any_size, array(*children))
+        end
+
+        # [*, a, b, *]
+        def on_find_pattern(node)
+          children = *node
+
+          children = children.map(&method(:process))
+
+          array(s(:sym, :find), array(*children))
+        end
+
+        private
+
+        def array(*args)
+          to_ast(args)
+        end
+
+        def to_ast(val)
+          case val
+          when Array
+            s(:array, *val)
+          when Integer
+            s(:int, val)
+          when true
+            s(:true)
+          when false
+            s(:false)
+          when nil
+            s(:nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/version.rb

@@ -3,5 +3,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '1.2.0.beta1'
+  VERSION = '1.2.0'
 end

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '3.0.2'
-RUBY_ENGINE_VERSION = '1.2.0.beta1'
-RUBY_RELEASE_DATE   = '2021-07-23'
+RUBY_ENGINE_VERSION = '1.2.0'
+RUBY_RELEASE_DATE   = '2021-07-28'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = '0'
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'