sequel-rails 0.1.0

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,111 @@
+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
+
+      log_subscriber :sequel, ::Sequel::Railties::LogSubscriber.new
+
+      config.generators.orm :sequel, :migration => 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
+
+      # 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|
+        setup_sequel(app)
+      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
+
+      module Setup
+
+        def setup_sequel(app)
+          # preload_lib(app)
+          # preload_models(app)
+          Rails::Sequel.setup(Rails.env)
+        end
+
+        # def preload_lib(app)
+        #   app.config.paths.lib.each do |path|
+        #     Dir.glob("#{path}/**/*.rb").sort.each do |file|
+        #       require_dependency file unless file.match(/#{path}\/generators\/*/)
+        #     end
+        #   end
+        # end
+        # 
+        # def preload_models(app)
+        #   app.config.paths.app.models.each do |path|
+        #     Dir.glob("#{path}/**/*.rb").sort.each { |file| require_dependency file }
+        #   end
+        # end
+
+      end
+
+      extend Setup
+
+    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,45 @@
+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
+          # TODO add checks if Sequel is connected to a repository.
+          # If it is, do this, if it isn't, just delegate to super
+          db_rt_before_render = ::Sequel.repository.adapter.reset_runtime
+          runtime = super
+          db_rt_after_render = ::Sequel.repository.adapter.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,109 @@
+require 'sequel-rails/setup'
+require 'sequel-rails/storage'
+
+namespace :db do
+
+  task :load_models => :environment do
+    FileList["app/models/**/*.rb"].each { |model| load model }
+  end
+
+  desc 'Create the database, load the schema, and initialize with the seed data'
+  task :setup => [ 'db:create', 'db:migrate', 'db:seed' ]
+
+  namespace :test do
+    task :prepare => ['db:setup']
+  end
+
+  namespace :create do
+    desc 'Create all the local databases defined in config/database.yml'
+    task :all => :environment do
+      Rails::Sequel.storage.create_all
+    end
+  end
+
+  desc "Create the database(s) defined in config/database.yml for the current Rails.env - also creates the test database(s) if Rails.env.development?"
+  task :create => :environment do
+    Rails::Sequel.storage.create_environment(Rails::Sequel.configuration.environments[Rails.env])
+    if Rails.env.development? && Rails::Sequel.configuration.environments['test']
+      Rails::Sequel.storage.create_environment(Rails::Sequel.configuration.environments['test'])
+    end
+  end
+
+  namespace :drop do
+    desc 'Drop all the local databases defined in config/database.yml'
+    task :all => :environment do
+      Rails::Sequel.storage.drop_all
+    end
+  end
+
+  desc "Drops the database(s) for the current Rails.env - also drops the test database(s) if Rails.env.development?"
+  task :drop => :environment do
+    Rails::Sequel.storage.drop_environment(Rails::Sequel.configuration.environments[Rails.env])
+    if Rails.env.development? && Rails::Sequel.configuration.environments['test']
+      Rails::Sequel.storage.drop_environment(Rails::Sequel.configuration.environments['test'])
+    end
+  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
+
+  namespace :migrate do
+    task :load => :environment do
+      # FileList['db/migrate/*.rb'].each do |migration|
+      #   load migration
+      # end
+    end
+
+    desc 'Migrate up using migrations'
+    task :up, :version, :needs => :load do |t, args|
+      require 'sequel-rails/migrations'
+      ::Rails::Sequel::Migrations.migrate_up!(args[:version])
+    end
+
+    desc 'Migrate down using migrations'
+    task :down, :version, :needs => :load do |t, args|
+      require 'sequel-rails/migrations'
+      ::Rails::Sequel::Migrations.migrate_down!(args[:version])
+    end
+  end
+
+  ##
+  # TODO: deal with this at some point
+  #
+  # 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
+  #     File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+  #       file.puts(::Sequel::Model.db.schema())
+  #     end
+  #   end
+  #   
+  #   desc 'Load a schema.rb file into the database'
+  #   task :load => :environment do
+  #     
+  #   end
+  # end
+
+  desc 'Migrate the database to the latest version'
+  task :migrate => 'db:migrate:up'
+
+  namespace :sessions do
+    desc "Creates the sessions table for SequelStore"
+    task :create => :environment do
+      require 'sequel-rails/session_store'
+      Rails::Sequel::SessionStore::Session.auto_migrate!
+      puts "Created '#{::Rails::Sequel.configuration.environments[Rails.env]['database']}.sessions'"
+    end
+
+    desc "Clear the sessions table for SequelStore"
+    task :clear => :environment do
+      require 'sequel-rails/session_store'
+      Rails::Sequel::SessionStore::Session.delete()
+      puts "Deleted entries from '#{::Rails::Sequel.configuration.environments[Rails.env]['database']}.sessions'"
+    end
+  end
+
+end

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

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

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

@@ -0,0 +1,31 @@
+module Sequel
+  module Railties
+
+    class LogSubscriber < Rails::LogSubscriber
+
+      def sql(event)
+        name = '%s (%.1fms)' % [event.payload[:name], event.duration]
+        sql  = event.payload[:sql].squeeze(' ')
+
+        if odd?
+          name = color(name, :cyan, true)
+          sql  = color(sql, nil, true)
+        else
+          name = color(name, :magenta, true)
+        end
+
+        debug "  #{name}  #{sql}"
+      end
+
+      def odd?
+        @odd_or_even = !@odd_or_even
+      end
+
+      def logger
+        ::Sequel.logger
+      end
+
+    end
+
+  end
+end

data/lib/sequel-rails/session_store.rb

@@ -0,0 +1,82 @@
+require 'sequel'
+
+# Implements Sequel-specific session store.
+
+module Rails
+  module Sequel
+
+    class SessionStore < ActionDispatch::Session::AbstractStore
+
+      class Session < ::Sequel::Model
+
+        # property :id,         Serial
+        # property :session_id, String,   :required => true, :unique => true, :unique_index => true
+        # property :data,       Object,   :required => true, :default => ActiveSupport::Base64.encode64(Marshal.dump({}))
+        # property :updated_at, DateTime, :required => false, :index => true
+
+        class << self
+          
+          def auto_migrate!
+            self.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
+          
+        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
+end