sequel-rails 0.7.0 → 0.8.0

data/lib/sequel_rails/configuration.rb

@@ -1,7 +1,6 @@
 require 'active_support/core_ext/class/attribute_accessors'
 
 module SequelRails
-
   mattr_accessor :configuration
 
   def self.setup(environment)
@@ -9,7 +8,6 @@ module SequelRails
   end
 
   class Configuration < ActiveSupport::OrderedOptions
-
     def self.for(root, database_yml_hash)
       ::SequelRails.configuration ||= begin
         config = new
@@ -35,7 +33,7 @@ module SequelRails
     end
 
     def environments
-      @environments ||= raw.inject({}) do |normalized, environment|
+      @environments ||= raw.reduce({}) do |normalized, environment|
         name, config = environment.first, environment.last
         normalized[name] = normalize_repository_config(config)
         normalized
@@ -44,47 +42,45 @@ module SequelRails
 
     def connect(environment)
       normalized_config = environment_for environment
-      db = if normalized_config['url']
+      if normalized_config['url']
         ::Sequel.connect normalized_config['url'], normalized_config
       else
         ::Sequel.connect normalized_config
-      end
-      after_connect.call if after_connect.respond_to?(:call)
-      db
+      end.tap { after_connect.call if after_connect.respond_to?(:call) }
     end
 
-  private
+    private
 
     def default_schema_dump
-      not %w(test production).include? Rails.env
+      !%w(test production).include? Rails.env
     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
+        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
 
       # always use jdbc when running jruby
       if SequelRails.jruby?
         if config['adapter']
           case config['adapter'].to_sym
-            when :postgres
-              config['adapter'] = :postgresql
+          when :postgres
+            config['adapter'] = :postgresql
           end
           config['adapter'] = "jdbc:#{config['adapter']}"
         end
@@ -95,29 +91,27 @@ module SequelRails
       config['search_path'] = search_path if search_path
 
       # some adapters only support an url
-      if config['adapter'] && config['adapter'] =~ /^(jdbc|do):/ && !config.has_key?('url')
+      if config['adapter'] && config['adapter'] =~ /^(jdbc|do):/ && !config.key?('url')
         params = {}
         config.each do |k, v|
-          next if ['adapter', 'host', 'port', 'database'].include?(k)
+          next if %w(adapter host port database).include?(k)
           if k == 'search_path'
-            v = v.split(',').map &:strip unless v.is_a? Array
-            v = URI::escape(v.join(','))
+            v = v.split(',').map(&:strip) unless v.is_a? Array
+            v = URI.escape(v.join(','))
           end
           params[k] = v
         end
         params_str = params.map { |k, v| "#{k}=#{v}" }.join('&')
         port = config['port'] ? ":#{config['port']}" : ''
-        config['url'] ||= case config['adapter']
-        when /sqlite/
-          "%s:%s" % [config['adapter'], config['database']]
+        config['url'] ||=
+        if config['adapter'].include?('sqlite')
+          sprintf('%s:%s', config['adapter'], config['database'])
         else
-          "%s://%s%s/%s?%s" % [config['adapter'], config['host'], port, config['database'], params_str]
+          sprintf('%s://%s%s/%s?%s', config['adapter'], config['host'], port, config['database'], params_str)
         end
       end
 
       config
     end
-
   end
-
 end

data/lib/sequel_rails/migrations.rb

@@ -3,7 +3,7 @@ require 'sequel/extensions/migration'
 module SequelRails
   class Migrations
     class << self
-      def migrate(version=nil)
+      def migrate(version = nil)
         opts = {}
         opts[:target] = version.to_i if version
         ::Sequel::Migrator.run(::Sequel::Model.db, migrations_dir, opts)
@@ -16,10 +16,10 @@ module SequelRails
         !::Sequel::Migrator.is_current?(::Sequel::Model.db, migrations_dir)
       end
 
-      def dump_schema_information(opts={})
+      def dump_schema_information(opts = {})
         sql = opts.fetch :sql
         db = ::Sequel::Model.db
-        res = ""
+        res = ''
 
         if available_migrations?
           migrator_class = ::Sequel::Migrator.send(:migrator_class, migrations_dir)
@@ -40,7 +40,7 @@ module SequelRails
       end
 
       def migrations_dir
-        Rails.root.join("db/migrate")
+        Rails.root.join('db/migrate')
       end
 
       def available_migrations?

data/lib/sequel_rails/railtie.rb

@@ -1,7 +1,7 @@
-require "sequel"
+require 'sequel'
 
-require "rails"
-require "active_model/railtie"
+require 'rails'
+require 'active_model/railtie'
 
 # Comment taken from active_record/railtie.rb
 #
@@ -9,37 +9,35 @@ require "active_model/railtie"
 # 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 '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/database/active_support_notification"
+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/database/active_support_notification'
 
 module SequelRails
+  autoload :SessionStore, 'sequel_rails/session_store'
 
   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::NoMatchingRow" => :not_found,
-      "Sequel::ValidationFailed" => :unprocessable_entity,
-      "Sequel::NoExistingObject" => :unprocessable_entity
+      'Sequel::Plugins::RailsExtensions::ModelNotFound' => :not_found,
+      'Sequel::NoMatchingRow' => :not_found,
+      'Sequel::ValidationFailed' => :unprocessable_entity,
+      'Sequel::NoExistingObject' => :unprocessable_entity
     )
 
     config.sequel = ::SequelRails::Configuration.new
 
     rake_tasks do |app|
-      if app.config.sequel.load_database_tasks
-        load "sequel_rails/railties/database.rake"
-      end
+      load 'sequel_rails/railties/database.rake' if app.config.sequel.load_database_tasks
     end
 
     initializer 'sequel.configuration' do |app|
@@ -84,7 +82,5 @@ module SequelRails
     def setup_logger(app, logger)
       app.config.sequel.logger = logger
     end
-
   end
-
 end

data/lib/sequel_rails/railties/controller_runtime.rb

@@ -1,10 +1,8 @@
-require "active_support/core_ext/module/attr_internal"
+require 'active_support/core_ext/module/attr_internal'
 
 module SequelRails
   module Railties
-
     module ControllerRuntime
-
       extend ActiveSupport::Concern
 
       protected
@@ -25,16 +23,12 @@ module SequelRails
       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 << sprintf('Models: %.1fms', db_runtime.to_f) if db_runtime
           messages
         end
-
       end
-
     end
-
   end
 end

data/lib/sequel_rails/railties/database.rake

@@ -8,59 +8,59 @@ namespace :db do
   end
 
   # desc "Raises an error if there are pending migrations"
-  task :abort_if_pending_migrations => [:environment, "db:migrate:load"] do
+  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.}
+      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"
+    desc 'Create a db/schema.rb file that can be portably used against any DB supported by Sequel'
     task :dump => :environment do
       db_for_current_env.extension :schema_dumper
       filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
-      File.open filename, "w" do |file|
+      File.open filename, 'w' do |file|
         file << db_for_current_env.dump_schema_migration(:same_db => true)
         file << SequelRails::Migrations.dump_schema_information(:sql => false)
       end
-      Rake::Task["db:schema:dump"].reenable
+      Rake::Task['db:schema:dump'].reenable
     end
 
-    desc "Load a schema.rb file into the database"
+    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.each{|m| m.apply(db_for_current_env, :up)}
+        ::Sequel::Migration.descendants.each { |m| m.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}
+        abort "#{file} doesn't exist yet. Run 'rake db:migrate' to create it, then try again."
       end
     end
   end
 
   namespace :structure do
-    desc "Dump the database structure to db/structure.sql. Specify another file with DB_STRUCTURE=db/my_structure.sql"
+    desc 'Dump the database structure to db/structure.sql'
     task :dump, [:env] => :environment do |t, args|
       args.with_defaults(:env => Rails.env)
 
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, 'db', 'structure.sql')
       if SequelRails::Storage.dump_environment args.env, filename
-        ::File.open filename, "a" do |file|
+        ::File.open filename, 'a' do |file|
           file << SequelRails::Migrations.dump_schema_information(:sql => true)
         end
       else
         abort "Could not dump structure for #{args.env}."
       end
 
-      Rake::Task["db:structure:dump"].reenable
+      Rake::Task['db:structure:dump'].reenable
     end
 
     task :load, [:env] => :environment do |t, args|
       args.with_defaults(:env => Rails.env)
 
-      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, 'db', 'structure.sql')
       unless SequelRails::Storage.load_environment args.env, filename
         abort "Could not load structure for #{args.env}."
       end
@@ -70,9 +70,9 @@ namespace :db do
   task :dump => :environment do
     case (SequelRails.configuration.schema_format ||= :ruby)
     when :ruby
-      Rake::Task["db:schema:dump"].invoke
+      Rake::Task['db:schema:dump'].invoke
     when :sql
-      Rake::Task["db:structure:dump"].invoke
+      Rake::Task['db:structure:dump'].invoke
     else
       abort "unknown schema format #{SequelRails.configuration.schema_format}"
     end
@@ -81,9 +81,9 @@ namespace :db do
   task :load => :environment do
     case (SequelRails.configuration.schema_format ||= :ruby)
     when :ruby
-      Rake::Task["db:schema:load"].invoke
+      Rake::Task['db:schema:load'].invoke
     when :sql
-      Rake::Task["db:structure:load"].invoke
+      Rake::Task['db:structure:load'].invoke
     else
       abort "unknown schema format #{SequelRails.configuration.schema_format}"
     end
@@ -92,13 +92,11 @@ namespace :db do
   namespace :create do
     desc 'Create all the local databases defined in config/database.yml'
     task :all => :environment do
-      unless SequelRails::Storage.create_all
-        abort "Could not create all databases."
-      end
+      abort 'Could not create all databases.' unless SequelRails::Storage.create_all
     end
   end
 
-  desc "Create the database defined in config/database.yml for the current Rails.env"
+  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)
 
@@ -110,13 +108,11 @@ namespace :db do
   namespace :drop do
     desc 'Drops all the local databases defined in config/database.yml'
     task :all => :environment do
-      unless SequelRails::Storage.drop_all
-        warn "Couldn't drop all databases"
-      end
+      warn "Couldn't drop all databases" unless SequelRails::Storage.drop_all
     end
   end
 
-  desc "Drop the database defined in config/database.yml for the current Rails.env"
+  desc 'Drop 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)
 
@@ -132,39 +128,39 @@ namespace :db do
 
     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
+      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
+        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"]
+    task :reset => %w(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
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      fail 'VERSION is required' unless version
       SequelRails::Migrations.migrate_up!(version)
-      Rake::Task["db:dump"].invoke if SequelRails.configuration.schema_dump
+      Rake::Task['db:dump'].invoke if SequelRails.configuration.schema_dump
     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
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      fail 'VERSION is required' unless version
       SequelRails::Migrations.migrate_down!(version)
-      Rake::Task["db:dump"].invoke if SequelRails.configuration.schema_dump
+      Rake::Task['db:dump'].invoke if SequelRails.configuration.schema_dump
     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:dump"].invoke if SequelRails.configuration.schema_dump
+  task :migrate => 'migrate:load' do
+    SequelRails::Migrations.migrate_up!(ENV['VERSION'] ? ENV['VERSION'].to_i : nil)
+    Rake::Task['db:dump'].invoke if SequelRails.configuration.schema_dump
   end
 
   desc 'Load the seed data from db/seeds.rb'
@@ -174,10 +170,10 @@ namespace :db do
   end
 
   desc 'Create the database, load the schema, and initialize with the seed data'
-  task :setup => [ 'db:create', 'db:load', 'db:seed' ]
+  task :setup => %w(db:create db: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' ]
+  task :reset => %w(db:drop db:setup)
 
   desc 'Forcibly close any open connections to the current env database (PostgreSQL specific)'
   task :force_close_open_connections, [:env] => :environment do |t, args|
@@ -186,8 +182,8 @@ namespace :db do
   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
+    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:drop'].execute
       Rake::Task['db:create'].execute
@@ -200,4 +196,4 @@ namespace :db do
   end
 end
 
-task "test:prepare" => "db:test:prepare"
+task 'test:prepare' => 'db:test:prepare'

data/lib/sequel_rails/railties/i18n_support.rb

@@ -1,10 +1,8 @@
 module SequelRails
-
   module I18nSupport
     # Set the i18n scope to overwrite ActiveModel.
     def i18n_scope #:nodoc:
       :sequel
     end
   end
-
 end

data/lib/sequel_rails/railties/legacy_model_config.rb

@@ -1,4 +1,4 @@
-require "sequel_rails/sequel/plugins/rails_extensions"
+require 'sequel_rails/sequel/plugins/rails_extensions'
 
 ::Sequel::Model.plugin :active_model
 ::Sequel::Model.plugin :validation_helpers

data/lib/sequel_rails/railties/log_subscriber.rb

@@ -1,14 +1,12 @@
 module SequelRails
   module Railties
-
     class LogSubscriber < ActiveSupport::LogSubscriber
-
       def self.runtime=(value)
-        Thread.current["sequel_sql_runtime"] = value
+        Thread.current['sequel_sql_runtime'] = value
       end
 
       def self.runtime
-        Thread.current["sequel_sql_runtime"] ||= 0
+        Thread.current['sequel_sql_runtime'] ||= 0
       end
 
       def self.reset_runtime
@@ -22,14 +20,14 @@ module SequelRails
 
         payload = event.payload
 
-        name = '%s (%.1fms)' % [payload[:name], event.duration]
+        name = sprintf('%s (%.1fms)', payload[:name], event.duration)
         sql  = payload[:sql].squeeze(' ')
         binds = nil
 
         unless (payload[:binds] || []).empty?
-          binds = "  " + payload[:binds].map { |col,v|
+          binds = '  ' + payload[:binds].map do |col, v|
             [col.name, v]
-          }.inspect
+          end.inspect
         end
 
         if odd?
@@ -49,8 +47,6 @@ module SequelRails
       def logger
         ::SequelRails.configuration.logger
       end
-
     end
-
   end
 end

data/lib/sequel_rails/sequel/database/active_support_notification.rb

@@ -1,15 +1,14 @@
-require "sequel/database/logging"
-require "active_support/notifications"
+require 'sequel/database/logging'
+require 'active_support/notifications'
 
 module Sequel
   class Database
-
-    def log_yield(sql, args=nil)
+    def log_yield(sql, args = nil)
       sql_for_log = args ? "#{sql}; #{args.inspect}" : sql
       start = Time.now
       begin
         ::ActiveSupport::Notifications.instrument(
-          "sql.sequel",
+          'sql.sequel',
           :sql => sql,
           :name => self.class,
           :binds => args
@@ -23,6 +22,5 @@ module Sequel
         log_duration(Time.now - start, sql_for_log) unless e || @loggers.empty?
       end
     end
-
   end
 end

data/lib/sequel_rails/sequel/plugins/rails_extensions.rb

@@ -1,4 +1,4 @@
-require "sequel"
+require 'sequel'
 
 module Sequel
   module Plugins
@@ -25,11 +25,10 @@ module Sequel
       module ClassMethods
         def find!(args)
           m = self[args]
-          raise ModelNotFound, "Couldn't find #{self} matching #{args}." unless m
+          fail ModelNotFound, "Couldn't find #{self} matching #{args}." unless m
           m
         end
       end
-
     end
   end
 end

data/lib/sequel_rails/session_store.rb

@@ -1,49 +1,15 @@
-require "sequel"
+require 'sequel'
 
 # Implements Sequel-specific session store.
 
 module SequelRails
-
   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
+    def self.session_class
+      @@session_class ||= Class.new(Sequel::Model(:sessions))
+    end
 
     private
 
@@ -51,7 +17,7 @@ module SequelRails
       sid ||= generate_sid
       session = find_session(sid)
       env[SESSION_RECORD_KEY] = session
-      [ sid, session.data ]
+      [sid, session.data]
     end
 
     def set_session(env, sid, session_data)
@@ -71,10 +37,8 @@ module SequelRails
 
     def find_session(sid)
       klass = self.class.session_class
-      
+
       klass.where(:session_id => sid).first || klass.new(:session_id => sid)
     end
-
   end
-
 end