rubrowser 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89bd09805ec1de06cd644cdeaea90d6476b30198
-  data.tar.gz: aca07615cb33ab42ac46b36e605c5f736df98d56
+  metadata.gz: 533883a63e4f0656b260f7495ea2a62acc82ef64
+  data.tar.gz: 2bb665c87d91821898dc4e5965289291dc79809b
 SHA512:
-  metadata.gz: b4b93d8dd79f946fa1d6f25e582646b5231ae7ba2d0694a8aa01528e1c35a5c5aae7dd686a1b86907717a6ad3589b2e8caf3dcdd35c03994accee42988a2cee4
-  data.tar.gz: cdb14c5309c34579a627837f57ba0b36198973cc52666f52dba291caa82d73b400cd2a0e8cd76292ee16b13cde701a40948a36bbacdcd028fa96ca8d3ae68504
+  metadata.gz: 457739897ae0990378db89a4c8bdf95d6f5e21ff3d2b5bef310d21318e5c33f8216a0df006aa954710a8b0e32fce86995e8d7ac40e6439ff8bbd4d0c4ad38768
+  data.tar.gz: 3923cc2724f4f0602ef7a8651ad84852274f4536f53c62ac8e9188d64573178b228cd3a7d31de109343522b9491ee8206976fd72b5d30b79c0565b2409093f2a

data/.rubocop.yml

@@ -0,0 +1,4 @@
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubrowser (0.1.6)
+    rubrowser (0.2.0)
       parser (~> 2.3, >= 2.3.0)
 
 GEM

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Emad Elsaid
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/data.rb

@@ -1,30 +1,29 @@
 require 'parser/factory'
-require 'tree'
-require 'd3'
 
 module Rubrowser
   class Data
-    def initialize(paths)
-      @files = paths
+    def initialize(files)
+      @files = files
       @parsed = false
+      parse
     end
 
-    def constants
-      @_constants ||= d3.constants.to_a
+    def definitions
+      @_constants ||= parsers.map(&:definitions).reduce(:+).to_a
     end
 
-    def occurences
-      @_occurences ||= d3.occurences.to_a
+    def relations
+      @_relations ||= parsers.map(&:relations).reduce(:+).to_a
     end
 
+    private
+
     def parse
       return if parsed?
       parsers.each(&:parse)
       @parsed = true
     end
 
-    private
-
     attr_reader :files, :parsed
     alias parsed? parsed
 
@@ -33,15 +32,5 @@ module Rubrowser
         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/formatter/json.rb

@@ -0,0 +1,46 @@
+require 'json'
+
+module Rubrowser
+  module Formatter
+    class JSON
+      def initialize(data)
+        @data = data
+      end
+
+      def call
+        {
+          definitions: data.definitions.map { |d| definition_as_json(d) },
+          relations: data.relations.map { |r| relation_as_json(r, data.definitions) }
+        }.to_json
+      end
+
+      private
+
+      attr_reader :data
+
+      def definition_as_json(definition)
+        {
+          type: demoularize(definition.class.name),
+          namespace: definition.to_s,
+          file: definition.file,
+          line: definition.line
+        }
+      end
+
+      def relation_as_json(relation, definitions)
+        {
+          type: demoularize(relation.class.name),
+          namespace: relation.namespace.to_s,
+          resolved_namespace: relation.resolve(definitions).to_s,
+          caller: relation.caller_namespace.to_s,
+          file: relation.file,
+          line: relation.line
+        }
+      end
+
+      def demoularize(class_name)
+        class_name.split('::').last || ''
+      end
+    end
+  end
+end

data/lib/parser/definition/base.rb

@@ -0,0 +1,35 @@
+module Rubrowser
+  module Parser
+    module Definition
+      class Base
+        attr_reader :namespace, :file, :line
+
+        def initialize(namespace, file: nil, line: nil)
+          @namespace = Array(namespace)
+          @file = file
+          @line = line
+        end
+
+        def name
+          namespace.last
+        end
+
+        def parent
+          new(namespace[0...-1])
+        end
+
+        def kernel?
+          namespace.empty?
+        end
+
+        def ==(other)
+          namespace == other.namespace
+        end
+
+        def to_s
+          namespace.join('::')
+        end
+      end
+    end
+  end
+end

data/lib/parser/definition/class.rb

@@ -0,0 +1,10 @@
+require 'parser/definition/base'
+
+module Rubrowser
+  module Parser
+    module Definition
+      class Class < Base
+      end
+    end
+  end
+end

data/lib/parser/definition/module.rb

@@ -0,0 +1,10 @@
+require 'parser/definition/base'
+
+module Rubrowser
+  module Parser
+    module Definition
+      class Module < Base
+      end
+    end
+  end
+end

data/lib/parser/directory.rb

@@ -17,8 +17,8 @@ module Rubrowser
         parsers.map(&:definitions).map(&:to_a).reduce([], :+)
       end
 
-      def occurences
-        parsers.map(&:occurences).map(&:to_a).reduce([], :+)
+      def relations
+        parsers.map(&:relations).map(&:to_a).reduce([], :+)
       end
 
       private

data/lib/parser/file.rb

@@ -1,27 +1,29 @@
 require 'parser/current'
+require 'parser/definition/class'
+require 'parser/definition/module'
+require 'parser/relation/base'
 
 module Rubrowser
   module Parser
     class File
       FILE_SIZE_LIMIT = 2 * 1024 * 1024
 
-      attr_reader :file, :definitions, :occurences
+      attr_reader :file, :definitions, :relations
 
       def initialize(file)
-        @file = file
+        @file = ::File.absolute_path(file)
         @definitions = []
-        @occurences = []
+        @relations = []
       end
 
       def parse
         if file_valid?(file)
-          ::File.open(file) do |f|
-            code = f.read
-            ast = ::Parser::CurrentRuby.parse(code)
-            constants = parse_block(ast)
-            @definitions = constants[:definitions].uniq
-            @occurences = constants[:occurences].uniq
-          end
+          code = ::File.read(file)
+          ast = ::Parser::CurrentRuby.parse(code)
+          constants = parse_block(ast)
+
+          @definitions = constants[:definitions]
+          @relations = constants[:relations]
         end
       rescue ::Parser::SyntaxError
         warn "SyntaxError in #{file}"
@@ -36,62 +38,79 @@ module Rubrowser
       private
 
       def parse_block(node, parents = [])
-        return { definitions: [], occurences: [] } unless node.is_a?(::Parser::AST::Node)
+        return empty_result unless valid_node?(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: [] }
+        when :module then parse_module(node, parents)
+        when :class then parse_class(node, parents)
+        when :const then parse_const(node, parents)
+        else parse_array(node.children, parents)
         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) }
+        namespace = ast_consts_to_array(node.children.first, parents)
+        definition = Definition::Module.new(
+          namespace,
+          file: file,
+          line: node.loc.line
+        )
+        constants = { definitions: [definition] }
+        children_constants = parse_array(node.children[1..-1], namespace)
+
+        merge_constants(children_constants, constants)
       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) }
+        namespace = ast_consts_to_array(node.children.first, parents)
+        definition = Definition::Class.new(
+          namespace,
+          file: file,
+          line: node.loc.line
+        )
+        constants = { definitions: [definition] }
+        children_constants = parse_array(node.children[1..-1], namespace)
+
+        merge_constants(children_constants, constants)
       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 }
+        constant = ast_consts_to_array(node)
+        definition = Relation::Base.new(
+          constant,
+          parents,
+          file: file,
+          line: node.loc.line
+        )
+        { relations: [definition] }
+      end
+
+      def parse_array(arr, parents = [])
+        arr.map { |n| parse_block(n, parents) }
+           .reduce { |a, e| merge_constants(a, e) }
       end
 
       def merge_constants(c1, c2)
+        c1 ||= {}
+        c2 ||= {}
         {
-          definitions: c1[:definitions] + c2[:definitions],
-          occurences: c1[:occurences] + c2[:occurences]
+          definitions: c1[:definitions].to_a + c2[:definitions].to_a,
+          relations: c1[:relations].to_a + c2[:relations].to_a
         }
       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]
+      def ast_consts_to_array(node, parents = [])
+        return parents unless valid_node?(node) &&
+                              [:const, :cbase].include?(node.type)
+        ast_consts_to_array(node.children.first, parents) + [node.children.last]
+      end
+
+      def empty_result
+        {}
+      end
+
+      def valid_node?(node)
+        node.is_a?(::Parser::AST::Node)
       end
     end
   end

data/lib/parser/relation/base.rb

@@ -0,0 +1,60 @@
+require 'parser/definition/base'
+
+module Rubrowser
+  module Parser
+    module Relation
+      class Base
+        attr_reader :namespace, :caller_namespace, :file, :line
+
+        def initialize(namespace, caller_namespace, file: nil, line: nil)
+          @namespace = namespace
+          @caller_namespace = caller_namespace
+          @file = file
+          @line = line
+        end
+
+        def namespace
+          Definition::Base.new(@namespace, file: file, line: line)
+        end
+
+        def caller_namespace
+          Definition::Base.new(@caller_namespace, file: file, line: line)
+        end
+
+        def resolve(definitions)
+          possibilities.find do |possibility|
+            definitions.any? { |definition| definition == possibility }
+          end || possibilities.last
+        end
+
+        def ==(other)
+          namespace == other.namespace &&
+            caller_namespace == other.caller_namespace
+        end
+
+        private
+
+        def possibilities
+          return [
+            Definition::Base.new(@namespace.compact, file: file, line: line)
+          ] if absolute?
+
+          possible_parent_namespaces
+            .map { |possible_parent| possible_parent + @namespace }
+            .push(@namespace)
+            .map { |i| Definition::Base.new(i, file: file, line: line) }
+        end
+
+        def possible_parent_namespaces
+          (@caller_namespace.size - 1)
+            .downto(0)
+            .map { |i| @caller_namespace[0..i] }
+        end
+
+        def absolute?
+          @caller_namespace.empty? || @namespace.first.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubrowser.rb

@@ -1,3 +1,3 @@
 module Rubrowser
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/server.rb

@@ -1,38 +1,50 @@
 require 'webrick'
 require 'data'
-require 'json'
+require 'formatter/json'
 require 'erb'
 
 module Rubrowser
   class Server < WEBrick::HTTPServer
     include ERB::Util
 
+    ROUTES = {
+      '/' => :root,
+      '/data.json' => :data
+    }
+
     def self.start(options = {})
       new(options).start
     end
 
     def initialize(options)
       super Port: options[:port]
-
-      @data = Rubrowser::Data.new(options[:files])
-      @data.parse
+      @files = options[:files]
 
       mount_proc '/' do |req, res|
-        res.body = root(req.path)
+        res.body = router(req.path)
       end
-
-      trap('INT') { shutdown }
     end
 
     private
 
-    attr_reader :data
+    attr_reader :files
 
-    def root(path)
+    def router(path)
       return file(path) if file?(path)
+      return send(ROUTES[path]) if ROUTES.key?(path)
+      'Route not found.'
+    end
+
+    def root
       erb :index
     end
 
+    def data
+      data = Data.new(files)
+      formatter = Formatter::JSON.new(data)
+      formatter.call
+    end
+
     def file?(path)
       path = resolve_file_path("/public#{path}")
       File.file?(path)

data/public/css/application.css

@@ -1,16 +1,18 @@
-html, body{
+html, body, .dependency_graph, .dependency_graph svg{
     width: 100%;
     height: 100%;
     padding: 0px;
     margin: 0px;
-}
-.dependency_graph, .dependency_graph svg{
-    width: 100%;
-    height: 100%;
+    font: 10px sans-serif;
 }
 
-line{
-    stroke: #888;
+.loading{
+    position: absolute;
+    top: 30px;
+    left: 0px;
+    text-align: center;
+    width: 100%;
+    font-size: 3rem;
 }
 
 .link {
@@ -20,13 +22,13 @@ line{
 }
 
 circle {
-  fill: #ccc;
+  fill: #fff;
   stroke: #333;
   stroke-width: 1.5px;
 }
 
 .fixed circle {
-  fill: #f00;
+  stroke-width: 3px;
 }
 
 text {

data/public/javascript/application.js

@@ -1,19 +1,25 @@
-var ParseGraph = function(){
-  var svg = d3.select(".dependency_graph svg");
-  var $svg = $('.dependency_graph svg');
-
-  if(!svg.size()){
-    return false;
-  }
-
-  var width = $svg.width(),
+d3.json("/data.json", function(error, data) {
+  parseGraph(data);
+  $('.loading').hide();
+});
+
+var parseGraph = function(data){
+  var svg = d3.select(".dependency_graph svg"),
+      $svg = $('.dependency_graph svg'),
+      width = $svg.width(),
       height = $svg.height(),
-      constants = JSON.parse(svg.attr('data-constants')),
-      occurences = JSON.parse(svg.attr('data-occurences')),
       drag = d3.drag()
         .on("start", dragstarted)
         .on("drag", dragged)
-        .on("end", dragended);
+        .on("end", dragended),
+      constants = _.uniqWith(data.definitions.map(function(d){ return {id: d.namespace}; }), _.isEqual),
+      namespaces = constants.map(function(d){ return d.id; }),
+      relations = data.relations.map(function(d){ return {source: d.caller, target: d.resolved_namespace }; });
+
+  relations = relations.filter(function(d){
+    return namespaces.indexOf(d.source) >= 0 && namespaces.indexOf(d.target) >= 0;
+  });
+  relations = _.uniqWith(relations, _.isEqual);
 
   var zoom = d3.zoom()
         .on("zoom", function () {
@@ -23,9 +29,8 @@ var ParseGraph = function(){
   svg.call(zoom)
     .on("dblclick.zoom", null);
 
-  var container = svg.append('g');
-
-  var simulation = d3.forceSimulation()
+  var container = svg.append('g'),
+      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))
@@ -36,36 +41,33 @@ var ParseGraph = function(){
     .on("tick", ticked);
 
   simulation.force("link")
-    .links(occurences);
+    .links(relations);
 
   var link = container.append("g")
         .attr("class", "links")
         .selectAll("path")
-        .data(occurences)
+        .data(relations)
         .enter().append("path")
         .attr("class", 'link')
-        .attr("marker-end", "url(#occurence)");
-
-  var node = container.append("g")
+        .attr("marker-end", "url(#relation)"),
+      node = container.append("g")
         .attr("class", "nodes")
         .selectAll("g")
         .data(constants)
         .enter().append("g")
         .call(drag)
-        .on("dblclick", dblclick);
-
-  var circle = node
+        .on("dblclick", dblclick),
+      circle = node
         .append("circle")
-        .attr("r", 6);
-
-  var text = node
+        .attr("r", 6),
+      text = node
         .append("text")
         .attr("x", 8)
         .attr("y", ".31em")
         .text(function(d) { return d.id; });
 
   container.append("defs").selectAll("marker")
-    .data(['occurence'])
+    .data(['relation'])
     .enter().append("marker")
     .attr("id", function(d) { return d; })
     .attr("viewBox", "0 -5 10 10")
@@ -144,5 +146,3 @@ var ParseGraph = function(){
   return true;
 
 };
-
-$(function(){ParseGraph();});