sequel-rails-cartodb 0.1.7

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.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 => :environment do
+      Sequel.extension :schema_dumper
+      db = Sequel.connect(Rails.configuration.database_configuration[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'

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 < ActiveSupport::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
+        ::Rails::Sequel.configuration.logger
+      end
+
+    end
+
+  end
+end

data/lib/sequel-rails/runtime.rb

@@ -0,0 +1,14 @@
+module Rails
+  module Sequel
+   
+    class << self
+      def reset_runtime
+        @runtime ||= 0
+        
+        rt, @runtime = @runtime, 0
+        rt
+      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