blueprints 0.9.0 → 1.0.0

data/.gitignore

@@ -7,3 +7,4 @@ debug.log
 *.rbc
 doc
 .yardoc
+Gemfile.lock

data/Gemfile

@@ -1,3 +1,16 @@
-source :gemcutter
+source 'http://rubygems.org'
 
 gemspec
+gem 'rspec', '~> 2.0'
+gem 'mysql2', '>= 0.2.0'
+gem 'activerecord', '>= 3.0.0'
+gem 'bson_ext', '>= 1.1.4'
+gem 'mongoid', '>= 2.0.0'
+gem 'mongo_mapper', '>= 0.9.0'
+gem 'dm-migrations', '>= 1.0.0'
+gem 'dm-transactions', '>= 1.0.0'
+gem 'dm-mysql-adapter', '>= 1.0.0'
+gem 'mocha'
+gem 'shoulda'
+gem 'cucumber'
+gem 'bundler', '>= 1.0.0'

data/README.rdoc

@@ -1,183 +1,13 @@
 = Blueprints
 
 Awesome replacement for factories and fixtures that focuses on being DRY and making developers type as little as possible.
-
-== Setup
-
-The easiest way to install this gem for Ruby on Rails is just add this line to your Gemfile:
-
-  gem 'blueprints'
-
-If you're not using bundler, then you can install it through command line
-
-  sudo gem install blueprints
-
-Lastly you could use it as plugin:
-
-  ruby script/plugin install git://github.com/sinsiliux/blueprints.git
-
-Blueprints is activated by calling Blueprints.enable at the bottom of your spec_helper/test_helper. If you're using RSpec
-make sure you call Blueprints.enable after requiring RSpec, otherwise it will lead to strange behaviour. This method accepts
-block and yields Blueprints::Configuration object.
-
-These options can be set on blueprint configuration object:
-* root - custom framework root if automatic detection fails for some reason (eg. not rails/merb project)
-* filename - custom patterns of files that contain your blueprints (in case one of automatic ones doesn't fit your needs)
-* prebuild - list of blueprints that should be preloaded (available in all tests, never reloaded so they're much faster)
-* transactions - set this to false if you don't want to use transactions. This will severely slow the tests but sometimes transactions can't be used.
-
-Sample usage:
-
-  Blueprints.enable do |config|
-    config.filename = 'my_blueprints.rb'
-    config.prebuild = :preloaded_blueprint
-  end
-
-== Blueprints file
-
-Blueprints file is the file that contains all definitions of blueprints. This can either be single file or whole folder
-if you have many blueprints.
-
-By default blueprints are searched in these files in this particular order in application root (which is either Rails.root if it's defined or current folder by default):
-* blueprint.rb
-* blueprint/*.rb
-* spec/blueprint.rb
-* spec/blueprint/*.rb
-* test/blueprint.rb
-* test/blueprint/*.rb
-You can set root option to override application root and filename option to pass custom filename pattern.
-
-== Usage
-
-Definitions of blueprints look like this:
-
-  blueprint :apple do
-    Fruit.blueprint :species => 'apple'
-  end
-
-  blueprint :orange do
-    Fruit.create! :species => 'orange'
-  end
-
-  blueprint :fruitbowl => [:apple, :orange] do
-    @fruits = [@apple,@orange]
-    FruitBowl.blueprint :fruits => @fruits
-  end
-
-  Kitchen.blueprint :kitchen, :fruitbowl => d(:fruitbowl)
-
-...and you use them in specs/tests like this:
-
-  describe Fruit, "apple" do
-    before do
-      build :apple
-    end
-
-    it "should be an apple" do
-      @apple.species.should == 'apple'
-    end
-  end
-
-  describe FruitBowl, "with and apple and an orange" do
-    before do
-      build :fruitbowl
-    end
-
-    it "should have 2 fruits" do
-      @fruits.should == [@apple, @orange]
-      @fruitbowl.should have(2).fruits
-    end
-  end
-
-Result of 'blueprint' block is assigned to an instance variable with the same name. You can also assign your own instance variables
-inside 'blueprint' block and they will be accessible in tests that build this blueprint.
-
-Instead of SomeModel.create! you can also use SomeModel.blueprint, which does the same thing but also bypasses attr_protected
-and attr_accessible restrictions (which is what you usually want in tests).
-
-All blueprints are run only once, no matter how many times they were called, meaning that you don't need to worry about
-duplicating data.
-
-=== Shorthands
-
-There's a shorthand for these type of scenarios:
-
-  blueprint :something do
-    @something = SomeModel.blueprint :field => 'value'
-  end
-
-You can just type:
-
-  SomeModel.blueprint :something, :field => 'value'
-
-If you need to make associations then:
-
-  SomeModel.blueprint(:something, :associated_column => d(:some_blueprint))
-
-...or if the name of blueprint and the name of instance variable are not the same:
-
-   SomeModel.blueprint(:something, :associated_column => d(:some_blueprint, :some_instance_variable))
-
-...and when you need to pass options to associated blueprint:
-
-   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
-
-=== Advanced Usage
-
-Its just ruby, right? So go nuts:
-
-  1.upto(9) do |i|
-    blueprint("user_#{i}") do
-      User.blueprint :name => "user#{i}"
-    end
-  end
-
-You can also read more about advanced usages in http://wiki.github.com/sinsiliux/blueprints/advanced-usages
-
-== Transactions
-
-Blueprints by default is transactional, meaning that before every test transaction is started and after every test that transaction is dropped
-which resets database to the state before the test. This state is empty database + any scenarios that you specify in enable_blueprints.
-
-Sometimes using transactions is not possible (eg. using MongoDB or in cucumber scenarios). In that case you can turn off transactions when
-enabling Blueprints. Be aware though that disabling transactions on relational databases is quite a major performance loss.
-
-== ORM support
-
-Blueprints is not tied to any ORM, however it does use Database Cleaner gem which currently supports Active Record, Data Mapper, Mongo Mapper, Mongoid and Couch Potato.
-
-=== Active Record
-
-Blueprints support Active Record >= 2.3 (yes that includes 3.0). Lower versions are not supported due to lack of nested transactions,
-however they should probably work without transactions. Class and instance 'blueprint' method is added to all models.
-
-=== Mongoid
-
-Blueprints was tested with Mongoid 2.0 only. It does support lower versions, but 'blueprint' method might not be available prior 2.0.
-
-=== Mongo Mapper
-
-Tested with Mongo Mapper 0.8.4, but should work with all prior versions too. Class and instance 'blueprint' method is added to all models.
-
-=== Data Mapper
-
-Is not fully supported (does not work with transactions). Maybe some Data Mapper guru can help me with that? Class and instance 'blueprint' method is added to all models.
-
-=== Other ORMs and not ORMs
-
-If you're using some other ORM (except Couch Potato)  you will need to manually clean database before all tests. If you want to have blueprint method in your
-models you should take a look at Blueprints::Extensions modules (I will gladly help adding support to other ORMs).
+Blueprints allows you to create and manage data for tests in simple but poweful ways. For documentation please see
+http://sinsiliux.github.com/blueprints.
 
 == Links
 
+* Homepage: http://sinsiliux.github.com/blueprints
 * Official google group: http://groups.google.com/group/ruby-blueprints
-* Homepage: http://github.com/sinsiliux/blueprints
-
-== TODO
-
-* Add support for other test frameworks
 
 == Credits
 

data/Rakefile

@@ -1,23 +1,21 @@
-require  'rubygems'
-require 'bundler'
+require 'rubygems'
+require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rd|
-  rd.main = "README.rdoc"
-  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-end
-
 namespace :db do
   desc "Create database structure"
   task :prepare do
-    require 'rubygems'
     require 'active_record'
+    require File.expand_path("../spec/support/active_record/initializer", __FILE__)
+    require File.expand_path("../spec/support/active_record/schema", __FILE__)
+  end
 
-    Root = Pathname.new(__FILE__).dirname
-    require Root.join("spec/support/active_record/initializer")
-
-    load("spec/support/active_record/schema.rb")
+  desc "Copy all database.yml.example files to database.yml"
+  task :config do
+    Dir.glob('spec/support/*/database.yml.example').each do |example_yml|
+      database_yml = example_yml.sub(/\.example$/, '')
+      FileUtils.copy(example_yml, database_yml) unless File.exists?(database_yml)
+    end
   end
 end
 
@@ -26,7 +24,7 @@ task :rspec_to_test do
   Dir.chdir File.dirname(__FILE__)
   data = IO.read('spec/blueprints_spec.rb')
 
-  data.gsub!("require File.dirname(__FILE__) + '/spec_helper'", "require File.dirname(__FILE__) + '/test_helper'")
+  data.gsub!("spec_helper", "test_helper")
   data.gsub!("describe Blueprints do", 'class BlueprintsTest < ActiveSupport::TestCase')
 
   # lambda {
@@ -54,5 +52,24 @@ task :rspec_to_test do
   data.gsub!(/^(\s+)before.*do/, '\1setup do')
   data.gsub!(/^(\s+)after.*do/, '\1teardown do')
 
-  File.open('test/blueprints_test.rb', 'w') {|f| f.write(data)}
+  File.open('test/blueprints_test.rb', 'w') { |f| f.write(data) }
+end
+
+task :default => [:rspec_to_test, 'db:config', 'db:prepare'] do
+  commands = [
+          ["Unit specs", "rspec -c spec/unit/*_spec.rb"],
+          ["Active record integration", "rspec -c spec/blueprints_spec.rb"],
+          ["No ORM integration", "rspec -c spec/blueprints_spec.rb", 'none'],
+          ["Mongoid integration", "rspec -c spec/blueprints_spec.rb", 'mongoid'],
+          ["Mongo mapper integration", "rspec -c spec/blueprints_spec.rb", 'mongo_mapper'],
+          ["Test::Unit", "ruby test/blueprints_test.rb"],
+          ["Cucumber", "cucumber features/blueprints.feature -f progress"],
+  ]
+
+  statuses = commands.collect do |label, command, orm|
+    puts "#{label}:"
+    ENV['ORM'] = orm
+    system command
+  end
+  exit 1 unless statuses.all? { |status| status }
 end

data/blueprints.gemspec

@@ -11,7 +11,6 @@ Gem::Specification.new do |s|
 
   s.authors = ["Andrius Chamentauskas"]
   s.email = %q{sinsiliux@gmail.com}
-  s.default_executable = %q{blueprintify}
   s.homepage = %q{http://sinsiliux.github.com/blueprints}
   s.summary = %q{Awesome replacement for factories and fixtures}
   s.description = %q{Awesome replacement for factories and fixtures that focuses on being DRY and making developers type as little as possible.}
@@ -21,20 +20,7 @@ Gem::Specification.new do |s|
   s.files = `git ls-files`.split("\n")
   s.require_path = "lib"
 
-  s.add_runtime_dependency(%q<activesupport>, [">= 2.3.0"])
-  s.add_runtime_dependency(%q<database_cleaner>, ["~> 0.5.0"])
-  s.add_development_dependency(%q<rspec>, ["~> 2.2.0"])
-  s.add_development_dependency(%q<mysql2>)
-  s.add_development_dependency(%q<activerecord>, [">= 2.3.0"])
-  s.add_development_dependency(%q<bson_ext>, [">= 1.1.4"])
-  s.add_development_dependency(%q<mongoid>, [">= 2.0.0.beta"])
-  s.add_development_dependency(%q<mongo_mapper>, [">= 0.8.0"])
-  s.add_development_dependency(%q<dm-migrations>, [">= 1.0.0"])
-  s.add_development_dependency(%q<dm-transactions>, [">= 1.0.0"])
-  s.add_development_dependency(%q<dm-mysql-adapter>, [">= 1.0.0"])
-  s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
-  s.add_development_dependency(%q<shoulda>, [">= 2.10.0"])
-  s.add_development_dependency(%q<cucumber>, [">= 0.7.0"])
-  s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+  s.add_runtime_dependency("activesupport", ">= 2.3.0")
+  s.add_runtime_dependency("database_cleaner", "~> 0.6.1")
 end
 

data/lib/blueprints.rb

@@ -10,10 +10,18 @@ require 'active_support/core_ext/enumerable'
 require 'database_cleaner'
 require 'set'
 
-files = %w{
-configuration context eval_context buildable namespace root_namespace blueprint helper errors dependency extensions database_cleaner_fix
-}
-files.each { |f| require "blueprints/#{f}" }
+require 'blueprints/configuration'
+require 'blueprints/context'
+require 'blueprints/buildable'
+require 'blueprints/namespace'
+require 'blueprints/root_namespace'
+require 'blueprints/blueprint'
+require 'blueprints/helper'
+require 'blueprints/errors'
+require 'blueprints/dependency'
+require 'blueprints/extensions'
+require 'blueprints/blueprint_name_proxy'
+require 'blueprints/railtie' if defined?(Rails)
 
 # Main namespace of blueprints. Contains methods for Blueprints setup.
 module Blueprints
@@ -26,8 +34,7 @@ module Blueprints
   # Setups variables from global context and starts transaction. Should be called before every test case.
   # @param current_context Object to copy instance variables for prebuilt blueprints/namespaces.
   def self.setup(current_context)
-    Namespace.root.setup
-    Namespace.root.eval_context.copy_instance_variables(current_context)
+    Namespace.root.setup(current_context)
     if_orm { DatabaseCleaner.start }
   end
 
@@ -74,7 +81,7 @@ module Blueprints
       blueprints_path = File.expand_path(File.dirname(__FILE__))
 
       bc.add_filter { |line| line.sub(root_sub, '') }
-      bc.add_silencer { |line| [blueprints_path, *Gem.path].any? { |path| File.expand_path(File.dirname(line)).starts_with?(path) } }
+      bc.add_silencer { |line| [blueprints_path, *Gem.path].any? { |path| File.expand_path(File.dirname(line)).start_with?(path) } }
     end
   end
 
@@ -101,7 +108,7 @@ module Blueprints
   # @param [Blueprints::Blueprint] blueprint Name of blueprint that this occurred in.
   def self.warn(message, blueprint)
     $stderr.puts("**WARNING** #{message}: '#{blueprint.name}'")
-    $stderr.puts(backtrace_cleaner.clean(blueprint.backtrace(caller)).first)
+    $stderr.puts(backtrace_cleaner.clean(caller).first)
   end
 
   protected
@@ -124,7 +131,7 @@ module Blueprints
 
   def self.each_blueprint(from = Namespace.root)
     enumerator_class.new do |enum|
-      from.children.values.collect do |child|
+      from.children.collect do |child|
         if child.is_a?(Blueprints::Blueprint)
           enum.yield child
         else
@@ -145,6 +152,6 @@ module Blueprints
 
   def self.if_orm
     yield
-  rescue DatabaseCleaner::NoORMDetected, DatabaseCleaner::NoStrategySetError
+  rescue DatabaseCleaner::NoORMDetected
   end
 end

data/lib/blueprints/blueprint.rb

@@ -10,29 +10,13 @@ module Blueprints
     def initialize(name, context, &block)
       super(name, context)
 
-      ivname = variable_name
-      @block = block
-      @demolish_block = Proc.new { instance_variable_get(ivname).destroy }
-      @update_block = Proc.new { instance_variable_get(ivname).blueprint(options) }
+      @strategies = {}
+      @strategies[:default] = block || Proc.new { dependencies.collect { |dep| instance_variable_get(:"@#{dep}") } }
+      @strategies[:demolish] = Proc.new { instance_variable_get(variable_name).destroy }
+      @strategies[:update] = Proc.new { instance_variable_get(variable_name).blueprint(options) }
       @uses = 0
     end
 
-    # Builds blueprint and adds it to executed blueprint array. Setups instance variable with same name as blueprint if it is not defined yet.
-    # Marks blueprint as used.
-    # @param eval_context (see Buildable#build)
-    # @param build_once (see Buildable#build)
-    # @param options (see Buildable#build)
-    def build_self(eval_context, build_once, options)
-      @uses += 1 unless built?
-      surface_errors do
-        if built? and build_once
-          eval_context.instance_eval(@context, options, &@update_block) if options.present?
-        elsif @block
-          result(eval_context) { eval_context.instance_eval(@context, options, &@block) }
-        end
-      end
-    end
-
     # Changes blueprint block to build another blueprint by passing additional options to it. Usually used to dry up
     # blueprints that are often built with some options.
     # @example Extending blueprints
@@ -40,29 +24,22 @@ module Blueprints
     #   blueprint(:published_post).extends(:post, :published_at => Time.now)
     # @param [Symbol, String] parent Name of parent blueprint.
     # @param [Hash] options Options to be passed when building parent.
-    def extends(parent, options)
-      attributes(options)
-      @block = Proc.new { build parent => attributes }
-    end
-
-    # Changes backtrace to include what blueprint was being built.
-    # @param [Array<String>] trace Current trace
-    # @return [Array<String>] Changed trace with included currently built blueprint name.
-    def backtrace(trace)
-      trace.collect! { |line| line.sub(/^#{@context.file}:(\d+).*/, "#{@context.file}:\\1:in blueprint '#{@name}'") }
+    def extends(parent, options = {})
+      attributes(options).blueprint(:default) { build parent => attributes }
     end
 
     # @overload demolish(&block)
     #   Sets custom block for demolishing this blueprint.
-    # @overload demolish(eval_context)
+    # @overload demolish(environment)
     #   Demolishes blueprint by calling demolish block.
-    #   @param [Blueprints::EvalContext] eval_context Context where blueprint was built in.
+    #   @param [Object] environment Context where blueprint was built in.
+    #   @param [Symbol] current_name Current name of blueprint (used when demolishing blueprints with regexp name). When nil is passed then @name is used.
     #   @raise [Blueprints::DemolishError] If blueprint has not been built yet.
-    def demolish(eval_context = nil, &block)
+    def demolish(environment = nil, current_name = nil, &block)
       if block
-        @demolish_block = block
-      elsif eval_context and built?
-        eval_context.instance_eval(@context, {}, &@demolish_block)
+        blueprint(:demolish, &block)
+      elsif environment and built?
+        eval_block(environment, {}, current_name, &@strategies[:demolish])
         undo!
       else
         raise DemolishError, @name
@@ -71,16 +48,83 @@ module Blueprints
 
     # Allows customizing what happens when blueprint is already built and it's being built again.
     def update(&block)
-      @update_block = block
+      blueprint(:update, &block)
+    end
+
+    # Defines strategy for this blueprint. Blueprint can later be built using this strategy by passing :strategy option
+    # to Buildable#build method.
+    # @param [#to_sym] name Name of strategy.
+    # @return [Blueprints::Blueprint] self.
+    def blueprint(name, &block)
+      @strategies[name.to_sym] = block
+      self
+    end
+
+    # Returns normalized attributes for this blueprint. Normalized means that all dependencies are replaced by real
+    # instances and all procs evaluated.
+    # @param environment Context that blueprints are built against
+    # @param [Hash] options Options hash, merged into attributes
+    # @return [Hash] normalized attributes for this blueprint
+    def normalized_attributes(environment, options = {})
+      normalize_hash(environment, @context.attributes.merge(options))
     end
 
     private
 
-    def surface_errors
+    def build_self(environment, options)
+      @uses += 1 unless built?
+      opts = options[:options] || {}
+      strategy = (options[:strategy] || :default).to_sym
+      current_name = options[:name] || @name
+
+      if built? and not options[:rebuild]
+        eval_block(environment, opts, current_name, &@strategies[:update]) if opts.present?
+      elsif @strategies[strategy]
+        result(environment, current_name) { eval_block(environment, opts, current_name, &@strategies[strategy]) }
+      end
+    end
+
+    def eval_block(environment, options, current_name, &block)
+      with_method(environment, :options, options = normalize_hash(environment, options)) do
+        with_method(environment, :attributes, normalized_attributes(environment, options)) do
+          with_method(environment, :variable_name, variable_name(current_name)) do
+            with_method(environment, :dependencies, dependencies) do
+              environment.instance_eval(&block)
+            end
+          end
+        end
+      end
+    end
+
+    def normalize_hash(environment, hash)
+      hash.each_with_object({}) do |(attr, value), normalized|
+        normalized[attr] = if value.respond_to?(:to_proc) and not Symbol === value
+          environment.instance_exec(&value)
+        else
+          value
+        end
+      end
+    end
+
+    def with_method(environment, name, value)
+      old_method = nil
+      environment.singleton_class.class_eval do
+        if method_defined?(name)
+          old_method = environment.method(name)
+          if old_method.owner == self
+            remove_method(name)
+          else
+            old_method = nil
+          end
+        end
+        define_method(name) { value }
+      end
       yield
-    rescue StandardError => error
-      backtrace(error.backtrace)
-      raise error
+    ensure
+      environment.singleton_class.class_eval do
+        remove_method(name)
+        define_method(name, old_method) if old_method
+      end
     end
   end
 end