mini_record-cj 0.3.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27896303273b7579110fcaca700f5ad8573606f6
+  data.tar.gz: 411456a93af4970469f7f7d7d4f5d9012518016a
+SHA512:
+  metadata.gz: 6d6ae3f5c75e2041ad1787ca7ff2a4b0d69b46133c46c3a12b7fee9608f05a9c6e6f6bffb298adc29ce85abd4e8f5b7a16a395d21f7c42d77e7ee52e7c29034b
+  data.tar.gz: 4ee3159eee1475baa6764fc7e4f9781208222b94ca1f05a384255f40735a9e3d0542b690876d062f1346281217590a0051c46fc4b0a02c3814e3d1bb679ab9e8

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+*.swp
+*.swo

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+before_install: 'gem update --system'
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-18mode
+  - rbx
+  - ree
+notifications:
+  recipients:
+    - info@daddye.it

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mini_record.gemspec
+gem 'rake'
+gem 'minitest'
+gem 'sqlite3'
+gem 'mysql2'
+gem 'mysql'
+gem 'pg'
+gem 'activerecord', '<= 3.2'
+
+group :test do
+  gem 'foreigner', '>= 1.4.2'
+end
+
+gemspec

data/README.md

@@ -0,0 +1,198 @@
+[![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.
+
+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
+
+## Instructions
+
+What you need is to move/remove your `db/schema.rb`.
+This avoid conflicts.
+
+Add to your `Gemfile`:
+
+``` rb
+gem 'mini_record'
+```
+
+That's all!
+
+## Examples
+
+Remember that inside properties you can use all migrations methods,
+see [documentation](http://api.rubyonrails.org/classes/ActiveRecord/Migration.html)
+
+``` rb
+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
+end
+Post.auto_upgrade!
+```
+
+If you don't like `col` there are also few aliases: `key, field, property, attribute`
+
+Instead of `:as => :my_type` you can use `:type => :my_type`
+
+Option `:as` or `:type` if not provided is `:string` by default, you can use all ActiveRecord types:
+
+``` rb
+:primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time,
+:date, :binary, :boolean, :references, :belongs_to, :timestamp
+```
+
+You can provide others ActiveRecord options like:
+
+``` rb
+: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
+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.
+
+### Single Table Inheritance
+
+MiniRecord as ActiveRecord support STI plus some goodness, see our specs for more details.
+
+### 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
+
+#### belongs_to
+```ruby
+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
+
+#### belongs_to with foreign key in database
+```ruby
+class Address < ActiveRecord::Base
+  belongs_to :person
+  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
+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
+end
+```
+Will result in addressable id and type columns with composite indexes `add_index(:addresses), [:addressable_id, :addressable_type]`
+
+#### habtm
+```ruby
+class Address < ActiveRecord::Base
+  has_and_belongs_to_many :people
+end
+```
+Will generate a "addresses_people" join table and index the id columns
+
+### Adding a new column
+
+Super easy, open your model and just add it:
+
+``` rb
+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
+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.
+
+### Removing a column
+
+It's exactly the same, but the column will be _really_ deleted without affect other columns.
+
+### 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`
+
+### Add/Remove indexes
+
+In the same ways 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
+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:
+
+``` rb
+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' }
+end
+```
+
+That is the same of:
+
+``` rb
+class Fox < ActiveRecord::Base
+  col :foo
+  add_index :foo
+  add_index :custom_name
+  add_index [:foo, :bar]
+  add_index [:branch_id, :party_id], :unique => true, :name => 'by_branch_party'
+end
+```
+
+## 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)
+
+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 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/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
+
+%w(install release).each do |task|
+  Rake::Task[task].enhance do
+    sh "rm -rf pkg"
+  end
+end
+
+desc "Bump version on github"
+task :bump do
+  if `git status -s`.strip == ""
+    puts "\e[31mNothing to commit (working directory clean)\e[0m"
+  else
+    version  = Bundler.load_gemspec(Dir[File.expand_path('../*.gemspec', __FILE__)].first).version
+    sh "git add .; git commit -a -m \"Bump to version #{version}\""
+  end
+end
+
+task :release => :bump
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/test_*.rb']
+  test.verbose = true
+end
+
+task :default => :test
+task :spec    => :test

data/lib/mini_record.rb

@@ -0,0 +1,5 @@
+require 'rubygems' unless defined?(Gem)
+require 'active_record'
+require 'mini_record/auto_schema'
+
+ActiveRecord::Base.send(:include, MiniRecord::AutoSchema)

data/lib/mini_record/auto_schema.rb

@@ -0,0 +1,364 @@
+module MiniRecord
+  module AutoSchema
+    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)
+
+        case ActiveRecord::ConnectionAdapters::TableDefinition.instance_method(:initialize).arity
+        when 1
+          # Rails 3.2 and earlier
+          ActiveRecord::ConnectionAdapters::TableDefinition.new(connection)
+        when 4, -5
+          # Rails 4
+          ActiveRecord::ConnectionAdapters::TableDefinition.new(connection.native_database_types, table_name, false, {})
+        else
+          raise ArgumentError,
+            "Unsupported number of args for ActiveRecord::ConnectionAdapters::TableDefinition.new()"
+        end
+
+      end
+
+      def schema_tables
+        @@_schema_tables ||= []
+      end
+
+      def table_definition
+        return superclass.table_definition unless (superclass == ActiveRecord::Base) || (superclass.respond_to?(:abstract_class?) && superclass.abstract_class?)
+
+        @_table_definition ||= begin
+          tb = init_table_definition(connection)
+          tb.primary_key(primary_key)
+          tb
+        end
+      end
+
+      def indexes
+        return superclass.indexes unless (superclass == ActiveRecord::Base) || (superclass.respond_to?(:abstract_class?) && superclass.abstract_class?)
+
+        @_indexes ||= {}
+      end
+
+      def indexes_in_db
+        connection.indexes(table_name).inject({}) do |hash, index|
+          hash[index.name] = index
+          hash
+        end
+      end
+
+      def get_sql_field_type(field)
+        if field.respond_to?(:sql_type)
+          # Rails 3.2 and earlier
+          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
+
+      def fields
+        table_definition.columns.inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+      end
+
+      def fields_in_db
+        connection.columns(table_name).inject({}) do |hash, column|
+          hash[column.name] = column
+          hash
+        end
+      end
+
+      def columns_hash
+        if mini_record_fake_columns
+          super.merge mini_record_fake_columns
+        else
+          super
+        end
+      end
+
+      def mini_record_columns
+        @@_mr_columns ||= {}
+        @@_mr_columns[table_name] ||= {}
+      end
+
+      def mini_record_fake_columns
+        @@_mr_fake_columns ||= {}
+        @@_mr_fake_columns[table_name] ||= {}
+      end
+
+      def field(*args)
+        return unless connection?
+
+        options    = args.extract_options!
+        type       = options.delete(:as) || options.delete(:type) || :string
+        index      = options.delete(:index)
+        fake       = options.delete(:fake) || false
+
+        args.each do |column_name|
+          # add it it the mini record columns for this table so we can access
+          # special fields like input_as, used by form builders
+          mini_record_columns[column_name] = options
+
+          if fake
+            # allow you to access the field on the instance object
+            attr_accessor column_name
+            # create a column that column_hashes will understand (a fake row)
+            fake_column = ActiveRecord::ConnectionAdapters::Column.new(
+              column_name.to_s, nil, type, true
+            )
+            # add it to the list of fake columns for this table
+            mini_record_fake_columns[column_name.to_s] = fake_column
+            # skip everything else as it's a fake column and don't want it in the db
+            next
+          end
+
+          # Allow custom types like:
+          #   t.column :type, "ENUM('EMPLOYEE','CLIENT','SUPERUSER','DEVELOPER')"
+          if type.is_a?(String)
+            # will be converted in: t.column :type, "ENUM('EMPLOYEE','CLIENT')"
+            table_definition.column(column_name, type, options.reverse_merge(:limit => 0))
+          else
+            # wil be converted in: t.string :name
+            table_definition.send(type, column_name, options)
+          end
+
+          # Get the correct column_name i.e. in field :category, :as => :references
+          column_name = table_definition.columns[-1].name
+
+          # Parse indexes
+          case index
+          when Hash
+            add_index(options.delete(:column) || column_name, index)
+          when TrueClass
+            add_index(column_name)
+          when String, Symbol, Array
+            add_index(index)
+          end
+        end
+      end
+      alias :key       :field
+      alias :property  :field
+      alias :col       :field
+
+      def timestamps
+        field :created_at, :updated_at, :as => :datetime, :null => false
+      end
+
+      def reset_table_definition!
+        @_table_definition = nil
+      end
+      alias :reset_schema! :reset_table_definition!
+
+      def schema
+        reset_table_definition!
+        yield table_definition
+        table_definition
+      end
+
+      def add_index(column_name, options={})
+        index_name = connection.index_name(table_name, :column => column_name)
+        indexes[index_name] = options.merge(:column => column_name) unless indexes.key?(index_name)
+        index_name
+      end
+      alias :index :add_index
+
+      def connection?
+        !!connection
+      rescue Exception => e
+        puts "\e[31m%s\e[0m" % e.message.strip
+        false
+      end
+
+      def clear_tables!
+        (connection.tables - schema_tables).each do |name|
+          connection.drop_table(name)
+          schema_tables.delete(name)
+        end
+      end
+
+      def foreign_keys
+        # fk cache to minimize quantity of sql queries
+        @foreign_keys ||= {}
+        @foreign_keys[:table_name] ||= connection.foreign_keys(table_name)
+      end
+
+      # Remove foreign keys for indexes with :foreign=>false option
+      def remove_foreign_keys
+        indexes.each do |name, options|
+          if options[:foreign]==false
+            foreign_key = foreign_keys.detect { |fk| fk.options[:column] == options[:column].to_s }
+            if foreign_key
+              connection.remove_foreign_key(table_name, :name => foreign_key.options[:name])
+              foreign_keys.delete(foreign_key)
+            end
+          end
+        end
+      end
+
+      # Add foreign keys for indexes with :foreign=>true option, if the key doesn't exists
+      def add_foreign_keys
+        indexes.each do |name, options|
+          if options[:foreign]
+            column = options[:column].to_s
+            unless foreign_keys.detect { |fk| fk[:options][:column] == column }
+              to_table = reflect_on_all_associations.detect { |a| a.foreign_key.to_s==column }.table_name
+              connection.add_foreign_key(table_name, to_table, options)
+              foreign_keys << { :options=> { :column=>column } }
+            end
+          end
+        end
+      end
+
+      def auto_upgrade!
+        return unless connection?
+        return if respond_to?(:abstract_class?) && abstract_class?
+
+        if self == ActiveRecord::Base
+          descendants.each(&:auto_upgrade!)
+          clear_tables!
+        else
+          # If table doesn't exist, create it
+          unless connection.tables.include?(table_name)
+            # TODO: 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 = init_table_definition(connection)
+          end
+
+          # Add this to our schema tables
+          schema_tables << table_name unless schema_tables.include?(table_name)
+
+          # Generate fields from associations
+          if reflect_on_all_associations.any?
+            reflect_on_all_associations.each do |association|
+              foreign_key = association.options[:foreign_key] || "#{association.name}_id"
+              type_key    = "#{association.name.to_s}_type"
+              case association.macro
+              when :belongs_to
+                field foreign_key, :as => :integer unless fields.key?(foreign_key.to_s)
+                if association.options[:polymorphic]
+                  field type_key, :as => :string unless fields.key?(type_key.to_s)
+                  index [foreign_key, type_key]
+                else
+                  index foreign_key
+                end
+              when :has_and_belongs_to_many
+                table = if name = association.options[:join_table]
+                          name.to_s
+                        else
+                          [table_name, association.name.to_s].sort.join("_")
+                        end
+                unless connection.tables.include?(table.to_s)
+                  foreign_key             = association.options[:foreign_key] || association.foreign_key
+                  association_foreign_key = association.options[:association_foreign_key] || association.association_foreign_key
+                  connection.create_table(table, :id => false) do |t|
+                    t.integer foreign_key
+                    t.integer association_foreign_key
+                  end
+                  index_name = connection.index_name(table, :column => [foreign_key, association_foreign_key])
+                  index_name = index_name[0...connection.index_name_length] if index_name.length > connection.index_name_length
+                  connection.add_index table, [foreign_key, association_foreign_key], :name => index_name, :unique => true
+                end
+                # Add join table to our schema tables
+                schema_tables << table unless schema_tables.include?(table)
+              end
+            end
+          end
+
+          # Add to schema inheritance column if necessary
+          if descendants.present?
+            field inheritance_column, :as => :string unless fields.key?(inheritance_column.to_s)
+            index inheritance_column
+          end
+
+          # Remove fields from db no longer in schema
+          (fields_in_db.keys - fields.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.keys - fields_in_db.keys).each do |field|
+            column  = fields[field]
+            options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
+            options[:default] = column.default unless column.default.nil?
+            options[:null]    = column.null    unless column.null.nil?
+            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_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])
+
+              if old_sql_type != new_sql_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]
+              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
+              fields[field].each_pair do |att,value|
+                next unless [:name, :limit, :precision, :scale, :default, :null].include?(att)
+                value = true if att == :null && value.nil?
+                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
+              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
+          (indexes_in_db.keys - indexes.keys).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 }
+              connection.add_index(table_name, options.delete(:column), options)
+            end
+          end
+
+          add_foreign_keys if connection.respond_to?(:foreign_keys)
+
+          # Reload column information
+          reset_column_information
+        end
+      end
+    end # ClassMethods
+  end # AutoSchema
+end # MiniRecord