talentbox-sequel-rails 0.2.0

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

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

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

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

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

@@ -0,0 +1,7 @@
+class <%= class_name %>Observer
+
+  include Sequel::Observer
+
+  observe <%= class_name %>
+
+end

data/lib/sequel-rails.rb

@@ -0,0 +1,7 @@
+require 'sequel-rails/railtie'
+
+module Rails
+  module Sequel
+  end
+end
+

data/lib/sequel-rails/configuration.rb

@@ -0,0 +1,63 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/class/attribute_accessors'
+
+module Rails
+  module Sequel
+
+    mattr_accessor :configuration
+
+    class Configuration
+
+      def self.for(root, database_yml_hash)
+        Rails::Sequel.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
+end

data/lib/sequel-rails/migrations.rb

@@ -0,0 +1,30 @@
+require 'sequel/extensions/migration'
+
+module Rails
+  module Sequel
+    class Migrations
+
+      class << self
+        
+        def migrate_up!(version=nil)
+          opts = {}
+          opts[:target] = version.to_i if version
+          
+          
+          
+          ::Sequel::Migrator.run(::Sequel::Model.db, "db/migrate", opts)
+        end
+        
+        def migrate_down!(version=nil)
+          opts = {}
+          opts[:target] = version.to_i if version
+
+          ::Sequel::Migrator.run(::Sequel::Model.db, "db/migrate", opts)
+        end
+        
+      end
+      
+      
+    end
+  end
+end

data/lib/sequel-rails/railtie.rb

@@ -0,0 +1,90 @@
+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/setup'
+require "sequel-rails/railties/log_subscriber"
+require "sequel-rails/railties/i18n_support"
+
+
+module Rails
+  module Sequel
+
+    class Railtie < Rails::Railtie
+
+      ::Sequel::Railties::LogSubscriber.attach_to :sequel
+
+      config.app_generators.orm :sequel, :migration => true
+      config.rails_fancy_pants_logging = true
+
+      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|
+        Rails::Sequel.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.raise_on_save_failure = false
+      end
+
+
+      # Support overwriting crucial steps in subclasses
+
+      def configure_sequel(app)
+        app.config.sequel = Rails::Sequel::Configuration.for(
+          Rails.root, app.config.database_configuration
+        )
+      end
+
+      def setup_i18n_support(app)
+        ::Sequel::Model.send :include, Rails::Sequel::I18nSupport
+      end
+
+      def setup_controller_runtime(app)
+        require "sequel-rails/railties/controller_runtime"
+        ActionController::Base.send :include, Rails::Sequel::Railties::ControllerRuntime
+      end
+
+      def setup_logger(app, logger)
+        app.config.sequel.logger=logger
+      end
+
+    end
+
+  end
+end

data/lib/sequel-rails/railties/benchmarking_mixin.rb

@@ -0,0 +1,23 @@
+module Sequel
+  module Adapters
+    module Benchmarking
+
+      %w[ create read update delete ].each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def #{method}(*args, &block)
+            result = nil
+            @runtime ||= 0
+            @runtime += Benchmark.ms { result = super(*args, &block) }
+            result
+          end
+        RUBY
+      end
+
+      def reset_runtime
+        rt, @runtime = @runtime, 0
+        rt.to_f
+      end
+
+    end
+  end
+end

data/lib/sequel-rails/railties/controller_runtime.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module Rails
+  module Sequel
+    module Railties
+
+      module ControllerRuntime
+
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :db_runtime
+
+        def cleanup_view_runtime
+          db_rt_before_render = ::Rails::Sequel.reset_runtime
+          runtime = super
+          db_rt_after_render = ::Rails::Sequel.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
+end

data/lib/sequel-rails/railties/database.rake

@@ -0,0 +1,167 @@
+# TODO: DRY these up
+namespace :db do
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by Sequel"
+    task :dump do
+      Sequel.extension :schema_dumper
+      db = Sequel.connect(::Rails::Sequel.configuration.environment_for(Rails.env))
+      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+        file.write(db.dump_schema_migration)
+      end
+      Rake::Task["db:schema:dump"].reenable
+    end
+    
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      require 'sequel-rails/storage'
+      Rails::Sequel::Storage.new(Rails.env).create
+      
+      file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
+      if File.exists?(file)
+        load(file)
+      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
+      require 'sequel-rails/storage'
+      Rails::Sequel::Storage.create_all
+    end
+  end
+
+  desc "Create the database defined in config/database.yml for the current Rails.env - also creates the test database if Rails.env.development?"
+  task :create, [:env] => :environment do |t, args|
+    args.with_defaults(:env => Rails.env)
+    
+    require 'sequel-rails/storage'
+    Rails::Sequel::Storage.new(args.env).create
+    
+    if Rails.env.development? && Rails.configuration.database_configuration['test']
+      Rails::Sequel::Storage.new('test').create
+    end
+  end
+  
+  namespace :drop do
+    desc 'Drops all the local databases defined in config/database.yml'
+    task :all => :environment do
+      require 'sequel-rails/storage'
+      Rails::Sequel::Storage.drop_all
+    end
+  end
+  
+  desc "Create the database defined in config/database.yml for the current Rails.env - also creates the test database if Rails.env.development?"
+  task :drop, [:env] => :environment do |t, args|
+    args.with_defaults(:env => Rails.env)
+    
+    require 'sequel-rails/storage'
+    Rails::Sequel::Storage.new(args.env).drop
+    
+    if Rails.env.development? && Rails.configuration.database_configuration['test']
+      Rails::Sequel::Storage.new('test').drop
+    end
+  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
+      Rails::Sequel::Migrations.migrate_up!(version)
+      Rake::Task["db:schema:dump"].invoke if 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
+      Rails::Sequel::Migrations.migrate_down!(version)
+      Rake::Task["db:schema:dump"].invoke if Rails.env != 'test'
+    end
+  end
+  
+  desc 'Migrate the database to the latest version'
+  task :migrate => :'migrate:load' do
+    Rails::Sequel::Migrations.migrate_up!(ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke if 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 if 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 if Rails.env != 'test'
+  end
+  
+  desc 'Load the seed data from db/seeds.rb'
+  task :seed => :environment 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:migrate', '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 test database'
+  task :force_close_open_connections => :environment do
+    if Rails.env.test?
+       db_config = Rails.configuration.database_configuration[Rails.env].symbolize_keys
+       begin
+         #Will only work on Postgres > 8.4
+         Sequel::Model.db.execute <<-SQL.gsub(/^\s{9}/,'')
+         SELECT COUNT(pg_terminate_backend(procpid))
+         FROM  pg_stat_activity
+         WHERE datname = '#{db_config[: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
+    task :prepare do
+      Rails.env = 'test'
+      Rake::Task['db:force_close_open_connections'].invoke()
+      Rake::Task['db:reset'].invoke()
+      Sequel::DATABASES.each do |db|
+        db.disconnect
+      end
+    end
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'