blueprints 0.5.1 → 0.6.0

data/README.rdoc

@@ -75,7 +75,11 @@ And if you also need it to depend on other blueprints:
 
 ...or...
 
-  SomeModel.blueprint(:something, :associated_column => :@some_iv).depends_on(:some_blueprint) # I prefer this one
+  SomeModel.blueprint(:something, :associated_column => :@some_iv).depends_on(:some_blueprint)
+
+...or if name of associated blueprint and instance variable are same...
+
+  SomeModel.blueprint(:something, :associated_column => d(:some_blueprint)) # I prefer this one
 
 === Blueprints file
 

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/blueprints.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{blueprints}
-  s.version = "0.5.1"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrius Chamentauskas"]
-  s.date = %q{2010-02-24}
+  s.date = %q{2010-05-25}
   s.description = %q{Another replacement for factories and fixtures. The library that lazy typists will love}
   s.email = %q{sinsiliux@gmail.com}
   s.extra_rdoc_files = [
@@ -59,7 +59,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/sinsiliux/blueprints}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Another replacement for factories and fixtures}
   s.test_files = [
     "spec/no_db/fixtures/fruit.rb",
@@ -80,7 +80,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else

data/lib/blueprints.rb

@@ -70,6 +70,10 @@ module Blueprints
     @@orm.delete_tables(@@delete_policy, *tables)
   end
 
+  def self.warn(message, blueprint)
+    $stderr.puts("**WARNING** #{message}: '#{blueprint}'")
+  end
+
   protected
 
   # Loads blueprints file and creates blueprints from data it contains. Is run by setup method

data/lib/blueprints/buildable.rb

@@ -1,5 +1,13 @@
 module Blueprints
   class Buildable
+    class Dependency < Struct.new(:name)
+      alias :to_sym :name
+
+      def iv_name
+        :"@#{name}"
+      end
+    end
+
     attr_reader :name
     attr_accessor :namespace
 
@@ -7,30 +15,53 @@ module Blueprints
       @name, parents = parse_name(name)
       depends_on(*parents)
 
+      Blueprints.warn("Overwriting existing blueprint", @name) if Namespace.root and Namespace.root.children[@name]
       Namespace.root.add_child(self) if Namespace.root
     end
 
     # Defines blueprint dependencies. Used internally, but can be used externally too.
     def depends_on(*scenarios)
       @parents = (@parents || []) + scenarios.map{|s| s.to_sym}
+      self
     end
 
     # Builds dependencies of blueprint and then blueprint itself.
-    def build(options = {})
-      namespace = self
-      namespace.build_parent_plans while namespace = namespace.namespace
-      build_parent_plans
+    def build(build_once = true, options = {})
+      each_namespace {|namespace| namespace.build_parents }
+      build_parents
+
       Namespace.root.context.options = options
-      build_plan.tap { Namespace.root.context.options = {} }
+      Namespace.root.context.attributes = attributes.merge(options)
+      each_namespace {|namespace| Namespace.root.context.attributes.reverse_merge! namespace.attributes }
+
+      build_self(build_once).tap do
+        Namespace.root.context.options = {}
+        Namespace.root.context.attributes = {}
+      end
+    end
+
+    def attributes(value = nil)
+      if value
+        raise value.inspect + @name if @name == ''
+        @attributes = value
+        self
+      else
+        @attributes ||= {}
+      end
     end
 
     protected
 
+    def each_namespace
+      namespace = self
+      yield(namespace) while namespace = namespace.namespace
+    end
+
     def path
       @path = (namespace.path + "_" unless namespace.nil? or namespace.path.empty?).to_s + @name.to_s
     end
 
-    def build_parent_plans
+    def build_parents
       @parents.each do |p|
         parent = begin
           namespace[p]

data/lib/blueprints/context.rb

@@ -1,7 +1,7 @@
 module Blueprints
   # Class that blueprint blocks are evaluated against. Allows you to access options that were passed to build method.
   class Context
-    attr_accessor :options
+    attr_accessor :options, :attributes
 
     def build(*names)
       Namespace.root.build(*names)

data/lib/blueprints/database_backends/active_record.rb

@@ -52,26 +52,36 @@ module Blueprints
           # 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))
+          # or like this:
           #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => :@user).depends_on(:user)
           # or like this:
           #   Post.blueprint({:post => :user}, :title => 'first post', :text => 'My first post', :user => :@user)
           def blueprint(*args)
-            attributes = args.extract_options!
+            attrs = args.pop
             if args.present?
               klass = self
-              Blueprints::Plan.new(*args) do
-                klass.blueprint attributes.merge(options)
-              end
+              blueprint = Blueprints::Plan.new(*args) { klass.blueprint attributes }
+              blueprint.depends_on(*attrs.values.select {|attr| attr.is_a?(Blueprints::Buildable::Dependency) }).attributes(attrs)
+              blueprint
             else
-              returning(self.new) { |object| object.blueprint(attributes) }
+              if attrs.is_a?(Array)
+                attrs.collect { |attr| blueprint(attr) }
+              else
+                returning(self.new) { |object| object.blueprint(attrs) }
+              end
             end
           end
         end
 
         module Instance
-          # Updates attributes of object and calls save!. Bypasses attr_protected anduep attr_accessible.
+          # Updates attributes of object and calls save!. Bypasses attr_protected and attr_accessible.
           def blueprint(attributes)
-            attributes.each {|attr, value| attributes[attr] = Blueprints::Namespace.root.context.instance_variable_get(value) if value.is_a? Symbol and value.to_s =~ /^@.+$/ }
+            attributes.each do |attr, value|
+              iv_name = value.iv_name if value.is_a?(Blueprints::Buildable::Dependency)
+              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
             send(:attributes=, attributes, false)
             save!
           end

data/lib/blueprints/file_context.rb

@@ -14,6 +14,13 @@ module Blueprints
       yield
       old_namespace.add_child(namespace)
       Namespace.root = old_namespace
+      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 self.d(name)
+      Buildable::Dependency.new(name)
     end
   end
 end

data/lib/blueprints/helper.rb

@@ -11,11 +11,21 @@ module Blueprints
     #
     #   # options can also be passed for several blueprints
     #   build :pear, :apple => {:color => 'red'}, :orange => {:color => 'orange'}
-    def build_plan(*names)
-      returning(Namespace.root.build(*names)) { Namespace.root.copy_ivars(self) }
+    def build_blueprint(*names)
+      Namespace.root.build(names, self, true)
     end
 
-    alias :build :build_plan
+    # Same as #build_blueprint except that you can use it to build same blueprint several times.
+    def build_blueprint!(*names)
+      Namespace.root.build(names, self, false)
+    end
+
+    def build_attributes(name)
+      Namespace.root[name].attributes
+    end
+
+    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.

data/lib/blueprints/namespace.rb

@@ -3,6 +3,7 @@ module Blueprints
   # all it's children.
   class Namespace < Buildable
     cattr_accessor :root
+    attr_reader :children
     delegate :empty?, :size, :to => :@children
 
     def initialize(name)
@@ -11,7 +12,6 @@ module Blueprints
     end
 
     def add_child(child)
-      #TODO: Raise error for duplicate children!
       @children[child.name] = child
       child.namespace = self
     end
@@ -26,7 +26,7 @@ module Blueprints
       end
     end
 
-    def build_plan
+    def build_self(build_once = true)
       Namespace.root.add_variable(path, @children.collect {|p| p.last.build }.uniq)
     end
   end

data/lib/blueprints/plan.rb

@@ -8,13 +8,17 @@ module Blueprints
     end
 
     # Builds plan and adds it to executed plan hash. Setups instance variable with same name as plan if it is not defined yet.
-    def build_plan
-      surface_errors do
-        if @block
-          @result = Namespace.root.context.instance_eval(&@block)
-          Namespace.root.add_variable(path, @result)
+    def build_self(build_once = true)
+      if build_once and Namespace.root.executed_plans.include?(path)
+        Blueprints.warn("Building with options, but blueprint was already built", @name) if Namespace.root.context.options.present?
+      else
+        surface_errors do
+          if @block
+            @result = Namespace.root.context.instance_eval(&@block)
+            Namespace.root.add_variable(path, @result)
+          end
         end
-      end unless Namespace.root.executed_plans.include?(path)
+      end
       Namespace.root.executed_plans << path
       @result
     end

data/lib/blueprints/root_namespace.rb

@@ -17,7 +17,7 @@ module Blueprints
     # Loads all instance variables from global context to current one.
     def setup
       @context = Blueprints::Context.new
-      YAML.load(@global_variables).each { |name, value| @context.instance_variable_set(name, value) }
+      Marshal.load(@global_variables).each { |name, value| @context.instance_variable_set(name, value) }
       @executed_plans = @global_executed_plans.clone
     end
 
@@ -31,21 +31,25 @@ module Blueprints
     # Sets up global context and executes prebuilt blueprints against it.
     def prebuild(plans)
       @context = Blueprints::Context.new
-      @global_scenarios = build(*plans) if plans
+      @global_scenarios = build(plans) if plans
       @global_executed_plans = @executed_plans
 
-      @global_variables = YAML.dump(@context.instance_variables.each_with_object({}) {|iv, hash| hash[iv] = @context.instance_variable_get(iv) })
+      @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.
-    def build(*names)
-      names.inject(nil) do |result, member|
+    # Builds blueprints that are passed against current context. Copies instance variables to context given if one is given.
+    def build(names, context = nil, build_once = true)
+      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(options) }.last
+          member.map {|name, options| self[name].build(build_once, options) }.last
         else
-          self[member].build
+          self[member].build(build_once)
         end
       end
+
+      copy_ivars(context) if context
+      result
     end
 
     # Sets instance variable in current context to passed value. If instance variable with same name already exists, it

data/spec/active_record/blueprint.rb

@@ -25,7 +25,7 @@ blueprint :cherry do
 end
 
 blueprint :big_cherry => :cherry do
-  Fruit.create! :species => @cherry.species, :average_diameter => 7
+  Fruit.create! options.reverse_merge(:species => @cherry.species, :average_diameter => 7)
 end
 
 blueprint :cherry_basket => [:big_cherry, :cherry] do
@@ -41,7 +41,7 @@ blueprint :pine do
   @the_pine = Tree.blueprint :name => 'Pine', :size => 'medium'
 end
 
-Fruit.blueprint(:acorn, :species => 'Acorn', :tree => :@oak).depends_on(:oak)
+Fruit.blueprint(:acorn, :species => 'Acorn', :tree => d(:oak))
 blueprint :small_acorn do
   build :acorn => {:average_diameter => 1}
 end
@@ -60,3 +60,11 @@ end
 blueprint :apple_with_params do
   Fruit.create! options.reverse_merge(:species => 'apple')
 end
+
+namespace :attributes do
+  blueprint :cherry do
+    Fruit.blueprint attributes
+  end.attributes(:species => 'cherry')
+
+  Fruit.blueprint :shortened_cherry, :species => 'cherry'
+end.attributes(:average_diameter => 10, :species => 'fruit with attributes')

data/spec/active_record/blueprints_spec.rb

@@ -258,6 +258,12 @@ describe Blueprints do
       @oak.name.should == 'Oak'
       @oak.size.should == 'optional'
     end
+
+    it "should allow to pass array of hashes to blueprint method" do
+      Fruit.create
+      fruits = Fruit.blueprint([{:species => 'fruit1'}, {:species => 'fruit2'}])
+      fruits.collect(&:species).should == %w{fruit1 fruit2}
+    end
   end
 
   describe "with pitted namespace" do
@@ -364,5 +370,45 @@ describe Blueprints do
       @huge_acorn.tree.size.should == 'huge'
     end
   end
+
+  it "should allow to build! without checking if it was already built" do
+    build! :big_cherry, :big_cherry => {:species => 'not so big cherry'}
+    Fruit.count.should == 4
+    Fruit.find_by_species('not so big cherry').should_not be_nil
+  end
+
+  it "should warn when blueprint with same name exists" do
+    $stderr.expects(:puts).with("**WARNING** Overwriting existing blueprint: 'overwritten'")
+    Blueprints::Plan.new(:overwritten)
+    Blueprints::Plan.new(:overwritten)
+  end
+
+  it "should warn when building with options and blueprint is already built" do
+    STDERR.expects(:puts).with("**WARNING** Building with options, but blueprint was already built: 'big_cherry'")
+    build :big_cherry => {:species => 'some species'}
+  end
+
+  describe 'attributes' do
+    it "should allow to extract attributes from blueprint" do
+      build_attributes('attributes.cherry').should == {:species => 'cherry'}
+      build_attributes('attributes.shortened_cherry').should == {:species => 'cherry'}
+      build_attributes(:big_cherry).should == {}
+    end
+
+    it "should use attributes when building" do
+      build 'attributes.cherry'
+      @attributes_cherry.species.should == 'cherry'
+    end
+
+    it "should automatically merge options to attributes" do
+      build 'attributes.cherry' => {:species => 'a cherry'}
+      @attributes_cherry.species.should == 'a cherry'
+    end
+
+    it "should reverse merge attributes from namespaces" do
+      build 'attributes.cherry'
+      @attributes_cherry.average_diameter.should == 10
+    end
+  end
 end
 

data/spec/active_record/fixtures/database.yml.example

@@ -2,7 +2,7 @@ test:
   adapter: mysql
   socket: /var/run/mysqld/mysqld.sock
   encoding: utf8
-  database: hornsby_test
+  database: blueprints_test
   username: root
   password:
-  host: localhost
+  host: localhost

data/test/blueprints_test.rb

@@ -258,6 +258,12 @@ class BlueprintsTest < ActiveSupport::TestCase
       assert(@oak.name == 'Oak')
       assert(@oak.size == 'optional')
     end
+
+    should "allow to pass array of hashes to blueprint method" do
+      Fruit.create
+      fruits = Fruit.blueprint([{:species => 'fruit1'}, {:species => 'fruit2'}])
+      assert(fruits.collect(&:species) == %w{fruit1 fruit2})
+    end
   end
 
   context "with pitted namespace" do
@@ -364,5 +370,45 @@ class BlueprintsTest < ActiveSupport::TestCase
       assert(@huge_acorn.tree.size == 'huge')
     end
   end
+
+  should "allow to build! without checking if it was already built" do
+    build! :big_cherry, :big_cherry => {:species => 'not so big cherry'}
+    assert(Fruit.count == 4)
+    assert(!(Fruit.find_by_species('not so big cherry').nil?))
+  end
+
+  should "warn when blueprint with same name exists" do
+    $stderr.expects(:puts).with("**WARNING** Overwriting existing blueprint: 'overwritten'")
+    Blueprints::Plan.new(:overwritten)
+    Blueprints::Plan.new(:overwritten)
+  end
+
+  should "warn when building with options and blueprint is already built" do
+    STDERR.expects(:puts).with("**WARNING** Building with options, but blueprint was already built: 'big_cherry'")
+    build :big_cherry => {:species => 'some species'}
+  end
+
+  context 'attributes' do
+    should "allow to extract attributes from blueprint" do
+      assert(build_attributes('attributes.cherry') == {:species => 'cherry'})
+      assert(build_attributes('attributes.shortened_cherry') == {:species => 'cherry'})
+      assert(build_attributes(:big_cherry) == {})
+    end
+
+    should "use attributes when building" do
+      build 'attributes.cherry'
+      assert(@attributes_cherry.species == 'cherry')
+    end
+
+    should "automatically merge options to attributes" do
+      build 'attributes.cherry' => {:species => 'a cherry'}
+      assert(@attributes_cherry.species == 'a cherry')
+    end
+
+    should "reverse merge attributes from namespaces" do
+      build 'attributes.cherry'
+      assert(@attributes_cherry.average_diameter == 10)
+    end
+  end
 end
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: blueprints
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Andrius Chamentauskas
@@ -9,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-24 00:00:00 +02:00
+date: 2010-05-25 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -71,21 +77,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Another replacement for factories and fixtures