padrino-gen 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 529163bdc909b9c5aad2faa4ba1dcf647290eef3
-  data.tar.gz: 3fd83aca799e92e14220d0447f8a0145e279aade
+  metadata.gz: a7628694455061d5f6906099df64d2570594b629
+  data.tar.gz: 30c14c0393ea4289e1aa41d06d579646e1f864b7
 SHA512:
-  metadata.gz: 49e3c1b34292d216122cd51ce66d23359b38df3409966063f5db03ace99ea3dea3a077edc1503c6cffdb2055046625b1b47aa53acadf5913aa581ecd6891ef0a
-  data.tar.gz: 3aa0eea49ffdb6dc2b020d1a551423d68e86c71c2b942d799327ce0df3f9abb49d7eec7ecbc1843d66cc2cd696c600ffbdace4d45ec47680e10172abb2e80c52
+  metadata.gz: c230053d26d0c623f1f03b5ef036f7f0b0315f14bdc3b3abeb8d8cfc327584407d27b3d04fa590c5fdaf4110d2a71d309ddf9ca7697c91dbe600a4a7c3991bc2
+  data.tar.gz: 226607ee34f61de01dd944de3dd97245c70c2b9b033e978e663c4983edfa05e95cd936667dfa20791324198ad6025c801448a0c664943741832f69c232d5f9d0

data/README.rdoc

@@ -43,7 +43,7 @@ renderer::   slim  (default), erb, erubis, liquid, haml
 stylesheet:: none  (default), less, compass, sass, scss
 mock::       none  (default), mocha, rr
 script::     none  (default), jquery, prototype, mootools, rightjs, extcore, dojo
-orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, minirecord, sequel, couchrest, ohm, mongomatic, ripple
+orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, minirecord, sequel, couchrest, ohm, mongomatic, ripple, dynamoid
 
 In addition, you can generate projects based on existing templates:
 

data/lib/padrino-gen.rb

@@ -1,4 +1,3 @@
-require 'padrino-core/support_lite'
 require 'padrino-core/tasks'
 require 'padrino-gen/command'
 require 'active_support/ordered_hash'

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

@@ -35,25 +35,33 @@ module Padrino
         if in_app_root?
           @project_name = options[:namespace].underscore.camelize
           @project_name = fetch_project_name(@app_folder) if @project_name.empty?
-          if already_exists?(@app_name, @project_name)
+
+          if options[:destroy]
+            self.behavior = :revoke
+          else
             say "#{@app_name} already exists."
             say "Please, change the name."
             return
+          end if already_exists?(@app_name, @project_name)
+
+          lowercase_app_folder = @app_folder.downcase
+          app_skeleton(lowercase_app_folder, options[:tiny])
+          empty_directory destination_root("public/#{lowercase_app_folder}")
+
+          mount_command = "\nPadrino.mount('#{@project_name}::#{@app_name}', :app_file => Padrino.root('#{lowercase_app_folder}/app.rb')).to('/#{lowercase_app_folder}')\n"
+          if File.read(destination_root('config/apps.rb')).match(/^Padrino.mount.*\.to\('\/'\)$/)
+            inject_into_file destination_root('config/apps.rb'), mount_command, :before => /^Padrino.mount.*\.to\('\/'\)$/
           else
-            lowercase_app_folder = @app_folder.downcase
-            self.behavior = :revoke if options[:destroy]
-            app_skeleton(lowercase_app_folder, options[:tiny])
-            empty_directory destination_root("public/#{lowercase_app_folder}")
-            inject_into_file destination_root('config/apps.rb'), "\nPadrino.mount('#{@project_name}::#{@app_name}', :app_file => Padrino.root('#{lowercase_app_folder}/app.rb')).to('/#{lowercase_app_folder}')\n", :before => /^Padrino.mount.*\.to\('\/'\)$/
-  
-            return if self.behavior == :revoke
-            say
-            say '=' * 65, :green
-            say "Your #{@app_name} application has been installed."
-            say '=' * 65, :green
-            say "This application has been mounted to /#{@app_name.downcase}"
-            say "You can configure a different path by editing 'config/apps.rb'"
+            append_file destination_root('config/apps.rb'), mount_command
           end
+
+          return if self.behavior == :revoke
+          say
+          say '=' * 65, :green
+          say "Your #{@app_name} application has been installed."
+          say '=' * 65, :green
+          say "This application has been mounted to /#{@app_name.downcase}"
+          say "You can configure a different path by editing 'config/apps.rb'"
         else
           say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
         end

data/lib/padrino-gen/generators/app/app.rb.tt

@@ -1,6 +1,5 @@
 module <%= @project_name %>
   class <%= @app_name %> < Padrino::Application
-    register Padrino::Rendering
     register Padrino::Mailer
     register Padrino::Helpers
 

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

@@ -25,8 +25,7 @@ module Padrino
           if File.exist?(boot)
             require File.expand_path(boot)
           else
-            # If we are outside app we need to load support_lite
-            require 'padrino-core/support_lite' unless defined?(SupportLite)
+            require 'padrino-support'
           end
         rescue StandardError => e
           puts "=> Problem loading #{boot}"

data/lib/padrino-gen/generators/components/actions.rb

@@ -67,7 +67,7 @@ module Padrino
           else
             return if migration_exist?(filename)
             change_format = options[:change_format]
-            migration_scan = filename.underscore.camelize.scan(/(Add|Remove)(?:.*?)(?:To|From)(.*?)$/).flatten
+            migration_scan = filename.underscore.camelize.scan(/(Add|Remove).*?(?:(?:To|From).+?)*(?:To|From)((?:To|From)?.*?)$/).flatten
             direction, table_name = migration_scan[0].downcase, migration_scan[1].downcase.pluralize if migration_scan.any?
             tuples = direction ? columns.map { |value| value.split(":") } : []
             tuples.map! { |field, kind| kind =~ /datetime/i ? [field, 'DateTime'] : [field, kind] }

data/lib/padrino-gen/generators/components/mocks/rr.rb

@@ -1,8 +1,8 @@
 def setup_mock
-  require_dependencies 'rr', :group => 'test'
+  require_dependencies 'rr', :require => false, :group => 'test'
   case options[:test].to_s
     when 'rspec'
-      inject_into_file 'spec/spec_helper.rb', "  conf.mock_with :rr\n", :after => "RSpec.configure do |conf|\n"
+      inject_into_file 'spec/spec_helper.rb', "require 'rr'\n", :after => "\"/../config/boot\")\n"
     when 'riot'
       inject_into_file "test/test_config.rb","require 'riot/rr'\n", :after => "\"/../config/boot\")\n"
     when 'minitest'

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

@@ -53,6 +53,9 @@ ActiveSupport.escape_html_entities_in_json = false
 
 # Now we can establish connection with our db.
 ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
+
+# Timestamps are in the utc by default.
+ActiveRecord::Base.default_timezone = :utc
 AR
 
 MYSQL = (<<-MYSQL) unless defined?(MYSQL)

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

@@ -9,6 +9,27 @@ DM = (<<-DM) unless defined?(DM)
 # # A Sqlite3 connection
 # DataMapper.setup(:default, "sqlite3://" + Padrino.root('db', "development.db"))
 #
+# # Setup DataMapper using config/database.yml
+# DataMapper.setup(:default, YAML.load_file(Padrino.root('config/database.yml'))[RACK_ENV])
+#
+# config/database.yml file:
+#
+# ---
+# development: &defaults
+#   adapter: mysql
+#   database: example_development
+#   username: user
+#   password: Pa55w0rd
+#   host: 127.0.0.1
+#
+# test:
+#   <<: *defaults
+#   database: example_test
+#
+# production:
+#   <<: *defaults
+#   database: example_production
+#
 
 DataMapper.logger = logger
 DataMapper::Property::String.length(255)

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

@@ -0,0 +1,67 @@
+DYNAMOID = (<<-DYNAMOID) unless defined?(DYNAMOID)
+
+AWS.config({
+  :access_key_id => ENV['AWS_ACCESS_KEY'],
+  :secret_access_key => ENV['AWS_SECRET_KEY'],
+  :dynamo_db_endpoint => 'dynamodb.ap-southeast-1.amazonaws.com'
+})
+
+Dynamoid.configure do |config|
+  config.adapter = 'aws_sdk' # This adapter establishes a connection to the DynamoDB servers using Amazon's own AWS gem.
+  config.read_capacity = 100 # Read capacity for your tables
+  config.write_capacity = 20 # Write capacity for your tables
+end
+
+# If you use mock in testing [for example in case of using fake_dynamo],
+# the way is as following:
+#
+#   - install fake_dynamo
+#     gem install fake_dynamo --version 0.1.3
+#   - run
+#     fake_dynamo --port 4567
+# 
+# And then setting for AWS.config is as following:
+# 
+#   AWS.config({
+#     :access_key_id => 'xxx', # everything is ok
+#     :secret_access_key => 'xxx', # everything is ok
+#     :dynamo_db_endpoint => 'localhost', # fake_dynamo runs hostname
+#     :dynamo_db_port => 4567, # fake_dynamo listens port
+#     :use_ssl => false # fake_dynamo don't speak ssl
+#   })
+#
+# Additional information on https://github.com/ananthakumaran/fake_dynamo
+DYNAMOID
+
+def setup_orm
+  require_dependencies 'aws-sdk'
+  require_dependencies 'dynamoid', :version => '~>0.7.1'
+  create_file("config/database.rb", DYNAMOID.gsub(/!NAME!/, @project_name.underscore))
+end
+
+DYNAMOID_MODEL = (<<-MODEL) unless defined?(DYNAMOID_MODEL)
+class !NAME!
+  include Dynamoid::Document
+
+  !FIELDS!
+
+end
+MODEL
+
+# options => { :fields => ["title:string", "body:string"], :app => 'app' }
+def create_model_file(name, options={})
+  model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
+  field_tuples = options[:fields].map { |value| value.split(":") }
+  column_declarations = field_tuples.map { |field, kind| "field :#{field}, :#{kind}" }.join("\n  ")
+  model_contents = DYNAMOID_MODEL.gsub(/!NAME!/, name.to_s.underscore.camelize)
+  model_contents.gsub!(/!FIELDS!/, column_declarations)
+  create_file(model_path, model_contents)
+end
+
+def create_model_migration(filename, name, fields)
+  # NO MIGRATION NEEDED
+end
+
+def create_migration_file(migration_name, name, columns)
+  # NO MIGRATION NEEDED
+end

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

@@ -53,6 +53,9 @@ ActiveSupport.escape_html_entities_in_json = false
 
 # Now we can establish connection with our db.
 ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Padrino.env])
+
+# Timestamps are in the utc by default.
+ActiveRecord::Base.default_timezone = :utc
 MR
 
 MYSQL = (<<-MYSQL) unless defined?(MYSQL)

data/lib/padrino-gen/generators/components/tests/cucumber.rb

@@ -46,7 +46,7 @@ When /^I press '(.*)'$/ do |name|
 end
 
 Then /^I should see '(.*)'$/ do |text|
-  response_body.should contain(/#\{text}/m)
+  page.should have_content(text)
 end
 TEST
 

data/lib/padrino-gen/generators/components/tests/minitest.rb

@@ -64,7 +64,7 @@ TEST
 
 def setup_test
   require_dependencies 'rack-test', :require => 'rack/test', :group => 'test'
-  require_dependencies 'minitest', :version => "~>2.6.0", :require => 'minitest/autorun', :group => 'test'
+  require_dependencies 'minitest', :require => 'minitest/autorun', :group => 'test'
   insert_test_suite_setup MINITEST_SETUP
   create_file destination_root("test/test.rake"), MINITEST_RAKE
 end

data/lib/padrino-gen/generators/components/tests/rspec.rb

@@ -39,10 +39,10 @@ RSPEC_RAKE = (<<-TEST).gsub(/^ {12}/, '') unless defined?(RSPEC_RAKE)
 begin
   require 'rspec/core/rake_task'
 
-	spec_tasks = Dir['spec/*/'].inject([]) do |result, d|
-	  result << File.basename(d) unless Dir["\#{d}*"].empty?
-	  result
-	end
+  spec_tasks = Dir['spec/*/'].inject([]) do |result, d|
+    result << File.basename(d) unless Dir["\#{d}*"].empty?
+    result
+  end
 
   spec_tasks.each do |folder|
     RSpec::Core::RakeTask.new("spec:\#{folder}") do |t|

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

@@ -28,37 +28,81 @@ module Padrino
       # Execute the model generation.
       #
       def create_model
+        app = options[:app]
+        return unless valid_model_for?(app)
+
+        include_component_module_for(:test)
+        migration_name = "create_#{name.pluralize.underscore}"
+        apply_default_fields fields
+        create_model_file(name, :fields => fields, :app => app)
+        generate_model_test(name) if test?
+        create_model_migration(migration_name, name, fields) unless options[:skip_migration]
+      end
+
+      private
+
+      ##
+      # Validate model characteristics
+      # Alert if the model name is being used
+      #
+      def valid_model_for?(app)
         self.destination_root = options[:root]
-        if in_app_root?
-          app = options[:app]
-          check_app_existence(app)
-          camel_name = name.to_s.underscore.camelize
-          @project_name = ""
-          @project_name = fetch_project_name
-          if already_exists?(camel_name, @project_name)
-            say "#{camel_name} already exists."
-            say "Please, change the name."
-            return
-          else
-            self.behavior = :revoke if options[:destroy]
-            if invalids = invalid_fields(fields)
-              say 'Invalid field name:', :red
-              say " #{invalids.join(", ")}"
-              return
-            end
-            unless include_component_module_for(:orm)
-              say "<= You need an ORM adapter for run this generator. Sorry!"
-              raise SystemExit
-            end
-            include_component_module_for(:test)
-            migration_name = "create_#{name.pluralize.underscore}"
-            apply_default_fields fields
-            create_model_file(name, :fields => fields, :app => app)
-            generate_model_test(name) if test?
-            create_model_migration(migration_name, name, fields) unless options[:skip_migration]
-          end
+        return false unless correct_path?
+
+        check_app_existence(app)
+
+        if options[:destroy]
+          self.behavior = :revoke
         else
-          say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
+          say "#{@camel_name} already exists."
+          say "Please, change the name."
+          return false
+        end if model_name_already_exists?
+
+        return false if has_invalid_fields?
+
+        check_orm
+      end
+
+      ##
+      # Return false if the model name is being used
+      #
+      def model_name_already_exists?
+        @camel_name = name.to_s.underscore.camelize
+
+        @project_name = ""
+        @project_name = fetch_project_name
+
+        return false unless already_exists?(@camel_name, @project_name)
+        true
+      end
+
+      ##
+      # Alert if there is not an ORM Adapter
+      #
+      def check_orm
+        return true if include_component_module_for(:orm)
+
+        say "<= You need an ORM adapter for run this generator. Sorry!"
+        raise SystemExit
+      end
+
+      ##
+      # Check app path
+      #
+      def correct_path?
+        return true if in_app_root?
+        say 'You are not at the root of a Padrino application! (config/boot.rb not found)'
+        false
+      end
+
+      ##
+      # Check if the fields are valid
+      #
+      def has_invalid_fields?
+        if invalids = invalid_fields(fields)
+          say 'Invalid field name:', :red
+          say " #{invalids.join(", ")}"
         end
       end
     end

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

@@ -26,6 +26,7 @@ module Padrino
       class_option :root,             :desc => 'The root destination',                                             :aliases => '-r', :default => '.',         :type => :string
       class_option :dev,              :desc => 'Use padrino from a git checkout',                                                    :default => false,       :type => :boolean
       class_option :tiny,             :desc => 'Generate tiny app skeleton',                                       :aliases => '-i', :default => false,       :type => :boolean
+      class_option :lean,             :desc => 'Generate lean project without apps',                               :aliases => '-l', :default => false,       :type => :boolean
       class_option :adapter,          :desc => 'SQL adapter for ORM (sqlite, mysql, mysql2, mysql-gem, postgres)', :aliases => '-a', :default => 'sqlite',    :type => :string
       class_option :template,         :desc => 'Generate project from template',                                   :aliases => '-p', :default => nil,         :type => :string
       class_option :gem,              :desc => 'Generate project as a gem',                                        :aliases => '-g', :default => false,       :type => :boolean
@@ -47,16 +48,19 @@ module Padrino
         @project_name = name.gsub(/\W/, '_').underscore.camelize
         @app_name = app.gsub(/\W/, '_').underscore.camelize
         self.destination_root = File.join(options[:root], name)
-        if options[:template] # Run the template to create project
+        if options[:template]
           execute_runner(:template, options[:template])
-        else # generate project without template
+        else
           directory('project/', destination_root)
           empty_directory destination_root('public/images')
           empty_directory destination_root('public/javascripts')
           empty_directory destination_root('public/stylesheets')
           empty_directory destination_root('tmp')
           store_component_config('.components')
-          app_skeleton('app', options[:tiny])
+          unless options[:lean]
+            app_skeleton('app', options[:tiny])
+            append_file destination_root('config/apps.rb'), "Padrino.mount('#{@project_name}::#{@app_name}', :app_file => Padrino.root('app/app.rb')).to('/')\n"
+          end
           template 'templates/Gemfile.tt', destination_root('Gemfile')
           template 'templates/Rakefile.tt', destination_root('Rakefile')
           if options.gem?

data/lib/padrino-gen/generators/project/config/apps.rb.tt

@@ -33,4 +33,3 @@ Padrino.configure_apps do
 end
 
 # Mounts the core application for this project
-Padrino.mount('<%= @project_name.to_s %>::<%= @app_name.to_s %>', :app_file => Padrino.root('app/app.rb')).to('/')

data/lib/padrino-gen/generators/templates/Gemfile.tt

@@ -24,6 +24,6 @@ gem 'rake'
 # gem 'padrino', :github => 'padrino/padrino-framework'
 
 # Or Individual Gems
-<% unless options.dev? %># <% end %>%w(core gen helpers cache mailer admin).each do |g|
+<% unless options.dev? %># <% end %>%w(core support gen helpers cache mailer admin).each do |g|
 <% unless options.dev? %># <% end %>  gem 'padrino-' + g, <% if options.dev? %>:path => '<%= Padrino::Generators::DEV_PATH %>/padrino-' + g<% else %>'<%= Padrino.version %>'<% end %>
 <% unless options.dev? %># <% end %>end

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

@@ -129,7 +129,7 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
     end
 
     namespace :migrate do
-      desc  'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with VERSION=x.'
+      desc 'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with VERSION=x.'
       task :redo => :environment do
         if ENV["VERSION"]
           Rake::Task["ar:migrate:down"].invoke
@@ -144,35 +144,17 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
       task :reset => ["ar:drop", "ar:create", "ar:migrate"]
 
       desc 'Runs the "up" for a given migration VERSION.'
-      task :up => :environment do
-        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-        raise "VERSION is required" unless version
-        ActiveRecord::Migrator.run(:up, "db/migrate/", version)
-        Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-      end
+      task(:up => :environment){ migrate_as(:up) }
 
       desc 'Runs the "down" for a given migration VERSION.'
-      task :down => :environment do
-        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-        raise "VERSION is required" unless version
-        ActiveRecord::Migrator.run(:down, "db/migrate/", version)
-        Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-      end
+      task(:down => :environment){ migrate_as(:down) }
     end
 
     desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
-    task :rollback => :environment do
-      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-      ActiveRecord::Migrator.rollback('db/migrate/', step)
-      Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-    end
+    task(:rollback => :environment){ move_as(:rollback) }
 
     desc 'Pushes the schema to the next version. Specify the number of steps with STEP=n'
-    task :forward => :environment do
-      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-      ActiveRecord::Migrator.forward('db/migrate/', step)
-      Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-    end
+    task(:forward => :environment){ move_as(:forward) }
 
     desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
     task :reset => [ 'ar:drop', 'ar:setup' ]
@@ -252,36 +234,37 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
       desc "Dump the database structure to a SQL file"
       task :dump => :environment do
         abcs = ActiveRecord::Base.configurations
-        case abcs[Padrino.env][:adapter]
+        config = abcs[Padrino.env]
+        case config[:adapter]
         when "mysql", "mysql2", 'em_mysql2', "oci", "oracle", 'jdbcmysql'
-          ActiveRecord::Base.establish_connection(abcs[Padrino.env])
-          File.open("#{Padrino.root}/db/#{Padrino.env}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+          config = config.inject({}){|result, (key, value)| result[key.to_s] = value; result }
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, resolve_structure_sql)
         when "postgresql"
-          ENV['PGHOST']     = abcs[Padrino.env][:host] if abcs[Padrino.env][:host]
-          ENV['PGPORT']     = abcs[Padrino.env][:port].to_s if abcs[Padrino.env][:port]
-          ENV['PGPASSWORD'] = abcs[Padrino.env][:password].to_s if abcs[Padrino.env][:password]
-          search_path = abcs[Padrino.env][:schema_search_path]
+          ENV['PGHOST']     = config[:host] if config[:host]
+          ENV['PGPORT']     = config[:port].to_s if config[:port]
+          ENV['PGPASSWORD'] = config[:password].to_s if config[:password]
+          search_path = config[:schema_search_path]
           unless search_path.blank?
             search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
           end
-          `pg_dump -i -U "#{abcs[Padrino.env][:username]}" -s -x -O -f db/#{Padrino.env}_structure.sql #{search_path} #{abcs[Padrino.env][:database]}`
+          `pg_dump -i -U "#{config[:username]}" -s -x -O -f db/#{Padrino.env}_structure.sql #{search_path} #{config[:database]}`
           raise "Error dumping database" if $?.exitstatus == 1
         when "sqlite", "sqlite3"
-          dbfile = abcs[Padrino.env][:database] || abcs[Padrino.env][:dbfile]
-          `#{abcs[Padrino.env][:adapter]} #{dbfile} .schema > db/#{Padrino.env}_structure.sql`
+          dbfile = config[:database] || config[:dbfile]
+          `#{config[:adapter]} #{dbfile} .schema > db/#{Padrino.env}_structure.sql`
         when "sqlserver"
-          `scptxfr /s #{abcs[Padrino.env][:host]} /d #{abcs[Padrino.env][:database]} /I /f db\\#{Padrino.env}_structure.sql /q /A /r`
-          `scptxfr /s #{abcs[Padrino.env][:host]} /d #{abcs[Padrino.env][:database]} /I /F db\ /q /A /r`
+          `scptxfr /s #{config[:host]} /d #{config[:database]} /I /f db\\#{Padrino.env}_structure.sql /q /A /r`
+          `scptxfr /s #{config[:host]} /d #{config[:database]} /I /F db\ /q /A /r`
         when "firebird"
-          set_firebird_env(abcs[Padrino.env])
-          db_string = firebird_db_string(abcs[Padrino.env])
+          set_firebird_env(config)
+          db_string = firebird_db_string(config)
           sh "isql -a #{db_string} > #{Padrino.root}/db/#{Padrino.env}_structure.sql"
         else
-          raise "Task not supported by '#{abcs[Padrino.env][:adapter]}'"
+          raise "Task not supported by '#{config[:adapter]}'"
         end
 
         if ActiveRecord::Base.connection.supports_migrations?
-          File.open("#{Padrino.root}/db/#{Padrino.env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+          File.open(resolve_structure_sql, "a"){|f| f << ActiveRecord::Base.connection.dump_schema_information }
         end
       end
     end
@@ -366,6 +349,27 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
     end
   end
 
+  def migrate_as(type)
+    version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+    raise "VERSION is required" unless version
+    ActiveRecord::Migrator.run(type, "db/migrate/", version)
+    dump_schema
+  end
+
+  def move_as(type)
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.send(type, 'db/migrate/', step)
+    dump_schema
+  end
+
+  def dump_schema
+    Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  def resolve_structure_sql
+    "#{Padrino.root}/db/#{Padrino.env}_structure.sql"
+  end
+
   task 'db:migrate' => 'ar:migrate'
   task 'db:create'  => 'ar:create'
   task 'db:drop'    => 'ar:drop'