def_dsl 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 261b8110ab1aac82ab1db4c553d93761cce94976
-  data.tar.gz: e7143d0ab588b9c93ad750077260e5ba360a5238
+  metadata.gz: e0bf88a700504a38b4fc76da05744ba255305098
+  data.tar.gz: 76cccfdc5bdb63cc32797ede9e91907e631b9688
 SHA512:
-  metadata.gz: 9cf5009a0ad94abeb3f3c74a84a994f077452ef42303f95d2abbaee5998398478d8ef7a09c6eb6c2a16e1618e21e8408546f5e4f675e51333aa2f47e3cb8d99e
-  data.tar.gz: 46a1c3149973383fd39d21b4443a8c94c635108f8b6138229359da44f8e550d44b5b762575a91c13c54d8281334ad2abd94d4bfbcaf1a7b071f3e6a084e296ea
+  metadata.gz: 54a1517902548b0ea57202cf384638bffda51646a5cb10aeaf2fa83e1f751471ca34cf2696085fb6201119a377172a592e48223d76955e9f73e33d731b97b9bd
+  data.tar.gz: 3d86dd7b95305dcd8070b56454552804701385a16912a7575e044e41928538184e538d8a87401509187ec40d59078f18729b239c18f303c152cdecc3e934e806

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.un~
+*.swp

data/Guardfile

@@ -0,0 +1,37 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+notification :tmux, display_message: false
+#notification :tmux,
+#  :display_message => true,
+#  :timeout => 5, # in seconds
+#  :default_message_format => '%s >> %s',
+#  # the first %s will show the title, the second the message
+#  # Alternately you can also configure *success_message_format*,
+#  # *pending_message_format*, *failed_message_format*
+#  :line_separator => ' > ', # since we are single line we need a separator
+#  :color_location => 'status-left-bg' # to customize which tmux element will change color
+
+
+guard 'rspec', all_on_start: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(/\.rb$/) { 'spec' }
+  # some discipline to map lib => spec
+end
+__END__
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/def_dsl.gemspec

@@ -22,4 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
 
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "meta_module"
 end

data/lib/def_dsl.rb

@@ -3,55 +3,179 @@
 #
 # extended at the end of context class
 # rspec!!!!!!!!!!!!!
+# mutant?
+# So is'nt tested
+# more comments inside method - more dumb decisions it has!
 
+require "def_dsl/version"
+require 'meta_module'
 
-# def def_dsl klass
-# end
+#def DefDsl *classes
+#  DefDsl::Dsl.new *classes
+#end
+#alias DefDSL DefDsl
 
-require "def_dsl/version"
+# shortcut to extend and define
+def DefDsl! *black_list
+  Module.new do
+    define_singleton_method :extended do |target|
+      target.send :extend, DefDsl
+      target.def_dsl *black_list
+    end
+  end
+end
+alias DefDSL! DefDsl!
 
 module DefDsl
 
+  module Lazy
+    def feed_block &b; @block_ = b end
+    def block!; @block_ end
+    def call! ctx; ctx.instance_eval &block! end
+  end
+
+  # todo: test so, trash(?)
+  def def_dsl trash = []
+    DefDsl.traverse self, trash do |who|
+      who.send :include, So
+      who.send :include, Lazy if who.instance_eval { @lazy }
+
+      DefDsl.shallow(who, trash).each do |mod|
+        mini = mod.name.underscore # .....
+        method = mod.instance_eval { @dsl } ||  mod.name.underscore
 
-  def def_dsl *const
-    const.each do |const|
-      define_dsl! self, [[const.name.to_s.underscore(self), const]]
+        who.module_eval do
+          define_method method do |*a,&b|
+            so [mini,method],*a,&b # artifact...
+          end
+        end
+        # or check superclass if respond for meta_modules + test
+        if who.class == Module
+          who.send :module_function, method
+        end
+      end
     end
   end
-  alias define_dsl def_dsl  
 
+  # todo: to test optional black list or run mutant :)
+  #
+  # @param given [Class, Module]
+  # @return [Array<Class, Module>] that explicitly defined in given
+  def shallow given, trash = []
+    if given.class == Module;   given.constants.map { |x| given.const_get x }
+    elsif given.class == Class
+      here = given.constants.map { |x| given.const_get x }
+      sup = given.superclass
+      other = sup.constants.map { |x| sup.const_get x }
+      here - other
+    else []
+    end - trash
+  end
+  module_function :shallow # explicit_const or other name?
 
-  def shallow_constants who
-    (who.constants - who.superclass.constants).map { |name| * = name.to_s.underscore, who.const_get(name) }
+  # @param klass
+  # @param trash [Class, Module, Array<Class, Module>]
+  #   optional black list of entities to visit and return
+  # @return [Array<Class, Module>]
+  def all_modules klass, trash = []
+    trash = [*trash]
+    trash += [klass]
+    children = shallow(klass, trash)
+    all = [klass, children.
+           map { |x| all_modules x, trash + children }].
+           flatten.select { |x| Module === x }
+    all
   end
+  module_function :all_modules
 
+  # implicit way to use instance_eval, by passing block with zero arity
+  # @param block [Proc]
+  # @return [Proc]
+  def arity_based &block
+    block.arity == 0 ? proc { |obj| obj.instance_eval &block }
+                     : block
+  end
+  module_function :arity_based
 
-  def define_dsl! who, constants=shallow_constants(who) # ...
-    # constants = constants.nil?? shallow_constants(who) : constants_info(constants)
-    constants.each do |mini, const|
+  # traverse tree of classes and modules, acts {arity_based}
+  #
+  # @param target [Class, Module]       root of search tree
+  # @param trash [Array<Class, Module>] black list of entities to visit and yield
+  # @yield [Class, Module]              once per entity
+  def traverse target, trash = [], &block
+    all_modules(target, trash).each &DefDsl.arity_based(&block)
+  end
+  module_function :traverse
 
-      next if const.included_modules.include? So
-      who.send :include, So
-      define_dsl! const if const.is_a? Class
+  #include MetaModule
+  #class DSL < MModule
+  #  def initialize(*classes) @classes = classes end
+  #  used do |x|
+  #    x.extend DefDsl
+  #    @classes.each { |c| x.def_dsl c }
+  #  end
+  #end
+  #Dsl = DSL
 
-      meth = const.instance_eval { @dsl } || mini
 
-      who.class_eval do
-        define_method(meth) do |*a,&b|
-          so [mini,meth],*a,&b
-        end
-      end
 
-      # const.send :include, So if const.is_a? Module # or even class
-      # who.send :include, So if who.is_a? Module # or even class
-      if who.class == Module
-        who.send :module_function, meth
-        who.send :module_function, :so
-        who.send :module_function, :so1
-        who.send :module_function, :so2
-      end      
-    end
-  end 
+  #
+  #
+  #
+  #
+  #######################################################
+  #
+  #
+  #
+  #
+
+
+
+  #def def_dsl *const
+  #  const.each do |const|
+  #    define_dsl! self, [[const.name.to_s.underscore(self), const]]
+  #  end
+  #end
+  #alias define_dsl def_dsl  
+
+
+#  def shallow_constants who
+#    (who.constants - who.superclass.constants).map { |name| * = name.to_s.underscore, who.const_get(name) }
+#  end
+#
+#
+#  def define_dsl! who, constants=shallow_constants(who) # ...
+#    # constants = constants.nil?? shallow_constants(who) : constants_info(constants)
+#    return if who.included_modules.include? So
+#    who.send :include, So
+#    constants.each do |mini, const|
+#
+#      #next if who.included_modules.include? So
+#      #who.send :include, So
+#      next if const.included_modules.include? So
+#      const.send :include, So
+#      #who.send :include, So
+#      
+#      define_dsl! const if const.is_a? Class
+#
+#      meth =  const.instance_eval { @dsl } || mini
+#
+#      who.class_eval do
+#        define_method(meth) do |*a,&b|
+#          so [mini,meth],*a,&b
+#        end
+#      end
+#
+#      # const.send :include, So if const.is_a? Module # or even class
+#      # who.send :include, So if who.is_a? Module # or even class
+#      if who.class == Module
+#        who.send :module_function, meth
+#        who.send :module_function, :so
+#        who.send :module_function, :so1
+#        who.send :module_function, :so2
+#      end      
+#    end
+#  end 
 
   module So
     def feed_block &block
@@ -87,8 +211,17 @@ module DefDsl
       value = @so[name]
       value.is_a?(Array) ? value : [value]
     end    
+
+    def self.included target
+      if target.class == Module # class.superclass for meta_module...
+        target.send :module_function, :so
+        target.send :module_function, :so1
+        target.send :module_function, :so2
+      end
+    end
   end
 
+
 end
 DefDSL = DefDsl
 
@@ -98,12 +231,56 @@ class String
     self.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
   end
 
-  def underscore(relative_to=nil)
-    name = relative_to.nil?? self : self.sub(/^#{ relative_to.to_s }::/,'')
+  # just last name
+  def underscore    #(relative_to=nil)
+    #name = relative_to.nil?? self : self.sub(/^#{ relative_to.name.to_s }::/,'')
+    name = self
     name.gsub(/::/, '/').
          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
          gsub(/([a-z\d])([A-Z])/,'\1_\2').
          tr("-", "_").
-         downcase
+         downcase.
+         split('/').last
   end
 end
+__END__
+  #def def_dsl *classes
+  #  classes.any?? def_dsl!(classes) : def_dsl!
+  #end
+  #def def_dsl #*classes #=shallow(self)
+  #  classes
+  #  classes.each do |klass|
+  #    klass.def_dsl_shallow # WTF?  #klass
+  #  end
+  #  #magic = So
+  #  #self.send :include, magic #unless self.included_modules.include? magic
+  #  #p self
+  #  #classes.each do |klass|
+  #  #  DefDsl.include_recursively klass, magic
+  #  #end
+  #end
+  #def def_dsl_shallow targets = shallow(self); root = self
+  #  [*targets].each do |x|
+  #    meth = x.instance_eval { @dsl } || x.name.to_s.underscore(root)
+  #    root.class_eval do
+  #      define_method(meth) do |*a,&b|
+  #        #so [mini,meth],*a,&b
+  #      end
+  #    end
+  #    if root.class == Module
+  #      root.send :module_function, meth
+  #      #who.send :module_function, :so
+  #      #who.send :module_function, :so1
+  #      #who.send :module_function, :so2
+  #    end      
+  #  end
+  #end
+
+  ####def include_recursively target, mod, &block
+  ####  all_modules(target).each do |x|
+  ####    x.send :include, mod
+  ####    x.instance_eval &block if block
+  ####  end
+  ####end
+  ####module_function :include_recursively
+  ####module_function :all_modules, :shallow

data/lib/def_dsl/version.rb

@@ -1,3 +1,3 @@
 module DefDsl
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/exmaple_spec.rb

@@ -1,4 +1,4 @@
-describe [DefDsl,DefDSL].join' or ' do
+describe 'DefDsl or DefDSL' do
   after { remove_const :My if defined? My }
 
   example 'usage inside module' do
@@ -10,8 +10,7 @@ describe [DefDsl,DefDSL].join' or ' do
         File = File
       end
 
-      extend DefDSL
-      def_dsl Dir, File
+      extend DefDSL! # accepts optional black list of classes
 
       file 'root.txt'
       dir 'dir' do
@@ -42,7 +41,7 @@ describe [DefDsl,DefDSL].join' or ' do
       end
 
       extend DefDSL
-      def_dsl Dir, File
+      def_dsl # accepts optional black list of classes
 
       def initialize
         file 'root.txt'
@@ -77,7 +76,7 @@ describe [DefDsl,DefDSL].join' or ' do
       end
 
       extend DefDSL
-      def_dsl ADir, AFile
+      def_dsl #ADir, AFile
 
       file 'root.txt'
       dir 'dir' do
@@ -112,7 +111,7 @@ describe [DefDsl,DefDSL].join' or ' do
       end
 
       extend DefDSL
-      def_dsl Dir, File
+      def_dsl #Dir, File
 
       file 'root.txt' do
         this.block.should_be just stored.in_ivar
@@ -137,7 +136,7 @@ describe [DefDsl,DefDSL].join' or ' do
   end
 
 
-  example 'lazy evaluation' do
+  example 'lazy evaluation' do # useless
     pending
     class My
       class File < Struct.new :name; end
@@ -147,7 +146,7 @@ describe [DefDsl,DefDSL].join' or ' do
       end
 
       extend DefDSL
-      def_dsl Dir, File
+      def_dsl #Dir, File
 
       def initialize &block
         @block = block
@@ -195,4 +194,41 @@ describe [DefDsl,DefDSL].join' or ' do
     pending
   end  
 
-end
+
+  example 'easy dsl' do
+    module My
+      class Use123; end
+
+      extend DefDsl!
+      use123
+      so.should == {use123: so1(:use123)}
+    end
+  end
+
+  example 'declarative way to remember block' do
+    module My
+      class Blocky
+        @lazy = true # should remember block to be used in other context
+      end            # lazy is too short to ignore
+      extend DefDSL!
+
+      blocky do |x|
+        @a = (@a || 0) + 1
+      end
+
+      context = Object.new
+      so1(:blocky).call!(context)
+      context.instance_eval { @a }.should == 1
+
+      #so.should == {file: so1(:file), dir: so1(:dir)}
+      #class Blocky < Struct.new :shit
+      #end
+      #extend DefDsl #(Block)
+      #def_dsl Blocky
+      #blocky do
+      #  @a = 123
+      #end
+      #expect { my.so1(:block).call! }.to change { my.so1(:block).instance_eval{@a} }.from(nil).to(123)
+    end
+  end
+end

data/spec/support/remove_const.rb

@@ -1,3 +1,3 @@
-def remove_const name
-  Object.send :remove_const, name  
-end
+def remove_const *names
+  names.each { |name| Object.send :remove_const, name }
+end

data/spec/unit/def_dsl/all_modules_spec.rb

@@ -0,0 +1,255 @@
+describe DefDsl do
+  #subject { DefDsl }
+  after { remove_const :My if defined? My }
+
+  describe '.shallow' do
+    it '<:*works*:>' do
+      module My
+        X = Class.new
+        class ASuper
+          B = Class.new
+          C = Class.new
+        end
+        class Super < ASuper
+          A = Class.new
+          Y = Class.new
+        end
+        class B < Super
+          A = Class.new
+          B = Class.new
+          C = Class.new
+        end
+      end
+
+      DefDsl.shallow(My::B).should == [My::B::A, My::B::B, My::B::C]
+    end
+  end
+
+  # todo find a better place for helpers
+  describe '.arity_based' do
+    it 'wraps block with instance_eval if block.arity == 0' do
+      a = [1,2,3].map &DefDsl.arity_based { to_s }
+      a.should == %w[1 2 3]
+    end
+    it 'just returns given block otherwise' do
+      a = proc { |x| }
+      DefDsl.arity_based(&a).should == a
+    end
+  end
+  
+
+  describe '#def_dsl' do
+    #it 'traverse self, includes So; So.included does other work?'
+    #it 'define dsl for each AMBIGUOUS?
+    #it 'takes optional black list'
+    it 'includes So... in self and each who is_a module' do
+      module My
+        @magic = DefDsl::So # name...
+
+        class A; end; class B; end
+        class C
+          module E
+            class D; end
+          end
+        end
+
+        extend DefDsl
+      
+        [My,A,B,C,C::E,C::E::D].map { |x| x.include? @magic }.should == [false]*6
+        def_dsl
+        [My,A,B,C,C::E,C::E::D].map { |x| x.include? @magic }.should == [true]*6
+
+        #extend RSpec::Matchers ### redefines method `include`...
+        #RSpec::Matchers.expect { def_dsl }.to RSpec::Matchers.change {
+        #  [My, A, B, C, C::E, C::E::D].map { |x| x.include? @magic }
+        #}.from([false]*6).to([true]*6)
+      end
+    end
+    it 'defines dsl methods for classes inside module' do
+      module My
+        class A; end
+        class B
+          class C; end
+        end
+
+        extend DefDsl
+        def_dsl
+        extend RSpec::Matchers
+        expect { a;b;B.new.c }.not_to raise_error
+      end
+    end
+    it 'defines dsl methods for classes inside class' do
+      class My
+        class A < Struct.new :any; end
+        class B
+          class C; end
+        end
+
+        extend DefDsl
+        def_dsl
+        self
+      end.new.instance_eval do
+        extend RSpec::Matchers
+        expect { a;b;My::B.new.c }.not_to raise_error
+      end
+    end
+  end
+
+  describe '.traverse' do
+    it 'acts arity based' do
+      module My
+        class A; end; class B; end
+
+        DefDsl.should_receive(:arity_based).once
+        DefDsl.traverse(My) { }
+      end
+    end
+    context 'one argument' do
+      it 'runs block in context of each found module once per entity' do
+        module My
+          class A
+          end
+          class B
+            module C
+              A = A
+              X = A
+              Y = B
+            end
+          end
+          DefDsl.traverse My do
+            @count = (@count || 0) + 1
+          end
+          [A, B, B::C, B::C::A, B::C::X, B::C::Y].each do |x|
+            x.instance_eval { @count }.should == 1
+          end
+        end
+      end
+    end
+    context 'two arguments' do # not very useful but emergent anyway!
+      it 'takes optional black list of entities to visit and yield' do
+        module My
+          class A
+          end
+          class B
+            module C
+              A = A
+              X = A
+              Y = B
+            end
+          end
+          DefDsl.traverse My, [A] do
+            @count = (@count || 0) + 1
+          end
+          [A, B::C::A, B::C::X].each do |x|
+            x.instance_eval { @count }.should == nil
+          end
+          [B, B::C, B::C::Y].each do |x|
+            x.instance_eval { @count }.should == 1
+          end
+        end
+      end
+    end
+  end
+
+  describe '.all_modules' do
+    # todo: returns '' do instead of it '' do 
+    it 'returns all unique nested modules and classes' do
+      module My
+        ODDMy = My
+        ODD = 1
+        A = Class.new
+        class B
+          ODDB = B
+          ODDA = A
+          C = Module.new
+          ODD = 1
+          module D
+            ODDB = B
+            E = Module.new
+            ODD = 1
+          end
+        end
+        module F
+          ODD = 1
+          G = Module.new
+        end
+      end
+
+      DefDsl.all_modules(My).map(&:name).map{|x|x.split('::').last}.should == ['My',*'A'..'G']
+    end
+    it 'takes optional black list of entities to visit and return' do
+      module My
+        A = Class.new
+        class B
+          C = Class.new
+        end
+
+        DefDsl.all_modules(My, My::B).should == [My,My::A]
+      end
+    end
+  end
+end
+__END__
+  describe '#def_dsl_shallow' do
+    it 'defines dsl methods for each shallow nested module if no argument given' do
+      module My
+        A = Class.new
+        B = Module.new
+        extend DefDsl
+        extend RSpec::Matchers
+        expect { def_dsl_shallow }.to change { (a && b) rescue :err }.from(:err)
+      end
+    end
+    it 'defines dsl methods only for given classes/modules' do
+      module My
+        A = Class.new
+        B = Module.new
+        extend DefDsl
+        extend RSpec::Matchers
+        expect { def_dsl_shallow A }.to change {
+          [:a,:b].select { |x| respond_to? x } }.from([]).to([:a])
+      end
+    end
+  end
+
+  #describe 'def_dsl' do
+  #  it 'calls def_dsl_shallow for self and each nested module recursively' do
+  #    module My
+  #      A = Module.new
+  #      class B
+  #        C = Class.new
+  #      end
+  #      extend DefDsl
+  #      extend RSpec::Matchers
+  #      ########## DefDsl.should_receive(:def_shallow_dsl) ###
+  #      def_dsl
+  #      expect { def_dsl }.to change {
+  #        respond_to?(:a) # && respond_to?(:b) && B.new.respond_to?(:c)
+  #      }.from(false).to(true)
+  #    end
+  #  end
+  #  it 'include ***crap*** in self' do#.include_recursively for given module' do
+  #    module My
+  #      class A; end
+  #      #DefDsl.should_receive(:include_recursively).with(My, DefDsl::So)
+  #      extend DefDsl
+  #      extend RSpec::Matchers
+  #      expect { My.def_dsl A }.to change { My.included_modules }
+  #    end
+  #  end
+  #end
+    #it 'includes second module into first and all its children' do
+    #  module My
+    #    @rec = Module.new
+    #    class A
+    #    end
+    #    class B
+    #      module C
+    #      end
+    #    end
+    #    DefDsl.include_recursively My, @rec
+    #    [A, B, B::C].each do |x|
+    #      x.included_modules.include?(@rec).should == true
+    #    end
+    #  end
+    #end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: def_dsl
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Alexander K
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-24 00:00:00.000000000 Z
+date: 2013-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  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: meta_module
+  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: easy way to build dsl without use of dsl...
 email:
 - xpyro@ya.ru
@@ -62,6 +90,7 @@ files:
 - .gitignore
 - .rspec
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -72,6 +101,7 @@ files:
 - spec/support/remove_const.rb
 - spec/support/require_self.rb
 - spec/support/spec_helper.rb
+- spec/unit/def_dsl/all_modules_spec.rb
 homepage: https://github.com/sowcow/def_dsl
 licenses:
 - MIT
@@ -101,3 +131,4 @@ test_files:
 - spec/support/remove_const.rb
 - spec/support/require_self.rb
 - spec/support/spec_helper.rb
+- spec/unit/def_dsl/all_modules_spec.rb