sqrbl 0.1.0

data/lib/sqrbl/step.rb

@@ -0,0 +1,192 @@
+# This file is part of SQrbL, which is free software licensed under v3 of the GNU GPL.
+# For more information, please see README.txt and LICENSE.txt in the project's root directory.
+
+
+module Sqrbl
+  # The Step class is where most of the work of SQrbL takes place.
+  # All of the public methods on this class have side effects:  they
+  # take the parameters given, tweak their format in some way, and
+  # use them to append data to the +output+ attribute.
+  #
+  # For example, the following code will cause the DELETE statement
+  # to appear in +output+:
+  #
+  #   action "Drop imported organizational contacts" {
+  #     'DELETE FROM new_widgets WHERE note LIKE "Imported from old_widgets"'
+  #   }
+  #
+  # +action+ is the primary method you'll use to do the actual work,
+  # but there are a number of other helper methods that let you insert
+  # variously-formatted comments, and +insert_into+ helps DRY up some
+  # of the verbosity involved in writing INSERT statements.
+  class Step
+    attr_reader :step_pair, :output, :block
+
+    include Sqrbl::ExpectsBlockWithNew
+    include Sqrbl::MethodMissingDelegation
+    delegate_method_missing_to :step_pair
+    include HasTodos
+
+    # :stopdoc:
+    GiantWarningText = <<-EOF
+##     ##    ###    #######   ##    ##  ######  ##    ##    #####    ##
+##     ##   ## ##   ##    ##  ###   ##    ##    ###   ##   ##   ##   ##
+##     ##  ##   ##  ##    ##  ####  ##    ##    ####  ##  ##         ##
+##  #  ##  #######  #######   ## ## ##    ##    ## ## ##  ##   ####  ##
+## ### ##  ##   ##  ##  ##    ##  ####    ##    ##  ####  ##     ##  ##
+#### ####  ##   ##  ##   ##   ##   ###    ##    ##   ###   ##   ##
+###   ###  ##   ##  ##    ##  ##    ##  ######  ##    ##    #####    ##
+EOF
+    GiantWarningSeparator = '#' * GiantWarningText.split(/\n/).map(&:length).max
+    GiantWarningTemplate =  "/*" +
+                            "\n" + GiantWarningSeparator + "\n" +
+                            "\n" + GiantWarningText      +
+                            "\n" + GiantWarningSeparator + "\n[[LineNum]]\n[[Message]]" +
+                            "\n" + GiantWarningSeparator +
+                            "\n" + "*/"
+    # :startdoc:
+
+    def initialize(step_pair, options = {}, &block)
+      @output    = ''
+      @step_pair = step_pair
+      @block     = lambda(&block)
+
+      eval_block_on_initialize(options)
+    end
+
+    # Writes a commented-out Todo item to +output+.
+    #
+    # Also, creates a Todo object that may be used to create console
+    # output when building the *.sql output files (see HasTodos for
+    # more information).
+    def todo(message)
+      returning(super) do |todo|
+        todo_msg = "--> %s %s:\t%s" % ['todo'.upcase, caller_info(todo), todo.message]
+        write todo_msg
+      end
+    end
+
+    # Takes +message+ and writes it to +output+ surrounded by a large
+    # block-commented ASCII-art message that reads "WARNING!".  The
+    # intent here is to create a large message that stands out when
+    # scrolling through the output or copy/pasting it into your SQL
+    # client.  This message will also contain information pointing
+    # you to the place where +warning+ was called.
+    #
+    # For example, calling <tt>warning "Danger, Will Robinson!"</tt>
+    # from foo.rb on line 42 will append something like the following
+    # to +output+:
+    #
+    #   /*
+    #   #######################################################################
+    #
+    #   ##     ##    ###    #######   ##    ##  ######  ##    ##    #####    ##
+    #   ##     ##   ## ##   ##    ##  ###   ##    ##    ###   ##   ##   ##   ##
+    #   ##     ##  ##   ##  ##    ##  ####  ##    ##    ####  ##  ##         ##
+    #   ##  #  ##  #######  #######   ## ## ##    ##    ## ## ##  ##   ####  ##
+    #   ## ### ##  ##   ##  ##  ##    ##  ####    ##    ##  ####  ##     ##  ##
+    #   #### ####  ##   ##  ##   ##   ##   ###    ##    ##   ###   ##   ##
+    #   ###   ###  ##   ##  ##    ##  ##    ##  ######  ##    ##    #####    ##
+    #
+    #   #######################################################################
+    #   (foo.rb, line 42)
+    #   Danger, Will Robinson!
+    #   #######################################################################
+    #   */
+    #
+    # Also, creates a Todo object of subtype <tt>:warning</tt> that
+    # may be used to create console output when building the *.sql
+    # output files (see HasTodos for more information).
+    def warning(message)
+      returning(super) do |warn|
+        giant_warning = GiantWarningTemplate.gsub('[[LineNum]]', caller_info(warn)) \
+                                            .gsub('[[Message]]', warn.message)
+        write giant_warning
+      end
+    end
+    alias :danger_will_robinson! :warning
+
+    # Outputs a message preceded by the SQL line-comment prefix <tt>"-- "</tt>.
+    def comment(message)
+      write '-- ' + message
+    end
+
+    # Outputs a message surrounded by /* SQL block-comment delimiters */.
+    def block_comment(&block_returning_string)
+      write "/*\n%s\n*/" % indent(4, unindent(yield))
+    end
+
+    # Expects a message and a block whose return value is a string.
+    # Outputs a comment containing +message+, followed by the return value of the block.
+    def action(message, &block_returning_string)
+      comment(message)
+      write(unindent(block_returning_string.call))
+    end
+
+    # Helper method for DRYing up INSERT statements.  Takes a table name
+    # and a hash that maps field names to SQL expressions, and builds an
+    # INSERT statement that populates those fields.  For example:
+    #
+    #   insert_into 'new_widgets', {
+    #     :name     => 'widget_name',
+    #     :part_num => 'CONCAT("X_", part_number)',
+    #     :note     => '"Imported from old_widgets"',
+    #   }
+    #
+    # will produce:
+    #
+    #   INSERT INTO new_widgets (
+    #       part_num,
+    #       note,
+    #       name
+    #   )
+    #   SELECT
+    #       CONCAT("X_", part_number) AS part_num,
+    #       "Imported from old_widgets" AS note,
+    #       widget_name AS name
+    #
+    # <i>(Note that this only creates the INSERT INTO and SELECT clauses
+    # of a SQL statement.)</i>
+    def insert_into(table_name, map_from_fieldname_to_expr = {})
+      # Build the "INSERT INTO (foo, bar, baz)" clause
+      insert_fields = map_from_fieldname_to_expr.keys.join(",\n")
+      insert_clause = "INSERT INTO %s (\n%s\n)\n" % [table_name, indent(4, insert_fields)]
+
+      # Build the "SELECT FROM" clause
+      select_fields = map_from_fieldname_to_expr.map { |field_name, expr| "#{expr} AS #{field_name}" }.join(",\n")
+      select_clause = "SELECT\n" + indent(4, select_fields)
+
+      insert_clause + select_clause
+    end
+
+    # Write +text+ to +output+, followed by newlines.
+    # (This is used by most other methods on Step; it's made public
+    # in case you want to use it in a way I didn't anticipate.)
+    def write(text)
+      output << text + "\n\n"
+    end
+
+    protected
+    # Format caller information from the Todo for output.
+    def caller_info(todo)
+      "(#{todo.creating_file}, line #{todo.calling_line})"
+    end
+
+    # Indents +text+ by +n+ spaces.
+    def indent(n, text)
+      text.to_s.gsub(/^(.)/, (' ' * n) + '\1')
+    end
+
+    # If the first line of +text+ has leading whitespace, remove
+    # that same amount of leading whitespace from all lines in +text+.
+    #
+    # (This is an anal-retentiveness helper method:  it lets you
+    # keep your SQL statements indented below the +action+ calls
+    # that append them to +output+, while keeping that extra
+    # indentation from appearing in your generated *.sql files.)
+    def unindent(text)
+      return text unless text =~ /^(\s+)/
+      text.gsub(Regexp.new("^" + $1), '')
+    end
+  end
+end

data/lib/sqrbl/step_pair.rb

@@ -0,0 +1,56 @@
+# This file is part of SQrbL, which is free software licensed under v3 of the GNU GPL.
+# For more information, please see README.txt and LICENSE.txt in the project's root directory.
+
+
+module Sqrbl
+  # Like the Group class, StepPair doesn't do much on its own.
+  # It's basically a container for two Step objects, which are created using
+  # +up+ and +down+.  These two steps will usually, but not always, have a
+  # one-to-one correspondence in their actions.  <i>(For example, a temp table
+  # may take a number of actions to create and populate, but removing it
+  # just takes a "DROP TABLE" statement.)</i>
+  #
+  # * The +up_step+ describes the actions necessary to move the source data one
+  #   step closer to the target format.
+  # * The +down_step+ describes the actions necessary to undo the actions taken
+  #   by the up_step.
+  #
+  # StepPair delegates +method_missing+ calls to its +group+ object.
+  # For more information, see MethodMissingDelegation.
+  class StepPair
+    attr_reader :group, :description, :block
+    attr_reader :up_step, :down_step
+
+    include Sqrbl::ExpectsBlockWithNew
+    include Sqrbl::MethodMissingDelegation
+    delegate_method_missing_to :group
+    include HasTodos
+
+    def initialize(group, description, options = {}, &block)
+      @group       = group
+      @description = description
+      @block       = lambda(&block)
+
+      eval_block_on_initialize(options)
+    end
+
+    # Create a Step object, passing it the block.
+    def up(&block)
+      @up_step = Step.new(self, &block)
+    end
+
+    # Create a Step object, passing it the block.
+    def down(&block)
+      @down_step = Step.new(self, &block)
+    end
+
+    # A StepPair is valid if both the up_step and the down_step have been created as Step objects.
+    def valid?
+      [up_step, down_step].all? { |step| step.kind_of?(Step) }
+    end
+
+    def unix_name
+      Sqrbl.calculate_unix_name(description)
+    end
+  end
+end

data/lib/sqrbl/unified_migration_writer.rb

@@ -0,0 +1,34 @@
+module Sqrbl
+  # Writes two files:  output_directory/all_up.sql and output_directory/all_down.sql.
+  # * output_directory/all_up.sql contains all 'up' steps, in creation order.
+  # * output_directory/all_down.sql contains all 'down' steps, in reverse creation order.
+  class UnifiedMigrationWriter < BaseMigrationWriter
+    # Create all_up.sql and all_down.sql in output_directory.
+    def write!
+      ensure_dir_exists(output_directory)
+      write_file(up_file, all_up_steps_output)
+      write_file(down_file, all_down_steps_output)
+    end
+
+    # Output from all 'up' steps, in creation order
+    def all_up_steps_output
+      migration.up_steps.map(&:output).join
+    end
+
+    # Output from all 'down' steps, in reverse creation order
+    def all_down_steps_output
+      migration.down_steps.reverse.map(&:output).join
+    end
+
+    protected
+    # Pathname to all_up.sql
+    def up_file
+      File.join(output_directory, 'all_up.sql'  )
+    end
+
+    # Pathname to all_down.sql
+    def down_file
+      File.join(output_directory, 'all_down.sql')
+    end
+  end
+end

data/lib/sqrbl.rb

@@ -0,0 +1,83 @@
+# This file is part of SQrbL, which is free software licensed under v3 of the GNU GPL.
+# For more information, please see README.txt and LICENSE.txt in the project's root directory.
+#
+# Most of this was autogenerated by the 'bones' gem.
+# The primary domain-specific method of interest here is Sqrbl.migration.
+module Sqrbl
+
+  # :stopdoc:
+  VERSION = '0.1.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  # Convenience method:  builds and writes a migration in one go.
+  def self.migration(&block)
+    returning(build_migration(&block)) do |mig|
+      write_migration!(mig)
+    end
+  end
+
+  # Convenience method:  Calls Sqrbl::Migration.build and passes it the given block.
+  def self.build_migration(&block)
+    Sqrbl::Migration.build(&block)
+  end
+
+  # Convenience method:  Write a Migration using all subclasses of BaseMigrationWriter.
+  def self.write_migration!(migration)
+    BaseMigrationWriter.subclasses.each do |writer_class|
+      writer_class.write_migration!(migration)
+    end
+  end
+
+  # Returns the string, in lower case, with whitespace converted to underscores
+  # and all non-alphanumeric characters removed.
+  def self.calculate_unix_name(string)
+    string.gsub(/\s+/, '_').downcase.gsub(/[^a-z0-9_]/, '')
+  end
+
+end  # module Sqrbl
+
+#--
+# TODO: figure out how to do autoload on const_missing
+#++
+Sqrbl.require_all_libs_relative_to(__FILE__, 'core_exts')
+Sqrbl.require_all_libs_relative_to(__FILE__, 'sqrbl/mixins')
+Sqrbl.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/spec/README.txt

@@ -0,0 +1,4 @@
+Spec notes:
+
+- When you see "foo.should_receive(:bar).with(self)" inside a block, it's probably a hack that takes advantage of the fact that the block is being instance_eval'd somewhere else.
+- When you see "foo.should_receive(:bar).with(some_args).and_yield", the and_yield means that the #bar method on foo must be sent a block parameter.

data/spec/functional/base_migration_writer_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe BaseMigrationWriter do
+  it "should know what its subclasses are" do
+    BaseMigrationWriter.subclasses.should == [
+      IndividualMigrationWriter,
+      UnifiedMigrationWriter,
+    ]
+  end
+end

data/spec/functional/individual_migration_writer_spec.rb

@@ -0,0 +1,172 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe IndividualMigrationWriter do
+  before(:each) do
+    @mig = Sqrbl.build_migration do
+      group 'Group one' do
+        step 'Step one' do
+          up   { write 'Step one up'   }
+          down { write 'Step one down' }
+        end
+      end
+    end
+
+    @base_dir = File.expand_path(File.join(File.dirname(__FILE__), 'sql'))
+    @writer = IndividualMigrationWriter.new(@mig)
+  end
+
+  it "should have a output_directory attribute" do
+    @writer.output_directory.should == @base_dir
+  end
+
+  describe :write! do
+    it "should clear the sql/up and sql/down directories (yes, this is dangerous)" do
+      FileUtils.should_receive(:rm_rf).with(File.join(File.expand_path(@base_dir), 'up')  )
+      FileUtils.should_receive(:rm_rf).with(File.join(File.expand_path(@base_dir), 'down'))
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should NOT clear the sql/up and sql/down directories if passed :safe_mode => true" do
+      FileUtils.should_not_receive(:rm_rf)
+      stub_out_file_creation
+      @writer.write!(:safe_mode => true)
+    end
+  end
+
+  describe "for a migration with two groups and three steps" do
+    before(:each) do
+      @mig = Sqrbl.build_migration do
+        group 'Group one' do
+          step 'Step one' do
+            up   { write 'Step one up'   }
+            down { write 'Step one down' }
+          end
+          step 'Step two' do
+            up   { write 'Step two up'  }
+            down { write 'Step two down'}
+          end
+        end
+        group 'Group two' do
+          step 'Step three' do
+            up   { write 'Step three up'   }
+            down { write 'Step three down' }
+          end
+        end
+      end
+
+      @base_dir = File.expand_path(File.join(File.dirname(__FILE__), 'sql'))
+      @writer = IndividualMigrationWriter.new(@mig)
+    end
+
+    it "should create a separate subdirectory in [output_directory]/up for each group" do
+      @mig.groups.each_with_index do |group, idx|
+        group_dir   = "#{idx + 1}_#{group.unix_name}"
+        up_subdir   = File.join(@writer.output_directory, 'up',   group_dir)
+        down_subdir = File.join(@writer.output_directory, 'down', group_dir)
+        File     .should_receive(:directory?).with(up_subdir  ).and_return(false)
+        File     .should_receive(:directory?).with(down_subdir).and_return(false)
+        FileUtils.should_receive(:makedirs).with(up_subdir  )
+        FileUtils.should_receive(:makedirs).with(down_subdir)
+      end
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should create a separate file for each step, in the subdirectory for that step's group" do
+      @mig.groups.each_with_index do |group, idx|
+        group_dir     = "#{idx + 1}_#{group.unix_name}"
+        up_subdir   = File.join(@writer.output_directory, 'up',   group_dir)
+        down_subdir = File.join(@writer.output_directory, 'down', group_dir)
+        group.steps.each_with_index do |step, idx|
+          up_step_filename   = File.join(up_subdir,   "#{idx + 1}_#{step.up_step.unix_name  }.sql")
+          down_step_filename = File.join(down_subdir, "#{idx + 1}_#{step.down_step.unix_name}.sql")
+
+          @writer.should_receive(:write_file).with(up_step_filename,   step.up_step.output  )
+          @writer.should_receive(:write_file).with(down_step_filename, step.down_step.output)
+        end
+      end
+      stub_out_file_creation
+      @writer.write!
+    end
+  end
+
+  describe "for a migration with 10 groups" do
+    before(:each) do
+      @mig = Sqrbl.build_migration do
+        group 'Group one' do
+          step 'Step one' do
+            up   { write 'Step one up'   }
+            down { write 'Step one down' }
+          end
+        end
+        group 'Group two' do
+          step 'Step two' do
+            up   { write 'Step two up'  }
+            down { write 'Step two down'}
+          end
+        end
+        group 'Group three' do
+          step 'Step three' do
+            up   { write 'Step three up'   }
+            down { write 'Step three down' }
+          end
+        end
+        group 'Group four' do
+          step 'Step four' do
+            up   { write 'Step four up'   }
+            down { write 'Step four down' }
+          end
+        end
+        group 'Group five' do
+          step 'Step five' do
+            up   { write 'Step five up'   }
+            down { write 'Step five down' }
+          end
+        end
+        group 'Group six' do
+          step 'Step six' do
+            up   { write 'Step six up'   }
+            down { write 'Step six down' }
+          end
+        end
+        group 'Group seven' do
+          step 'Step seven' do
+            up   { write 'Step seven up'   }
+            down { write 'Step seven down' }
+          end
+        end
+        group 'Group eight' do
+          step 'Step eight' do
+            up   { write 'Step eight up'   }
+            down { write 'Step eight down' }
+          end
+        end
+        group 'Group nine' do
+          step 'Step nine' do
+            up   { write 'Step nine up'   }
+            down { write 'Step nine down' }
+          end
+        end
+        group 'Group ten' do
+          step 'Step ten' do
+            up   { write 'Step ten up'   }
+            down { write 'Step ten down' }
+          end
+        end
+      end
+
+      @writer = IndividualMigrationWriter.new(@mig)
+    end
+
+    it "should left-fill the group numbers with zeros" do
+      group_ten_up_dir = File.join(@writer.output_directory, 'up', '10_group_ten')
+      File.should_receive(:directory?).with(group_ten_up_dir).and_return(false)
+      FileUtils.should_receive(:makedirs).with(group_ten_up_dir).once
+      stub_out_file_creation
+      @writer.write!
+    end
+  end
+end

data/spec/functional/unified_migration_writer_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include Sqrbl
+
+describe UnifiedMigrationWriter do
+  describe "for a migration with #output_directory set" do
+    it "should set #output_directory from the migration's #output_directory" do
+      mig = mock('Migration', :output_directory => '/path/to/sql', :creating_file => nil)
+      writer = UnifiedMigrationWriter.new(mig)
+      writer.output_directory.should == mig.output_directory
+    end
+  end
+
+  describe "for a migration with output_directory blank" do
+    it "should set #output_directory using the dirname of the migration's #creating_file, plus /sql" do
+      mig = mock('Migration', :output_directory => nil, :creating_file => '/path/to/some/sqrbl_file.rb')
+      writer = UnifiedMigrationWriter.new(mig)
+      writer.output_directory.should == '/path/to/some/sql'
+    end
+  end
+
+  describe "for a migration with two groups and three steps" do
+    before(:each) do
+      @mig = Sqrbl.build_migration do
+        group 'Group one' do
+          step 'Step one' do
+            up   { write 'Step one up'   }
+            down { write 'Step one down' }
+          end
+          step 'Step two' do
+            up   { write 'Step two up'  }
+            down { write 'Step two down'}
+          end
+        end
+        group 'Group two' do
+          step 'Step three' do
+            up   { write 'Step three up'   }
+            down { write 'Step three down' }
+          end
+        end
+      end
+
+      @base_dir = File.expand_path(File.join(File.dirname(__FILE__), 'sql'))
+      @writer = UnifiedMigrationWriter.new(@mig)
+    end
+
+    it "should not create the target directory if it already exists" do
+      File.should_receive(:directory?).with(@base_dir).and_return(true)
+      FileUtils.should_not_receive(:makedirs).with(@base_dir)
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should create the target directory if it does not exist" do
+      File.should_receive(:directory?).with(@base_dir).and_return(false)
+      FileUtils.should_receive(:makedirs).with(@base_dir)
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should create a file 'sql/all_up.sql' in the target directory" do
+      File.should_receive(:open).with(File.join(@base_dir, 'all_up.sql'), 'w')
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should combine the contents of all up steps in order" do
+      @writer.all_up_steps_output.should == @mig.up_steps.map(&:output).join
+    end
+
+    it "should write the contents of all up steps to the all_up.sql file" do
+      mock_file = mock('File')
+      File.should_receive(:open).with(File.join(@base_dir, 'all_up.sql'), 'w').and_yield(mock_file)
+      mock_file.should_receive(:<<).with(@writer.all_up_steps_output)
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should create a file 'sql/all_down.sql' in the target directory" do
+      File.should_receive(:open).with(File.join(@base_dir, 'all_down.sql'), 'w')
+      stub_out_file_creation
+      @writer.write!
+    end
+
+    it "should combine the contents of all down steps in REVERSE order" do
+      @writer.all_down_steps_output.should == @mig.down_steps.reverse.map(&:output).join
+    end
+
+    it "should write the contents of all down steps to the all_down.sql file" do
+      mock_file = mock('File')
+      File.should_receive(:open).with(File.join(@base_dir, 'all_down.sql'), 'w').and_yield(mock_file)
+      mock_file.should_receive(:<<).with(@writer.all_down_steps_output)
+      stub_out_file_creation
+      @writer.write!
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# This file is part of SQrbL, which is free software licensed under v3 of the GNU GPL.
+# For more information, please see README.txt and LICENSE.txt in the project's root directory.
+
+
+require 'rubygems'
+require 'spec'
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib sqrbl]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses its own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+
+# Stub out the various things that the migration writers do.
+# Call this after defining the mocks you care about (because mocks created first take precedence).
+# Then, calling #write! shouldn't actually touch the filesystem.
+def stub_out_file_creation
+  File     .should_receive(:directory?).with(any_args).any_number_of_times.and_return(true)
+  FileUtils.should_receive(:makedirs)  .with(any_args).any_number_of_times
+  File     .should_receive(:open)      .with(any_args).any_number_of_times.and_return(mock('File'))
+end
+
+# EOF