blackbird 1.0.0.pre

data/lib/blackbird/patch.rb

@@ -0,0 +1,64 @@
+class Blackbird::Patch
+
+  def initialize(fragment, name, options={}, &block)
+    @fragment     = fragment
+    @name         = name.to_s
+    @options      = options.dup
+    @block        = block
+  end
+
+  attr_reader :fragment, :name, :options, :block, :instructions
+
+  def call(changes)
+    @instructions = []
+    @block.call(SchemaPatcher.new(self, changes))
+  end
+
+  def <<(instruction)
+    @instructions << instruction
+  end
+
+  class SchemaPatcher
+
+    def initialize(patch, changes)
+      @patch, @changes = patch, changes
+      @instructions = []
+    end
+
+    %w( add? exists? remove? change? ).each do |m|
+      define_method(m) { |*args| @changes.__send__(m, *args) }
+    end
+
+    def table(name)
+      (@tables ||= {})[name.to_s] = TablePatcher.new(@patch, @changes.table(name))
+    end
+
+    def apply(name)
+      @patch << [:apply, @patch.fragment.method(name)]
+    end
+
+  end
+
+  class TablePatcher
+
+    def initialize(patch, changes)
+      @patch, @changes = patch, changes
+    end
+
+    %w( add? add_index? remove? remove_index? change? change_index? exists? index_exists? ).each do |m|
+      define_method(m) { |*args| @changes.__send__(m, *args) }
+    end
+
+    def apply(name)
+      @patch << [:apply, @patch.fragment.method(name)]
+    end
+
+    def rename(old_name, new_name)
+      @changes.old_columns.delete(old_name.to_s)
+      @changes.new_columns.delete(new_name.to_s)
+      @patch << [:rename_column, @changes.current.name, old_name.to_sym, new_name.to_sym]
+    end
+
+  end
+
+end

data/lib/blackbird/processor_list.rb

@@ -0,0 +1,41 @@
+class Blackbird::ProcessorList < Array
+
+  def use(processor, *args, &block)
+    push([processor.to_s, args, block])
+    self
+  end
+
+  def insert_before(other, processor, *args, &block)
+    idx = index { |p| p.first == other.to_s }
+    if idx
+      insert(idx, [processor.to_s, args, block])
+    else
+      unshift([processor.to_s, args, block])
+    end
+    self
+  end
+
+  def insert_after(other, processor, *args, &block)
+    idx = index { |p| p.first == other.to_s }
+    if idx
+      insert(idx + 1, [processor.to_s, args, block])
+    else
+      push([processor.to_s, args, block])
+    end
+    self
+  end
+
+  def delete(name)
+    idx = index { |p| p.first == other.to_s }
+    if idx
+      delete_at(idx)
+    end
+  end
+
+  def build
+    collect do |(klassname, args, block)|
+      klassname.constantize.new(*args, &block)
+    end
+  end
+  
+end

data/lib/blackbird/processors/indexed_columns.rb

@@ -0,0 +1,22 @@
+class Blackbird::Processors::IndexedColumns
+
+  def visit_table(table)
+    @current_table = table
+  end
+
+  def visit_column(column)
+    options = column.options
+
+    if options.delete(:unique)
+      index_columns = [options.delete(:scope)].flatten.compact
+      index_columns << column.name
+      @current_table.add_index(index_columns, :unique => true)
+    end
+
+    if options.delete(:index)
+      @current_table.add_index(column.name)
+    end
+
+  end
+
+end

data/lib/blackbird/processors/normal_default.rb

@@ -0,0 +1,7 @@
+class Blackbird::Processors::NormalDefault
+
+  def visit_column(column)
+    column.options.delete(:default) if column.options[:default].nil?
+  end
+
+end

data/lib/blackbird/railtie.rb

@@ -0,0 +1,55 @@
+class Blackbird::Railtie < Rails::Railtie
+
+  config.blackbird = ActiveSupport::OrderedOptions.new
+  config.blackbird.verbose  = true
+  config.blackbird.auto_run = false
+  config.blackbird.fragments  = nil
+
+  config.generators.orm :active_record, :migration => false, :timestamps => true
+
+  rake_tasks do
+    load "blackbird/railtie/tasks.rake"
+  end
+
+  initializer "blackbird.setup_configuration" do |app|
+    Blackbird.options[:verbose] = app.config.blackbird.verbose
+  end
+
+  initializer "blackbird.find_fragments" do |app|
+    unless config.blackbird.fragments
+      config.blackbird.fragments = []
+      railties = [app.railties.all, app].flatten
+      railties.each do |railtie|
+        next unless railtie.respond_to? :paths
+        config.blackbird.fragments.concat(
+          railtie.paths.app.fragments.to_a)
+      end
+    end
+  end
+
+  initializer "blackbird.run_blackbird" do |app|
+    if app.config.blackbird.auto_run
+      Blackbird::Transition.run!(
+        config.blackbird.fragments)
+    end
+  end
+
+  generators do
+    require "rails/generators/active_record/transition/transition_generator"
+  end
+
+end
+
+class Rails::Engine::Configuration
+
+  alias_method :paths_without_blackbird, :paths
+
+  def paths
+    @paths ||= begin
+      paths_without_blackbird
+      @paths.app.fragments "app/schema", :glob => "**/*_fragment.rb"
+      @paths
+    end
+  end
+
+end

data/lib/blackbird/railtie/tasks.rake

@@ -0,0 +1,8 @@
+namespace :db do
+
+  desc "Transition to the current schema"
+  task :transition => :environment do
+    Blackbird::Transition.run!(Rails.application.config.blackbird.fragments)
+  end
+
+end

data/lib/blackbird/schema.rb

@@ -0,0 +1,25 @@
+class Blackbird::Schema
+
+  require 'blackbird/schema/loader'
+  require 'blackbird/schema/builder'
+  require 'blackbird/schema/changes'
+
+  attr_reader :tables, :patches
+  attr_writer :patches
+
+  def initialize
+    @tables  = {}
+    @patches = ActiveSupport::OrderedHash.new
+  end
+
+  def process(visitor)
+    if visitor.respond_to?(:visit_schema)
+      visitor.visit_schema(self)
+    end
+
+    @tables.values.dup.each do |table|
+      table.process(visitor)
+    end
+  end
+
+end

data/lib/blackbird/schema/builder.rb

@@ -0,0 +1,31 @@
+class Blackbird::Schema::Builder
+
+  def initialize(schema)
+    @schema = schema
+  end
+
+  def table(fragment, name, options={}, &block)
+    name  = name.to_s
+    table = @schema.tables[name] || begin
+                                      @schema.tables[name] = Blackbird::Table.new(name, options)
+                                    end
+
+    if block
+      builder = Blackbird::Table::Builder.new(@schema, fragment, table)
+      if block.arity != 1
+        builder.instance_eval(&block)
+      else
+        block.call(builder)
+      end
+    end
+    
+    self
+  end
+
+  def patch(fragment, name, options={}, &block)
+    patch = Blackbird::Patch.new(fragment, name, options, &block)
+    @schema.patches[patch.name] = patch
+    self
+  end
+
+end

data/lib/blackbird/schema/changes.rb

@@ -0,0 +1,77 @@
+class Blackbird::Schema::Changes
+
+  def self.analyze!(current, future)
+    new(current, future).analyze!
+  end
+
+  attr_reader :new_tables, :old_tables, :changed_tables, :unchanged_tables
+  attr_reader :new_patches, :old_patches
+
+  def initialize(current, future)
+    @current, @future = current, future
+  end
+
+  def analyze!
+    @table_changes = (@current.tables.keys | @future.tables.keys).uniq
+    @table_changes = @table_changes.inject({}) do |memo, table_name|
+      memo[table_name] ||= Blackbird::Table::Changes.analyze!(
+        @current.tables[table_name], @future.tables[table_name])
+      memo
+    end
+
+    @new_tables      = (@future.tables.keys - @current.tables.keys).sort
+    @old_tables      = (@current.tables.keys - @future.tables.keys).sort
+    @changed_tables  = @table_changes.inject([]) do |memo, (table_name, table)|
+      if @new_tables.include?(table_name)
+        memo
+      elsif @old_tables.include?(table_name)
+        memo
+      elsif table.has_changes?
+        memo << table_name
+        memo
+      else
+        memo
+      end
+    end.sort
+    @unchanged_tables = (@table_changes.keys -
+      (@changed_tables + @new_tables + @old_tables)).sort
+
+    @new_patches = @future.patches.keys - @current.patches
+    @old_patches = @current.patches - @future.patches.keys
+
+    self
+  end
+
+  def table(name)
+    @table_changes[name.to_s]
+  end
+
+  def add?(name)
+    @new_tables.include?(name.to_s)
+  end
+
+  def remove?(name)
+    @old_tables.include?(name.to_s)
+  end
+
+  def change?(name)
+    @changed_tables.include?(name.to_s)
+  end
+
+  def unchange?(name)
+    @unchanged_tables.include?(name.to_s)
+  end
+
+  def exists?(name)
+    @table_changes.key?(name.to_s)
+  end
+
+  def should_apply?(patch)
+    @new_patches.include?(patch)
+  end
+
+  def should_forget?(patch)
+    @old_patches.include?(patch)
+  end
+
+end

data/lib/blackbird/schema/loader.rb

@@ -0,0 +1,79 @@
+class Blackbird::Schema::Loader
+
+  def self.load
+    new.load
+  end
+
+  def load
+    schema = Blackbird::Schema.new
+    builder = Blackbird::Schema::Builder.new(schema)
+
+    schema.patches = []
+
+    connection.tables.each do |table|
+
+      if table == 'blackbird_patches'
+        schema.patches = connection.select_values(
+          %{ SELECT name FROM blackbird_patches })
+      end
+
+      pk_name = connection.primary_key(table)
+      has_pk  = !!pk_name
+
+      builder.table(nil, table, :id => has_pk, :primary_key => pk_name) do |t|
+
+        connection.columns(table).each do |column|
+          next if column.name == pk_name
+
+          options = {}
+
+          if !column.null.nil?
+            options[:null] = column.null
+          else
+            options[:null] = true
+          end
+
+          if column.limit and column.limit != 255
+            options[:limit] = column.limit
+          end
+
+          if column.has_default?
+            options[:default] = column.default
+          end
+
+          if column.type == :decimal
+            options[:scale]     = column.scale
+            options[:precision] = column.precision
+          end
+
+          t.column(column.name, column.type, options)
+
+        end
+
+        connection.indexes(table).each do |index|
+
+          options = {
+            :name => index.name
+          }
+
+          if index.unique
+            options[:unique] = index.unique
+          end
+
+          t.index(index.columns, options)
+
+        end
+
+      end
+    end
+
+    schema
+  end
+
+private
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+end

data/lib/blackbird/table.rb

@@ -0,0 +1,71 @@
+class Blackbird::Table
+
+  require 'blackbird/table/builder'
+  require 'blackbird/table/changes'
+
+  attr_reader :name, :options, :columns, :indexes
+
+  def initialize(name, options={})
+    @name    = name.to_s
+    @options = { :id => true, :primary_key => 'id' }.merge(options)
+    @columns = ActiveSupport::OrderedHash.new
+    @indexes = ActiveSupport::OrderedHash.new
+
+    if @options.delete(:id) and pk_name = @options.delete(:primary_key)
+      add_column(pk_name, :integer, :primary => true)
+    end
+  end
+
+  def process(visitor)
+    if visitor.respond_to?(:visit_table)
+      visitor.visit_table(self)
+    end
+
+    @columns.values.dup.each do |column|
+      column.process(visitor)
+    end
+
+    @indexes.values.dup.each do |index|
+      index.process(visitor)
+    end
+  end
+
+  def hash
+    [@name, @options, @columns, @indexes].hash
+  end
+
+  def primary_key
+    @columns.values.each do |column|
+      return column.name if column.primary?
+    end
+    nil
+  end
+
+  def add_column(name, type, options={})
+    column = Blackbird::Column.new(name, type, options)
+    @columns[column.name] = column
+  end
+
+  def remove_column(name)
+    column = @columns.delete(name.to_s)
+    @indexes.values.each do |index|
+      index.columns.delete(name.to_s)
+      remove_index(index.options[:name]) if index.columns.empty?
+    end
+    column
+  end
+
+  def change_column(name, type, options={})
+    @columns[name.to_s].change(type, options)
+  end
+
+  def add_index(columns, options={})
+    index = Blackbird::Index.new(@name, columns, options)
+    @indexes[index.name] = index
+  end
+
+  def remove_index(name)
+    @indexes.delete(name.to_s)
+  end
+
+end