datamappify 0.2.2 → 0.9.0

data/lib/datamappify/fake/column.rb

@@ -1,17 +0,0 @@
-require 'active_record/connection_adapters/abstract/schema_definitions'
-
-module Datamappify
-  module Fake
-    class Column < ActiveRecord::ConnectionAdapters::Column
-      def initialize(property)
-        allow_null = property[:options].include?(:null) ? property[:options][:null] : true
-        
-        super(property[:name], property[:options][:default], property[:sql_type], allow_null)
-        
-        @limit     = property[:options][:limit]
-        @precision = property[:options][:precision]
-        @scale     = property[:options][:scale]
-      end
-    end
-  end
-end

data/lib/datamappify/fake/connection.rb

@@ -1,77 +0,0 @@
-module Datamappify
-  module Fake
-    class Connection
-      def columns(table)
-        @primary_key = "id"
-        resource     = get_resource(table)
-        columns      = []
-        
-        # manually add the primary key property (without the :primary_key option)
-        # as ActiveRecord ignores the primary_key column
-        add_primary_key_to(resource) unless is_a_join_table?(table)
-        
-        resource[:properties].map do |property|
-          if (property[:name] == :timestamps)
-            create_timestamps_for(resource)
-          else
-            columns << Column.new(property)
-          end
-        end
-        
-        columns
-      end
-      
-      def primary_key(table)
-        resource = get_resource(table)
-        primary_key_for(resource)
-      end
-      
-      def indexes(table)
-        resource = get_resource(table)
-        resource[:indexes].map do |index|
-          Index.new(resource, index)
-        end
-      end
-      
-      private
-      
-      def get_resource(table)
-        Collection.get.select do |r|
-          r[:table_name].to_s == table.to_s
-        end[0]
-      end
-      
-      def create_timestamps_for(resource)
-        resource[:properties] << {
-          :name     => :created_at,
-          :sql_type => :datetime,
-          :options  => {},
-        }
-        resource[:properties] << {
-          :name     => :updated_at,
-          :sql_type => :datetime,
-          :options  => {},
-        }
-      end
-      
-      def primary_key_for(resource)
-        resource[:properties].select do |property|
-          return property[:name].to_s if property[:options][:primary_key]
-        end
-        "id"
-      end
-      
-      def add_primary_key_to(resource)
-        resource[:properties] << {
-          :name     => primary_key_for(resource),
-          :sql_type => :datetime,
-          :options  => {},
-        }
-      end
-      
-      def is_a_join_table?(table)
-        Associations.join_tables.key?(table)
-      end
-    end
-  end
-end

data/lib/datamappify/fake/index.rb

@@ -1,34 +0,0 @@
-require 'active_record/connection_adapters/abstract/schema_statements'
-
-module Datamappify
-  module Fake
-    class Index
-      include ActiveRecord::ConnectionAdapters::SchemaStatements
-      
-      def initialize(resource, index)
-        @resource = resource
-        @index    = index
-      end
-      
-      def table
-        @resource[:table_name]
-      end
-      
-      def name
-        @index[:options].include?(:name) ? @index[:options][:name].to_s : index_name(table, :column => @index[:columns])
-      end
-      
-      def columns
-        @index[:columns]
-      end
-      
-      def unique
-        @index[:options][:unique] if @index[:options].include?(:unique)
-      end
-      
-      def lengths
-        @index[:options][:length] if @index[:options].include?(:length)
-      end
-    end
-  end
-end

data/lib/datamappify/railtie.rb

@@ -1,10 +0,0 @@
-if defined?(Rails::Railtie)
-  module Datamappify
-    class Railtie < Rails::Railtie
-      rake_tasks do
-        load File.expand_path("../../tasks/datamappify.rake", __FILE__)
-        load File.expand_path("../../../vendor/auto_migrations/lib/tasks/auto_migrations_tasks.rake", __FILE__)
-      end
-    end
-  end
-end

data/lib/datamappify/resource.rb

@@ -1,35 +0,0 @@
-module Datamappify
-  module Resource
-    def self.included(model)
-      model.send :cattr_accessor, :properties
-      model.send :cattr_accessor, :indexes
-      
-      model.extend Resource::ClassMethods
-      model.extend Associations::ClassMethods
-    end
-    
-    module ClassMethods
-      def self.extended(model)
-        @@model = model
-        
-        @@model.properties = []
-        @@model.indexes    = []
-      end
-      
-      def property(name, sql_type=nil, options={})
-        @@model.properties << {
-          :name     => name,
-          :sql_type => sql_type,
-          :options  => options,
-        }
-      end
-      
-      def add_index(columns, options={})
-        @@model.indexes << {
-          :columns => columns,
-          :options => options,
-        }
-      end
-    end
-  end
-end

data/lib/datamappify/schema_dumper.rb

@@ -1,21 +0,0 @@
-module Datamappify
-  class SchemaDumper < ActiveRecord::SchemaDumper
-    def self.dump_to_file
-      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
-        Datamappify::SchemaDumper.dump(ActiveRecord::Base.connection, file)
-      end
-    end
-    
-    def initialize(connection)
-      super(connection)
-      @connection = Datamappify::Fake::Connection.new
-    end
-    
-    def tables(stream)
-      Datamappify::Collection.get.each do |entry|
-        tbl = entry[:table_name] or entry[:resource].pluralize
-        table(tbl, stream)
-      end
-    end
-  end
-end

data/lib/tasks/datamappify.rake

@@ -1,15 +0,0 @@
-namespace :db do
-  namespace :schema do
-    desc "Update schema.rb with Datamappfiy"
-    task :update => :environment do
-      Datamappify::SchemaDumper.dump_to_file
-      Rake::Task["db:schema:update"].reenable
-    end
-    
-    desc "Auto-migrate via schema.rb"
-    task :auto_migrate => :environment do
-      Rake::Task["db:schema:update"].invoke
-      Rake::Task["db:auto:migrate"].invoke
-    end
-  end
-end

data/vendor/auto_migrations/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2007 PJ Hyett
-
-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 OR COPYRIGHT HOLDERS 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/vendor/auto_migrations/README

@@ -1,46 +0,0 @@
-== AutoMigrations
-
-Forget migrations, auto-migrate!
-
-
-== Usage
-
-Write out your schema (or use an existing one)
-
-  $ cat db/schema.rb
-
-  ActiveRecord::Schema.define do
-
-    create_table :posts do |t|
-      t.string   :title
-      t.text     :body
-      t.timestamps
-    end
-  
-  end
-
-  $ rake db:auto:migrate
-
-  Created posts table
-
-...a few days later
-
-  $ cat db/schema.rb
-
-  ActiveRecord::Schema.define do
-
-    create_table :posts do |t|
-      t.string   :title
-      t.text     :content
-      t.timestamps
-    end
-  
-  end
-
-  $ rake db:auto:migrate
-  -- add_column("posts", :content, :text)
-     -> 0.0307s
-  -- remove_column("posts", "body")
-     -> 0.0311s
-
-* PJ Hyett [ pjhyett@gmail.com ]

data/vendor/auto_migrations/Rakefile

@@ -1,24 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the auto_migrations plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the auto_migrations plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  files = ['README', 'LICENSE', 'lib/**/*.rb']
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README" # page to start on
-  rdoc.title = "auto_migrations"
-  rdoc.template = File.exists?(t="/Users/chris/ruby/projects/err/rock/template.rb") ? t : "/var/www/rock/template.rb"
-  rdoc.rdoc_dir = 'doc' # rdoc output folder
-  rdoc.options << '--inline-source'
-end

data/vendor/auto_migrations/init.rb

@@ -1,2 +0,0 @@
-require 'auto_migrations'
-ActiveRecord::Migration.send :include, AutoMigrations

data/vendor/auto_migrations/lib/auto_migrations.rb

@@ -1,178 +0,0 @@
-module AutoMigrations
-  
-  def self.run
-    # Turn off schema_info code for auto-migration
-    class << ActiveRecord::Schema
-      alias :old_define :define
-      attr_accessor :version
-      def define(info={}, &block) @version = Time.now.utc.strftime("%Y%m%d%H%M%S"); instance_eval(&block) end
-    end
-  
-    load(Rails.root.join('db', 'schema.rb'))
-    ActiveRecord::Migration.drop_unused_tables
-    ActiveRecord::Migration.drop_unused_indexes
-    ActiveRecord::Migration.update_schema_version(ActiveRecord::Schema.version) if ActiveRecord::Schema.version
-  
-    class << ActiveRecord::Schema
-      alias :define :old_define
-    end
-  end
-  
-  def self.schema_to_migration(with_reset = false)
-    schema_in = File.read(Rails.root.join("db", "schema.rb"))
-    schema_in.gsub!(/#(.)+\n/, '')
-    schema_in.sub!(/ActiveRecord::Schema.define(.+)do[ ]?\n/, '')
-    schema_in.gsub!(/^/, '  ')
-    schema = "class InitialSchema < ActiveRecord::Migration\n  def self.up\n" 
-    schema += "    # We're resetting the migrations database...\n" +
-              "    drop_table :schema_migrations\n" +
-              "    initialize_schema_migrations_table\n\n" if with_reset
-    schema += schema_in
-    schema << "\n  def self.down\n"
-    schema << (ActiveRecord::Base.connection.tables - %w(schema_info schema_migrations)).map do |table| 
-                "    drop_table :#{table}\n"
-              end.join
-    schema << "  end\nend\n"
-    migration_file = Rails.root.join("db", "migrate", "001_initial_schema.rb")
-    File.open(migration_file, "w") { |f| f << schema }
-    puts "Migration created at db/migrate/001_initial_schema.rb"
-  end
-  
-  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 = [], []
-      alias_method_chain :method_missing, :auto_migration
-    end
-  end
-
-  module ClassMethods
-  
-    def method_missing_with_auto_migration(method, *args, &block)
-      case method
-      when :create_table
-        auto_create_table(method, *args, &block)
-      when :add_index
-        auto_add_index(method, *args, &block)
-      else
-        method_missing_without_auto_migration(method, *args, &block) 
-      end
-    end
-    
-    def auto_create_table(method, *args, &block)
-      table_name = args.shift.to_s    
-      options    = args.pop || {}
-        
-      (self.tables_in_schema ||= []) << table_name
-
-      # Table doesn't exist, create it
-      unless ActiveRecord::Base.connection.tables.include?(table_name)
-        return method_missing_without_auto_migration(method, *[table_name, options], &block)
-      end
-    
-      # Grab database columns
-      fields_in_db = ActiveRecord::Base.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(ActiveRecord::Base.connection)
-      primary_key = options[:primary_key] || "id"
-      table_definition.primary_key(primary_key) unless options[:id] == false
-      yield table_definition
-      fields_in_schema = table_definition.columns.inject({}) do |hash, column|
-        hash[column.name.to_s] = column
-        hash
-      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.to_s if !column.default.nil?
-        options[:null]    = column.null    if !column.null.nil?
-        add_column table_name, column.name, column.type.to_sym, options
-      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]
-        remove_column table_name, column.name
-      end
-      
-      (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
-          change_column table_name, field, new_type, new_attr if changed
-        end
-      end
-    end
-    
-    def auto_add_index(method, *args, &block)      
-      table_name = args.shift.to_s
-      fields     = Array(args.shift).map(&:to_s)
-      options    = args.shift
-
-      index_name = options[:name] if options  
-      index_name ||= ActiveRecord::Base.connection.index_name(table_name, :column => fields)
-
-      (self.indexes_in_schema ||= []) << index_name
-
-      unless ActiveRecord::Base.connection.indexes(table_name).detect { |i| i.name == index_name }
-        method_missing_without_auto_migration(method, *[table_name, fields, options], &block)
-      end
-    end
-  
-    def drop_unused_tables
-      (ActiveRecord::Base.connection.tables - tables_in_schema - %w(schema_info schema_migrations)).each do |table|
-        drop_table table
-      end
-    end
-    
-    def drop_unused_indexes
-      tables_in_schema.each do |table_name|
-        indexes_in_db = ActiveRecord::Base.connection.indexes(table_name).map(&:name)
-        (indexes_in_db - indexes_in_schema & indexes_in_db).each do |index_name|
-          remove_index table_name, :name => index_name
-        end
-      end
-    end
-    
-    def update_schema_version(version)
-      ActiveRecord::Base.connection.update("INSERT INTO schema_migrations VALUES ('#{version}')")
-
-      schema_file = Rails.root.join("db", "schema.rb")
-      schema = File.read(schema_file)
-      schema.sub!(/:version => \d+/, ":version => #{version}")
-      File.open(schema_file, "w") { |f| f << schema }
-    end
-  
-  end
-
-end