courgette 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 57adf4c4137fcf9342cc36a2da2d18bae46adff3
+  data.tar.gz: c7d05925b78857a07c8765859e9c945dbcffd3e8
+SHA512:
+  metadata.gz: 17e68370df6b304fdf7973b9f969e53d5bc9f30764a2eebdf0b33442b48bfddf6d4b40a81bcb4bd35679448e23a1962e222688339fc1797670d75943f732d5a4
+  data.tar.gz: bf96fc9d079926ea905030564e21a12f2543fbe546249056c53c85565deed8d05ac56e49b608e68d2fc3750009480a258506e7968aa8f5cd67aa5a6640e0ff2c

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*.rb'
+end
+
+task :default => :test

data/bin/courgette.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander/import'
+
+require 'courgette/commands/graph'
+require 'courgette/commands/stats'
+
+program :version, '1.0.0'
+program :description, 'Dependency graph fetcher'
+
+default_command :stats
+
+command :stats do |c|
+  c.syntax = 'courgette stats [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  c.option '--glob STRING', String, 'Glob to run metrics over (default: **/*.rb)'
+  c.action do |args, options|
+    options.default :glob => '**/*.rb'
+
+    Courgette::Commands::Stats.new(options).run
+  end
+end
+
+command :graph do |c|
+  c.syntax = 'courgette graph [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  c.option '--glob STRING', String, 'Glob to run metrics over (default: **/*.rb)'
+  c.option '--name STRING', String, 'Glob to run metrics over (default: graph)'
+  c.option '--format STRING', String, 'Format (default: png)'
+  c.action do |args, options|
+    options.default :glob => '**/*.rb', :format => 'png', :name => 'graph'
+
+    Courgette::Commands::Graph.new(options).run
+  end
+end

data/courgette.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'courgette/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "courgette"
+  spec.version       = Courgette::VERSION
+  spec.authors       = ["Hugo Peixoto"]
+  spec.email         = ["hugo.peixoto@gmail.com"]
+  spec.description   = %q{Static ruby dependency analyser}
+  spec.summary       = %q{Courgette analyses a set of files, and calculates a dependency graph}
+  spec.homepage      = "https://github.com/hugopeixoto/courgette"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ruby_parser"
+  spec.add_dependency "commander"
+  spec.add_dependency "graph"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/lib/courgette/capturer.rb

@@ -0,0 +1,88 @@
+require 'courgette/scope'
+
+module Courgette
+  class Capturer
+    def initialize
+      @references  = []
+      @definitions = []
+    end
+
+    def capture sexpr
+      iterate sexpr, []
+    end
+
+    def references
+      @references.uniq! { |reference| reference.to_a }
+      @references
+    end
+
+    def definitions
+      @definitions.uniq! { |definition| definition.to_a }
+      @definitions
+    end
+
+    private
+    Reference = Struct.new :name, :context
+
+    def add_definition definition
+      @definitions << definition.flatten
+    end
+
+    def add_reference context, reference
+      @references << Reference.new(reference, context)
+    end
+
+    def scope sexpr
+      Courgette::Scope.new.scope sexpr
+    end
+
+    def iterate_many sexprs, context
+      sexprs.each do |sexpr|
+        iterate sexpr, context
+      end
+    end
+
+    def iterate_cdecl sexpr, context
+      s = scope sexpr[1]
+      new_context = context + [s]
+      add_definition new_context
+
+      iterate_many sexpr[2..-1], context
+    end
+
+    def iterate_definition sexpr, context
+      s = scope sexpr[1]
+      new_context = context + [s]
+      add_definition new_context
+
+      iterate_many sexpr[2..-1], new_context
+    end
+
+    def iterate_call sexpr, context
+      iterate sexpr[1], context
+      iterate_many sexpr[3..-1], context
+    end
+
+
+    def iterate sexpr, context
+      return unless sexpr.is_a? Enumerable
+
+      case sexpr[0]
+      when :const, :colon2
+        add_reference context, scope(sexpr)
+      when :module, :class
+        iterate_definition sexpr, context
+      when :cdecl
+        iterate_cdecl sexpr, context
+      when :defn
+        iterate_many sexpr[3..-1], context
+
+      when :call
+        iterate_call sexpr, context
+      when :nil, :lit
+      else
+        iterate_many sexpr[1..-1], context
+      end
+    end
+  end
+end

data/lib/courgette/commands/graph.rb

@@ -0,0 +1,46 @@
+require 'courgette/directory_analyser'
+require 'courgette/graph2dot'
+
+module Courgette
+  module Commands
+    class Graph
+      def initialize options
+        @options = options
+      end
+
+      def run
+        factory.load graph
+
+        formats.each do |fmt|
+          factory.save name, fmt
+        end
+      end
+
+      private
+      def glob
+        @options.glob
+      end
+
+      def formats
+        Array(@options.format)
+      end
+
+      def name
+        @options.name
+      end
+
+      def factory
+        @factory ||= Courgette::Graph2Dot.new do
+          boxes
+          node_attribs << filled
+        end
+      end
+
+      def graph
+        @graph ||= Courgette::DirectoryAnalyser.new.tap do |da|
+          da.analyse glob
+        end.graph
+      end
+    end
+  end
+end

data/lib/courgette/commands/stats.rb

@@ -0,0 +1,42 @@
+require 'courgette/directory_analyser'
+
+module Courgette
+  module Commands
+    class Stats
+      def initialize options
+        @options = options
+      end
+
+      def run
+        stats.each do |fanout, fanin, reference|
+          print_reference fanout, fanin, reference
+        end
+      end
+
+      def print_reference fo, fi, ref
+        print "%8d %8d: %s\n" % [fo, fi, ref.join("::")]
+      end
+
+      private
+      def glob
+        @options.glob
+      end
+
+      def stats
+        @stats ||= graph.nodes.map do |node|
+          [
+            graph.dependency_count(node),
+            graph.depender_count(node),
+            node
+          ]
+        end.sort
+      end
+
+      def graph
+        @graph ||= Courgette::DirectoryAnalyser.new.tap do |da|
+          da.analyse glob
+        end.graph
+      end
+    end
+  end
+end

data/lib/courgette/directory_analyser.rb

@@ -0,0 +1,38 @@
+require 'courgette/capturer'
+require 'courgette/reference_to_dependency'
+require 'courgette/file_to_sexpr'
+require 'courgette/graph'
+
+module Courgette
+  class DirectoryAnalyser
+    def initialize
+      @capturer   = Courgette::Capturer.new
+      @file2sexpr = Courgette::FileToSexpr.new
+    end
+
+    def analyse pattern
+      Dir.glob(pattern) do |file|
+        capturer.capture file2sexpr.convert(file)
+      end
+    end
+
+    def graph
+      Courgette::Graph.new definitions, dependencies
+    end
+
+    private
+    attr_reader :capturer, :file2sexpr
+
+    def definitions
+      capturer.definitions
+    end
+
+    def dependencies
+      r2d = Courgette::ReferenceToDependency.new definitions
+
+      capturer.references.map do |reference|
+        r2d.transform reference
+      end.compact
+    end
+  end
+end

data/lib/courgette/file_to_sexpr.rb

@@ -0,0 +1,15 @@
+require 'ruby_parser'
+
+module Courgette
+  class FileToSexpr
+    def initialize
+      @parser = RubyParser.new
+    end
+
+    def convert filename
+      contents = File.read filename
+
+      @parser.parse contents
+    end
+  end
+end

data/lib/courgette/graph.rb

@@ -0,0 +1,20 @@
+module Courgette
+  class Graph
+    attr_reader :nodes, :edges
+
+    def initialize nodes, edges
+      @nodes = nodes
+      @edges = edges
+    end
+
+    def dependency_count node
+      edges.select { |r| r.referrer == node }.count
+    end
+
+    def depender_count node
+      edges.select { |r| r.reference == node }.count
+    end
+
+    private
+  end
+end

data/lib/courgette/graph2dot.rb

@@ -0,0 +1,56 @@
+require 'courgette/node_grouper'
+require 'graph'
+
+module Courgette
+  class Graph2Dot
+    def initialize &block
+      @dot = digraph &block
+    end
+
+    def load graph
+      calculate_distinct_namespaces graph.nodes
+      set_colorscheme
+
+      graph.nodes.each do |node|
+        add_node node
+      end
+
+      graph.edges.each do |edge|
+        add_edge edge
+      end
+    end
+
+    def save *args
+      dot.save *args
+    end
+
+    private
+    attr_reader :dot
+
+    def set_colorscheme
+      dot.colorscheme(:set2, [4, [8, @grouper.groups.count + 1].min].max)
+    end
+
+    def calculate_distinct_namespaces nodes
+      @grouper = Courgette::NodeGrouper.new nodes, 8
+    end
+
+    def add_node node
+      color(node) << dot.node(label(node))
+    end
+
+    def add_edge edge
+      dot.edge(label(edge.referrer), label(edge.reference))
+    end
+
+    def color node
+      idx = @grouper.group node
+
+      dot.send "c#{idx}"
+    end
+
+    def label node
+      node.flatten.join("::")
+    end
+  end
+end

data/lib/courgette/name_resolution.rb

@@ -0,0 +1,27 @@
+module Courgette
+  class NameResolution
+    def initialize definitions
+      @definitions = definitions
+    end
+
+    def resolve reference
+      definitions.find do |definition|
+        match_name?(definition, reference) &&
+          match_scope?(definition, reference)
+      end
+    end
+
+    private
+    attr_reader :definitions
+
+    def match_name? definition, reference
+      definition.last == reference.name.last
+    end
+
+    def match_scope? definition, reference
+      (0..reference.context.length).any? do |level|
+        reference.context[0...level].flatten + reference.name == definition
+      end
+    end
+  end
+end

data/lib/courgette/node_grouper.rb

@@ -0,0 +1,31 @@
+module Courgette
+  class NodeGrouper
+    def initialize nodes, max_groups
+      @nodes = nodes
+      @max_groups = max_groups
+
+      calculate
+    end
+
+    def group node
+      idx   = namespaces.index node[0...-1][0...1]
+      idx ||= -1
+      idx   = [2 + idx, @max_groups].min
+    end
+
+    def groups
+      @namespaces
+    end
+
+    private
+    attr_reader :nodes, :namespaces
+
+    def calculate
+      @namespaces = nodes.
+        group_by { |n| n[0...-1][0...1] }.
+        reject { |k, v| k.empty? || v.length < 4 }.
+        map(&:first).
+        uniq
+    end
+  end
+end

data/lib/courgette/reference_to_dependency.rb

@@ -0,0 +1,20 @@
+require 'courgette/name_resolution'
+
+module Courgette
+  class ReferenceToDependency
+    def initialize definitions
+      @resolver = Courgette::NameResolution.new definitions
+    end
+
+    def transform reference
+      definition = @resolver.resolve reference
+      return if definition.nil?
+
+      Dependency.new definition, reference.context.flatten
+    end
+
+    private
+    attr_reader :resolver
+    Dependency = Struct.new :reference, :referrer
+  end
+end

data/lib/courgette/scope.rb

@@ -0,0 +1,14 @@
+module Courgette
+  class Scope
+    def scope sexpr
+      case sexpr[0]
+      when :colon2
+        scope(sexpr[1]) + scope(sexpr[2])
+      when :const
+        scope sexpr[1]
+      else
+        [sexpr]
+      end
+    end
+  end
+end

data/lib/courgette/version.rb

@@ -0,0 +1,4 @@
+module Courgette
+  VERSION = "0.1.0"
+end
+

data/lib/courgette.rb

@@ -0,0 +1,2 @@
+module Courgette
+end

data/test/courgette/test_name_resolution.rb

@@ -0,0 +1,72 @@
+require 'minitest/autorun'
+require 'courgette/name_resolution'
+
+FakeReference = Struct.new :name, :context
+
+class TestCourgetteNameResolution < MiniTest::Unit::TestCase
+  def create definitions
+    @resolver = Courgette::NameResolution.new definitions
+  end
+
+  def test_root_level
+    create [[:RootA], [:RootB]]
+
+    ref = FakeReference.new [:RootA], []
+
+    assert_equal [:RootA], @resolver.resolve(ref)
+  end
+
+  def test_root_unknown
+    create [[:Root]]
+
+    ref = FakeReference.new [:Unknown], []
+
+    assert_equal nil, @resolver.resolve(ref)
+  end
+
+  def test_top_definition_referenced_from_nested
+    create [[:Root]]
+
+    ref = FakeReference.new [:Root], [[:A, :B]]
+    assert_equal [:Root], @resolver.resolve(ref)
+  end
+
+  def test_nested_definition_referenced_from_nested
+    create [[:Scoped, :Name]]
+
+    ref = FakeReference.new [:Name], [[:Scoped]]
+    assert_equal [:Scoped, :Name], @resolver.resolve(ref)
+  end
+
+  def test_double_scope
+    definition = [:Potato, :Scoped, :Name]
+    create [definition]
+
+    ref = FakeReference.new [:Name], [[:Potato], [:Scoped]]
+    assert_equal definition, @resolver.resolve(ref)
+  end
+
+  def test_grouped_double_scope
+    definition = [:Potato, :Scoped, :Name]
+    create [definition]
+
+    ref = FakeReference.new [:Name], [[:Potato, :Scoped]]
+    assert_equal definition, @resolver.resolve(ref)
+  end
+
+  def test_scoped_definition_referenced_double
+    definition = [:Potato, :Name]
+    create [definition]
+
+    ref = FakeReference.new [:Name], [[:Potato], [:Scoped]]
+    assert_equal definition, @resolver.resolve(ref)
+  end
+
+  def test_scoped_definition_referenced_grouped
+    definition = [:Potato, :Name]
+    create [definition]
+
+    ref = FakeReference.new [:Name], [[:Potato, :Scoped]]
+    assert_equal nil, @resolver.resolve(ref)
+  end
+end

data/test/courgette/test_scope.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'courgette/scope'
+
+class TestCourgetteScope < MiniTest::Unit::TestCase
+  def setup
+    @scope = Courgette::Scope.new
+  end
+
+  def test_const
+    assert_equal [:Name], @scope.scope([:const, :Name])
+  end
+
+  def test_other
+    assert_equal [:potato], @scope.scope(:potato)
+  end
+
+  def test_colon2
+    assert_equal [:Scoped, :Name],
+      @scope.scope([:colon2, :Scoped, :Name])
+  end
+
+  def test_compose
+    assert_equal [:Really, :Scoped, :Name],
+      @scope.scope(
+        [:colon2,
+          [:colon2,
+            [:const, :Really],
+            [:const, :Scoped]],
+          [:const, :Name]])
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: courgette
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hugo Peixoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  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'
+- !ruby/object:Gem::Dependency
+  name: commander
+  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'
+- !ruby/object:Gem::Dependency
+  name: graph
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Static ruby dependency analyser
+email:
+- hugo.peixoto@gmail.com
+executables:
+- courgette.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- bin/courgette.rb
+- courgette.gemspec
+- lib/courgette.rb
+- lib/courgette/capturer.rb
+- lib/courgette/commands/graph.rb
+- lib/courgette/commands/stats.rb
+- lib/courgette/directory_analyser.rb
+- lib/courgette/file_to_sexpr.rb
+- lib/courgette/graph.rb
+- lib/courgette/graph2dot.rb
+- lib/courgette/name_resolution.rb
+- lib/courgette/node_grouper.rb
+- lib/courgette/reference_to_dependency.rb
+- lib/courgette/scope.rb
+- lib/courgette/version.rb
+- test/courgette/test_name_resolution.rb
+- test/courgette/test_scope.rb
+homepage: https://github.com/hugopeixoto/courgette
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Courgette analyses a set of files, and calculates a dependency graph
+test_files:
+- test/courgette/test_name_resolution.rb
+- test/courgette/test_scope.rb
+has_rdoc: