depression 0.0.1

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "awesome_print"
+end

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    depression (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (0.3.1)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    test-unit (2.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  depression!
+  mocha
+  test-unit

data/README.rdoc

@@ -0,0 +1,7 @@
+= Easy resolution of before/after relations for Ruby
+
+== Todo
+
+* Drop greedy relations if they conflict with simple relations.
+* Implement a "friendly" mode that doesn't raise errors but simply drops
+  "older" relations until a circular relation is resolved.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.test_files = FileList["test/*_test.rb"]
+end

data/depression.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "depression/version"
+
+Gem::Specification.new do |s|
+  s.name        = "depression"
+  s.version     = Depression::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lars Gierth"]
+  s.email       = ["lars.gierth@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/depression"
+  s.summary     = %q{Easy resolution of before/after relations for Ruby}
+  s.description = %q{depression resolves before/after relations ny forming a
+                     graph of them and flattening it. Simple before/after
+                     relations are supported as well as "greedy" relations
+                     (before/after all other items) with simple relations being
+                     more important in the case of a conflict. Circular
+                     dependencies are detected and cause an exception.}
+
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "mocha"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/depression.rb

@@ -0,0 +1,90 @@
+class Depression
+  def self.process(items)
+    graph = new(items)
+    graph.process
+    graph.result
+  end
+  
+  attr_reader :items, :result
+  
+  def initialize(items)
+    @items, @result, @changed = items, [], false
+  end
+  
+  def process
+    items.each do |item|
+      unless item.respond_to?(:name) && item.name
+        raise "Items need to have a name."
+      end
+    end
+    
+    @data = Hash[*items.map do |item|
+      [item.name, Data.new(0, [])]
+    end.flatten]
+    
+    build_dependencies
+    
+    @data.each do |name, data|
+      increment(name) unless data.relations.empty?
+      data.relations.each do |rel|
+        increment(rel.name) if @data[rel.name].weight <= data.weight
+      end
+    end
+    
+    @result = items.sort do |item, other|
+      @data[item.name].weight.<=>(@data[other.name].weight)
+    end
+  end
+  
+  protected
+  
+  def increment(name)
+    @stack ||= []
+    raise "Circular dep: #{@stack.inspect}" if @stack.include?(name)
+    
+    @stack.push(name)
+    
+    @data[name].weight += 1
+    @data[name].relations.each {|dep| increment(dep.name) }
+    
+    @stack.delete(name)
+  end
+  
+  def build_dependencies
+    items.each do |item|
+      data = @data[item.name]
+      
+      item.relations[:before] ||= []
+      if item.relations[:before] == :all
+        rels = items.map do |item2|
+          next if item.name == item2.name
+          Relation.new(item2.name, :greedy_reverse)
+        end
+        rels.delete(nil)
+        data.relations.push(*deps)
+      else
+        item.relations[:before].each do |name|
+          next unless @data[name]
+          data.relations << Relation.new(name, :normal_reverse)
+        end
+      end
+      
+      item.relations[:after] ||= []
+      if item.relations[:after] == :all
+        @data.each do |name, data2|
+          next if item.name == name
+          data2.relations << Relation.new(item.name, :greedy)
+        end
+      else
+        item.relations[:after].each do |name|
+          next unless @data[name]
+          @data[name].relations << Relation.new(item.name, :normal)
+        end
+      end
+    end
+  end
+  
+  class Data < Struct.new(:weight, :relations); end
+  
+  class Relation < Struct.new(:name, :type); end
+end

data/lib/depression/version.rb

@@ -0,0 +1,3 @@
+class Depression
+  VERSION = "0.0.1"
+end

data/test/depression_test.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + "/helper.rb"
+
+class DepressionTest < Test::Unit::TestCase
+  def setup
+    @item = Proc.new do |n, r|
+      r ||= {}
+      Struct.new(:name, :relations).new(n, r)
+    end
+  end
+  
+  test "has items" do
+    items = [@item.call(:foo), @item.call(:bar)]
+    graph = Depression.new(items)
+    assert_equal items, graph.items
+    
+    assert_raise(NoMethodError) { graph.items = [] }
+  end
+  
+  test "expects items to have a name" do
+    assert_raise(RuntimeError) { Depression.new([:foo]).process }
+    
+    Depression.new([@item.call(:foo)]).process
+  end
+  
+  test "provides a shorthand method for processing items" do
+    items = [@item.call(:foo)]
+    
+    instance = stub("instance")
+    Depression.expects(:new).with(items).returns(instance)
+    instance.expects(:process)
+    instance.expects(:result)
+    
+    Depression.process(items)
+  end
+  
+  test "resolves simple before/after relations" do
+    items = [
+      @item.call(:foo, :before => [:baz]),
+      @item.call(:bar, :after => [:foo]),
+      @item.call(:baz, :after => [:bar]),
+      @item.call(:asd, :before => [:foo]),
+      @item.call(:sdf, :before => [:foo, :baz], :after => [:asd])
+    ]
+    
+    result = Depression.process(items).map {|i| i.name }
+    assert_equal [:asd, :sdf, :foo, :bar, :baz], result
+  end
+  
+  test "resolves greedy before/after relations" do
+    items = [
+      @item.call(:foo, :before => [:bar]),
+      @item.call(:bar, :after => [:all]),
+      @item.call(:baz, :before => [:all])
+    ]
+    
+    result = Depression.process(items).map {|i| i.name }
+    assert_equal [:baz, :foo, :bar], result
+  end
+  
+  test "detects circular relations" do
+    items = [
+      @item.call(:foo, :before => [:bar]),
+      @item.call(:bar, :before => [:baz]),
+      @item.call(:baz, :before => [:asd]),
+      @item.call(:asd, :before => [:foo])
+    ]
+    
+    begin
+      Depression.process(items)
+    rescue => e
+    end
+    assert e.message =~ /^Circular dep:/
+  end
+  
+  test "drops greedy relations in favor of simple relations" do
+    pend("Not yet implemented.")
+  end
+  
+  test "can drop 'older' relations until a circular relation is resolved" do
+    pend("Not yet implemented.")
+  end
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :development)
+
+require "test/unit"
+require "mocha"
+require "awesome_print"
+
+require "depression"

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: depression
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: |-
+  depression resolves before/after relations ny forming a
+                       graph of them and flattening it. Simple before/after
+                       relations are supported as well as "greedy" relations
+                       (before/after all other items) with simple relations being
+                       more important in the case of a conflict. Circular
+                       dependencies are detected and cause an exception.
+email: 
+- lars.gierth@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- depression.gemspec
+- lib/depression.rb
+- lib/depression/version.rb
+- test/depression_test.rb
+- test/helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/depression
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easy resolution of before/after relations for Ruby
+test_files: []
+