ensured_schema 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/ensured_schema.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ensured_schema/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ensured_schema"
+  s.version     = EnsuredSchema::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Chris Conley"]
+  s.email       = ["chris@chrisconley.me"]
+  s.homepage    = "http://rubygems.org/gems/ensured_schema"
+  s.summary     = %q{Ensures database schema always matches your schema.rb file}
+  s.description = %q{Smarter migrations}
+
+  s.rubyforge_project = "ensured_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"]
+end

data/lib/ensured_schema/version.rb

@@ -0,0 +1,3 @@
+module EnsuredSchema
+  VERSION = "0.0.1"
+end

data/lib/ensured_schema.rb

@@ -0,0 +1,155 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def table_exists?(table_name)
+        tables.map(&:downcase).include?(table_name.to_s.downcase)
+      end
+    end
+
+    module SchemaStatements
+      # Checks to see if a column exists in a given table.
+      #
+      # === Examples
+      #  # Check a column exists
+      #  column_exists?(:suppliers, :name)
+      #
+      #  # Check a column exists of a particular type
+      #  column_exists?(:suppliers, :name, :string)
+      #
+      #  # Check a column exists with a specific definition
+      #  column_exists?(:suppliers, :name, :string, :limit => 100)
+      def column_exists?(table_name, column_name, type = nil, options = {})
+        #debugger
+        columns(table_name).any?{ |c| c.name == column_name.to_s &&
+                                      (!type                 || c.type.to_s == type.to_s) &&
+                                      (!options[:limit]      || c.limit_exists?(options[:limit])) &&
+                                      (!options[:precision]  || c.precision == options[:precision]) &&
+                                      (!options[:scale]      || c.scale == options[:scale]) }
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Column
+      def limit_exists?(new_limit)
+        self.limit == new_limit
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlColumn
+      def limit_exists?(new_limit)
+        return super unless type.to_s == 'integer'
+        case new_limit
+        when 5..8
+          self.limit == 8
+        when nil, 4, 11
+          self.limit == 4
+        else
+          self.limit == new_limit
+        end
+      end
+    end
+  end
+end
+
+
+module ActiveRecord
+  module ConnectionAdapters
+    class EnsuredTable < Table
+
+      def column_exists?(column_name, type = nil, options = {})
+        #debugger
+        @base.column_exists?(@table_name, column_name, type, options)
+      end
+
+      %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)
+            define_columns('#{column_type}', *args)    #   define_column('string', *args)
+          end                                         # end
+        EOV
+      end
+
+      def define_columns(column_type, *args)
+        options = args.extract_options!
+        column_names = args
+
+        column_names.each do |name|
+          column_def = build_column_definition(name, column_type, options)
+          def_options = column_def.members.inject({}){|h, k| h[k.to_sym] = column_def[k]; h;}
+          #debugger
+          if column_exists?(name)
+            unless column_exists?(name, column_type, def_options)
+              debugger
+              change(name, column_def.sql_type, options)
+              puts "#{name} has been changed!"
+            end
+          else
+            puts "creating column"
+            @base.add_column(@table_name, name, column_def.sql_type, options)
+          end
+        end
+      end
+
+      def build_column_definition(column_name, column_type, options = {})
+        column = ColumnDefinition.new(@base, column_name, column_type)
+        if options[:limit]
+          column.limit = options[:limit]
+        elsif native[column_type.to_sym].is_a?(Hash)
+          column.limit = native[column_type.to_sym][:limit]
+        end
+        column.precision = options[:precision]
+        column.scale = options[:scale]
+        column.default = options[:default]
+        column.null = options[:null]
+        column
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Schema
+    def self.ensure(options={}, &block)
+      self.define(options, &block)
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      def table(table_name, options = {}, &block)
+        if table_exists?(table_name)
+          puts "table already exists"
+          ensure_table(table_name, &block) # what to do about changing table options
+        else
+          puts "creating table"
+          create_table(table_name, options, &block)
+        end
+      end
+
+      def ensure_table(table_name)
+        yield EnsuredTable.new(table_name, self)
+      end
+
+      def ensure_index(table_name, column_name, options = {})
+        begin
+          add_index(table_name, column_name, options)
+        rescue => e
+          if e.message =~ /Duplicate key/
+            puts "index already exists"
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: ensured_schema
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Conley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-08 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Smarter migrations
+email: 
+- chris@chrisconley.me
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- ensured_schema.gemspec
+- lib/ensured_schema.rb
+- lib/ensured_schema/version.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/ensured_schema
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ensured_schema
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ensures database schema always matches your schema.rb file
+test_files: []
+