starscope 1.1.2 → 1.2.0

data/lib/starscope/export.rb

@@ -0,0 +1,256 @@
+module Starscope::Export
+
+  CTAGS_DEFAULT_PATH='tags'
+  CSCOPE_DEFAULT_PATH='cscope.out'
+
+  class UnknownExportFormatError < StandardError; end
+
+  def export(format, path=nil)
+    case format
+    when :ctags
+      path ||= CTAGS_DEFAULT_PATH
+    when :cscope
+      path ||= CSCOPE_DEFAULT_PATH
+    else
+      raise 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.")
+  end
+
+  def export_to(format, io)
+    case format
+    when :ctags
+      export_ctags(io)
+    when :cscope
+      export_cscope(io)
+    else
+      raise UnknownExportFormatError
+    end
+  end
+
+  private
+
+  # cscope has this funky issue where it refuses to recognize function calls that
+  # happen outside of a function definition - this isn't an issue in C, where all
+  # calls must occur in a function, but in ruby et al. it is perfectly legal to
+  # write normal code outside the "scope" of a function definition - we insert a
+  # fake shim "global" function everywhere we can to work around this
+  CSCOPE_GLOBAL_HACK_START = "\n\t$-\n"
+  CSCOPE_GLOBAL_HACK_STOP = "\n\t}\n"
+
+  def export_ctags(file)
+    file.puts <<END
+!_TAG_FILE_FORMAT	2	/extended format/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Evan Huus /eapache@gmail.com/
+!_TAG_PROGRAM_NAME	Starscope //
+!_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.each do |record|
+      file.puts ctag_line(record, @meta[:files][record[:file]])
+    end
+  end
+
+  # ftp://ftp.eeng.dcu.ie/pub/ee454/cygwin/usr/share/doc/mlcscope-14.1.8/html/cscope.html
+  def export_cscope(file)
+    buf = ""
+    files = []
+    db_by_line().each do |filename, lines|
+      next if lines.empty?
+
+      buf << "\t@#{filename}\n\n"
+      buf << "0 #{CSCOPE_GLOBAL_HACK_START}\n"
+      files << filename
+      func_count = 0
+
+      lines.sort.each do |line_no, records|
+        line = line_for_record(records.first)
+        toks = tokenize_line(line, records)
+        next if toks.empty?
+
+        prev = 0
+        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
+          # have them at all. Skipping tokens is easy; since prev isn't updated
+          # they get turned into plain text automatically.
+          if record[:type] == :func
+            case record[:tbl]
+            when :defs
+              func_count += 1
+              next unless func_count == 1
+            when :end
+              func_count -= 1
+              next unless func_count == 0
+            end
+          end
+
+          buf << CSCOPE_GLOBAL_HACK_STOP if record[:type] == :func && record[:tbl] == :defs
+          buf << cscope_plaintext(line, prev, offset) << "\n"
+          buf << cscope_mark(record[:tbl], record) << record[:key] << "\n"
+          buf << CSCOPE_GLOBAL_HACK_START if record[:type] == :func && record[:tbl] == :end
+
+          prev = offset + record[:key].length
+
+        end
+        buf << cscope_plaintext(line, prev, line.length) << "\n\n"
+      end
+    end
+
+    buf << "\t@\n"
+
+    header = "cscope 15 #{Dir.pwd} -c "
+    offset = "%010d\n" % (header.length + 11 + buf.bytes.count)
+
+    file.print(header)
+    file.print(offset)
+    file.print(buf)
+
+    file.print("#{@meta[:paths].length}\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"}
+    file.print("#{buf.length}\n#{buf}")
+  end
+
+  def db_by_line()
+    db = {}
+    @tables.each do |tbl, records|
+      records.each do |record|
+        next if not record[:line_no]
+        record[:tbl] = tbl
+        db[record[:file]] ||= {}
+        db[record[:file]][record[:line_no]] ||= []
+        db[record[:file]][record[:line_no]] << record
+      end
+    end
+    return db
+  end
+
+  def tokenize_line(line, records)
+    toks = {}
+
+    records.each do |record|
+      key = record[:name][-1].to_s
+
+      # use the column if we have it, otherwise fall back to scanning
+      index = record[:col] || line.index(key)
+
+      # keep scanning if our current index doesn't actually match the key, or if
+      # either the preceeding or succeeding character is a word character
+      # (meaning we've accidentally matched the middle of some other token)
+      while !index.nil? &&
+        ((line[index, key.length] != key) ||
+         (index > 0 && line[index-1] =~ /\w/) ||
+         (index+key.length < line.length && line[index+key.length] =~ /\w/))
+        index = line.index(key, index+1)
+      end
+
+      next if index.nil?
+
+      # Strip trailing non-word characters, otherwise cscope barfs on
+      # function names like `include?`
+      if key =~ /^\W*$/
+        next unless [:defs, :end].include?(record[:tbl])
+      else
+        key.sub!(/\W+$/, '')
+      end
+
+      record[:key] = key
+      toks[index] = record
+
+    end
+
+    return toks.sort
+  end
+
+  def cscope_plaintext(line, start, stop)
+    ret = line.slice(start, stop-start)
+    ret.lstrip! if start == 0
+    ret.rstrip! if stop == line.length
+    ret.gsub(/\s+/, ' ')
+  rescue ArgumentError
+    # invalid utf-8 byte sequence in the line, oh well
+    line
+  end
+
+  def cscope_mark(tbl, rec)
+    case tbl
+    when :end
+      case rec[:type]
+      when :func
+        ret = "}"
+      else
+        return ""
+      end
+    when :file
+      ret = "@"
+    when :defs
+      case rec[:type]
+      when :func
+        ret = "$"
+      when :class, :module
+        ret = "c"
+      when :type
+        ret = "t"
+      else
+        ret = "g"
+      end
+    when :calls
+      ret = "`"
+    when :requires
+      ret = "~\""
+    when :imports
+      ret = "~<"
+    when :assigns
+      ret = "="
+    else
+      return ""
+    end
+
+    return "\t" + ret
+  end
+
+  def ctag_line(rec, file)
+    ret = "#{rec[:name][-1]}\t#{rec[:file]}\t/^#{line_for_record(rec)}$/"
+
+    ext = ctag_ext_tags(rec, file)
+    if not ext.empty?
+      ret << ";\""
+      ext.sort.each do |k, v|
+        ret << "\t#{k}:#{v}"
+      end
+    end
+
+    ret
+  end
+
+  def ctag_ext_tags(rec, file)
+    tag = {}
+
+    # these extensions are documented at http://ctags.sourceforge.net/FORMAT
+    case rec[:type]
+    when :func
+      tag["kind"] = "f"
+    when :module, :class
+      tag["kind"] = "c"
+    end
+
+    tag["language"] = file[:lang]
+
+    tag
+  end
+
+end

data/lib/starscope/langs/coffeescript.rb

@@ -1,5 +1,6 @@
-module StarScope::Lang
+module Starscope::Lang
   module Coffeescript
+    VERSION = 0
 
     def self.match_file(name)
       name.end_with?(".coffee")

data/lib/starscope/langs/go.rb

@@ -1,5 +1,7 @@
-module StarScope::Lang
+module Starscope::Lang
   module Go
+    VERSION = 1
+
     FUNC_CALL = /([\w\.]*?\w)\(/
     END_OF_BLOCK = /^\s*\}\s*$/
     END_OF_GROUP = /^\s*\)\s*$/
@@ -43,7 +45,8 @@ module StarScope::Lang
           # strip string literals like "foo" unless they're part of an import
           pos = 0
           while match = STRING_LITERAL.match(line[pos..-1])
-            line = line[0...pos] + match.pre_match + "\"\"" + match.post_match
+            eos = find_end_of_string(line, match.begin(0))
+            line = line[0..match.begin(0)] + line[eos..-1]
             pos += match.begin(0) + 2
           end
         end
@@ -188,5 +191,20 @@ module StarScope::Lang
       stack.pop
       scope.pop
     end
+
+    def self.find_end_of_string(line, start)
+      escape = false
+      (start+1...line.length).each do |i|
+        if escape
+          escape = false
+        elsif line[i].chr == '\\'
+          escape = true
+        elsif line[i].chr == '"'
+          return i
+        end
+      end
+
+      return line.length
+    end
   end
 end

data/lib/starscope/langs/ruby.rb

@@ -1,7 +1,9 @@
 require "parser/current"
 
-module StarScope::Lang
+module Starscope::Lang
   module Ruby
+    VERSION = 1
+
     def self.match_file(name)
       return true if name.end_with?(".rb")
       File.open(name) do |f|
@@ -18,97 +20,84 @@ module StarScope::Lang
         ast = Parser::CurrentRuby.parse_file(file)
       rescue
       else
-        Extractor.new(ast).extract &block
+        extract_tree(ast, [], &block) if not ast.nil?
       end
     end
 
     private
 
-    class Extractor
-      def initialize(ast)
-        @ast = ast
-        @scope = []
-      end
+    def self.extract_tree(tree, scope, &block)
+      extract_node(tree, scope, &block)
 
-      def extract(&block)
-        extract_tree(@ast, &block) if not @ast.nil?
+      new_scope = []
+      if [:class, :module].include? tree.type
+        new_scope = scoped_name(tree.children[0], scope)
+        scope += new_scope
       end
 
-      private
+      tree.children.each {|node| extract_tree(node, scope, &block) if node.is_a? AST::Node}
 
-      def extract_tree(tree, &block)
-        extract_node tree, &block
-
-        new_scope = []
-        if [:class, :module].include? tree.type
-          new_scope = scoped_name(tree.children[0])
-          @scope += new_scope
-        end
-
-        tree.children.each {|node| extract_tree node, &block if node.is_a? AST::Node}
-
-        @scope.pop(new_scope.count)
-      end
+      scope.pop(new_scope.count)
+    end
 
-      def extract_node(node)
-        loc = node.location
+    def self.extract_node(node, scope)
+      loc = node.location
 
-        case node.type
-        when :send
-          name = scoped_name(node)
-          yield :calls, name, :line_no => loc.line, :col => loc.column
+      case node.type
+      when :send
+        name = scoped_name(node, scope)
+        yield :calls, name, :line_no => loc.line, :col => loc.column
 
-          if name.last.to_s =~ /\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? and node.children[1] == :require and node.children[2].type == :str
-            yield :requires, node.children[2].children[0].split("/"),
-              :line_no => loc.line, :col => loc.column
-          end
+        if name.last.to_s =~ /\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? and node.children[1] == :require and 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 :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 :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]),
-            :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 :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
-          fqn = scoped_name(node)
-          yield :assigns, fqn, :line_no => loc.line, :col => loc.name.column
-          yield :defs, fqn, :line_no => loc.line, :col => loc.name.column
+      when :casgn
+        fqn = scoped_name(node, scope)
+        yield :assigns, fqn, :line_no => loc.line, :col => loc.name.column
+        yield :defs, fqn, :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
-        end
+      when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+        yield :assigns, scope + [node.children[0]], :line_no => loc.line, :col => loc.name.column
       end
+    end
 
-      def scoped_name(node)
-        if node.type == :block
-          scoped_name(node.children[0])
-        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]) << node.children[1]
-          elsif node.children[0].nil?
-            if node.type == :const
-              [node.children[1]]
-            else
-              @scope + [node.children[1]]
-            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]]
           end
-        else
-          [node.type]
         end
+      else
+        [node.type]
       end
     end
   end