deptree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 230b571654f043a6d6d9124bf235c7d319cba19e
+  data.tar.gz: f76179e0f130b7be1cfe834f00783bc608a8571d
+SHA512:
+  metadata.gz: c21d14cbc467bfa9fa816b6c0dc941052c51fda67201267cb31133eb3f0192d9b76be16727634b2b8bed79520d01a5f6abe7a9d376d70455fc9b3b2c93014691
+  data.tar.gz: 94ed3a54b321ff9de72dc5f1dcbf0bdb365334960a07c03b0a3900fc96f6f75d7eeb5caa070e19bc05cd93044105bc2159d675e1279b337dbce4742f0fd5a607

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,11 @@
+language: "Ruby"
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - 2.3.0
+  - rbx-2
+  - jruby
+  - ruby-head

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Andrzej Kajetanowicz
+
+MIT License
+
+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,98 @@
+# Easly manage initialization steps in your Ruby application.
+
+When building Ruby applications, quite often, your application has to be properly configured before it can be run. Configuration steps might include things like: reading config files, instantiating singleton objects (`Logger` for example), configuring various API  clients, establishing connections to databases, message brokers etc. It can become a tedious task if your application is complex and some steps depend on another.
+
+**Deptree** is attempting to solve this problem by exposing declarative DSL that allows to define configuration steps, dependencies between them and most importantly, executing those steps without explicitly specifying the order of invocation.
+
+## Usage
+
+First, you need to define all the configuration steps (with their dependencies) required by your application:
+
+```ruby
+module Application
+  module Dependencies
+    extend Deptree::DSL
+
+    dependency :config_file do
+      configure do
+        Application.config = YAML.load_file('config.yml')[environment]
+      end
+    end
+
+    dependency :logger => :config_file do
+      configure do
+        Application.logger = Logger.new(Application.config.log_path)
+      end
+    end
+
+    dependency :github_client => [:logger, :config_file] do
+      configure do
+        GithubClient.configure do |config|
+          config.host = Application.config.github.host
+          config.logger = Application.logger
+        end
+      end
+    end
+
+    helpers do
+      def environment
+        ENV['RACK_ENV'] || 'development'
+      end
+    end
+  end
+end
+```
+
+Once you're ready to start your app, invoke all the configuration steps:
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'application'
+
+Application::Dependencies.configure
+# At this point **ALL** the configuration steps required by your application
+# will have run in correct order
+
+# Start your application
+Application.run!
+
+```
+
+Alternatively, you can choose to invoke only specific steps:
+
+```ruby
+Application::Dependencies.configure(:logger, :github_client)
+# NOTE: config will be automatically loaded since both (logger and github_cllient) depend on it.
+```
+
+## How it works
+Each configuration step can be represented as a vertex in a [directed graph](https://en.wikipedia.org/wiki/Directed_acyclic_graph) where each dependency between two steps forms an edge. In order to invoke those steps in correct order, we first need to sort those vertices in a [topological order](https://en.wikipedia.org/wiki/Topological_sorting). **Deptree** gem uses a simplified version of *Kahn's* alghoritm to achieve this.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deptree'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deptree
+
+## Code status
+
+[![Build Status](https://travis-ci.org/kajetanowicz/deptree.svg?branch=master)](https://travis-ci.org/kajetanowicz/deptree)
+
+## Contributing
+
+1. Fork it ( https://github.com/kajetanowicz/deptree/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+task default: :spec

data/deptree.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'deptree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "deptree"
+  spec.version       = Deptree::VERSION
+  spec.authors       = ["Andrzej Kajetanowicz"]
+  spec.email         = ["Andrzej.Kajetanowicz@gmail.com"]
+  spec.summary       = %q{Easly manage initialization steps in your Ruby application.}
+  spec.description   = %q{Easly manage initialization steps in your Ruby application.}
+  spec.homepage      = "https://github.com/kajetanowicz/deptree"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

data/lib/deptree.rb

@@ -0,0 +1,14 @@
+require "deptree/version"
+require "deptree/errors"
+require "deptree/dsl"
+require "deptree/registry"
+require "deptree/visitor"
+require "deptree/visitor/kahn"
+require "deptree/dependency/actions"
+require "deptree/dependency/prerequsites_proxy"
+require "deptree/dependency"
+require "deptree/definition"
+require "deptree/arguments_parser"
+
+module Deptree
+end

data/lib/deptree/arguments_parser.rb

@@ -0,0 +1,32 @@
+module Deptree
+  class ArgumentsParser
+    attr_reader :name, :prerequisites
+
+    def initialize(args)
+      @args = args
+    end
+
+    def parse!
+      fail! if @args.size > 1
+      args = @args.first
+
+      case args
+      when String, Symbol
+        @name, @prerequisites = args, []
+      when Hash
+        fail! if args.size != 1
+        @name, @prerequisites = args.map { |k, v| [k, Array(v)] }.first
+      else
+        fail!
+      end
+
+      return self
+    end
+
+    private
+
+    def fail!
+      fail InvalidArgumentError.new(@args)
+    end
+  end
+end

data/lib/deptree/definition.rb

@@ -0,0 +1,23 @@
+module Deptree
+  class Definition < BasicObject
+
+    def self.add(configurable, args, block)
+      parser = ArgumentsParser.new(args).parse!
+      prerequisites = Dependency::PrerequisitesProxy.new(parser.prerequisites, configurable.registry)
+      name = parser.name
+
+      dependency = Dependency.new(name, prerequisites, configurable.helpers)
+      new(dependency).instance_eval(&block)
+      configurable.registry.add(dependency.name, dependency)
+    end
+
+    def initialize(dependency)
+      @dependency = dependency
+    end
+
+    def method_missing(name, &behaviour)
+      @dependency.action(name, &behaviour)
+    end
+  end
+
+end

data/lib/deptree/dependency.rb

@@ -0,0 +1,28 @@
+module Deptree
+  class Dependency
+    attr_reader :name, :prerequisites, :actions
+
+    def initialize(name, prerequisites, helpers)
+      @name = name
+      @prerequisites = prerequisites
+      @helpers = helpers
+      @actions = Actions.new(self)
+    end
+
+    def action(name, &behaviour)
+      @actions.add(name, behaviour)
+    end
+
+    def execute(name)
+      if (action = @actions.find(name))
+        action.execute
+      end
+    end
+
+    def execution_context
+      @execution_context ||= Object.new.tap do |ctx|
+        ctx.extend(@helpers)
+      end
+    end
+  end
+end

data/lib/deptree/dependency/actions.rb

@@ -0,0 +1,41 @@
+module Deptree
+  class Dependency
+    class Actions
+      def initialize(dependency)
+        @dependency, @actions = dependency, []
+      end
+
+      def add(name, behaviour)
+        fail DuplicateActionError.new(@dependency.name, name) if find(name)
+
+        action = Action.new(name, behaviour, @dependency.execution_context)
+        @actions << action
+        action
+      end
+
+      def find(name)
+        @actions.find { |a| a.name == name }
+      end
+
+      def size
+        @actions.size
+      end
+    end
+
+    class Action
+      attr_reader :name
+
+      def initialize(name, behaviour, context)
+        @name, @behaviour, @context = name, behaviour, context
+      end
+
+      def execute
+        @context.instance_eval(&@behaviour)
+      end
+
+      def ==(other)
+        name == other.name
+      end
+    end
+  end
+end

data/lib/deptree/dependency/prerequsites_proxy.rb

@@ -0,0 +1,17 @@
+module Deptree
+  class Dependency
+    class PrerequisitesProxy
+      include Enumerable
+
+      def initialize(names, registry)
+        @names, @registry = names, registry
+      end
+
+      def each(&block)
+        @names.each do |name|
+          block.call(@registry.find(name))
+        end
+      end
+    end
+  end
+end

data/lib/deptree/dsl.rb

@@ -0,0 +1,24 @@
+module Deptree
+  module DSL
+
+    def dependency(*args, &block)
+      Definition.add(self, args, block)
+    end
+
+    def configure(*names)
+      Visitor.each(registry.select(*names)) do |dependency|
+        dependency.execute(:configure)
+      end
+    end
+
+    def helpers(&block)
+      @helpers ||= Module.new
+      @helpers.module_eval(&block) if block_given?
+      @helpers
+    end
+
+    def registry
+      @registry ||= Deptree::Registry.new
+    end
+  end
+end

data/lib/deptree/errors.rb

@@ -0,0 +1,28 @@
+module Deptree
+  class Error < StandardError; end
+
+  class InvalidArgumentError < Error
+    def initialize(arguments)
+      args = arguments.map(&:to_s).join(', ')
+      super("Dependency takes either a String or a Hash with a single key-value pair. Got: #{args}")
+    end
+  end
+
+  class DuplicateActionError < Error
+    def initialize(dependency, action)
+      super("Dependency #{dependency} already contains the definition of action #{action}")
+    end
+  end
+
+  class DuplicateDependencyError < Error
+    def initialize(name)
+      super("Dependency #{name} has already been added.")
+    end
+  end
+
+  class CircularDependencyError < Error
+    def initialize
+      super("Circular dependency detected")
+    end
+  end
+end

data/lib/deptree/registry.rb

@@ -0,0 +1,35 @@
+module Deptree
+  class Registry
+
+    def initialize
+      @dependencies = {}
+    end
+
+    def add(name, dependency)
+      fail DuplicateDependencyError.new(name) if include?(name)
+      @dependencies.store(normalize(name), dependency)
+    end
+
+    def find(name)
+      @dependencies.fetch(normalize(name))
+    end
+
+    def select(*names)
+      if names.empty?
+        @dependencies.values
+      else
+        names.map { |name| find(name) }
+      end
+    end
+
+    def include?(name)
+      @dependencies.has_key?(name)
+    end
+
+    private
+
+    def normalize(name)
+      name.to_s
+    end
+  end
+end

data/lib/deptree/version.rb

@@ -0,0 +1,3 @@
+module Deptree
+  VERSION = "0.1.0"
+end

data/lib/deptree/visitor.rb

@@ -0,0 +1,37 @@
+require 'set'
+
+module Deptree
+  class Visitor
+    def self.each(roots, &block)
+      new(roots).visit(&block)
+    end
+
+    def initialize(roots)
+      @roots = roots
+    end
+
+    def visit(&block)
+      sorted.each(&block)
+    end
+
+    private
+
+    def sorted
+      Kahn.new(nodes).topsort
+    end
+
+    def nodes
+      queue = @roots.dup
+      nodes = Set.new
+
+      while (node = queue.shift) do
+        unless nodes.include?(node)
+          nodes.add(node)
+          node.prerequisites.each { |child| queue.push(child) }
+        end
+      end
+
+      nodes
+    end
+  end
+end

data/lib/deptree/visitor/kahn.rb

@@ -0,0 +1,45 @@
+module Deptree
+  class Visitor
+    class Kahn
+      def initialize(nodes)
+        @nodes = nodes
+      end
+
+      def topsort
+        sorted = []
+        queue = incoming.keys.select { |node| incoming[node].zero? }
+
+        fail CircularDependencyError if queue.empty?
+
+        while (node = queue.shift) do
+          sorted << node
+          node.prerequisites.each do |child|
+            incoming[child] -= 1
+            queue.push(child) if incoming[child].zero?
+          end
+        end
+
+        fail CircularDependencyError unless incoming.values.all?(&:zero?)
+
+        sorted.reverse
+      end
+
+      def incoming
+        @incoming||= compute_incoming_edges(@nodes)
+      end
+
+      def compute_incoming_edges(nodes)
+        incoming = {}
+        nodes.each { |node| incoming[node] = 0 }
+
+        nodes.each do |node|
+          node.prerequisites.each do |child|
+            incoming[child] += 1
+          end
+        end
+
+        incoming
+      end
+    end
+  end
+end

data/spec/deptree/arguments_parser_spec.rb

@@ -0,0 +1,49 @@
+module Deptree
+  describe ArgumentsParser do
+
+      def parse(*args)
+        ArgumentsParser.new(args).parse!
+      end
+
+      it 'retrieves correct dependency name' do
+        parser = parse('bar')
+
+        expect(parser.name).to eq('bar')
+        expect(parser.prerequisites).to eq([])
+      end
+
+      context 'when the dependency has one prerequisite' do
+        it 'retrieves correct name and prerequisites' do
+          parser = parse('foo' => 'bar')
+
+          expect(parser.name).to eq('foo')
+          expect(parser.prerequisites).to eq(['bar'])
+        end
+      end
+
+      context 'when the dependency has many prerequisites' do
+        it 'retrieves correct name and prerequisites' do
+          parser = parse('foo' => ['bar', 'baz'])
+
+          expect(parser.name).to eq('foo')
+          expect(parser.prerequisites).to eq(['bar', 'baz'])
+        end
+      end
+
+      context 'when the dependency name is a Symbol' do
+        it 'retrieves correct name and prerequisites' do
+          parser = parse(:foo => ['bar', 'baz'])
+
+          expect(parser.name).to eq(:foo)
+          expect(parser.prerequisites).to eq(['bar', 'baz'])
+        end
+      end
+
+      context 'when passing invalid arguments' do
+        it 'raises an exception' do
+          expect { parse('foo' => 'bar', 'bar' => 'baz') }.
+            to raise_error(InvalidArgumentError, /Got: {"foo"=>"bar", "bar"=>"baz"}/)
+        end
+      end
+  end
+end

data/spec/deptree/definition_spec.rb

@@ -0,0 +1,32 @@
+module Deptree
+  describe Definition do
+    describe '.add' do
+      let(:configurable) do
+        double(
+          'Configurable',
+          registry: Registry.new,
+          helpers: Module.new
+        )
+      end
+
+      it 'returns a dependency' do
+        expect(Definition.add(configurable, ['foo'], Proc.new {})).to  be_a(Dependency)
+      end
+
+      it 'yields a block within an instance of DefinitionContext' do
+        expect { |b| Definition.add(configurable, ['bar'], b) }.to yield_control.once
+      end
+
+      it 'allows to define various actions' do
+        block = Proc.new do
+          action_one do; end
+          action_two do; end
+          action_three do; end
+        end
+        dependency = Definition.add(configurable, ['baz'], block)
+
+        expect(dependency.actions.size).to eq 3
+      end
+    end
+  end
+end

data/spec/deptree/dependency_spec.rb

@@ -0,0 +1,46 @@
+module Deptree
+  describe Dependency do
+    subject(:dependency) { Dependency.new('foo', [], Module.new) }
+
+    describe '#action' do
+      it 'returns an Action' do
+        action = dependency.action(:configure) do; end
+
+        expect(action).to be_an(Dependency::Action)
+        expect(action.name).to eq :configure
+      end
+
+      it 'does not allow to define an action with the same name twice' do
+        expect {
+          dependency.action(:configure) do; end
+          dependency.action(:configure) do; end
+        }.to raise_error(DuplicateActionError, /foo.*configure/)
+      end
+    end
+
+    describe '#execute' do
+      it 'executes an action' do
+        expect { |blk|
+          dependency.action(:foo, &blk)
+          dependency.execute(:foo)
+
+        }.to yield_control.once
+      end
+
+      it 'executes all actions in the same context' do
+        ctx = self
+        ctx1 = ctx2 = nil
+
+        dependency.action(:action1) { ctx1 = self }
+        dependency.action(:action2) { ctx2 = self }
+
+        dependency.execute(:action1)
+        dependency.execute(:action2)
+
+        expect(ctx1).to eql(ctx2)
+        expect(ctx).not_to eql(ctx1)
+        expect(ctx).not_to eql(ctx2)
+      end
+    end
+  end
+end

data/spec/deptree/dsl_spec.rb

@@ -0,0 +1,65 @@
+describe Deptree::DSL do
+
+  let(:host_class) {
+    Class.new { extend Deptree::DSL }
+  }
+
+  it 'defines DSL for adding dependencies' do
+    expect(host_class).to respond_to(:dependency)
+  end
+
+  it 'defines DSL for configuring dependencies' do
+    expect(host_class).to respond_to(:configure)
+  end
+
+  it 'defines DSL for adding helpers' do
+    expect(host_class).to respond_to(:helpers)
+  end
+
+  describe 'adding a new dependency' do
+    it 'allows to add a new dependency to the Registry' do
+      host_class.dependency 'foo' do; end
+
+      expect(host_class.registry).to include 'foo'
+    end
+  end
+
+  describe '.helpers' do
+    context 'when called without block' do
+      it 'returns a module with helper methods' do
+        expect(host_class.helpers).to be_a(Module)
+      end
+
+      it 'returns the same module when called multiple times' do
+        expect(host_class.helpers).to eq host_class.helpers
+      end
+    end
+
+    context 'when called with block' do
+      it 'defines methods in an anonymous module' do
+        host_class.helpers do
+          def foo
+            # ...
+          end
+
+          def bar
+            # ...
+          end
+        end
+
+        host_class.helpers do
+          def baz;
+            # ...
+          end
+        end
+
+        object = Object.new
+        object.extend(host_class.helpers)
+
+        expect(object).to respond_to(:foo)
+        expect(object).to respond_to(:bar)
+        expect(object).to respond_to(:baz)
+      end
+    end
+  end
+end

data/spec/deptree/registry_spec.rb

@@ -0,0 +1,56 @@
+describe Deptree::Registry do
+  let(:registry) { Deptree::Registry.new }
+
+  before do
+    registry.add('dep1', double('Dependency', name: 'Dependency1'))
+    registry.add('dep2', double('Dependency', name: 'Dependency2'))
+    registry.add('dep3', double('Dependency', name: 'Dependency3'))
+    registry.add('dep4', double('Dependency', name: 'Dependency4'))
+  end
+
+  describe '#add' do
+    it 'registers a dependency' do
+      expect(registry).to_not include('dep_name')
+
+      registry.add('dep_name', double('Dependency1'))
+      expect(registry).to include('dep_name')
+    end
+
+    it 'prevents from adding the same dependency more than once' do
+      expect {
+        registry.add('dep_name', double('Dependency1'))
+        registry.add('dep_name', double('Dependency1'))
+
+      }.to raise_error(Deptree::DuplicateDependencyError, /dep_name/)
+    end
+  end
+
+  describe '#find' do
+    it 'finds dependency by name' do
+      expect(registry.find('dep1').name).to eq 'Dependency1'
+    end
+
+    it 'accepts symbolized names' do
+      expect(registry.find(:dep2).name).to eq 'Dependency2'
+    end
+
+    context 'when trying to find non-existing dependency' do
+      it 'raises an exception' do
+        expect { registry.find('non-existing') }.
+          to raise_error(KeyError, /non-existing/)
+      end
+    end
+  end
+
+  describe '#select' do
+    it 'returns selected dependencies' do
+      expect(registry.select('dep1', 'dep3').size).to eq 2
+    end
+
+    context 'when called without any names' do
+      it 'returns all registered dependencies' do
+        expect(registry.select.size).to eq 4
+      end
+    end
+  end
+end

data/spec/deptree_spec.rb

@@ -0,0 +1,231 @@
+describe '.configure' do
+  it 'handles single dependency' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one do
+        configure { called << :one }
+      end
+    end
+
+    application.configure
+    expect(called).to eq [:one]
+  end
+
+  it 'handles multiple un-linked dependencies' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one do
+        configure { called << :one }
+      end
+      dependency :two do
+        configure { called << :two }
+      end
+      dependency :three do
+        configure { called << :three }
+      end
+    end
+
+    application.configure
+    expect(called.sort).to eq [:one, :three, :two]
+  end
+
+  it 'only resolves specified dependencies' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one do
+        configure { called << :one }
+      end
+      dependency :two do
+        configure { called << :two }
+      end
+      dependency :three do
+        configure { called << :three }
+      end
+    end
+
+    application.configure(:three, :two)
+    expect(called.sort).to eq [:three, :two]
+  end
+
+  it 'makes helpers available in the context of configure block' do
+    ARGS = []
+
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one do
+        configure do
+          foo(:one)
+        end
+      end
+
+      dependency :two do
+        configure do
+          foo(:two)
+        end
+      end
+
+      helpers do
+        def foo(name)
+          ARGS << name
+        end
+      end
+    end
+
+    application.configure
+    expect(ARGS.sort).to eq [:one, :two].sort
+  end
+
+  it 'invokes indirect dependencies' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one => [:two] do
+        configure { called << :one }
+      end
+      dependency :two => :three do
+        configure { called << :two }
+      end
+      dependency :three do
+        configure { called << :three }
+      end
+    end
+
+    application.configure(:one)
+    expect(called.sort).to eq [:one, :three, :two]
+  end
+
+  it 'detects simple circular dependencies' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one =>:two do
+        configure { called << :one }
+      end
+      dependency :two => :one do
+        configure { called << :two }
+      end
+    end
+
+    expect { application.configure }.
+      to raise_error(Deptree::CircularDependencyError)
+  end
+
+  it 'handles 2 ordered dependencies ' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :three => :two do
+        configure { called << :three }
+      end
+      dependency :two do
+        configure { called << :two }
+      end
+    end
+
+    application.configure
+    expect(called.index(:two)).to be < called.index(:three)
+  end
+
+  it 'handles 3 ordered dependencies ' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :three => :two do
+        configure { called << :three }
+      end
+      dependency :four => :three do
+        configure { called << :four }
+      end
+      dependency :two do
+        configure { called << :two }
+      end
+    end
+
+    application.configure
+    expect(called.index(:two)).to be < called.index(:three)
+    expect(called.index(:three)).to be < called.index(:four)
+  end
+
+  it 'handles 6 ordered dependencies ' do
+    called = []
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :five => [:six, :four] do
+        configure { called << :five }
+      end
+      dependency :six do
+        configure { called << :six }
+      end
+      dependency :three => :two do
+        configure { called << :three }
+      end
+      dependency :four => :two do
+        configure { called << :four }
+      end
+      dependency :two do
+        configure { called << :two }
+      end
+      dependency :one => :five do
+        configure { called << :one }
+      end
+    end
+
+    application.configure
+    expect(called.index(:four)).to be < called.index(:five)
+    expect(called.index(:five)).to be < called.index(:one)
+    expect(called.index(:two)).to be < called.index(:one)
+  end
+
+  it 'detects indirect circular dependencies' do
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :five => :four do
+        configure { called << :five }
+      end
+      dependency :six => [:five] do
+        configure { called << :six }
+      end
+      dependency :three => :two do
+        configure { called << :three }
+      end
+      dependency :four => :three do
+        configure { called << :four }
+      end
+      dependency :two => :one do
+        configure { called << :two }
+      end
+      dependency :one => :five do
+        configure { called << :one }
+      end
+    end
+
+    expect { application.configure }.
+      to raise_error(Deptree::CircularDependencyError)
+  end
+
+  it 'detects when dependency in linked to itself' do
+    application = Class.new do
+      extend Deptree::DSL
+
+      dependency :one => :one do
+        configure { called << :one }
+      end
+    end
+
+    expect { application.configure }.
+      to raise_error(Deptree::CircularDependencyError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'deptree'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+  config.order = :random
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: deptree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrzej Kajetanowicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: Easly manage initialization steps in your Ruby application.
+email:
+- Andrzej.Kajetanowicz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- deptree.gemspec
+- lib/deptree.rb
+- lib/deptree/arguments_parser.rb
+- lib/deptree/definition.rb
+- lib/deptree/dependency.rb
+- lib/deptree/dependency/actions.rb
+- lib/deptree/dependency/prerequsites_proxy.rb
+- lib/deptree/dsl.rb
+- lib/deptree/errors.rb
+- lib/deptree/registry.rb
+- lib/deptree/version.rb
+- lib/deptree/visitor.rb
+- lib/deptree/visitor/kahn.rb
+- spec/deptree/arguments_parser_spec.rb
+- spec/deptree/definition_spec.rb
+- spec/deptree/dependency_spec.rb
+- spec/deptree/dsl_spec.rb
+- spec/deptree/registry_spec.rb
+- spec/deptree_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kajetanowicz/deptree
+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: Easly manage initialization steps in your Ruby application.
+test_files:
+- spec/deptree/arguments_parser_spec.rb
+- spec/deptree/definition_spec.rb
+- spec/deptree/dependency_spec.rb
+- spec/deptree/dsl_spec.rb
+- spec/deptree/registry_spec.rb
+- spec/deptree_spec.rb
+- spec/spec_helper.rb