ffast 0.2.2 → 0.2.4

data/lib/fast/node.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Fast
+  class Node
+    attr_reader :type, :children, :loc
+
+    def initialize(type, children = [], properties = {})
+      @type = type.to_sym
+      @children = Array(children).freeze
+      @loc = properties[:location]
+      assign_parents!
+    end
+
+    class << self
+      def set_parent(node, parent)
+        NODE_PARENTS[node] = parent
+      end
+
+      def parent_for(node)
+        NODE_PARENTS[node]
+      end
+    end
+
+    # @return [String] with path of the file or simply buffer name.
+    def buffer_name
+      expression.source_buffer.name
+    end
+
+    # @return [Fast::Source::Range] from the expression
+    def expression
+      loc.expression
+    end
+
+    # Backward-compatible alias for callers that still use `location`.
+    def location
+      loc
+    end
+
+    # @return [String] with the content of the #expression
+    def source
+      expression.source
+    end
+
+    # @return [Boolean] true if a file exists with the #buffer_name
+    def from_file?
+      File.exist?(buffer_name)
+    end
+
+    def each_child_node
+      return enum_for(:each_child_node) unless block_given?
+
+      children.select { |child| Fast.ast_node?(child) }.each { |child| yield child }
+    end
+
+    def each_descendant(*types, &block)
+      return enum_for(:each_descendant, *types) unless block_given?
+
+      each_child_node do |child|
+        yield child if types.empty? || types.include?(child.type)
+        child.each_descendant(*types, &block) if child.respond_to?(:each_descendant)
+      end
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def parent
+      self.class.parent_for(self)
+    end
+
+    def updated(type = nil, children = nil, properties = nil)
+      updated_node = self.class.new(
+        type || self.type,
+        children || self.children,
+        { location: properties&.fetch(:location, loc) || loc }
+      )
+      updated_node.send(:assign_parents!)
+      updated_node
+    end
+
+    def ==(other)
+      Fast.ast_node?(other) && type == other.type && children == other.children
+    end
+    alias eql? ==
+
+    def hash
+      [type, children].hash
+    end
+
+    def to_a
+      children.dup
+    end
+
+    def <<(child)
+      updated(nil, children + [child])
+    end
+
+    def deconstruct
+      to_a
+    end
+
+    def to_ast
+      self
+    end
+
+    def to_sexp
+      format_node(:sexp)
+    end
+
+    def to_s
+      to_sexp
+    end
+
+    def inspect
+      format_node(:inspect)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      type_query_method?(method_name) || super
+    end
+
+    def method_missing(method_name, *args, &block)
+      return type == type_query_name(method_name) if type_query_method?(method_name) && args.empty? && !block
+
+      super
+    end
+
+    # @return [Array<String>] with authors from the current expression range
+    def blame_authors
+      `git blame -L #{expression.first_line},#{expression.last_line} #{buffer_name}`.lines.map do |line|
+        line.split('(')[1].split(/\d+/).first.strip
+      end
+    end
+
+    # @return [String] with the first element from #blame_authors
+    def author
+      blame_authors.first
+    end
+
+    # Search recursively into a node and its children using a pattern.
+    # @param [String] pattern
+    # @param [Array] *args extra arguments to interpolate in the pattern.
+    # @return [Array<Fast::Node>>] with files and results
+    def search(pattern, *args)
+      Fast.search(pattern, self, *args)
+    end
+
+    # Captures elements from search recursively
+    # @param [String] pattern
+    # @param [Array] *args extra arguments to interpolate in the pattern.
+    # @return [Array<Fast::Node>>] with files and results
+    def capture(pattern, *args)
+      Fast.capture(pattern, self, *args)
+    end
+
+    private
+
+    def assign_parents!
+      each_child_node do |child|
+        self.class.set_parent(child, self)
+        child.send(:assign_parents!) if child.respond_to?(:assign_parents!, true)
+      end
+    end
+
+    def type_query_method?(method_name)
+      method_name.to_s.end_with?('_type?')
+    end
+
+    def type_query_name(method_name)
+      method_name.to_s.delete_suffix('_type?').to_sym
+    end
+
+    def format_node(style)
+      opener = style == :inspect ? "s(:#{type}" : "(#{type}"
+      separator = style == :inspect ? ', ' : ' '
+      inline_children = children.map { |child| format_atom(child, style, inline: true) }
+      return "#{opener})" if inline_children.empty?
+
+      if children.none? { |child| Fast.ast_node?(child) } && inline_children.all? { |child| !child.include?("\n") }
+        return "#{opener}#{separator}#{inline_children.join(separator)})"
+      end
+
+      lines = [opener]
+      current_line = +''
+
+      children.each do |child|
+        formatted = format_atom(child, style, inline: false)
+        if formatted.include?("\n")
+          flush_current_line!(lines, current_line, style)
+          current_line.clear
+          lines << indent_multiline(formatted)
+        elsif Fast.ast_node?(child)
+          flush_current_line!(lines, current_line, style)
+          current_line = formatted.dup
+        else
+          current_line << separator unless current_line.empty?
+          current_line << formatted
+        end
+      end
+
+      flush_current_line!(lines, current_line, style)
+      if lines.length > 2 && scalar_line?(lines[1], style)
+        lines[0] = "#{lines[0]}#{separator}#{lines[1].strip}"
+        lines.delete_at(1)
+      end
+      lines[-1] = "#{lines[-1]})"
+      lines.join("\n")
+    end
+
+    def flush_current_line!(lines, current_line, style)
+      return if current_line.empty?
+
+      line = style == :inspect ? "  #{current_line}," : "  #{current_line}"
+      lines << line
+    end
+
+    def indent_multiline(text)
+      text.lines.map { |line| "  #{line}" }.join
+    end
+
+    def format_atom(atom, style, inline:)
+      if Fast.ast_node?(atom)
+        text = style == :inspect ? atom.inspect : atom.to_sexp
+        return text if inline || !text.include?("\n")
+
+        style == :inspect ? trim_trailing_comma(text) : text
+      else
+        format_scalar(atom, style)
+      end
+    end
+
+    def trim_trailing_comma(text)
+      lines = text.lines
+      lines[-1] = lines[-1].sub(/,\z/, '')
+      lines.join
+    end
+
+    def scalar_line?(line, style)
+      stripped = line.strip
+      return false if stripped.empty?
+
+      opener = style == :inspect ? 's(' : '('
+      !stripped.start_with?(opener)
+    end
+
+    def format_scalar(value, _style)
+      case value
+      when Symbol, String
+        value.inspect
+      when Array
+        "[#{value.map { |item| format_atom(item, :sexp, inline: true) }.join(', ')}]"
+      else
+        value.inspect
+      end
+    end
+  end
+end

data/lib/fast/prism_adapter.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'fast/source'
+
+module Fast
+  module PrismAdapter
+    module_function
+
+    class Location
+      attr_accessor :node
+      attr_reader :expression
+
+      def initialize(buffer_name, source, start_offset, end_offset, prism_node: nil)
+        @buffer_name = buffer_name
+        @source = source
+        @prism_node = prism_node
+        buffer = Fast::Source.buffer(buffer_name, source: source)
+        @expression = Fast::Source.range(
+          buffer,
+          character_offset(source, start_offset),
+          character_offset(source, end_offset)
+        )
+      end
+
+      def name
+        return unless @prism_node&.respond_to?(:name_loc) && @prism_node.name_loc
+
+        range_for(@prism_node.name_loc)
+      end
+
+      def selector
+        return unless @prism_node&.respond_to?(:message_loc) && @prism_node.message_loc
+
+        range_for(@prism_node.message_loc)
+      end
+
+      def operator
+        return unless @prism_node&.respond_to?(:operator_loc) && @prism_node.operator_loc
+
+        range_for(@prism_node.operator_loc)
+      end
+
+      private
+
+      def character_offset(source, byte_offset)
+        source.byteslice(0, byte_offset).to_s.length
+      end
+
+      def range_for(prism_location)
+        buffer = Fast::Source.buffer(@buffer_name, source: @source)
+        Fast::Source.range(
+          buffer,
+          character_offset(@source, prism_location.start_offset),
+          character_offset(@source, prism_location.end_offset)
+        )
+      end
+    end
+
+    class Node < Fast::Node
+      def initialize(type, children:, loc:)
+        super(type, Array(children), location: loc)
+      end
+
+      def updated(type = nil, children = nil, properties = nil)
+        self.class.new(
+          type || self.type,
+          children: children || self.children,
+          loc: properties&.fetch(:location, loc) || loc
+        )
+      end
+    end
+
+    def parse(source, buffer_name: '(string)')
+      result = Prism.parse(source)
+      return unless result.success?
+
+      adapt(result.value, source, buffer_name)
+    end
+
+    def adapt(node, source, buffer_name)
+      return if node.nil?
+
+      case node
+      when Prism::ProgramNode
+        statements = adapt_statements(node.statements, source, buffer_name)
+        statements.is_a?(Node) ? statements : build_node(:begin, statements, node, source, buffer_name)
+      when Prism::StatementsNode
+        adapt_statements(node, source, buffer_name)
+      when Prism::ModuleNode
+        build_node(:module, [adapt(node.constant_path, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::ClassNode
+        build_node(:class, [adapt(node.constant_path, source, buffer_name), adapt(node.superclass, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::SingletonClassNode
+        build_node(:sclass, [adapt(node.expression, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::DefNode
+        if node.receiver
+          build_node(:defs, [adapt(node.receiver, source, buffer_name), node.name, adapt_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+        else
+          build_node(:def, [node.name, adapt_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+        end
+      when Prism::BlockNode
+        return nil unless node.respond_to?(:call)
+
+        build_node(:block, [adapt_call_node(node.call, source, buffer_name), adapt_block_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::CallNode
+        if node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+          return build_node(
+            :block,
+            [
+              adapt_call_node(node, source, buffer_name),
+              adapt_block_parameters(node.block.parameters, source, buffer_name),
+              adapt(node.block.body, source, buffer_name)
+            ],
+            node,
+            source,
+            buffer_name
+          )
+        end
+
+        adapt_call_node(node, source, buffer_name)
+      when Prism::ParenthesesNode
+        adapt(node.body, source, buffer_name)
+      when Prism::RangeNode
+        build_node(node.exclude_end? ? :erange : :irange, [adapt(node.left, source, buffer_name), adapt(node.right, source, buffer_name)], node, source, buffer_name)
+      when Prism::BlockArgumentNode
+        build_node(:block_pass, [adapt(node.expression, source, buffer_name)], node, source, buffer_name)
+      when Prism::ConstantPathNode
+        build_const_path(node, source, buffer_name)
+      when Prism::ConstantReadNode
+        build_node(:const, [nil, node.name], node, source, buffer_name)
+      when Prism::ConstantWriteNode
+        build_node(:casgn, [nil, node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::SymbolNode
+        build_node(:sym, [node.unescaped], node, source, buffer_name)
+      when Prism::StringNode
+        build_node(:str, [node.unescaped], node, source, buffer_name)
+      when Prism::XStringNode
+        build_node(:xstr, [node.unescaped], node, source, buffer_name)
+      when Prism::InterpolatedStringNode
+        build_node(:dstr, node.parts.filter_map { |part| adapt(part, source, buffer_name) }, node, source, buffer_name)
+      when Prism::InterpolatedXStringNode
+        build_node(:dxstr, node.parts.filter_map { |part| adapt(part, source, buffer_name) }, node, source, buffer_name)
+      when Prism::InterpolatedSymbolNode
+        build_node(:dsym, node.parts.filter_map { |part| adapt(part, source, buffer_name) }, node, source, buffer_name)
+      when Prism::ArrayNode
+        build_node(:array, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::HashNode
+        build_node(:hash, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::KeywordHashNode
+        build_node(:hash, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::AssocNode
+        build_node(:pair, [adapt(node.key, source, buffer_name), adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::SelfNode
+        build_node(:self, [], node, source, buffer_name)
+      when Prism::LocalVariableReadNode
+        build_node(:lvar, [node.name], node, source, buffer_name)
+      when Prism::InstanceVariableReadNode
+        build_node(:ivar, [node.name], node, source, buffer_name)
+      when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode
+        build_node(:ivasgn, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::LocalVariableWriteNode, Prism::LocalVariableOrWriteNode
+        build_node(:lvasgn, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::LocalVariableOperatorWriteNode
+        build_node(
+          :op_asgn,
+          [
+            build_node(:lvasgn, [node.name], node, source, buffer_name),
+            (node.respond_to?(:binary_operator) ? node.binary_operator : node.operator),
+            adapt(node.value, source, buffer_name)
+          ],
+          node,
+          source,
+          buffer_name
+        )
+      when Prism::IntegerNode
+        build_node(:int, [node.value], node, source, buffer_name)
+      when Prism::FloatNode
+        build_node(:float, [node.value], node, source, buffer_name)
+      when Prism::TrueNode
+        build_node(:true, [], node, source, buffer_name)
+      when Prism::FalseNode
+        build_node(:false, [], node, source, buffer_name)
+      when Prism::NilNode
+        build_node(:nil, [], node, source, buffer_name)
+      when Prism::IfNode
+        build_node(:if, [adapt(node.predicate, source, buffer_name), adapt(node.statements, source, buffer_name), adapt(node.consequent, source, buffer_name)], node, source, buffer_name)
+      when Prism::UnlessNode
+        build_node(:if, [adapt(node.predicate, source, buffer_name), adapt(node.consequent, source, buffer_name), adapt(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::RescueModifierNode
+        build_node(:rescue, [adapt(node.expression, source, buffer_name), build_node(:resbody, [nil, nil, adapt(node.rescue_expression, source, buffer_name)], node, source, buffer_name), nil], node, source, buffer_name)
+      when Prism::CaseNode
+        children = [adapt(node.predicate, source, buffer_name)]
+        children.concat(node.conditions.map { |condition| adapt(condition, source, buffer_name) })
+        else_clause =
+          if node.respond_to?(:else_clause)
+            node.else_clause
+          elsif node.respond_to?(:consequent)
+            node.consequent
+          end
+        children << adapt_else_clause(else_clause, source, buffer_name) if else_clause
+        build_node(:case, children, node, source, buffer_name)
+      when Prism::WhenNode
+        condition =
+          if node.conditions.length == 1
+            adapt(node.conditions.first, source, buffer_name)
+          else
+            build_node(:array, node.conditions.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+          end
+        build_node(:when, [condition, adapt(node.statements, source, buffer_name)].compact, node, source, buffer_name)
+      when Prism::ElseNode
+        adapt_else_clause(node, source, buffer_name)
+      when Prism::BeginNode, Prism::EmbeddedStatementsNode
+        statements = adapt_statements(node.statements, source, buffer_name)
+        children = statements.is_a?(Node) && statements.type == :begin ? statements.children : Array(statements)
+        build_node(:begin, children, node, source, buffer_name)
+      when Prism::EmbeddedVariableNode
+        build_node(:begin, [adapt(node.variable, source, buffer_name)].compact, node, source, buffer_name)
+      when Prism::LambdaNode
+        build_node(:lambda, [adapt_block_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      else
+        nil
+      end
+    end
+
+    def adapt_statements(node, source, buffer_name)
+      return nil unless node
+
+      children = node.body.filter_map { |child| adapt(child, source, buffer_name) }
+      return nil if children.empty?
+      return children.first if children.one?
+
+      build_node(:begin, children, node, source, buffer_name)
+    end
+
+    def adapt_parameters(node, source, buffer_name)
+      return build_node(:args, [], nil, source, buffer_name) unless node
+
+      children = []
+      children.concat(node.requireds.map { |child| adapt_required_parameter(child, source, buffer_name) }) if node.respond_to?(:requireds)
+      children.concat(node.optionals.map { |child| build_node(:optarg, [parameter_name(child), adapt(child.value, source, buffer_name)], child, source, buffer_name) }) if node.respond_to?(:optionals)
+      children << build_node(:restarg, [parameter_name(node.rest)], node.rest, source, buffer_name) if node.respond_to?(:rest) && node.rest
+      children.concat(node.posts.map { |child| adapt_required_parameter(child, source, buffer_name) }) if node.respond_to?(:posts)
+      children.concat(node.keywords.map { |child| adapt_keyword_parameter(child, source, buffer_name) }) if node.respond_to?(:keywords)
+      children << build_node(:kwrestarg, [parameter_name(node.keyword_rest)], node.keyword_rest, source, buffer_name) if node.respond_to?(:keyword_rest) && node.keyword_rest
+      children << build_node(:blockarg, [parameter_name(node.block)], node.block, source, buffer_name) if node.respond_to?(:block) && node.block
+      build_node(:args, children, node, source, buffer_name)
+    end
+
+    def adapt_block_parameters(node, source, buffer_name)
+      return build_node(:args, [], nil, source, buffer_name) unless node
+
+      params = node.respond_to?(:parameters) ? node.parameters : node
+      adapt_parameters(params, source, buffer_name)
+    end
+
+    def adapt_required_parameter(child, source, buffer_name)
+      if child.is_a?(Prism::MultiTargetNode)
+        mlhs_children = child.lefts.map { |c| adapt_required_parameter(c, source, buffer_name) }
+        mlhs_children << build_node(:restarg, [parameter_name(child.rest)], child.rest, source, buffer_name) if child.respond_to?(:rest) && child.rest
+        mlhs_children.concat(child.rights.map { |c| adapt_required_parameter(c, source, buffer_name) }) if child.respond_to?(:rights)
+        build_node(:mlhs, mlhs_children, child, source, buffer_name)
+      else
+        build_node(:arg, [parameter_name(child)], child, source, buffer_name)
+      end
+    end
+
+    def adapt_keyword_parameter(node, source, buffer_name)
+      case node
+      when Prism::RequiredKeywordParameterNode
+        build_node(:kwarg, [parameter_name(node)], node, source, buffer_name)
+      when Prism::OptionalKeywordParameterNode
+        build_node(:kwoptarg, [parameter_name(node), adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      else
+        build_node(:arg, [parameter_name(node)], node, source, buffer_name)
+      end
+    end
+
+    def adapt_call_node(node, source, buffer_name)
+      children = [adapt(node.receiver, source, buffer_name), node.name]
+      children.concat(node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) } || [])
+      children << adapt(node.block, source, buffer_name) if node.respond_to?(:block) && node.block && !node.block.is_a?(Prism::BlockNode)
+      return build_node(:send, children, node, source, buffer_name) unless node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+
+      end_offset = node.block.location.start_offset
+      while end_offset > node.location.start_offset && source.byteslice(end_offset - 1, 1)&.match?(/\s/)
+        end_offset -= 1
+      end
+
+      loc = Location.new(
+        buffer_name,
+        source,
+        node.location.start_offset,
+        end_offset,
+        prism_node: node
+      )
+      send_node = Node.new(:send, children: children, loc: loc)
+      loc.node = send_node
+      send_node
+    end
+
+    def adapt_else_clause(node, source, buffer_name)
+      adapt(node.statements, source, buffer_name)
+    end
+
+    def parameter_name(node)
+      node.respond_to?(:name) ? node.name : nil
+    end
+
+    def build_const_path(node, source, buffer_name)
+      parent = node.parent ? adapt(node.parent, source, buffer_name) : nil
+      build_node(:const, [parent, node.child.name], node, source, buffer_name)
+    end
+
+    def build_node(type, children, prism_node, source, buffer_name)
+      loc =
+        if prism_node
+          Location.new(buffer_name, source, prism_node.location.start_offset, prism_node.location.end_offset, prism_node: prism_node)
+        else
+          Location.new(buffer_name, source, 0, 0)
+        end
+      node = Node.new(type, children: children, loc: loc)
+      loc.node = node
+      node
+    end
+  end
+end