force_schema 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+rdoc/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in force_schema.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,44 @@
+=force_schema
+
+    class Car < ActiveRecord::Base
+      set_primary_key :name
+      force_schema do
+        string   'name'       # Nissan Altima, will automatically be indexed because it's the primary key
+        string   'make_name'  # Nissan
+        string   'model_name' # Altime
+        float    'fuel_efficiency_city'
+        string   'fuel_efficiency_city_units'
+        float    'fuel_efficiency_highway'
+        string   'fuel_efficiency_highway_units'
+        integer  'year'
+        datetime 'released_at'
+        date     'released_on'
+        index    ['name', 'make_name']
+      end
+    end
+
+== Warning: data loss
+
+If you call <tt>Car.force_schema!</tt>, it may destroy data by adding, removing, or changing the type of columns. <b>No attempt is made to preserve data.</b>
+
+== What it synchronizes
+
+* adds missing columns
+* adds missing indexes
+* removes unrecognized columns
+* removes unrecognized indexes
+* changes the type of columns if it doesn't match what you asked for
+* changes the columns indexed if they don't match what you asked for
+* makes sure default value is synced up
+
+== Supported databases
+
+* MySQL is tested
+* SQLite is tested
+* Postgres is not supported
+
+== History
+
+Extracted from https://github.com/seamusabshere/data_miner. In production use at http://carbon.brighterplanet.com and http://data.brighterplanet.com.
+
+Copyright 2011 Seamus Abshere

data/Rakefile

@@ -0,0 +1,26 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'force_schema'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :test_separately do
+  puts `bundle exec rake test TEST=test/test_mysql.rb`
+  puts `bundle exec rake test TEST=test/test_sqlite3.rb`
+end
+
+task :default => :test_separately

data/force_schema.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "force_schema/version"
+
+Gem::Specification.new do |s|
+  s.name        = "force_schema"
+  s.version     = ForceSchema::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Seamus Abshere"]
+  s.email       = ["seamus@abshere.net"]
+  s.homepage    = "https://github.com/seamusabshere/force_schema"
+  s.summary     = %q{Sometimes you don't need to write up and down migrations, you just want a table (aka schema) to have a certain structure.}
+  s.description = %q{Declare a table structure like an ActiveRecord migration and run 'force_schema!' whenever you want. For when you don't need up and down migrations.}
+
+  s.rubyforge_project = "force_schema"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'mysql'
+  s.add_development_dependency 'sqlite3-ruby'
+  s.add_development_dependency 'rake'
+  s.add_dependency 'activerecord', '>=2.3.10'
+  s.add_dependency 'activesupport', '>=2.3.10'
+  s.add_dependency 'blockenspiel'
+end

data/lib/force_schema.rb

@@ -0,0 +1,23 @@
+require 'active_record'
+require 'active_support/core_ext'
+
+module ForceSchema
+  autoload :Registry, 'force_schema/registry'
+  autoload :Schema, 'force_schema/schema'
+    
+  def force_schema!
+    enforced_schema.run
+  end
+
+  def force_schema(create_table_options = {}, &blk)
+    enforced_schema.create_table_options = create_table_options
+    ::Blockenspiel.invoke blk, enforced_schema
+    enforced_schema
+  end
+  
+  def enforced_schema
+    Registry.instance[name] ||= Schema.new self
+  end
+end
+
+::ActiveRecord::Base.extend ::ForceSchema

data/lib/force_schema/registry.rb

@@ -0,0 +1,6 @@
+require 'singleton'
+module ForceSchema
+  class Registry < ::Hash
+    include ::Singleton
+  end
+end

data/lib/force_schema/schema.rb

@@ -0,0 +1,279 @@
+require 'blockenspiel'
+require 'zlib'
+require 'active_support'
+require 'active_support/core_ext'
+module ForceSchema
+  class Schema
+    MAX_INDEX_NAME_LENGTH = 32 # mysql
+    
+    class << self
+      def suggest_index_name(active_record, columns, index_options = {})
+        return index_options[:name] if index_options.has_key? :name
+        default_name = 'index_' + ::Array.wrap(columns).join('_and_') #active_record.connection.index_name(active_record.table_name, index_options.merge(:column => columns))
+        if default_name.length < MAX_INDEX_NAME_LENGTH
+          default_name
+        else
+          default_name[0..MAX_INDEX_NAME_LENGTH-11] + ::Zlib.crc32(default_name).to_s
+        end
+      end
+    end
+    
+    include ::Blockenspiel::DSL
+
+    attr_reader :active_record
+    attr_reader :create_table_options
+
+    def initialize(active_record)
+      @active_record = active_record
+    end
+    
+    def create_table_options=(options = {})
+      @create_table_options = options.symbolize_keys
+      raise ":id => true is not allowed in create_table_options." if create_table_options[:id] === true
+      raise ":primary_key is not allowed in create_table_options. Use set_primary_key instead." if create_table_options.has_key?(:primary_key)
+      if create_table_options[:options].blank? and mysql?
+        create_table_options[:options] = 'ENGINE=INNODB CHARSET=UTF8 COLLATE=UTF8_GENERAL_CI'
+      end
+      create_table_options[:id] = false # always
+    end
+
+    # sabshere 1/25/11 lifted straight from activerecord-3.0.3/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+    %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
+      class_eval <<-EOV
+        def #{column_type}(*args)                                               # def string(*args)
+          options = args.extract_options!                                       #   options = args.extract_options!
+          column_names = args                                                   #   column_names = args
+                                                                                #
+          column_names.each { |name| ideal_table.column(name, '#{column_type}', options) }  #   column_names.each { |name| ideal_table.column(name, 'string', options) }
+        end                                                                     # end
+      EOV
+    end
+    
+    def index(columns, index_options = {})
+      index_options = index_options.symbolize_keys
+      columns = ::Array.wrap columns
+      index_name = Schema.suggest_index_name active_record, columns, index_options
+      index_unique = index_options.has_key?(:unique) ? index_options[:unique] : true
+      ideal_indexes.push ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, index_unique, columns)
+      nil
+    end
+
+    def run
+      _create_table
+      _set_primary_key
+      _remove_columns
+      _add_columns
+      _remove_indexes
+      _add_indexes
+      nil
+    end
+
+    private
+
+    def log_debug(msg)
+      ::ActiveRecord::Base.logger.try :debug, msg
+    end
+
+    def column(*args)
+      ideal_table.column(*args)
+    end
+
+    def ideal_primary_key_name
+      active_record.primary_key.to_s
+    end
+
+    def actual_primary_key_name
+      if sqlite? and pk = active_record.columns_hash.detect { |k, v| v.primary }
+        pk[1].name
+      elsif pk = connection.primary_key(table_name)
+        pk
+      end.to_s
+    end
+
+    def index_equivalent?(a, b)
+      return false unless a and b
+      %w{ name columns }.all? do |property|
+        a_property = ::Array.wrap(a.send(property)).map(&:to_s)
+        b_property = ::Array.wrap(b.send(property)).map(&:to_s)
+        log_debug "...comparing #{a_property.inspect} <-> #{b_property.inspect}"
+        a_property == b_property
+      end
+    end
+
+    COMPARABLE_OPTIONS = [ :default ] # other things vary rather unpredicatably by adapter
+    
+    def column_equivalent?(a, b)
+      return false unless a and b
+      a_type = (a.type.to_s == 'primary_key') ? 'integer' : a.type.to_s
+      b_type = (b.type.to_s == 'primary_key') ? 'integer' : b.type.to_s
+      a_type == b_type and a.name.to_s == b.name.to_s and column_options(a).slice(COMPARABLE_OPTIONS) == column_options(b).slice(COMPARABLE_OPTIONS)
+    end
+
+    %w{ column index }.each do |i|
+      eval %{
+        def #{i}_needs_to_be_placed?(name)
+          actual = actual_#{i} name
+          return true unless actual
+          ideal = ideal_#{i} name
+          not #{i}_equivalent? actual, ideal
+        end
+
+        def #{i}_needs_to_be_removed?(name)
+          ideal_#{i}(name).nil?
+        end
+      }
+    end
+
+    def ideal_column(name)
+      ideal_table[name.to_s]
+    end
+
+    def actual_column(name)
+      active_record.columns_hash[name.to_s]
+    end
+
+    def ideal_index(name)
+      ideal_indexes.detect { |ideal| ideal.name == name.to_s }
+    end
+
+    def actual_index(name)
+      actual_indexes.detect { |actual| actual.name == name.to_s }
+    end
+    
+    POSSIBLE_OPTIONS = [ :limit, :default, :null, :precision, :scale ]
+    
+    def column_options(column)
+      POSSIBLE_OPTIONS.inject({}) do |memo, k|
+        v = column.send(k)
+        if v == false or v.present?
+          memo[k] = v
+        end
+        memo
+      end
+    end
+    
+    def place_column(name)
+      remove_column name if actual_column name
+      ideal = ideal_column name
+      options = column_options ideal
+      log_debug "PLACING COLUMN #{name}"
+      connection.add_column table_name, name, ideal.type.to_sym, options
+      active_record.reset_column_information
+    end
+
+    def remove_column(name)
+      log_debug "REMOVING COLUMN #{name}"
+      connection.remove_column table_name, name
+      active_record.reset_column_information
+    end
+
+    def place_index(name)
+      remove_index name if actual_index name
+      ideal = ideal_index name
+      log_debug "PLACING INDEX #{name}"
+      connection.add_index table_name, ideal.columns, :name => ideal.name
+      active_record.reset_column_information
+    end
+
+    def remove_index(name)
+      log_debug "REMOVING INDEX #{name}"
+      connection.remove_index table_name, :name => name
+      active_record.reset_column_information
+    end
+
+    # sabshere 1/25/11 what if there were multiple connections
+    # blockenspiel doesn't like to delegate this to #active_record
+    def connection
+      ::ActiveRecord::Base.connection
+    end
+
+    def table_name
+      active_record.table_name
+    end
+
+    def ideal_table
+      @ideal_table ||= ::ActiveRecord::ConnectionAdapters::TableDefinition.new connection
+    end
+
+    def ideal_indexes
+      @ideal_indexes ||= []
+    end
+
+    def actual_indexes
+      connection.indexes table_name
+    end
+
+    def _create_table
+      if not active_record.table_exists?
+        log_debug "CREATING TABLE #{table_name} with #{create_table_options.inspect}"
+        connection.create_table table_name, create_table_options do |t|
+          t.integer 'force_schema_tmp'
+        end
+        active_record.reset_column_information
+      end
+    end
+
+    def _set_primary_key
+      if ideal_primary_key_name == 'id' and not ideal_column('id')
+        log_debug "no special primary key set on #{table_name}, so using 'id'"
+        column 'id', :primary_key # needs to be a sym?
+      end
+      actual = actual_column actual_primary_key_name
+      ideal = ideal_column ideal_primary_key_name
+      if not column_equivalent? actual, ideal
+        log_debug "looks like #{table_name} has a bad (or missing) primary key"
+        if actual
+          log_debug "looks like primary key needs to change from #{actual_primary_key_name} to #{ideal_primary_key_name}, re-creating #{table_name} from scratch"
+          connection.drop_table table_name
+          active_record.reset_column_information
+          _create_table
+        end
+        place_column ideal_primary_key_name
+        unless ideal.type.to_s == 'primary_key'
+          log_debug "SETTING #{ideal_primary_key_name} AS PRIMARY KEY"
+          if sqlite?
+            special_sqlite_primary_key_index_name = "IDX_#{table_name}_#{ideal_primary_key_name}"
+            connection.execute "CREATE UNIQUE INDEX #{special_sqlite_primary_key_index_name} ON #{table_name} (#{ideal_primary_key_name} ASC)"
+            ideal_indexes.push ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, special_sqlite_primary_key_index_name, true, ideal_primary_key_name)
+          else
+            connection.execute "ALTER TABLE `#{table_name}` ADD PRIMARY KEY (`#{ideal_primary_key_name}`)"
+          end
+        end
+      end
+      active_record.reset_column_information
+    end
+
+    def sqlite?
+      connection.adapter_name.downcase.start_with? 'sqlite'
+    end
+    
+    def mysql?
+      connection.adapter_name.downcase.start_with? 'mysql'
+    end
+
+    def _remove_columns
+      active_record.columns_hash.values.each do |actual|
+        remove_column actual.name if column_needs_to_be_removed? actual.name
+      end
+    end
+
+    def _add_columns
+      ideal_table.columns.each do |ideal|
+        place_column ideal.name if column_needs_to_be_placed? ideal.name
+      end
+    end
+
+    def _remove_indexes
+      actual_indexes.each do |actual|
+        remove_index actual.name if index_needs_to_be_removed? actual.name
+      end
+    end
+
+    def _add_indexes
+      ideal_indexes.each do |ideal|
+        next if ideal.name == ideal_primary_key_name # this should already have been taken care of
+        place_index ideal.name if index_needs_to_be_placed? ideal.name
+      end
+    end
+  end
+end

data/lib/force_schema/version.rb

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

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'logger'
+require 'test/unit'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'force_schema'
+require 'support/shared'
+class Test::Unit::TestCase
+end
+
+ActiveRecord::Base.logger = Logger.new($stderr)
+ActiveRecord::Base.logger.level = Logger::DEBUG

data/test/support/car.rb

@@ -0,0 +1,18 @@
+class Car < ActiveRecord::Base
+  set_primary_key :name
+
+  force_schema do
+    string   'name'       # Nissan Altima, will automatically be indexed because it's the primary key
+    string   'make_name'  # Nissan
+    string   'model_name' # Altime
+    float    'fuel_efficiency_city'
+    string   'fuel_efficiency_city_units'
+    float    'fuel_efficiency_highway'
+    string   'fuel_efficiency_highway_units'
+    integer  'year'
+    datetime 'released_at'
+    date     'released_on'
+    boolean  'consumer_reports_best_buy', :default => false
+    index    ['name', 'make_name']
+  end
+end

data/test/support/monk.rb

@@ -0,0 +1,7 @@
+class Monk < ActiveRecord::Base
+  set_primary_key :name
+
+  force_schema do
+    string   'name'
+  end
+end

data/test/support/shared.rb

@@ -0,0 +1,103 @@
+module Shared
+  def setup
+    ActiveRecord::Base.connection.drop_table 'cars' rescue nil
+    Car.force_schema!
+  end
+  
+  def test_001_add_columns_and_indexes_from_scratch
+    assert_equal :string, ct(Car, :name)
+    assert_equal :float, ct(Car, :fuel_efficiency_city)
+    assert_equal :integer, ct(Car, :year)
+    assert_equal :datetime, ct(Car, :released_at)
+    assert_equal :date, ct(Car, :released_on)
+    assert index?(Car, :index_name_and_make_name)
+  end
+  
+  def test_002_restore_removed_column
+    Car.connection.remove_column :cars, :year
+    assert_equal nil, ct(Car, :year)
+    Car.force_schema!
+    assert_equal :integer, ct(Car, :year)
+  end
+  
+  def test_003_fix_column_type
+    Car.connection.remove_column :cars, :year
+    Car.connection.add_column :cars, :year, :string
+    Car.reset_column_information
+    assert_equal :string, ct(Car, :year)
+    Car.force_schema!
+    assert_equal :integer, ct(Car, :year)
+  end
+  
+  def test_004_remove_unrecognized_column
+    Car.connection.add_column :cars, :foobar, :string
+    assert_equal :string, ct(Car, :foobar)
+    Car.force_schema!
+    assert_equal nil, ct(Car, :foobar)
+  end
+  
+  def test_005_restore_removed_index
+    Car.connection.remove_index :cars, :name => 'index_name_and_make_name'
+    Car.reset_column_information
+    assert !index?(Car, :index_name_and_make_name)
+    Car.force_schema!
+    assert index?(Car, :index_name_and_make_name)
+  end
+  
+  def test_006_restore_damaged_index
+    Car.connection.remove_column :cars, :make_name
+    Car.force_schema!
+    assert index?(Car, :index_name_and_make_name)
+  end
+  
+  def test_007_remove_unrecognized_index
+    Car.connection.add_index :cars, :year, :name => 'foobar'
+    Car.reset_column_information
+    assert index?(Car, :foobar)
+    Car.force_schema!
+    assert !index?(Car, :foobar)
+  end
+  
+  def test_008_primary_key_is_unique
+    a = Car.new
+    a.name = 'a'
+    a.save!
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      a = Car.new
+      a.name = 'a'
+      a.save!
+    end
+  end
+  
+  def test_009_edge_case_one_column
+    ActiveRecord::Base.connection.drop_table 'monks' rescue nil
+    Monk.force_schema!
+    Monk.force_schema!
+    Monk.force_schema!
+    assert_equal :string, ct(Monk, :name)
+  end
+  
+  def test_010_default_false
+    a = Car.new
+    assert_equal false, a.consumer_reports_best_buy
+  end
+  
+  private
+
+  def ct(active_record, column_name)
+    if c = active_record.columns_hash[column_name.to_s]
+      c.type
+    end
+  end
+
+  def index?(active_record, index_name)
+    active_record.reset_column_information
+    index_name = index_name.to_s
+    return true if index_name == active_record.primary_key.to_s
+    if ActiveRecord::VERSION::MAJOR < 3
+      active_record.connection.index_exists?(active_record.table_name, index_name, :not_supported_by_adapter)
+    else
+      active_record.connection.index_exists?(active_record.table_name, nil, :name => index_name)
+    end
+  end
+end

data/test/test_mysql.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+ActiveRecord::Base.establish_connection(
+  'adapter' => 'mysql',
+  'database' => 'test_force_schema',
+  'username' => 'root',
+  'password' => 'password',
+  'encoding' => 'utf8'
+)
+
+require 'support/car'
+require 'support/monk'
+
+class TestMysql < Test::Unit::TestCase
+  include Shared
+end

data/test/test_sqlite3.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+
+require 'support/car'
+require 'support/monk'
+
+class TestSqlite3 < Test::Unit::TestCase
+  include Shared
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: force_schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Seamus Abshere
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &2154422840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154422840
+- !ruby/object:Gem::Dependency
+  name: mysql
+  requirement: &2154422420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154422420
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: &2154422000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154422000
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2154421580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154421580
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2154421080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154421080
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2154420580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154420580
+- !ruby/object:Gem::Dependency
+  name: blockenspiel
+  requirement: &2154420200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154420200
+description: Declare a table structure like an ActiveRecord migration and run 'force_schema!'
+  whenever you want. For when you don't need up and down migrations.
+email:
+- seamus@abshere.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- force_schema.gemspec
+- lib/force_schema.rb
+- lib/force_schema/registry.rb
+- lib/force_schema/schema.rb
+- lib/force_schema/version.rb
+- test/helper.rb
+- test/support/car.rb
+- test/support/monk.rb
+- test/support/shared.rb
+- test/test_mysql.rb
+- test/test_sqlite3.rb
+homepage: https://github.com/seamusabshere/force_schema
+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: force_schema
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Sometimes you don't need to write up and down migrations, you just want a
+  table (aka schema) to have a certain structure.
+test_files:
+- test/helper.rb
+- test/support/car.rb
+- test/support/monk.rb
+- test/support/shared.rb
+- test/test_mysql.rb
+- test/test_sqlite3.rb