vizzuality-sequel-rails 0.3.4

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::Sequel.configuration.environment_for(Rails.env))
+      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+        file.write db.dump_schema_migration(same_db: true)
+      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

data/lib/sequel-rails/setup.rb

@@ -0,0 +1,27 @@
+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 Rails
+  module Sequel
+
+    def self.connection(environment = nil)
+      environment ||= Rails.env
+      @@connections[environment] ||= setup(environment)
+    end
+
+    def self.setup(environment = nil)
+      environment ||= Rails.env
+      puts "[sequel-blat] Setting up the #{environment.inspect} environment:"
+
+      @@connections ||= {}
+      @@connections[environment] ||= ::Sequel.connect({:logger => configuration.logger}.merge(::Rails::Sequel.configuration.environment_for(environment.to_s)))
+      @@connections[environment]
+    end
+
+  end
+end

data/lib/sequel-rails/storage.rb

@@ -0,0 +1,222 @@
+module Rails
+  module Sequel
+
+    def self.storage
+      Storage
+    end
+
+    class Storage
+      attr_reader :config
+
+      def self.create_all
+        with_local_repositories { |config| create_environment(config) }
+      end
+
+      def self.drop_all
+        with_local_repositories { |config| drop_environment(config) }
+      end
+
+      def self.create_environment(config)
+        new(config).create
+      end
+
+      def self.drop_environment(config)
+        new(config).drop
+      end
+
+      def self.new(config)
+        config = Rails::Sequel.configuration.environments[config.to_s] unless config.kind_of?(Hash)
+
+        klass = lookup_class(config['adapter'])
+        if klass.equal?(self)
+          super(config)
+        else
+          klass.new(config)
+        end
+      end
+
+      class << self
+      private
+
+        def with_local_repositories
+          Rails::Sequel.configuration.environments.each_value do |config|
+            next if config['database'].blank?
+            if config['host'].blank? || %w[ 127.0.0.1 localhost ].include?(config['host'])
+              yield(config)
+            else
+              puts "This task only modifies local databases. #{config['database']} is on a remote host."
+            end
+          end
+        end
+
+        def lookup_class(adapter)
+          klass_name = adapter.camelize.to_sym
+
+          unless Storage.const_defined?(klass_name)
+            raise "Adapter #{adapter} not supported (#{klass_name.inspect})"
+          end
+
+          const_get(klass_name)
+        end
+
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def create
+        _create
+        puts "[sequel] Created database '#{database}'"
+      end
+
+      def drop
+        ::Sequel::Model.db.disconnect
+        _drop
+        puts "[sequel] Dropped database '#{database}'"
+      end
+
+      def database
+        @database ||= config['database'] || config['path']
+      end
+
+      def username
+        @username ||= config['username'] || config['user'] || ''
+      end
+
+      def password
+        @password ||= config['password'] || ''
+      end
+
+      def host
+        @host ||= config['host'] || ''
+      end
+
+      def port
+        @port ||= config['port'] || ''
+      end
+
+      def owner
+        @owner ||= config['owner'] || ''
+      end
+
+      def charset
+        @charset ||= config['charset'] || ENV['CHARSET'] || 'utf8'
+      end
+
+      class Sqlite < Storage
+        def _create
+          return if in_memory?
+          ::Sequel.connect(config.merge('database' => path))
+        end
+
+        def _drop
+          return if in_memory?
+          path.unlink if path.file?
+        end
+
+      private
+
+        def in_memory?
+          database == ':memory:'
+        end
+
+        def path
+          @path ||= Pathname(File.expand_path(database, Rails.root))
+        end
+
+      end
+
+      class Mysql < Storage
+        def _create
+          execute("CREATE DATABASE IF NOT EXISTS `#{database}` DEFAULT CHARACTER SET #{charset} DEFAULT COLLATE #{collation}")
+        end
+
+        def _drop
+          execute("DROP DATABASE IF EXISTS `#{database}`")
+        end
+
+      private
+
+        def execute(statement)
+          commands = ["mysql"]
+          commands << "--user" << username unless username.blank?
+          commands << "--password" << password unless password.blank?
+          commands << "--host" << host unless host.blank?
+          commands << "-e" << statement
+          system(*commands)
+        end
+
+        def collation
+          @collation ||= config['collation'] || ENV['COLLATION'] || 'utf8_unicode_ci'
+        end
+
+      end
+      class Mysql2 < Mysql
+      end
+
+      class Postgres < Storage
+        def _create
+          ENV["PGPASSWORD"] = password unless password.blank?
+          commands = ["createdb", "--encoding", charset]
+          commands << "--username" << username unless username.blank?
+          commands << "--owner" << owner unless owner.blank?
+          commands << "--port" << port.to_s unless port.blank?
+          commands << "--host" << host unless host.blank?
+          commands << database
+          res = system(*commands)
+          ENV["PGPASSWORD"] = nil
+          res
+        end
+
+        def _drop
+          system("dropdb", "-U", username, database)
+        end
+      end
+
+      class Jdbc < Storage
+
+        def _is_mysql?
+          database.match(/^jdbc:mysql/)
+        end
+
+        def _root_url
+          database.scan /^jdbc:mysql:\/\/\w*:?\d*/
+        end
+
+        def db_name
+          database.scan(/^jdbc:mysql:\/\/\w+:?\d*\/(\w+)/).flatten.first
+        end
+
+        def _params
+          database.scan /\?.*$/
+        end
+
+        def _create
+          if _is_mysql?
+            ::Sequel.connect("#{_root_url}#{_params}") do |db|
+              db.execute("CREATE DATABASE IF NOT EXISTS `#{db_name}` DEFAULT CHARACTER SET #{charset} DEFAULT COLLATE #{collation}")
+            end
+          end
+        end
+
+        def _drop
+          if _is_mysql?
+            ::Sequel.connect("#{_root_url}#{_params}") do |db|
+              db.execute("DROP DATABASE IF EXISTS `#{db_name}`")
+            end
+          end
+        end
+
+        private
+
+        def collation
+          @collation ||= config['collation'] || ENV['COLLATION'] || 'utf8_unicode_ci'
+        end
+
+
+      end
+
+    end
+  end
+end