automigration 0.2.2 → 1.0.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -1,9 +1,7 @@
 language: ruby
 rvm:
   - 1.9.3
-before_script:
-  - psql -c 'create database automigration_test;' -U postgres
 env:
   - "PG_USER=postgres"
 script:
-  - bundle exec rake test
+  - bundle exec rake db:prepare && bundle exec rspec

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+
+## Automigration 1.0.0 (March 23, 2012)
+
+* Clean API
+
+## Automigration 0.2.2 (March 19, 2012)
+
+* Remove db:auto rake task, enhance db:migrate instead
+
+## Automigration 0.2.1 (March 18, 2012)
+
+* First public release

data/README.md

@@ -1,24 +1,50 @@
 # ActiveRecord automigrations
 
-[<img src="https://secure.travis-ci.org/boshie/automigration.png"/>](http://travis-ci.org/boshie/automigration)
-[<img src="https://gemnasium.com/boshie/automigration.png"/>](http://gemnasium.com/boshie/automigration)
+Create/modify/delete Active Record columns without migrations. It works only with PostgreSQL.
+
+## Installation
+
+```
+gem 'automigration'
+```
 
+## Usage
 
-## Overview
+Add <tt>has_fields</tt> into your models:
 
 ``` ruby
 class User < ActiveRecord::Base
-  # attributes created via migration
-  migration_attr :secure_password, :auth_token
-  migration_attr :salt
-
-  has_fields do |f|
-    f.string :name
-    f.integer :login_count
+  has_fields do
+    string :name
+    integer :login_count
   end
 end
 ```
 
+Fire in console:
+
+``
+rake db:migrate
+```
+
+To keep some system tables add to <tt>config/application.rb</tt>
+
+```
+  config.automigration.system_tables << %w[hits very_system_table]
+```
+
+Supported fields:
+
+* belongs_to
+* boolean
+* date
+* datetime
+* float
+* integer
+* string
+* text
+* time
+
 ## Devise support
 
 ActiveRecord::Base supports all types of devise fields with prefix devise\_
@@ -27,11 +53,11 @@ ActiveRecord::Base supports all types of devise fields with prefix devise\_
 class User < ActiveRecord::Base
   devise :database_authenticatable, :rememberable, :trackable, :validatable, :recoverable
 
-  has_fields do |t|
-    t.devise_database_authenticatable :null => false
-    t.devise_rememberable
-    t.devise_trackable
-    t.devise_recoverable
+  has_fields do
+    devise_database_authenticatable :null => false
+    devise_rememberable
+    devise_trackable
+    devise_recoverable
   end
 end
 ```
@@ -41,12 +67,7 @@ end
 By default in models with has_fields always columns updated_at and created_at created. To ignore 
 use has_fields(:timestamps => false)
 
-## Changelog
+## Status
 
-### Automigration 0.2.2 (March 19, 2012)
-
-* Remove db:auto rake task, enhance db:migrate instead
-
-### Automigration 0.2.1 (March 18, 2012)
-
-* First public release
+[<img src="https://secure.travis-ci.org/boshie/automigration.png"/>](http://travis-ci.org/boshie/automigration)
+[<img src="https://gemnasium.com/boshie/automigration.png"/>](http://gemnasium.com/boshie/automigration)

data/Rakefile

@@ -1,18 +1,16 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
 
-Rake::TestTask.new :test do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = true
-end
+require "rubygems"
+require "bundler/setup"
+require 'rspec/core/rake_task'
 
 namespace :db do
-  desc 'Recreate test db'
-  task :prepare do
-    `dropdb automigration_test`
-    `createdb automigration_test`
+  desc "prepare db for specs"
+  task "prepare" do
+    system "cd spec/dummy && bundle exec rake db:drop"
+    system "cd spec/dummy && bundle exec rake db:create db:migrate db:test:prepare"
   end
 end
 
+RSpec::Core::RakeTask.new(:spec)

data/automigration.gemspec

@@ -20,5 +20,9 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'rails', '~> 3.1'
   s.add_dependency 'ansi'
+
   s.add_development_dependency 'pg'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'factory_girl_rails'
 end

data/lib/automigration.rb

@@ -1,42 +1,9 @@
-require 'rails/engine'
 require 'ansi'
 require 'automigration/version'
+require 'automigration/engine'
 require 'automigration/migrator'
-require 'automigration/fields/sys/base'
-require 'automigration/fields/belongs_to'
-require 'automigration/fields/boolean'
-require 'automigration/fields/date'
-require 'automigration/fields/datetime'
-require 'automigration/fields/float'
-require 'automigration/fields/integer'
-require 'automigration/fields/password'
-require 'automigration/fields/string'
-require 'automigration/fields/text'
-require 'automigration/fields/time'
-require 'automigration/fields/sys/db_column'
-require 'automigration/fields/sys/keeper'
-require 'automigration/fields/sys/slice_creater'
+require 'automigration/field'
+require 'automigration/db_column'
+require 'automigration/fields_keeper'
+require 'automigration/dsl'
 
-module Automigration
-  class Engine < ::Rails::Engine
-    config.automigration = ActiveSupport::OrderedOptions.new
-    config.automigration.system_tables = []
-    config.automigration.models_load_path = []
-    config.automigration.models_to_ignore = []
-    config.automigration.migrations_path = nil
-
-    initializer 'automigration' do |app|
-      app.config.automigration.models_load_path << Rails.root + 'app/models'
-      app.config.automigration.migrations_path = Rails.root + 'db/migrate'
-
-      ActiveSupport.on_load(:active_record) do
-        require 'automigration/base_extention'
-      end
-
-      Migrator.set_models_load_path(app.config.automigration.models_load_path)
-      Migrator.set_models_to_ignore(app.config.automigration.models_to_ignore)
-      Migrator.set_system_tables(app.config.automigration.system_tables)
-      Migrator.set_migrations_path(app.config.automigration.migrations_path)
-    end
-  end
-end

data/lib/automigration/active_record_ext.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class Base
+    class_attribute :__fields_keeper
+    self.__fields_keeper = nil
+
+    def self.__fields_keeper_instance
+      self.__fields_keeper ||= ::Automigration::FieldsKeeper.new(self)
+    end
+
+    class << self
+      delegate :has_fields, :add_field, :migration_attr, :to => :__fields_keeper_instance
+      delegate :auto_migrable?, :migration_attrs, :to => :__fields_keeper_instance
+      delegate :field_db_columns, :to => :__fields_keeper_instance
+      delegate :fields, :field_names, :to => :__fields_keeper_instance
+    end
+  end
+end

data/lib/automigration/db_column.rb

@@ -0,0 +1,32 @@
+module Automigration
+  class DbColumn < Struct.new(:name, :type, :options)
+    def initialize(name_, type_, options_)
+      super
+      options_.assert_valid_keys(:default, :null, :limit, :scale, :precision)
+    end
+
+    def self.from_activerecord_column(column)
+      out = DbColumn.new(column.name.to_sym, column.type.to_sym, {
+        :default => column.default,
+        :null => column.null,
+        :limit => column.limit,
+        :scale => column.scale,
+        :precision => column.precision
+      })
+    end
+
+    def the_same?(other)
+      (__to_array <=> other.send(:__to_array)) == 0
+    end
+
+    def to_options
+      options.reject{|k, v| v.nil?}
+    end
+
+    private
+    # compare only by 3 values
+    def __to_array
+      [name.to_s, type.to_s, options[:default].to_s]
+    end
+  end
+end

data/lib/automigration/dsl.rb

@@ -0,0 +1,29 @@
+module Automigration
+  class Dsl
+    attr_reader :fields
+    attr_reader :devise_fields
+
+    def initialize
+      @fields = []
+      @devise_fields = []
+    end
+
+    Field::KIND.each do |field|
+      define_method field do |*args|
+        options = args.extract_options!
+        raise "wrong amount of args" unless args.size == 1
+        name = args[0]
+        @fields << {:name => name, :as => field.to_sym}.merge(options)
+        Field.valid_options_keys(@fields.last)
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^devise_(.*)/
+        @devise_fields << {:as => meth, :args => args}
+      else
+        super
+      end
+    end
+  end
+end

data/lib/automigration/engine.rb

@@ -0,0 +1,23 @@
+require 'rails/engine'
+
+module Automigration
+  class Engine < ::Rails::Engine
+    config.automigration = ActiveSupport::OrderedOptions.new
+    config.automigration.system_tables = []
+    config.automigration.migration_paths = []
+    config.automigration.model_paths = []
+
+    initializer 'automigration' do |app|
+      app.config.automigration.migration_paths << Rails.root + 'db/migrate'
+      app.config.automigration.model_paths << Rails.root + 'app/models'
+
+      ActiveSupport.on_load(:active_record) do
+        require 'automigration/active_record_ext'
+      end
+
+      Migrator.set_system_tables(app.config.automigration.system_tables)
+      Migrator.set_migration_paths(app.config.automigration.migration_paths)
+      Migrator.set_model_paths(app.config.automigration.model_paths)
+    end
+  end
+end

data/lib/automigration/field.rb

@@ -0,0 +1,75 @@
+module Automigration
+  module Field
+    KIND = %w[
+      belongs_to
+      boolean
+      date
+      datetime
+      float
+      integer
+      string
+      text
+      time
+    ]
+
+    def self.to_db_columns(field) 
+      type = field[:as]
+
+      if type == :belongs_to
+        name = "#{field[:name]}_id"
+        column_type = :integer
+      else
+        name = field[:name]
+        column_type = type
+      end
+
+      if type == :boolean
+        default = !!field[:default]
+      else
+        default = field[:default]
+      end
+      
+      Automigration::DbColumn.new(name, column_type, {
+        :default => default,
+        :null => field[:null], 
+        :limit => field[:limit], 
+        :scale => field[:scale], 
+        :precision => field[:precision]
+      })
+    end
+
+    def self.valid_options_keys(field)
+      valid_keys = [
+        :name, :as,                                  # system attributes
+        :default, :null, :limit, :scale, :precision, # db columns keys
+        :accessible                                  # mark attribute as accessible
+      ]
+
+      type = field[:as]
+
+      if type == :belongs_to
+        valid_keys += [:class_name, :inverse_of]
+      end
+
+      field.assert_valid_keys(*valid_keys)
+    end
+
+    def self.extend_model!(model, field)
+      type = field[:as]
+      name = field[:name]
+      accessible = (field[:accessible] == nil) || field[:accessible]
+      
+      if type == :belongs_to
+        model.belongs_to name, :class_name => field[:class_name], :inverse_of => field[:inverse_of]
+
+        if accessible
+          model.attr_accessible "#{name}_id"
+        end
+      end
+
+      if accessible
+        model.attr_accessible name
+      end
+    end
+  end
+end

data/lib/automigration/fields_keeper.rb

@@ -0,0 +1,85 @@
+module Automigration
+  class FieldsKeeper
+    attr_reader :fields
+    attr_reader :migration_attrs
+
+    def initialize(model)
+      @model = model
+      @fields = nil
+      @devise_fields = []
+      @migration_attrs = []
+      @timestamps_added = false
+
+      @fields_lookup = {}
+    end
+
+    def has_fields(options = {}, &block)
+      options.assert_valid_keys(:timestamps)
+      options.reverse_merge!(:timestamps => true)
+
+      dsl = Automigration::Dsl.new
+      block.arity == 1 ?  block.call(dsl) : dsl.instance_exec(&block)
+
+      dsl.fields.each do |field|
+        Field.extend_model!(@model, field)
+      end
+
+      @fields ||= []
+      @fields += dsl.fields
+      @devise_fields = dsl.devise_fields
+
+      if !@timestamps_added && options[:timestamps]
+        @timestamps_added = true
+        @fields << {:as => :datetime, :name => :created_at, :accessible => false}
+        @fields << {:as => :datetime, :name => :updated_at, :accessible => false}
+      end
+    end
+
+    def add_field(type, name, options = {})
+      has_fields(:timestamps => false) do |f|
+        f.send type, name, options
+      end
+    end
+
+    def migration_attr(*args)
+      @migration_attrs += args.flatten.map(&:to_s)
+    end
+
+    def auto_migrable?
+      @fields.present?
+    end
+
+    def field_names
+      @field_names ||= fields.map{|f| f[:name]}
+    end
+
+    def field_db_columns
+      out = []
+
+      out += @fields.map do |field|
+        Field.to_db_columns(field)
+      end.flatten
+
+      if defined?(Devise::Schema)
+        devise_schema = Class.new do
+          include Devise::Schema
+
+          define_method :apply_devise_schema do |*args|
+            opts = args.extract_options!
+            raise "wrong arguments" unless args.size == 2
+            name = args[0]
+            as = args[1].to_s.underscore.to_sym
+            as = :datetime if as == :date_time
+            out << Automigration::DbColumn.new(name, as, opts)
+          end
+        end.new
+
+        @devise_fields.each do |meta|
+          devise_schema.send(meta[:as].to_s.sub(/^devise_/, ''), *meta[:args])
+        end
+      end
+
+      out
+    end
+  end
+end