data_plan 1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Pavel Vasev
+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/README

@@ -0,0 +1,57 @@
+== Data Plan
+
+A tool for easy migration generation. Works with Sinatra/ActiveRecord and with Rails too.
+
+== Usage
+
+Before use in Sinatra, install 'sinatra-activerecord' gem. 
+It extends Sinatra with extension methods and Rake tasks for dealing with an SQL database using the ActiveRecord ORM.
+Follow it's instructions and create a Rakefile with migration commands.
+After that you can invoke 'rake db:create_migration' and get migrations.
+
+And then, magic begins. 
+* Add to Rakefile:
+require 'data_plan/generators/migration/sinatra'
+* Create db/plan.rb file and describe desired db schema in it.
+
+Now, when you create a migration, DataPlan will generate a new migration and put all differencies 
+between plan.rb and your current database schema! You can migrate immediately, or add some
+more tweaks to your migration, or something else.
+
+Why is it great? Because you don't need to remember all that syntax like
+change_column, add_column, etc - you just modify your schema (in the plan.rb).
+
+Nice bonus: migrations are automatically named (of course you may override name suggested).
+
+== How to use with Rails
+Copy from the gem the folder 
+GEMROOT/lib/data_plan/generators/migration/* 
+to the Rails project as follows:
+YOURAPPROOT/lib/generators/migration/*
+Thats it, Data Plan now in your rails app, and you can invoke 'script/generate migration' 
+and get migrations auto-generated as described above.
+
+== How to install
+
+gem install data_plan
+
+== Todo
+
+Indices are partially supported at the moment.
+
+== Changelog
+
+Workaround on views. Thanks to Cyril Boswell.
+
+== Legal
+
+Found a bug? Fix it and email pull request to me: pavel.vasev@gmail.com
+
+Want to add a feature? Implement it and email the patch!
+
+Pavel Vasev [ pavel.vasev@gmail.com ]
+
+
+Released under the MIT license (included)
+
+p.s. Schema-Definition plugin is hugely based on Auto-Migrations by PJ Hyett [ pjhyett@gmail.com ]

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/data_plan/generators/migration/lib/auto_migrations.rb

@@ -0,0 +1,216 @@
+module AutoMigrations
+  
+  def self.run
+    # Turn off schema_info code for auto-migration
+    class << ActiveRecord::Schema
+      alias :old_define :define
+      def define(info={}, &block) instance_eval(&block) end
+    end
+  
+    load(File.join(DB_PROJECT_ROOT, 'db', 'plan.rb'))
+    ActiveRecord::Migration.drop_unused_tables
+    ActiveRecord::Migration.drop_unused_views
+    ActiveRecord::Migration.drop_unused_indexes
+  
+    class << ActiveRecord::Schema
+      alias :define :old_define
+    end
+  end
+  
+  def self.schema_to_migration
+    schema = File.read(File.join(DB_PROJECT_ROOT, "db", "plan.rb")) rescue begin
+      puts "Please copy your schema.rb file to plan.rb before generating migrations!"
+      raise
+    end
+    schema.gsub!(/#(.)+\n/, '')
+    schema.sub!(/ActiveRecord::Schema.define(.+)do[ ]?\n/, '')
+    schema.gsub!(/^/, '  ')
+    schema = "class InitialSchema < ActiveRecord::Migration\n  def self.up\n" + schema
+    schema << "\n  def self.down\n"
+    schema << (ActiveRecord::Base.connection.tables - ["schema_info"]).map do |table| 
+                "    drop_table :#{table}\n"
+              end.join
+    schema << "  end\nend\n"
+    migration_file = File.join(DB_PROJECT_ROOT, "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, :views_in_schema
+      self.tables_in_schema, self.indexes_in_schema, self.views_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 :create_view
+        auto_create_view(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)
+      table_definition.primary_key(options[:primary_key] || "id") 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]
+        add_column table_name, column.name, column.type.to_sym, :limit => column.limit, :precision => column.precision, 
+          :scale => column.scale, :default => column.default, :null => column.null
+      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
+      
+      # Change field type if schema is different from db
+      (fields_in_schema.keys & fields_in_db.keys).each do |field|
+        # TYPE
+        if (field != 'id') && (fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym)
+          change_column table_name, fields_in_schema[field].name.to_sym, fields_in_schema[field].type.to_sym
+        end
+        # DEFAULT VALUE
+        if (field != 'id') && (fields_in_schema[field].default != fields_in_db[field].default)
+          change_column_default table_name, fields_in_schema[field].name.to_sym, fields_in_schema[field].default
+        end
+      end
+    end
+
+    def auto_create_view(method, *args, &block)
+      # we are working on it with Cyril Boswell
+      return true
+      # so when we'll find an idea, we'll remove this return true.
+      view_name = args.shift.to_s    
+      select_query = args.pop
+      options    = args.pop || {}
+
+      (self.views_in_schema ||= []) << view_name
+
+      # View doesn't exist, create it
+      unless ActiveRecord::Base.connection.views.include?(view_name)
+        return method_missing_without_auto_migration(method, *[view_name, options], &block)
+      end
+
+      # Grab database view select
+      db_select = ActiveRecord::Base.connection.view_select_statement( view_name )
+    
+      # Grab database columns
+      fields_in_db = ActiveRecord::Base.connection.columns(view_name).inject({}) do |hash, column|
+        hash[column.name] = column
+        hash
+      end
+    
+      # Grab schema columns (lifted from active_record/connection_adapters/abstract/schema_statements.rb)
+      view_definition = RailsSqlViews::ConnectionAdapters::ViewDefinition.new(ActiveRecord::Base.connection,select_query)
+
+      yield view_definition
+
+      fields_in_schema = view_definition.columns.inject({}) do |hash, column|
+        hash[column.to_s] = column
+        hash
+      end
+    
+      not_same = false
+      # Add fields to db new to schema
+      (fields_in_schema.keys - fields_in_db.keys).each do |field|
+        not_same = true
+#        column = fields_in_schema[field]
+#        add_column view_name, column
+      end
+
+
+      # Remove fields from db no longer in schema
+      (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
+         not_same = true        
+#        column = fields_in_db[field]
+#        remove_column view_name, column.name
+      end
+ 
+      puts "DB_SELECT="+db_select
+      puts "QUERY="+select_query
+      puts "NOT SAME="+not_same.to_s
+      if not_same or (db_select != select_query)
+        drop_view view_name  
+        return method_missing_without_auto_migration(method, *[view_name, options], &block)
+      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 ||= "index_#{table_name}_on_#{fields.join('_and_')}"
+
+      (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 - ["schema_info"]).each do |table|
+        drop_table table if table != "schema_migrations"
+      end
+    end
+
+    def drop_unused_views
+      # temporary
+      return true
+      (ActiveRecord::Base.connection.views - views_in_schema - ["schema_info"]).each do |view|
+        drop_view view
+      end
+    end    
+    
+    def drop_unused_indexes
+      tables_in_schema.each do |table_name|
+        indexes_in_db = ActiveRecord::Base.connection.indexes(table_name).map(&:name) rescue next
+        (indexes_in_db - indexes_in_schema & indexes_in_db).each do |index_name|
+          remove_index table_name, :name => index_name
+        end
+      end
+    end
+  
+  end
+
+end

data/lib/data_plan/generators/migration/lib/sexy_statements_hook.rb

@@ -0,0 +1,58 @@
+module SexyStatementsHook
+  
+  def self.included(base)
+    base.extend ClassMethods
+    class << base
+      cattr_accessor :sexy_up, :sexy_down, :desired_migration_name
+      self.sexy_up, self.sexy_down, self.desired_migration_name = "","",""
+      alias_method_chain :method_missing, :sexy_statements
+    end
+  end
+
+  module ClassMethods
+  
+    def add_to_migration_name(what)
+      if self.desired_migration_name.length < 100
+        self.desired_migration_name << "_" unless self.desired_migration_name.blank?
+        self.desired_migration_name << what 
+      else
+        self.desired_migration_name << "and_more" unless self.desired_migration_name.index("and_more")
+      end      
+    end
+  
+    def method_missing_with_sexy_statements(method, *args, &block)
+      case method
+      when :create_table, :create_view
+        table_name = args.shift.to_s    
+        lines = IO.readlines(File.join(DB_PROJECT_ROOT, 'db', 'plan.rb'))
+        inside_table = false
+        self.sexy_up << "\n"
+        for line in lines do
+          clean_line = line.gsub(/#.*/,"")
+          if clean_line =~ /create_(table|view)\W+#{table_name}(\W+|$)/i
+            inside_table = true  
+          end
+          self.sexy_up << "  " + line if inside_table
+          if inside_table and (clean_line =~ /\send\s*/i || clean_line =~ /^end\s*/i)
+            break
+          end
+        end
+      
+        add_to_migration_name( "create_#{table_name}" )
+
+      else
+        add_to_migration_name( method.to_s.split('_')[0] + ("_"+args[0].to_s rescue "") + ("_"+args[1].to_s rescue "") )
+        self.sexy_up << "    " + method.to_s + " " + args.collect{ |a| a.inspect }.join(",") + "\n"
+			end
+	
+#        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
+  
+  end
+
+end

data/lib/data_plan/generators/migration/migration_generator.rb

@@ -0,0 +1,28 @@
+# This is for Rails
+
+#require 'rails_generator'
+#require 'rails_generator/base'
+#require 'railties/lib/rails_generator/base'
+
+DB_PROJECT_ROOT = RAILS_ROOT
+require File.join( File.expand_path(File.dirname(__FILE__)),'','migration_generator_core' )
+
+class MigrationGenerator < Rails::Generator::Base
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @migration_arg_name = runtime_args.first
+  end
+
+  def manifest
+    mg = MigrationGeneratorCore.new
+    up,down,hints,migration_name = mg.calculate_migration( @migration_arg_name )
+
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate', 
+                           :assigns => { :up => up, :down => down, :hints => hints, :migration_name => migration_name.camelize }, 
+                           :migration_file_name => migration_name
+      end
+  end
+  
+end

data/lib/data_plan/generators/migration/migration_generator_core.rb

@@ -0,0 +1,76 @@
+# you should set DB_PROJECT_ROOT constant to some path before including this file
+
+class MigrationGeneratorCore
+
+  DB_PROJECT_ROOT = "." if not defined?(DB_PROJECT_ROOT)
+
+  def migration_default_name
+    i = Dir["#{DB_PROJECT_ROOT}/db/migrate/*definition_migration*"].length
+    "definition_migration_#{i+1}"
+  end
+
+  def calculate_migration(predefined_migration_name=nil)
+    require File.join( File.expand_path(File.dirname(__FILE__)),'lib','auto_migrations.rb')
+    require File.join( File.expand_path(File.dirname(__FILE__)),'lib','sexy_statements_hook.rb') 
+    ActiveRecord::Migration.send :include, SexyStatementsHook
+    ActiveRecord::Migration.send :include, AutoMigrations      
+
+    AutoMigrations.run
+    
+    print "Migration generated. Self.up is:\n" + ActiveRecord::Migration.sexy_up
+
+    migration_name = predefined_migration_name
+    if migration_name.blank?
+      name = ActiveRecord::Migration.desired_migration_name 
+      name = migration_default_name if name.blank?
+      migration_name = input("\nEnter filename [#{name}]:").strip.gsub(' ', '_')
+      migration_name = name if migration_name.blank?
+    end  
+
+    up = ActiveRecord::Migration.sexy_up + "    "
+    down = ActiveRecord::Migration.sexy_down
+      
+    hints = <<HINT
+
+# Hints on migrations syntax.
+#
+# add_column(table_name, column_name, type, options = {}) 
+#	  Types are: :primary_key, :string, :text, :integer, :float, :datetime, :timestamp, :time, :date, :binary, :boolean. 
+#
+# Other stuff:
+#   change_column(table_name, column_name, type, options = {}) - options as in add_column
+#   change_column_default(table_name, column_name, default)
+#   remove_column(table_name, column_name) 
+#   rename_column(table_name, column_name, new_column_name) 
+#
+# Sample: Don't add a primary key column
+#   create_table(:categories_suppliers, :id => false) do |t|
+#     t.column :category_id, :integer
+#     t.column :supplier_id, :integer
+#   end
+#
+# Sample: reload columns for a model from DB
+#   Person.reset_column_information
+#
+# More samples here: http://guides.rubyonrails.org/migrations.html
+HINT
+
+    #return { :up => up, :down => down, :hints => hints, :migration_name => migration_name.camelize, :migration_file_name => migration_name }
+    return up,down,hints,migration_name
+
+  end
+  
+
+  def input(prompt, options=nil)
+    print(prompt + " ")
+    if options
+      while !(response = STDIN.readline.strip.downcase).in?(options); 
+        print(prompt + " ")
+      end
+      response
+    else
+      STDIN.readline
+    end
+  end
+
+end

data/lib/data_plan/generators/migration/sinatra.rb

@@ -0,0 +1,49 @@
+# This is for Sinatra
+
+require 'active_record'
+require 'active_support/core_ext/string/strip'
+require 'fileutils'
+
+DB_PROJECT_ROOT = "."
+require File.join( File.expand_path(File.dirname(__FILE__)),'migration_generator_core' )
+
+module Sinatra
+  module ActiveRecordTasks
+    extend self
+
+    def create_migration(migration_name, version = nil)
+
+      mg = MigrationGeneratorCore.new
+      up,down,hints,migration_name = mg.calculate_migration( migration_name )
+
+      migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      migration_file = File.join(migrations_dir, "#{migration_number}_#{migration_name}.rb")
+
+      FileUtils.mkdir_p(migrations_dir)
+
+      File.open(migration_file, 'w') do |file|
+        file.write <<-MIGRATION.strip_heredoc
+class #{ migration_name.camelize } < ActiveRecord::Migration
+  def self.up
+#{ up }
+  end
+
+  def self.down
+#{ down }
+  end
+end
+
+#{ hints }
+MIGRATION
+      end
+
+      # puts "done"
+
+    end
+
+  end
+
+end
+
+# no need to load because already loaded from sinatra_activerecord
+# load 'sinatra/activerecord/tasks.rake'

data/lib/data_plan/generators/migration/templates/migration.rb

@@ -0,0 +1,11 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+<%= up %>
+  end
+
+  def self.down
+    <%= down %>
+  end
+end
+
+<%= hints %>

data/test/test_data_plan.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+
+class DataPlanTest < Test::Unit::TestCase
+
+  def test_this
+    puts "so test is good"
+    #flunk
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: data_plan
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Pavel Vasev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-28 00:00:00 Z
+dependencies: []
+
+description: Edit you db schema in db/plan.rb file. It has same syntax as rails schema.rb, but you can also leave comments and so on. Then, generate migration, and it will be prefilled with diff between plan.rb and your current db.
+email: pavel.vasev@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/data_plan/generators/migration/lib/auto_migrations.rb
+- lib/data_plan/generators/migration/lib/sexy_statements_hook.rb
+- lib/data_plan/generators/migration/migration_generator.rb
+- lib/data_plan/generators/migration/migration_generator_core.rb
+- lib/data_plan/generators/migration/sinatra.rb
+- lib/data_plan/generators/migration/templates/migration.rb
+- Rakefile
+- README
+- LICENSE
+- test/test_data_plan.rb
+homepage: http://rubygems.org/gems/data_plan
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Sinatra/ActiveRecord tool for easy migration generation. Works with Rails too.
+test_files: []
+