padrino-gen 0.6.7 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.7
+0.7.0

data/lib/padrino-gen/generators/components/orms/activerecord_gen.rb

@@ -10,11 +10,15 @@ module Padrino
           # You can use other adapters like:
           # 
           #   ActiveRecord::Base.configurations[:development] = {
-          #     :adapter  => "mysql",
-          #     :host     => "localhost",
-          #     :username => "myuser",
-          #     :password => "mypass",
-          #     :database => "somedatabase"
+          #     :adapter   => 'mysql',
+          #     :encoding  => 'utf8',
+          #     :reconnect => false,
+          #     :database  => 'your_database',
+          #     :pool      => 5,
+          #     :username  => 'root',
+          #     :password  => '',
+          #     :host      => 'localhost',
+          #     :socket    => '/tmp/mysql.sock'
           #   )
           #
           ActiveRecord::Base.configurations[:development] = {
@@ -52,27 +56,9 @@ module Padrino
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
           AR
 
-          RAKE = (<<-RAKE).gsub(/^ {10}/, '')
-          require 'sinatra/base'
-          require 'active_record'
-
-          namespace :db do
-            desc "Migrate the database"
-            task(:migrate) do
-              load File.dirname(__FILE__) + '/config/boot.rb'
-              APP_CLASS.new
-              ActiveRecord::Base.logger = Logger.new(STDOUT)
-              ActiveRecord::Migration.verbose = true
-              ActiveRecord::Migrator.migrate( File.dirname(__FILE__) + "/db/migrate")
-            end
-          end
-          RAKE
-
-
           def setup_orm
             require_dependencies 'active_record'
             create_file("config/database.rb", AR)
-            create_file("Rakefile", RAKE.gsub(/APP_CLASS/, @class_name))
             empty_directory('app/models')
           end
 

data/lib/padrino-gen/generators/controller.rb

@@ -34,9 +34,9 @@ module Padrino
         self.destination_root = options[:root]
         if in_app_root?
           @app_name = fetch_app_name(options[:root])
-          @actions = controller_actions(fields)
+          @actions  = controller_actions(fields)
+          @controller = name
           self.behavior = :revoke if options[:destroy]
-          # inject_into_file destination_root("config/urls.rb"), controller_routes(name,fields), :after => "urls do\n"
           template "templates/controller.rb.tt", destination_root("app/controllers", "#{name}.rb")
           template "templates/helper.rb.tt",     destination_root("app/helpers", "#{name}_helper.rb")
           empty_directory destination_root("app/views/#{name}")

data/lib/padrino-gen/generators/templates/controller.rb.tt

@@ -1,11 +1,17 @@
-<%= @app_name %>.controllers do
+<%= @app_name %>.controllers :<%= @name %> do
   # get :index, :map => "/foo/bar" do
   #   session[:foo] = "bar"
   #   render 'index'
   # end
-  
-  # get :sample, :map => "/sample/url" do
-  #   "Hello world!"
+
+  # get :sample, :map => "/sample/url", :respond_to => [:any, :js] do
+  #   case content_type
+  #     when :js then ...
+  #     else ...
+  # end
+
+  # get :foo, :with => :id do
+  #   "Im foo/#{params[:id]}"
   # end
 
   # get "/example" do

data/lib/padrino-gen/generators.rb

@@ -33,6 +33,7 @@ module Padrino
         Dir[File.dirname(__FILE__) + '/generators/{components}/**/*.rb'].each { |lib| require lib }
 
         begin
+          ENV['PADRINO_LOG_LEVEL'] ||= "test"
           if options[:root]
             require File.join(options[:root], 'config/boot.rb') if File.exist?(File.join(options[:root], 'config/boot.rb'))
           else

data/lib/padrino-gen/padrino-tasks/activerecord.rb

@@ -126,7 +126,6 @@ if defined?(ActiveRecord)
       end
     end
 
-
     desc "Migrate the database through scripts in db/migrate and update db/schema.rb by invoking ar:schema:dump. Target specific version with VERSION=x. Turn off output with VERBOSE=false."
     task :migrate => :environment do
       ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
@@ -252,6 +251,16 @@ if defined?(ActiveRecord)
           raise %{#{file} doesn't exist yet. Run "rake ar:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Padrino.root}/config/boot.rb to limit the frameworks that will be loaded}
         end
       end
+
+      desc "Create migration from schema.rb"
+      task :to_migration => :environment do
+        AutoMigrations.schema_to_migration
+      end
+
+      desc "Create migration from schema.rb and reset migrations log"
+      task :to_migration_with_reset => :environment do
+        AutoMigrations.schema_to_migration(true)
+      end
     end
 
     namespace :structure do
@@ -292,6 +301,13 @@ if defined?(ActiveRecord)
       end
     end
 
+    namespace :auto do
+      desc "Use schema.rb to auto-upgrade"
+      task :upgrade => :environment do
+        AutoMigrations.run
+      end 
+    end
+
   end
 
   def drop_database(config)
@@ -323,4 +339,191 @@ if defined?(ActiveRecord)
   def firebird_db_string(config)
     FireRuby::Database.db_string_for(config.symbolize_keys)
   end
+
+  ##
+  # Padrino plugin for automating migrations
+  # 
+  # Thanks to:: PJ Hyett
+  # Original Repo:: http://github.com/pjhyett/auto_migrations
+  # 
+  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(Padrino.root('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(Padrino.root("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 = Padrino.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
+        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 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 = Padrino.root("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
+
+  ActiveRecord::Migration.send :include, AutoMigrations
 end

data/padrino-gen.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-gen}
-  s.version = "0.6.7"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2010-01-26}
+  s.date = %q{2010-01-31}
   s.default_executable = %q{padrino-gen}
   s.description = %q{Generators for easily creating and building padrino applications from the console}
   s.email = %q{nesquena@gmail.com}
@@ -98,7 +98,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_runtime_dependency(%q<padrino-core>, ["= 0.6.7"])
+      s.add_runtime_dependency(%q<padrino-core>, ["= 0.7.0"])
       s.add_runtime_dependency(%q<thor>, [">= 0.11.8"])
       s.add_runtime_dependency(%q<bundler>, [">= 0.5.0"])
       s.add_development_dependency(%q<haml>, [">= 2.2.1"])
@@ -109,7 +109,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<fakeweb>, [">= 1.2.3"])
     else
       s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_dependency(%q<padrino-core>, ["= 0.6.7"])
+      s.add_dependency(%q<padrino-core>, ["= 0.7.0"])
       s.add_dependency(%q<thor>, [">= 0.11.8"])
       s.add_dependency(%q<bundler>, [">= 0.5.0"])
       s.add_dependency(%q<haml>, [">= 2.2.1"])
@@ -121,7 +121,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-    s.add_dependency(%q<padrino-core>, ["= 0.6.7"])
+    s.add_dependency(%q<padrino-core>, ["= 0.7.0"])
     s.add_dependency(%q<thor>, [">= 0.11.8"])
     s.add_dependency(%q<bundler>, [">= 0.5.0"])
     s.add_dependency(%q<haml>, [">= 2.2.1"])

data/test/test_app_generator.rb

@@ -106,7 +106,6 @@ class TestAppGenerator < Test::Unit::TestCase
       buffer = silence_logger { @app.start(['sample_app', '--root=/tmp', '--orm=activerecord', '--script=none']) }
       assert_match /Applying.*?activerecord.*?orm/, buffer
       assert_match_in_file(/gem 'active_record'/, '/tmp/sample_app/Gemfile')
-      assert_match_in_file(/Migrate the database/, '/tmp/sample_app/Rakefile')
       assert_match_in_file(/ActiveRecord::Base.establish_connection/, '/tmp/sample_app/config/database.rb')
       assert_dir_exists('/tmp/sample_app/app/models')
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-gen
 version: !ruby/object:Gem::Version 
-  version: 0.6.7
+  version: 0.7.0
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-26 00:00:00 +01:00
+date: 2010-01-31 00:00:00 +01:00
 default_executable: padrino-gen
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,7 +33,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.6.7
+        version: 0.7.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: thor