nulogy-sequel-rails 0.3.8

data/lib/sequel/rails/log_subscriber.rb

@@ -0,0 +1,71 @@
+
+module Sequel::Rails
+  # This is copied straight from ActiveRecord::LogSubscriber
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["sequel_sql_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["sequel_sql_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+
+      return if 'SCHEMA' == payload[:name]
+
+      name  = '%s (%.1fms)' % [payload[:name], event.duration]
+      sql   = payload[:sql].squeeze(' ')
+      binds = nil
+
+      unless (payload[:binds] || []).empty?
+        binds = "  " + payload[:binds].map { |col,v|
+          [col.name, v]
+        }.inspect
+      end
+
+      if odd?
+        name = color(name, CYAN, true)
+        sql  = color(sql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{sql}#{binds}"
+    end
+
+    def identity(event)
+      return unless logger.debug?
+
+      name = color(event.payload[:name], odd? ? CYAN : MAGENTA, true)
+      line = odd? ? color(event.payload[:line], nil, true) : event.payload[:line]
+
+      debug "  #{name}  #{line}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+
+    def logger
+      Sequel::Rails.configuration.logger
+    end
+  end
+end
+
+Sequel::Rails::LogSubscriber.attach_to :sequel
+

data/lib/sequel/rails/migrations.rb

@@ -0,0 +1,22 @@
+
+require 'sequel/extensions/migration'
+
+module Sequel
+  module Rails
+    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,76 @@
+
+require File.expand_path('../../rails', __FILE__)
+
+if not defined?(Rails)
+  raise "Rails must be loaded before Sequel::Rails::Railtie is loaded"
+end
+if Rails.version.to_i < 3
+  raise "sequel-rails requires Rails >= 3"
+end
+
+module Sequel
+  module Rails
+    require libpath('sequel/rails/railties/i18n_support')
+    require libpath('sequel/rails/railties/controller_runtime')
+
+    class Railtie < ::Rails::Railtie
+      config.sequel = Sequel::Rails.configuration
+
+      Sequel::Rails::LogSubscriber.attach_to :sequel
+
+      config.app_generators.orm :sequel, :migration => true
+
+      config.action_dispatch.rescue_responses.merge!(
+        # If a record cannot be found within an action (resulting from a call
+        # to #find!, which is a method we patch into Sequel::Model), then rescue
+        # it as a 404
+        'Sequel::Plugins::RailsExtensions::ModelNotFound' => :not_found,
+        # If a record fails validation within an action, rescue it as a 500
+        'Sequel::ValidationFailed'                        => :unprocessable_entity,
+        # If something bad happens, rescue it as a 500
+        'Sequel::NoExistingObject'                        => :unprocessable_entity
+      )
+
+      rake_tasks do
+        load Sequel::Rails.libpath('sequel/rails/railties/database.rake')
+      end
+
+      initializer 'sequel.logger' do |app|
+        app.config.sequel.logger ||=
+          if defined?(Logging)
+            Logging.logger['Sequel']
+          else
+            ::Rails.logger
+          end
+      end
+
+      initializer 'sequel.i18n_support' do |app|
+        Sequel::Model.class_eval { include Sequel::Rails::Railties::I18nSupport }
+      end
+
+      # Expose database runtime to controller for logging.
+      initializer 'sequel.log_runtime' do |app|
+        ActiveSupport.on_load(:action_controller) do
+          include Sequel::Rails::Railties::ControllerRuntime
+        end
+      end
+
+      initializer 'sequel.connect' do |app|
+        Sequel::Rails.configuration.init_database(app.config.database_configuration)
+        Sequel::Rails.connect(::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.raise_on_save_failure = false
+        Sequel::Model.plugin :active_model
+        Sequel::Model.plugin :validation_helpers
+        # This is our own plugin
+        Sequel::Model.plugin :rails_extensions
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+
+require 'active_support/core_ext/module/attr_internal'
+
+module Sequel::Rails::Railties
+  # This is copied straight from ActiveRecord::Railties::ControllerRuntime
+  module ControllerRuntime
+    extend ActiveSupport::Concern
+
+  protected
+    attr_internal :db_runtime
+
+    def process_action(action, *args)
+      # We also need to reset the runtime before each action
+      # because of queries in middleware or in cases we are streaming
+      # and it won't be cleaned up by the method below.
+      Sequel::Rails::LogSubscriber.reset_runtime
+      super
+    end
+
+    def cleanup_view_runtime
+      if Sequel::Rails.connected?
+        db_rt_before_render = Sequel::Rails::LogSubscriber.reset_runtime
+        runtime = super
+        db_rt_after_render = Sequel::Rails::LogSubscriber.reset_runtime
+        self.db_runtime = db_rt_before_render + db_rt_after_render
+        runtime - db_rt_after_render
+      else
+        super
+      end
+    end
+
+    def append_info_to_payload(payload)
+      super
+      if Sequel::Rails.connected?
+        payload[:db_runtime] = (db_runtime || 0) + Sequel::Rails::LogSubscriber.reset_runtime
+      end
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages, db_runtime = super, payload[:db_runtime]
+        messages << ("Sequel: %.1fms" % db_runtime.to_f) if db_runtime
+        messages
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,185 @@
+
+# TODO: DRY these up
+# TODO: Add task to create sessions table
+
+######################################################
+# BEWARE: Regular Expressions of DOOOOOOOOOOOOOOOOOM #
+######################################################
+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 => :environment do
+      Sequel.extension :schema_dumper
+      db = Sequel::Rails.db
+      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+        database = db.dump_schema_migration(same_db: true)
+        # 0. Add schema_migrations info (mucho importante!)
+        filenames = db[:schema_migrations].map{|x| x[:filename]}
+        statements = filenames.sort.map do |f|
+          "self[:schema_migrations].insert(:filename => \"#{f}\")"
+        end
+
+        inserts = statements.map do |s|
+          "    #{s}"
+        end.join("\n")
+
+        database.gsub!(/(create_table\(:schema_migrations\) do.+?end)/m, '\1'+"\n\n#{inserts}\n")
+
+        # 1. Fuck arbitrary whitespaces.
+        database.gsub!(/\s+$/,"\n")
+
+        # 2. Add new line at end of file
+        database += "\n"
+        file.write database
+      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)
+        Sequel::Migration.descendants.first.apply(::Sequel::Model.db, :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
+      require 'sequel/rails/storage'
+      Sequel::Rails::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)
+
+    require 'sequel/rails/storage'
+    Sequel::Rails::Storage.new(args.env).create
+  end
+
+  namespace :drop do
+    desc 'Drops all the local databases defined in config/database.yml'
+    task :all => :environment do
+      require 'sequel/rails/storage'
+      Sequel::Rails::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)
+
+    require 'sequel/rails/storage'
+    Sequel::Rails::Storage.new(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
+      Sequel::Rails::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
+      Sequel::Rails::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
+    Sequel::Rails::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: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 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:drop'].invoke()
+      Rake::Task['db:create'].invoke()
+      Rake::Task['db:schema:load'].invoke()
+      Sequel::DATABASES.each do |db|
+        db.disconnect
+      end
+    end
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'
+

data/lib/sequel/rails/railties/i18n_support.rb

@@ -0,0 +1,9 @@
+
+module Sequel::Rails::Railties
+  module I18nSupport
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope
+      :sequel
+    end
+  end
+end

data/lib/sequel/rails/session_store.rb

@@ -0,0 +1,69 @@
+
+module Sequel::Rails
+  # Database-backed session store, with a Sequel model as the interface to the
+  # session table.
+  #
+  # Note that Rails will not use this by default (since the default store is
+  # CookieStore). To use it, you'll need to add this to config/application.rb:
+  #
+  #   config.session_store(Sequel::Rails::SessionStore)
+  #
+  class SessionStore < ActionDispatch::Session::AbstractStore
+    class Session < Sequel::Model
+      def self.auto_migrate!
+        db.create_table :sessions do
+          primary_key :id
+          column :session_id, String,
+                 :null    => false,
+                 :unique  => true,
+                 :index   => true
+
+          column :data, :text,
+                 :null => false
+
+          column :updated_at, DateTime,
+                 :null => true,
+                 :index => true
+        end
+      end
+
+      def self.name
+        'session'
+      end
+    end
+
+    SESSION_RECORD_KEY = 'rack.session.record'.freeze
+
+    cattr_accessor :session_class
+    self.session_class = Session
+
+  private
+    def get_session(env, sid)
+      sid ||= generate_sid
+      session = find_session(sid)
+      env[SESSION_RECORD_KEY] = session
+      [ sid, session.data ]
+    end
+
+    def set_session(env, sid, session_data)
+      session            = get_session_resource(env, sid)
+      session.data       = session_data
+      session.updated_at = Time.now if session.dirty?
+      session.save
+    end
+
+    def get_session_resource(env, sid)
+      if env[ENV_SESSION_OPTIONS_KEY][:id].nil?
+        env[SESSION_RECORD_KEY] = find_session(sid)
+      else
+        env[SESSION_RECORD_KEY] ||= find_session(sid)
+      end
+    end
+
+    def find_session(sid)
+      klass = self.class.session_class
+
+      klass.where(:session_id => sid).first || klass.new(:session_id => sid)
+    end
+  end
+end

data/lib/sequel/rails/setup.rb

@@ -0,0 +1,14 @@
+require 'active_support/core_ext/hash/except'
+
+require 'sequel/extensions/migration'
+
+require 'sequel/rails/configuration'
+require 'sequel/rails/runtime'
+require 'sequel/rails/railties/benchmarking_mixin'
+
+module Sequel
+  module Rails
+
+
+  end
+end