mini_record 0.0.1 → 0.1.0

data/README.md

@@ -1,9 +1,9 @@
-MiniRecord is micro extension for our `ActiveRecord` gem.
+MiniRecord is a micro extension for our `ActiveRecord` gem.
 With it you can add the ability to create columns outside the default schema, directly
 in your **model** in a similar way that you just know in others projects
 like  DataMapper or  MongoMapper.
 
-My inspiration come from this handy [project](https://github.com/pjhyett/auto_migrations)
+My inspiration come from this handy [project](https://github.com/pjhyett/auto_migrations).
 
 ## Features
 
@@ -38,14 +38,33 @@ class Person < ActiveRecord::Base
   end
   belongs_to :address
 end
+Person.auto_upgrade!
 
+# you can use also this way
 class Address < ActiveRecord::Base
-  schema, :id => true do |s| # id => true is not really necessary but as
-    s.string  :city          # in +create_table+ you have here the same options
-    s.string  :state
-    s.integer :number
-  end
+  key.string  :city
+  key.string  :state
+  key.integer :number
+  has_many :people
 end
+
+# or this
+class Address < ActiveRecord::Base
+  col.string  :city
+  col.string  :state
+  col.integer :number
+  has_many :people
+end
+
+# or this
+class Address < ActiveRecord::Base
+  property.string  :city
+  property.string  :state
+  property.integer :number
+  has_many :people
+end
+
+Address.auto_upgrade!
 ```
 
 Once you bootstrap your **app**, missing columns and tables will be created on the fly.
@@ -63,6 +82,14 @@ class Person < ActiveRecord::Base
   end
   belongs_to :address
 end
+
+# or if you use others ways
+class Person < ActiveRecord::Base
+  col.string  :name
+  col.string  :surname # <<- this
+  col.integer :address_id
+  belongs_to :address
+end
 ```
 
 So now when you start your **webserver** you can see an `ALTER TABLE` statement, this mean that your existing
@@ -72,21 +99,12 @@ records are happy and safe.
 
 It's exactly the same, but the column will be _really_ deleted without affect other columns.
 
-### Changing a column
+### Change columns
 
 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`
 
-### Drop unused tables/indexes
-
-You can do it by hand but if yours are lazy like mine you can simply invoke:
-
-``` rb
-ActiveRecord::Base.drop_unused_tables
-ActiveRecord::Base.drop_unused_indexes
-```
-
-# Warning
+## Warnings
 
 This software is not yet tested in a production project, now is only heavy development and if you can
 pleas fork it, find bug add a spec and then come back with a pull request. Thanks!

data/lib/mini_record/auto_schema.rb

@@ -1,19 +1,103 @@
-require 'mini_record/auto_migrations'
-
 module MiniRecord
   module AutoSchema
     def self.included(base)
       base.extend(ClassMethods)
-      base.send(:include, MiniRecord::AutoMigrations)
     end
 
     module ClassMethods
-      def schema(options={}, &block)
-        auto_create_table(table_name, options, &block)
-        reset_column_information
+      def table_definition
+        @_table_definition ||= begin
+          tb = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+          tb.primary_key(primary_key)
+        end
+      end
+      alias :col :table_definition
+      alias :key :table_definition
+      alias :property :table_definition
+
+      def reset_table_definition!
+        @_table_definition = nil
+      end
+
+      def schema
+        reset_table_definition!
+        yield table_definition
       end
       alias :keys :schema
       alias :properties :schema
-    end
+
+      def auto_upgrade!
+        # Table doesn't exist, create it
+        unless connection.tables.include?(table_name)
+          # TODO: Add to create_table options
+          class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
+          connection.table_definition = table_definition
+          connection.create_table(table_name)
+          connection.table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+        end
+
+        # Grab database columns
+        fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+
+        # Grab new schema
+        fields_in_schema = table_definition.columns.inject({}) do |hash, column|
+          hash[column.name.to_s] = column
+          hash
+        end
+
+        # Remove fields from db no longer in schema
+        (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
+          column = fields_in_db[field]
+          connection.remove_column table_name, column.name
+        end
+
+        # Add fields to db new to schema
+        (fields_in_schema.keys - fields_in_db.keys).each do |field|
+          column  = fields_in_schema[field]
+          options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
+          options[:default] = column.default if !column.default.nil?
+          options[:null]    = column.null    if !column.null.nil?
+          connection.add_column table_name, column.name, column.type.to_sym, options
+        end
+
+        # Change attributes of existent columns
+        (fields_in_schema.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_in_schema[field].type.to_sym
+            new_attr = {}
+
+            # First, check if the field type changed
+            if fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym
+              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_in_schema[field][:precision]
+            new_attr[:scale]     = fields_in_schema[field][:scale]
+
+            # Next, iterate through our extended attributes, looking for any differences
+            # This catches stuff like :null, :precision, etc
+            fields_in_schema[field].each_pair do |att,value|
+              next if att == :type or att == :base or att == :name # special cases
+              if !value.nil? && value != fields_in_db[field].send(att)
+                new_attr[att] = value
+                changed = true
+              end
+            end
+
+            # Change the column if applicable
+            connection.change_column table_name, field, new_type, new_attr if changed
+          end
+        end
+
+        # Reload column information
+        reset_column_information
+      end
+    end # ClassMethods
   end # AutoSchema
 end # MiniRecord

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/mini_record_spec.rb

@@ -1,13 +1,16 @@
 require File.expand_path('../spec_helper.rb', __FILE__)
-require File.expand_path('../fake_model.rb', __FILE__)
+require File.expand_path('../models.rb', __FILE__)
 
 describe MiniRecord do
 
-  it 'works correctly' do
+  it 'has #schema inside model' do
     # For unknown reason separate specs doesn't works
+    ActiveRecord::Base.connection.table_exists?(Person.table_name).must_equal false
+    Person.auto_upgrade!
     Person.table_name.must_equal 'people'
-    Person.db_columns.must_equal %w[id name]
+    Person.db_columns.sort.must_equal %w[id name]
     Person.column_names.must_equal Person.db_columns
+    Person.column_names.must_equal Person.schema_columns
     person = Person.create(:name => 'foo')
     person.name.must_equal 'foo'
     proc { person.surname }.must_raise NoMethodError
@@ -19,12 +22,13 @@ describe MiniRecord do
         p.string :surname
       end
     end
+    Person.auto_upgrade!
     Person.count.must_equal 1
     person = Person.last
     person.name.must_equal 'foo'
     person.surname.must_be_nil
     person.update_attribute(:surname, 'bar')
-    Person.db_columns.must_equal %w[id name surname]
+    Person.db_columns.sort.must_equal %w[id name surname]
     Person.column_names.must_equal Person.db_columns
 
     # Remove a column without lost data
@@ -33,11 +37,13 @@ describe MiniRecord do
         p.string :name
       end
     end
+    Person.auto_upgrade!
     person = Person.last
     person.name.must_equal 'foo'
     proc { person.surname }.must_raise NoMethodError
-    Person.db_columns.must_equal %w[id name]
+    Person.db_columns.sort.must_equal %w[id name]
     Person.column_names.must_equal Person.db_columns
+    Person.column_names.must_equal Person.schema_columns
 
     # Change column without lost data
     Person.class_eval do
@@ -49,9 +55,30 @@ describe MiniRecord do
     person.name.must_equal 'foo'
   end
 
-  it 'should remove no tables, since Person is still defined' do
-    ActiveRecord::Base.drop_unused_tables
-    ActiveRecord::Base.connection.tables.must_equal %w[people]
-    Person.count.must_equal 1
+  it 'has #key,col,property inside model' do
+    ActiveRecord::Base.connection.table_exists?(Post.table_name).must_equal false
+    ActiveRecord::Base.connection.table_exists?(Category.table_name).must_equal false
+    Post.auto_upgrade!; Category.auto_upgrade!
+    Post.column_names.must_equal Post.db_columns
+    Category.column_names.must_equal Category.schema_columns
+
+    # Check default properties
+    category = Category.create(:title => 'category')
+    post = Post.create(:title => 'foo', :body => 'bar', :category_id => category.id)
+    post = Post.first
+    post.title.must_equal 'foo'
+    post.body.must_equal 'bar'
+    post.category.must_equal category
+
+    # Remove a column
+    Post.reset_table_definition!
+    Post.class_eval do
+      key.string :name
+      key.references :category
+    end
+    Post.auto_upgrade!
+    post = Post.first
+    post.name.must_be_nil
+    post.category.must_equal category
   end
 end

data/spec/models.rb

@@ -0,0 +1,44 @@
+require 'logger'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+# ActiveRecord::Base.connection.tables.each { |t| ActiveRecord::Base.connection.drop_table(t) }
+# ActiveRecord::Base.logger = Logger.new($stdout)
+
+module SpecHelper
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def db_columns
+      connection.columns(table_name).map(&:name)
+    end
+
+    def schema_columns
+      table_definition.columns.map { |c| c.name.to_s }
+    end
+  end
+end
+
+class Person < ActiveRecord::Base
+  include SpecHelper
+  schema do |s|
+    s.string :name
+  end
+end
+
+class Post < ActiveRecord::Base
+  include SpecHelper
+
+  key.string :title
+  key.string :body
+  key.references :category
+  belongs_to :category
+end
+
+class Category < ActiveRecord::Base
+  include SpecHelper
+
+  key.string :title
+  has_many :posts
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mini_record
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Davide D'Agostino
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-05 00:00:00 +02:00
+date: 2011-09-06 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,13 +52,12 @@ files:
 - README.md
 - Rakefile
 - lib/mini_record.rb
-- lib/mini_record/auto_migrations.rb
 - lib/mini_record/auto_schema.rb
 - lib/mini_record/version.rb
 - mini_record.gemspec
 - rakefile.compiled.rbc
-- spec/fake_model.rb
 - spec/mini_record_spec.rb
+- spec/models.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: https://github.com/DAddYE/mini_record
@@ -95,6 +94,6 @@ signing_key:
 specification_version: 3
 summary: MiniRecord is a micro gem that allow you to write schema inside your model as you can do in DataMapper.
 test_files: 
-- spec/fake_model.rb
 - spec/mini_record_spec.rb
+- spec/models.rb
 - spec/spec_helper.rb

data/lib/mini_record/auto_migrations.rb

@@ -1,108 +0,0 @@
-require 'active_support/core_ext/class/attribute_accessors'
-
-module MiniRecord
-
-  module AutoMigrations
-    def self.included(base)
-      base.extend ClassMethods
-      class << base
-        cattr_accessor :tables_in_schema, :indexes_in_schema
-        self.tables_in_schema, self.indexes_in_schema = [], []
-      end
-    end
-
-    module ClassMethods
-      def auto_create_table(table_name, options, &block)
-
-        (self.tables_in_schema ||= []) << table_name
-
-        # Table doesn't exist, create it
-        unless connection.tables.include?(table_name)
-          return connection.create_table(table_name, options, &block)
-        end
-
-        # Grab database columns
-        fields_in_db = connection.columns(table_name).inject({}) do |hash, column|
-          hash[column.name] = column
-          hash
-        end
-
-        # Grab schema columns (lifted from active_record/connection_adapters/abstract/schema_statements.rb)
-        table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
-        primary_key = options[:primary_key] || "id"
-        table_definition.primary_key(primary_key) unless options[:id] == false
-
-        # Return the table definition
-        yield table_definition
-
-        # Grab new schema
-        fields_in_schema = table_definition.columns.inject({}) do |hash, column|
-          hash[column.name.to_s] = column
-          hash
-        end
-
-        # Remove fields from db no longer in schema
-        (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
-          column = fields_in_db[field]
-          connection.remove_column table_name, column.name
-        end
-
-        # Add fields to db new to schema
-        (fields_in_schema.keys - fields_in_db.keys).each do |field|
-          column  = fields_in_schema[field]
-          options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
-          options[:default] = column.default if !column.default.nil?
-          options[:null]    = column.null    if !column.null.nil?
-          connection.add_column table_name, column.name, column.type.to_sym, options
-        end
-
-        # Change attributes of existent columns
-        (fields_in_schema.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_in_schema[field].type.to_sym
-            new_attr = {}
-
-            # First, check if the field type changed
-            if fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym
-              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_in_schema[field][:precision]
-            new_attr[:scale]     = fields_in_schema[field][:scale]
-
-            # Next, iterate through our extended attributes, looking for any differences
-            # This catches stuff like :null, :precision, etc
-            fields_in_schema[field].each_pair do |att,value|
-              next if att == :type or att == :base or att == :name # special cases
-              if !value.nil? && value != fields_in_db[field].send(att)
-                new_attr[att] = value
-                changed = true
-              end
-            end
-
-            # Change the column if applicable
-            connection.change_column table_name, field, new_type, new_attr if changed
-          end
-        end
-      end
-
-      def drop_unused_tables
-        (connection.tables - tables_in_schema - %w(schema_info schema_migrations)).each do |table|
-          connection.drop_table table
-        end
-      end
-
-      def drop_unused_indexes
-        tables_in_schema.each do |table_name|
-          indexes_in_db = connection.indexes(table_name).map(&:name)
-          (indexes_in_db - indexes_in_schema & indexes_in_db).each do |index_name|
-            connection.remove_index table_name, :name => index_name
-          end
-        end
-      end
-    end # ClassMethods
-  end # Migrations
-end # ActiveKey

data/spec/fake_model.rb

@@ -1,21 +0,0 @@
-require 'logger'
-
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-# ActiveRecord::Base.connection.tables.each { |t| ActiveRecord::Base.connection.drop_table(t) }
-# ActiveRecord::Base.logger = Logger.new($stdout)
-
-class Person < ActiveRecord::Base
-  schema do |s|
-    s.string :name
-  end
-
-  # Testing purpose
-  def self.db_columns
-    connection.columns(table_name).map(&:name)
-  end
-
-  def self.schema_columns
-    table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
-    table_definition.columns.map(&:name)
-  end
-end