mini_record 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee891eba3f9e58c760acce562bd83a6595c4b9ef
-  data.tar.gz: 9aba338c47d2a027e73c4b81347a4f4cf35d0964
+  metadata.gz: 09d1ec6c447a806ef8ecc9c33e51c52404ccc948
+  data.tar.gz: 23f2145d50bfc6b57bd3517af5312b9ca57d04fa
 SHA512:
-  metadata.gz: eee2c19a616f355e653d37be8c7a9a913d001c01af3486cde45ca6ba755d35152b872ed803786efdbe6e79730c679dd053bea90e9c648951b66446e82a0013d9
-  data.tar.gz: 90e4353472d858b08a3124e8ac56d265cb4d2a0326583c89375f4ed0dd1c3a6f8019ea82a7782e1e0ca151765741ed4afb0ab9442f99eecdc56a8b3d63cd7dc8
+  metadata.gz: b0a1daa513f1d05437be824e33672092e79b699848678dbafc9c743904694aa83c079caa20d770862311e39bf6ab82f0b7bcc78af9bb72b33d7aac847e18c2ad
+  data.tar.gz: ba06f494683ca8028b95985cc2ee9a7735b25d01d497f5fb6d47f92fc065881b17312f058a0b947777d128e5d091c9a529249f9c094453f422453225d365f28b

data/README.md

@@ -25,6 +25,14 @@ Add to your `Gemfile`:
 gem 'mini_record'
 ```
 
+To optionally block any destructive actions on the database, create a file `config/initializers/mini_record.rb` and add:
+
+```ruby
+MiniRecord.configure do |config|
+  config.destructive = false
+end
+```
+
 That's all!
 
 ## Examples

data/lib/mini_record/auto_schema.rb

@@ -3,7 +3,7 @@ module MiniRecord
     def self.included(base)
       base.extend(ClassMethods)
     end
-
+    
     module ClassMethods
       def init_table_definition(connection)
         #connection.create_table(table_name) unless connection.table_exists?(table_name)
@@ -23,7 +23,7 @@ module MiniRecord
             "Unsupported number of args for ActiveRecord::ConnectionAdapters::TableDefinition.new()"
         end
       end
-
+      
       def schema_tables
         @@_schema_tables ||= []
       end
@@ -158,6 +158,7 @@ module MiniRecord
       end
 
       def clear_tables!
+        return unless MiniRecord.configuration.destructive == true 
         (connection.tables - schema_tables).each do |name|
           connection.drop_table(name)
           schema_tables.delete(name)
@@ -172,6 +173,7 @@ module MiniRecord
 
       # Remove foreign keys for indexes with :foreign=>false option
       def remove_foreign_keys
+        return unless MiniRecord.configuration.destructive == true 
         indexes.each do |name, options|
           if options[:foreign]==false
             foreign_key = foreign_keys.detect { |fk| fk.options[:column] == options[:column].to_s }
@@ -260,20 +262,73 @@ module MiniRecord
             index inheritance_column
           end
 
-          # Rename fields
-          rename_fields.each do |old_name, new_name|
-            old_column = fields_in_db[old_name.to_s]
-            new_column = fields_in_db[new_name.to_s]
-            if old_column && !new_column
-              connection.rename_column(table_name, old_column.name, new_name)
+          # Group Destructive Actions
+          if MiniRecord.configuration.destructive == true 
+            
+            # Rename fields
+            rename_fields.each do |old_name, new_name|
+              old_column = fields_in_db[old_name.to_s]
+              new_column = fields_in_db[new_name.to_s]
+              if old_column && !new_column
+                connection.rename_column(table_name, old_column.name, new_name)
+              end
             end
-          end
+            
+            # Remove fields from db no longer in schema
+            columns_to_delete = fields_in_db.keys - fields.keys & fields_in_db.keys
+            columns_to_delete.each do |field|
+              column = fields_in_db[field]
+              connection.remove_column table_name, column.name
+            end
+            
+            # Change attributes of existent columns
+            (fields.keys & fields_in_db.keys).each do |field|
+              if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
+                changed  = false  # flag
+                new_attr = {}
+
+                # Special catch for precision/scale, since *both* must be specified together
+                # Always include them in the attr struct, but they'll only get applied if changed = true
+                new_attr[:precision] = fields[field][:precision]
+                new_attr[:scale]     = fields[field][:scale]
+
+                # If we have precision this is also the limit
+                fields[field][:limit] ||= fields[field][:precision]
+
+                # Next, iterate through our extended attributes, looking for any differences
+                # This catches stuff like :null, :precision, etc
+                # Ignore junk attributes that different versions of Rails include
+                [:name, :limit, :precision, :scale, :default, :null].each do |att|
+                  value = fields[field][att]
+                  value = true if att == :null && value.nil?
+
+                  # Skip unspecified limit/precision/scale as DB will set them to defaults,
+                  # and on subsequent runs, this will be erroneously detected as a change.
+                  next if value.nil? and [:limit, :precision, :scale].include?(att)
+
+                  old_value = fields_in_db[field].send(att)
+                  if value != old_value
+                    logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}##{att} " +
+                                 "from #{old_value.inspect} to #{value.inspect}" if logger
+                    new_attr[att] = value
+                    changed = true
+                  end
+                end
+
+                # Change the column if applicable
+                new_type = fields[field].type.to_sym
+                connection.change_column table_name, field, new_type, new_attr if changed
+              end
+            end
+            
+            remove_foreign_keys if connection.respond_to?(:foreign_keys)
 
-          # Remove fields from db no longer in schema
-          columns_to_delete = fields_in_db.keys - fields.keys & fields_in_db.keys
-          columns_to_delete.each do |field|
-            column = fields_in_db[field]
-            connection.remove_column table_name, column.name
+            # Remove old index
+            index_names = indexes.collect{|name,opts| opts[:name] || name }
+            (indexes_in_db.keys - index_names).each do |name|
+              connection.remove_index(table_name, :name => name)
+            end
+            
           end
 
           # Add fields to db new to schema
@@ -286,54 +341,6 @@ module MiniRecord
             connection.add_column table_name, column.name, column.type.to_sym, options
           end
 
-          # Change attributes of existent columns
-          (fields.keys & fields_in_db.keys).each do |field|
-            if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
-              changed  = false  # flag
-              new_attr = {}
-
-              # Special catch for precision/scale, since *both* must be specified together
-              # Always include them in the attr struct, but they'll only get applied if changed = true
-              new_attr[:precision] = fields[field][:precision]
-              new_attr[:scale]     = fields[field][:scale]
-
-              # If we have precision this is also the limit
-              fields[field][:limit] ||= fields[field][:precision]
-
-              # Next, iterate through our extended attributes, looking for any differences
-              # This catches stuff like :null, :precision, etc
-              # Ignore junk attributes that different versions of Rails include
-              [:name, :limit, :precision, :scale, :default, :null].each do |att|
-                value = fields[field][att]
-                value = true if att == :null && value.nil?
-
-                # Skip unspecified limit/precision/scale as DB will set them to defaults,
-                # and on subsequent runs, this will be erroneously detected as a change.
-                next if value.nil? and [:limit, :precision, :scale].include?(att)
-
-                old_value = fields_in_db[field].send(att)
-                if value != old_value
-                  logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}##{att} " +
-                               "from #{old_value.inspect} to #{value.inspect}" if logger
-                  new_attr[att] = value
-                  changed = true
-                end
-              end
-
-              # Change the column if applicable
-              new_type = fields[field].type.to_sym
-              connection.change_column table_name, field, new_type, new_attr if changed
-            end
-          end
-
-          remove_foreign_keys if connection.respond_to?(:foreign_keys)
-
-          # Remove old index
-          index_names = indexes.collect{|name,opts| opts[:name] || name }
-          (indexes_in_db.keys - index_names).each do |name|
-            connection.remove_index(table_name, :name => name)
-          end
-
           # Add indexes
           indexes.each do |name, options|
             options = options.dup

data/lib/mini_record/configuration.rb

@@ -0,0 +1,22 @@
+module MiniRecord
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.reset_configuration!
+    self.configuration = Configuration.new
+  end
+  
+  class Configuration
+    attr_accessor :destructive
+
+    def initialize
+      @destructive = true
+    end
+  end
+end

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/mini_record.rb

@@ -1,5 +1,8 @@
 require 'rubygems' unless defined?(Gem)
 require 'active_record'
+require 'mini_record/configuration'
 require 'mini_record/auto_schema'
 
+MiniRecord.configure do |config|
+end
 ActiveRecord::Base.send(:include, MiniRecord::AutoSchema)

data/test/test_mini_record.rb

@@ -11,6 +11,7 @@ describe MiniRecord do
     ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
     load File.expand_path('../models.rb', __FILE__)
     ActiveRecord::Base.auto_upgrade!
+    MiniRecord.reset_configuration!
   end
 
   it 'has #schema inside model' do
@@ -264,6 +265,31 @@ describe MiniRecord do
       refute_includes Foo.db_columns, 'image_id'
       assert_empty Foo.db_indexes
     end
+    
+    it 'doesnt remove a column and index when relation is removed and destructive is false' do
+      MiniRecord.configuration.destructive = false
+      class Foo < ActiveRecord::Base
+        key :name
+        belongs_to :image, :polymorphic => true
+      end
+      Foo.auto_upgrade!
+      assert_includes Foo.db_columns, 'name'
+      assert_includes Foo.db_columns, 'image_type'
+      assert_includes Foo.db_columns, 'image_id'
+      assert_includes Foo.db_indexes, 'index_foos_on_image_id_and_image_type'
+
+      Foo.class_eval do
+        reset_table_definition!
+        reflections.clear
+        indexes.clear
+        key :name
+      end
+      Foo.auto_upgrade!
+      assert_includes Foo.db_columns, 'name'
+      assert_includes Foo.db_columns, 'image_type'
+      assert_includes Foo.db_columns, 'image_id'
+      assert_includes Foo.db_indexes, 'index_foos_on_image_id_and_image_type'
+    end
 
     it 'creates columns and index based on polymorphic relation' do
       Attachment.create(:name => 'Avatar', :attachable_id => 1, :attachable_type => 'Post')
@@ -363,6 +389,32 @@ describe MiniRecord do
 
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
     end
+    
+    it 'doesnt remove foreign key with :foreign option, when Foreigner gem used on mysql and destructive = false' do
+      MiniRecord.configuration.destructive = false
+      skip unless conn.adapter_name =~ /mysql/i
+
+      class Book < ActiveRecord::Base
+        belongs_to :publisher
+        index :publisher_id, :foreign => true
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'publisher_id'
+      assert_includes Book.db_indexes, 'index_books_on_publisher_id'
+
+      assert connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
+
+      Object.send(:remove_const, :Book)
+      class Book < ActiveRecord::Base
+        belongs_to :publisher
+         index :publisher_id, :foreign => false
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'publisher_id'
+      assert_includes Book.db_indexes, 'index_books_on_publisher_id'
+    end
 
     it 'add/remove named foreign key with :foreign option, when Foreigner gem used on mysql' do
       skip unless conn.adapter_name =~ /mysql/i
@@ -388,6 +440,33 @@ describe MiniRecord do
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
       Object.send(:remove_const, :Book)
     end
+    
+    it 'doesnt remove named foreign key with :foreign option, when Foreigner gem used on mysql and destructive = false' do
+      MiniRecord.configuration.destructive = false
+      skip unless conn.adapter_name =~ /mysql/i
+
+      class Book < ActiveRecord::Base
+        belongs_to :publisher
+        index :publisher_id, :name => 'my_super_publisher_id_fk', :foreign => true
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'publisher_id'
+      assert_includes Book.db_indexes, 'my_super_publisher_id_fk'
+
+      assert connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'publisher_id'}
+
+      Object.send(:remove_const, :Book)
+      class Book < ActiveRecord::Base
+        belongs_to :publisher
+        index :publisher_id, :name => 'my_super_publisher_id_fk', :foreign => false
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'publisher_id'
+      assert_includes Book.db_indexes, 'my_super_publisher_id_fk'
+      Object.send(:remove_const, :Book)
+    end
 
     it 'support :foreign option in the index with custom :foreign_key in the belong_to association' do
       skip unless conn.adapter_name =~ /mysql/i
@@ -412,6 +491,32 @@ describe MiniRecord do
 
       assert_nil connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'second_publisher_id'}
     end
+    
+    it 'support :foreign option in the index with custom :foreign_key in the belong_to association and wont remove if destructive = false' do
+      MiniRecord.configuration.destructive = false
+      skip unless conn.adapter_name =~ /mysql/i
+
+      class Book < ActiveRecord::Base
+        belongs_to :second_publisher, :foreign_key => 'second_publisher_id', :class_name => 'Publisher'
+        index :second_publisher_id, :foreign => true
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'second_publisher_id'
+      assert_includes Book.db_indexes, 'index_books_on_second_publisher_id'
+
+      assert connection.foreign_keys(:books).detect {|fk| fk.options[:column] == 'second_publisher_id'}
+
+      Object.send(:remove_const, :Book)
+      class Book < ActiveRecord::Base
+        belongs_to :second_publisher, :foreign_key => 'second_publisher_id', :class_name => 'Publisher'
+        index :second_publisher_id, :foreign => false
+      end
+      Book.auto_upgrade!
+
+      assert_includes Book.db_columns, 'second_publisher_id'
+      assert_includes Book.db_indexes, 'index_books_on_second_publisher_id'
+    end
 
   end
 
@@ -436,6 +541,19 @@ describe MiniRecord do
       ActiveRecord::Base.clear_tables!
       refute_includes Tool.connection.tables, 'purposes_tools'
     end
+    
+    it 'keeps join table if has_and_belongs_to_many relation is deleted and destructive = false' do
+      MiniRecord.configuration.destructive = false
+      
+      tables = Tool.connection.tables
+      assert_includes tables, 'purposes_tools'
+      
+      Tool.schema_tables.delete('purposes_tools')
+      refute_includes ActiveRecord::Base.schema_tables, 'purposes_tools'
+
+      ActiveRecord::Base.clear_tables!
+      assert_includes Tool.connection.tables, 'purposes_tools'
+    end
 
     it 'has_and_belongs_to_many with custom join_table and foreign keys' do
       class Foo < ActiveRecord::Base
@@ -534,6 +652,47 @@ describe MiniRecord do
     refute_empty Foo.queries
     assert_equal 255, Foo.db_fields[:string].limit
   end
+  
+  it 'should not change #limit if destructive = false' do
+    MiniRecord.configuration.destructive = false
+    class Foo < ActiveRecord::Base
+      key :number, :as => :integer
+      key :string, :limit => 100
+    end
+    Foo.auto_upgrade!
+    assert_match /CREATE TABLE/, Foo.queries
+
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+
+    # According to this:
+    # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L476-487
+    Foo.key :number, :as => :integer, :limit => 4
+    Foo.auto_upgrade!
+    case conn.adapter_name
+    when /sqlite/i
+      # In sqlite there is a difference between limit: 4 and limit: 11
+      assert_match Foo.queries, "" 
+      assert_equal nil, Foo.db_fields[:number].limit
+      assert_equal 4, Foo.schema_fields[:number].limit
+    when /mysql/i
+      # In mysql according to this: http://goo.gl/bjZE7 limit: 4 is same of limit:11
+      assert_empty Foo.queries
+      assert_equal nil, Foo.db_fields[:number].limit
+      assert_equal 4, Foo.schema_fields[:number].limit
+    when /postgres/i
+      # In postgres limit: 4 will be translated to nil
+      assert_match Foo.queries, ""
+      assert_equal nil, Foo.db_fields[:number].limit
+      assert_equal 4, Foo.schema_fields[:number].limit
+    end
+
+    # Change limit to string
+    Foo.key :string, :limit => 255
+    Foo.auto_upgrade!
+    assert_empty Foo.queries
+    assert_equal 100, Foo.db_fields[:string].limit
+  end
 
   it 'should change #null' do
     class Foo < ActiveRecord::Base
@@ -558,6 +717,31 @@ describe MiniRecord do
     assert_match /alter/i, Foo.queries
     refute Foo.db_fields[:string].null
   end
+  
+  it 'should not change #null if destructive = false' do
+    MiniRecord.configuration.destructive = false
+    class Foo < ActiveRecord::Base
+      key :string
+    end
+    Foo.auto_upgrade!
+    assert Foo.db_fields[:string].null
+
+    # Same as above
+    Foo.key :string, :null => true
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+    assert Foo.db_fields[:string].null
+
+    Foo.key :string, :null => nil
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+    assert Foo.db_fields[:string].null
+
+    Foo.key :string, :null => false
+    Foo.auto_upgrade!
+    assert_match "", Foo.queries
+    assert Foo.db_fields[:string].null
+  end
 
   it 'should change #scale #precision' do
     class Foo < ActiveRecord::Base
@@ -578,6 +762,27 @@ describe MiniRecord do
     assert_equal 2, Foo.db_fields[:currency].scale
     assert_equal 4, Foo.db_fields[:currency].limit
   end
+  
+  it 'should not change #scale #precision if destructive = false' do
+    MiniRecord.configuration.destructive = false
+    class Foo < ActiveRecord::Base
+      field :currency, :as => :decimal, :precision => 8, :scale => 2
+    end
+    Foo.auto_upgrade!
+    assert_equal 8, Foo.db_fields[:currency].precision
+    assert_equal 2, Foo.db_fields[:currency].scale
+    assert_equal 8, Foo.db_fields[:currency].limit
+
+    Foo.auto_upgrade!
+    refute_match /alter/i, Foo.queries
+
+    Foo.field :currency, :as => :decimal, :precision => 4, :scale => 2, :limit => 5
+    Foo.auto_upgrade!
+    assert_match "", Foo.queries
+    assert_equal 8, Foo.db_fields[:currency].precision
+    assert_equal 2, Foo.db_fields[:currency].scale
+    assert_equal 8, Foo.db_fields[:currency].limit
+  end
 
   it 'should ignore abstract classes' do
     class Foo < ActiveRecord::Base
@@ -649,4 +854,37 @@ describe MiniRecord do
     assert_match '', Foo.queries
 
   end
+  
+  it 'should note rename a column specified by rename_field if destructive = false' do
+    MiniRecord.configuration.destructive = false
+    class Foo < ActiveRecord::Base
+      field :currency, :limit => 3
+    end
+    Foo.auto_upgrade!
+    assert_match /CREATE TABLE/, Foo.queries
+    
+    Foo.create :currency => 'USD'
+
+    Foo.rename_field :currency, :new_name => :currency_iso
+    Foo.field :currency_iso, :limit => 3
+
+    Foo.auto_upgrade!
+
+    case conn.adapter_name
+    when /sqlite/i
+      assert_match "", Foo.queries
+    when /mysql/i
+      assert_match "", Foo.queries
+    when /postgres/i
+      assert_match "", Foo.queries
+    end
+
+    cols = conn.columns('foos').map(&:name)
+    assert_includes cols, "currency_iso"
+    assert_includes cols, "currency"
+
+    Foo.auto_upgrade!
+    assert_match '', Foo.queries
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_record
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Davide D'Agostino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2014-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -40,6 +40,7 @@ files:
 - Rakefile
 - lib/mini_record.rb
 - lib/mini_record/auto_schema.rb
+- lib/mini_record/configuration.rb
 - lib/mini_record/version.rb
 - mini_record.gemspec
 - test/helper.rb