migrant 0.1.0

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+tmp/*
+test/rails_app/db/migrate/*.rb
+test/rails_app/db/schema.rb

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Pascal Houliston
+
+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.rdoc

@@ -0,0 +1,124 @@
+= Migrant
+
+== Summary
+
+Migrant gives you a super-clean DSL to describe your ActiveRecord models (somewhat similar to DataMapper)
+and generates all your migrations for you so you can spend more time coding the stuff that counts!
+
+You'll also get a handy .mock method to instantiate a filled in model for testing or debugging purposes.
+
+== Getting Started
+
+Only for Rails 3 and Ruby 1.9+ folks. Simply install the gem "migrant", or add it to your bundler Gemfile
+    
+== Jumping right in
+
+Start by creating some models with the structure you need:
+
+  class Business < ActiveRecord::Base
+    belongs_to :user
+    
+    # Here's where you describe the columns in your model
+    # You can provide a symbol (like a migration) or better still, give an example
+    # of the data that will go in there
+    
+    structure do
+      name             "The kernel's favourite fried chickens"
+      website          "http://www.google.co.za/"
+      address          ["11 Test Drive", "Gardens", "Cape Town" ,"South Africa"].join("\n")
+      date_established Time.now - 300.years
+    end
+  end
+  
+And another for good measure:
+
+  class User < ActiveRecord::Base
+    has_many :businesses
+    
+    structure do
+      name        "John"
+      surname     "Smith"
+      description :string
+    end
+  end
+  
+Now, to get your database up to date simply run:
+
+  > rake db:upgrade
+
+  Wrote db/migrate/20101028192913_create_businesses.rb...  
+  Wrote db/migrate/20101028192916_create_users.rb...
+  
+OR, if you'd prefer to look over the migrations yourself first, run:
+
+  > rails generate migrations
+  
+Result:
+
+  irb(main):001:0> Business                                                                                                                                                                                                                    
+  => Business(id: integer, user_id: integer, name: string, website: string, address: text, date_established: datetime)  
+  
+  irb(main):002:0> Awesome!!!!                                                                                                                                                                                                                    
+  NoMethodError: undefined method `Awesome!!!!' for main:Object
+  
+== Want more examples?
+
+Check out the test models in test/rails_app/app/models/*
+  
+== What will happen seamlessly
+
+* Creating tables or adding columns (as appropriate)
+* Adding indexes (happens on foreign keys automatically)
+* Changing column types
+* Rollbacks for all the above
+
+== What won't
+
+These actions won't be performed (because we don't want to hurt your data):
+
+* Remove tables/columns 
+* Changing column types where data loss may occur (e.g. varchar -> int)
+
+== Getting a mock of your model
+
+  > rails console
+
+  irb(main):002:0> my_business = Business.mock
+  => #<Business id: nil, name: "The Kernel's favourite fried chickens", website: "http://www.google.co.za/", 
+       address: "11 Test Drive\nGardens\nCape Town\nSouth Africa", date_established: "1710-10-28 21:03:31">
+  
+  irb(main):003:0> my_business.user
+  => #<User id: nil, name: "John", surname: "Smith", description: "Some string">
+
+== License
+
+Copyright (c) 2010 Pascal Houliston
+
+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.
+
+== Development
+
+Please be sure to install all the development dependencies from the gemspec, then to run tests do:
+
+> rake test
+
+
+
+

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "migrant"
+    gem.summary = %Q{All the fun of ActiveRecord, without writing your migrations, and a dash of mocking.}
+    gem.description = %Q{Migrant gives you a super-clean DSL to describe your ActiveRecord models (somewhat similar to DataMapper) and generates all your migrations for you so you can spend more time coding the stuff that counts!}
+    gem.email = "101pascal@gmail.com"
+    gem.homepage = "http://github.com/pascalh1011/migrant"
+    gem.authors = ["Pascal Houliston"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "ansi", "= 1.2.2"
+    gem.add_development_dependency "turn", "= 0.8.1"  
+    gem.add_development_dependency "sqlite3-ruby", ">= 0"
+    gem.add_development_dependency "simplecov", ">= 0.3.5"
+    gem.add_dependency "activerecord", ">= 3.0.0"
+    gem.add_dependency "activesupport", ">= 3.0.0"    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "migrant #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/datatype/base.rb

@@ -0,0 +1,65 @@
+module DataType
+  class DangerousMigration < Exception; end;
+
+  class Base
+    attr_accessor :aliases
+  
+    # Pass the developer's ActiveRecord::Base structure and we'll
+    # decide the best structure
+    def initialize(options={})
+      @options = options
+      @value = options.delete(:value)
+      @field = options.delete(:field)
+      @aliases = options.delete(:was) || Array.new
+    end
+    
+    # Default is 'ye good ol varchar(255)
+    def column
+      {:type => :string}.merge(@options)
+    end
+    
+    def mock
+      @value || self.class.default_mock
+    end
+    
+    def self.default_mock
+      "Some string"
+    end
+    
+    # Decides if and how a column will be changed
+    # Provide the details of a previously column, or simply nil to create a new column
+    def structure_changes_from(current_structure = nil)    
+      new_structure = column
+    
+      if current_structure
+        # General RDBMS data loss scenarios
+        raise DataType::DangerousMigration if (new_structure[:type] != :text && [:string, :text].include?(current_structure[:type]) && new_structure[:type] != current_structure[:type])
+
+        if new_structure[:limit] && current_structure[:limit].to_i != new_structure[:limit].to_i ||
+           new_structure[:default] && current_structure[:default].to_s != new_structure[:default].to_s ||
+           new_structure[:type] != current_structure[:type]
+           column
+        else
+          nil # No changes
+        end
+      else
+        column
+      end
+    end
+    
+    def self.migrant_data_type?; true; end
+  end
+end
+
+# And all the data types we offer...
+require 'datatype/boolean'
+require 'datatype/currency'
+require 'datatype/date'
+require 'datatype/float'
+require 'datatype/foreign_key'
+require 'datatype/hash'
+require 'datatype/polymorphic'
+require 'datatype/range'
+require 'datatype/string'
+require 'datatype/symbol'
+require 'datatype/time'

data/lib/datatype/boolean.rb

@@ -0,0 +1,15 @@
+module DataType
+  class TrueClass < Base
+    def column
+      {:type => :boolean}
+    end  
+    
+    def self.default_mock
+      true
+    end
+  end
+  
+  class FalseClass < TrueClass; end;
+end
+  
+

data/lib/datatype/currency.rb

@@ -0,0 +1,11 @@
+module DataType
+  class Currency < Base
+    def column
+      {:type => :decimal, :precision => 10, :scale => 2}
+    end
+    
+    def self.default_mock
+      rand(9999999).to_f+0.51
+    end
+  end
+end

data/lib/datatype/date.rb

@@ -0,0 +1,13 @@
+module DataType
+  class Date < Base
+    def column
+      {:type => :datetime}
+    end
+    
+    def self.default_mock
+      ::Time.now
+    end
+  end
+end
+  
+

data/lib/datatype/float.rb

@@ -0,0 +1,11 @@
+module DataType
+  class Float < Base
+    def column
+      {:type => :float}
+    end
+    
+    def self.default_mock
+      rand(100).to_f-55.0
+    end
+  end
+end

data/lib/datatype/foreign_key.rb

@@ -0,0 +1,9 @@
+module DataType
+  class ForeignKey < Base
+    def column
+      {:type => :integer}
+    end
+  end
+end
+  
+

data/lib/datatype/hash.rb

@@ -0,0 +1,10 @@
+module DataType
+  class Hash < Base
+    def column
+      @options = @value # Assign developer's options verbatim
+        super
+    end
+  end
+end
+  
+

data/lib/datatype/polymorphic.rb

@@ -0,0 +1,8 @@
+module DataType
+  class Polymorphic < Base
+    def mock
+      # Eek, can't mock an unknown type
+      nil
+    end
+  end
+end

data/lib/datatype/range.rb

@@ -0,0 +1,13 @@
+module DataType
+  class Range < Base
+    def column
+      definition = {:type => :integer}
+      definition[:limit] = @value.max.to_s.length if @value.respond_to?(:max)
+      definition
+    end
+    
+    def self.default_mock
+      0..100
+    end
+  end
+end

data/lib/datatype/string.rb

@@ -0,0 +1,22 @@
+module DataType
+  class String < Base
+    def initialize(options)
+      super(options)
+      @value ||= ''
+    end
+  
+    def column
+      if @value.match(/[\d,]+\.\d{2}$/)
+        return Currency.new(@options).column
+      else
+        return @value.match(/[\r\n\t]/)? { :type => :text }.merge(@options) : super
+      end
+    end
+    
+    def mock
+      @value || ((self.column[:type] == :text)? %W{Several lines of long text.}.join("\n") : "Some string")
+    end
+  end
+end
+  
+

data/lib/datatype/symbol.rb

@@ -0,0 +1,10 @@
+module DataType
+  class Symbol < Base
+    def column
+      # Just construct whatever the user wants
+      {:type => @value || :string }.merge(@options)
+    end  
+  end
+end
+  
+

data/lib/datatype/time.rb

@@ -0,0 +1,5 @@
+module DataType
+  class Time < Date
+    # No different to date type
+  end
+end

data/lib/migrant/migration_generator.rb

@@ -0,0 +1,123 @@
+module Migrant
+  class MigrationGenerator
+    TABS = '  ' # Tabs to spaces * 2
+    NEWLINE = "\n  "
+    def run
+      migrator = ActiveRecord::Migrator.new(:up, migrations_path)
+
+      unless migrator.pending_migrations.blank?
+        puts "You have some pending database migrations. You can either:\n1. Run them with rake db:migrate\n2. Delete them, in which case this task will probably recreate their actions (DON'T do this if they've been in SCM)."
+        return false
+      end
+      
+      # Get all tables and compare to the desired schema
+      # The next line is an evil hack to recursively load all model files in app/models
+      # This needs to be done because Rails normally lazy-loads these files, resulting a blank descendants list of AR::Base
+      Dir["#{Rails.root.to_s}/app/models/**/*.rb"].each { |f| load(f) } if ActiveRecord::Base.descendants.blank?
+
+      ActiveRecord::Base.descendants.each do |model|
+        next if model.schema.nil? || !model.schema.requires_migration? # Skips inherited schemas (such as models with STI)
+        model.reset_column_information # db:migrate doesn't do this
+        model_schema = model.schema.column_migrations
+  
+        if model.table_exists?
+          # Structure ActiveRecord::Base's column information so we can compare it directly to the schema
+          db_schema = Hash[*model.columns.collect {|c| [c.name.to_sym, Hash[*[:type, :limit].map { |type| [type, c.send(type)] }.flatten]  ] }.flatten]
+            changes = model.schema.columns.collect do |name, data_type| 
+              begin                  
+                [name, data_type.structure_changes_from(db_schema[name])]
+              rescue DataType::DangerousMigration
+                puts "Cannot generate migration automatically for #{model.table_name}, this would involve possible data loss on column: #{name}\nOld structure: #{db_schema[name].inspect}. New structure: #{data_type.column.inspect}\nPlease create and run this migration yourself (with the appropriate data integrity checks)"
+                return false
+              end
+            end.reject { |change| change[1].nil? }
+            next if changes.blank?
+            activity = model.table_name+'_modify_fields_'+changes.collect { |field, options| field.to_s }.join('_')
+            
+            up_code = changes.collect do |field, options|
+              type = options.delete(:type)            
+              arguments = (options.blank?)? "" : ", #{options.inspect[1..-2]}"              
+              
+              if db_schema[field]
+                "change_column :#{model.table_name}, :#{field}, :#{type}#{arguments}"
+              else
+                "add_column :#{model.table_name}, :#{field}, :#{type}#{arguments}"
+              end
+            end.join(NEWLINE+TABS)
+           
+            down_code = changes.collect do |field, options|
+              if db_schema[field]
+                type = db_schema[field].delete(:type)            
+                arguments = (db_schema[field].blank?)? "" : ", #{db_schema[field].inspect[1..-2]}"              
+                "change_column :#{model.table_name}, :#{field}, :#{type}#{arguments}"
+              else
+                "remove_column :#{model.table_name}, :#{field}"
+              end
+            end.join(NEWLINE+TABS)            
+            
+            # For adapters that can report indexes, add as necessary
+            if ActiveRecord::Base.connection.respond_to?(:indexes)
+              current_indexes = ActiveRecord::Base.connection.indexes(model.table_name).collect { |index| (index.columns.length == 1)? index.columns.first.to_sym : index.columns.collect(&:to_sym) }
+              up_code += model.schema.indexes.uniq.collect do |index|
+                unless current_indexes.include?(index)
+                  NEWLINE+TABS+"add_index :#{model.table_name}, #{index.inspect}"
+                end
+              end.compact.join
+            end
+        else
+          activity = "create_#{model.table_name}"          
+          up_code = "create_table :#{model.table_name} do |t|"+NEWLINE+model_schema.collect do |field, options| 
+            type = options.delete(:type)
+            options.delete(:was) # Aliases not relevant when creating a new table
+            arguments = (options.blank?)? "" : ", #{options.inspect[1..-2]}"
+            (TABS*2)+"t.#{type} :#{field}#{arguments}"
+          end.join(NEWLINE)+NEWLINE+TABS+"end"
+          
+          down_code = "drop_table :#{model.table_name}"
+          up_code   += NEWLINE+TABS+model.schema.indexes.collect { |fields| "add_index :#{model.table_name}, #{fields.inspect}"}.join(NEWLINE+TABS)          
+        end
+
+        # Indexes
+         # down_code += NEWLINE+TABS+model.schema.indexes.collect { |fields| "remove_index :#{model.table_name}, #{fields.inspect}"}.join(NEWLINE+TABS)
+        filename = "#{migrations_path}/#{next_migration_number}_#{activity}.rb"
+        File.open(filename, 'w') { |migration| migration.write(migration_template(activity, up_code, down_code)) }
+        puts "Wrote #{filename}..."
+      end
+      true
+    end
+    
+    private
+    def migrations_path
+      Rails.root.join(ActiveRecord::Migrator.migrations_path)
+    end
+    
+    # See ActiveRecord::Generators::Migration
+    # Only generating a migration to each second is a problem.. because we generate everything in the same second
+    # So we have to add further "pretend" seconds. This WILL cause problems.
+    # TODO: Patch ActiveRecord to end this nonsense.
+    def next_migration_number #:nodoc:
+      highest = Dir.glob(migrations_path.to_s+"/[0-9]*_*.rb").collect do |file|
+        File.basename(file).split("_").first.to_i
+      end.max
+      
+      if ActiveRecord::Base.timestamped_migrations
+        base = Time.now.utc.strftime("%Y%m%d%H%M%S").to_s
+        (highest.to_i >= base.to_i)? (highest + 1).to_s : base
+      else
+        (highest.to_i + 1).to_s
+      end
+    end
+    
+    def migration_template(activity, up_code, down_code)
+      "class #{activity.camelize.gsub(/\s/, '')} < ActiveRecord::Migration
+  def self.up
+    #{up_code}
+  end
+  
+  def self.down
+    #{down_code}
+  end
+end"
+    end
+  end
+end

data/lib/migrant/model_extensions.rb

@@ -0,0 +1,37 @@
+module Migrant
+  module ModelExtensions
+    attr_accessor :schema
+    def structure(&block)
+      # Using instance_*evil* to get the neater DSL on the models.
+      # So, my_field in the structure block actually calls Migrant::Schema.my_field
+      
+      if self.superclass == ActiveRecord::Base
+        @schema ||= Schema.new
+        @schema.add_associations(self.reflect_on_all_associations)
+        @schema.define_structure(&block)
+      else
+        self.superclass.structure(&block) # For STI, cascade all fields onto the parent model
+        @schema = InheritedSchema.new(self.superclass.schema)
+      end
+    end
+    
+    # Same as defining a structure block, but with no attributes besides
+    # relationships (such as in a many-to-many)
+    def no_structure
+      structure {}
+    end
+    
+    def mock(recursive=true)
+      attribs = @schema.columns.reject { |column| column.is_a?(DataType::ForeignKey)}.collect { |name, data_type| [name, data_type.mock] }.flatten
+      # Only recurse to one level, otherwise things get way too complicated
+      if recursive
+        attribs += self.reflect_on_all_associations(:belongs_to).collect do |association| 
+                    begin
+                      (association.klass.respond_to?(:mock))? [association.name, association.klass.mock(false)] : nil
+                    rescue NameError; nil; end # User hasn't defined association, just skip it
+                   end.compact.flatten
+      end
+      new Hash[*attribs]
+    end
+  end
+end

data/lib/migrant/schema.rb

@@ -0,0 +1,91 @@
+module Migrant
+  # Converts the following DSL:
+  #
+  # class MyModel < ActiveRecord::Base
+  #   structure do
+  #     my_field "some string"
+  #    end
+  # end
+  # into a schema on that model class by calling method_missing(my_field)
+  # and deciding what the best schema type is for the user's requiredments
+  class Schema
+    attr_accessor :indexes, :columns, :methods_to_alias
+
+    def initialize  
+      @columns = Hash.new
+      @indexes = Array.new
+      @methods_to_alias = Array.new
+    end      
+
+    def define_structure(&block)      
+      # Runs method_missing on columns given in the model "structure" DSL
+      self.instance_eval(&block) if block_given?
+    end
+    
+    def add_associations(associations)
+      associations.each do |association|
+        field = association.options[:foreign_key] || (association.name.to_s+'_id').to_sym
+        case association.macro
+          when :belongs_to
+            if association.options[:polymorphic]
+              @columns[(association.name.to_s+'_type').to_sym] = DataType::Polymorphic.new(:field => field)
+              @indexes << [(association.name.to_s+'_type').to_sym, field]
+            end
+            @columns[field] = DataType::ForeignKey.new(:field => field)
+            @indexes << (association.name.to_s+'_id').to_sym
+        end
+      end
+    end
+    
+    def requires_migration?
+      !(@columns.blank? && @indexes.blank?)
+    end
+    
+    def column_migrations
+      @columns.collect {|field, data| [field, data.column] } # All that needs to be migrated
+    end
+    
+    # This is where we decide what the best schema is based on the structure requirements
+    # The output of this is essentially a formatted schema hash that is processed 
+    # on each model by Migrant::MigrationGenerator
+    def method_missing(*args, &block)
+      field = args.slice!(0)
+      data_type = (args.first.nil?)? DataType::String : args.slice!(0)
+      options = args.extract_options!
+
+      # Add index if explicitly asked
+      @indexes << field if options.delete(:index) || data_type.class.to_s == 'Hash' && data_type.delete(:index)
+      options.merge!(:field => field)
+
+      # Matches: description DataType::Paragraph, :index => true
+      if data_type.is_a?(Class) && data_type.respond_to?(:migrant_data_type?)
+        @columns[field] = data_type.new(options)
+      # Matches: description :index => true, :unique => true
+      else
+        begin
+          # Eg. "My field" -> String -> DataType::String
+          @columns[field] = "DataType::#{data_type.class.to_s}".constantize.new(options.merge(:value => data_type))
+        rescue NameError
+          # We don't have a matching type, throw a warning and default to string
+          puts "MIGRATION WARNING: No migration implementation for class #{data_type.class.to_s} on field '#{field}', defaulting to string..."
+          @columns[field] = DataType::Base.new(options)
+        end
+      end
+      puts [":#{field}", "#{@columns[field].class}", "#{options.inspect}"].collect { |s| s.ljust(25) }.join if ENV['DEBUG']
+    end
+  end
+  
+  class InheritedSchema < Schema
+    attr_accessor :parent_schema
+    
+    def initialize(parent_schema)
+      @parent_schema = parent_schema
+      @columns = Array.new
+      @indexes = Array.new
+    end
+    
+    def requires_migration?
+      false # All added to base table
+    end
+  end
+end