blueprints 0.9.0 → 1.0.0

data/lib/blueprints/version.rb

@@ -1,3 +1,3 @@
 module Blueprints
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

data/lib/generators/blueprints/model/model_generator.rb

@@ -0,0 +1,29 @@
+module Blueprints
+  class ModelGenerator < Rails::Generators::NamedBase
+    argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+    def create_blueprint
+      blueprint = "#{class_name}.blueprint :#{singular_name}"
+      attributes.each do |attribute|
+        blueprint << ", :#{attribute.name} => #{default_for(attribute)}"
+      end
+
+      dir = File.exists?('spec') ? 'spec' : 'test'
+      file = "#{dir}/blueprint.rb"
+      create_file file unless File.exists?(file)
+      append_file file, "#{blueprint}\n"
+    end
+
+    private
+
+    def default_for(attribute)
+      if attribute.reference?
+        "d(:#{attribute.name})"
+      else
+        attribute.default.inspect
+      end
+    end
+  end
+end
+
+Rails::Generators.hide_namespace(:blueprints)

data/spec/blueprints_spec.rb

@@ -1,4 +1,8 @@
-require File.dirname(__FILE__) + '/spec_helper'
+if RUBY_VERSION.start_with?('1.9')
+  require_relative 'spec_helper'
+else
+  require File.dirname(__FILE__) + '/spec_helper'
+end
 
 describe Blueprints do
   it "should return result of built scenario when calling build" do
@@ -70,6 +74,7 @@ describe Blueprints do
   describe "build per describe" do
     unless File.dirname(__FILE__) =~ /test$/
       build_blueprint :apple
+      build :acorn => {:tree => d(:pine)}
 
       it "should have cherry" do
         @apple.should_not be_nil
@@ -78,6 +83,10 @@ describe Blueprints do
       it "should have correct cherry species" do
         @apple.species.should == 'apple'
       end
+
+      it "should set tree to pine" do
+        @acorn.tree.should == @pine
+      end
     end
   end
 
@@ -371,4 +380,12 @@ describe Blueprints do
   it "should allow inferring blueprint name" do
     build(:infered).name.should == 'infered'
   end
+
+  it "should allow building with :new strategy" do
+    build_with(:new, :oak)
+    @oak.should be_instance_of(Tree)
+    @oak.should be_new_record
+    @oak.name.should == 'Oak'
+    @oak.size.should == 'large'
+  end
 end

data/spec/support/active_record/initializer.rb

@@ -1,15 +1,19 @@
+db_config = YAML::load_file(File.expand_path("../database.yml", __FILE__))
+ActiveRecord::Base.establish_connection(db_config)
+ActiveRecord::Base.logger = @logger
+
 class Fruit < ActiveRecord::Base
   belongs_to :tree
 end
 
 class Tree < ActiveRecord::Base
   attr_protected :size
-  has_many :fruits
-end
+  has_many :fruits, :after_add => :fruit_after_add
+  belongs_to :main_fruit, :class_name => 'Fruit'
 
-db_config = YAML::load(Root.join("spec/support/active_record/database.yml").read)
-ActiveRecord::Base.establish_connection(db_config)
-ActiveRecord::Base.logger = @logger
+  def fruit_after_add(_)
+  end
+end
 
 @rspec1 = @version.to_s[0, 1] == '2'
 @transactions = true

data/spec/support/none/initializer.rb

@@ -44,6 +44,10 @@ class NoneOrm
   def destroy
     self.class.destroy(self)
   end
+
+  def new_record?
+    true
+  end
 end
 
 class Fruit < NoneOrm

data/spec/unit/active_record_spec.rb

@@ -1,12 +1,66 @@
-require 'active_record'
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require File.dirname(__FILE__) + '/../support/active_record/initializer'
 
 describe ActiveRecord::Base do
+  subject do
+    Tree.blueprint(:name => 'tree')
+  end
+
   it "should allow calling blueprint on associations" do
-    tree = Tree.blueprint(:name => 'tree')
-    fruit = tree.fruits.blueprint(:species => 'fruit')
+    fruit = subject.fruits.blueprint(:species => 'fruit')
     fruit.should be_instance_of(Fruit)
     fruit.species.should == 'fruit'
+    fruit.tree.should == subject
+  end
+
+  it "should update object on belongs to association" do
+    subject.create_main_fruit(:species => 'fruit')
+    subject.main_fruit.blueprint(:species => 'apple')
+    subject.main_fruit.reload.species.should == 'apple'
+  end
+
+  describe "association callbacks" do
+    after do
+      class Tree
+        def fruit_after_add(fruit)
+        end
+      end
+    end
+
+    it "should call associations specific callbacks when calling blueprint on association" do
+      class Tree
+        def fruit_after_add(fruit)
+          fruit.average_diameter = -1
+        end
+      end
+
+      fruit = subject.fruits.blueprint(:species => 'fruit')
+      fruit.average_diameter.should == -1
+    end
+
+    it "should have fields set in callback" do
+      Tree.class_eval do
+        define_method(:fruit_after_add) do |fruit|
+          fruit.species.should == 'fruit'
+        end
+      end
+
+      subject.fruits.blueprint(:species => 'fruit')
+    end
+  end
+
+  describe "defining blueprints" do
+    describe "inferring name" do
+      it "should infer name from class name" do
+        blueprint = nil
+        Blueprints::Context.eval_within_context({}) { blueprint = Tree.blueprint :attr => 'val' }
+        blueprint.name.should == :tree
+      end
+
+      it "should still infer name from name default attributes first" do
+        blueprint = nil
+        Blueprints::Context.eval_within_context({}) { blueprint = Tree.blueprint :name => 'my_tree' }
+        blueprint.name.should == :my_tree
+      end
+    end
   end
 end

data/spec/unit/blueprint_name_proxy_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blueprints::BlueprintNameProxy do
+  subject do
+    Blueprints::BlueprintNameProxy.new(:regexp_blueprint, namespace_regexp_blueprint)
+  end
+
+  it "should pass matched groups as options" do
+    subject.build(stage)
+    stage.instance_variable_get(:@namespace_regexp_blueprint).should == {:arg0 => 'blueprint'}
+  end
+
+  it "should pass any other options" do
+    namespace_regexp_blueprint.expects(:build).with(stage, :options => {:passed => 1, :arg0 => 'blueprint'}, :rebuild => true, :name => :regexp_blueprint)
+    subject.build(stage, :options => {:passed => 1}, :rebuild => true)
+  end
+
+  it "should allow capturing named groups" do
+    if RUBY_VERSION.start_with?('1.9')
+      regexp = 'regexp_(?<name>.*)'
+      namespace_regexp_blueprint(Regexp.new(regexp))
+      subject.build(stage)
+      stage.instance_variable_get(:@namespace_regexp_blueprint).should == {:name => 'blueprint'}
+    end
+  end
+
+  it "should allow demolishing buildable" do
+    subject.build(stage).expects(:destroy)
+    subject.demolish(stage)
+  end
+end

data/spec/unit/blueprint_spec.rb

@@ -1,13 +1,37 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Blueprints::Blueprint do
-  it "should rewrite trace" do
-    context         = Blueprints::Context.new(:file => __FILE__)
-    error_blueprint = Blueprints::Blueprint.new(:error, context) { raise 'error' }
-    begin
-      error_blueprint.build(stage)
-    rescue RuntimeError => e
-      e.backtrace[0].should =~ %r{spec/unit/blueprint_spec.rb:#{__LINE__ - 4}:in blueprint 'error'}
+  describe "backtrace" do
+    before do
+      blueprint { raise 'error' }
+    end
+
+    it "should rewrite trace" do
+      begin
+        blueprint.build(stage)
+      rescue RuntimeError => e
+        e.backtrace[0].should == "While building blueprint 'blueprint'"
+      end
+    end
+
+    it "should set correct order of trace" do
+      blueprint2.depends_on(:blueprint)
+      begin
+        blueprint2.build(stage)
+      rescue RuntimeError => e
+        e.backtrace[0].should == "While building blueprint 'blueprint'"
+        e.backtrace[1].should == "While building blueprint 'blueprint2'"
+      end
+    end
+
+    it "should set correct order of trace when building blueprint within blueprint" do
+      blueprint2 { build :blueprint }
+      begin
+        blueprint2.build(stage)
+      rescue RuntimeError => e
+        e.backtrace[0].should == "While building blueprint 'blueprint'"
+        e.backtrace[1].should == "While building blueprint 'blueprint2'"
+      end
     end
   end
 
@@ -22,7 +46,7 @@ describe Blueprints::Blueprint do
       it "should not increase build count if blueprint was already built" do
         blueprint.build(stage)
         lambda {
-          blueprint.build(stage, false)
+          blueprint.build(stage, :rebuild => true)
         }.should_not change(blueprint, :uses)
       end
     end
@@ -51,25 +75,129 @@ describe Blueprints::Blueprint do
       it "should reset auto variable" do
         blueprint.build(stage)
         stage.instance_variable_set(:@blueprint, :false_result)
-        blueprint.build(stage, false)
+        blueprint.build(stage, :rebuild => true)
         stage.instance_variable_get(:@blueprint).should == mock1
       end
     end
 
-    it "should allow passing options" do
-      (result = mock).expects(:options=).with(:option => 'value')
-      blueprint2 { result.options = options }.build(stage, true, :option => 'value')
+    describe "dependencies" do
+      before do
+        blueprint
+        blueprint2
+      end
+
+      it "should automatically build dependencies" do
+        blueprint3.depends_on(:blueprint).build(stage)
+        blueprint.should be_built
+      end
+
+      it "should set return value to array of all dependent blueprints" do
+        blueprint3.depends_on(:blueprint, :blueprint2).build(stage)
+        stage.instance_variable_get(:@blueprint3).should == [mock1, mock1]
+      end
     end
 
-    it "should include attributes for blueprint" do
-      (result = mock).expects(:attributes=).with(:option => 'value')
-      blueprint2 { result.attributes = attributes }.attributes(:option => 'value').build(stage)
+    describe 'options and attributes' do
+      it "should allow passing options" do
+        (result = mock).expects(:options=).with(:option => 'value')
+        blueprint2 { result.options = options }.build(stage, :options => {:option => 'value'})
+      end
+
+      it "should include attributes for blueprint" do
+        (result = mock).expects(:attributes=).with(:option => 'value')
+        blueprint2 { result.attributes = attributes }.attributes(:option => 'value').build(stage)
+      end
+
+      it "should not overwrite options and attributes methods" do
+        def stage.options
+          :options
+        end
+
+        def stage.attributes
+          :attributes
+        end
+
+        blueprint2.build(stage, :options => {:option => 'value'})
+
+        stage.options.should == :options
+        stage.attributes.should == :attributes
+      end
+
+      it "should not try to remove options and attributes methods if they're not defined by singleton class" do
+        mod = Module.new do
+          def options
+            :options
+          end
+          def attributes
+            :attributes
+          end
+        end
+
+        stage_class = Class.new do
+          include mod
+        end
+        stage = stage_class.new
+
+        blueprint2.build(stage, :options => {:option => 'value'})
+        stage.options.should == :options
+        stage.attributes.should == :attributes
+      end
+
+      it "should normalize options and attributes" do
+        blueprint
+        stage.instance_variable_set(:@value, 2)
+        blueprint2 { [options, attributes] }.attributes(:attr => Blueprints::Dependency.new(:blueprint))
+        options, attributes = blueprint2.build(stage, :options => {:attr2 => lambda { @value + 2 }, :attr3 => :value})
+
+        options.should == {:attr2 => 4, :attr3 => :value}
+        attributes.should == {:attr => mock1, :attr2 => 4, :attr3 => :value}
+      end
+
+      it "should return normalized attributes" do
+        blueprint2
+        blueprint.attributes(:attr => Blueprints::Dependency.new(:blueprint2))
+        blueprint.normalized_attributes(stage, :attr2 => 1).should == {:attr => mock1, :attr2 => 1}
+      end
     end
 
-    it "should automatically build dependencies" do
-      blueprint
-      blueprint2.depends_on(:blueprint).build(stage)
-      blueprint.should be_built
+    describe "strategies" do
+      it "should allow defining different strategies" do
+        new_result = mock('new_result')
+        blueprint.blueprint(:new) { new_result }
+        blueprint.build(stage, :strategy => 'new').should == new_result
+      end
+
+      it "should return blueprint itself" do
+        blueprint.blueprint(:new) { 1 }.should == blueprint
+      end
+    end
+
+    describe "on error" do
+      it "should allow rebuilding blueprint" do
+        blueprint do
+          unless @is_built
+            @is_built = true
+            raise 'Failure'
+          end
+          :success
+        end
+
+        expect {
+          blueprint.build(stage)
+        }.to raise_error
+        blueprint.build(stage).should == :success
+      end
+
+      it "should restore overwritten methods" do
+        def stage.options
+          :options
+        end
+
+        expect {
+          blueprint { raise 'error' }.build(stage)
+        }.to raise_error
+        stage.options.should == :options
+      end
     end
   end
 
@@ -108,17 +236,27 @@ describe Blueprints::Blueprint do
 
     it "should allow building blueprint with different parameters" do
       @result.expects(:blueprint).with(:option => 'value')
-      blueprint.build stage, true, :option => 'value'
+      blueprint.build stage, :options => {:option => 'value'}
     end
 
     it "should allow customizing update block" do
       blueprint.update { @blueprint.update_attributes(options) }
       @result.expects(:update_attributes).with(:option => 'value')
-      blueprint.build stage, true, :option => 'value'
+      blueprint.build stage, :options => {:option => 'value'}
     end
 
     it "should not update if build_once is false" do
-      blueprint.build stage, false, :option => 'value'
+      blueprint.build stage, :options => {:option => 'value'}, :rebuild => true
+    end
+  end
+
+  describe "extending" do
+    before do
+      blueprint
+    end
+
+    it "should allow extending with nothing" do
+      blueprint2.extends(:blueprint)
     end
   end
 end

data/spec/unit/blueprints_spec.rb

@@ -10,17 +10,17 @@ describe Blueprints do
     end
 
     it "should allow getting unused blueprints" do
-      Blueprints::Namespace.root.build [:blueprint, :"namespace.blueprint2"]
+      Blueprints::Namespace.root.build [:blueprint, :"namespace.blueprint2"], stage
       Blueprints.unused.should =~ ['blueprint2', 'namespace.blueprint']
     end
 
     describe "most used" do
       before do
-        Blueprints::Namespace.root.build [:blueprint, :blueprint2, :"namespace.blueprint"]
+        Blueprints::Namespace.root.build [:blueprint, :blueprint2, :"namespace.blueprint"], stage
         Blueprints::Namespace.root.executed_blueprints.clear
-        Blueprints::Namespace.root.build [:blueprint2, :"namespace.blueprint"]
+        Blueprints::Namespace.root.build [:blueprint2, :"namespace.blueprint"], stage
         Blueprints::Namespace.root.executed_blueprints.clear
-        Blueprints::Namespace.root.build [:"namespace.blueprint"]
+        Blueprints::Namespace.root.build [:"namespace.blueprint"], stage
       end
 
       it "should return all blueprints with their usages" do