migrake 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+/MIGRAKE_STATUS
+/Gemfile.lock
+/pkg

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - rbx-19mode
+  - jruby-19mode
+env:
+  - RUBYOPT="$RUBYOPT -Itest -Ilib"
+notifications:
+  email:
+    - contacto@nicolassanguinetti.info

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,115 @@
+# Migrake
+
+[![Build Status](https://secure.travis-ci.org/foca/migrake.png?branch=master)](http://travis-ci.org/foca/migrake)
+
+A simple [Rake][rake] extension that lets you define tasks that are divided into
+multiple smaller "versions". When you run the task in a given host, it will only
+run the "versions" that haven't yet been run in that host. Think something
+similar to [ActiveRecord::Migration][migrations] for Rake tasks.
+
+This is specially useful to define tasks that should be run on deploy, in order
+to do some sort of house cleaning that should be run once. For example, some
+complex data migrations, or re-processing your user avatars because now the UI
+shows them in a different size.
+
+The important thing is these tasks should only be run once when you deploy to a
+given environment, and they should be run immediately.
+
+[rake]:       http://rake.rubyforge.org
+[migrations]: http://api.rubyonrails.org/classes/ActiveRecord/Migration.html
+
+## An example
+
+In `lib/tasks/migrake.rake`:
+
+``` ruby
+require "migrake"
+
+migrake Set.new([
+  "data:set_default_user_state",
+  "twitter:purge_cache",
+  # etc, etc
+])
+```
+
+This would define a task called `:migrake` that, when called, will invoke the
+tasks in that set _unless they have been invoked before_. This means that after
+each deploy you can run this task (with a capistrano hook, for example) and any
+tasks that need to be run in this environment will be run.
+
+## How it works
+
+This will keep a file named `MIGRAKE_STATUS`, that will contain the name of the
+tasks that were ran in the past. Whenever you run `rake migrake` migrake will
+check that file, see which tasks in the set aren't in it, and will run those
+tasks (no order is guaranteed, if you need tasks to run in order, define the
+dependencies in the task themselves.)
+
+## Overriding where to keep the MIGRAKE_STATUS file
+
+The file will be located, by default, at whichever directory `rake` is invoked
+from. In order to change that (for example, to put it in capistrano's `shared`
+directory), do either of the following:
+
+Define `Migrake.status_file_directory` before running the tasks (so, for
+example, at the top of your `migrake.rake`):
+
+``` ruby
+Migrake.status_file_directory = File.expand_path("../tmp", __FILE__)
+```
+
+Or as an alternative, pass it as an environment variable to Rake:
+
+``` shell
+MIGRAKE_STATUS_DIR=./some/path bundle exec rake migrake
+```
+
+The latter lets you define it within the capistrano definition file, like this:
+
+``` ruby
+namespace :deploy do
+  task :migrake do
+    run "MIGRAKE_STATUS_DIR=#{shared_path} bundle exec rake migrake"
+  end
+end
+
+after "deploy:migrations", "deploy:migrake"
+```
+
+## Bootstrapping a new environment
+
+When you bootstrap a new environment you don't need to run migrake tasks that
+have been already run. For this, when the `migrake` method is invoked we also
+define a `migrake:ready` task, that forces all tasks defined in the migrake set
+into the `MIGRAKE_STATUS` file.
+
+This way you can just run that when you bootstrap the environment and then keep
+running `rake migrake` when you deploy.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 [Nicolas Sanguinetti][me], with the support of [Cubox][cubox]
+
+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.
+
+[me]:    http://nicolassanguinetti.info
+[cubox]: http://cuboxlabs.com

data/Rakefile

@@ -0,0 +1,15 @@
+require "rake/testtask"
+require "rubygems/package_task"
+
+gem_spec = eval(File.read("./migrake.gemspec"))
+Gem::PackageTask.new(gem_spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+  t.verbose = true
+end
+
+task default: :test

data/examples/Rakefile

@@ -0,0 +1,10 @@
+require "migrake"
+
+migrake Set.new(%w(a b c d))
+
+%w(a b c d).each do |t|
+  desc "Print #{t}"
+  task t do
+    puts t
+  end
+end

data/lib/migrake/dsl.rb

@@ -0,0 +1,45 @@
+require "migrake"
+
+module Migrake
+  module DSL
+    # Public: Define the rake tasks required to run migrake. This defines the
+    # following tasks:
+    #
+    #   - A task to create the `Migrake.status_file_directory` unless it exists.
+    #   - A task to create the MIGRAKE_STATUS file in the aforementioned
+    #     directory, unless it exists.
+    #   - A `migrake:ready` task to bootstrap new environments by writing all
+    #     the tasks to the store.
+    #   - The `migrake` task, that will run any tasks not run before.
+    #
+    # tasks - A Set of tasks to be run.
+    #
+    # Returns the `migrake` Rake::Task.
+    def migrake(tasks)
+      dir = Migrake.status_file_directory
+      status_file = dir.join("MIGRAKE_STATUS")
+
+      namespace :migrake do
+        directory dir.to_s
+
+        file status_file.to_s => dir.to_s do
+          touch status_file
+        end
+
+        task :run_tasks => status_file.to_s do
+          Migrake::Runner.run(tasks, Migrake::Store.new(status_file))
+        end
+
+        desc "Tell migrake that all defined tasks have already been run"
+        task :ready => status_file.to_s do
+          Migrake::Store.new(status_file).write(tasks)
+        end
+      end
+
+      desc "Run the tasks defined by migrake"
+      task migrake: "migrake:run_tasks"
+    end
+  end
+end
+
+extend Migrake::DSL

data/lib/migrake/version.rb

@@ -0,0 +1,3 @@
+module Migrake
+  VERSION = "0.1.0"
+end

data/lib/migrake.rb

@@ -0,0 +1,82 @@
+require "rake/task"
+require "migrake/dsl"
+require "migrake/version"
+require "yaml"
+require "set"
+require "pathname"
+
+module Migrake
+  # Public: Change the directory where we keep the MIGRAKE_STATUS file.
+  #
+  # dir - A filesystem path.
+  #
+  # Returns the directory path.
+  def self.status_file_directory=(dir)
+    @status_dir = Pathname(dir)
+  end
+
+  # Public: Get the directory where we keep the MIGRAKE_STATUS file. If no
+  # directory is set, we will try to fetch it from the ENV, using the
+  # MIGRAKE_STATUS_DIR environment variable. If that isn't set either, we
+  # default to the working directory.
+  #
+  # Returns a Pathname.
+  def self.status_file_directory
+    @status_dir ||= Pathname(ENV.fetch("MIGRAKE_STATUS_DIR", Dir.pwd))
+  end
+
+  # The Runner is responsible for selecting the rake tasks to be run and run
+  # them, unless they have already been run in this host.
+  module Runner
+    # Public: Run all the rake tasks in `set` that haven't been stored in
+    # `store`.
+    #
+    # set   - A Set with tasks to be run.
+    # store - A Migrake::Store with the tasks that have already been run.
+    #
+    # Returns the Set of tasks that were run.
+    def self.run(set, store)
+      (set - store.all).each do |task|
+        Rake::Task[task].invoke
+        store.put(task)
+      end
+    end
+  end
+
+  # The Store handles the file where tasks that have already been run are stored
+  # so they aren't run again.
+  class Store
+    # Public: Initialize the store.
+    #
+    # path - The path to the file where we store the information.
+    def initialize(path)
+      @path = path
+    end
+
+    # Public: Add one task to the store. This immediately writes the file to
+    # disk, to preserve consistency.
+    #
+    # task - A string with a task's name.
+    #
+    # Returns nil.
+    def put(task)
+      write(all << task)
+    end
+
+    # Public: Load all the tasks from the store.
+    #
+    # Returns a Set.
+    def all
+      @all ||= YAML.load(@path.read) || Set.new
+    end
+
+    # Public: Write a whole set of tasks to the store, replacing what is in it.
+    #
+    # set - A Set of tasks.
+    #
+    # Returns nil.
+    def write(set)
+      @path.open("w+") { |f| f.puts YAML.dump(set) }
+    end
+  end
+end

data/migrake.gemspec

@@ -0,0 +1,19 @@
+# For some reason, 'require "migrake/version"' doesn't work in jruby (1.6.6, on
+# 1.9 mode), even with RUBYOPT=-Ilib, so resorting to this hackery.
+require File.expand_path("../lib/migrake/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "migrake"
+  s.version     = Migrake::VERSION
+  s.description = "Migrake allows you to run rake tasks that only need to be run once in a given environment each time you deploy"
+  s.summary     = "Migrake is like ActiveRecord::Migration for Rake"
+  s.authors     = ["Nicolas Sanguinetti"]
+  s.email       = "hi@nicolassanguinetti.info"
+  s.homepage    = "http://github.com/foca/migrake"
+  s.has_rdoc    = false
+  s.files       = `git ls-files`.split "\n"
+  s.platform    = Gem::Platform::RUBY
+
+  s.add_dependency("rake", ">= 0.9.2")
+  s.add_development_dependency("minitest")
+end

data/test/runner_test.rb

@@ -0,0 +1,54 @@
+require_relative "test_helper"
+require "rake"
+
+describe Migrake::Runner do
+  it "runs tasks that aren't in the store" do
+    define_tasks "a", "b", "c"
+    define_store "a"
+
+    expect_tasks_ran "b", "c"
+
+    Migrake::Runner.run(Set.new(["a", "b", "c"]), store)
+
+    store.verify
+  end
+
+  it "runs no tasks if all the tasks are in the store" do
+    define_tasks "a", "b", "c"
+    define_store "a", "b", "c"
+    # setting no expectation for tasks run passes only if no tasks are run
+
+    Migrake::Runner.run(Set.new(["a", "b", "c"]), store)
+
+    store.verify
+  end
+
+  it "doesn't mind stored tasks that don't exist anymore" do
+    define_tasks "a"
+    define_store "b", "c"
+
+    expect_tasks_ran "a"
+
+    Migrake::Runner.run(Set.new(["a", "b", "c"]), store)
+
+    store.verify
+  end
+
+  def store
+    @store ||= MiniTest::Mock.new
+  end
+
+  def define_store(*tasks)
+    store.expect :all, Set.new(tasks)
+  end
+
+  def define_tasks(*tasks)
+    tasks.each { |task| Rake::Task.define_task(task) }
+  end
+
+  def expect_tasks_ran(*tasks)
+    Set.new(tasks).each do |task|
+      store.expect :put, nil, [task]
+    end
+  end
+end

data/test/store_test.rb

@@ -0,0 +1,45 @@
+require_relative "test_helper"
+require "tempfile"
+
+describe Migrake::Store do
+  it "can read a stored set" do
+    set = Set.new(["a", "b", "c"])
+    save_in_source set
+
+    store = Migrake::Store.new(source)
+    assert_equal set, store.all
+  end
+
+  it "an empty file means an empty set" do
+    store = Migrake::Store.new(source)
+    assert_equal Set.new, store.all
+  end
+
+  it "can add an entry to the store" do
+    store = Migrake::Store.new(source)
+    store.put("test")
+
+    assert_equal Set.new(["test"]), store.all
+  end
+
+  it "can write a set replacing whatever is there on the file" do
+    save_in_source Set.new(["d", "e", "f", "g"])
+
+    store = Migrake::Store.new(source)
+    store.write Set.new(["a", "b", "c"])
+
+    assert_equal Set.new(["a", "b", "c"]), store.all
+  end
+
+  after do
+    source.unlink # just to be polite
+  end
+
+  def save_in_source(set)
+    source.open("w+") { |f| f.puts YAML.dump(set) }
+  end
+
+  def source
+    @source ||= Pathname(Tempfile.new("store").path)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require "minitest/autorun"
+require "migrake"
+
+begin
+  require "purdytest"
+rescue LoadError
+  # Oh well, no colorized tests for you. You can always use minitest/pride if
+  # you want :P
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: migrake
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nicolas Sanguinetti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70142092483920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70142092483920
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70142092483500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70142092483500
+description: Migrake allows you to run rake tasks that only need to be run once in
+  a given environment each time you deploy
+email: hi@nicolassanguinetti.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- examples/Rakefile
+- lib/migrake.rb
+- lib/migrake/dsl.rb
+- lib/migrake/version.rb
+- migrake.gemspec
+- test/runner_test.rb
+- test/store_test.rb
+- test/test_helper.rb
+homepage: http://github.com/foca/migrake
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Migrake is like ActiveRecord::Migration for Rake
+test_files: []