class_dependencies 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,17 +1,18 @@
 = class_dependencies
 
-say you have a bunch of classes which have dependencies amongst them, e.g. you have
-A and B which both have a common parent, say Top, and they have a common operation
-but you have to do it to A before you do it to B. then :
-
-  class Top ; include Sonar::ClassDependencies ; end
-  class A < Top ; end
-  class B < Top ; depends_on :a ; end
-
-  Top.ordered_dependencies
-  =>[:a, :b]
-  Top.ordered_dependent_classes
-  =>[A, B]
+say you have a bunch of classes which have a dependency relationship
+e.g. you have A, B and C and a relationship depends_on. you can express
+this as follows :
+
+  module DependsOn ; include Sonar::ClassDependencies ; end
+  class A ; include DependsOn ; depends_on :b ; end
+  class B ; include DependsOn ; depends_on :c ; end
+  class C ; include DependsOn ; end
+
+  DependsOn.ordered_dependencies
+  =>[:c, :b, :a]
+  DependsOn.ordered_dependent_classes
+  =>[C, B, A]
 
 == Install
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/class_dependencies.rb

@@ -1,56 +1,93 @@
 require 'set'
+require 'inflector.rb'
 
-# when included, defines a class method on the module
-# which can be used to declare dependencies amongst descendants
-# of that module
+# include Sonar::ClassDependencies onto a Module or Class
+# then include that Module, or inherit from that Class,
+# and declare dependencies amongst the descendants of
+# that Module or Class, which can be queried on
+# the Module or Class, and ordered by dependency
 # e.g.
-# class Top ; include Sonar::ClassDependencies ; end
-# class A < Top ; depends_on :b ; end
-# class B < Top ; depends_on :c ; end
-# class C < Top ; end
 #
-# Top.ordered_dependencies
+# module SomeDep ; include Sonar::ClassDependencies ; end
+# class A ; include Base ; some_dep :b ; end
+# class B ; include Base ; some_dep :c ; end
+# class C ; include Base ; end
+# SomeDep.ordered_dependencies
 # => [:c, :b, :a]
-# Top.ordered_dependent_classes
+# SomeDep.ordered_dependent_classes
 # => [C, B, A]
 #
+# class AnotherDep ; include Sonar::ClassDependencies ; end
+# class D < Top ; another_dep :e ; end
+# class E < Top ; another_dep :f ; end
+# class F < Top ; end
+# AnotherDep.ordered_dependencies
+# => [:f, :e, :d]
+# AnotherDep.ordered_dependent_classes
+# => [F, E, D]
+
 module Sonar
   module ClassDependencies
+    module ClassName
+      def class_to_sym(klass)
+        klass.to_s.underscore.to_sym
+      end
+
+      def sym_to_class(sym)
+        eval(sym.to_s.camelize)
+      end
+    end
+
     class << self
+      include Sonar::ClassDependencies::ClassName
 
-      # generates a method from a closure returning the value
-      def generate_closure_value_method(obj, method_name, value)
-        obj.send(:define_method, method_name) do
-          value
+      # generates an inclusion method [suitable for included() or inherited() ] on the module 
+      # we are included into,
+      # which generates value proxys for the class_dependencies and obj_descendants
+      def generate_inclusion_method(mod, method_name)
+        mc = mod.instance_eval{class << self ; self ; end}
+        
+        mc.send(:define_method, method_name) do |mod2|
+          raise "include #{mod.to_s} on a Class... doesn't work with intermediate modules" if ! mod2.is_a? Class
+          mod.descendants << class_to_sym(mod2)
+          dep_method_name = class_to_sym(mod)
+          mod2.instance_eval do
+            mc2 = class << self ; self ; end
+            mc2.send(:define_method, dep_method_name){|*params| mod.add_dependency(mod2, *params)}
+          end
         end
       end
-
+      
       def included(mod)
-        mod.instance_eval do
-          class << self
-            ClassDependencies::generate_closure_value_method(self, :class_dependencies, {})
-            ClassDependencies::generate_closure_value_method(self, :descendants, [])
-            include( ClassMethods )
-          end 
+        mc = mod.instance_eval do
+          class << self ; include BaseModuleMethods ; self ; end
         end
+        # generate the dependency list value and the descendants value accessors
+        # on first include : they return a closed over value
+        dependencies = {}
+        descendants = []
+        mc.send(:define_method, :class_dependencies){dependencies}
+        mc.send(:define_method, :descendants){descendants}
+
+        # generate an included method if we are included into a module
+        ClassDependencies::generate_inclusion_method(mod, :included)
+        # and if we are included into a Class, then generate an inherited method too
+        ClassDependencies::generate_inclusion_method(mod, :inherited) if mod.is_a? Class
       end
     end
-    
-    module ClassMethods
-      def inherited(subclass)
-        descendants << subclass.to_s.underscore.to_sym
-      end
 
-      def class_to_sym(klass)
-        klass.to_s.underscore.to_sym
-      end
+    # methods for the base module, on which the dependency map and descendants list live
+    module BaseModuleMethods
+      include Sonar::ClassDependencies::ClassName
 
-      def sym_to_class(sym)
-        eval(sym.to_s.camelize)
-      end
-
-      def depends_on(dep)
-        add_dependency(self, dep)
+      def add_dependency(from, to)
+        from_sym = class_to_sym(from)
+        to_sym = class_to_sym(to)
+        return if from_sym == to_sym
+        deps = (class_dependencies[from_sym] ||= [])
+        raise "circular dependency" if all_dependencies_of(to_sym).include?(from_sym)
+        deps << to_sym
+        nil
       end
 
       def all_dependencies_of(from)
@@ -76,16 +113,6 @@ module Sonar
 
       private
 
-      def add_dependency(from, to)
-        from_sym = class_to_sym(from)
-        to_sym = class_to_sym(to)
-        return if from_sym == to_sym
-        deps = (class_dependencies[from_sym] ||= [])
-        raise "circular dependency" if all_dependencies_of(to_sym).include?(from_sym)
-        deps << to_sym
-        nil
-      end
-
       def find_dependencies_of(from, deps)
         deps << from
         (class_dependencies[from]||[]).each do |dep|

data/lib/inflector.rb

@@ -0,0 +1,32 @@
+# camelize and underscore taken from ActiveSupport
+
+if !defined? Inflector
+  module Inflector
+    extend self
+
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+
+  class String
+    def camelize
+      Inflector::camelize(self)
+    end
+    def underscore
+      Inflector::underscore(self)
+    end
+  end
+end

data/spec/class_dependencies_spec.rb

@@ -1,62 +1,59 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-# camelize and underscore take from ActiveSupport
-module Inflector
-  extend self
-  
-  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-    if first_letter_in_uppercase
-      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    else
-      lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
-    end
-  end
-
-  def underscore(camel_cased_word)
-    camel_cased_word.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-end
-class String
-  def camelize
-    Inflector::camelize(self)
-  end
-  def underscore
-    Inflector::underscore(self)
-  end
-end
-
 describe "ClassDependencies" do
   
-  class Top
+  class BaseDep
     include Sonar::ClassDependencies
   end
 
-  class A < Top
-    depends_on :b
+  class A < BaseDep
+    base_dep :b
   end
 
-  class B < Top
-    depends_on :c
+  class B < BaseDep
+    base_dep :c
   end
 
-  class C < Top
+  class C < BaseDep
   end
   
 
   it "should correctly order class dependences" do
-    Top.ordered_dependencies.should == [:c, :b, :a]
+    BaseDep.ordered_dependencies.should == [:c, :b, :a]
   end
 
   it "should record dependency declarations" do
-    Top.class_dependencies.should == {:a=>[:b], :b=>[:c]}
+    BaseDep.class_dependencies.should == {:a=>[:b], :b=>[:c]}
   end
   
   it "should record class inheritance" do
-    Top.descendants == [:a, :b, :c]
+    BaseDep.descendants == [:a, :b, :c]
+  end
+
+  module AnotherDep
+    include Sonar::ClassDependencies
+  end
+
+  class D
+    include AnotherDep
+    another_dep :e
+  end
+
+  class E
+    include AnotherDep
+    another_dep :f
+  end
+
+  class F
+    include AnotherDep
+  end
+
+  it "should correctly order class dependencies for module include" do
+    AnotherDep.ordered_dependencies.should == [:f, :e, :d]
+  end
+
+  it "should record dependency declarations for module include" do
+    AnotherDep.class_dependencies.should == {:d=>[:e], :e=>[:f]}
   end
 
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - mccraig mccraig of the clan mccraig
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-22 00:00:00 +00:00
+date: 2010-03-23 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,6 +48,7 @@ files:
 - Rakefile
 - VERSION
 - lib/class_dependencies.rb
+- lib/inflector.rb
 - spec/class_dependencies_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb