sequelizer 0.3.0 → 0.4.0

data/lib/sequelizer/connection_maker.rb

@@ -1,7 +1,17 @@
-require 'sequel'
-require_relative 'options'
+require "sequel"
+require_relative "options"
 
 module Sequelizer
+  # Raised when no configuration source names an adapter or a URL, so there
+  # is no database to connect to.
+  class MissingAdapterError < ArgumentError
+    def initialize(msg = nil)
+      super(msg || "no database configured: none of the passed options, .env, SEQUELIZER_* " \
+                   "environment variables, config/sequelizer.yml or ~/.config/sequelizer/database.yml " \
+                   "sets an :adapter or a :url")
+    end
+  end
+
   # = ConnectionMaker
   #
   # Class that handles loading/interpreting the database options and
@@ -14,7 +24,6 @@ module Sequelizer
   #   maker = ConnectionMaker.new(adapter: 'postgres', host: 'localhost')
   #   db = maker.connection
   class ConnectionMaker
-
     # @!attribute [r] options
     #   @return [Options] the database connection options
     attr_reader :options
@@ -25,10 +34,11 @@ module Sequelizer
     # in order of precedence:
     # 1. .env file
     # 2. Environment variables
-    # 3. config/database.yml
+    # 3. config/sequelizer.yml
     # 4. ~/.config/sequelizer/database.yml
     #
-    # @param options [Hash, nil] database connection options
+    # @param options [Hash, String, nil] database connection options, or a
+    #   database URL String, which is the same as passing <tt>{ url: string }</tt>
     # @option options [String] :adapter database adapter (e.g., 'postgres', 'mysql2')
     # @option options [String] :host database host
     # @option options [Integer] :port database port
@@ -46,6 +56,7 @@ module Sequelizer
     # using the configured options.
     #
     # @return [Sequel::Database] configured database connection
+    # @raise [MissingAdapterError] if no source sets an adapter or a URL
     # @raise [Sequel::Error] if connection fails
     #
     # @example
@@ -53,6 +64,8 @@ module Sequelizer
     #   users = connection[:users].all
     def connection
       opts = options.to_hash
+      raise MissingAdapterError unless opts[:adapter] || opts[:url] || opts[:uri]
+
       extensions = options.extensions
 
       conn = create_sequel_connection(opts)
@@ -62,18 +75,36 @@ module Sequelizer
 
     private
 
+    # Connects with an after_connect proc that applies db_opts to every new
+    # connection. The proc needs the Database, which Sequel does not pass to
+    # after_connect, so it closes over +db+. Sequel hands the Database to
+    # :before_preconnect before it makes any connection (preconnect, the
+    # :extensions option, and the connection test all come after it), so
+    # that is where +db+ is assigned.
     def create_sequel_connection(opts)
+      db = nil
+      user_after_connect = opts[:after_connect]
+      user_before_preconnect = opts[:before_preconnect]
+
+      opts = opts.merge(
+        before_preconnect: proc do |database|
+          db = database
+          user_before_preconnect&.call(database)
+        end,
+        after_connect: proc do |conn, server|
+          if user_after_connect
+            user_after_connect.arity == 2 ? user_after_connect.call(conn, server) : user_after_connect.call(conn)
+          end
+          db.extension :db_opts
+          db.db_opts.apply(conn)
+        end,
+      )
+
       if (url = opts.delete(:uri) || opts.delete(:url))
         Sequel.connect(url, opts)
       else
-        configure_adapter_specific_options(opts)
         Sequel.connect(opts)
       end
     end
-
-    def configure_adapter_specific_options(opts)
-      # No adapter-specific configuration needed currently
-    end
-
   end
 end

data/lib/sequelizer/env_config.rb

@@ -1,10 +1,9 @@
-require 'dotenv'
+require "dotenv"
 
 module Sequelizer
   # Creates a set of database configuration options from environment
   # variables
   class EnvConfig
-
     # Any environment variables in the .env file are loaded and then
     # any environment variable starting with SEQUELIZER_ will be used
     # as an option for the database
@@ -12,7 +11,7 @@ module Sequelizer
       Dotenv.load
 
       seq_config = ENV.keys.grep(/^SEQUELIZER_/).each_with_object({}) do |key, config|
-        new_key = key.gsub(/^SEQUELIZER_/, '').downcase
+        new_key = key.gsub(/^SEQUELIZER_/, "").downcase
         config[new_key] = ENV.fetch(key, nil)
       end
 
@@ -23,6 +22,5 @@ module Sequelizer
 
       db_config.merge(seq_config)
     end
-
   end
 end

data/lib/sequelizer/options.rb

@@ -1,7 +1,6 @@
-require 'uri'
-require_relative 'yaml_config'
-require_relative 'env_config'
-require_relative 'options_hash'
+require "uri"
+require_relative "yaml_config"
+require_relative "env_config"
 
 module Sequelizer
   # = Options
@@ -20,7 +19,7 @@ module Sequelizer
   # 1. Passed options (highest priority)
   # 2. .env file
   # 3. Environment variables
-  # 4. config/database.yml
+  # 4. config/sequelizer.yml
   # 5. ~/.config/sequelizer/database.yml (lowest priority)
   #
   # @example Basic usage
@@ -32,16 +31,22 @@ module Sequelizer
   #   options = Options.new
   #   puts options.adapter  # => 'postgres'
   class Options
-
     # @!attribute [r] extensions
     #   @return [Array<Symbol>] list of Sequel extensions to load
     attr_reader :extensions
 
+    # The three names of the PostgreSQL search path, in the order that decides
+    # between them when one source sets more than one.
+    SEARCH_PATH_KEYS = %i[search_path schema_search_path schema].freeze
+
     # Creates a new Options instance, processing configuration from multiple sources.
     #
     # @param options [Hash, String, nil] database connection options or connection URL
     #   If a Hash is provided, it will be merged with configuration from other sources.
-    #   If a String is provided, it's treated as a database URL and returned as-is.
+    #   If a String is provided, it is a database URL, the way Sequel.connect accepts one:
+    #   <tt>Options.new("postgres://host/db")</tt> is the same as
+    #   <tt>Options.new(url: "postgres://host/db")</tt>, so it is merged with the other
+    #   sources too.
     #   If nil, configuration is loaded entirely from external sources.
     def initialize(options = nil)
       opts = fix_options(options)
@@ -50,13 +55,13 @@ module Sequelizer
 
     # Returns the processed options as a hash suitable for Sequel.connect.
     #
-    # @return [Hash] the database connection options
+    # @return [Hash{Symbol => Object}] the database connection options, keyed by Symbol
     def to_hash
       @options
     end
 
     # Define accessor methods for common database options
-    %w[adapter database username password search_path].each do |name|
+    %i[adapter database username password search_path].each do |name|
       # @!method #{name}
       #   @return [String, nil] the #{name} option value
       define_method(name) do
@@ -66,77 +71,75 @@ module Sequelizer
 
     private
 
-    # Creates an after_connect callback proc that handles custom callbacks
-    # and applies database-specific options.
-    #
-    # @param opts [Hash] options hash that may contain an :after_connect callback
-    # @return [Proc] callback to be executed after database connection
-    def make_ac(opts)
-      proc do |conn, server, db|
-        if (ac = opts[:after_connect])
-          ac.arity == 2 ? ac.call(conn, server) : ac.call(conn)
-        end
-        db.extension :db_opts
-        db.db_opts.apply(conn)
-      end
-    end
-
     # Processes and fixes the passed options, handling various input types
     # and applying adapter-specific transformations.
     #
-    # If passed a hash, scans hash for certain options and sets up hash
-    # to be fed to Sequel.connect. Handles PostgreSQL schema setup and
-    # timeout conversion.
+    # Scans the options for certain keys and sets up a hash to be fed to
+    # Sequel.connect. Handles PostgreSQL schema setup and timeout conversion.
+    # A String is a database URL and is processed as <tt>{ url: string }</tt>.
     #
-    # If passed anything else (like a string that represents a database URL),
-    # the value is returned without modification.
+    # For PostgreSQL, +search_path+, +schema_search_path+ and +schema+ are three
+    # names for one option. The highest-precedence source that sets any of them
+    # decides the search path; within that source, the names rank in the order of
+    # SEARCH_PATH_KEYS. The search path setup runs on each new connection, and
+    # then any +after_connect+ the caller passed.
     #
     # @param passed_options [Hash, String, nil] the options to process
-    # @return [Hash, String] processed options or original string
+    # @return [Hash{Symbol => Object}] processed options
     def fix_options(passed_options)
-      return passed_options unless passed_options.nil? || passed_options.is_a?(Hash)
-
-      opts = OptionsHash.new(passed_options || {}).to_hash
-      sequelizer_options = db_config(opts).merge(opts)
+      passed_options = { url: passed_options } if passed_options.is_a?(String)
+      opts = symbolize_keys(passed_options || {})
+      sources = [ opts, *config_sources(opts) ]
+      sequelizer_options = sources.reverse.reduce({}, :merge)
 
       adapter = sequelizer_options[:adapter]
       adapter ||= URI.parse(sequelizer_options[:url].to_s).scheme if sequelizer_options[:url]
 
       if adapter =~ /^postgres/
-        sequelizer_options[:adapter] = 'postgres'
-        paths = %w[search_path schema_search_path schema].map { |key| sequelizer_options.delete(key) }.compact
+        sequelizer_options[:adapter] = "postgres"
+        search_path = sources.filter_map { |source| source.values_at(*SEARCH_PATH_KEYS).compact.first }.first
+        SEARCH_PATH_KEYS.each { |key| sequelizer_options.delete(key) }
 
-        unless paths.empty?
-          sequelizer_options[:search_path] = paths.first
-          sequelizer_options[:after_connect] = after_connect(paths.first)
+        if search_path
+          sequelizer_options[:search_path] = search_path
+          sequelizer_options[:after_connect] = after_connect(search_path, sequelizer_options[:after_connect])
         end
       end
 
-      if sequelizer_options[:timeout]
-        # I'm doing a merge! here because the indifferent access part
-        # of OptionsHash seemed to not work when I tried
-        # sequelizer_options[:timeout] = sequelizer_options[:timeout].to_i
-        sequelizer_options.merge!(timeout: sequelizer_options[:timeout].to_i)
-      end
+      sequelizer_options[:timeout] = sequelizer_options[:timeout].to_i if sequelizer_options[:timeout]
 
-      sequelizer_options.merge(after_connect: make_ac(sequelizer_options))
+      sequelizer_options
     end
 
-    # Loads database configuration from external sources in order of precedence.
-    # Sources checked (in order):
-    # - ~/.config/sequelizer.yml (if it exists and not ignored)
-    # - config/database.yml (if it exists and not ignored)
-    # - environment variables (including .env file if not ignored)
+    # Loads database configuration from the external sources that +opts+ does
+    # not ignore. They are read in this order:
+    # - ~/.config/sequelizer/database.yml (unless +:ignore_yaml+)
+    # - config/sequelizer.yml (unless +:ignore_yaml+)
+    # - environment variables, including the .env file (unless +:ignore_env+)
     #
-    # @param opts [Hash] base options that may contain ignore flags
-    # @return [OptionsHash] merged configuration from all sources
-    def db_config(opts)
-      @db_config ||= begin
-        opts = OptionsHash.new(opts)
-        opts.merge!(YamlConfig.user_config.options) unless opts[:ignore_yaml]
-        opts.merge!(YamlConfig.local_config.options) unless opts[:ignore_yaml]
-        opts.merge!(EnvConfig.new.options) unless opts[:ignore_env]
-        opts
+    # @param opts [Hash] passed options that may contain ignore flags
+    # @return [Array<Hash{Symbol => Object}>] one hash per source, highest
+    #   precedence first
+    def config_sources(opts)
+      sources = []
+      sources << YamlConfig.user_config.options unless opts[:ignore_yaml]
+      sources << YamlConfig.local_config.options unless opts[:ignore_yaml]
+      sources << EnvConfig.new.options unless opts[:ignore_env]
+      sources.reverse.map { |source| symbolize_keys(source) }
+    end
+
+    # Returns a copy of +value+ with every Hash key, at any depth, converted
+    # to a Symbol. Options arrive with String keys from YAML, ENV, and some
+    # callers; Sequel expects Symbols, including for nested hashes such as
+    # +:servers+, which it indexes by server name.
+    #
+    # @param value [Object] a Hash, an Array, or any other value
+    # @return [Object] the converted copy; the caller's objects are not modified
+    def symbolize_keys(value)
+      case value
+      when Hash then value.to_h { |k, v| [ k.to_sym, symbolize_keys(v) ] }
+      when Array then value.map { |v| symbolize_keys(v) }
+      else value
       end
     end
 
@@ -146,23 +149,29 @@ module Sequelizer
     # For PostgreSQL connections with a search_path defined, this proc will:
     # 1. Create each schema in the search path if it doesn't exist
     # 2. Set the search_path for the connection
+    # 3. Call +user_after_connect+, if given, with the connection (and the
+    #    server, if it takes two arguments, as Sequel does)
     #
     # @param search_path [String, Array<String>] PostgreSQL schema names as a
     #   comma-separated string, an Array of schema names, or a mixed Array
     #   containing comma-separated strings
+    # @param user_after_connect [Proc, nil] the caller's own after_connect
     # @return [Proc] callback to execute after connection
     # @example String input
     #   callback = after_connect('public,app_schema')
     # @example Array input
     #   callback = after_connect(['public', 'app_schema'])
-    def after_connect(search_path)
-      schemas = Array(search_path).flat_map { |p| p.to_s.split(',') }.map(&:strip)
-      path_string = schemas.join(', ')
-      proc do |conn|
+    def after_connect(search_path, user_after_connect = nil)
+      schemas = Array(search_path).flat_map { |p| p.to_s.split(",") }.map(&:strip)
+      path_string = schemas.join(", ")
+      proc do |conn, server|
         schemas.each do |schema|
           conn.execute("CREATE SCHEMA IF NOT EXISTS #{schema}")
         end
         conn.execute("SET search_path TO #{path_string}")
+        if user_after_connect
+          user_after_connect.arity == 2 ? user_after_connect.call(conn, server) : user_after_connect.call(conn)
+        end
       end
     end
 
@@ -184,10 +193,9 @@ module Sequelizer
       extension_keys = options.keys.select { |k| k.to_s =~ extension_regexp }
       extensions = extension_keys.map do |key|
         options.delete(key)
-        key.to_s.gsub(extension_regexp, '').to_sym
+        key.to_s.gsub(extension_regexp, "").to_sym
       end
-      [options, extensions]
+      [ options, extensions ]
     end
-
   end
 end

data/lib/sequelizer/version.rb

@@ -1,6 +1,4 @@
 module Sequelizer
-
   # Version for the gem
-  VERSION = '0.3.0'.freeze
-
+  VERSION = "0.4.0".freeze
 end

data/lib/sequelizer/yaml_config.rb

@@ -1,13 +1,11 @@
-require 'psych'
-require 'erb'
+require "psych"
+require "erb"
 
 module Sequelizer
   class YamlConfig
-
     attr_reader :config_file_path
 
     class << self
-
       def local_config
         new
       end
@@ -19,24 +17,24 @@ module Sequelizer
       def user_config_path
         return nil unless Dir.home
 
-        Pathname.new(Dir.home).join('.config', 'sequelizer', 'database.yml')
+        Pathname.new(Dir.home).join(".config", "sequelizer", "database.yml")
       end
-
     end
 
     def initialize(config_file_path = nil)
-      @config_file_path = Pathname.new(config_file_path || Pathname.pwd.join('config', 'sequelizer.yml')).expand_path
+      @config_file_path = Pathname.new(config_file_path || Pathname.pwd.join("config", "sequelizer.yml")).expand_path
     end
 
-    # Returns a set of options pulled from config/database.yml
-    # or +nil+ if config/database.yml doesn't exist
+    # Returns a set of options pulled from the YAML file at +config_file_path+
+    # (config/sequelizer.yml by default), or an empty hash if that file
+    # doesn't exist
     def options
       return {} unless config_file_path.exist?
 
       config[environment] || config
     end
 
-    # The environment to load from database.yml
+    # The environment to load from the YAML file
     #
     # Searches the following environment variables in this order:
     # * SEQUELIZER_ENV
@@ -46,15 +44,14 @@ module Sequelizer
     # Lastly, if none of those environment variables are specified, the
     # environment defaults to 'development'
     def environment
-      ENV['SEQUELIZER_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      ENV["SEQUELIZER_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
     end
 
     private
 
-    # The config as read from config/database.yml
+    # The config as read from the YAML file at +config_file_path+
     def config
       @config ||= Psych.load(ERB.new(File.read(config_file_path)).result)
     end
-
   end
 end

data/lib/sequelizer.rb

@@ -1,13 +1,12 @@
-require_relative 'sequelizer/version'
-require_relative 'sequelizer/connection_maker'
-require_relative 'sequelizer/monkey_patches/database_in_after_connect'
-require_relative 'sequel/extensions/db_opts'
-require_relative 'sequel/extensions/settable'
+require_relative "sequelizer/version"
+require_relative "sequelizer/connection_maker"
+require_relative "sequel/extensions/db_opts"
+require_relative "sequel/extensions/settable"
 
 # = Sequelizer
 #
 # Sequelizer is a Ruby gem that simplifies database connections using Sequel.
-# It allows users to configure database connections via config/database.yml
+# It allows users to configure database connections via config/sequelizer.yml
 # or .env files, providing an easy-to-use interface for establishing database
 # connections without hardcoding sensitive information.
 #
@@ -30,7 +29,7 @@ require_relative 'sequel/extensions/settable'
 # 1. Passed options
 # 2. .env file
 # 3. Environment variables
-# 4. config/database.yml
+# 4. config/sequelizer.yml
 # 5. ~/.config/sequelizer/database.yml
 #
 # == Examples
@@ -42,7 +41,6 @@ require_relative 'sequel/extensions/settable'
 #   new_db(adapter: 'postgres', host: 'localhost')
 #
 module Sequelizer
-
   # Returns the default options hash for database connections.
   #
   # @return [Hash] the default connection options
@@ -54,7 +52,8 @@ module Sequelizer
   # the connection on the first call and then memoizes itself so only a single
   # connection is used on repeated calls.
   #
-  # @param options [Hash] an optional set of database connection options.
+  # @param options [Hash, String] an optional set of database connection options,
+  #   or a database URL string, which means { url: string }.
   #   If no options are provided, options are read from config/sequelizer.yml
   #   or from .env or from environment variables.
   # @return [Sequel::Database] the memoized database connection
@@ -68,7 +67,8 @@ module Sequelizer
 
   # Instantiates and returns a new database connection on each call.
   #
-  # @param options [Hash] an optional set of database connection options.
+  # @param options [Hash, String] an optional set of database connection options,
+  #   or a database URL string, which means { url: string }.
   #   If no options are provided, options are read from config/sequelizer.yml
   #   or from .env or from environment variables.
   # @return [Sequel::Database] a new database connection
@@ -78,6 +78,7 @@ module Sequelizer
   #   conn2 = new_db  # Different connection instance
   #   new_db(force_new: true)  # Bypasses cache entirely
   def new_db(options = {})
+    options = { url: options } if options.is_a?(String)
     cached = find_cached(options)
     return cached if cached && !options[:force_new]
 
@@ -86,11 +87,12 @@ module Sequelizer
 
   # Finds a cached connection for the given options.
   #
-  # @param options [Hash] the connection options to look up
+  # @param options [Hash, String] the connection options to look up, or a
+  #   database URL string, which means { url: string }
   # @return [Sequel::Database, nil] the cached connection or nil if not found
   def find_cached(options)
+    options = { url: options } if options.is_a?(String)
     @_sequelizer_cache ||= {}
     @_sequelizer_cache[options]
   end
-
 end