code-explorer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb4f5f3aec4c52c667605028d891dccf6bab2b6d
+  data.tar.gz: c3590e42ee2bf91facc0553fee487c19873b884c
+SHA512:
+  metadata.gz: 7757f66ac7088828f58beb5ddcfb84f84dd415e5680c5493a1f3bcc23e22c6e602b3f59a2aaf38eafe1eb641f289d1a10ae8dc8170d8078a55049119bc745436
+  data.tar.gz: d0e8a1630fdf7a037ffbced5fa1bf7daad69990d33377cc4daa8c41965e9b0632804784924e559a475a3154b670a0b031b0824701e312a4fc89594272762aa92

data/README.md

@@ -0,0 +1,42 @@
+# Call Graph
+
+This makes a call graph among methods of a single Ruby file.
+
+I made it to help me orient myself in unfamiliar legacy code and to help
+identify cohesive parts that could be split out.
+
+Yes, it is quick and dirty.
+
+## Requirements
+
+- [parser gem](https://github.com/whitequark/parser)
+- [Graphviz](http://www.graphviz.org/)
+
+## License
+
+MIT
+
+## Running from Source
+
+```sh
+bundle install --path vendor/bundle
+bundle exec bin/code-explorer  # otherwise Sinatra will not start
+```
+
+## Example
+
+[One file in YaST][p-rb] has around 2700 lines and 73 methods. The call graph
+below was made with
+```console
+$ bin/call-graph ../yast/packager/src/modules/Packages.rb
+$ dot -Tpng -oPackages.png ../yast/packager/src/modules/Packages.dot
+```
+
+If the resulting size is too big, use ImageMagick:
+```console
+$ convert Packages.png -resize 1200 Packages-small.png
+```
+
+[p-rb]: https://github.com/yast/yast-packager/blob/a0b38c046e6e4086a986047d0d7cd5d155af5024/src/modules/Packages.rb
+
+![Packages.png, an example output](example.png)

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/call-graph

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby
+
+# method dependency graph
+
+$: << File.expand_path("../lib", __FILE__)
+
+require "code_explorer/call_graph"
+
+filename_rb = ARGV[0]
+dot = call_graph(filename_rb)
+filename_dot = filename_rb.sub(/\.rb$/, "") + ".dot"
+File.write(filename_dot, dot)

data/bin/class-dependencies

@@ -0,0 +1,177 @@
+#!/usr/bin/ruby
+
+# class dependency graph
+
+require "parser/current"
+require "pp"
+
+require "code_explorer/dot"
+
+def main
+  asts = ARGV.map {|fn| ast_for_filename(fn)}
+  cs = Consts.new
+  cs.report_modules(asts)
+  graph = cs.superclasses
+  puts dot_from_hash(graph)
+end
+
+def ast_for_filename(fn)
+  ruby = File.read(fn)
+  Parser::CurrentRuby.parse(ruby)
+end
+
+# ruby [String] a ruby program
+# @return a dot graph string
+def dep_graph(ast)
+  Consts.new.report_modules(ast)
+  dot_from_hash({})
+end
+
+# tracks what constants are resolvable
+class ConstBinding
+  def initialize(fqname, parent = nil)
+    @fqname = fqname
+    @parent = parent
+    @known = {}
+  end
+
+  # @return [ConstBinding] the new scope
+  def open_namespace(fqname)
+    ns = @known[fqname]
+    if ns.is_a? ConstBinding
+      # puts "(reopening #{fqname})"
+    else
+      ns = self.class.new(fqname, self)
+      @known[fqname] = ns
+    end
+    ns
+  end
+
+  # @return [ConstBinding] the parent scope
+  def close_namespace
+    @parent
+  end
+
+  def declare_const(fqname)
+    if @known[fqname]
+#      puts "warning: #{fqname} already declared"
+    end
+    @known[fqname] = :const
+  end
+
+  def resolve_declared_const(name)
+    if @fqname.empty?
+      name
+    else
+      "#{@fqname}::#{name}"
+    end
+  end
+
+  def resolve_used_const(name)
+#    puts "resolving #{name} in #{@fqname}, known #{@known.inspect}"
+    candidate = resolve_declared_const(name)
+    if @known.include?(candidate)
+      candidate
+    elsif @parent
+      @parent.resolve_used_const(name)
+    else
+      name
+    end
+  end
+end
+
+class Consts < Parser::AST::Processor
+  include AST::Sexp
+
+  # @return [ConstBinding]
+  attr_reader :cb
+  # @return [Hash{String => Array<String>}]
+  attr_reader :superclasses
+
+  def initialize
+    @cb = ConstBinding.new("")
+    @superclasses = {}
+  end
+
+  def report_modules(asts)
+    Array(asts).each do |ast|
+      process(ast)
+    end
+  end
+
+  def const_name_from_sexp(node)
+    case node.type
+    when :self
+      "self"
+    when :cbase
+      ""
+    when :const, :casgn
+      parent, name, _maybe_value = *node
+      if parent
+        const_name_from_sexp(parent) + "::#{name}"
+      else
+        name.to_s
+      end
+    else
+      raise "Unexpected #{node.type}"
+    end
+  end
+
+  def new_scope(name, &block)
+    @cb = cb.open_namespace(name)
+    block.call
+    @cb = cb.close_namespace
+  end
+
+  def on_module(node)
+    name, _body = *node
+    name = cb.resolve_declared_const(const_name_from_sexp(name))
+#    puts "module #{name}"
+
+    new_scope(name) do
+      super
+    end
+  end
+
+  def on_class(node)
+    name, parent, _body = *node
+    parent ||= s(:const, s(:cbase), :Object)
+
+    name   = cb.resolve_declared_const(const_name_from_sexp(name))
+    parent = cb.resolve_used_const(const_name_from_sexp(parent))
+#    puts "class #{name} < #{parent}"
+
+    @superclasses[name] = [parent]
+
+    new_scope(name) do
+      super
+    end
+  end
+
+  def on_sclass(node)
+    parent, _body = *node
+
+    parent = const_name_from_sexp(parent)
+    name = "<< #{parent}" # cheating
+#    puts "class #{name}"
+
+    new_scope(name) do
+      super
+    end
+  end
+
+  def on_casgn(node)
+    name = cb.resolve_declared_const(const_name_from_sexp(node))
+    cb.declare_const(name)
+#    puts "casgn #{name}"
+  end
+
+  def on_const(node)
+    name = const_name_from_sexp(node)
+    fqname = cb.resolve_used_const(name)
+#    puts "CONST #{fqname}"
+  end
+
+end
+
+main

data/bin/code-explorer

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby
+
+require "sinatra"
+require "cheetah"
+
+require "code_explorer/call_graph"
+require "code_explorer/numbered_lines"
+
+def path_link(prefix, path, text)
+    "<a href='#{prefix}/#{path}'>#{text}</a>"
+end
+
+configure do
+  mime_type :png, "image/png"
+  mime_type :svg, "image/svg+xml"
+end
+
+get "/" do
+  files = Dir.glob("**/*.rb").sort
+  files.map do |f|
+    path_link("/files", f, f) + " " +
+      path_link("/call-graph", f, "call graph")
+  end.join("<br>\n")
+end
+
+get "/files/*" do |path|
+  numbered_lines(File.read(path))
+#  send_file path, :type => :text
+end
+
+get "/call-graph/*" do |path|
+  dot = call_graph(path)
+
+  type = :svg
+  graph = Cheetah.run(["dot", "-T#{type}"], stdin: dot, stdout: :capture)
+
+  content_type type
+  graph
+end

data/bin/required-files

@@ -0,0 +1,11 @@
+#!/bin/sh
+# required-files ~/mygem/lib mygem
+# lists all files from mygem loaded when we "require mygem",
+# in the correct order
+INCLUDE=$1
+REQUIRE=$2
+strace -eopen ruby -I $INCLUDE -r $REQUIRE -e 1 |& \
+  grep -v ENOENT | \
+  grep $INCLUDE | \
+  uniq | \
+  sed -e 's/[^"]*"\([^"]*\)".*/\1/'

data/lib/code_explorer/call_graph.rb

@@ -0,0 +1,91 @@
+
+require "parser/current"
+require "pp"
+
+require_relative "dot"
+
+# filename_rb [String] file with a ruby program
+# @return a dot graph string
+def call_graph(filename_rb)
+  ruby = File.read(filename_rb)
+  ast = Parser::CurrentRuby.parse(ruby, filename_rb)
+  defs = defs_from_ast(ast)
+  def_names = defs.map {|d| def_name(d) }
+  defs_to_hrefs = defs.map {|d| [def_name(d), "/files/" + def_location(d)] }.to_h
+
+  defs_to_calls = {}
+  defs.each do |d|
+    calls = calls_from_def(d)
+    call_names = calls.map {|c| send_name(c)}
+    call_names = call_names.find_all{ |cn| def_names.include?(cn) }
+    defs_to_calls[def_name(d)] = call_names
+  end
+
+  dot_from_hash(defs_to_calls, defs_to_hrefs)
+end
+
+def def_name(node)
+  case node.type
+  when :def
+    name, _args, _body = *node
+  when :defs
+    _obj, name, _args, _body = *node
+  else
+    raise
+  end
+  name
+end
+
+def def_location(node)
+  range = node.loc.expression
+  file = range.source_buffer.name
+  line = range.line
+  "#{file}#line=#{line}"
+end
+
+def send_name(node)
+  _receiver, name, *_args = *node
+  name
+end
+
+class Defs < Parser::AST::Processor
+  def initialize
+    @defs = []
+    @sends = []
+  end
+
+  def defs_from_ast(ast)
+    @defs = []
+    process(ast)
+    @defs
+  end
+
+  def sends_from_ast(ast)
+    @sends = []
+    process(ast)
+    @sends
+  end
+
+  def on_def(node)
+    @defs << node
+    super
+  end
+
+  def on_defs(node)
+    @defs << node
+    super
+  end
+
+  def on_send(node)
+    @sends << node
+    super
+  end
+end
+
+def defs_from_ast(ast)
+  Defs.new.defs_from_ast(ast)
+end
+
+def calls_from_def(ast)
+  Defs.new.sends_from_ast(ast)
+end

data/lib/code_explorer/dot.rb

@@ -0,0 +1,20 @@
+
+# @param graph [Hash{String => Array<String>}] vertex -> reachable vertices
+# @param hrefs [Hash{String => String}]        vertex -> href
+def dot_from_hash(graph, hrefs = {})
+  dot = ""
+  dot << "digraph g {\n"
+  dot << "rankdir=LR;\n"
+  graph.keys.sort.each do |vertex|
+    href = hrefs[vertex]
+    href = "href=\"#{href}\" " if href
+
+    dot << "\"#{vertex}\"[#{href}];\n"
+    destinations = graph[vertex].sort
+    destinations.each do |d|
+      dot << "\"#{vertex}\" -> \"#{d}\";\n"
+    end
+  end
+  dot << "}\n"
+  dot
+end

data/lib/code_explorer/numbered_lines.rb

@@ -0,0 +1,18 @@
+
+# relies on escape_html
+
+# convert plain text to HTML where lines are hyperlinkable (emulate RFC 5147)
+def numbered_lines(text)
+  lines = text.lines
+  count_width = lines.count.to_s.size
+  lines.each_with_index.map do |line, i|
+    i += 1 # lines are counted from 1
+
+    show_line_num = i.to_s.rjust(count_width).gsub(" ", " ")
+    escaped_line = escape_html(line.chomp).gsub(" ", " ")
+    id = "line=#{i}" # RFC 5147 fragment identifier
+
+    "<tt><a id='#{id}' href='##{id}'>#{show_line_num}</a></tt> " \
+      "<code>#{escaped_line}</code><br>\n"
+  end.join("")
+end

data/lib/code_explorer/version.rb

@@ -0,0 +1,3 @@
+module CodeExplorer
+  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").strip
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: code-explorer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Vidner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: cheetah
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Find your way around source code written in Ruby
+email: martin@vidner.net
+executables:
+- call-graph
+- class-dependencies
+- code-explorer
+- required-files
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- VERSION
+- bin/call-graph
+- bin/class-dependencies
+- bin/code-explorer
+- bin/required-files
+- lib/code_explorer/call_graph.rb
+- lib/code_explorer/dot.rb
+- lib/code_explorer/numbered_lines.rb
+- lib/code_explorer/version.rb
+homepage: https://github.com/mvidner/code-explorer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Explore Ruby code
+test_files: []
+has_rdoc: