starscope 1.5.3 → 1.5.4

data/lib/starscope/langs/javascript.rb

@@ -2,138 +2,140 @@ require 'rkelly'
 require 'babel/transpiler'
 require 'sourcemap'
 
-module Starscope::Lang
-  module Javascript
-    VERSION = 1
+module Starscope
+  module Lang
+    module Javascript
+      VERSION = 1
 
-    def self.match_file(name)
-      name.end_with?('.js')
-    end
+      def self.match_file(name)
+        name.end_with?('.js')
+      end
 
-    def self.extract(path, contents, &block)
-      return if path.end_with?('.min.js')
+      def self.extract(path, contents, &block)
+        return if path.end_with?('.min.js')
 
-      transform = Babel::Transpiler.transform(contents,
-                                              'stage' => 0,
-                                              'blacklist' => ['validation.react'],
-                                              'externalHelpers' => true,
-                                              'compact' => false,
-                                              'sourceMaps' => true)
-      map = SourceMap::Map.from_hash(transform['map'])
-      ast = RKelly::Parser.new.parse(transform['code'])
-      lines = contents.lines.to_a
+        transform = Babel::Transpiler.transform(contents,
+                                                'stage' => 0,
+                                                'blacklist' => ['validation.react'],
+                                                'externalHelpers' => true,
+                                                'compact' => false,
+                                                'sourceMaps' => true)
+        map = SourceMap::Map.from_hash(transform['map'])
+        ast = RKelly::Parser.new.parse(transform['code'])
+        lines = contents.lines.to_a
 
-      return unless ast
+        return unless ast
 
-      found = extract_methods(ast, map, lines, &block)
+        found = extract_methods(ast, map, lines, &block)
 
-      found = extract_var_decls(ast, map, lines, found, &block)
+        found = extract_var_decls(ast, map, lines, found, &block)
 
-      extract_var_reads(ast, map, lines, found, &block)
-    end
+        extract_var_reads(ast, map, lines, found, &block)
+      end
 
-    def self.extract_methods(ast, map, lines, &block)
-      found = {}
+      def self.extract_methods(ast, map, lines)
+        found = {}
 
-      ast.each do |node|
-        case node
-        when RKelly::Nodes::FunctionExprNode, RKelly::Nodes::FunctionDeclNode
-          line = find_line(node.range.from, map, lines, node.value)
-          next unless line
+        ast.each do |node|
+          case node
+          when RKelly::Nodes::FunctionExprNode, RKelly::Nodes::FunctionDeclNode
+            line = find_line(node.range.from, map, lines, node.value)
+            next unless line
 
-          type = :func
-          type = :class if lines[line - 1].include?("class #{node.value}")
+            type = :func
+            type = :class if lines[line - 1].include?("class #{node.value}")
 
-          yield :defs, node.value, line_no: line, type: type
-          found[node.value] ||= Set.new
-          found[node.value].add(line)
+            yield :defs, node.value, line_no: line, type: type
+            found[node.value] ||= Set.new
+            found[node.value].add(line)
 
-          next if type == :class
+            next if type == :class
 
-          mapping = map.bsearch(SourceMap::Offset.new(node.range.to.line, node.range.to.char))
-          if lines[mapping.original.line - 1].include? '}'
-            yield :end, '}', line_no: mapping.original.line, type: type
-          else
-            yield :end, '', line_no: mapping.original.line, type: type, col: mapping.original.column
-          end
-        when RKelly::Nodes::FunctionCallNode
-          name = node_name(node.value)
-          next unless name
+            mapping = map.bsearch(SourceMap::Offset.new(node.range.to.line, node.range.to.char))
+            if lines[mapping.original.line - 1].include? '}'
+              yield :end, '}', line_no: mapping.original.line, type: type
+            else
+              yield :end, '', line_no: mapping.original.line, type: type, col: mapping.original.column
+            end
+          when RKelly::Nodes::FunctionCallNode
+            name = node_name(node.value)
+            next unless name
 
-          node = node.arguments.value[0] if name == 'require' && !node.value.is_a?(RKelly::Nodes::DotAccessorNode)
+            node = node.arguments.value[0] if name == 'require' && !node.value.is_a?(RKelly::Nodes::DotAccessorNode)
 
-          line = find_line(node.range.from, map, lines, name)
-          next unless line
+            line = find_line(node.range.from, map, lines, name)
+            next unless line
 
-          found[name] ||= Set.new
-          found[name].add(line)
+            found[name] ||= Set.new
+            found[name].add(line)
 
-          if name == 'require' && node.is_a?(RKelly::Nodes::StringNode)
-            yield :requires, node.value[1...-1], line_no: line
-          else
-            yield :calls, name, line_no: line
+            if name == 'require' && node.is_a?(RKelly::Nodes::StringNode)
+              yield :requires, node.value[1...-1], line_no: line
+            else
+              yield :calls, name, line_no: line
+            end
           end
         end
+
+        found
       end
 
-      found
-    end
+      def self.extract_var_decls(ast, map, lines, found)
+        ast.each do |node|
+          next unless node.is_a? RKelly::Nodes::VarDeclNode
 
-    def self.extract_var_decls(ast, map, lines, found, &block)
-      ast.each do |node|
-        next unless node.is_a? RKelly::Nodes::VarDeclNode
+          line = find_line(node.range.from, map, lines, node.name)
+          next unless line
 
-        line = find_line(node.range.from, map, lines, node.name)
-        next unless line
+          if node.value.is_a?(RKelly::Nodes::AssignExprNode) &&
+             node.value.value.is_a?(RKelly::Nodes::FunctionCallNode) &&
+             node.value.value.value.is_a?(RKelly::Nodes::ResolveNode) &&
+             node.value.value.value.value == 'require'
+            found[node.name] ||= Set.new
+            found[node.name].add(line)
+            next
+          end
 
-        if node.value.is_a?(RKelly::Nodes::AssignExprNode) &&
-           node.value.value.is_a?(RKelly::Nodes::FunctionCallNode) &&
-           node.value.value.value.is_a?(RKelly::Nodes::ResolveNode) &&
-           node.value.value.value.value == 'require'
+          next if found[node.name] && found[node.name].include?(line)
+          yield :defs, node.name, line_no: line
           found[node.name] ||= Set.new
           found[node.name].add(line)
-          next
         end
 
-        next if found[node.name] && found[node.name].include?(line)
-        yield :defs, node.name, line_no: line
-        found[node.name] ||= Set.new
-        found[node.name].add(line)
+        found
       end
 
-      found
-    end
-
-    def self.extract_var_reads(ast, map, lines, found, &block)
-      ast.each do |node|
-        name = node_name(node)
-        next unless name
+      def self.extract_var_reads(ast, map, lines, found)
+        ast.each do |node|
+          name = node_name(node)
+          next unless name
 
-        line = find_line(node.range.from, map, lines, name)
-        next unless line
+          line = find_line(node.range.from, map, lines, name)
+          next unless line
 
-        next if found[name] && found[name].include?(line)
-        yield :reads, name, line_no: line
+          next if found[name] && found[name].include?(line)
+          yield :reads, name, line_no: line
+        end
       end
-    end
 
-    def self.node_name(node)
-      case node
-      when RKelly::Nodes::DotAccessorNode
-        node.accessor
-      when RKelly::Nodes::ResolveNode
-        node.value
+      def self.node_name(node)
+        case node
+        when RKelly::Nodes::DotAccessorNode
+          node.accessor
+        when RKelly::Nodes::ResolveNode
+          node.value
+        end
       end
-    end
 
-    def self.find_line(from, map, lines, name)
-      mapping = map.bsearch(SourceMap::Offset.new(from.line, from.char))
-      return unless mapping
+      def self.find_line(from, map, lines, name)
+        mapping = map.bsearch(SourceMap::Offset.new(from.line, from.char))
+        return unless mapping
 
-      line = lines[mapping.original.line - 1]
-      return unless line.include?(name) || (name == 'require' && line.include?('import'))
+        line = lines[mapping.original.line - 1]
+        return unless line.include?(name) || (name == 'require' && line.include?('import'))
 
-      mapping.original.line
+        mapping.original.line
+      end
     end
   end
 end

data/lib/starscope/langs/ruby.rb

@@ -1,111 +1,129 @@
 require 'parser/current'
 
-module Starscope::Lang
-  module Ruby
-    VERSION = 2
-
-    def self.match_file(name)
-      return true if name.end_with?('.rb', '.rake')
-      File.open(name) do |f|
-        head = f.read(2)
-        return false if head.nil? || !head.start_with?('#!')
-        return f.readline.include?('ruby')
+module Starscope
+  module Lang
+    module Ruby
+      # This class exists solely to workaround/suppress issues from upstream's handling of invalid unicode.
+      # See https://github.com/whitequark/parser/issues/283; workaround borrowed from
+      # https://github.com/bbatsov/rubocop/commit/5e820eb5cfddf5e0f7efd2c0fa99e6b8a4c7b7e0
+      class Builder < Parser::Builders::Default
+        def string_value(token)
+          value(token)
+        end
       end
-    end
-
-    def self.extract(path, contents, &block)
-      ast = Parser::CurrentRuby.parse(contents)
-      extract_tree(ast, [], &block) unless ast.nil?
-    end
 
-    def self.extract_tree(tree, scope, &block)
-      extract_node(tree, scope, &block)
+      VERSION = 2
 
-      new_scope = []
-      if [:class, :module].include? tree.type
-        new_scope = scoped_name(tree.children[0], scope)
-        scope += new_scope
+      def self.match_file(name)
+        return true if name.end_with?('.rb', '.rake')
+        File.open(name) do |f|
+          head = f.read(2)
+          return false if head.nil? || !head.start_with?('#!')
+          return f.readline.include?('ruby')
+        end
       end
 
-      tree.children.each { |node| extract_tree(node, scope, &block) if node.is_a? AST::Node }
+      def self.extract(path, contents, &block)
+        buffer = Parser::Source::Buffer.new(path, 1)
+        buffer.source = contents.force_encoding(Encoding::UTF_8)
 
-      scope.pop(new_scope.count)
-    end
+        parser = Parser::CurrentRuby.new(Builder.new)
+        parser.diagnostics.ignore_warnings = true
+        parser.diagnostics.all_errors_are_fatal = false
 
-    def self.extract_node(node, scope)
-      loc = node.location
+        ast = parser.parse(buffer)
+        extract_tree(ast, [], &block) unless ast.nil?
+      end
 
-      case node.type
-      when :send
-        name = scoped_name(node, scope)
-        yield :calls, name, line_no: loc.line, col: loc.column
+      def self.extract_tree(tree, scope, &block)
+        extract_node(tree, scope, &block)
 
-        if name.last =~ /\w+=$/
-          name[-1] = name.last.to_s.chop.to_sym
-          yield :assigns, name, line_no: loc.line, col: loc.column
-        elsif node.children[0].nil? && node.children[1] == :require && node.children[2].type == :str
-          yield :requires, node.children[2].children[0].split('/'),
-            line_no: loc.line, col: loc.column
+        new_scope = []
+        if [:class, :module].include? tree.type
+          new_scope = scoped_name(tree.children[0], scope)
+          scope += new_scope
         end
 
-      when :def
-        yield :defs, scope + [node.children[0]],
-          line_no: loc.line, type: :func, col: loc.name.column
-        yield :end, :end, line_no: loc.end.line, type: :func, col: loc.end.column
-
-      when :defs
-        yield :defs, scope + [node.children[1]],
-          line_no: loc.line, type: :func, col: loc.name.column
-        yield :end, :end, line_no: loc.end.line, type: :func, col: loc.end.column
-
-      when :module, :class
-        yield :defs, scope + scoped_name(node.children[0], scope),
-          line_no: loc.line, type: node.type, col: loc.name.column
-        yield :end, :end, line_no: loc.end.line, type: node.type, col: loc.end.column
-
-      when :casgn
-        name = scoped_name(node, scope)
-        yield :assigns, name, line_no: loc.line, col: loc.name.column
-        yield :defs, name, line_no: loc.line, col: loc.name.column
-
-      when :lvasgn, :ivasgn, :cvasgn, :gvasgn
-        yield :assigns, scope + [node.children[0]], line_no: loc.line, col: loc.name.column
-
-      when :const
-        name = scoped_name(node, scope)
-        yield :reads, name, line_no: loc.line, col: loc.name.column
-
-      when :lvar, :ivar, :cvar, :gvar
-        yield :reads, scope + [node.children[0]], line_no: loc.line, col: loc.name.column
-
-      when :sym
-        # handle `:foo` vs `foo: 1`
-        col = if loc.begin
-                loc.begin.column + 1
-              else
-                loc.expression.column
-              end
-        yield :sym, [node.children[0]], line_no: loc.line, col: col
+        tree.children.each { |node| extract_tree(node, scope, &block) if node.is_a? AST::Node }
+
+        scope.pop(new_scope.count)
+      end
+
+      def self.extract_node(node, scope)
+        loc = node.location
+
+        case node.type
+        when :send
+          name = scoped_name(node, scope)
+          yield :calls, name, line_no: loc.line, col: loc.column
+
+          if name.last =~ /\w+=$/
+            name[-1] = name.last.to_s.chop.to_sym
+            yield :assigns, name, line_no: loc.line, col: loc.column
+          elsif node.children[0].nil? && node.children[1] == :require && node.children[2].type == :str
+            yield :requires, node.children[2].children[0].split('/'),
+              line_no: loc.line, col: loc.column
+          end
+
+        when :def
+          yield :defs, scope + [node.children[0]],
+            line_no: loc.line, type: :func, col: loc.name.column
+          yield :end, :end, line_no: loc.end.line, type: :func, col: loc.end.column
+
+        when :defs
+          yield :defs, scope + [node.children[1]],
+            line_no: loc.line, type: :func, col: loc.name.column
+          yield :end, :end, line_no: loc.end.line, type: :func, col: loc.end.column
+
+        when :module, :class
+          yield :defs, scope + scoped_name(node.children[0], scope),
+            line_no: loc.line, type: node.type, col: loc.name.column
+          yield :end, :end, line_no: loc.end.line, type: node.type, col: loc.end.column
+
+        when :casgn
+          name = scoped_name(node, scope)
+          yield :assigns, name, line_no: loc.line, col: loc.name.column
+          yield :defs, name, line_no: loc.line, col: loc.name.column
+
+        when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+          yield :assigns, scope + [node.children[0]], line_no: loc.line, col: loc.name.column
+
+        when :const
+          name = scoped_name(node, scope)
+          yield :reads, name, line_no: loc.line, col: loc.name.column
+
+        when :lvar, :ivar, :cvar, :gvar
+          yield :reads, scope + [node.children[0]], line_no: loc.line, col: loc.name.column
+
+        when :sym
+          # handle `:foo` vs `foo: 1`
+          col = if loc.begin
+                  loc.begin.column + 1
+                else
+                  loc.expression.column
+                end
+          yield :sym, [node.children[0]], line_no: loc.line, col: col
+        end
       end
-    end
 
-    def self.scoped_name(node, scope)
-      if node.type == :block
-        scoped_name(node.children[0], scope)
-      elsif [:lvar, :ivar, :cvar, :gvar, :const, :send, :casgn].include? node.type
-        if node.children[0].is_a? Symbol
-          [node.children[0]]
-        elsif node.children[0].is_a? AST::Node
-          scoped_name(node.children[0], scope) << node.children[1]
-        elsif node.children[0].nil?
-          if node.type == :const
-            [node.children[1]]
-          else
-            scope + [node.children[1]]
+      def self.scoped_name(node, scope)
+        if node.type == :block
+          scoped_name(node.children[0], scope)
+        elsif [:lvar, :ivar, :cvar, :gvar, :const, :send, :casgn].include? node.type
+          if node.children[0].is_a? Symbol
+            [node.children[0]]
+          elsif node.children[0].is_a? AST::Node
+            scoped_name(node.children[0], scope) << node.children[1]
+          elsif node.children[0].nil?
+            if node.type == :const
+              [node.children[1]]
+            else
+              scope + [node.children[1]]
+            end
           end
+        else
+          [node.type]
         end
-      else
-        [node.type]
       end
     end
   end