blackbird 1.0.0.pre

data/.gitignore

@@ -0,0 +1,8 @@
+pkg/*
+*.gem
+.bundle
+doc/
+tmp/
+coverage
+.yardoc
+.DS_Store

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 0.1.0 (Not released yet)
+
+Features:
+
+  - [none]
+
+Bugfixes:
+
+  - [none]

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gemspec
+
+group :development do
+  gem "shoulda", ">= 2.10.3"
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Simon Menke
+
+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.md

@@ -0,0 +1,77 @@
+# Blackbird
+
+Blackbird aims to remove traditional ActiveRecord migrations and replace it with DataMapper-like automatic migrations mixed with event based data patching.
+
+The major advantage of Blackbird over migrations is that it allows Rails engines to define there own schemas which get automatically loaded in the application. The application remains in full control as it can overwrite an engines schema.
+
+## Installation
+
+### Using Ruby gems
+
+Add the gem to your `Gemfile`
+
+    gem "rails", "3.0.0.beta3"
+    gem "blackbird"
+
+### Using git
+
+Add the repo to your `Gemfile`
+
+    gem "blackbird", :git => "git://github.com/fd/blackbird.git"
+
+## Quick Start Guide
+
+Generate a `Post` model without the migration file.
+
+    $ rails g model Post --migration=false
+
+Create a schema file at `app/schemas/posts_schema.rb` with the following contents:
+
+    class PostsSchema < Blackbird::Schema
+
+      table :posts do |t|
+        t.string   :title
+        t.text     :body
+
+        t.datetime :published_at
+        t.timestamps
+      end
+
+    end
+
+Then transition the database to the new schema:
+
+    $ rake db:transition
+    --- Creating table posts
+     +c title:string
+     +c body:text
+     +c published_at:datetime
+     +c created_at:datetime
+     +c updated_at:datetime
+
+Now, let's make some trivial changes:
+
+- add an index to the published_at column
+- add an extra column for the tags
+
+and here is the diff:
+
+    --- a/app/schemas/posts_schema.rb
+    +++ b/app/schemas/posts_schema.rb
+    @@ -4,7 +4,9 @@ class PostsSchema < Blackbird::Schema
+         t.string   :title
+         t.text     :body
+
+    -    t.datetime :published_at
+    +    t.string :tags
+    +
+    +    t.datetime :published_at, :index => true
+         t.timestamps
+       end
+
+Transition the database to the updated schema:
+
+    $ rake db:transition
+    --- Constructive changes for posts
+     +c tags:string
+     +i published_at

data/ROADMAP.md

@@ -0,0 +1,5 @@
+## 0.1.0
+
+  - non destructive blackbird
+  - automatic blackbird (at application boot)
+  - rails railtie

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['-O', 'spec/spec.opts']
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+end
+
+task :default  => :spec

data/blackbird.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/blackbird/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "blackbird"
+  s.version     = Blackbird::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Simon Menke"]
+  s.email       = ["simon.menke@gmail.com"]
+  s.homepage    = "http://github.com/fd/blackbird"
+  s.summary     = "Migrations should be more adaptable"
+  s.description = "Blackbird are Migrations but then better."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "blackbird"
+
+  s.add_runtime_dependency "activerecord", ">= 2.3.4"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/blackbird.rb

@@ -0,0 +1,39 @@
+module Blackbird
+
+  require 'active_record'
+
+  require 'blackbird/version'
+
+  require 'blackbird/transition'
+  require 'blackbird/migration'
+  require 'blackbird/processor_list'
+
+  require 'blackbird/fragment'
+  require 'blackbird/schema'
+  require 'blackbird/table'
+  require 'blackbird/column'
+  require 'blackbird/index'
+  require 'blackbird/patch'
+
+  module Processors
+    require 'blackbird/processors/indexed_columns'
+    require 'blackbird/processors/normal_default'
+  end
+
+  module Helpers
+    require 'blackbird/helpers/typed_columns'
+    require 'blackbird/helpers/join_tables'
+  end
+
+  if defined? ::Rails::Railtie
+    require 'blackbird/railtie'
+  end
+
+  def self.options
+    @options ||= {
+      :verbose => true,
+      :processors => Blackbird::ProcessorList.new
+    }
+  end
+  
+end

data/lib/blackbird/column.rb

@@ -0,0 +1,32 @@
+class Blackbird::Column
+
+  attr_reader :name, :type, :options
+
+  def initialize(name, type, options={})
+    options.delete(:default) if options[:default] == nil
+    @name, @type, @options = name.to_s, type, options
+  end
+
+  def process(visitor)
+    if visitor.respond_to?(:visit_column)
+      visitor.visit_column(self)
+    end
+  end
+
+  def primary?
+    !!@options[:primary]
+  end
+
+  def hash
+    [@name, @type, @options].hash
+  end
+
+  def change(type, options={})
+    @type, @options = type, options
+  end
+
+  def ==(other)
+    self.hash == other.hash
+  end
+
+end

data/lib/blackbird/fragment.rb

@@ -0,0 +1,58 @@
+class Blackbird::Fragment
+
+  def self.subclasses
+    @subclasses ||= []
+  end
+
+  def self.inherited(subclass)
+    Blackbird::Fragment.subclasses.push(subclass)
+    subclass.extend InheritanceBlocker
+  end
+
+  def self.instructions
+    @instructions ||= []
+  end
+
+  def self.table(name, options={}, &block)
+    self.instructions << [:table, name, options, block]
+  end
+
+  def self.patch(name, options={}, &block)
+    self.instructions << [:patch, name, options, block]
+  end
+
+  def initialize
+    @instructions = self.class.instructions.dup
+  end
+
+  def apply(builder)
+    @instructions.each do |instruction|
+      instruction = instruction.dup
+      instruction[1,0] = self
+      block = (Proc === instruction.last ? instruction.pop : nil)
+      builder.__send__(*instruction, &block)
+    end
+  end
+
+private
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  %w( select_values select_value select_rows select_all execute ).each do |m|
+    define_method(m) do |sql_pattern, *args|
+      sql = sql = sql_pattern.gsub('?') do
+        connection.quote(arguments.shift)
+      end
+      connection.__send__(m, sql)
+    end
+  end
+
+  module InheritanceBlocker
+    def inherited(base)
+      raise "#{base} cannot inherit from non abstract fragment #{self}"
+    end
+  end
+
+end

data/lib/blackbird/helpers/join_tables.rb

@@ -0,0 +1,50 @@
+module Blackbird::Helpers::JoinTables
+
+  def join(*args, &block)
+
+    tables  = []
+    columns = []
+
+    while arg = args.shift
+      case arg
+      when String, Symbol
+        tables  << arg.to_s
+        columns << "#{arg.to_s.singularize}_id"
+        
+      when Array
+        tables  << arg[0].to_s
+        columns << arg[1].to_s
+        
+      when Hash
+        args = arg.to_ary + args
+
+      else
+        raise ArgumentError
+        
+      end  
+    end
+
+    name = tables.dup.sort.join('_')
+    
+    table name, :id => false do |t|
+
+      columns.each do |column|
+        t.integer column
+      end
+
+      if block
+        if block.arity == 1
+          block.call(t)
+        else
+          t.instance_eval(&block)
+        end
+      end
+      
+    end
+
+    self
+  end
+
+  Blackbird::Schema::Builder.send(:include, self)
+  
+end

data/lib/blackbird/helpers/typed_columns.rb

@@ -0,0 +1,50 @@
+module Blackbird::Helpers::TypedColumns
+
+  def integer(name, options={})
+    column(name, :integer, options)
+  end
+
+  def float(name, options={})
+    column(name, :float, options)
+  end
+
+  def decimal(name, options={})
+    column(name, :decimal, options)
+  end
+
+  def string(name, options={})
+    column(name, :string, options)
+  end
+
+  def text(name, options={})
+    column(name, :text, options)
+  end
+
+  def boolean(name, options={})
+    column(name, :boolean, options)
+  end
+
+  def binary(name, options={})
+    column(name, :binary, options)
+  end
+
+  def datetime(name, options={})
+    column(name, :datetime, options)
+  end
+
+  def date(name, options={})
+    column(name, :date, options)
+  end
+
+  def timestamp(name, options={})
+    column(name, :timestamp, options)
+  end
+
+  def timestamps
+    datetime :created_at
+    datetime :updated_at
+  end
+  
+  Blackbird::Table::Builder.send(:include, self)
+  
+end

data/lib/blackbird/index.rb

@@ -0,0 +1,29 @@
+class Blackbird::Index
+
+  attr_reader :name, :columns, :options
+
+  def initialize(table_name, columns, options={})
+    @table_name = table_name
+    @columns, @options = [columns].flatten.compact, options
+    @columns.collect! { |n| n.to_s }
+  end
+
+  def process(visitor)
+    if visitor.respond_to?(:visit_index)
+      visitor.visit_index(self)
+    end
+  end
+
+  def name
+    @options[:name] ||= "index_#{@table_name}_on_#{Array(@columns) * '_and_'}"
+  end
+
+  def hash
+    [@columns, @options].hash
+  end
+
+  def ==(other)
+    self.hash == other.hash
+  end
+
+end

data/lib/blackbird/migration.rb

@@ -0,0 +1,218 @@
+# Blackbird::Migration is responsible for creating database instructions
+class Blackbird::Migration
+
+  attr_reader :instructions
+
+  def self.build(current, future, changes)
+    new(current, future, changes).build
+  end
+
+  def initialize(current, future, changes)
+    @current, @future, @changes = current, future, changes
+    @instructions = []
+  end
+
+  def build
+    evaluate_patches
+
+    remove_old_indexes
+
+    create_new_tables
+    change_existing_tables
+    remove_old_tables
+
+    create_new_indexes
+
+    self
+  end
+
+private
+
+  def create_new_tables
+    @changes.new_tables.each do |table_name|
+      table = @future.tables[table_name]
+
+      pk_name = table.primary_key
+      has_pk  = !!pk_name
+
+      log "--- Creating table #{table_name}"
+      run :create_table, table_name, table.options.merge(:id => has_pk, :primary_key => pk_name)
+
+      table.columns.each do |name, column|
+        next if name == pk_name
+
+        log " +c #{name}:#{column.type}"
+        run :add_column, table_name, name, column.type, column.options
+      end
+    end
+  end
+
+  def evaluate_patches
+    @evaluated_patches = []
+    @changes.new_patches.each do |patch_name|
+
+      patch = @future.patches[patch_name]
+      patch.call(@changes)
+      @evaluated_patches << patch
+
+    end
+  end
+
+  def apply_patches
+    @evaluated_patches.each do |patch|
+
+      log "--- Applying patch #{patch.name}"
+      @instructions.concat(patch.instructions)
+
+    end
+  end
+
+  def change_existing_tables
+    # new columns
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      future_table  = @future.tables[table_name]
+
+      unless changes.new_columns.empty?
+        log "--- Constructive changes for #{table_name}"
+      end
+
+      changes.new_columns.each do |name|
+        column = future_table.columns[name]
+
+        log " +c #{name}:#{column.type}"
+        run :add_column, table_name, name, column.type, column.options
+      end
+    end
+
+    apply_patches
+
+    # column changes
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      current_table = @current.tables[table_name]
+      future_table  = @future.tables[table_name]
+
+      unless changes.changed_columns.empty?
+        log "--- Mutative changes for #{table_name}"
+      end
+
+      changes.changed_columns.each do |name|
+        column = future_table.columns[name]
+
+        log " ~c #{name}:#{column.type} #{current_table.columns[name].options.inspect} => #{column.options.inspect}"
+        run :change_column, table_name, name, column.type, column.options
+      end
+    end
+
+    # old columns
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      current_table = @current.tables[table_name]
+
+      unless changes.old_columns.empty?
+        log "--- Destructive changes for #{table_name}"
+      end
+
+      changes.old_columns.each do |name|
+        column = current_table.columns[name]
+
+        log " -c #{name}:#{column.type}"
+        run :remove_column, table_name, name
+      end
+    end
+  end
+
+  def remove_old_tables
+    @changes.old_tables.each do |table_name|
+      log "-- Dropping table #{table_name}"
+      run :drop_table, table_name
+    end
+  end
+
+  def remove_old_indexes
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      current_table = @current.tables[table_name]
+
+      changes.old_indexes.each do |name|
+        index = current_table.indexes[name]
+
+        log(index.options[:unique]       ?
+            " -u #{index.columns * ' '}" :
+            " -i #{index.columns * ' '}" )
+        run :remove_index, table_name, {:name => name}
+      end
+    end
+
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      future_table  = @future.tables[table_name]
+
+      changes.changed_indexes.each do |name|
+        index = future_table.indexes[name]
+
+        log(index.options[:unique]       ?
+            " ~u #{index.columns * ' '}" :
+            " ~i #{index.columns * ' '}" )
+
+        run :remove_index, table_name, {:name => name}
+      end
+    end
+  end
+
+  def create_new_indexes
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      future_table  = @future.tables[table_name]
+
+      changes.changed_indexes.each do |name|
+        index = future_table.indexes[name]
+
+        log(index.options[:unique]       ?
+            " ~u #{index.columns * ' '}" :
+            " ~i #{index.columns * ' '}" )
+
+        run :add_index, table_name, index.columns, index.options
+      end
+    end
+
+    @changes.changed_tables.each do |table_name|
+      changes       = @changes.table(table_name)
+      future_table  = @future.tables[table_name]
+
+      changes.new_indexes.each do |name|
+        index = future_table.indexes[name]
+
+        log(index.options[:unique]       ?
+            " +u #{index.columns * ' '}" :
+            " +i #{index.columns * ' '}" )
+
+        run :add_index, table_name, index.columns, index.options
+      end
+    end
+
+    @changes.new_tables.each do |table_name|
+      table = @future.tables[table_name]
+
+      table.indexes.each do |name, index|
+        log(index.options[:unique]       ?
+            " +u #{index.columns * ' '}" :
+            " +i #{index.columns * ' '}" )
+
+        run :add_index, table_name, index.columns, index.options
+      end
+    end
+  end
+
+  def run(*instruction)
+    @instructions << instruction
+  end
+
+  def log(message)
+    if Blackbird.options[:verbose]
+      run :log, message
+    end
+  end
+
+end