blueprints_boy 1.0.0

data/integration/rspec/rspec_spec.rb

@@ -0,0 +1,113 @@
+require 'bundler/setup'
+require 'rspec'
+require 'blueprints_boy'
+require_relative '../shared'
+
+BlueprintsBoy.enable do |config|
+  config.root = File.dirname(__FILE__)
+  config.global = :global_cherry
+end
+
+describe 'rspec integration' do
+  describe "set" do
+    it "should allow setting methods directly" do
+      set :apple, 'apple'
+      apple.should == 'apple'
+    end
+
+    it "should return value that is set" do
+      set(:apple, 'apple').should == 'apple'
+    end
+
+    it "should auto set variable" do
+      autoset :apple, 'apple'
+      apple.should == 'apple'
+    end
+
+    it "should not auto set variable if it's already set" do
+      set :variable, :correct
+      autoset :variable, :incorrect
+      variable.should == :correct
+    end
+
+    it "should still autoset variable in blueprint_data even if environment defines method with same name" do
+      def self.variable
+      end
+
+      autoset :variable, :correct
+      variable.should be_nil
+      blueprint_data(:variable).should == :correct
+    end
+
+    it "should still return new value if variable is already set" do
+      set :variable, :correct
+      autoset(:variable, :incorrect).should == :incorrect
+    end
+
+    it "should allow reaching fixtures through fixtures method" do
+      set :apple, 'apple'
+      blueprint_data(:apple).should == 'apple'
+    end
+  end
+
+  describe "build" do
+    it "should allow building blueprint" do
+      build :apple
+      apple.should == 'apple'
+    end
+
+    it "should allow building several blueprints" do
+      build :apple, :orange
+      apple.should == 'apple'
+      orange.should == 'orange'
+    end
+
+    it "should not allow to reach blueprints from previous specs" do
+      blueprint_data(:apple).should be_nil
+    end
+  end
+
+  describe "build with" do
+    it "should allow building using different strategy" do
+      build_with :attributes, :orange
+      orange.should == {name: 'orange'}
+    end
+  end
+
+  describe "build!" do
+    it "allows building blueprint twice" do
+      orange1 = build! :orange
+      orange2 = build! :orange => {name: 'not apple'}
+      orange1.should == 'orange'
+      orange2.should == 'not apple'
+    end
+  end
+
+  describe "build_new" do
+    it "builds blueprint using :new strategy" do
+      build_new :orange
+      orange.should == 'new orange'
+    end
+  end
+
+  describe "build_attributes" do
+    it "returns attributes for building" do
+      build_attributes :orange => {size: 2}
+      orange.should == {name: 'orange', size: 2}
+    end
+  end
+
+  describe "class level set" do
+    build :apple
+
+    it "should build blueprints in before filter" do
+      apple.should == 'apple'
+    end
+  end
+
+  describe "global" do
+    it "should build global blueprints" do
+      global_cherry.should == 'cherry'
+    end
+  end
+end

data/integration/shared.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :should, :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :should, :expect
+  end
+end

data/lib/blueprints_boy/blueprint.rb

@@ -0,0 +1,59 @@
+class BlueprintsBoy::Blueprint
+  Data = Struct.new(:name, :options, :attributes, :factory)
+  attr_reader :name, :context
+
+  def initialize(context, name, attrs = {}, &block)
+    @context = context
+    @name = name.to_sym
+    @strategies = {
+        create: block,
+        attributes: proc { |data| data.attributes }
+    }
+    attributes(attrs)
+  end
+
+  def build(environment, strategy, options = {})
+    data = Data.new(@name, options, normalized_attributes(environment).merge(options), @context.factory_class)
+    block = @strategies[strategy]
+    block ||= BlueprintsBoy.factories[@context.factory_class, strategy] if @context.factory_class
+    if block
+      environment.autoset(@name, environment.instance_exec(data, &block))
+    else
+      raise BlueprintsBoy::StrategyNotFound, "Blueprint #{@name.inspect} does not define strategy #{strategy.inspect}"
+    end
+  end
+
+  def depends_on(*dependencies)
+    update_context dependencies, nil, nil
+  end
+
+  def attributes(attributes)
+    update_context nil, attributes, nil
+  end
+
+  def factory(factory_class)
+    update_context nil, nil, factory_class
+  end
+
+  def blueprint(strategy, &block)
+    @strategies[strategy] = block
+  end
+
+  private
+
+  def normalized_attributes(environment)
+    @context.attrs.each_with_object({}) do |(key, value), normalized|
+      normalized[key] = case value
+                        when BlueprintsBoy::Dependency
+                          environment.instance_eval(&value)
+                        else
+                          value
+                        end
+    end
+  end
+
+  def update_context(dependencies, attributes, factory_class)
+    @context = @context.chain(dependencies, attributes, factory_class)
+    self
+  end
+end

data/lib/blueprints_boy/configuration.rb

@@ -0,0 +1,48 @@
+module BlueprintsBoy
+  # Contains configuration of blueprints. Instance of this is yielded in Blueprints.enable block.
+  # @example Configuring through Blueprints.enable block
+  #   Blueprints.enable do |config|
+  #     config.prebuild = :user, :profile
+  #   end
+  # @example Configuring directly
+  #   Blueprints.config.transactions = false
+  class Configuration
+    # Allows passing custom filename pattern in case blueprints are held in place other than spec/blueprint, test/blueprint, blueprint.
+    attr_reader :filenames
+    # Allows passing scenarios that should be prebuilt and available in all tests. Works similarly to fixtures.
+    attr_accessor :prebuild
+    # Allows passing custom root folder to use in case of non rails project. Defaults to Rails.root or current folder if Rails is not defined.
+    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
+    # Define global blueprints that are prebuilt in all tests
+    attr_reader :global
+
+    # Initializes new Configuration object with default attributes.
+    # By defaults filename patterns are: blueprint.rb and blueprint/*.rb in spec, test and root directories.
+    # Also by default prebuildable blueprints list is empty, transactions are enabled and root is set to Rails.root or current directory.
+    def initialize
+      self.filenames = [nil, "spec", "test"].map do |dir|
+        ['blueprints.rb', 'blueprints/*.rb'].map do |pattern|
+          File.join([dir, pattern].compact)
+        end
+      end
+      @prebuild = []
+      @transactions = true
+      @root = defined?(Rails) ? Rails.root : Pathname.pwd
+      @global = []
+    end
+
+    def filenames=(value)
+      @filenames = Array(value).flatten.collect { |path| Pathname.new(path) }
+    end
+
+    def root=(value)
+      @root = Pathname.new(value)
+    end
+
+    def global=(value)
+      @global = Array(value)
+    end
+  end
+end

data/lib/blueprints_boy/context.rb

@@ -0,0 +1,53 @@
+module BlueprintsBoy
+  class Context
+    attr_accessor :dependencies, :attrs, :factory_class
+
+    def initialize(file_name, &added_callback)
+      @file_name = file_name
+      @added_callback = added_callback
+      @dependencies = []
+      @attrs = {}
+      @factory_class = nil
+      instance_eval(File.read(file_name), file_name)
+    end
+
+    def depends_on(*dependencies, &block)
+      chain(dependencies, nil, nil, &block)
+    end
+
+    def attributes(attributes, &block)
+      chain(nil, attributes, nil, &block)
+    end
+
+    def factory(factory_class, &block)
+      chain(nil, nil, factory_class, &block)
+    end
+
+    def chain(dependencies, attributes, factory, &block)
+      dup.tap do |context|
+        context.dependencies |= dependencies if dependencies
+        context.attrs = context.attrs.merge(attributes) if attributes
+        context.factory_class = factory if factory
+        context.instance_eval(&block) if block
+      end
+    end
+
+    def blueprint(*args, &block)
+      Blueprint.new(self, *args, &block).tap do |blueprint|
+        @added_callback.call blueprint if @added_callback
+      end
+    end
+
+    def group(groups)
+      groups.collect do |name, children|
+        blueprint(name) { build(*children) }
+      end
+    end
+
+    def dependency(name, *args, &block)
+      BlueprintsBoy::Dependency.new(name, *args, &block)
+    end
+
+    alias_method :method_missing, :dependency
+  end
+end

data/lib/blueprints_boy/dependency.rb

@@ -0,0 +1,23 @@
+class BlueprintsBoy::Dependency < BasicObject
+  def initialize(name, *args)
+    @name = name
+    @options = args.extract_options!
+    @blueprint_name = args.first || @name
+    @registry = []
+  end
+
+  def to_proc
+    name, options, registry, blueprint_name = @name, @options, @registry, @blueprint_name
+    ::Proc.new do
+      build blueprint_name => options
+      registry.inject(blueprint_data(name)) do |value, (method, args, block)|
+        value.send(method, *args, &block)
+      end
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    @registry << [method, args, block]
+    self
+  end
+end

data/lib/blueprints_boy/errors.rb

@@ -0,0 +1,10 @@
+module BlueprintsBoy
+  class BlueprintNotFound < StandardError
+  end
+
+  class FactoryNotFound < StandardError
+  end
+
+  class StrategyNotFound < StandardError
+  end
+end

data/lib/blueprints_boy/factories.rb

@@ -0,0 +1,18 @@
+module BlueprintsBoy
+  class Factories
+    def initialize
+      @factories = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def add(factory_class, strategy, &block)
+      @factories[factory_class][strategy] = block
+    end
+
+    def [](factory_class, strategy)
+      factory_class.ancestors.each do |ancestor|
+        return @factories[ancestor][strategy] if @factories.key?(ancestor)
+      end
+      raise FactoryNotFound, "Factory for #{factory_class} can't be located"
+    end
+  end
+end

data/lib/blueprints_boy/helper.rb

@@ -0,0 +1,47 @@
+module BlueprintsBoy::Helper
+  def set(name, value)
+    instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def self.#{name}
+        @_blueprint_data[:#{name}]
+      end
+    RUBY
+    @_blueprint_data[name] = value
+  end
+
+  def autoset(name, value)
+    if respond_to?(name)
+      @_blueprint_data[name] ||= value
+    else
+      set(name, value)
+    end
+    value
+  end
+
+  def blueprint_data(name = nil)
+    if name
+      @_blueprint_data[name]
+    else
+      @_blueprint_data
+    end
+  end
+
+  def build(*names)
+    build_with nil, *names
+  end
+
+  def build!(*names)
+    build_with :create, *names
+  end
+
+  def build_new(*names)
+    build_with :new, *names
+  end
+
+  def build_attributes(*names)
+    build_with :attributes, *names
+  end
+
+  def build_with(strategy, *names)
+    BlueprintsBoy.manager.build(self, names, strategy: strategy)
+  end
+end

data/lib/blueprints_boy/integration/active_record.rb

@@ -0,0 +1,11 @@
+if ActiveRecord::VERSION::MAJOR < 4
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :create) { |data| data.factory.create!(data.attributes, without_protection: true) }
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :new) { |data| data.factory.new(data.attributes, without_protection: true) }
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :update) { |data| blueprint_data(data.name).update_attributes!(data.options, without_protection: true) }
+else
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :create) { |data| data.factory.create!(data.attributes) }
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :new) { |data| data.factory.new(data.attributes) }
+  BlueprintsBoy.factories.add(ActiveRecord::Base, :update) { |data| blueprint_data(data.name).update_attributes!(data.options) }
+end
+
+DatabaseCleaner[:active_record].strategy = BlueprintsBoy.config.transactions ? :transaction : :truncation

data/lib/blueprints_boy/integration/cucumber.rb

@@ -0,0 +1,9 @@
+World BlueprintsBoy::Helper
+
+Before do
+  BlueprintsBoy.manager.setup(self)
+end
+
+After do
+  BlueprintsBoy.manager.teardown
+end

data/lib/blueprints_boy/integration/minitest.rb

@@ -0,0 +1,23 @@
+module BlueprintsBoy::MinitestHelper
+  def before_setup
+    super
+    BlueprintsBoy.manager.setup(self)
+  end
+
+  def after_teardown
+    super
+    BlueprintsBoy.manager.teardown
+  end
+
+  module ClassMethods
+    def build(*args)
+      before do
+        build(*args)
+      end
+    end
+  end
+end
+
+MiniTest::Unit::TestCase.send :include, BlueprintsBoy::Helper, BlueprintsBoy::MinitestHelper if defined?(MiniTest::Unit::TestCase)
+MiniTest::Test.send :include, BlueprintsBoy::Helper, BlueprintsBoy::MinitestHelper if defined?(MiniTest::Test)
+MiniTest::Spec.send :extend, BlueprintsBoy::MinitestHelper::ClassMethods if defined?(MiniTest::Spec)

data/lib/blueprints_boy/integration/mongoid.rb

@@ -0,0 +1,11 @@
+if Mongoid::VERSION.to_i < 4
+  BlueprintsBoy.factories.add(Mongoid::Document, :create) { |data| data.factory.create!(data.attributes, without_protection: true) }
+  BlueprintsBoy.factories.add(Mongoid::Document, :new) { |data| data.factory.new(data.attributes, without_protection: true) }
+  BlueprintsBoy.factories.add(Mongoid::Document, :update) { |data| blueprint_data(data.name).update_attributes!(data.options, without_protection: true) }
+else
+  BlueprintsBoy.factories.add(Mongoid::Document, :create) { |data| data.factory.create!(data.attributes) }
+  BlueprintsBoy.factories.add(Mongoid::Document, :new) { |data| data.factory.new(data.attributes) }
+  BlueprintsBoy.factories.add(Mongoid::Document, :update) { |data| blueprint_data(data.name).update_attributes!(data.options) }
+end
+
+DatabaseCleaner[:mongoid].strategy = :truncation

data/lib/blueprints_boy/integration/rspec.rb

@@ -0,0 +1,20 @@
+module BlueprintsBoy::RSpecHelper
+  def build(*args)
+    before do
+      build(*args)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include BlueprintsBoy::Helper
+  config.extend BlueprintsBoy::RSpecHelper
+
+  config.before do
+    BlueprintsBoy.manager.setup(self)
+  end
+
+  config.after do
+    BlueprintsBoy.manager.teardown
+  end
+end if RSpec.respond_to?(:configure) # Otherwise db:seed might crash

data/lib/blueprints_boy/manager.rb

@@ -0,0 +1,87 @@
+module BlueprintsBoy
+  class Manager
+    attr_reader :blueprints, :registry
+
+    def initialize
+      @blueprints = {}
+      @registry = nil
+    end
+
+    def add(blueprint)
+      @blueprints[blueprint.name] = blueprint
+    end
+
+    def find(name)
+      @blueprints[name] or raise BlueprintNotFound, "Blueprint :#{name} cannot be found"
+    end
+
+    alias_method :[], :find
+
+    def build(environment, names, options = {})
+      result = parse_names(names).collect do |name, attributes|
+        build_blueprint(environment, name, attributes, options)
+      end
+      result.size > 1 ? result : result.first
+    end
+
+    def setup(environment)
+      prepare_env(environment)
+      push_registry
+      @registry.restore.each { |name, value| environment.set name, value }
+
+      DatabaseCleaner.start
+    rescue DatabaseCleaner::NoORMDetected
+      # ignored
+    end
+
+    def teardown
+      @registry = @registry.parent
+      DatabaseCleaner.clean
+    rescue DatabaseCleaner::NoORMDetected
+      # ignored
+    end
+
+    def push_registry(blueprint_names = [])
+      @registry = Registry.new(blueprint_names, @registry)
+
+      environment = Object.new
+      environment.singleton_class.send(:include, BlueprintsBoy::Helper)
+      prepare_env(environment)
+      build(environment, @registry.names)
+      @registry.store environment.blueprint_data
+    end
+
+    private
+
+    def prepare_env(environment)
+      environment.instance_variable_set(:@_blueprint_data, {})
+    end
+
+    def build_blueprint(environment, name, attributes, options)
+      strategy = options[:strategy] || default_strategy_for(name, attributes)
+      return environment.blueprint_data(name) if strategy.nil? # Blueprint is already built
+
+      @registry.built << name
+      blueprint = find(name)
+      build environment, blueprint.context.dependencies if blueprint.context.dependencies.present?
+      blueprint.build(environment, strategy, attributes || {})
+    end
+
+    def default_strategy_for(name, attributes)
+      if @registry.built.include?(name)
+        if attributes.present?
+          :update
+        else
+          nil
+        end
+      else
+        :create
+      end
+    end
+
+    def parse_names(names)
+      names_with_options = names.extract_options!
+      names.push(*names_with_options)
+    end
+  end
+end

data/lib/blueprints_boy/railtie.rb

@@ -0,0 +1,24 @@
+class BlueprintsBoy::Railtie < Rails::Railtie
+  class Seeder
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def load_seed
+      BlueprintsBoy.enable
+
+      TOPLEVEL_BINDING.eval('self').instance_eval do
+        @_blueprint_data = {}
+        include BlueprintsBoy::Helper
+      end
+
+      @parent.load_seed
+    end
+  end
+
+  initializer 'blueprints_boy.set_seed_loader' do
+    if defined?(ActiveRecord::Tasks::DatabaseTasks)
+      ActiveRecord::Tasks::DatabaseTasks.seed_loader = Seeder.new(ActiveRecord::Tasks::DatabaseTasks.seed_loader)
+    end
+  end
+end

data/lib/blueprints_boy/registry.rb

@@ -0,0 +1,28 @@
+module BlueprintsBoy
+  class Registry
+    attr_reader :built, :parent, :names
+
+    def initialize(names, parent)
+      @names = names
+      @parent = parent
+      @built = Set.new
+      @built.merge(parent.built) if parent
+
+      @stored = {}
+    end
+
+    def store(data)
+      data.each do |name, value|
+        @stored[name] = Marshal.dump(value)
+      end
+    end
+
+    def restore
+      data = @stored.each_with_object({}) do |(name, dump), result|
+        result[name] = Marshal.load(dump)
+      end
+      data.reverse_merge!(@parent.restore) if @parent
+      data
+    end
+  end
+end

data/lib/blueprints_boy/version.rb

@@ -0,0 +1,3 @@
+module BlueprintsBoy
+  VERSION = "1.0.0"
+end

data/lib/blueprints_boy.rb

@@ -0,0 +1,62 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'database_cleaner'
+require 'blueprints_boy/version'
+require 'blueprints_boy/railtie' if defined?(Rails)
+
+module BlueprintsBoy
+  extend ActiveSupport::Autoload
+
+  autoload :BlueprintNotFound, 'blueprints_boy/errors'
+  autoload :FactoryNotFound, 'blueprints_boy/errors'
+  autoload :StrategyNotFound, 'blueprints_boy/errors'
+
+  autoload :Configuration
+  autoload :Helper
+  autoload :Context
+  autoload :Manager
+  autoload :Factories
+  autoload :Blueprint
+  autoload :Dependency
+  autoload :Registry
+
+  def self.enable
+    yield config if block_given?
+    require 'blueprints_boy/integration/minitest' if defined?(MiniTest)
+    require 'blueprints_boy/integration/rspec' if defined?(RSpec)
+    require 'blueprints_boy/integration/cucumber' if defined?(Cucumber)
+    require 'blueprints_boy/integration/active_record' if defined?(ActiveRecord)
+    require 'blueprints_boy/integration/mongoid' if defined?(Mongoid)
+    prepare
+    manager.push_registry(config.global)
+  end
+
+  def self.prepare
+    read_files
+    DatabaseCleaner.clean_with(:truncation)
+  rescue DatabaseCleaner::NoORMDetected
+    # ignored
+  end
+
+  def self.read_files
+    config.filenames.each do |pattern|
+      Dir[config.root.join(pattern)].each do |file_name|
+        Context.new(file_name) { |blueprint| manager.add(blueprint) } if File.file?(file_name)
+      end
+    end
+  end
+
+  def self.manager
+    @manager ||= Manager.new
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.factories
+    @factories ||= Factories.new
+  end
+end