sequel-rails 0.1.8 → 0.4.0.pre

data/lib/generators/sequel/migration/templates/migration.rb.erb

@@ -0,0 +1,48 @@
+Sequel.migration do
+  <%- if use_change -%>
+  change do
+    <%= table_action %>_table :<%= table_name %> do
+      <%- if table_action == 'create' -%>
+      primary_key :id
+      <%- end -%>
+      <%- attributes.each do |attribute| -%>
+      <%- if table_action == 'create' -%>
+      <%= attribute.type_class %> :<%= attribute.name %>
+      <%- else -%>
+      <%= column_action %>_column :<%= attribute.name %><% if column_action == 'add' %>, <%= attribute.type_class %><% end %>
+      <%- end -%>
+      <%- end -%>
+    end
+  end
+  <%- else -%>
+  up do
+    <%- if table_action == 'drop' -%>
+    drop_table :<%= table_name %>
+    <%- else -%>
+    <%= table_action %>_table :<%= table_name %> do
+      <%- attributes.each do |attribute| -%>
+      <%- if table_action == 'create' -%>
+      <%= attribute.type_class %> :<%= attribute.name %>
+      <%- else -%>
+      <%= column_action %>_column :<%= attribute.name %><% if column_action == 'add' %>, <%= attribute.type_class %><% end %>
+      <%- end -%>
+      <%- end -%>
+    end
+    <%- end -%>
+  end
+
+  down do
+    <%- alter_table_action = (table_action == 'drop') ? 'create' : table_action -%>
+    <%- alter_column_action = (column_action == 'add') ? 'drop' : 'add' -%>
+    <%= alter_table_action %>_table :<%= table_name %> do
+      <%- attributes.each do |attribute| -%>
+      <%- if alter_table_action == 'create' -%>
+      <%= attribute.type_class %> :<%= attribute.name %>
+      <%- else -%>
+      <%= alter_column_action %>_column :<%= attribute.name %><% if alter_column_action == 'add' %>, <%= attribute.type_class %><% end %>
+      <%- end -%>
+      <%- end -%>
+    end
+  end
+  <%- end -%>
+end

data/lib/generators/sequel/model/model_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/sequel'
+require "generators/sequel"
 
 module Sequel
   module Generators
@@ -8,11 +8,17 @@ module Sequel
 
       check_class_collision
 
+      class_option :migration,  :type => :boolean
       class_option :timestamps, :type => :boolean
       class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
 
+      def create_migration_file
+        return unless options[:migration]
+        migration_template "migration.rb.erb", "db/migrate/create_#{table_name}.rb"
+      end
+
       def create_model_file
-        template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+        template 'model.rb.erb', File.join('app/models', class_path, "#{file_name}.rb")
       end
 
       hook_for :test_framework

data/lib/generators/sequel/model/templates/migration.rb.erb

@@ -0,0 +1,16 @@
+Sequel.migration do 
+  change do
+
+    create_table :<%= table_name %> do
+      primary_key :id
+      <%- if options[:timestamps] -%>
+      DateTime :created_at
+      DateTime :updated_at
+      <%- end -%>
+      <%- attributes.each do |attribute| -%>
+      <%= attribute.type_class %> :<%= attribute.name %>
+      <%- end -%>
+    end
+
+  end
+end

data/lib/generators/sequel/model/templates/{model.rb → model.rb.erb}

@@ -1,3 +1,6 @@
 class <%= class_name %><%= options[:parent] ? " < #{options[:parent].classify}" : " < Sequel::Model" %>
-
+  <%- if options[:timestamps] -%>
+  plugin :timestamps
+  <%- end -%>
+  
 end

data/lib/generators/sequel/observer/observer_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/sequel'
+require "generators/sequel"
 
 module Sequel
   module Generators
@@ -8,7 +8,7 @@ module Sequel
       check_class_collision :suffix => "Observer"
 
       def create_observer_file
-        template 'observer.rb', File.join('app/models', class_path, "#{file_name}_observer.rb")
+        template 'observer.rb.erb', File.join('app/models', class_path, "#{file_name}_observer.rb")
       end
 
       hook_for :test_framework

data/lib/sequel-rails.rb

@@ -1 +1 @@
-require 'sequel-rails/railtie'
+require "sequel_rails"

data/lib/sequel_rails.rb

@@ -0,0 +1,2 @@
+require "sequel_rails/version"
+require "sequel_rails/railtie" if defined? Rails

data/lib/sequel_rails/configuration.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/class/attribute_accessors'
+
+module SequelRails
+
+  mattr_accessor :configuration
+
+  def self.setup(environment)
+    ::Sequel.connect configuration.environment_for environment.to_s
+  end
+
+  class Configuration
+
+    def self.for(root, database_yml_hash)
+      ::SequelRails.configuration ||= new(root, database_yml_hash)
+    end
+
+    attr_reader :root, :raw
+    attr_accessor :logger
+    attr_accessor :migration_dir
+
+    def environment_for(name)
+      environments[name.to_s] || environments[name.to_sym]
+    end
+
+    def environments
+      @environments ||= @raw.inject({}) do |normalized, environment|
+        name, config = environment.first, environment.last
+        normalized[name] = normalize_repository_config(config)
+        normalized
+      end
+    end
+
+  private
+
+    def initialize(root, database_yml_hash)
+      @root, @raw = root, database_yml_hash
+    end
+
+    def normalize_repository_config(hash)
+      config = {}
+      hash.each do |key, value|
+        config[key.to_s] = 
+          if key.to_s == 'port'
+            value.to_i
+          elsif key.to_s == 'adapter' && value == 'sqlite3'
+            'sqlite'
+          elsif key.to_s == 'database' && (hash['adapter'] == 'sqlite3' || 
+                                           hash['adapter'] == 'sqlite'  ||
+                                           hash[:adapter]  == 'sqlite3' ||
+                                           hash[:adapter]  == 'sqlite')
+            value == ':memory:' ? value : File.expand_path((hash['database'] || hash[:database]), root)
+          elsif key.to_s == 'adapter' && value == 'postgresql'
+            'postgres'
+          else
+            value
+          end
+      end
+      
+      config
+    end
+
+  end
+
+end

data/lib/sequel_rails/migrations.rb

@@ -0,0 +1,22 @@
+require 'sequel/extensions/migration'
+
+module SequelRails
+  class Migrations
+    def self.migrate_up!(version=nil)
+      opts = {}
+      opts[:target] = version.to_i if version
+      ::Sequel::Migrator.run(::Sequel::Model.db, "db/migrate", opts)
+    end
+
+    def self.migrate_down!(version=nil)
+      opts = {}
+      opts[:target] = version.to_i if version
+      ::Sequel::Migrator.run(::Sequel::Model.db, "db/migrate", opts)
+    end
+
+    def self.pending_migrations?
+      return false unless File.exists?("db/migrate")
+      !::Sequel::Migrator.is_current?(::Sequel::Model.db, "db/migrate")
+    end
+  end
+end

data/lib/sequel_rails/railtie.rb

@@ -0,0 +1,94 @@
+require "sequel"
+
+require "rails"
+require "active_model/railtie"
+
+# Comment taken from active_record/railtie.rb
+#
+# For now, action_controller must always be present with
+# rails, so let's make sure that it gets required before
+# here. This is needed for correctly setting up the middleware.
+# In the future, this might become an optional require.
+require "action_controller/railtie"
+
+require "sequel_rails/configuration"
+require "sequel_rails/migrations"
+require "sequel_rails/railties/log_subscriber"
+require "sequel_rails/railties/i18n_support"
+require "sequel_rails/railties/controller_runtime"
+require "sequel_rails/sequel/plugins/rails_extensions"
+require "sequel_rails/sequel/database/active_support_notification"
+
+module SequelRails
+
+  class Railtie < Rails::Railtie
+
+    ::SequelRails::Railties::LogSubscriber.attach_to :sequel
+
+    config.app_generators.orm :sequel, :migration => true
+    config.rails_fancy_pants_logging = true
+
+    config.action_dispatch.rescue_responses.merge!(
+      "Sequel::Plugins::RailsExtensions::ModelNotFound" => :not_found,
+      "Sequel::ValidationFailed" => :unprocessable_entity,
+      "Sequel::NoExistingObject" => :unprocessable_entity
+    )
+
+    rake_tasks do
+      load "sequel_rails/railties/database.rake"
+    end
+
+    initializer 'sequel.configuration' do |app|
+      configure_sequel app
+    end
+
+    initializer 'sequel.logger' do |app|
+      setup_logger app, ::Rails.logger
+    end
+
+    initializer 'sequel.i18n_support' do |app|
+      setup_i18n_support app
+    end
+
+    # Expose database runtime to controller for logging.
+    initializer 'sequel.log_runtime' do |app|
+      setup_controller_runtime app
+    end
+
+    initializer 'sequel.connect' do |app|
+      ::SequelRails.setup ::Rails.env
+    end
+
+    # Run setup code after_initialize to make sure all config/initializers
+    # are in effect once we setup the connection. This is especially necessary
+    # for the cascaded adapter wrappers that need to be declared before setup.
+    config.after_initialize do |app|
+      ::Sequel::Model.plugin :active_model
+      ::Sequel::Model.plugin :validation_helpers
+      ::Sequel::Model.plugin :rails_extensions
+      ::Sequel::Model.raise_on_save_failure = false
+    end
+
+    # Support overwriting crucial steps in subclasses
+    def configure_sequel(app)
+      app.config.sequel = ::SequelRails::Configuration.for(
+        ::Rails.root, app.config.database_configuration
+      )
+    end
+
+    def setup_i18n_support(app)
+      ::Sequel::Model.send :include, ::SequelRails::I18nSupport
+    end
+
+    def setup_controller_runtime(app)
+      require 'sequel_rails/railties/controller_runtime'
+      ActionController::Base.send :include, SequelRails::Railties::ControllerRuntime
+    end
+
+    def setup_logger(app, logger)
+      app.config.sequel.logger = logger
+    end
+
+  end
+
+end

data/lib/sequel_rails/railties/controller_runtime.rb

@@ -0,0 +1,40 @@
+require "active_support/core_ext/module/attr_internal"
+
+module SequelRails
+  module Railties
+
+    module ControllerRuntime
+
+      extend ActiveSupport::Concern
+
+      protected
+
+      attr_internal :db_runtime
+
+      def cleanup_view_runtime
+        db_rt_before_render = ::SequelRails::Railties::LogSubscriber.reset_runtime
+        runtime = super
+        db_rt_after_render = ::SequelRails::Railties::LogSubscriber.reset_runtime
+        self.db_runtime = db_rt_before_render + db_rt_after_render
+        runtime - db_rt_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:db_runtime] = db_runtime
+      end
+
+      module ClassMethods
+
+        def log_process_action(payload)
+          messages, db_runtime = super, payload[:db_runtime]
+          messages << ("Models: %.1fms" % db_runtime.to_f) if db_runtime
+          messages
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/sequel_rails/railties/database.rake

@@ -0,0 +1,175 @@
+require 'sequel_rails/storage'
+
+# TODO: DRY these up
+namespace :db do
+  def db_for_current_env
+    @db_for_current_env ||= {}
+    @db_for_current_env[Rails.env] ||= begin
+      config = ::SequelRails.configuration.environment_for(Rails.env)
+      ::Sequel.connect(config)
+    end
+  end
+
+  # desc "Raises an error if there are pending migrations"
+  task :abort_if_pending_migrations => [:environment, "db:migrate:load"] do
+    if SequelRails::Migrations.pending_migrations?
+      puts "You have pending migrations:"
+      abort %{Run `rake db:migrate` to update your database then try again.}
+    end
+  end
+
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by Sequel"
+    task :dump => :environment do
+      ::Sequel.extension :schema_dumper
+      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+        file.write db_for_current_env.dump_schema_migration(same_db: true)
+      end
+      Rake::Task["db:schema:dump"].reenable
+    end
+
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+      if File.exists?(file)
+        require 'sequel/extensions/migration'
+        load(file)
+        SequelRails::Migration.descendants.first.apply(db_for_current_env, :up)
+      else
+        abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/boot.rb to limit the frameworks that will be loaded}
+      end
+    end
+  end
+
+  namespace :create do
+    desc 'Create all the local databases defined in config/database.yml'
+    task :all => :environment do
+      SequelRails::Storage.create_all
+    end
+  end
+
+  desc "Create the database defined in config/database.yml for the current Rails.env"
+  task :create, [:env] => :environment do |t, args|
+    args.with_defaults(:env => Rails.env)
+
+    SequelRails::Storage.adapter_for(args.env).create
+  end
+
+  namespace :drop do
+    desc 'Drops all the local databases defined in config/database.yml'
+    task :all => :environment do
+      SequelRails::Storage.drop_all
+    end
+  end
+
+  desc "Create the database defined in config/database.yml for the current Rails.env"
+  task :drop, [:env] => :environment do |t, args|
+    args.with_defaults(:env => Rails.env)
+
+    Rails::Sequel::Storage.adapter_for(args.env).drop
+  end
+
+  namespace :migrate do
+    task :load => :environment do
+      require 'sequel_rails/migrations'
+    end
+
+    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 => :load do
+      if ENV["VERSION"]
+        Rake::Task["db:migrate:down"].invoke
+        Rake::Task["db:migrate:up"].invoke
+      else
+        Rake::Task["db:rollback"].invoke
+        Rake::Task["db:migrate"].invoke
+      end
+    end
+
+
+    desc 'Resets your database using your migrations for the current environment'
+    task :reset => ["db:drop", "db:create", "db:migrate"]
+
+    desc 'Runs the "up" for a given migration VERSION.'
+    task :up => :load do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      raise "VERSION is required" unless version
+      SequelRails::Migrations.migrate_up!(version)
+      Rake::Task["db:schema:dump"].invoke unless Rails.env.test?
+    end
+
+    desc 'Runs the "down" for a given migration VERSION.'
+    task :down => :load do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      raise "VERSION is required" unless version
+      SequelRails::Migrations.migrate_down!(version)
+      Rake::Task["db:schema:dump"].invoke unless Rails.env.test?
+    end
+  end
+
+  desc 'Migrate the database to the latest version'
+  task :migrate => "migrate:load" do
+    SequelRails::Migrations.migrate_up!(ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke unless Rails.env.test?
+  end
+
+  desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
+  task :rollback => "migrate:load" do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    Sequel::Migrator.rollback('db/migrate/', step)
+    Rake::Task["db:schema:dump"].invoke unless Rails.env.test?
+  end
+
+  desc 'Pushes the schema to the next version. Specify the number of steps with STEP=n'
+  task :forward => "migrate:load" do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    Sequel::Migrator.forward('db/migrate/', step)
+    Rake::Task["db:schema:dump"].invoke unless Rails.env.test?
+  end
+
+  desc 'Load the seed data from db/seeds.rb'
+  task :seed => :abort_if_pending_migrations do
+    seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+    load(seed_file) if File.exist?(seed_file)
+  end
+
+  desc 'Create the database, load the schema, and initialize with the seed data'
+  task :setup => [ 'db:create', 'db:schema:load', 'db:seed' ]
+
+  desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
+  task :reset => [ 'db:drop', 'db:setup' ]
+
+  desc 'Forcibly close any open connections to the current env database (PostgreSQL specific)'
+  task :force_close_open_connections => :environment do
+    if db_for_current_env.database_type==:postgres
+      begin
+        # Will only work on Postgres > 8.4
+        pid_column = db_for_current_env.server_version < 90200 ? "procpid" : "pid"
+        db_for_current_env.execute <<-SQL.gsub(/^\s{9}/,'')
+          SELECT COUNT(pg_terminate_backend(#{pid_column}))
+          FROM  pg_stat_activity
+          WHERE datname = '#{db_for_current_env.opts[:database]}';
+        SQL
+      rescue => e
+        #Will raise an error as it kills existing process running this command
+        #Seems to be only way to ensure *all* test connections are closed
+      end
+    end
+  end
+
+  namespace :test do
+    desc "Prepare test database (ensure all migrations ran, drop and re-create database then load schema). This task can be run in the same invocation as other task (eg: rake db:migrate db:test:prepare)."
+    task :prepare => "db:abort_if_pending_migrations" do
+      previous_env, Rails.env = Rails.env, 'test'
+      Rake::Task['db:force_close_open_connections'].execute
+      Rake::Task['db:drop'].execute
+      Rake::Task['db:create'].execute
+      Rake::Task['db:schema:load'].execute
+      Sequel::DATABASES.each do |db|
+        db.disconnect
+      end
+      Rails.env = previous_env
+    end
+  end
+end
+
+task "test:prepare" => "db:test:prepare"