starscope 1.3.3 → 1.4.0

data/lib/starscope/exportable.rb

@@ -1,25 +1,24 @@
 module Starscope::Exportable
-
-  CTAGS_DEFAULT_PATH='tags'
-  CSCOPE_DEFAULT_PATH='cscope.out'
+  CTAGS_DEFAULT_PATH = 'tags'
+  CSCOPE_DEFAULT_PATH = 'cscope.out'
 
   class UnknownExportFormatError < StandardError; end
 
-  def export(format, path=nil)
+  def export(format, path = nil)
     case format
     when :ctags
       path ||= CTAGS_DEFAULT_PATH
     when :cscope
       path ||= CSCOPE_DEFAULT_PATH
     else
-      raise UnknownExportFormatError
+      fail UnknownExportFormatError
     end
 
     @output.normal("Exporting to '#{path}' in format '#{format}'...")
     File.open(path, 'w') do |file|
       export_to(format, file)
     end
-    @output.normal("Export complete.")
+    @output.normal('Export complete.')
   end
 
   def export_to(format, io)
@@ -29,7 +28,7 @@ module Starscope::Exportable
     when :cscope
       export_cscope(io)
     else
-      raise UnknownExportFormatError
+      fail UnknownExportFormatError
     end
   end
 
@@ -44,7 +43,7 @@ module Starscope::Exportable
 !_TAG_PROGRAM_URL	https://github.com/eapache/starscope //
 !_TAG_PROGRAM_VERSION	#{Starscope::VERSION}	//
 END
-    defs = (@tables[:defs] || {}).sort_by {|x| x[:name][-1].to_s}
+    defs = (@tables[:defs] || {}).sort_by { |x| x[:name][-1].to_s }
     defs.each do |record|
       file.puts ctag_line(record, @meta[:files][record[:file]])
     end
@@ -55,7 +54,7 @@ END
     ret = "#{rec[:name][-1]}\t#{rec[:file]}\t/^#{line}$/"
 
     ext = ctag_ext_tags(rec, file)
-    if not ext.empty?
+    unless ext.empty?
       ret << ";\""
       ext.sort.each do |k, v|
         ret << "\t#{k}:#{v}"
@@ -71,12 +70,12 @@ END
     # these extensions are documented at http://ctags.sourceforge.net/FORMAT
     case rec[:type]
     when :func
-      tag["kind"] = "f"
+      tag['kind'] = 'f'
     when :module, :class
-      tag["kind"] = "c"
+      tag['kind'] = 'c'
     end
 
-    tag["language"] = file[:lang]
+    tag['language'] = file[:lang]
 
     tag
   end
@@ -91,9 +90,9 @@ END
 
   # ftp://ftp.eeng.dcu.ie/pub/ee454/cygwin/usr/share/doc/mlcscope-14.1.8/html/cscope.html
   def export_cscope(file)
-    buf = ""
+    buf = ''
     files = []
-    db_by_line().each do |filename, lines|
+    db_by_line.each do |filename, lines|
       next if lines.empty?
 
       buf << "\t@#{filename}\n\n"
@@ -107,9 +106,8 @@ END
         next if toks.empty?
 
         prev = 0
-        buf << line_no.to_s << " "
+        buf << line_no.to_s << ' '
         toks.each do |offset, record|
-
           next if offset < prev # this probably indicates an extractor bug
 
           # Don't export nested functions, cscope barfs on them since C doesn't
@@ -128,7 +126,6 @@ END
 
           buf << cscope_output(line, prev, offset, record)
           prev = offset + record[:key].length
-
         end
         buf << cscope_plaintext(line, prev, line.length) << "\n\n"
       end
@@ -144,19 +141,19 @@ END
     file.print(buf)
 
     file.print("#{@meta[:paths].length}\n")
-    @meta[:paths].each {|p| file.print("#{p}\n")}
+    @meta[:paths].each { |p| file.print("#{p}\n") }
     file.print("0\n")
     file.print("#{files.length}\n")
-    buf = ""
-    files.each {|f| buf << f + "\n"}
+    buf = ''
+    files.each { |f| buf << f + "\n" }
     file.print("#{buf.length}\n#{buf}")
   end
 
-  def db_by_line()
+  def db_by_line
     db = {}
     @tables.each do |tbl, records|
       records.each do |record|
-        next if not record[:line_no]
+        next unless record[:line_no]
         record[:tbl] = tbl
         db[record[:file]] ||= {}
         db[record[:file]][record[:line_no]] ||= []
@@ -176,7 +173,7 @@ END
       index = record[:col] || line.index(key)
 
       while index && !valid_index?(line, index, key)
-        index = line.index(key, index+1)
+        index = line.index(key, index + 1)
       end
 
       next if index.nil?
@@ -197,7 +194,7 @@ END
   end
 
   def cscope_output(line, prev, offset, record)
-    buf = ""
+    buf = ''
     buf << CSCOPE_GLOBAL_HACK_STOP if record[:type] == :func && record[:tbl] == :defs
 
     record[:name][0...-1].each do |key|
@@ -207,11 +204,11 @@ END
 
       index = line.index(key, prev)
 
-      while index && index+key.length < offset && !valid_index?(line, index, key)
-        index = line.index(key, index+1)
+      while index && index + key.length < offset && !valid_index?(line, index, key)
+        index = line.index(key, index + 1)
       end
 
-      if index && index+key.length < offset
+      if index && index + key.length < offset
         buf << cscope_plaintext(line, prev, index) << "\n"
         buf << "#{key}\n"
         prev = index + key.length
@@ -231,12 +228,12 @@ END
   def valid_index?(line, index, key)
     # index is valid if the key exists at it, and the prev/next chars are not word characters
     ((line[index, key.length] == key) &&
-     (index == 0 || line[index-1] !~ /\w/) &&
-     (index+key.length == line.length || line[index+key.length] !~ /\w/))
+     (index == 0 || line[index - 1] !~ /\w/) &&
+     (index + key.length == line.length || line[index + key.length] !~ /\w/))
   end
 
   def cscope_plaintext(line, start, stop)
-    ret = line.slice(start, stop-start)
+    ret = line.slice(start, stop - start)
     ret.lstrip! if start == 0
     ret.rstrip! if stop == line.length
     ret.gsub(/\s+/, ' ')
@@ -250,33 +247,33 @@ END
     when :end
       case rec[:type]
       when :func
-        ret = "}"
+        ret = '}'
       else
-        return ""
+        return ''
       end
     when :file
-      ret = "@"
+      ret = '@'
     when :defs
       case rec[:type]
       when :func
-        ret = "$"
+        ret = '$'
       when :class, :module
-        ret = "c"
+        ret = 'c'
       when :type
-        ret = "t"
+        ret = 't'
       else
-        ret = "g"
+        ret = 'g'
       end
     when :calls
-      ret = "`"
+      ret = '`'
     when :requires
       ret = "~\""
     when :imports
-      ret = "~<"
+      ret = '~<'
     when :assigns
-      ret = "="
+      ret = '='
     else
-      return ""
+      return ''
     end
 
     "\t" + ret

data/lib/starscope/fragment_extractor.rb

@@ -0,0 +1,22 @@
+class Starscope::FragmentExtractor
+  def initialize(lang, frags)
+    @child = Starscope::Lang.const_get(lang)
+    @frags = frags
+  end
+
+  def extract(path, text)
+    text = @frags.map { |f| f.delete(:frag).strip }.join("\n")
+
+    extractor_metadata = @child.extract(path, text) do |tbl, name, args|
+      args.merge!(@frags[args[:line_no] - 1]) if args[:line_no]
+      yield tbl, name, args
+    end
+
+    # TODO: translate metadata?
+    extractor_metadata
+  end
+
+  def name
+    @child.name
+  end
+end

data/lib/starscope/langs/erb.rb

@@ -0,0 +1,45 @@
+module Starscope::Lang
+  module ERB
+    VERSION = 1
+
+    ERB_START = /<%(?:-|={1,4})?/
+    ERB_END = /-?%>/
+
+    def self.match_file(name)
+      name.end_with?('.erb')
+    end
+
+    def self.extract(path, contents, &block)
+      multiline = false # true when parsing a multiline <% ... %> block
+
+      contents.lines.each_with_index do |line, line_no|
+        line_no += 1 # zero-index to one-index
+
+        if multiline
+          term = line.index(ERB_END)
+          if term
+            yield FRAGMENT, :Ruby, :frag => line[0...term], :line_no => line_no
+            line = line[term + 1..-1]
+            multiline = false
+          else
+            yield FRAGMENT, :Ruby, :frag => line, :line_no => line_no
+          end
+        end
+
+        unless multiline
+          line.scan(/#{ERB_START}(.*?)#{ERB_END}/) do |match|
+            yield FRAGMENT, :Ruby, :frag => match[0], :line_no => line_no
+          end
+
+          line.gsub!(/<%.*?%>/, '')
+
+          match = /#{ERB_START}(.*)$/.match(line)
+          if match
+            yield FRAGMENT, :Ruby, :frag => match[1], :line_no => line_no
+            multiline = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/starscope/langs/go.rb

@@ -6,42 +6,39 @@ module Starscope::Lang
     END_OF_BLOCK = /^\s*\}\s*$/
     END_OF_GROUP = /^\s*\)\s*$/
     STRING_LITERAL = /".+?"/
-    BUILTIN_FUNCS = ['new', 'make', 'len', 'close', 'copy', 'delete',
-                     'int', 'int8', 'int16', 'int32', 'int64',
-                     'uint', 'uint8', 'uint16', 'uint32', 'uint64',
-                     'string', 'byte']
-    CONTROL_KEYS = ['if', 'for', 'switch', 'case']
+    BUILTIN_FUNCS = %w(new make len close copy delete int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 string byte)
+    CONTROL_KEYS = %w(if for switch case)
 
     def self.match_file(name)
-      name.end_with?(".go")
+      name.end_with?('.go')
     end
 
-    def self.extract(file, &block)
+    def self.extract(path, contents, &block)
       stack = []
       scope = []
-      File.readlines(file).each_with_index do |line, line_no|
+      contents.lines.each_with_index do |line, line_no|
         line_no += 1 # zero-index to one-index
 
         # strip single-line comments like // foo
-        match = /\/\//.match(line)
+        match = %r{//}.match(line)
         line = match.pre_match if match
         # strip single-line comments like foo /* foo */ foo
-        match = /\/\*.*\*\//.match(line)
+        match = %r{/\*.*\*/}.match(line)
         line = match.pre_match + match.post_match if match
         # strip end-of-line comment starters like foo /* foo \n
-        match = /\/\*/.match(line)
+        match = %r{/\*}.match(line)
         line = match.pre_match if match
         ends_with_comment = !match.nil?
 
         # if we're in a block comment, wait for it to end
         if stack[-1] == :comment
-          match = /\*\/(.*)/.match(line)
+          match = %r{\*/(.*)}.match(line)
           next unless match
           line = match[1]
           stack.pop
         end
 
-        if stack[-1] != :import && !line.start_with?("import")
+        if stack[-1] != :import && !line.start_with?('import')
           # strip string literals like "foo" unless they're part of an import
           pos = 0
           while match = STRING_LITERAL.match(line[pos..-1])
@@ -58,21 +55,21 @@ module Starscope::Lang
           when END_OF_BLOCK
             end_block(line_no, scope, stack, &block)
           when /(.+)\s+\w+/
-            parse_def($1, line_no, scope, &block)
+            parse_def(Regexp.last_match(1), line_no, scope, &block)
           end
         when :interface
           case line
           when END_OF_BLOCK
             end_block(line_no, scope, stack, &block)
           when /(\w+)\(.*\)\s+/
-            yield :defs, scope + [$1], :line_no => line_no
+            yield :defs, scope + [Regexp.last_match(1)], :line_no => line_no
           end
         when :def
           case line
           when END_OF_GROUP
             stack.pop
           when /(.+)\s*=.*/
-            parse_def($1, line_no, scope, &block)
+            parse_def(Regexp.last_match(1), line_no, scope, &block)
             parse_call(line, line_no, scope, &block)
           else
             parse_def(line, line_no, scope, &block)
@@ -82,13 +79,13 @@ module Starscope::Lang
           when END_OF_GROUP
             stack.pop
           when /"(.+)"/
-            name = $1.split('/')
+            name = Regexp.last_match(1).split('/')
             yield :imports, name, :line_no => line_no
           end
         when :func
           case line
           when /^\}/
-            yield :end, "}", :line_no => line_no, :type => :func
+            yield :end, '}', :line_no => line_no, :type => :func
             stack.pop
           else
             parse_new_line(line, line_no, scope, stack, &block)
@@ -99,9 +96,7 @@ module Starscope::Lang
 
         # if the line looks like "foo /* foo" then we enter the comment state
         # after parsing the usable part of the line
-        if ends_with_comment
-          stack.push(:comment)
-        end
+        stack.push(:comment) if ends_with_comment
       end
     end
 
@@ -109,44 +104,44 @@ module Starscope::Lang
     def self.parse_new_line(line, line_no, scope, stack, &block)
       case line
       when /^func\s+(\w+)\(/
-        yield :defs, scope + [$1], :line_no => line_no, :type => :func
+        yield :defs, scope + [Regexp.last_match(1)], :line_no => line_no, :type => :func
         stack.push(:func)
       when /^func\s+\(\w+\s+\*?(\w+)\)\s*(\w+)\(/
-        yield :defs, scope + [$1, $2], :line_no => line_no, :type => :func
+        yield :defs, scope + [Regexp.last_match(1), Regexp.last_match(2)], :line_no => line_no, :type => :func
         stack.push(:func)
       when /^package\s+(\w+)/
-        scope.push($1)
+        scope.push(Regexp.last_match(1))
         yield :defs, scope, :line_no => line_no, :type => :package
       when /^type\s+(\w+)\s+struct\s*\{/
-        scope.push($1)
+        scope.push(Regexp.last_match(1))
         stack.push(:struct)
         yield :defs, scope, :line_no => line_no, :type => :class
       when /^type\s+(\w+)\s+interface\s*\{/
-        scope.push($1)
+        scope.push(Regexp.last_match(1))
         stack.push(:interface)
         yield :defs, scope, :line_no => line_no, :type => :class
       when /^type\s+(\w+)/
-        yield :defs, scope + [$1], :line_no => line_no, :type => :type
+        yield :defs, scope + [Regexp.last_match(1)], :line_no => line_no, :type => :type
       when /^import\s+"(.+)"/
-        name = $1.split('/')
+        name = Regexp.last_match(1).split('/')
         yield :imports, name, :line_no => line_no
       when /^import\s+\(/
         stack.push(:import)
       when /^var\s+\(/
         stack.push(:def)
       when /^var\s+(\w+)\s/
-        yield :defs, scope + [$1], :line_no => line_no
+        yield :defs, scope + [Regexp.last_match(1)], :line_no => line_no
         parse_call(line, line_no, scope, &block)
       when /^const\s+\(/
         stack.push(:def)
       when /^const\s+(\w+)\s/
-        yield :defs, scope + [$1], :line_no => line_no
+        yield :defs, scope + [Regexp.last_match(1)], :line_no => line_no
         parse_call(line, line_no, scope, &block)
       when /^\s+(.*?) :?=[^=]/
-        $1.split(' ').each do |var|
+        Regexp.last_match(1).split(' ').each do |var|
           next if CONTROL_KEYS.include?(var)
           name = var.delete(',').split('.')
-          next if name[0] == "_" # assigning to _ is a discard in golang
+          next if name[0] == '_' # assigning to _ is a discard in golang
           if name.length == 1
             yield :assigns, scope + [name[0]], :line_no => line_no
           else
@@ -161,7 +156,7 @@ module Starscope::Lang
 
     def self.parse_call(line, line_no, scope)
       line.scan(FUNC_CALL) do |match|
-        name = match[0].split('.').select {|chunk| not chunk.empty?}
+        name = match[0].split('.').select { |chunk| !chunk.empty? }
         if name.length == 1
           next if name[0] == 'func'
           if BUILTIN_FUNCS.include?(name[0])
@@ -178,23 +173,23 @@ module Starscope::Lang
     def self.parse_def(line, line_no, scope)
       # if it doesn't start with a valid identifier character, it's probably
       # part of a multi-line literal and we should skip it
-      return if not line =~ /^\s*[[:alpha:]_]/
+      return unless line =~ /^\s*[[:alpha:]_]/
 
       line.split.each do |var|
         yield :defs, scope + [var.delete(',')], :line_no => line_no
-        break if not var.end_with?(',')
+        break unless var.end_with?(',')
       end
     end
 
     def self.end_block(line_no, scope, stack)
-      yield :end, scope + ["}"], :line_no => line_no, :type => :class
+      yield :end, scope + ['}'], :line_no => line_no, :type => :class
       stack.pop
       scope.pop
     end
 
     def self.find_end_of_string(line, start)
       escape = false
-      (start+1...line.length).each do |i|
+      (start + 1...line.length).each do |i|
         if escape
           escape = false
         elsif line[i].chr == '\\'
@@ -204,7 +199,7 @@ module Starscope::Lang
         end
       end
 
-      return line.length
+      line.length
     end
   end
 end