blackbird 1.0.0.pre

data/lib/blackbird/table/builder.rb

@@ -0,0 +1,124 @@
+class Blackbird::Table::Builder
+
+  def initialize(schema, fragment,  table)
+    @schema, @fragment, @table = schema, fragment, table
+  end
+
+  ##
+  # Scope a number of column definitions. All the column and index
+  # options can be passed here. also :prefix and :suffix can be passed
+  # and they prefix or suffix the names of the indexes and columns.
+  def scope(options={}, &block)
+    _scope, @scope = @scope, (@scope || {}).merge(options)
+    if block.arity != 1
+      instance_eval(&block)
+    else
+      yield(self)
+    end
+  ensure
+    @scope = _scope
+  end
+
+  ##
+  # Remove any previously defined scopes
+  def without_scope(&block)
+    _scope, @scope = @scope, nil
+    if block.arity != 1
+      instance_eval(&block)
+    else
+      yield(self)
+    end
+  ensure
+    @scope = _scope
+  end
+
+  
+  ##
+  # Define a column
+  def column(name, type, options={})
+    options = @scope.merge(options) if @scope
+    options = { :null => true }.merge(options)
+    
+    name = "#{options[:prefix]}#{name}" if options[:prefix]
+    name = "#{name}#{options[:suffix]}" if options[:suffix]
+    
+    if @table.columns[name.to_s]
+      @table.change_column(name, type, options)
+    else
+      @table.add_column(name, type, options)
+    end
+  end
+
+  ##
+  # Remove a column
+  def remove_column(name)
+    options = @scope || {}
+    
+    name = "#{options[:prefix]}#{name}" if options[:prefix]
+    name = "#{name}#{options[:suffix]}" if options[:suffix]
+    
+    @table.remove_column(name)
+  end
+
+
+  ##
+  # Define an index
+  def index(columns, options={})
+    options = @scope.merge(options) if @scope
+
+    columns = [columns].flatten.collect do |name|
+      name = "#{options[:prefix]}#{name}" if options[:prefix]
+      name = "#{name}#{options[:suffix]}" if options[:suffix]
+      name
+    end
+    
+    @table.add_index(columns, options)
+  end
+
+  ##
+  # Remove an index
+  def remove_index(name)
+    options = @scope || {}
+    
+    name = "#{options[:prefix]}#{name}" if options[:prefix]
+    name = "#{name}#{options[:suffix]}" if options[:suffix]
+    
+    @table.remove_index(name)
+  end
+
+  ##
+  # Rename a previously defined columns. This also creates a patch to
+  # migrate any data in the old column to the new column.
+  def rename(old_name, new_name)
+    options = @scope
+    if options
+      new_name = "#{options[:prefix]}#{new_name}" if options[:prefix]
+      new_name = "#{new_name}#{options[:suffix]}" if options[:suffix]
+      
+      old_name = "#{options[:prefix]}#{old_name}" if options[:prefix]
+      old_name = "#{old_name}#{options[:suffix]}" if options[:suffix]
+    end
+    
+    column = @table.columns[old_name.to_s]
+
+    without_scope do
+      self.remove old_name
+      self.column new_name, column.type, column.options
+    end
+    
+    msg = "Renaming #{@table.name}.#{old_name} to #{@table.name}.#{new_name}"
+    patch = Blackbird::Patch.new(@fragment, msg) do |p|
+      t = p.table(@table.name)
+
+      if t.add?(new_name) and t.remove?(old_name)
+        t.rename(old_name, new_name)
+      end
+    end
+    @schema.patches[patch.name] = patch
+  end
+
+  def remove(name)
+    remove_column name
+  end
+
+end

data/lib/blackbird/table/changes.rb

@@ -0,0 +1,86 @@
+class Blackbird::Table::Changes
+
+  def self.analyze!(current, future)
+    new(current, future).analyze!
+  end
+
+  attr_reader :current, :future
+  attr_reader :new_columns, :old_columns, :all_columns, :changed_columns, :unchanged_columns, :renamed_columns
+  attr_reader :new_indexes, :old_indexes, :all_indexes, :changed_indexes, :unchanged_indexes
+
+  def initialize(current, future)
+    @current, @future = current, future
+    @renamed_columns = []
+  end
+
+  def analyze!
+    current_columns = @current ? @current.columns : {}
+    future_columns  = @future  ? @future.columns  : {}
+
+    @new_columns     = (future_columns.keys - current_columns.keys)
+    @old_columns     = (current_columns.keys - future_columns.keys)
+    @all_columns     = (current_columns.keys | future_columns.keys)
+    @changed_columns = []
+    (current_columns.keys & future_columns.keys).each do |name|
+      if current_columns[name] != future_columns[name]
+        @changed_columns << name
+      end
+    end
+    @unchanged_columns = (current_columns.keys & future_columns.keys) - @changed_columns
+
+    current_indexes = @current ? @current.indexes : {}
+    future_indexes  = @future  ? @future.indexes  : {}
+
+    @new_indexes     = (future_indexes.keys - current_indexes.keys)
+    @old_indexes     = (current_indexes.keys - future_indexes.keys)
+    @all_indexes     = (current_indexes.keys | future_indexes.keys)
+    @changed_indexes = []
+    (current_indexes.keys & future_indexes.keys).each do |name|
+      if current_indexes[name] != future_indexes[name]
+        p [name, current_indexes[name], future_indexes[name]]
+        @changed_indexes << name
+      end
+    end
+    @unchanged_indexes = (current_indexes.keys & future_indexes.keys) - @changed_indexes
+
+    self
+  end
+
+  def has_changes?
+    !((@unchanged_columns == @all_columns) and
+      (@unchanged_indexes == @all_indexes))
+  end
+
+  def add?(name)
+    @new_columns.include?(name.to_s)
+  end
+
+  def add_index?(name)
+    @new_indexes.include?(name.to_s)
+  end
+
+  def remove?(name)
+    @old_columns.include?(name.to_s)
+  end
+
+  def remove_index?(name)
+    @old_indexes.include?(name.to_s)
+  end
+
+  def change?(name)
+    @changed_columns.include?(name.to_s)
+  end
+
+  def change_index?(name)
+    @changed_indexes.include?(name.to_s)
+  end
+
+  def exists?(name)
+    @all_columns.include?(name.to_s)
+  end
+
+  def index_exists?(name)
+    @all_indexes.include?(name.to_s)
+  end
+
+end

data/lib/blackbird/transition.rb

@@ -0,0 +1,85 @@
+# Blackbird::Transition is the coordinator of the transition process
+class Blackbird::Transition
+
+  def self.run!(*fragment_files)
+    build(fragment_files).run!
+  end
+
+  def self.build(*fragment_files)
+    new(fragment_files).build
+  end
+
+  attr_reader :fragment_files, :current, :future, :changes, :migration, :fragments
+
+  def initialize(*fragment_files)
+    @fragment_files = fragment_files.flatten.uniq.compact
+  end
+
+  def build
+    load_fragments
+    load_current
+    build_future
+    analyze_changes
+    build_migration
+
+    self
+  end
+
+  def run!
+    connection = ActiveRecord::Base.connection
+    connection.transaction do
+
+      @migration.instructions.each do |instruction|
+        case instruction.first
+        when :apply
+          instruction.last.call
+        when :log
+          puts instruction.last if Blackbird.options[:verbose]
+        when :create_table
+          connection.__send__(*instruction) {}
+        else
+          connection.__send__(*instruction)
+        end
+      end
+
+    end
+
+    self
+  end
+
+private
+
+  def load_fragments
+    @fragment_files.each do |path|
+      require path
+    end
+  end
+
+  def load_current
+    @current = Blackbird::Schema::Loader.load
+  end
+
+  def build_future
+    @future = Blackbird::Schema.new
+    @fragments = ActiveSupport::OrderedHash.new
+    builder = Blackbird::Schema::Builder.new(@future)
+    Blackbird::Fragment.subclasses.each do |fragment|
+      fragment = fragment.new
+      @fragments[fragment.class] = fragment
+      fragment.apply(builder)
+    end
+
+    Blackbird.options[:processors].build.each do |processor|
+      @future.process processor
+    end
+  end
+
+  def analyze_changes
+    @changes = Blackbird::Schema::Changes.analyze!(@current, @future)
+  end
+
+  def build_migration
+    @migration = Blackbird::Migration.build(@current, @future, @changes)
+  end
+
+end

data/lib/blackbird/version.rb

@@ -0,0 +1,3 @@
+module Blackbird
+  VERSION = '1.0.0.pre'
+end

data/lib/rails/generators/active_record/transition/templates/fragment.rb

@@ -0,0 +1,12 @@
+class <%= class_name.pluralize %>Fragment < Blackbird::Fragment
+
+  table(:<%= class_name.gsub('::', '').underscore.pluralize %>) do |t|
+<% for attribute in attributes -%>
+    t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+<% if options[:timestamps] %>
+    t.timestamps
+<% end -%>
+  end
+
+end

data/lib/rails/generators/active_record/transition/transition_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/rails/model/model_generator'
+
+Rails::Generators::ModelGenerator.hook_for :transition,
+  :in => :active_record,
+  :default => true, :type => :boolean
+
+module ActiveRecord
+  module Generators
+    class TransitionGenerator < Rails::Generators::NamedBase
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      def self.source_root
+        @_tr_source_root ||= begin
+          if base_name && generator_name
+            File.expand_path('../templates', __FILE__)
+          end
+        end
+      end
+
+      def create_schema_file
+        template 'fragment.rb', File.join('app/schema', class_path, "#{file_name.pluralize}_fragment.rb")
+      end
+    end
+  end
+end

data/spec/fixtures/a/comments_fragment.rb

@@ -0,0 +1,10 @@
+class CommentsFragment < Blackbird::Fragment
+
+  table :comments do |t|
+    t.integer  :post_id, :index => true
+    t.integer  :user_id, :index => true
+    t.text     :body
+    t.datetime :published_at, :index => true
+  end
+
+end

data/spec/fixtures/a/pages_fragment.rb

@@ -0,0 +1,9 @@
+class PagesFragment < Blackbird::Fragment
+
+  table :pages do |t|
+    t.string   :title, :index => true
+    t.text     :body
+    t.datetime :published_at, :index => true
+  end
+
+end

data/spec/fixtures/a/posts_fragment.rb

@@ -0,0 +1,9 @@
+class PostsFragment < Blackbird::Fragment
+
+  table :posts do |t|
+    t.string   :title, :unique => true
+    t.text     :body
+    t.datetime :published_at, :index => true
+  end
+
+end

data/spec/fixtures/a/users_fragment.rb

@@ -0,0 +1,7 @@
+class UsersFragment < Blackbird::Fragment
+
+  table :users do |t|
+    t.string :full_name
+  end
+
+end

data/spec/fixtures/b/comments_fragment.rb

@@ -0,0 +1,23 @@
+class CommentsFragment < Blackbird::Fragment
+
+  table :comments do |t|
+    t.rename   :published_at, :posted_at
+    t.string   :username
+  end
+
+  patch "Add usernames based on user_ids" do |p|
+    t = p.table(:comments)
+
+    if t.add?(:username) and t.exists?(:user_id)
+      t.apply :set_user_names
+    end
+  end
+
+  def set_user_names
+    user_names = select_rows %{ SELECT comments.id, users.full_name FROM comments LEFT JOIN users ON users.id = comments.user_id }
+    user_names.each do |(id, name)|
+      execute %{ UPDATE comments SET username = ? WHERE id = ? }, name, id
+    end
+  end
+
+end

data/spec/fixtures/b/posts_fragment.rb

@@ -0,0 +1,8 @@
+class PostsFragment < Blackbird::Fragment
+
+  table :posts do |t|
+    t.string :title, :unique => true
+    t.rename :published_at, :posted_at
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--require spec/spec_helper.rb
+--format specdoc
+--colour
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+
+case ENV['RAILS_VERSION']
+when '3.0', nil
+  gem 'activerecord', '~> 3.0.0'
+when '2.3'
+  gem 'activerecord', '~> 2.3.0'
+else
+  gem 'activerecord', ENV['RAILS_VERSION']
+end
+
+require 'blackbird'
+require 'fileutils'
+require 'pp'
+
+puts "Running with ActiveRecord version #{ActiveRecord::VERSION::STRING}"
+
+tmp = File.expand_path('../../tmp', __FILE__)
+FileUtils.mkdir_p(tmp)
+FileUtils.rm_f(tmp)
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3',
+  :database => tmp+'/test.db'
+})
+
+ActiveRecord::Schema.define do
+  create_table "posts", :force => true do |t|
+    t.column "title", :string
+    t.column "body",  :text
+    t.column "published_at", :datetime
+  end
+
+  create_table "pages", :force => true do |t|
+    t.column "title", :string
+    t.column "body",  :string
+    t.column "image_id", :integer
+  end
+
+  create_table "images", :force => true do |t|
+    t.column "caption", :text
+    t.column "filename", :string
+  end
+
+  create_table "users", :force => true do |t|
+    t.column "full_name", :string
+  end
+
+  ActiveRecord::Base.connection.execute('INSERT INTO users (id, full_name) VALUES (1, "Simon Menke")')
+  ActiveRecord::Base.connection.execute('INSERT INTO users (id, full_name) VALUES (2, "Yves")')
+end
+
+
+def reset_connection
+  tmp = File.expand_path('../../tmp', __FILE__)
+  FileUtils.rm_f(tmp+'/test_real.db')
+  FileUtils.cp(tmp+'/test.db', tmp+'/test_real.db')
+
+  ActiveRecord::Base.establish_connection({
+    :adapter => 'sqlite3',
+    :database => tmp+'/test_real.db'
+  })
+end
+
+Blackbird.options[:verbose] = false
+Blackbird.options[:processors] = Blackbird::ProcessorList.new
+Blackbird.options[:processors].use 'Blackbird::Processors::IndexedColumns'
+Blackbird.options[:processors].use 'Blackbird::Processors::NormalDefault'
+
+FRAGMENT_PATHS = (
+  Dir.glob(File.expand_path('../fixtures/a/**/*_fragment.rb', __FILE__)) +
+  Dir.glob(File.expand_path('../fixtures/b/**/*_fragment.rb', __FILE__)) )