mini_record 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 865494ec47990622d36b41ccf2c468bfce175efd
-  data.tar.gz: 1dd728a8022e9d1eda5901348e121ca42249ea41
+  metadata.gz: ee891eba3f9e58c760acce562bd83a6595c4b9ef
+  data.tar.gz: 9aba338c47d2a027e73c4b81347a4f4cf35d0964
 SHA512:
-  metadata.gz: 835e2394dc4c27ee55dacfbf1479da6480100193d1e680292e35dada29d620c569494a316b8c52791d7b4a32716ee4a7e0e1a7940f734b540ea2d50b7ed58c46
-  data.tar.gz: 06f2bc360a0a6a6042365fbb0de94ecaf9cf6fb03731f56d104c9d16749e0b3958690a431622b0fb79bb00145ed25d9e659a50a4e0ecee82a434fdfe4e7fc647
+  metadata.gz: eee2c19a616f355e653d37be8c7a9a913d001c01af3486cde45ca6ba755d35152b872ed803786efdbe6e79730c679dd053bea90e9c648951b66446e82a0013d9
+  data.tar.gz: 90e4353472d858b08a3124e8ac56d265cb4d2a0326583c89375f4ed0dd1c3a6f8019ea82a7782e1e0ca151765741ed4afb0ab9442f99eecdc56a8b3d63cd7dc8

data/.travis.yml

@@ -3,6 +3,7 @@ before_install: 'gem update --system'
 rvm:
   - 1.9.3
   - 2.1.0
+  - 2.1.2
 notifications:
   recipients:
     - info@daddye.it

data/README.md

@@ -1,19 +1,18 @@
 [![Build Status](https://secure.travis-ci.org/DAddYE/mini_record.png)](http://travis-ci.org/DAddYE/mini_record)
 
 
-MiniRecord is a micro extension for our `ActiveRecord` gem.
-With MiniRecord you can add the ability to create columns outside the default `schema.rb`, directly
-in your **model** in a similar way that should know in others projects
-like  DataMapper, MongoMapper or MongoID.
+MiniRecord is a **micro** extension for the `ActiveRecord` gem.
+
+MiniRecord will allow you to create/edit/manage columns, directly in your **model**.
 
-My inspiration come from this handy [project](https://github.com/pjhyett/auto_migrations).
 
 ## Features
 
 * Define columns/properties inside your model
 * Perform migrations automatically
-* Auto upgrade your schema, so if you know what you are doing you don't lose your existing data!
-* Add, Remove, Change Columns; Add, Remove, Change indexes
+* Auto upgrade your schema
+* Add, Remove, Change **columns**
+* Add, Remove, Change **indexes**
 
 ## Instructions
 
@@ -22,7 +21,7 @@ This avoid conflicts.
 
 Add to your `Gemfile`:
 
-``` rb
+```sh
 gem 'mini_record'
 ```
 
@@ -33,53 +32,67 @@ That's all!
 Remember that inside properties you can use all migrations methods,
 see [documentation](http://api.rubyonrails.org/classes/ActiveRecord/Migration.html)
 
-``` rb
+```ruby
 class Post < ActiveRecord::Base
-  col :title_en, :title_jp
-  col :description_en, :description_jp, :as => :text
-  col :permalink, :index => true, :limit => 50
-  col :comments_count, :as => :integer
-  col :category, :as => :references, :index => true
+  field :title_en, :title_jp
+  field :description_en, :description_jp, as: :text
+  field :permalink, index: true, limit: 50
+  field :comments_count, as: :integer
+  field :category, as: :references, index: true
 end
 Post.auto_upgrade!
 ```
 
-If you don't like `col` there are also few aliases: `key, field, property, attribute`
+Instead of `field` you can pick an alias: `key, field, property, col`
 
-Instead of `:as => :my_type` you can use `:type => :my_type`
+If the option `:as` is omitted, minirecord will assume it's a `:string`.
 
-Option `:as` or `:type` if not provided is `:string` by default, you can use all ActiveRecord types:
+Remember that as for `ActiveRecord` you can choose different types:
 
-``` rb
+```ruby
 :primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time,
 :date, :binary, :boolean, :references, :belongs_to, :timestamp
 ```
 
-You can provide others ActiveRecord options like:
+You can also provide other options like:
 
-``` rb
+```ruby
 :limit, :default, :null, :precision, :scale
 
 # example
 class Foo < ActiveRecord::Base
-  col :title, :default => "MyTitle" # :as => :string is by default
-  col :price, :as => :decimal, :scale => 8, :precision => 2
+  field :title, default: "MyTitle" # as: :string is not necessary since is a default
+  field :price, as: :decimal, scale: 8, precision: 2
 end
 ```
 
 See [ActiveRecord::TableDefinition](http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html)
 for more details.
 
-Finally, when you execute `MyModel.auto_upgrade!`, missing columns, indexes and tables will be created on the fly.
-Indexes and columns present in the db but **not** in your model schema will be **deleted*** also in your db.
+### Perform upgrades
+
+Finally, when you execute `MyModel.auto_upgrade!`, missing columns, indexes and tables will be created on the fly. 
+
+Indexes and columns present in the db but **not** in your model schema/definition will be **deleted** also from your db.
 
 ### Single Table Inheritance
 
-MiniRecord as ActiveRecord support STI plus some goodness, see our specs for more details.
+MiniRecord as ActiveRecord support STI:
+
+```ruby
+  class Pet < ActiveRecord::Base; end
+  class Dog < Pet; end
+  class Cat < Pet; end
+  ActiveRecord::Base.auto_upgrade!
+```
+
+When you perform `ActiveRecord::Base.auto_upgrade!`, just **1** table will be created with the `type` column (indexed as well).
 
 ### ActiveRecord Relations
 
-MiniRecord has built-in support of belongs_to, belongs_to polymorphic and habtm relations. Just declaring these in your model will generate the necessary id columns, indexes and join tables
+MiniRecord has built-in support of `belongs_to`, _polymorphic associations_ as well with _habtm_ relations. 
+
+You don't need to do anything in particular, is not even necessary define the field for them since they will be handled automatically.
 
 #### belongs_to
 ```ruby
@@ -87,27 +100,42 @@ class Address < ActiveRecord::Base
   belongs_to :person
 end
 ```
-Will result in a person_id column (you can override with the `foreign_key` option) which is indexed
+Will result in a indexed `person_id` column. You can use a different one using the `foreign_key` option:
+
+```ruby
+belongs_to :person, foreign_key: :person_pk
+```
 
 #### belongs_to with foreign key in database
+
 ```ruby
 class Address < ActiveRecord::Base
   belongs_to :person
-  index :person_id, :foreign => true
+  index :person_id, foreign: true
 end
 ```
-The same as in the previous case, but foreign key will be added to the database with help of [foreigner](https://github.com/matthuhiggins/foreigner) gem.
 
-To remove the key please use :foreign => false
+This is the same example, but foreign key will be added to the database with help of
+[foreigner](https://github.com/matthuhiggins/foreigner) gem.
+
+In this case you have more control (if needed).
+
+To remove the key please use `:foreign => false`
 If you simple remove the index, the foreign key will not be removed.
 
 #### belongs_to (polymorphic)
+
 ```ruby
 class Address < ActiveRecord::Base
-  belongs_to :addressable, :polymorphic => true
+  belongs_to :addressable, polymorphic: true
 end
 ```
-Will result in addressable id and type columns with composite indexes `add_index(:addresses), [:addressable_id, :addressable_type]`
+
+Will create an `addressable_id` and an `addressable_type` column with composite indexes:
+
+```ruby
+add_index(:addresses), [:addressable_id, :addressable_type]
+```
 
 #### habtm
 ```ruby
@@ -115,75 +143,138 @@ class Address < ActiveRecord::Base
   has_and_belongs_to_many :people
 end
 ```
-Will generate a "addresses_people" join table and index the id columns
+
+Will generate a "addresses_people" (aka: join table) with indexes on the id columns
 
 ### Adding a new column
 
 Super easy, open your model and just add it:
 
-``` rb
+```ruby
 class Post < ActiveRecord::Base
-  col :title
-  col :body, :as => :text # <<- this
-  col :permalink, :index => true
-  col :comments_count, :as => :integer
-  col :category, :as => :references, :index => true
+  field :title
+  field :body, as: :text # <<- this
+  field :permalink, index: true
+  field :comments_count, as: :integer
+  field :category, as: :references, index: true
 end
 Post.auto_upgrade!
 ```
 
-So now when you invoke `MyModel.auto_upgrade!` you should see a SQL query like `ALTER TABLE` that mean that your existing
-records are happy and safe.
+So now when you invoke `MyModel.auto_upgrade!` a diff between the old schema an the new one will detect changes and create the new column.
 
 ### Removing a column
 
-It's exactly the same, but the column will be _really_ deleted without affect other columns.
+It's exactly the same as in the previous example.
+
+### Rename columns
+
+Simply adding a `rename_field` declaration and mini_record will do a `connection.rename_column` in the next `auto_upgrade!` but **only** if the db has the old column and not the new column. 
+
+This means that you still need to have a `field` declaration for the new column name so subsequent `MyModel.auto_upgrade!` will not remove the column. 
+
+You are free to leave the `rename_field` declaration in place or you can remove it once the new column exists in the db.
 
-### Change columns
+Moving from:
+```ruby
+class Vehicle < ActiveRecord::Base
+  field :color
+end
+```
+
+To:
+```ruby
+class Vehicle < ActiveRecord::Base
+  rename_field :color, new_name: :body_color
+  field :body_color
+end
+```
+
+Then perhaps later:
+```ruby
+class Vehicle < ActiveRecord::Base
+  rename_field :color, new_name: :body_color
+  rename_field :body_color, new_name: :chassis_color
+  field :chassis_color
+end
+```
+
+### Change the type of columns
+
+Where when you rename a column the task should be _explicit_ changing the type is _implicit_.
+
+This means that if you have
+
+```ruby
+field :total, as: :integer
+```
+
+and later on you'll figure out that you wanted a `float`
+
+```ruby
+field :total, as: :float
+```
+
+Will automatically change the type the the first time you'll invoke `auto_upgrade`.
 
-It's not possible for us know when/what column you have renamed, but we can know if you changed the `type` so
-if you change `t.string :name` to `t.text :name` we are be able to perform an `ALTER TABLE`
 
 ### Add/Remove indexes
 
-In the same ways we manage columns MiniRecord will detect new indexes and indexes that needs to be removed.
+In the same way we manage columns MiniRecord will detect new indexes and indexes that needs to be removed.
+
 So when you perform `MyModel.auto_upgrade!` a SQL command like:
 
-``` SQL
+```SQL
 PRAGMA index_info('index_people_on_name')
 CREATE INDEX "index_people_on_surname" ON "people" ("surname")
 ```
 
-Note that writing it in DSL way you have same options as `add_index` so you are be able to write:
+A quick hint, sometimes index gets too verbose/long:
 
-``` rb
+```ruby
 class Fox < ActiveRecord::Base
-  col :foo, :index => true
-  col :foo, :index => :custom_name
-  col :foo, :index => [:foo, :bar]
-  col :foo, :index => { :column => [:branch_id, :party_id], :unique => true, :name => 'by_branch_party' }
+  field :foo, index: true
+  field :foo, index: :custom_name
+  field :foo, index: [:foo, :bar]
+  field :foo, index: { column: [:branch_id, :party_id], unique: true, name: 'by_branch_party' }
 end
 ```
 
-That is the same of:
+Here is where `add_index` comes handy, so you can rewrite the above in:
 
-``` rb
+```ruby
 class Fox < ActiveRecord::Base
-  col :foo
+  field :foo
   add_index :foo
   add_index :custom_name
   add_index [:foo, :bar]
-  add_index [:branch_id, :party_id], :unique => true, :name => 'by_branch_party'
+  add_index [:branch_id, :party_id], unique: true, name: 'by_branch_party'
 end
 ```
 
+## Contributors
+
+A special thanks to all who have contributed in this project:
+
+* Dmitriy Partsyrniy
+* Steven Garcia
+* Carlo Bertini
+* Nate Wiger
+* Dan Watson
+* Guy Boertje
+* virtax
+* Nagy Bence
+* Takeshi Yabe
+* blahutka
+* 4r2r
+
 ## Author
 
 DAddYE, you can follow me on twitter [@daddye](http://twitter.com/daddye) or take a look at my site [daddye.it](http://www.daddye.it)
 
 ## Copyright
 
-Copyright (C) 2011 Davide D'Agostino - [@daddye](http://twitter.com/daddye)
+Copyright (C) 2011-2014 Davide D'Agostino - [@daddye](http://twitter.com/daddye)
 
 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
@@ -195,4 +286,4 @@ The above copyright notice and this permission notice shall be included in all c
 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 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.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/mini_record/auto_schema.rb

@@ -52,11 +52,9 @@ module MiniRecord
       end
 
       def get_sql_field_type(field)
-        if field.respond_to?(:sql_type)
-          # Rails 3.2 and earlier
+        if ActiveRecord::VERSION::MAJOR.to_i < 4
           field.sql_type.to_s.downcase
         else
-          # Rails 4
           connection.type_to_sql(field.type.to_sym, field.limit, field.precision, field.scale)
         end
       end
@@ -261,7 +259,7 @@ module MiniRecord
             field inheritance_column, :as => :string unless fields.key?(inheritance_column.to_s)
             index inheritance_column
           end
-          
+
           # Rename fields
           rename_fields.each do |old_name, new_name|
             old_column = fields_in_db[old_name.to_s]
@@ -292,24 +290,8 @@ module MiniRecord
           (fields.keys & fields_in_db.keys).each do |field|
             if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
               changed  = false  # flag
-              new_type = fields[field].type.to_sym
               new_attr = {}
 
-              # First, check if the field type changed
-              old_sql_type = get_sql_field_type(fields_in_db[field])
-              new_sql_type = get_sql_field_type(fields[field])
-
-              # Strip off the "(10,0)", from "decimal(10,0)" - we re-check this below.
-              # This is all a bit hacky but different versions of Rails act differently.
-              old_base_type = old_sql_type.sub(/\(.*/,'')
-              new_base_type = new_sql_type.sub(/\(.*/,'')
-
-              if old_sql_type != new_sql_type and old_base_type != new_base_type
-                logger.debug "[MiniRecord] Detected schema change for #{table_name}.#{field}#type " +
-                             " from #{old_sql_type.inspect} to #{new_sql_type.inspect}" if logger
-                changed = true
-              end
-
               # 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]
@@ -339,6 +321,7 @@ module MiniRecord
               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
@@ -346,14 +329,16 @@ module MiniRecord
           remove_foreign_keys if connection.respond_to?(:foreign_keys)
 
           # Remove old index
-          (indexes_in_db.keys - indexes.keys).each do |name|
+          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
-            unless connection.indexes(table_name).detect { |i| i.name == name }
+            index_name = options[:name] || name
+            unless connection.indexes(table_name).detect { |i| i.name == index_name }
               connection.add_index(table_name, options.delete(:column), options)
             end
           end

data/lib/mini_record/version.rb

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

data/mini_record.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "mini_record"
   s.version     = MiniRecord::VERSION
   s.authors     = ["Davide D'Agostino"]
-  s.email       = ["d.dagostino@lipsiasoft.com"]
+  s.email       = ["info@daddye.it"]
   s.homepage    = "https://github.com/DAddYE/mini_record"
   s.summary     = %q{MiniRecord is a micro gem that allow you to write schema inside your model as you can do in DataMapper.}
   s.description = %q{

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_record
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Davide D'Agostino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-24 00:00:00.000000000 Z
+date: 2014-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,7 +28,7 @@ description: "\nWith it you can add the ability to create columns outside the de
   schema, directly\nin your model in a similar way that you just know in others projects\nlike
   \ DataMapper or  MongoMapper.\n  "
 email:
-- d.dagostino@lipsiasoft.com
+- info@daddye.it
 executables: []
 extensions: []
 extra_rdoc_files: []