syntax_tree 6.1.1 → 6.3.0

data/lib/syntax_tree/database.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # Provides the ability to index source files into a database, then query for
+  # the nodes.
+  module Database
+    class IndexingVisitor < SyntaxTree::FieldVisitor
+      attr_reader :database, :filepath, :node_id
+
+      def initialize(database, filepath)
+        @database = database
+        @filepath = filepath
+        @node_id = nil
+      end
+
+      private
+
+      def comments(node)
+      end
+
+      def field(name, value)
+        return unless value.is_a?(SyntaxTree::Node)
+
+        binds = [node_id, visit(value), name]
+        database.execute(<<~SQL, binds)
+          INSERT INTO edges (from_id, to_id, name)
+          VALUES (?, ?, ?)
+        SQL
+      end
+
+      def list(name, values)
+        values.each_with_index do |value, index|
+          binds = [node_id, visit(value), name, index]
+          database.execute(<<~SQL, binds)
+            INSERT INTO edges (from_id, to_id, name, list_index)
+            VALUES (?, ?, ?, ?)
+          SQL
+        end
+      end
+
+      def node(node, _name)
+        previous = node_id
+        binds = [
+          node.class.name.delete_prefix("SyntaxTree::"),
+          filepath,
+          node.location.start_line,
+          node.location.start_column
+        ]
+
+        database.execute(<<~SQL, binds)
+          INSERT INTO nodes (type, path, line, column)
+          VALUES (?, ?, ?, ?)
+        SQL
+
+        begin
+          @node_id = database.last_insert_row_id
+          yield
+          @node_id
+        ensure
+          @node_id = previous
+        end
+      end
+
+      def text(name, value)
+      end
+
+      def pairs(name, values)
+        values.each_with_index do |(key, value), index|
+          binds = [node_id, visit(key), "#{name}[0]", index]
+          database.execute(<<~SQL, binds)
+            INSERT INTO edges (from_id, to_id, name, list_index)
+            VALUES (?, ?, ?, ?)
+          SQL
+
+          binds = [node_id, visit(value), "#{name}[1]", index]
+          database.execute(<<~SQL, binds)
+            INSERT INTO edges (from_id, to_id, name, list_index)
+            VALUES (?, ?, ?, ?)
+          SQL
+        end
+      end
+    end
+
+    # Query for a specific type of node.
+    class TypeQuery
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def each(database, &block)
+        sql = "SELECT * FROM nodes WHERE type = ?"
+        database.execute(sql, type).each(&block)
+      end
+    end
+
+    # Query for the attributes of a node, optionally also filtering by type.
+    class AttrQuery
+      attr_reader :type, :attrs
+
+      def initialize(type, attrs)
+        @type = type
+        @attrs = attrs
+      end
+
+      def each(database, &block)
+        joins = []
+        binds = []
+
+        attrs.each do |name, query|
+          ids = query.each(database).map { |row| row[0] }
+          joins << <<~SQL
+            JOIN edges AS #{name}
+            ON #{name}.from_id = nodes.id
+            AND #{name}.name = ?
+            AND #{name}.to_id IN (#{(["?"] * ids.size).join(", ")})
+          SQL
+
+          binds.push(name).concat(ids)
+        end
+
+        sql = +"SELECT nodes.* FROM nodes, edges #{joins.join(" ")}"
+
+        if type
+          sql << " WHERE nodes.type = ?"
+          binds << type
+        end
+
+        sql << " GROUP BY nodes.id"
+        database.execute(sql, binds).each(&block)
+      end
+    end
+
+    # Query for the results of either query.
+    class OrQuery
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def each(database, &block)
+        left.each(database, &block)
+        right.each(database, &block)
+      end
+    end
+
+    # A lazy query result.
+    class QueryResult
+      attr_reader :database, :query
+
+      def initialize(database, query)
+        @database = database
+        @query = query
+      end
+
+      def each(&block)
+        return enum_for(__method__) unless block_given?
+        query.each(database, &block)
+      end
+    end
+
+    # A pattern matching expression that will be compiled into a query.
+    class Pattern
+      class CompilationError < StandardError
+      end
+
+      attr_reader :query
+
+      def initialize(query)
+        @query = query
+      end
+
+      def compile
+        program =
+          begin
+            SyntaxTree.parse("case nil\nin #{query}\nend")
+          rescue Parser::ParseError
+            raise CompilationError, query
+          end
+
+        compile_node(program.statements.body.first.consequent.pattern)
+      end
+
+      private
+
+      def compile_error(node)
+        raise CompilationError, PP.pp(node, +"").chomp
+      end
+
+      # Shortcut for combining two queries into one that returns the results of
+      # if either query matches.
+      def combine_or(left, right)
+        OrQuery.new(left, right)
+      end
+
+      # in foo | bar
+      def compile_binary(node)
+        compile_error(node) if node.operator != :|
+
+        combine_or(compile_node(node.left), compile_node(node.right))
+      end
+
+      # in Ident
+      def compile_const(node)
+        value = node.value
+
+        if SyntaxTree.const_defined?(value, false)
+          clazz = SyntaxTree.const_get(value)
+          TypeQuery.new(clazz.name.delete_prefix("SyntaxTree::"))
+        else
+          compile_error(node)
+        end
+      end
+
+      # in SyntaxTree::Ident
+      def compile_const_path_ref(node)
+        parent = node.parent
+        if !parent.is_a?(SyntaxTree::VarRef) ||
+             !parent.value.is_a?(SyntaxTree::Const)
+          compile_error(node)
+        end
+
+        if parent.value.value == "SyntaxTree"
+          compile_node(node.constant)
+        else
+          compile_error(node)
+        end
+      end
+
+      # in Ident[value: String]
+      def compile_hshptn(node)
+        compile_error(node) unless node.keyword_rest.nil?
+
+        attrs = {}
+        node.keywords.each do |keyword, value|
+          compile_error(node) unless keyword.is_a?(SyntaxTree::Label)
+          attrs[keyword.value.chomp(":")] = compile_node(value)
+        end
+
+        type = node.constant ? compile_node(node.constant).type : nil
+        AttrQuery.new(type, attrs)
+      end
+
+      # in Foo
+      def compile_var_ref(node)
+        value = node.value
+
+        if value.is_a?(SyntaxTree::Const)
+          compile_node(value)
+        else
+          compile_error(node)
+        end
+      end
+
+      def compile_node(node)
+        case node
+        when SyntaxTree::Binary
+          compile_binary(node)
+        when SyntaxTree::Const
+          compile_const(node)
+        when SyntaxTree::ConstPathRef
+          compile_const_path_ref(node)
+        when SyntaxTree::HshPtn
+          compile_hshptn(node)
+        when SyntaxTree::VarRef
+          compile_var_ref(node)
+        else
+          compile_error(node)
+        end
+      end
+    end
+
+    class Connection
+      attr_reader :raw_connection
+
+      def initialize(raw_connection)
+        @raw_connection = raw_connection
+      end
+
+      def execute(query, binds = [])
+        raw_connection.execute(query, binds)
+      end
+
+      def index_file(filepath)
+        program = SyntaxTree.parse(SyntaxTree.read(filepath))
+        program.accept(IndexingVisitor.new(self, filepath))
+      end
+
+      def last_insert_row_id
+        raw_connection.last_insert_row_id
+      end
+
+      def prepare
+        raw_connection.execute(<<~SQL)
+          CREATE TABLE nodes (
+            id integer primary key,
+            type varchar(20),
+            path varchar(200),
+            line integer,
+            column integer
+          );
+        SQL
+
+        raw_connection.execute(<<~SQL)
+          CREATE INDEX nodes_type ON nodes (type);
+        SQL
+
+        raw_connection.execute(<<~SQL)
+          CREATE TABLE edges (
+            id integer primary key,
+            from_id integer,
+            to_id integer,
+            name varchar(20),
+            list_index integer
+          );
+        SQL
+
+        raw_connection.execute(<<~SQL)
+          CREATE INDEX edges_name ON edges (name);
+        SQL
+      end
+
+      def search(query)
+        QueryResult.new(self, Pattern.new(query).compile)
+      end
+    end
+  end
+end

data/lib/syntax_tree/formatter.rb

@@ -60,7 +60,7 @@ module SyntaxTree
             # constant. That constant is responsible for determining the default
             # disable ternary value. If it's defined, then we default to true.
             # Otherwise we default to false.
-            defined?(DISABLE_TERNARY)
+            defined?(DISABLE_AUTO_TERNARY)
           else
             disable_auto_ternary
           end

data/lib/syntax_tree/language_server.rb

@@ -217,11 +217,13 @@ module SyntaxTree
     def initialize(
       input: $stdin,
       output: $stdout,
-      print_width: DEFAULT_PRINT_WIDTH
+      print_width: DEFAULT_PRINT_WIDTH,
+      ignore_files: []
     )
       @input = input.binmode
       @output = output.binmode
       @print_width = print_width
+      @ignore_files = ignore_files
     end
 
     # rubocop:disable Layout/LineLength
@@ -255,8 +257,12 @@ module SyntaxTree
           store.delete(request.dig(:params, :textDocument, :uri))
         when Request[method: "textDocument/formatting", id: :any, params: { textDocument: { uri: :any } }]
           uri = request.dig(:params, :textDocument, :uri)
+          filepath = uri.split("///").last
+          ignore = @ignore_files.any? do |glob|
+            File.fnmatch(glob, filepath)
+          end
           contents = store[uri]
-          write(id: request[:id], result: contents ? format(contents, uri.split(".").last) : nil)
+          write(id: request[:id], result: contents && !ignore ? format(contents, uri.split(".").last) : nil)
         when Request[method: "textDocument/inlayHint", id: :any, params: { textDocument: { uri: :any } }]
           uri = request.dig(:params, :textDocument, :uri)
           contents = store[uri]

data/lib/syntax_tree/node.rb

@@ -288,7 +288,7 @@ module SyntaxTree
         q.text(value)
       else
         q.text(q.quote)
-        q.text(value[1] == "\"" ? "\\\"" : value[1])
+        q.text(value[1] == q.quote ? "\\#{q.quote}" : value[1])
         q.text(q.quote)
       end
     end
@@ -1299,7 +1299,7 @@ module SyntaxTree
       end
     end
 
-    # [nil | VarRef] the optional constant wrapper
+    # [nil | VarRef | ConstPathRef] the optional constant wrapper
     attr_reader :constant
 
     # [Array[ Node ]] the regular positional arguments that this array
@@ -1783,45 +1783,60 @@ module SyntaxTree
       end
     end
 
-    def self.for(container)
-      container.assocs.each do |assoc|
-        if assoc.is_a?(AssocSplat)
-          # Splat nodes do not impact the formatting choice.
-        elsif assoc.value.nil?
-          # If the value is nil, then it has been omitted. In this case we have
-          # to match the existing formatting because standardizing would
-          # potentially break the code. For example:
-          #
-          #     { first:, "second" => "value" }
-          #
-          return Identity.new
-        else
-          # Otherwise, we need to check the type of the key. If it's a label or
-          # dynamic symbol, we can use labels. If it's a symbol literal then it
-          # needs to match a certain pattern to be used as a label. If it's
-          # anything else, then we need to use hash rockets.
-          case assoc.key
-          when Label, DynaSymbol
-            # Here labels can be used.
-          when SymbolLiteral
-            # When attempting to convert a hash rocket into a hash label,
-            # you need to take care because only certain patterns are
-            # allowed. Ruby source says that they have to match keyword
-            # arguments to methods, but don't specify what that is. After
-            # some experimentation, it looks like it's:
-            value = assoc.key.value.value
-
-            if !value.match?(/^[_A-Za-z]/) || value.end_with?("=")
-              return Rockets.new
-            end
+    class << self
+      def for(container)
+        (assocs = container.assocs).each_with_index do |assoc, index|
+          if assoc.is_a?(AssocSplat)
+            # Splat nodes do not impact the formatting choice.
+          elsif assoc.value.nil?
+            # If the value is nil, then it has been omitted. In this case we
+            # have to match the existing formatting because standardizing would
+            # potentially break the code. For example:
+            #
+            #     { first:, "second" => "value" }
+            #
+            return Identity.new
           else
-            # If the value is anything else, we have to use hash rockets.
-            return Rockets.new
+            # Otherwise, we need to check the type of the key. If it's a label
+            # or dynamic symbol, we can use labels. If it's a symbol literal
+            # then it needs to match a certain pattern to be used as a label. If
+            # it's anything else, then we need to use hash rockets.
+            case assoc.key
+            when Label, DynaSymbol
+              # Here labels can be used.
+            when SymbolLiteral
+              # When attempting to convert a hash rocket into a hash label,
+              # you need to take care because only certain patterns are
+              # allowed. Ruby source says that they have to match keyword
+              # arguments to methods, but don't specify what that is. After
+              # some experimentation, it looks like it's:
+              value = assoc.key.value.value
+
+              if !value.match?(/^[_A-Za-z]/) || value.end_with?("=")
+                if omitted_value?(assocs[(index + 1)..])
+                  return Identity.new
+                else
+                  return Rockets.new
+                end
+              end
+            else
+              if omitted_value?(assocs[(index + 1)..])
+                return Identity.new
+              else
+                return Rockets.new
+              end
+            end
           end
         end
+
+        Labels.new
       end
 
-      Labels.new
+      private
+
+      def omitted_value?(assocs)
+        assocs.any? { |assoc| !assoc.is_a?(AssocSplat) && assoc.value.nil? }
+      end
     end
   end
 
@@ -2849,7 +2864,10 @@ module SyntaxTree
             # to print the operator trailing in order to keep it working.
             last_child = children.last
             if last_child.is_a?(CallNode) && last_child.message != :call &&
-                 last_child.message.comments.any? && last_child.operator
+                 (
+                   (last_child.message.comments.any? && last_child.operator) ||
+                     (last_child.operator && last_child.operator.comments.any?)
+                 )
               q.format(CallOperatorFormatter.new(last_child.operator))
               skip_operator = true
             else
@@ -5413,7 +5431,7 @@ module SyntaxTree
   #     end
   #
   class FndPtn < Node
-    # [nil | Node] the optional constant wrapper
+    # [nil | VarRef | ConstPathRef] the optional constant wrapper
     attr_reader :constant
 
     # [VarField] the splat on the left-hand side
@@ -6035,7 +6053,7 @@ module SyntaxTree
       end
     end
 
-    # [nil | Node] the optional constant wrapper
+    # [nil | VarRef | ConstPathRef] the optional constant wrapper
     attr_reader :constant
 
     # [Array[ [DynaSymbol | Label, nil | Node] ]] the set of tuples
@@ -7207,36 +7225,17 @@ module SyntaxTree
         q.text(" ")
         q
           .if_break do
-            force_parens =
-              q.parents.any? do |node|
-                node.is_a?(Command) || node.is_a?(CommandCall)
-              end
-
-            if force_parens
-              q.text("{")
+            q.text("do")
 
-              unless statements.empty?
-                q.indent do
-                  q.breakable_space
-                  q.format(statements)
-                end
+            unless statements.empty?
+              q.indent do
                 q.breakable_space
+                q.format(statements)
               end
-
-              q.text("}")
-            else
-              q.text("do")
-
-              unless statements.empty?
-                q.indent do
-                  q.breakable_space
-                  q.format(statements)
-                end
-              end
-
-              q.breakable_space
-              q.text("end")
             end
+
+            q.breakable_space
+            q.text("end")
           end
           .if_flat do
             q.text("{")
@@ -8293,8 +8292,8 @@ module SyntaxTree
     # parameter
     attr_reader :rest
 
-    # [Array[ Ident ]] any positional parameters that exist after a rest
-    # parameter
+    # [Array[ Ident | MLHSParen ]] any positional parameters that exist after a
+    #  rest parameter
     attr_reader :posts
 
     # [Array[ [ Label, nil | Node ] ]] any keyword parameters and their
@@ -11660,6 +11659,10 @@ module SyntaxTree
           elsif value.is_a?(Array) && (index = value.index(self))
             parent.public_send(key)[index] = replace
             break
+          elsif value.is_a?(Array) &&
+                (index = value.index { |(_k, v)| v == self })
+            parent.public_send(key)[index][1] = replace
+            break
           end
         end
     end

data/lib/syntax_tree/parser.rb

@@ -670,7 +670,11 @@ module SyntaxTree
 
       visit_methods do
         def visit_var_ref(node)
-          node.pin(stack[-2], pins.shift)
+          if node.start_char > pins.first.start_char
+            node.pin(stack[-2], pins.shift)
+          else
+            super
+          end
         end
       end
 
@@ -1732,13 +1736,13 @@ module SyntaxTree
     # :call-seq:
     #   on_field: (
     #     untyped parent,
-    #     (:"::" | Op | Period) operator
+    #     (:"::" | Op | Period | 73) operator
     #     (Const | Ident) name
     #   ) -> Field
     def on_field(parent, operator, name)
       Field.new(
         parent: parent,
-        operator: operator,
+        operator: operator == 73 ? :"::" : operator,
         name: name,
         location: parent.location.to(name.location)
       )
@@ -2867,6 +2871,7 @@ module SyntaxTree
     alias on_assign_error on_parse_error
     alias on_class_name_error on_parse_error
     alias on_param_error on_parse_error
+    alias compile_error on_parse_error
 
     # :call-seq:
     #   on_period: (String value) -> Period

data/lib/syntax_tree/pattern.rb

@@ -70,6 +70,7 @@ module SyntaxTree
           raise CompilationError, query
         end
 
+      raise CompilationError, query if program.nil?
       compile_node(program.statements.body.first.consequent.pattern)
     end
 

data/lib/syntax_tree/plugin/{disable_ternary.rb → disable_auto_ternary.rb}

@@ -2,6 +2,6 @@
 
 module SyntaxTree
   class Formatter
-    DISABLE_TERNARY = true
+    DISABLE_AUTO_TERNARY = true
   end
 end

data/lib/syntax_tree/reflection.rb

@@ -64,7 +64,7 @@ module SyntaxTree
 
       class << self
         def parse(comment)
-          comment = comment.gsub(/\n/, " ")
+          comment = comment.gsub("\n", " ")
 
           unless comment.start_with?("[")
             raise "Comment does not start with a bracket: #{comment.inspect}"

data/lib/syntax_tree/version.rb

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

data/lib/syntax_tree/with_scope.rb

@@ -152,10 +152,7 @@ module SyntaxTree
     # arguments.
     def visit_params(node)
       add_argument_definitions(node.requireds)
-
-      node.posts.each do |param|
-        current_scope.add_local_definition(param, :argument)
-      end
+      add_argument_definitions(node.posts)
 
       node.keywords.each do |param|
         current_scope.add_local_definition(param.first, :argument)

data/lib/syntax_tree/yarv/assembler.rb

@@ -31,7 +31,6 @@ module SyntaxTree
         "FCALL" => CallData::CALL_FCALL,
         "VCALL" => CallData::CALL_VCALL,
         "ARGS_SIMPLE" => CallData::CALL_ARGS_SIMPLE,
-        "BLOCKISEQ" => CallData::CALL_BLOCKISEQ,
         "KWARG" => CallData::CALL_KWARG,
         "KW_SPLAT" => CallData::CALL_KW_SPLAT,
         "TAILCALL" => CallData::CALL_TAILCALL,
@@ -409,7 +408,7 @@ module SyntaxTree
       def find_local(iseq, operands)
         name_string, level_string = operands.split(/,\s*/)
         name = name_string.to_sym
-        level = level_string&.to_i || 0
+        level = level_string.to_i
 
         iseq.local_table.plain(name)
         iseq.local_table.find(name, level)
@@ -456,7 +455,7 @@ module SyntaxTree
             CallData::CALL_ARGS_SIMPLE
           end
 
-        YARV.calldata(message.to_sym, argc_value&.to_i || 0, flags)
+        YARV.calldata(message.to_sym, argc_value.to_i, flags)
       end
     end
   end