syntax_tree 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b573afdda378e664e11b1f5acab2c89ce0fdd2c8b3d4c6400d74e133aaffc3
-  data.tar.gz: 6be0570ce471fe3f34c53730d7095d9b81be5b7e3e2e84ac5724ba95d7ac7362
+  metadata.gz: bd341a51ce36b230703bfbe86078641e7670058a3e41d0dbb125548c0821a65a
+  data.tar.gz: 9ebdca60f2956e24f83a58749266c89eb0eed88003a06699432956a0ecfa735a
 SHA512:
-  metadata.gz: 36236536a1dda5e6e2907b82c383b74f207f5e2b64f282490cf26161d62d748d1cdf51b68c393cd60f1777d2c5434c294ad2e243f2575faae34c42ac44155f76
-  data.tar.gz: 5c2e0ee682e5847287cee5a6ca4357c51e4172bacf7aa98b780e427fb7d0912b6bd829bbf6236baa294a919be9be5730d8c7e74b27a0ca630a29a91c37540324
+  metadata.gz: b8292d8020afa5ece8afdbaa60e959902357e769f098c75894d2b85686a20f824cf510563b2cd31e86b3f8f781f74cf8aaafac76e0e156e26897999ccb72ae36
+  data.tar.gz: 968a355401a9bd1ca6a3e67d60e5587485de9ad3ad2a5f9e8cbe7add95622364e4c094a757035482c35377ab75cb14926af1f5ab8a0df0e5069ba69f7bed1851

data/CHANGELOG.md

@@ -6,6 +6,16 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [2.1.1] - 2022-04-16
+
+### Changed
+
+- [#45](https://github.com/ruby-syntax-tree/syntax_tree/issues/45) - Fix parsing expressions like `foo.instance_exec(&T.must(block))`, where there are two `args_add_block` calls with a single `&`. Previously it was associating the `&` with the wrong block.
+- [#47](https://github.com/ruby-syntax-tree/syntax_tree/pull/47) - Handle expressions like `not()`.
+- [#48](https://github.com/ruby-syntax-tree/syntax_tree/pull/48) - Handle special call syntax with `::` operator.
+- [#49](https://github.com/ruby-syntax-tree/syntax_tree/pull/49) - Handle expressions like `case foo; in {}; end`.
+- [#50](https://github.com/ruby-syntax-tree/syntax_tree/pull/50) - Parsing expressions like `case foo; in **nil; end`.
+
 ## [2.1.0] - 2022-04-12
 
 ### Added
@@ -143,7 +153,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release! 🎉
 
-[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.1.0...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.1.1...HEAD
+[2.1.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.1.0...v2.1.1
 [2.1.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.0.1...v2.1.0
 [2.0.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v1.2.0...v2.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (2.1.0)
+    syntax_tree (2.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -33,6 +33,7 @@ It is built with only standard library dependencies. It additionally ships with
   - [textDocument/formatting](#textdocumentformatting)
   - [textDocument/inlayHints](#textdocumentinlayhints)
   - [syntaxTree/visualizing](#syntaxtreevisualizing)
+- [Plugins](#plugins)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -307,6 +308,26 @@ Implicity, the `2 * 3` is going to be executed first because the `*` operator ha
 
 The language server additionally includes this custom request to return a textual representation of the syntax tree underlying the source code of a file. Language server clients can use this to (for example) open an additional tab with this information displayed.
 
+## Plugins
+
+You can register additional languages that can flow through the same CLI with Syntax Tree's plugin system. To register a new language, call:
+
+```ruby
+SyntaxTree.register_handler(".mylang", MyLanguage)
+```
+
+In this case, whenever the CLI encounters a filepath that ends with the given extension, it will invoke methods on `MyLanguage` instead of `SyntaxTree` itself. To make sure your object conforms to each of the necessary APIs, it should implement:
+
+* `MyLanguage.read(filepath)` - usually this is just an alias to `File.read(filepath)`, but if you need anything else that hook is here.
+* `MyLanguage.parse(source)` - this should return the syntax tree corresponding to the given source. Those objects should implement the `pretty_print` interface.
+* `MyLanguage.format(source)` - this should return the formatted version of the given source.
+
+Below are listed all of the "official" plugins hosted under the same GitHub organization, which can be used as references for how to implement other plugins.
+
+* [SyntaxTree::Haml](https://github.com/ruby-syntax-tree/syntax_tree-haml) for the [Haml template language](https://haml.info/).
+* [SyntaxTree::JSON](https://github.com/ruby-syntax-tree/syntax_tree-json) for JSON.
+* [SyntaxTree::RBS](https://github.com/ruby-syntax-tree/syntax_tree-rbs) for the [RBS type language](https://github.com/ruby/rbs).
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby-syntax-tree/syntax_tree.

data/lib/syntax_tree/node.rb

@@ -4536,6 +4536,7 @@ module SyntaxTree
     def format(q)
       parts = keywords.map { |(key, value)| KeywordFormatter.new(key, value) }
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
+
       contents = -> do
         q.seplist(parts) { |part| q.format(part, stackable: false) }
       end
@@ -4546,8 +4547,9 @@ module SyntaxTree
         return
       end
 
-      parent = q.parent
-      if PATTERNS.include?(parent.class)
+      if parts.empty?
+        q.text("{}")
+      elsif PATTERNS.include?(q.parent.class)
         q.text("{ ")
         contents.call
         q.text(" }")
@@ -8168,7 +8170,7 @@ module SyntaxTree
   #     not value
   #
   class Not < Node
-    # [untyped] the statement on which to operate
+    # [nil | untyped] the statement on which to operate
     attr_reader :statement
 
     # [boolean] whether or not parentheses were used
@@ -8205,7 +8207,7 @@ module SyntaxTree
 
     def format(q)
       q.text(parentheses ? "not(" : "not ")
-      q.format(statement)
+      q.format(statement) if statement
       q.text(")") if parentheses
     end
   end
@@ -8675,7 +8677,11 @@ module SyntaxTree
     end
 
     def format(q)
-      q.format(value) if value
+      if value == :nil
+        q.text("nil")
+      elsif value
+        q.format(value)
+      end
     end
   end
 

data/lib/syntax_tree/parser.rb

@@ -414,12 +414,19 @@ module SyntaxTree
     #     (false | untyped) block
     #   ) -> Args
     def on_args_add_block(arguments, block)
+      # First, see if there is an & operator that could potentially be
+      # associated with the block part of this args_add_block. If there is not,
+      # then just return the arguments.
       operator = find_token(Op, "&", consume: false)
-
-      # If we can't find the & operator, then there's no block to add to the
-      # list, so we're just going to return the arguments as-is.
       return arguments unless operator
 
+      # If there are any arguments and the operator we found from the list is
+      # not after them, then we're going to return the arguments as-is because
+      # we're looking at an & that occurs before the arguments are done.
+      if arguments.parts.any? && operator.location.start_char < arguments.location.end_char
+        return arguments
+      end
+
       # Now we know we have an & operator, so we're going to delete it from the
       # list of tokens to make sure it doesn't get confused with anything else.
       tokens.delete(operator)
@@ -428,13 +435,6 @@ module SyntaxTree
       location = operator.location
       location = operator.location.to(block.location) if block
 
-      # If there are any arguments and the operator we found from the list is
-      # not after them, then we're going to return the arguments as-is because
-      # we're looking at an & that occurs before the arguments are done.
-      if arguments.parts.any? && location.start_char < arguments.location.end_char
-        return arguments
-      end
-
       # Otherwise, we're looking at an actual block argument (with or without a
       # block, which could be missing because it could be a bare & since 3.1.0).
       arg_block = ArgBlock.new(value: block, location: location)
@@ -761,8 +761,14 @@ module SyntaxTree
     #     (:call | Backtick | Const | Ident | Op) message
     #   ) -> Call
     def on_call(receiver, operator, message)
-      ending = message
-      ending = operator if message == :call
+      ending =
+        if message != :call
+          message
+        elsif operator != :"::"
+          operator
+        else
+          receiver
+        end
 
       Call.new(
         receiver: receiver,
@@ -1495,13 +1501,19 @@ module SyntaxTree
     #     (nil | VarField) keyword_rest
     #   ) -> HshPtn
     def on_hshptn(constant, keywords, keyword_rest)
-      parts = [constant, keywords, keyword_rest].flatten(2).compact
+      parts = [constant, *keywords&.flatten(1), keyword_rest].compact
+      location =
+        if parts.empty?
+          find_token(LBrace).location.to(find_token(RBrace).location)
+        else
+          parts[0].location.to(parts[-1].location)
+        end
 
       HshPtn.new(
         constant: constant,
-        keywords: keywords,
+        keywords: keywords || [],
         keyword_rest: keyword_rest,
-        location: parts[0].location.to(parts[-1].location)
+        location: location
       )
     end
 
@@ -2837,19 +2849,17 @@ module SyntaxTree
         # parentheses they don't get reported as a paren node for some reason.
 
         beginning = find_token(Kw, "not")
-        ending = statement
-
-        range = beginning.location.end_char...statement.location.start_char
-        paren = source[range].include?("(")
+        ending = statement || beginning
+        parentheses = source[beginning.location.end_char] == "("
 
-        if paren
+        if parentheses
           find_token(LParen)
           ending = find_token(RParen)
         end
 
         Not.new(
           statement: statement,
-          parentheses: paren,
+          parentheses: parentheses,
           location: beginning.location.to(ending.location)
         )
       else
@@ -2981,7 +2991,7 @@ module SyntaxTree
     #   ) -> VarField
     def on_var_field(value)
       location =
-        if value
+        if value && value != :nil
           value.location
         else
           # You can hit this pattern if you're assigning to a splat using

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "2.1.0"
+  VERSION = "2.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-13 00:00:00.000000000 Z
+date: 2022-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler