cranky 0.1.1 → 0.2.0

data/README.rdoc

@@ -29,14 +29,16 @@ You can create as many different factory files as you want, just require them in
 
 == In a Nutshell
 
-Cranky steals its core syntax from Factory Girl...
+Cranky steals its core syntax from Factory Girl and can drop into tests already written for that framework...
 
   Factory.build(:user)                  # Build a user instance without saving
   Factory.create(:user)                 # Build and save a user instance
   Factory.build(:user, :name => "Ian")  # Override a default attribute value
   Factory.attributes_for(:user)         # Return a set of valid attributes rather than the object
 
-And has a nice debug option (rails only) to warn you when your factory is broken, recommend you do this for your first spec...
+Or if you're coming from Machinist, you can make your Cranky factories drop into your existing tests by setting up make and make! methods as shown here.[http://gist.github.com/525653]
+
+Cranky has a nice debug option (rails only) to warn you when your factory is broken, recommend you do this for your first spec...
 
   describe User do
     it "should have a working factory" do
@@ -48,7 +50,7 @@ And has a nice debug option (rails only) to warn you when your factory is broken
 Cranky allows you to build factories via std Ruby methods, like this...
 
   # factories/my_factories.rb
-  class Cranky          # Your factory must use the Cranky class
+  class Cranky::Factory     # Your factory must extend Cranky::Factory
 
     # Simple factory method to create a user instance, you would call this via Factory.build(:user)
     def user
@@ -87,14 +89,14 @@ This is where Cranky really shines, if you can create Ruby methods you can prett
 
 The only rules are:
 
-1. Your factory must use the +Cranky+ class
+1. Your factory must extend the Cranky::Factory class
 2. Your factory method must return the object you wanted to create
 3. You can access the overrides passed in via options[:key]  (not really a rule!) 
 
 So for example to create a simple user factory...
 
   # factories/my_factories.rb
-  class Cranky
+  class Cranky::Factory
 
     # Simple factory method to create a user instance, you would call this via Factory.build(:user)
     def user
@@ -112,7 +114,7 @@ Now of course you are working in straight Ruby here, so you can extend this any
 For example here it is with the capability to automatically create a default address association...
 
   # factories/my_factories.rb
-  class Cranky
+  class Cranky::Factory
 
     # Return the default address if it already exists, or call the address factory to make one
     def default_address
@@ -233,17 +235,8 @@ Clear all instance variables in the factory. This may be useful to run between t
 
 Sometimes it is useful to be warned that your factory is generating invalid instances (although quite often your tests may intentionally generate invalid instances, so use this with care). By turning on debug the Factory will raise an error if the generated instance is invalid...
 
-  Factory.debug = true
-
-Or run within a block...
-
-  Factory.debug do
-    Factory.build(:user)
-  end
-
-Or inline (runs the build method with debug enabled)...
-
-  Factory.debug(:user) 
+  Factory.debug(:user)   # A replacement for Factory.build, with validation warnings enabled
+  Factory.debug!(:user)  # Likewise for Factory.create
 
 Note that this relies on the instance having a valid? method, so in practice this may only work with Rails.
 

data/init.rb

@@ -1,2 +1,2 @@
-require 'crank_it'
+require 'cranky'
 

data/lib/cranky/factory.rb

@@ -0,0 +1,99 @@
+module Cranky
+  class Factory
+
+    attr_writer :debug
+
+    def initialize
+      # Factory jobs can be nested, i.e. a factory method can itself invoke another factory method to
+      # build a dependent object. In this case jobs the jobs are pushed into a pipeline and executed
+      # in a last in first out order. 
+      @pipeline = []
+      @n = 0
+      @errors = []
+    end
+    
+    def build(what, overrides={})
+      crank_it(what, overrides)
+    end
+
+    def create(what, overrides={})
+      item = build(what, overrides)
+      item.save
+      item
+    end
+
+    # Reset the factory instance, clear all instance variables 
+    def reset
+      self.instance_variables.each do |var|
+        instance_variable_set(var, nil)
+      end
+      initialize
+    end
+
+    def attributes_for(what, attrs={})
+      build(what, attrs).attributes
+    end
+
+    # Can be left in your tests as an alternative to build and to warn if your factory method 
+    # ever starts producing invalid instances 
+    def debug(*args)
+      item = build(*args) 
+      if !item.valid?
+        raise "Oops, the #{item.class} created by the Factory has the following errors: #{item.errors}"
+      end
+      item
+    end
+
+    # Same thing for create
+    def debug!(*args)
+      item = debug(*args)
+      item.save
+      item
+    end
+
+    private
+
+      def n
+        @n += 1
+      end
+
+      def inherit(what, overrides={})
+        build(what, overrides.merge(options))
+      end
+
+      # Execute the requested factory method, crank out the target object!
+      def crank_it(what, overrides)
+        item = "TBD"
+        new_job(what, overrides) do
+          item = self.send(what)        # Invoke the factory method
+        end
+        item
+      end
+
+      # This method actually makes the required object instance, it gets called by the users factory 
+      # method, where the name 'define' makes more sense than it does here!
+      def define(defaults={})
+        current_job.defaults = defaults   
+        current_job.execute
+      end
+
+      def current_job
+        @pipeline.last  
+      end
+
+      # Returns a hash containing any top-level overrides passed in when the current factory was invoked
+      def options
+        current_job.overrides
+      end
+
+      # Adds a new job to the pipeline then yields to the caller to execute it 
+      def new_job(what, overrides)
+        @pipeline << Job.new(what, overrides)
+        yield
+        @pipeline.pop
+      end
+
+  end
+
+end
+

data/lib/cranky/job.rb

@@ -0,0 +1,44 @@
+module Cranky
+  class Job
+
+    attr_writer :defaults
+    attr_reader :overrides
+
+    def initialize(target, overrides={})
+      @defaults = {}
+      @target = target
+      @overrides = overrides
+    end
+
+    def attributes
+      @attributes ||= @defaults.merge(@overrides)
+    end
+
+    def defaults=(defs)
+      @attributes = nil   # Needs to be re-calculated
+      @defaults = defs
+    end
+
+    def execute
+      item = get_constant(attributes[:class] ? attributes[:class] : @target).new
+      # Assign all explicit attributes first
+      attributes.each do |attribute, value|
+        item.send("#{attribute}=", value) if item.respond_to?("#{attribute}=") && !value.respond_to?("call")
+      end
+      # Then call any blocks
+      attributes.each do |attribute, value|
+        item.send("#{attribute}=", value.call(item)) if item.respond_to?("#{attribute}=") && value.respond_to?("call")
+      end
+      item
+    end
+
+    private
+
+      # Nicked from here: http://gist.github.com/301173 
+      def get_constant(name_sym)
+        name = name_sym.to_s.split('_').collect {|s| s.capitalize }.join('')
+        Object.const_defined?(name) ? Object.const_get(name) : Object.const_missing(name)
+      end
+
+  end
+end

data/lib/cranky/version.rb

@@ -0,0 +1,3 @@
+module Cranky
+  VERSION = "0.2.0"
+end

data/lib/cranky.rb

@@ -1,106 +1,18 @@
-class Cranky
-
-  VERSION = "0.1.1"
-
-#  Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/*.rb").each do |file|
-#    require file
-#    # Auto include all modules found in the directory
-#    file =~ /.*[\/\\](.*)\.rb/
-#    begin
-#      include $1.to_s.camelcase.constantize
-#    rescue
-#    end
-#  end
-
-  attr_writer :debug
-
-  def initialize
-    @what = []
-    @attrs = []
-    @n = 0
-  end
-
-  def build(what, attrs={})
-    crank_it(what, false, attrs)
-  end
-
-  def create(what, attrs={})
-    crank_it(what, true, attrs)
-  end
-
-  def reset
-    self.instance_variables.each do |var|
-      instance_variable_set(var, nil)
-    end
-    initialize
-  end
-
-  def attributes_for(what, attrs={})
-    build(what, attrs).attributes
-  end
-
-  def debug(what=nil)
-    if block_given?
-      @debug = true
-      yield
-      @debug = false
-    elsif what
-      @debug = true
-      item = build(what) 
-      @debug = false
-      item
-    else
-      @debug
-    end
-  end
-
-  private
-
-    def n
-      @n += 1
-    end
-
-    def inherit(what, attrs={})
-      build(what, attrs.merge(options))
-    end
-
-    def crank_it(what, save, attrs)
-      @attrs << attrs; @what << what
-      item = self.send(what)
-      @attrs.pop; @what.pop
-      if @debug && !item.valid?
-        raise "Oops, the #{what} created by the Factory has the following errors: #{item.errors}"
-      end
-      item.save if save
-      item
-    end
-
-    def define(attrs={})
-      final_attrs = attrs.merge(@attrs.last)
-      item = get_constant(attrs[:class] ? attrs[:class] : @what.last).new
-      final_attrs.delete(:class)
-      # Assign all explicit attributes first
-      final_attrs.each do |attr, value|
-        item.send("#{attr}=", value) if item.respond_to?("#{attr}=") && !value.respond_to?("call")
-      end
-      # Then call any blocks
-      final_attrs.each do |attr, value|
-        item.send("#{attr}=", value.call(item)) if item.respond_to?("#{attr}=") && value.respond_to?("call")
-      end
-      item
-    end
-
-    # Nicked from here: http://gist.github.com/301173 
-    def get_constant(name_sym)
-      name = name_sym.to_s.split('_').collect {|s| s.capitalize }.join('')
-      Object.const_defined?(name) ? Object.const_get(name) : Object.const_missing(name)
-    end
-
-    def options
-      @attrs.last
-    end
-
+require 'cranky/version'
+require 'cranky/job'
+require 'cranky/factory'
+
+# Instantiate a factory, this enables an easy drop in for tests written for Factory Girl  
+Factory = Cranky::Factory.new unless defined?(Factory)
+
+# Alternative Cranky specific syntax:
+#   crank(:user)   # equivalent to Factory.build(:user)
+#   crank!(:user)  # equivalent to Factory.create(:user)
+def crank(*args)
+  Factory.build(*args)
 end
 
-Factory = Cranky.new unless defined?(Factory)
+def crank!(*args)
+  Factory.create(*args)
+end
 

data/spec/cranky_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Cranky do
+describe "The Cranky factory" do
 
   before(:each) do
   end
@@ -54,6 +54,13 @@ describe Cranky do
     b.role.should == :admin
   end
 
+  it "should give top priority to attributes defined at the top level, even when inheriting" do
+    a = Factory.build(:admin_manually, :role => :something_else)
+    a.role.should == :something_else
+    b = Factory.build(:admin_by_define, :role => :something_else)
+    b.role.should == :something_else
+  end
+
   it "should create unique values using the n method" do
     a = Factory.build(:user)  
     b = Factory.build(:user)  
@@ -66,40 +73,19 @@ describe Cranky do
   describe "debugger" do 
 
     it "should raise an error if the factory produces an invalid object when enabled (rails only)" do
-      Factory.debug = true
       error = false
       begin
-        Factory.build(:user)
+        Factory.debug(:user, :valid => false)
       rescue
         error = true 
       end
       error.should == true
-      Factory.debug = false
     end
 
-    it "can be run as a block" do
-      Factory.debug.should == false
-      error = false
-      Factory.debug do
-        begin
-          Factory.build(:user)
-        rescue
-          error = true 
-        end
-      end
-      error.should == true
-      Factory.debug.should == false
-    end
-
-    it "can be run inline" do
-      Factory.debug.should == false
-      error = false
-      begin
-        Factory.debug(:user)
-      rescue
-        error = true 
-      end
-      error.should == true
+    it "should have debug work like build and create when there are no errors" do
+      Factory.debug(:user).class.should == User
+      Factory.debug(:user).saved?.should == false
+      Factory.debug!(:user).saved?.should == true
     end
 
   end
@@ -115,6 +101,20 @@ describe Cranky do
     Factory.build(:user, :name => "jenny", :email => Proc.new{ |u| "#{u.name}@home.com" }).email.should == "jenny@home.com"
     Factory.build(:user, :name => Proc.new{"jimmy" + " cranky"}).name.should == "jimmy cranky"
   end
+
+  it "allows factories to call other factories" do
+    Factory.build(:user_manually).address.city.should == "New York"
+    Factory.create(:user_manually).address.city.should == "New York"
+    Factory.create(:user_manually).address.saved?.should == false
+    Factory.build(:user_by_define).address.city.should == "New York"
+    Factory.create(:user_by_define).address.city.should == "New York"
+    Factory.create(:user_by_define).address.saved?.should == true
+  end
+
+  it "should also have its own syntax" do
+    crank(:user).saved?.should == false
+    crank!(:address).saved?.should == true
+  end
   
 end
 

data/spec/spec_helper.rb

@@ -2,13 +2,9 @@ require 'rubygems'
 require 'spec'
 require 'cranky'
 
-# A basic model to crank out
-class User
-  attr_accessor :name
-  attr_accessor :role
-  attr_accessor :email
-  attr_accessor :unique
-  attr_accessor :argument_received
+
+class TestClass
+  attr_accessor :valid
 
   def save
     @saved = true
@@ -19,7 +15,7 @@ class User
   end
 
   def valid?
-    false
+    @valid
   end
 
   def errors
@@ -29,11 +25,26 @@ class User
   def attributes
     self.instance_variables
   end
+end
 
+# A basic model to crank out
+class User < TestClass
+  attr_accessor :name
+  attr_accessor :role
+  attr_accessor :email
+  attr_accessor :unique
+  attr_accessor :argument_received
+  attr_accessor :address
+end
+
+
+class Address < TestClass
+  attr_accessor :address
+  attr_accessor :city
 end
 
 # Some basic factory methods
-class Cranky
+class Cranky::Factory
 
   attr_accessor :some_instance_variable
 
@@ -43,6 +54,8 @@ class Cranky
     u.role = options[:role] || :user
     u.unique = "value#{n}"
     u.email = "fred@home.com"
+    u.address = Factory.build(:address)
+    u.valid = true
     u
   end
 
@@ -51,7 +64,9 @@ class Cranky
                :name => "Fred",
                :role => :user,
                :unique => "value#{n}",
-               :email => "fred@home.com"
+               :email => "fred@home.com",
+               :address => Factory.create(:address),
+               :valid => true
     u.argument_received = true if options[:argument_supplied]
     u
   end
@@ -65,6 +80,12 @@ class Cranky
     inherit(:user_by_define, :role => :admin)
   end
 
+  def address
+    define :address => "25 Wisteria Lane",
+           :city => "New York",
+           :valid => true
+  end
+
 end
 
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cranky
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Stephen McGinty
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-14 00:00:00 -05:00
+date: 2010-08-22 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/cranky/job.rb
+- lib/cranky/factory.rb
+- lib/cranky/version.rb
 - lib/cranky.rb
 - spec/spec_helper.rb
 - spec/cranky_spec.rb