rubrowser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c00a8f96b4234e3126fb912dc5e16b91867db034
+  data.tar.gz: fe569abb2aca1ef762f8dae59d02d0517ae0d268
+SHA512:
+  metadata.gz: 57fbbf57070c4d09d6b24ed74d749f065c9bb3e6aaa713793e8f3566dae3d1187d9fec80ed5e6ddb46ae96800747febc9cb62a9168f7a2ad443f03583edd4893
+  data.tar.gz: efdde91ea7fbeeb5d8de14c3f7ec45d36d3bbc41b90e76c039120aa4f57700bc82e7d4e2881134065cb8753bf2dfd39cf752bfe528fe9524fe71ae5717a8962c

data/.gitignore

@@ -0,0 +1 @@
+tmp/

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    rubrowser (0.1.0)
+      haml (~> 4.0, >= 4.0.0)
+      parallel (~> 1.9, >= 1.9.0)
+      parser (~> 2.3, >= 2.3.0)
+      sinatra (~> 1.4, >= 1.4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    haml (4.0.7)
+      tilt
+    parallel (1.9.0)
+    parser (2.3.1.2)
+      ast (~> 2.2)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    sinatra (1.4.7)
+      rack (~> 1.5)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    tilt (2.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rubrowser!
+
+BUNDLED WITH
+   1.12.5

data/bin/rubrowser

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'server'
+Rubrowser::Server.start

data/lib/d3.rb

@@ -0,0 +1,33 @@
+module Rubrowser
+  class D3
+    def initialize(node)
+      @node = node
+    end
+
+    def constants
+      node_id(node)
+    end
+
+    def occurences
+      node_occurences(node)
+    end
+
+    private
+
+    attr_reader :node
+
+    def node_id(node)
+      node.children.map do |n|
+        node_id(n)
+      end.reduce(:+).to_a.push({ name: node.name, id: node.id })
+    end
+
+    def node_occurences(node)
+      occurences = []
+      occurences += node.children.map { |n| node_occurences(n) }.reduce(:+).to_a
+
+      occurences += node.occurences.map { |n| {source: node.id, target: n.id } }.to_a
+      occurences
+    end
+  end
+end

data/lib/data.rb

@@ -0,0 +1,51 @@
+require 'parser/factory'
+require 'tree'
+require 'd3'
+
+module Rubrowser
+  class Data
+    def self.instance
+      @_instance ||= new
+    end
+
+    def initialize
+      @files = ARGV
+      @parsed = false
+    end
+
+    def constants
+      @_constants ||= d3.constants.to_a
+    end
+
+    def occurences
+      @_occurences ||= d3.occurences.to_a
+    end
+
+    def parse
+      return if parsed?
+      parsers.each(&:parse)
+      @parsed = true
+    end
+
+    private
+
+    attr_reader :files, :parsed
+    alias parsed? parsed
+
+    def parsers
+      @_parsers ||= files.map do |file|
+        Rubrowser::Parser::Factory.build(file)
+      end
+    end
+
+    def d3
+      @_d3 ||= Rubrowser::D3.new(tree)
+    end
+
+    def tree
+      parse
+      @_tree ||= Rubrowser::Tree.from_parsers(parsers)
+    end
+
+  end
+end

data/lib/parser/directory.rb

@@ -0,0 +1,44 @@
+require 'parser/factory'
+require 'parallel'
+
+module Rubrowser
+  module Parser
+    class Directory
+      attr_reader :directory
+
+      def initialize(directory)
+        @directory = directory
+        @parsers = []
+        read
+      end
+
+      def parse
+        self.parsers = Parallel.map(parsers){ |parser| parser.parse }
+        self
+      end
+
+      def definitions
+        parsers.map(&:definitions).map(&:to_a).reduce(:+) || []
+      end
+
+      def occurences
+        parsers.map(&:occurences).map(&:to_a).reduce(:+) || []
+      end
+
+      def count
+        parsers.map(&:count).reduce(:+)
+      end
+
+      private
+
+      attr_accessor :parsers
+
+      def read
+        files = Dir.glob(::File.join(directory, '**', '*.rb'))
+        self.parsers = Parallel.map(files) do |file|
+          Factory.build(file)
+        end.compact
+      end
+    end
+  end
+end

data/lib/parser/factory.rb

@@ -0,0 +1,16 @@
+require 'parser/file'
+require 'parser/directory'
+
+module Rubrowser
+  module Parser
+    class Factory
+      def self.build(file)
+        if ::File.file?(file)
+          File.new(file)
+        elsif ::File.directory?(file)
+          Directory.new(file)
+        end
+      end
+    end
+  end
+end

data/lib/parser/file.rb

@@ -0,0 +1,101 @@
+require 'parser/current'
+
+module Rubrowser
+  module Parser
+    class File
+      FILE_SIZE_LIMIT = 2 * 1024 * 1024
+
+      attr_reader :file, :definitions, :occurences
+
+      def initialize(file)
+        @file = file
+        @definitions = Set.new
+        @occurences = []
+      end
+
+      def parse
+        if file_valid?(file)
+          ::File.open(file) do |f|
+            code = f.read
+            ast = ::Parser::CurrentRuby.parse(code)
+            constants = parse_block(ast)
+            self.definitions = constants[:definitions].uniq
+            self.occurences = constants[:occurences].uniq
+          end
+        end
+        self
+      end
+
+      def file_valid?(file)
+        !::File.symlink?(file) && ::File.file?(file) && ::File.size(file) <= FILE_SIZE_LIMIT
+      end
+
+      def count
+        1
+      end
+
+      private
+
+      attr_writer :definitions, :occurences
+
+      def parse_block(node, parents = [])
+        return { definitions: [], occurences: [] } unless node.is_a?(::Parser::AST::Node)
+
+        case node.type
+        when :module
+          parse_module(node, parents)
+        when :class
+          parse_class(node, parents)
+        when :const
+          parse_const(node, parents)
+        else
+          node
+            .children
+            .map { |n| parse_block(n, parents) }
+            .reduce { |a, e| merge_constants(a, e) } || { definitions: [], occurences: [] }
+        end
+      end
+
+      def parse_module(node, parents = [])
+        name = resolve_const_path(node.children.first, parents)
+        node
+          .children[1..-1]
+          .map { |n| parse_block(n, name) }
+          .reduce { |a, e| merge_constants(a, e) }
+          .tap { |constants| constants[:definitions].unshift(name) }
+      end
+
+      def parse_class(node, parents = [])
+        name = resolve_const_path(node.children.first, parents)
+        node
+          .children[1..-1]
+          .map { |n| parse_block(n, name) }
+          .reduce { |a, e| merge_constants(a, e) }
+          .tap { |constants| constants[:definitions].unshift(name) }
+      end
+
+      def parse_const(node, parents = [])
+        constant = resolve_const_path(node)
+        namespace = parents[0...-1]
+        constants = if namespace.empty? || constant.first.nil?
+                      [{ parents => [constant.compact] }]
+                    else
+                      [{ parents => (namespace.size-1).downto(0).map { |i| namespace[0..i] + constant }.push(constant) }]
+                    end
+        { definitions: [], occurences: constants }
+      end
+
+      def merge_constants(constants1, constants2)
+        {
+          definitions: constants1[:definitions] + constants2[:definitions],
+          occurences: constants1[:occurences] + constants2[:occurences]
+        }
+      end
+
+      def resolve_const_path(node, parents = [])
+        return parents unless node.is_a?(::Parser::AST::Node) && [:const, :cbase].include?(node.type)
+        resolve_const_path(node.children.first, parents) + [node.children.last]
+      end
+    end
+  end
+end

data/lib/rubrowser.rb

@@ -0,0 +1,3 @@
+module Rubrowser
+  VERSION = '0.1.0'.freeze
+end

data/lib/server.rb

@@ -0,0 +1,25 @@
+require 'sinatra/base'
+require 'data'
+require 'json'
+
+module Rubrowser
+  class Server < Sinatra::Base
+    get '/' do
+      data = Rubrowser::Data.instance
+      haml :index,
+           locals: {
+             constants: data.constants,
+             occurences: data.occurences
+           }
+    end
+
+    def self.start
+      Rubrowser::Data.instance.parse
+      Thread.new do
+        run! host: 'localhost',
+             port: 9000,
+             root: File.expand_path('../../', __FILE__)
+      end.join
+    end
+  end
+end

data/lib/tree.rb

@@ -0,0 +1,75 @@
+module Rubrowser
+  class Tree
+    attr_reader :name, :children, :occurences, :parent
+
+    def self.from_parsers(parsers)
+      return Tree.new if parsers.empty?
+
+      definitions = parsers.map(&:definitions).reduce(:+).uniq
+      occurences = parsers.map(&:occurences).reduce(:+).uniq
+      Tree.new.tap do |tree|
+        definitions.each { |definition| tree.add_child(definition) }
+        occurences.each { |occurence| tree.add_occurence(*occurence.first) }
+      end
+    end
+
+    def initialize(name = 'Kernel', parent = nil)
+      @name = name
+      @parent = parent
+      @children = Set.new
+      @occurences = Set.new
+    end
+
+    def root?
+      @parent.nil?
+    end
+
+    def id
+      return name if root? || parent.root?
+      "#{parent.id}::#{name}".to_sym
+    end
+
+    def add_child(child_name_path = [])
+      return if child_name_path.empty?
+      child = get_or_create_child(child_name_path[0])
+      children.add(child)
+      child.add_child(child_name_path[1..-1])
+    end
+
+    def add_occurence(user, constants)
+      user_node = find_node(user)
+      occured_node = constants.map { |constant| find_node(constant) }.compact.first
+      return unless user_node && occured_node
+      user_node.occurences << occured_node
+    end
+
+    def find_node(path)
+      return self if path.empty?
+      child = children.find { |c| c.name == path.first }
+      return unless child
+      child.find_node(path[1..-1])
+    end
+
+    def get_or_create_child(child_name)
+      children.find { |child| child_name == child.name } || Tree.new(child_name, self)
+    end
+
+    def eq?(other)
+      other.name == name
+    end
+
+    def to_h
+      {
+        id: id,
+        name: name
+      }.tap do |hash|
+        hash[:children] = children.map(&:to_h) unless children.empty?
+        hash[:occurences] = occurences.map(&:id) unless occurences.empty?
+      end
+    end
+
+    private
+
+    attr_writer :occurences
+  end
+end

data/public/css/application.css

@@ -0,0 +1,36 @@
+html, body{
+    width: 100%;
+    height: 100%;
+    padding: 0px;
+    margin: 0px;
+}
+.dependency_graph, .dependency_graph svg{
+    width: 100%;
+    height: 100%;
+}
+
+line{
+    stroke: #888;
+}
+
+.link {
+  fill: none;
+  stroke: #666;
+  stroke-width: 1.5px;
+}
+
+circle {
+  fill: #ccc;
+  stroke: #333;
+  stroke-width: 1.5px;
+}
+
+.fixed {
+  fill: #f00;
+}
+
+text {
+  font: 10px sans-serif;
+  pointer-events: none;
+  text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
+}

data/public/javascript/application.js

@@ -0,0 +1,121 @@
+var ParseGraph = function(){
+  var svg = d3.select(".dependency_graph svg");
+  var $svg = $('.dependency_graph svg');
+
+  if(!svg.size()){
+    return false;
+  }
+
+
+  var width = $svg.width(),
+      height = $svg.height(),
+      constants = JSON.parse(svg.attr('data-constants')),
+      occurences = JSON.parse(svg.attr('data-occurences'));
+  var color = d3.scaleOrdinal(d3.schemeCategory20);
+
+  var drag = d3.drag()
+        .on("start", dragstarted)
+        .on("drag", dragged)
+        .on("end", dragended);
+
+
+  svg.call(d3.zoom().on("zoom", function () {
+    container.attr("transform", d3.event.transform);
+  }));
+
+  container = svg.append('g');
+
+
+  var simulation = d3.forceSimulation()
+        .force("link", d3.forceLink().id(function(d) { return d.id; }))
+        .force("charge", d3.forceManyBody())
+        .force("center", d3.forceCenter(width / 2, height / 2))
+        .force("forceCollide", d3.forceCollide(function(){ return 80; }));
+
+  var link = container.append("g")
+        .attr("class", "links")
+        .selectAll("path")
+        .data(occurences)
+        .enter().append("path")
+        .attr("class", 'link')
+        .attr("marker-end", "url(#occurence)");
+
+  var circle = container.append("g").selectAll("circle")
+        .data(constants)
+        .enter().append("circle")
+        .attr("r", 6)
+        .on("dblclick", dblclick)
+        .call(drag);
+
+  var text = container.append("g").selectAll("text")
+        .data(constants)
+        .enter().append("text")
+        .attr("x", 8)
+        .attr("y", ".31em")
+        .text(function(d) { return d.id; });
+
+  container.append("defs").selectAll("marker")
+    .data(['occurence'])
+    .enter().append("marker")
+    .attr("id", function(d) { return d; })
+    .attr("viewBox", "0 -5 10 10")
+    .attr("refX", 15)
+    .attr("refY", -1.5)
+    .attr("markerWidth", 6)
+    .attr("markerHeight", 6)
+    .attr("orient", "auto")
+    .append("path")
+    .attr("d", "M0,-5L10,0L0,5");
+
+  simulation
+      .nodes(constants)
+      .on("tick", ticked);
+
+  simulation.force("link")
+      .links(occurences);
+
+  function ticked() {
+    link.attr("d", linkArc);
+    circle.attr("transform", transform);
+    text.attr("transform", transform);
+  }
+
+  function linkArc(d) {
+    var dx = d.target.x - d.source.x,
+        dy = d.target.y - d.source.y,
+        dr =  0; // Math.sqrt(dx * dx + dy * dy);
+    return "M" + d.source.x + "," + d.source.y + "A" + dr + "," + dr + " 0 0,1 " + d.target.x + "," + d.target.y;
+  }
+
+  function dragstarted(d) {
+    if (!d3.event.active) simulation.alphaTarget(0.3).restart();
+    d3.select(this).classed("fixed", true );
+    d.fx = d.x;
+    d.fy = d.y;
+  }
+
+  function dragged(d) {
+    d.fx = d3.event.x;
+    d.fy = d3.event.y;
+  }
+
+  function dragended(d) {
+    if (!d3.event.active) simulation.alphaTarget(0);
+  }
+
+  function dblclick(d) {
+    var node = d3.select(this);
+    node.classed("fixed", false);
+    d.fx = null;
+    d.fy = null;
+  }
+
+  function transform(d) {
+    return "translate(" + d.x + "," + d.y + ")";
+  }
+
+  return true;
+
+};
+
+$(function(){ParseGraph();});