dependencytree 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 871b5cca00b7e8c672ebe92d50d82ce45312b676
+  data.tar.gz: 24ba59e668837116dde2ccea7f5fdc5363cc0853
+SHA512:
+  metadata.gz: 02d79005326ff09a232d65027e7e25f6188693a516a82a81a4385d84dd2aa0890de0cdb979794346a3afc8b6e5cf849286092c31f1b913baefb40811e6150fa9
+  data.tar.gz: 58ef9a55ed91519884a254cd7f48c022569e4eb228162e158794398975fc6ed15e0dba89108384e0fa31f339f7dbc650aa0d01deb71c354c3653e3491bc9075c

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*~
+*.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in dependencytree.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 1&1 Internet SE
+
+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/README.md

@@ -0,0 +1,232 @@
+# Dependencytree
+
+Parses ruby source codes and tries to build a dependency tree from the seen classes, modules and references.
+The output is a JSON file that contains all modules/classes along with their references.
+
+The references can be used to build a dependency tree for your project.
+
+## Installation
+
+Install it yourself as from https://rubygems.org/ by calling:
+
+    $ gem install dependencytree
+
+## Usage
+
+Use the program in the shell and give it all ruby sources or folders containing ruby sources.
+
+        dependencytree ./lib
+
+The output will be a JSON of the references. The interesting parts are:
+* **uuid**: Every class/module has a unique UUID for referencing. The UUID will stay unique only for one parsing run.
+* **resolved_refs**: Resolved / found references that are pointing to the UUID of the refered class.
+* **unresolved_refs**: Unresolved references that could not be found inside the sources provided.
+  This can be Ruby classes or other classes from gems that were not scanned.
+  The unresolved_refs entries are arrays of the name parts, for example `[ "moduleA", "mobuleB", "classC" ]`
+* **methods**: List of seen method names.
+* **constants**: List of seen constant names.
+* **path**: Filesystem path of the first source file with a class/module definition.
+* **type**: `"module"` or `"class"`.
+* **refs**: An array of all references (resolvable and unresolvable) in array notation (see above).
+* **name**: The local module/class name, for example `"Stat"`.
+* **full_name**: The full name of the module/class, for example `"File::Stat"`.
+
+The following is the example for the dependency tree tool itself:
+
+```
+[
+   {
+      "methods" : [],
+      "full_name" : "Kernel",
+      "unresolved_refs" : [],
+      "uuid" : "424ab3a4-60d3-4e7d-9374-8d1d72bd0d91",
+      "type" : "module",
+      "resolved_refs" : [],
+      "refs" : [],
+      "constants" : [],
+      "path" : null,
+      "name" : "Kernel"
+   },
+   {
+      "type" : "module",
+      "uuid" : "401771ee-5c37-4bdf-a10d-f9a467827791",
+      "constants" : [
+         "VERSION"
+      ],
+      "name" : "Dependencytree",
+      "path" : "/home/stephan/git/z/dependencytree/lib/dependencytree/classcontainer.rb",
+      "resolved_refs" : [
+         "aad66db1-8229-4565-8a9e-d1ea73d2281c",
+         "1212a5b6-75b8-4836-8867-14a8734bf3e2"
+      ],
+      "refs" : [
+         [
+            "File"
+         ],
+         [
+            "Dir"
+         ],
+         [
+            "Parser",
+            "CurrentRuby"
+         ],
+         [
+            "Logger"
+         ],
+         [
+            "OptionParser"
+         ],
+         [
+            "DependencyAggregator"
+         ],
+         [
+            "ARGV"
+         ],
+         [
+            "ClassContainer"
+         ]
+      ],
+      "full_name" : "Dependencytree",
+      "methods" : [],
+      "unresolved_refs" : [
+         [
+            "File"
+         ],
+         [
+            "Dir"
+         ],
+         [
+            "Parser",
+            "CurrentRuby"
+         ],
+         [
+            "Logger"
+         ],
+         [
+            "OptionParser"
+         ],
+         [
+            "ARGV"
+         ]
+      ]
+   },
+   {
+      "parent_uuid" : "401771ee-5c37-4bdf-a10d-f9a467827791",
+      "type" : "class",
+      "uuid" : "1212a5b6-75b8-4836-8867-14a8734bf3e2",
+      "constants" : [],
+      "name" : "ClassContainer",
+      "path" : "/home/stephan/git/z/dependencytree/lib/dependencytree/classcontainer.rb",
+      "refs" : [],
+      "resolved_refs" : [],
+      "full_name" : "Dependencytree::ClassContainer",
+      "methods" : [
+         "initialize",
+         "resolve_references",
+         "resolve_reference",
+         "resolve_reference_as_constant",
+         "resolve_reference_direct",
+         "resolve_by_full_name",
+         "resolve_by_name"
+      ],
+      "unresolved_refs" : []
+   },
+   {
+      "full_name" : "Dependencytree::ClassModel",
+      "methods" : [
+         "initialize",
+         "full_name_array",
+         "full_name",
+         "set_parent",
+         "as_json",
+         "to_json",
+         "add_method",
+         "add_constant",
+         "add_reference"
+      ],
+      "unresolved_refs" : [
+         [
+            "SecureRandom"
+         ],
+         [
+            "ArgumentError"
+         ]
+      ],
+      "uuid" : "9a267b3e-0784-4114-810f-8d38484dbbc7",
+      "type" : "class",
+      "parent_uuid" : "401771ee-5c37-4bdf-a10d-f9a467827791",
+      "refs" : [
+         [
+            "SecureRandom"
+         ],
+         [
+            "ArgumentError"
+         ]
+      ],
+      "resolved_refs" : [],
+      "path" : "/home/stephan/git/z/dependencytree/lib/dependencytree/classmodel.rb",
+      "constants" : [],
+      "name" : "ClassModel"
+   },
+   {
+      "unresolved_refs" : [
+         [
+            "ArgumentError"
+         ],
+         [
+            "Exception"
+         ]
+      ],
+      "methods" : [
+         "initialize",
+         "top_of_stack",
+         "flatten_const_tree",
+         "_resolve",
+         "_const",
+         "_module",
+         "_class",
+         "_handle_class_module_common",
+         "_def",
+         "_casgn",
+         "visit_node",
+         "visit_children",
+         "visit"
+      ],
+      "full_name" : "Dependencytree::DependencyAggregator",
+      "path" : "/home/stephan/git/z/dependencytree/lib/dependencytree/dependencyaggregator.rb",
+      "constants" : [],
+      "name" : "DependencyAggregator",
+      "refs" : [
+         [
+            "ArgumentError"
+         ],
+         [
+            "ClassModel"
+         ],
+         [
+            "Exception"
+         ]
+      ],
+      "resolved_refs" : [
+         "9a267b3e-0784-4114-810f-8d38484dbbc7"
+      ],
+      "parent_uuid" : "401771ee-5c37-4bdf-a10d-f9a467827791",
+      "type" : "class",
+      "uuid" : "aad66db1-8229-4565-8a9e-d1ea73d2281c"
+   }
+]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/1and1/dependencytree.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dependencytree"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/dependencytree

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'dependencytree'

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dependencytree.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dependencytree/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dependencytree"
+  spec.version       = Dependencytree::VERSION
+  spec.authors       = ["Stephan Fuhrmann"]
+  spec.email         = ["stephan.fuhrmann@1und1.de"]
+
+  spec.summary       = %q{Calculate class dependencies and output to JSON.}
+  spec.description   = %q{Analyse Ruby source code, analyse class dependencies and output everything as a JSON.}
+  spec.homepage      = "http://www.1und1.de"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables << 'dependencytree'
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "parser", "~> 2.5.0.5"
+  spec.add_dependency "ast", "~> 2.4.0"
+end

data/lib/dependencytree.rb

@@ -0,0 +1,75 @@
+require "dependencytree/dependencyaggregator"
+require "dependencytree/classcontainer"
+
+require "dependencytree/version"
+require 'parser/current'
+require 'optparse'
+require 'pp'
+require 'json'
+require 'logger'
+
+module Dependencytree
+
+  def self.handle_path(options, consumer, path)
+    if options[:ignore].match(path)
+      return
+    end
+    if File.directory?(path)
+      Dir.entries(path).each { |x|
+        resolved = File.join(path, x)
+        handle_path(options, consumer, resolved) if File.directory?(resolved) && x != "." && x != ".."
+        handle_path(options, consumer, resolved) if File.file?(resolved) && options[:pattern].match(resolved)
+      }
+    elsif File.file?(path)
+      $LOG.debug("Handling path #{path}")
+      tree = Parser::CurrentRuby.parse_file(path)
+      $LOG.debug("Parsed tree: #{tree}") if $LOG.debug?
+      consumer.visit(path, tree)
+    end
+  end
+
+  $LOG = Logger.new('application.log', 'daily', 20)
+
+  options = {}
+  options[:ignore] = /^$/
+  options[:pattern] = /.*\.rb/
+  OptionParser.new do |opt|
+    opt.on("-v", "--verbose", "Verbose output") do |o|
+      # TBD
+      options[:verbose] = true
+      $LOG.debug("verbose")
+    end
+    opt.on("-p", "--pattern[=OPTIONAL]", "Pattern to accept source codes with (default: #{options[:pattern].to_s})") do |o|
+      options[:pattern] = /#{o}/
+      $LOG.debug("pattern = #{o}")
+    end
+    opt.on("-i", "--ignore[=OPTIONAL]", "Paths to not load (default: #{options[:ignore].to_s})") do |o|
+      options[:ignore] = /#{o}/
+      $LOG.debug("ignore = #{o}")
+    end
+    opt.on("-o", "--output[=OPTIONAL]", "Output path for the JSON file") do |o|
+      options[:output] = o
+      $LOG.debug("output = #{o}")
+    end
+    opt.on_tail("-h", "--help", "Show this message") do
+      puts opt
+      exit
+    end
+  end.parse!
+
+  consumer = DependencyAggregator.new
+  ARGV.each do |path|
+    handle_path(options, consumer, File.absolute_path(path))
+  end
+
+  classcontainer = ClassContainer.new(consumer.classes_and_modules)
+  classcontainer.resolve_references
+
+  json = classcontainer.classes_and_modules.to_json
+  if options[:output]
+    File.write(options[:output], json)
+  else
+    puts json
+  end
+end
+

data/lib/dependencytree/classcontainer.rb

@@ -0,0 +1,116 @@
+require "dependencytree/version"
+require "securerandom"
+
+module Dependencytree
+
+  # Model for classes and modules.
+  class ClassContainer
+
+    attr_reader :classes_and_modules
+
+    # type: :class or :module
+    # path: the filesystem path the parsed class was found in
+    # module_name: eventual module name or :anonymous
+    # class_name: the class name
+    def initialize(classes_and_modules)
+      @classes_and_modules = classes_and_modules
+      @by_full_name = @classes_and_modules.each_with_object({})  { |clazz, hash| hash[clazz.full_name()] = clazz }
+    end
+
+    # Goes thru all classes and tries to resolve the references.
+    def resolve_references
+      @classes_and_modules.each do |clazz|
+        $LOG.debug("Processing class #{clazz.full_name} located in #{clazz.path}")
+        clazz.references.each do |reference_array|
+          refered_class = resolve_reference(clazz, reference_array)
+          if refered_class
+            clazz.resolved_references << refered_class.uuid
+          else
+            clazz.unresolved_references << reference_array
+          end
+        end
+      end
+    end
+
+    # Tries to resolve one reference either as a constant or a class/module reference.
+    # @param referer_class_model the ClassModel where the reference is in.
+    # @param reference_array the reference as in the source, can be absolute or relative to the referer class.  
+    # @return the ClassModel refering to (also for constants!).
+    def resolve_reference(referer_class_model, reference_array)
+      refered_class_model = resolve_reference_direct(referer_class_model, reference_array)
+      if ! refered_class_model
+        refered_class_model = resolve_reference_as_constant(referer_class_model, reference_array)
+      end
+
+      if refered_class_model
+        $LOG.debug("Resolved #{reference_array.join('::')} to uuid #{refered_class_model.uuid}")
+      else
+        $LOG.debug("Could not resolve #{reference_array.join('::')}")
+      end
+      refered_class_model
+    end
+
+    # Resolve a constant module/class reference.
+    # @param referer_class_model the ClassModel where the reference is in.
+    # @param reference_array the reference as in the source, can be absolute or relative to the referer class. The last
+    # element of the array is the constant name.
+    # @return the refered class model or nil
+    def resolve_reference_as_constant(referer_class_model, reference_array)
+      reference_part = reference_array[0..-2]
+      constant_name = reference_array[-1]
+
+      $LOG.debug("Resolving reference array #{reference_array.to_s} as reference #{reference_part.to_s} and constant #{constant_name}")
+
+      refered_class_model = resolve_reference_direct(referer_class_model, reference_part)
+      if refered_class_model
+        $LOG.debug("Found reference to possible parent #{reference_part.to_s}")
+        if refered_class_model.constant_names.include? constant_name.to_sym
+          $LOG.debug("Found class #{refered_class_model.full_name} constant #{constant_name}")
+          refered_class_model
+        else
+          $LOG.debug("Found class #{refered_class_model.full_name}, but not constant #{constant_name}. Known constants: #{refered_class_model.constant_names}")
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    # Resolve a full module/class reference.
+    # @param referer_class_model the ClassModel where the reference is in.
+    # @param reference_array the reference as in the source, can be absolute or relative to the referer class.
+    # @return the refered class model or nil
+    def resolve_reference_direct(referer_class_model, reference_array)
+      $LOG.debug("Resolving reference array #{reference_array.to_s}")
+
+      referer_array = referer_class_model.full_name_array
+      i = 0
+      refered_class_model = nil
+      while !refered_class_model do
+        $LOG.debug("Referer array #{i} is #{referer_array.to_s}")
+        full_name = (referer_array+reference_array).join("::")
+        $LOG.debug("Full name #{i} is #{full_name} #{full_name.class.name}")
+        refered_class_model = resolve_by_full_name(full_name)
+
+        break if referer_array.empty?
+        referer_array = referer_array[0..-2]
+        i += 1
+      end
+
+      refered_class_model
+    end
+
+    # Finds a class or module by its full name.
+    # @param full_name the full name to search for.
+    def resolve_by_full_name(full_name)
+      @by_full_name[full_name]
+    end
+
+    # Finds a class or module by its local name.
+    # @param name the name to search for.
+    def resolve_by_name(name)
+      @classes_and_modules.find  { |clazz| clazz.name == name }
+    end
+  end
+end
+

data/lib/dependencytree/classmodel.rb

@@ -0,0 +1,105 @@
+require "dependencytree/version"
+require "securerandom"
+
+module Dependencytree
+
+  # Model for classes and modules
+  class ClassModel
+
+    attr_reader :uuid
+    attr_reader :name
+    attr_reader :references
+    attr_reader :path
+    attr_reader :constant_names
+    attr_reader :method_names
+
+    attr_reader :resolved_references
+    attr_reader :unresolved_references
+
+    # type: :class or :module
+    # path: the filesystem path the parsed class was found in
+    # module_name: eventual module name or :anonymous
+    # class_name: the class name
+    def initialize(type, path, name)
+      # unique uuid for reference
+      @uuid = SecureRandom.uuid
+      # :module or :class
+      @type = type
+      # filesystem path of (first) definition
+      @path = path
+      # local name (without enclosing modules)
+      @name = name
+      # list of names of methods
+      @method_names = []
+      # list of names of constants
+      @constant_names = []
+      # list of (unresolved) references as arrays
+      @references = []
+
+      @resolved_references = []
+      @unresolved_references = []
+    end
+
+    # Gets the full name of the class/module as an array.
+    # @return the full name, for example ["ModuleA","ModuleB","ClassA"]
+    def full_name_array
+      if @parent
+        result = @parent.full_name_array << @name.to_s
+      else
+        result = [ @name.to_s ]
+      end
+      result
+    end
+
+    # Gets the full name of the class/module.
+    # @return the full name, for example "ModuleA::ModuleB::ClassA"
+    def full_name
+      full_name_array.join("::")
+    end
+
+    def set_parent(parent)
+      raise ArgumentError, "Self parent reference for name #{@name}" if parent == self
+      @parent = parent
+    end
+
+    def as_json(*a)
+      result = {
+        "uuid" => @uuid,
+        "type" => @type,
+        "path" => @path,
+        "name" => @name,
+        "full_name" => full_name,
+        "methods" => @method_names,
+        "constants" => @constant_names,
+        "refs" => @references.uniq,
+        "resolved_refs" => @resolved_references.uniq,
+        "unresolved_refs" => @unresolved_references.uniq,
+      }
+
+      if @parent
+        result["parent_uuid"] = @parent.uuid
+      end
+      result
+    end
+
+    def to_json(*a)
+        as_json.to_json(*a)
+    end
+
+    # Adds a method by its name to the list of methods.
+    def add_method(method_name)
+      @method_names << method_name.to_sym
+    end
+
+    # Adds a constant by its name to the list of constants.
+    def add_constant(constant_name)
+      @constant_names << constant_name.to_sym
+    end
+
+    # Adds a reference by its array-style full name.
+    def add_reference(ref)
+      @references << ref
+    end
+  end
+end
+

data/lib/dependencytree/dependencyaggregator.rb

@@ -0,0 +1,192 @@
+require "dependencytree/version"
+require 'parser/current'
+require "dependencytree/classmodel"
+
+module Dependencytree
+  class DependencyAggregator
+    attr_reader :classes_and_modules
+
+    def initialize
+      # path will be the file system path of the source file
+      @path = nil
+      # context_stack is the stack of modules/classes loaded (namespacing)
+      @context_stack = []
+      # this is a flat list of all classes / modules seen
+      @classes_and_modules = []
+
+      # force adding the Kernel module to the list of classes
+      _handle_class_module_common(:module, "Kernel", nil)
+      @kernel = _resolve("Kernel")
+    end
+
+    # Gets the top of stack class/module or Kernel if nothing set.
+    def top_of_stack
+      if @context_stack.empty?
+        @kernel
+      else
+        @context_stack[-1]
+      end
+    end
+
+    # Make an array of strings out of a encapsulated tree of :const expressions.
+    # @param node the top const node to start flattening at.
+    def flatten_const_tree(node)
+      raise ArgumentError, "type needs to be const (#{node.type})" if node.type != :const
+      raise ArgumentError, "Children count needs to be 2 (#{node.children.length})" if node.children.length != 2
+
+      result = node.children[1..1]
+      if node.children[0] && node.children[0].type == :const
+        result = flatten_const_tree(node.children[0]) + result
+      end
+      result
+    end
+
+    # Finds a class or module by its full name.
+    # @param full_name the full name.
+    def _resolve(full_name)
+      @classes_and_modules.find  { |clazz| clazz.full_name.to_s == full_name.to_s }
+    end
+
+    # Handle a const expression.
+    # @param node the const node itself to handle.
+    def _const(node)
+      $LOG.debug("const")
+
+      raise ArgumentError, "type needs to be const (#{node.type})" if node.type != :const
+      raise ArgumentError, "Children count needs to be 2 (#{node.children.length})" if node.children.length != 2
+
+      reference = flatten_const_tree(node)
+
+      $LOG.debug("Reference to #{reference.to_s}")
+      top_of_stack.add_reference(reference)
+    end
+
+    # Handle a module expression.
+    # @param node the module node itself to handle.
+    def _module(node)
+      raise ArgumentError, "Children count for module is != 2 (#{node.children.length})" if node.children.length != 2
+      raise ArgumentError, "First module child needs to be a const (#{node.children[0].type} #{node.children[0].type})" if node.children[0].type != :const
+
+      $LOG.debug("module #{node.children[0].children[1]}")
+
+      current_module_name = node.children[0].children[1]
+      _handle_class_module_common(:module, current_module_name, node)
+    end
+
+    # Handle a class expression.
+    # @param node the class node itself to handle.
+    def _class(node)    
+      raise ArgumentError, "Children count for class is != 3 (#{node.children.length})" if node.children.length != 3
+      raise ArgumentError, "First class child needs to be a const (#{node.children[0].type} #{node.children[0].type})" if node.children[0].type != :const
+      $LOG.debug("class #{node.children[0].children[1]}")
+
+      current_class_name = node.children[0].children[1]
+      _handle_class_module_common(:class, current_class_name, node)
+    end
+
+    # Handle the common parts of a module or class definition. Will try to resolve the instance or create it if not found.
+    # @param type :module or :class.
+    # @param name the local class name.
+    # @param node the AST node of the class or module, can be nil if no children traversal required.
+    def _handle_class_module_common(type, name, node)
+      full_name = name
+      parent = nil
+      if ! @context_stack.empty?
+        parent = @context_stack[-1]
+        full_name = parent.full_name.to_s + "::" + name.to_s
+      end
+      $LOG.debug("Full name is #{full_name}")
+      resolved = _resolve(full_name)
+
+      if ! resolved.nil?
+        # found an existing module/class with the full_name
+        model = resolved
+      else
+        # found no existing module/class with the full_name
+        model = ClassModel.new(type, @path, name)
+        if parent
+          model.set_parent(parent)
+        end
+        @classes_and_modules << model 
+      end
+
+      if resolved.nil?
+        $LOG.debug("Created new ClassModel for #{model.full_name}")
+      end
+
+      @context_stack << model
+      # recurse over the contents of the module
+      visit_children(node.children[1..-1]) if node
+      @context_stack.pop
+    end
+
+    # Handle a def expression.
+    # @param node the def node itself to handle.
+    def _def(node)
+      raise ArgumentError, "Children count for def is != 3 (#{node.children.length})" if node.children.length != 3
+
+      $LOG.debug("def #{node.children[0]}")
+
+      top_of_stack.add_method(node.children[0])
+
+      visit_children(node.children[1..-1])
+    end
+
+    # Handle a def expression.
+    # @param node the def node itself to handle.
+    def _casgn(node)
+      raise ArgumentError, "Children count for casgn is != 3 (#{node.children.length})" if node.children.length != 3
+
+      $LOG.debug("casgn #{node.children[1]}")
+
+      top_of_stack.add_constant(node.children[1])
+
+      visit_children(node.children[1..-1])
+    end
+
+    # Visit a AST node and do the appropriate actions.
+    # @param node the node to visit.
+    def visit_node(node)
+      case node.type
+        when :const
+          _const(node)
+        when :class
+          _class(node)
+        when :module
+          _module(node)
+        when :def
+          _def(node)
+        when :casgn
+          _casgn(node)
+        else
+          visit_children(node.children)
+      end
+    end
+
+    # Visit all children of a node. Will call #visit_node on each node child.
+    # @param children the array of children to visit.
+    def visit_children(children)
+      return if ! children
+      children.each do |child|
+        visit_node(child) if child.respond_to?(:children)
+      end
+    end
+
+    # Visits all children of the AST tree.
+    # @param path the filesystem path of the parsed entity (ruby file).
+    # @param tree the AST tree node.
+    def visit(path, tree)
+      begin
+        $LOG.debug("Visiting path #{path}")
+        @path = path
+        visit_node(tree)
+        @path = nil
+      rescue Exception => e
+        $LOG.error("Error in path #{path}")
+        puts "Error in path #{path}"
+        raise e
+      end
+    end
+  end
+end
+

data/lib/dependencytree/version.rb

@@ -0,0 +1,3 @@
+module Dependencytree
+  VERSION = "0.1.3"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: dependencytree
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Stephan Fuhrmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0.5
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+description: Analyse Ruby source code, analyse class dependencies and output everything
+  as a JSON.
+email:
+- stephan.fuhrmann@1und1.de
+executables:
+- dependencytree
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/dependencytree
+- bin/setup
+- dependencytree.gemspec
+- lib/dependencytree.rb
+- lib/dependencytree/classcontainer.rb
+- lib/dependencytree/classmodel.rb
+- lib/dependencytree/dependencyaggregator.rb
+- lib/dependencytree/version.rb
+homepage: http://www.1und1.de
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Calculate class dependencies and output to JSON.
+test_files: []