blockenspiel 0.1.0 → 0.1.1

data/History.txt

@@ -1,3 +1,11 @@
+=== 0.1.1 / 2008-11-06
+
+* Added ability to pass the block as the first parameter in
+  the dynamic DSL builder API; cleaned up the API a little
+* Minor fixes to Implementing DSL Blocks paper
+* Some updates to rdocs
+* More test coverage
+
 === 0.1.0 / 2008-10-29
 
 * Alpha release, opened for public feedback

data/ImplementingDSLblocks.txt

@@ -83,7 +83,7 @@ Perhaps you were introduced to Ruby via the {Rails}[http://www.rubyonrails.org/]
 
 Blocks are central to Ruby as a language, and it feels natural to Ruby programmers to use them to delimit specialized code. When designing an API for a Ruby library, blocks like these are, in many cases, a natural and effective pattern.
 
-=== Let's be more precise about what we mean by "DSL block".
+=== Defining DSL blocks
 
 Blocks in Ruby are used for a variety of purposes. In many cases, they are used to provide _callbacks_, specifying functionality to inject into an operation. If you come from a functional programming background, you might see them as lambda expressions; in object-oriented-speak, they implement the Visitor pattern. A simple example is the +each+ method, which iterates over a collection, using the given block as a callback that allows the caller to specify processing to perform on each element.
 
@@ -97,7 +97,7 @@ Note that in both this case and the Routing case, the information contained in t
 
 The RSpec example illustrates a more sophisticated case with many keywords and multiple levels of blocks, but it shares common features with the Rails examples. Again, a language is being defined to describe things that could conceivably have been passed in as parameters, but are being specified in a block for clarity and readability.
 
-So far, we can see that DSL blocks have the following properties:
+Based on this discussion, we can see that DSL blocks have the following properties:
 
 * An API requires a caller to communicate complex descriptive information.
 * The API defines a domain-specific language designed to express this information.
@@ -336,9 +336,8 @@ Using the above method, it becomes easy to generate URL strings:
 
 Our <tt>routes.rb</tt> file, utilizing our "improvement" to the routing DSL, might now like this:
 
-  URL_PREFIX = 'mywebsite/:controller/:action/'
   def makeurl(*params)
-    URL_PREFIX + params.map{ |e| e.inspect }.join('/')
+    'mywebsite/:controller/:action/' + params.map{ |e| e.inspect }.join('/')
   end
   
   ActionController::Routing::Routes.draw do
@@ -522,7 +521,7 @@ Here is a sample implementation of these two techniques for handling instance va
         map.instance_eval(&block)
       ensure                      # Ensure the hashes are cleaned up and instance
         map.cleanup               # variables are pushed back to original_self,
-      end                         # even if the block threw and exception
+      end                         # even if the block threw an exception
       named_routes.install
     end
     
@@ -709,45 +708,45 @@ One more issue with the mixin strategy is that, like all implementations that dr
 
 Mixin's behavior is less straightforward, because of a subtlety in Ruby's method lookup behavior. Under most cases, it behaves similarly to an <tt>instance_eval</tt> with delegation: the DSL's methods take priority. However, if methods have been added directly to the object, they will take precedence over the DSL's methods. Following is an example of this case:
 
- # Suppose we have a DSL block available, via "call_my_dsl",
- # that implements the methods "foo" and "bar"...
- 
- # First, let's implement a simple class
- class MyClass
-   
-   # A test method
-   def foo
-     puts "in foo"
-   end
-   
- end
- 
- # Create an instance of MyClass
- obj = MyClass.new
- 
- # Now, add a new method "bar" to the object.
- def obj.bar
-   puts "in bar"
- end
- 
- # Finally, add a method "run" that runs a DSL block
- def obj.run
-   call_my_dsl do
-     foo         # DSL "foo" method takes precedence over MyClass#foo
-     bar         # The object's "bar" method takes precedence over DSL "bar"
-   end
- end
- 
- # At this point, obj has methods "foo", "bar", and "run"
- # Run the DSL block to test the behavior
- obj.run
+  # Suppose we have a DSL block available, via "call_my_dsl",
+  # that implements the methods "foo" and "bar"...
+  
+  # First, let's implement a simple class
+  class MyClass
+    
+    # A test method
+    def foo
+      puts "in foo"
+    end
+    
+  end
+  
+  # Create an instance of MyClass
+  obj = MyClass.new
+  
+  # Now, add a new method "bar" to the object.
+  def obj.bar
+    puts "in bar"
+  end
+  
+  # Finally, add a method "run" that runs a DSL block
+  def obj.run
+    call_my_dsl do
+      foo         # DSL "foo" method takes precedence over MyClass#foo
+      bar         # The object's "bar" method takes precedence over DSL "bar"
+    end
+  end
+  
+  # At this point, obj has methods "foo", "bar", and "run"
+  # Run the DSL block to test the behavior
+  obj.run
 
 In the above example, suppose both +foo+ and +bar+ are methods of the DSL. They are also both defined as methods of +obj+. (+foo+ is available because it is a method of +MyClass+, while +bar+ is available because it is explicitly added to +obj+.) However, if you run the code, it calls the DSL's +foo+ but +obj+'s +bar+. Why?
 
 The reason points to a subtlety in how Ruby does method lookup. When you define a method in the way +foo+ is defined, it is just added to the class. However, when you define a method in the way +bar+ is defined, it is defined as a "singleton method", and added to the "singleton class", which is an anonymous class that holds methods defined directly on a particular object. It turns out that the singleton class is always given the highest priority in method lookup. So, for example, the lookup order for methods of +obj+ within the block would look like this:
 
- singleton methods of obj  ->  mixin module from the DSL  ->  methods of MyClass
- (e.g. bar, run)               (e.g. foo, bar)                (e.g. foo)
+  singleton methods of obj  ->  mixin module from the DSL  ->  methods of MyClass
+  (e.g. bar, run)               (e.g. foo, bar)                (e.g. foo)
 
 So when the +foo+ method is called, it is not found in the singleton class, but it is found in the mixin, so the mixin's version is invoked. However, when +bar+ is called, it is found in the singleton class, so that version is invoked in favor of the mixin's version.
 
@@ -827,14 +826,14 @@ Atop this basic usage, blockenspiel provides two types of customization. First,
     dsl_method :set_title, :title=     # blocks under these alternate names.
   end
 
-Now, when we use block parameters, we use the methods of the original ConfigMethods class:
+Now, when we use block parameters, we use the methods of the original +ConfigMethods+ class:
 
   create_paper do |config|
     config.author = "Daniel Azuma"
     config.title = "Implementing DSL Blocks"
   end
 
-And omitting the parameter, the alternate method names are mixed in:
+And, when we omit the parameter, the alternate method names are mixed in:
 
   create_paper do
     set_author "Daniel Azuma"
@@ -932,4 +931,4 @@ The Blockenspiel library provides a concrete and robust implementation of DSL bl
 
 === About the author
 
-Daniel Azuma is Chief Software Architect at Zoodango. He has been working with Ruby for about three years, and finds the language generally pleasant to work with, though he thinks the scoping rules could use some improvement. His home page is at http://www.daniel-azuma.com/.
+Daniel Azuma is Chief Software Architect at Zoodango. He has been working with Ruby for about three years, and finds the language generally pleasant to work with, though he thinks the scoping rules could use some improvement. His home page is at http://www.daniel-azuma.com/

data/Manifest.txt

@@ -7,4 +7,5 @@ lib/blockenspiel.rb
 tests/tc_basic.rb
 tests/tc_behaviors.rb
 tests/tc_dsl_methods.rb
+tests/tc_dynamic.rb
 tests/tc_mixins.rb

data/Rakefile

@@ -46,4 +46,40 @@ Hoe.new('blockenspiel', Blockenspiel::VERSION_STRING) do |p_|
   p_.extra_deps = [['mixology', '>= 0.1.0']]
   p_.description_sections = ['blockenspiel']
   p_.url = 'http://virtuoso.rubyforge.org/blockenspiel'
+  p_.clean_globs << 'idslb_markdown.txt'
+end
+
+
+# Custom task that takes the implementing dsl blocks paper
+# and converts it from RDoc format to Markdown
+task :idslb_markdown do
+  File.open('ImplementingDSLblocks.txt') do |read_|
+    File.open('idslb_markdown.txt', 'w') do |write_|
+      linenum_ = 0
+      read_.each do |line_|
+        linenum_ += 1
+        next if linenum_ < 4
+        line_.sub!(/^===\ /, '### ')
+        line_.sub!(/^\ \ /, '    ')
+        if line_[0..3] == '### '
+          line_.gsub!(/(\w)_(\w)/, '\1\_\2')
+        end
+        if line_[0..3] != '    '
+          line_.gsub!('"it_should_behave_like"', '"it\_should\_behave\_like"')
+          line_.gsub!('"time_zone"', '"time\_zone"')
+          line_.gsub!(/\+(\w+)\+/, '`\1`')
+          line_.gsub!(/\*(\w+)\*/, '**\1**')
+          line_.gsub!(/<\/?em>/, '*')
+          line_.gsub!(/<\/?tt>/, '`')
+          line_.gsub!(/<\/?b>/, '**')
+          line_.gsub!(/\{([^\}]+)\}\[([^\]]+)\]/) do |match_|
+            text_, url_ = $1, $2
+            "[#{text_.gsub('_', '\_')}](#{url_})"
+          end
+          line_.gsub!(/\ (http:\/\/[^\s]+)/, ' [\1](\1)')
+        end
+        write_.puts(line_)
+      end
+    end
+  end
 end

data/lib/blockenspiel.rb

@@ -46,7 +46,7 @@ require 'mixology'
 module Blockenspiel
   
   # Current gem version
-  VERSION_STRING = '0.1.0'
+  VERSION_STRING = '0.1.1'.freeze
   
   
   # Base exception for all exceptions raised by Blockenspiel 
@@ -193,17 +193,26 @@ module Blockenspiel
     # To enable automatic exporting of methods to parameterless blocks.
     # After executing this command, all public methods defined in the class
     # will be available on parameterless blocks, until
-    # <tt>dsl_methods false</tt> is called.
+    # <tt>dsl_methods false</tt> is called:
     #  dsl_methods true
     # 
     # To disable automatic exporting of methods to parameterless blocks.
     # After executing this command, methods defined in this class will be
     # excluded from parameterless blocks, until <tt>dsl_methods true</tt>
-    # is called.
+    # is called:
     #  dsl_methods false
     # 
     # To make a list of methods available to parameterless blocks in bulk:
     #  dsl_methods :my_method1, :my_method2, ...
+    # 
+    # You can also point dsl methods to a method of a different name on the
+    # target class, by using a hash syntax, as follows:
+    #  dsl_methods :my_method1 => :target_class_method1,
+    #              :my_method2 => :target_class_method2
+    # 
+    # You can mix non-renamed and renamed method declarations as long as
+    # the renamed (hash) methods are at the end. e.g.:
+    #  dsl_methods :my_method1, :my_method2 => :target_class_method2
     
     def dsl_methods(*names_)
       if names_.size == 0 || names_ == [true]
@@ -311,12 +320,13 @@ module Blockenspiel
       
       def self._invoke_methodinfo(name_, params_, block_)
         info_ = @_blockenspiel_methodinfo[name_]
-        if info_[1]
-          realparams_ = params_ + [block_]
-          info_[0].call(*realparams_)
-        else
-          info_[0].call(*params_)
+        case info_[1]
+        when :first
+          params_.unshift(block_)
+        when :last
+          params_.push(block_)
         end
+        info_[0].call(*params_)
       end
       
     end
@@ -337,22 +347,56 @@ module Blockenspiel
     end
     
     
-    # Make a method available within the block.
+    # === Declare a DSL method.
     # 
+    # This call creates a method that can be called from the DSL block.
     # Provide a name for the method, and a block defining the method's
-    # implementation.
+    # implementation. You may also provided a list of options as follows:
+    # 
+    # The <tt>:block</tt> option controls how the generated method reports
+    # any block provided by the caller. If set to +false+ or not given, any
+    # caller-provided block is ignored. If set to <tt>:first</tt>, the
+    # block is _prepended_ (as a +Proc+ object) to the parameters passed to
+    # the method's implementing block. If set to <tt>:last</tt>, the block
+    # is _appended_. In either case, if the caller does not provide a block,
+    # a value of +nil+ is pre- or appended to the parameter list. A value of
+    # +true+ is equivalent to <tt>:first</tt>.
+    # (This is a workaround for the fact that blocks cannot themselves take
+    # block parameters in Ruby 1.8.)
+    # 
+    # For example, to create a method named "foo" that takes one parameter
+    # and a block, do this:
+    # 
+    #  add_method(:foo, :block => :first) do |block, param|
+    #    puts "foo called with parameter "+param.inspect
+    #    puts "the block returned "+block.call.inspect
+    #  end
+    # 
+    # In your DSL, you can then call:
+    # 
+    #  foo("hello"){ "a value" }
+    # 
+    # By default, a method of the same name is also made available to
+    # parameterless blocks. To change the name of the parameterless method,
+    # provide its name as the value of the <tt>:dsl_method</tt> option.
+    # To disable this method for parameterless blocks, set the
+    # <tt>:dsl_method</tt> option to +false+.
+    # 
+    # For historical reasons, the <tt>:mixin</tt> option is an alias for
+    # <tt>:dsl_method</tt>. However, its use is deprecated.
     # 
-    # By default, a method of the same name is also made available in
-    # mixin mode. To change the name of the mixin method, set its name
-    # as the value of the <tt>:mixin</tt> parameter. To disable the
-    # mixin method, set the <tt>:mixin</tt> parameter to +false+.
+    # The <tt>:receive_block</tt> option is also supported for historical
+    # reasons, but its use is deprecated. Setting <tt>:receive_block</tt> to
+    # +true+ is equivalent to setting <tt>:block</tt> to <tt>:last</tt>.
     
     def add_method(name_, opts_={}, &block_)
-      @target_class._add_methodinfo(name_, block_, opts_[:receive_block])
-      mixin_name_ = opts_[:mixin]
-      if mixin_name_ != false
-        mixin_name_ = name_ if mixin_name_.nil? || mixin_name_ == true
-        @target_class.dsl_method(mixin_name_, name_)
+      receive_block_ = opts_[:receive_block] ? :last : opts_[:block]
+      receive_block_ = :first if receive_block_ && receive_block_ != :last
+      @target_class._add_methodinfo(name_, block_, receive_block_)
+      dsl_method_name_ = opts_[:dsl_method] || opts_[:mixin]
+      if dsl_method_name_ != false
+        dsl_method_name_ = name_ if dsl_method_name_.nil? || dsl_method_name_ == true
+        @target_class.dsl_method(dsl_method_name_, name_)
       end
     end
     

data/tests/tc_basic.rb

@@ -33,6 +33,7 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
+;
 
 
 require File.expand_path("#{File.dirname(__FILE__)}/../lib/blockenspiel.rb")
@@ -120,7 +121,7 @@ module Blockenspiel
           add_method(:set_value) do |key_, value_|
             hash_[key_] = value_
           end
-          add_method(:set_value_by_block, :receive_block => true) do |key_, bl_|
+          add_method(:set_value_by_block, :block => true) do |bl_, key_|
             hash_[key_] = bl_.call
           end
         end

data/tests/tc_behaviors.rb

@@ -33,6 +33,7 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
+;
 
 
 require File.expand_path("#{File.dirname(__FILE__)}/../lib/blockenspiel.rb")

data/tests/tc_dsl_methods.rb

@@ -33,6 +33,7 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
+;
 
 
 require File.expand_path("#{File.dirname(__FILE__)}/../lib/blockenspiel.rb")
@@ -174,6 +175,27 @@ module Blockenspiel
       end
       
       
+      class Target6 < Blockenspiel::Base
+        
+        def initialize(hash_)
+          @hash = hash_
+        end
+        
+        dsl_methods false
+        
+        def set_value1(key_, value_)
+          @hash["#{key_}1"] = value_
+        end
+        
+        def set_value2(key_)
+          @hash["#{key_}2"] = yield
+        end
+        
+        dsl_methods :set_value1, :renamed_set_value2 => :set_value2
+        
+      end
+      
+      
       # Test default dsl method setting.
       # 
       # * Asserts the right dsl methods are added for the default setting.
@@ -277,6 +299,24 @@ module Blockenspiel
       end
       
       
+      # Test dsl_methods with multiple parameters.
+      # 
+      # * Asserts that hash syntax for dsl_methods works.
+      # * Asserts that combined array and hash parameters works.
+      
+      def test_multiple_dsl_methods
+        hash_ = Hash.new
+        block_ = proc do
+          set_value1('a', 1)
+          renamed_set_value2('b'){ 2 }
+          assert_raise(NoMethodError){ set_value2('c', 3) }
+        end
+        Blockenspiel.invoke(block_, Target6.new(hash_))
+        assert_equal(1, hash_['a1'])
+        assert_equal(2, hash_['b2'])
+      end
+      
+      
     end
     
   end

data/tests/tc_dynamic.rb

@@ -0,0 +1,174 @@
+# -----------------------------------------------------------------------------
+# 
+# Blockenspiel dynamic tests
+# 
+# This file contains tests for dynamic DSL generation.
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2008 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/blockenspiel.rb")
+
+
+module Blockenspiel
+  module Tests  # :nodoc:
+    
+    class TestDynamic < Test::Unit::TestCase  # :nodoc:
+      
+      
+      # Test the simple case.
+      # 
+      # * Asserts that the simplest case works.
+      
+      def test_simple
+        block_ = proc do
+          set_value(:a, 1)
+        end
+        hash_ = Hash.new
+        Blockenspiel.invoke(block_) do
+          add_method(:set_value) do |key_, value_|
+            hash_[key_] = value_
+          end
+        end
+        assert_equal(1, hash_[:a])
+      end
+      
+      
+      # Test renaming.
+      # 
+      # * Asserts that the method appears renamed in a parameterless block.
+      # * Asserts that the method appears in its original name in a parametered block.
+      
+      def test_renaming
+        hash_ = Hash.new
+        dsl_definition_ = proc do
+          add_method(:set_value, :dsl_method => :renamed_set_value) do |key_, value_|
+            hash_[key_] = value_
+          end
+        end
+        block1_ = proc do
+          renamed_set_value(:a, 1)
+          assert_raise(NoMethodError){ set_value(:b, 2) }
+        end
+        Blockenspiel.invoke(block1_, &dsl_definition_)
+        block2_ = proc do |dsl_|
+          dsl_.set_value(:c, 3)
+          assert_raise(NoMethodError){ renamed_set_value(:d, 4) }
+        end
+        Blockenspiel.invoke(block2_, &dsl_definition_)
+        assert_equal(1, hash_[:a])
+        assert_nil(hash_[:b])
+        assert_equal(3, hash_[:c])
+        assert_nil(hash_[:d])
+      end
+      
+      
+      # Test calls with blocks.
+      # 
+      # * Asserts that a block passed "first" works.
+      # * Asserts that a block passed "last" works.
+      # * Asserts that a block passed "last" works.
+      
+      def test_blocks_first_and_last
+        hash_ = Hash.new
+        dsl_definition_ = proc do
+          add_method(:set_value1, :block => :first) do |bl_, key_|
+            hash_[key_] = bl_.call
+          end
+          add_method(:set_value2, :block => :last) do |key_, bl_|
+            hash_[key_] = bl_.call
+          end
+          add_method(:set_value3, :block => true) do |bl_, key_|
+            hash_[key_] = bl_.call
+          end
+        end
+        block_ = proc do
+          set_value1(:a){ 1 }
+          set_value2(:b){ 2 }
+          set_value2(:c){ 3 }
+        end
+        Blockenspiel.invoke(block_, &dsl_definition_)
+        assert_equal(1, hash_[:a])
+        assert_equal(2, hash_[:b])
+        assert_equal(3, hash_[:c])
+      end
+      
+      
+      # Test calls with blocks not passed.
+      # 
+      # * Asserts that if a block isn't given, it is set to nil.
+      
+      def test_blocks_nil
+        hash_ = Hash.new
+        dsl_definition_ = proc do
+          add_method(:set_value1, :block => :first) do |bl_, key_|
+            assert_nil(bl_)
+          end
+          add_method(:set_value2, :block => :last) do |key_, bl_|
+            assert_nil(bl_)
+          end
+        end
+        block_ = proc do
+          set_value1(:a)
+          set_value2(:b)
+        end
+        Blockenspiel.invoke(block_, &dsl_definition_)
+        assert_nil(hash_[:a])
+        assert_nil(hash_[:b])
+      end
+      
+      
+      # Test calls with blocks (legacy api)
+      # 
+      # * Asserts that a block passed "first" works.
+      # * Asserts that a block passed "last" works.
+      # * Asserts that a block passed "last" works.
+      
+      def test_blocks_legacy
+        hash_ = Hash.new
+        dsl_definition_ = proc do
+          add_method(:set_value, :receive_block => true) do |key_, bl_|
+            hash_[key_] = bl_.call
+          end
+        end
+        block_ = proc do
+          set_value(:a){ 1 }
+        end
+        Blockenspiel.invoke(block_, &dsl_definition_)
+        assert_equal(1, hash_[:a])
+      end
+      
+      
+    end
+    
+  end
+end

data/tests/tc_mixins.rb

@@ -34,6 +34,7 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
+;
 
 
 require File.expand_path("#{File.dirname(__FILE__)}/../lib/blockenspiel.rb")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: blockenspiel
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-29 00:00:00 -07:00
+date: 2008-11-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,6 +54,7 @@ files:
 - tests/tc_basic.rb
 - tests/tc_behaviors.rb
 - tests/tc_dsl_methods.rb
+- tests/tc_dynamic.rb
 - tests/tc_mixins.rb
 has_rdoc: true
 homepage: http://virtuoso.rubyforge.org/blockenspiel
@@ -86,4 +87,5 @@ test_files:
 - tests/tc_basic.rb
 - tests/tc_behaviors.rb
 - tests/tc_dsl_methods.rb
+- tests/tc_dynamic.rb
 - tests/tc_mixins.rb