machinery 0.9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Lawrence Pit
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,208 @@
+Machinery
+=========
+
+*Machinery to create object graphs and speed up tests.*
+
+Machinery helps to create object graphs for use in tests without needing
+fixtures, using pure ruby style. These object graphs are easily re-usable
+in Test::Unit, RSpec, Cucumber and in rake tasks to populate a database.
+
+Secondly, even if you don't need object graphs, Machinery can speed up
+your tests significantly because you can set up any model objects in
+a before(:all) instead of a before(:each), and at the end of the tests
+all activerecord objects created in the before(:all) will be cleaned up
+automatically.
+
+Machinery works with plain ruby objects and currently supports ActiveRecord.
+A DataMapper abstraction should be too easy.
+
+
+Usage
+-----
+
+#### Object Graphs
+
+In /spec/scenarios.rb
+
+    Machinery.define do
+      scenario :earth_ships do
+        @titanic = Ship.create!(:name => "Titanic")
+        @pirate  = Ship.create!(:name => "Pirate")
+      end
+
+      scenario :space_ships do
+        @apollo = Ship.create!(:name => "Apollo")
+        @uss_enterprise = Ship.create!(:name => "USS Enterprise")
+      end
+
+      scenario :all_ships do
+        scenarios :earth_ships, :space_ships
+        @sunken_ship = Ship.create!(:name => "Sunk")
+      end
+    end
+
+
+In /spec/spec_helper.rb
+
+    require 'machinery'
+    require File.join(File.dirname(__FILE__) + 'scenarios')
+
+
+In /spec/models/ship_spec.rb
+
+    describe Ship do
+      scenarios :all_ships
+
+      it "should create a pirate ship" do
+        @pirate.should_not be_nil
+      end
+
+      it "should have 5 ships" do
+        Ship.count.should == 5
+      end
+    end
+
+
+#### Just the speed up please
+
+If it's only speeding up your tests you're after you can use anonymous scenarios, like this:
+
+In /spec/models/ship_spec.rb
+
+    describe Ship do
+      scenario do
+        @pirate = Ship.create!(:name => "Pirate")
+      end
+
+      it "should update a pirate ship" do
+        @pirate.name = "Updated Pirate"
+        @pirate.save
+        @pirate.reload
+        @pirate.name.should == "Updated Pirate"
+      end
+
+      it "should have 1 ship" do
+        Ship.count.should == 1
+      end
+
+      it "should be named 'Pirate'" do
+        @pirate.name.should == "Pirate"
+      end
+    end
+
+This will create one ship only in the database.
+
+
+
+Explain
+-------
+
+When you use +scenario+ with a block you are defining a scenario. Any instance
+variables you declare within a scenario will be available in your test when you
+use that scenario.
+
+When you use +scenario+ without a block then you indicate that the block for the
+scenario you previously defined should be executed. Any instance variables you
+defined within the block will now be available to you in your test methods. Note
+that you can re-use scenarios within scenarios.
+
+When you declare to use a scenario within an rspec +ExampleGroup+ (as in the first
+ship_spec example above) then the instances will be created for you exactly once.
+They will automatically be removed from the database after all the tests have run.
+Any instance variables declared within a scenario will be cloned before each test.
+If you make sure you use +use_transactional_fixtures+ then this means:
+
+* speedy tests, because instances are created exactly once for all tests
+* you can mess around with the instance variables any way you like within a test method as before each test they will always be in exactly the same initial state.
+
+A special case is when you use an anonymous +scenario+ with a block, specified at the
+top of your tests (as in the second ship_spec example above). It will behave as if it's
+a named scenario *and* it is used immediately.
+At most one anonymous +scenario+ per example group can be used.
+
+
+Magic?
+------
+
+Why write stuff like:
+
+    users(:admin).should be_nil
+
+when you can just as well write:
+
+    @user_admin.should be_nil
+
+Use less magic. Less code. Makes software softer.
+
+
+Installation
+------------
+
+### Rails installation (Test::Unit)
+
+#### As a Gem
+
+Use this if you prefer to use versioned releases of Machinery.
+Specify the gem dependency in your config/environment.rb file:
+
+    Rails::Initializer.run do |config|
+      config.gem "lawrencepit-machinery", :lib => "machinery", :source => "http://gems.github.com"
+    end
+
+Then:
+
+    $ rake gems:install
+    $ rake gems:unpack
+
+#### As a Plugin
+
+Use this if you prefer to use the edge version of Machinery:
+
+    $ script/plugin install git://github.com/lawrencepit/machinery.git
+
+### Rails installation (RSpec)
+
+If you're using Machinery with RSpec, it is recommended that you add config.gem lines
+for RSpec and Machinery in your config/environment/test.rb file, but do not ask
+Rails to load the RSpec and Machinery libraries:
+
+    config.gem 'rspec', :lib => false
+    config.gem 'rspec-rails', :lib => false
+    config.gem 'lawrencepit-machinery', :lib => false, :source => 'http://gems.github.com'
+
+Then require machinery from your spec/spec_helper.rb file, before Spec::Runner is
+configured:
+
+    # requires for RSpec
+    require 'machinery'
+    Spec::Runner.configure do |config|
+    # ...
+
+You should not need to require anything besides the top-level machinery library.
+
+
+
+Credits
+-------
+
+Written by [Lawrence Pit](http://lawrencepit.com).
+
+Thanks to
+[Machinist](http://github.com/notahat/machinist),
+[ModelStubbing](http://github.com/technoweenie/model_stubbing),
+[FactoryGirl](http://github.com/thoughtbot/factory_girl),
+[FixtureScenarios](http://errtheblog.com/posts/61-fixin-fixtures) and
+[Hornsby](http://github.com/lachie/hornsby)
+for inspiration.
+
+After using model_stubbing on a relatively large project for over a year I decided
+a simpler solution was needed. Object graphs need to be easily re-usable by specs,
+unit tests, cucumber stories and ad-hoc database loading. And tests need to be speedy.
+
+Machinery works especially pleasurable in combination with
+[Machinist](http://github.com/notahat/machinist) or
+[FactoryGirl](http://github.com/thoughtbot/factory_girl).
+
+
+----
+Copyright (c) 2009 Lawrence Pit, released under the MIT license

data/lib/machinery/active_record.rb

@@ -0,0 +1,48 @@
+module Machinery
+  module ActiveRecord
+    @@toys = []
+    @@recording_level = 0
+
+    def self.record
+      @@recording_level = @@recording_level + 1
+      yield
+      @@recording_level = @@recording_level - 1
+    end
+
+    def self.clear
+      @@toys.each do |toy| 
+        toy.connection.delete(
+          "DELETE FROM #{toy.class.quoted_table_name} " +
+          "WHERE #{toy.connection.quote_column_name(toy.class.primary_key)} = #{toy.quoted_id}",
+          "#{toy.class.name} Destroy"
+        )
+      end
+      @@toys = []
+    end
+
+    def self.created(obj)
+      @@toys << obj if @@recording_level > 0
+    end
+
+    module Extensions
+      private
+
+      def self.included(base)
+        base.class_eval do
+          alias_method :create_without_machinery, :create
+          alias_method :create, :create_with_machinery
+        end
+      end
+
+      def create_with_machinery
+        id = create_without_machinery
+        Machinery::ActiveRecord.created(self)
+        id
+      end
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, Machinery::ActiveRecord::Extensions)
+

data/lib/machinery.rb

@@ -0,0 +1,77 @@
+require 'active_record'
+require 'machinery/active_record'
+
+module Machinery
+  @@scenarios = {}
+
+  def self.scenario(name, &block)
+    @@scenarios[name] = block
+  end
+
+  def self.load(file)
+    Machinery.instance_eval(File.read(file))
+  end
+
+  def self.define(&block)
+    Machinery.instance_eval(&block)
+  end
+
+  private
+    def self.make_scenario(context, names, &block)
+      evaluated = context.instance_variable_get('@_machinery') || []
+      Machinery::ActiveRecord.record do
+        names.each do |name|
+          next if evaluated.include?(name)
+          context.instance_variable_set('@_machinery', evaluated << name)
+          context.instance_eval(&@@scenarios[name])
+        end
+      end
+    end
+
+  module Helpers
+    def scenario(*names, &block)
+      Machinery.scenario(names.first, &block) and return if block_given?
+      Machinery.make_scenario(self, names, &block)
+    end
+    alias_method :scenarios, :scenario
+
+    def rollback_scenario
+      Machinery::ActiveRecord.clear
+    end
+    alias_method :rollback_scenarios, :rollback_scenario
+
+    private
+      def clone_instance_variables
+        self.instance_variables.each do |ivar|
+          obj = self.instance_variable_get(ivar)
+          next unless obj.is_a?(::ActiveRecord::Base)
+          clone = obj.clone
+          clone.id = obj.id
+          clone.instance_variable_set('@new_record', obj.new_record?)
+          self.instance_variable_set(ivar, clone)
+        end
+      end
+  end
+
+  module ExampleGroupMacros
+    def scenario(*names, &block)
+      scenario(:__anonymous__, &block) and scenario(:__anonymous__) and return if names.empty?
+      Machinery.scenario(names.first, &block) and return true if block_given?
+      self.before(:all)  { scenarios(*names) }
+      self.after(:all)   { rollback_scenarios }
+      self.before(:each) { clone_instance_variables }
+    end
+    alias_method :scenarios, :scenario
+  end
+end
+
+if defined? Test::Unit::TestCase
+  Test::Unit::TestCase.extend Machinery::ExampleGroupMacros
+  Test::Unit::TestCase.send('include', Machinery::Helpers)
+end
+
+if defined? Spec::Example::ExampleGroup
+  Spec::Example::ExampleGroup.extend Machinery::ExampleGroupMacros
+  Spec::Example::ExampleGroupFactory[nil].send('include', Machinery::Helpers)
+end
+

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: machinery
+version: !ruby/object:Gem::Version 
+  version: "0.9"
+platform: ruby
+authors: 
+- Lawrence Pit
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lawrence.pit@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- MIT-LICENSE
+- lib/machinery.rb
+- lib/machinery/active_record.rb
+has_rdoc: true
+homepage: http://github.com/lawrencepit/machinery
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Machinery to create object graphs and speed up tests.
+test_files: []
+