blueprints 0.7.3 → 0.8.0

data/README.rdoc

@@ -113,19 +113,15 @@ You can just type:
 
 If you need to make associations then:
 
-  SomeModel.blueprint :something, :associated_column => :@association_instance_variable
+  SomeModel.blueprint(:something, :associated_column => d(:some_blueprint))
 
-And if you also need it to depend on other blueprints:
+...or if the name of blueprint and the name of instance variable are not the same:
 
-  SomeModel.blueprint({:something => :some_blueprint}, :associated_column => :@some_iv)
+   SomeModel.blueprint(:something, :associated_column => d(:some_blueprint, :some_instance_variable))
 
-...or...
+...and when you need to pass options to associated blueprint:
 
-  SomeModel.blueprint(:something, :associated_column => :@some_iv).depends_on(:some_blueprint)
-
-...or if name of blueprint that this one depends on and instance variable association uses are the same...
-
-  SomeModel.blueprint(:something, :associated_column => d(:some_blueprint)) # I prefer this one
+   SomeModel.blueprint(:something, :associated_column => d(:some_blueprint, :option => 'value'))
 
 You can learn more about blueprint method in http://wiki.github.com/sinsiliux/blueprints/method-blueprint
 
@@ -148,11 +144,10 @@ which resets database to the state before the test. This state is empty database
 
 == TODO
 
-* Add ability to revert one blueprint.
 * Add preloading blueprints for whole block of tests.
 * Fix rake tasks
 * Add merb support
-* Add support for other test frameworks (check support of cucumber)
+* Add support for other test frameworks
 
 == Credits
 

data/Rakefile

@@ -56,6 +56,8 @@ task :rspec_to_test do
   data.gsub!(/(\s+)lambda \{\n(.*)\n(\s+)\}.should raise_error\((.*)\)/, "\\1assert_raise(\\4) do\n\\2\n\\3end")
   # should =~ => assert_similar
   data.gsub!(/^(\s+)(.*)\.should\s*=~\s*(.*)/, '\1assert_similar(\2, \3)')
+  # A.should_not include(B) => assert_false(A.include?(B))
+  data.gsub!(/^(\s+)(.*)\.should_not\s*include\((.*)\)/, '\1assert(!\2.include?(\3))')
 
   # .should_not => assert(!())
   data.gsub!(/^(\s+)(.*)\.should_not(.*)/, '\1assert(!(\2\3))')

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

data/blueprints.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{blueprints}
-  s.version = "0.7.3"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrius Chamentauskas"]
-  s.date = %q{2010-07-17}
+  s.date = %q{2010-08-13}
   s.default_executable = %q{blueprintify}
   s.description = %q{Another replacement for factories and fixtures. The library that lazy typists will love}
   s.email = %q{sinsiliux@gmail.com}
@@ -38,10 +38,10 @@ Gem::Specification.new do |s|
      "lib/blueprints/context.rb",
      "lib/blueprints/convertable.rb",
      "lib/blueprints/convertable/fixtures.rb",
-     "lib/blueprints/database_backends/active_record.rb",
+     "lib/blueprints/core_ext.rb",
+     "lib/blueprints/dependency.rb",
      "lib/blueprints/errors.rb",
      "lib/blueprints/extensions/cucumber.rb",
-     "lib/blueprints/extensions/deprecated.rb",
      "lib/blueprints/extensions/rspec.rb",
      "lib/blueprints/extensions/test_unit.rb",
      "lib/blueprints/file_context.rb",
@@ -60,7 +60,12 @@ Gem::Specification.new do |s|
      "spec/no_db/fixtures/fruit.rb",
      "spec/no_db/spec_helper.rb",
      "spec/test_all.sh",
+     "spec/unit/active_record_spec.rb",
+     "spec/unit/blueprint_spec.rb",
+     "spec/unit/buildable_spec.rb",
      "spec/unit/configuration_spec.rb",
+     "spec/unit/dependency_spec.rb",
+     "spec/unit/namespace_spec.rb",
      "spec/unit/spec_helper.rb",
      "test/blueprints_test.rb",
      "test/test_helper.rb",
@@ -76,8 +81,13 @@ Gem::Specification.new do |s|
      "spec/no_db/spec_helper.rb",
      "spec/no_db/blueprints_spec.rb",
      "spec/no_db/blueprint.rb",
+     "spec/unit/active_record_spec.rb",
+     "spec/unit/blueprint_spec.rb",
      "spec/unit/spec_helper.rb",
      "spec/unit/configuration_spec.rb",
+     "spec/unit/namespace_spec.rb",
+     "spec/unit/buildable_spec.rb",
+     "spec/unit/dependency_spec.rb",
      "spec/active_record/fixtures/fruit.rb",
      "spec/active_record/fixtures/tree.rb",
      "spec/active_record/fixtures/schema.rb",

data/lib/blueprints/blueprint.rb

@@ -6,12 +6,22 @@ module Blueprints
     def initialize(name, file, &block)
       @file = file
       super(name)
+
+      ivname = :"@#{path}"
       @block = block
+      @demolish_block = lambda { instance_variable_get(ivname).destroy }
+      @update_block = lambda { instance_variable_get(ivname).blueprint(options) }
     end
 
     # Builds blueprint and adds it to executed blueprint hash. Setups instance variable with same name as blueprint if it is not defined yet.
     def build_self(build_once = true)
-      surface_errors { @result = Namespace.root.context.instance_eval(&@block) if @block }
+      surface_errors do
+        if built? and build_once
+          Namespace.root.context.instance_eval(&@update_block) if RootNamespace.root.context.options.present?
+        elsif @block
+          @result = Namespace.root.context.instance_eval(&@block)
+        end
+      end
     end
 
     # Changes blueprint block to build another blueprint by passing additional options to it. Usually used to dry up
@@ -22,7 +32,26 @@ module Blueprints
     end
 
     def backtrace(trace)
-      trace.collect {|line| line.sub(/^\(eval\):(\d+).*/, "#{@file}:\\1:in blueprint '#{@name}'") }
+      trace.collect { |line| line.sub(/^\(eval\):(\d+).*/, "#{@file}:\\1:in blueprint '#{@name}'") }
+    end
+
+    # If block is passed then sets custom demolish block for this blueprint.
+    # If no block is passed then calls demolish block and marks blueprint as not built.
+    # Raises DemolishError if blueprints has not been built.
+    def demolish(&block)
+      if block
+        @demolish_block = block
+      elsif built?
+        Namespace.root.context.instance_eval(&@demolish_block)
+        undo!
+      else
+        raise DemolishError, @name
+      end
+    end
+
+    # Allows customizing what happens when blueprint is already built and it's being built again.
+    def update(&block)
+      @update_block = block
     end
 
     private

data/lib/blueprints/buildable.rb

@@ -1,13 +1,5 @@
 module Blueprints
   class Buildable
-    class Dependency < Struct.new(:name) # :nodoc:
-      alias :to_sym :name
-
-      def iv_name
-        :"@#{name}"
-      end
-    end
-
     attr_reader :name
     attr_accessor :namespace
 
@@ -31,15 +23,12 @@ module Blueprints
 
     # Builds dependencies of blueprint and then blueprint itself.
     #
-    # +build_once+ - pass false if you want to build despite the fact that it was already built.
+    # +build_once+ - pass false if you want to build blueprint again instead of updating old one.
     #
     # +options+ - list of options to be accessible in the body of a blueprint. Defaults to empty Hash.
     def build(build_once = true, options = {})
-      if build_once and Namespace.root.executed_blueprints.include?(path)
-        Blueprints.warn("Building with options, but blueprint was already built", self) if options.present?
-        return @result
-      end
-      Namespace.root.executed_blueprints << path
+      return @result if (built? or Namespace.root.executed_blueprints.include? self) and build_once and options.blank?
+      Namespace.root.executed_blueprints << self
 
       each_namespace {|namespace| namespace.build_parents }
       build_parents
@@ -53,6 +42,17 @@ module Blueprints
       Namespace.root.add_variable(path, @result)
     end
 
+    # Returns if blueprint has been built
+    def built?
+      instance_variable_defined?(:@result)
+    end
+
+    # Marks blueprint as not built
+    def undo!
+      remove_instance_variable(:@result) if built?
+      Namespace.root.executed_blueprints.delete self
+    end
+
     # If value is passed then it sets attributes for this buildable object.
     # Otherwise returns attributes (defaulting to empty Hash)
     def attributes(value)
@@ -69,13 +69,11 @@ module Blueprints
     def self.normalize_attributes(attributes)
       attributes = attributes.dup
       attributes.each do |attr, value|
-        if value.is_a?(Blueprints::Buildable::Dependency)
-          iv_name = value.iv_name
-          Blueprints::Namespace.root.build(value.name)
+        attributes[attr] = value.value if value.is_a?(Blueprints::Dependency)
+        if value.is_a? Symbol and value.to_s =~ /^@.+$/
+          STDERR.puts "DEPRECATION WARNING: :@variables are deprecated in favor of `d` method"
+          attributes[attr] = Blueprints::Namespace.root.context.instance_variable_get(value)
         end
-        iv_name = value if value.is_a? Symbol and value.to_s =~ /^@.+$/
-
-        attributes[attr] = Blueprints::Namespace.root.context.instance_variable_get(iv_name) if iv_name
       end
     end
 

data/lib/blueprints/configuration.rb

@@ -9,8 +9,6 @@ module Blueprints
     attr_reader :root
     # By default blueprints runs each test in it's own transaction. This may sometimes be not desirable so this options allows to turn this off.
     attr_accessor :transactions
-    # Returns ORM that is used, default is :active_record
-    attr_reader :orm
 
     # Sets default attributes for all attributes
     def initialize
@@ -26,15 +24,6 @@ module Blueprints
       @root = defined?(Rails) ? Rails.root : Pathname.pwd
     end
 
-    # Allows specifying what ORM should be used. See SUPPORTED_ORMS to check what values it can contain.
-    def orm=(value)
-      if SUPPORTED_ORMS.include?(value)
-        @orm = value
-      else
-        raise ArgumentError, "Unsupported ORM #{value.inspect}. Blueprints supports only #{SUPPORTED_ORMS.collect(&:inspect).join(', ')}"
-      end
-    end
-
     def filename=(value)
       @filename = Array(value).flatten.collect {|path| Pathname.new(path) }
     end

data/lib/blueprints/core_ext.rb

@@ -0,0 +1,69 @@
+# Include this module into your class if you need klass.blueprint and object.blueprint methods.
+module Blueprints::Blueprintable
+  module ClassMethods
+    # Two forms of this method can be used. First one is typically used inside blueprint block. Essentially it does
+    # same as <tt>create!</tt>, except it does bypass attr_protected and attr_accessible. It accepts only a hash or attributes,
+    # same as <tt>create!</tt> does.
+    #   blueprint :post => [:user, :board] do
+    #     @user.posts.blueprint(:title => 'first post', :text => 'My first post')
+    #   end
+    # The second form is used when you want to define new blueprint. It takes first argument as name of blueprint
+    # and second one as hash of attributes. As you cannot use instance variables outside of blueprint block, you need
+    # to prefix them with colon. So the example above could be rewritten like this:
+    #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => d(:user)).depends_on(:board)
+    def blueprint(name_or_attrs, attrs = {})
+      if Blueprints::FileContext.current
+        define_blueprint(name_or_attrs, attrs)
+      else
+        if name_or_attrs.is_a?(Array)
+          name_or_attrs.collect { |attrs| blueprint(attrs) }
+        else
+          blueprint_object(name_or_attrs)
+        end
+      end
+    end
+
+    private
+
+    def define_blueprint(name, attrs)
+      klass = self
+      blueprint = Blueprints::Blueprint.new(name, Blueprints::FileContext.current.file) { klass.blueprint attributes }
+      blueprint.attributes(attrs)
+      blueprint
+    end
+
+    def blueprint_object(attrs)
+      object = new
+      object.blueprint(attrs)
+      object
+    end
+  end
+
+  def self.included(mod)
+    mod.extend Blueprints::Blueprintable::ClassMethods
+  end
+
+  # Updates attributes of object by calling setter methods.
+  def blueprint(attributes)
+    Blueprints::Blueprint.normalize_attributes(attributes).each do |attr, val|
+      send(:"#{attr}=", val)
+    end
+  end
+end
+
+# Include this instead of Blueprints::Blueprintable if record needs to persist, includes Blueprints::Blueprintable
+module Blueprints::Saveable
+  include Blueprints::Blueprintable
+
+  def self.included(mod)
+    mod.extend Blueprints::Blueprintable::ClassMethods
+  end
+
+  # Overrides object.blueprint to also call save!
+  def blueprint(attributes)
+    super(attributes)
+    save!
+  end
+end
+
+::ActiveRecord::Base.send(:include, Blueprints::Saveable) if defined?(ActiveRecord)

data/lib/blueprints/dependency.rb

@@ -0,0 +1,35 @@
+# Class for defining blueprint dependencies. Accepts up to 3 params:
+# * name - pass the name of blueprint to build when trying to access value of this dependency.
+# * iv_name (optional) - pass the name of instance variable to use for value. Defaults to same name as blueprint name.
+# * options (optional) - pass options that are then passed to blueprint when building.
+# Examples:
+#   Blueprints::Dependency.new(:blueprint).value # Builds blueprint 'blueprint' and returns value of @blueprint instance variable
+#   Blueprints::Dependency.new(:blueprint, value).value # Builds blueprint 'blueprint' and returns value of @value instance variable
+#   Blueprints::Dependency.new(:blueprint, :option => true).value # Builds blueprint 'blueprint' with options and returns value of @value instance variable
+#
+# Blueprints::Dependency objects also catch all missing methods. They are later replayed on instance variable when getting value. Example:
+#   d = Blueprints::Dependency.new(:blueprint).name.size
+#   d.value # => 4 when @blueprint.name == 'John'
+class Blueprints::Dependency
+  # Initializes new copy of Blueprints::Dependency with name, iv_name and options.
+  def initialize(name, *args)
+    @name = name
+    @options = args.extract_options!
+    @iv_name = args.first || @name
+    @registry = []
+  end
+
+  # Builds blueprint (if necessary) and returns the value of instance variable.
+  def value
+    Blueprints::RootNamespace.root.build @name => @options
+    @registry.inject(Blueprints::RootNamespace.root.context.instance_variable_get(:"@#{@iv_name}")) do |value, (method, args, block)|
+      value.send(method, *args, &block)
+    end
+  end
+
+  # Catches all missing methods to later replay when asking for value.
+  def method_missing(method, *args, &block)
+    @registry << [method, args, block]
+    self
+  end
+end

data/lib/blueprints/errors.rb

@@ -1,12 +1,24 @@
 module Blueprints
-  # Is raised when blueprint or namespace is not found.
-  class BlueprintNotFoundError < NameError
-    def initialize(*args)
-      @blueprints = args
+  class Error < StandardError
+    def initialize(blueprint)
+      @name = blueprint
     end
 
     def to_s
-      "Blueprint/namespace not found '#{@blueprints.join(',')}'"
+      "Blueprint '#{@name}' #{message_append}"
+    end
+  end
+
+  class DemolishError < Error
+    def message_append
+      'must be built before demolishing'
+    end
+  end
+
+  # Is raised when blueprint or namespace is not found.
+  class BlueprintNotFoundError < Error
+    def message_append
+      'not found'
     end
   end
 end

data/lib/blueprints/extensions/rspec.rb

@@ -1,6 +1,22 @@
+module DescribeHelper
+  # Creates new before filter that builds blueprints before each spec.
+  def build_blueprint(*names)
+    before { build_blueprint *names }
+  end
+
+  # Same as #build_blueprint except that you can use it to build same blueprint several times.
+  def build_blueprint!(*names)
+    before { build_blueprint! *names }
+  end
+
+  alias :build :build_blueprint
+  alias :build! :build_blueprint!
+end
+
 config_class = defined?(RSpec) ? RSpec : Spec::Runner
 config_class.configure do |config|
   config.include(Blueprints::Helper)
+  config.extend(DescribeHelper)
   config.before do
     Blueprints.setup(self)
   end

data/lib/blueprints/file_context.rb

@@ -29,10 +29,9 @@ module Blueprints
       namespace
     end
 
-    # Creates dependency for current blueprint on some other blueprint and marks that instance variable with same name
-    # should be used for value of column. Only works on "Class.blueprint :name" type of blueprints
-    def d(name)
-      Buildable::Dependency.new(name)
+    # Wrapper around Blueprints::Dependency.new. See Blueprints::Dependency for more information.
+    def d(*args)
+      Dependency.new(*args)
     end
   end
 end

data/lib/blueprints/helper.rb

@@ -33,25 +33,11 @@ module Blueprints
     alias :build :build_blueprint
     alias :build! :build_blueprint!
 
-    # Clears all tables in database. You can pass table names to clear only those tables. You can also pass <tt>:undo</tt> option
-    # to remove scenarios from built scenarios cache.
+    # Demolishes built blueprints (by default simply calls destroy method on result of blueprint, but can be customized).
     #
-    # TODO: add sample usage
-    def demolish(*args)
-      STDERR.puts "DEPRECATION WARNING: demolish is deprecated and will be changed to support per blueprint demolishing in blueprints 0.8.0"
-      options = args.extract_options!
-      args = (ActiveRecord::Base.connection.tables - ['schema_migrations']) if args.blank?
-      args.each {|table| ActiveRecord::Base.connection.execute("DELETE FROM #{table}") }
-
-      if options[:undo] == :all
-        Namespace.root.executed_blueprints.clear
-      else
-        undo = [options[:undo]].flatten.compact.collect(&:to_s)
-        unless (not_found = undo - Namespace.root.executed_blueprints.to_a).blank?
-          raise(BlueprintNotFoundError, not_found)
-        end
-        Namespace.root.executed_blueprints -= undo
-      end
+    #   demolish :apple, :pear
+    def demolish(*names)
+      names.each { |name| Namespace.root[name].demolish }
     end
   end
 end

data/lib/blueprints/namespace.rb

@@ -33,5 +33,10 @@ module Blueprints
     def build_self(build_once = true)
       @result = @children.collect {|p| p.last.build }.uniq
     end
+
+    # Demolished all child blueprints and namespaces
+    def demolish
+      @children.each_value(&:demolish)
+    end
   end
 end

data/lib/blueprints/root_namespace.rb

@@ -3,12 +3,10 @@ module Blueprints
   # building blueprints/namespaces by name. Is also used for copying instance variables between blueprints/contexts/global
   # context.
   class RootNamespace < Namespace
-    attr_reader :context, :blueprints
-    attr_accessor :executed_blueprints
+    attr_reader :context, :executed_blueprints
 
     def initialize
-      @executed_blueprints = Set.new
-      @global_executed_blueprints = Set.new
+      @executed_blueprints = @global_executed_blueprints = []
       @auto_iv_list = Set.new
 
       super ''
@@ -16,8 +14,10 @@ module Blueprints
 
     # Loads all instance variables from global context to current one.
     def setup
-      @context = Blueprints::Context.new
+      (@executed_blueprints - @global_executed_blueprints).each(&:undo!)
       @executed_blueprints = @global_executed_blueprints.clone
+      @context = Blueprints::Context.new
+
       if Blueprints.config.transactions
         Marshal.load(@global_variables).each { |name, value| @context.instance_variable_set(name, value) }
       else
@@ -35,10 +35,10 @@ module Blueprints
     # Sets up global context and executes prebuilt blueprints against it.
     def prebuild(blueprints)
       @context = Blueprints::Context.new
-      @global_scenarios = build(blueprints) if blueprints
-      @global_executed_blueprints = @executed_blueprints
+      build(blueprints) if blueprints
 
-      @global_variables = Marshal.dump(@context.instance_variables.each_with_object({}) {|iv, hash| hash[iv] = @context.instance_variable_get(iv) })
+      @global_executed_blueprints = @executed_blueprints
+      @global_variables = Marshal.dump(@context.instance_variables.each_with_object({}) { |iv, hash| hash[iv] = @context.instance_variable_get(iv) })
     end
 
     # Builds blueprints that are passed against current context. Copies instance variables to context given if one is given.
@@ -46,7 +46,7 @@ module Blueprints
       names = [names] unless names.is_a?(Array)
       result = names.inject(nil) do |result, member|
         if member.is_a?(Hash)
-          member.map {|name, options| self[name].build(build_once, options) }.last
+          member.map { |name, options| self[name].build(build_once, options) }.last
         else
           self[member].build(build_once)
         end

data/lib/blueprints.rb

@@ -4,9 +4,9 @@ require 'database_cleaner'
 require 'set'
 
 files = %w{
-configuration context buildable namespace root_namespace blueprint file_context helper errors extensions/deprecated
+configuration context buildable namespace root_namespace blueprint file_context helper errors dependency core_ext
 }
-files.each {|f| require File.join(File.dirname(__FILE__), 'blueprints', f) }
+files.each { |f| require File.join(File.dirname(__FILE__), 'blueprints', f) }
 
 module Blueprints
   # Contains current configuration of blueprints
@@ -18,12 +18,12 @@ module Blueprints
   def self.setup(current_context)
     Namespace.root.setup
     Namespace.root.copy_ivars(current_context)
-    DatabaseCleaner.start if config.orm
+    if_orm { DatabaseCleaner.start }
   end
 
   # Rollbacks transaction returning everything to state before test. Should be called after every test case.
   def self.teardown
-    DatabaseCleaner.clean if config.orm
+    if_orm { DatabaseCleaner.clean }
   end
 
   # Enables blueprints support for RSpec or Test::Unit depending on whether (R)Spec is defined or not. Yields
@@ -36,7 +36,7 @@ module Blueprints
                 elsif defined? Spec or defined? RSpec
                   'rspec'
                 else
-                   'test_unit'
+                  'test_unit'
                 end
     require File.join(File.dirname(__FILE__), 'blueprints', 'extensions', extension)
   end
@@ -45,12 +45,12 @@ module Blueprints
   def self.load
     return unless Namespace.root.empty?
 
-    require File.join(File.dirname(__FILE__), 'blueprints', 'database_backends', config.orm.to_s) if config.orm
-    DatabaseCleaner.clean_with :truncation if config.orm
-
+    if_orm do
+      DatabaseCleaner.clean_with :truncation
+      DatabaseCleaner.strategy = (config.transactions ? :transaction : :truncation)
+    end
     load_scenarios_files(config.filename)
 
-    DatabaseCleaner.strategy = (config.transactions ? :transaction : :truncation) if config.orm
     Namespace.root.prebuild(config.prebuild) if config.transactions
   end
 
@@ -59,10 +59,10 @@ module Blueprints
       root_sub = /^#{config.root}[\\\/]/
       blueprints_path = File.dirname(__FILE__).sub(root_sub, '')
 
-      bc.add_filter {|line| line.sub(root_sub, '') }
+      bc.add_filter { |line| line.sub(root_sub, '') }
 
-      bc.add_silencer {|line| File.dirname(line).starts_with?(blueprints_path) }
-      bc.add_silencer {|line| Gem.path.any? {|path| File.dirname(line).starts_with?(path) } }
+      bc.add_silencer { |line| File.dirname(line).starts_with?(blueprints_path) }
+      bc.add_silencer { |line| Gem.path.any? { |path| File.dirname(line).starts_with?(path) } }
     end
   end
 
@@ -77,10 +77,18 @@ module Blueprints
   def self.load_scenarios_files(patterns)
     patterns.each do |pattern|
       pattern = config.root.join(pattern)
-      Dir[pattern].each {|f| FileContext.new f }
-      return if Dir[pattern].size > 0
+      files = Dir[pattern.to_s]
+      files.each { |f| FileContext.new f }
+      return if files.size > 0
     end
 
     raise "Blueprints file not found! Put blueprints in #{patterns.join(' or ')} or pass custom filename pattern with :filename option"
   end
+
+  private
+
+  def self.if_orm
+    yield
+  rescue DatabaseCleaner::NoORMDetected, DatabaseCleaner::NoStrategySetError
+  end
 end

data/spec/active_record/blueprint.rb

@@ -44,6 +44,7 @@ Tree.blueprint(:oak_without_attributes)
 
 blueprint :pine do
   @the_pine = Tree.blueprint :name => 'Pine', :size => 'medium'
+  @pine = Tree.blueprint :name => 'Pine', :size => 'small'
 end
 
 Fruit.blueprint(:acorn, :species => 'Acorn', :tree => d(:oak))
@@ -74,7 +75,7 @@ namespace :attributes do
 
   Fruit.blueprint :shortened_cherry, :species => 'cherry'
 
-  Fruit.blueprint :dependent_cherry1, :tree => d(:pine)
+  Fruit.blueprint :dependent_cherry1, :tree => d(:pine, :the_pine)
   Fruit.blueprint(:dependent_cherry2, :tree => :@the_pine).depends_on(:pine)
 end.attributes(:average_diameter => 10, :species => 'fruit with attributes')