sequelizer 0.1.4 → 0.1.6

data/lib/sequelizer/yaml_config.rb

@@ -4,9 +4,11 @@ require 'erb'
 
 module Sequelizer
   class YamlConfig
+
     attr_reader :config_file_path
 
     class << self
+
       def local_config
         new
       end
@@ -16,19 +18,22 @@ module Sequelizer
       end
 
       def user_config_path
-        return nil unless ENV['HOME']
-        Pathname.new(ENV['HOME']) + ".config" + "sequelizer" + "database.yml"
+        return nil unless Dir.home
+
+        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 + "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
     def options
       return {} unless config_file_path.exist?
+
       config[environment] || config
     end
 
@@ -51,5 +56,6 @@ module Sequelizer
     def config
       @config ||= Psych.load(ERB.new(File.read(config_file_path)).result)
     end
+
   end
 end

data/lib/sequelizer.rb

@@ -4,37 +4,93 @@ require_relative 'sequelizer/monkey_patches/database_in_after_connect'
 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
+# or .env files, providing an easy-to-use interface for establishing database
+# connections without hardcoding sensitive information.
+#
+# == Usage
+#
 # Include this module in any class where you'd like to quickly establish
-# a Sequel connection to a database.
+# a Sequel connection to a database:
+#
+#   class MyClass
+#     include Sequelizer
+#
+#     def some_method
+#       db[:users].all  # Uses cached connection
+#     end
+#   end
+#
+# == Configuration Sources
+#
+# Configuration is loaded from multiple sources in order of precedence:
+# 1. Passed options
+# 2. .env file
+# 3. Environment variables
+# 4. config/database.yml
+# 5. ~/.config/sequelizer/database.yml
+#
+# == Examples
+#
+#   # Use cached connection
+#   db[:users].all
+#
+#   # Create new connection with custom options
+#   new_db(adapter: 'postgres', host: 'localhost')
+#
 module Sequelizer
+
+  # Returns the default options hash for database connections.
+  #
+  # @return [Hash] the default connection options
   def self.options
     Options.new.to_hash
   end
 
-  # Instantiates and memoizes a database connection.  The +db+ method instantiates
+  # Instantiates and memoizes a database connection. The +db+ method instantiates
   # the connection on the first call and then memoizes itself so only a single
-  # connection is used on repeated calls
+  # connection is used on repeated calls.
   #
-  # options :: an optional set of database connection options.
-  #            If no options are provided, options are read from
-  #            config/sequelizer.yml or from .env or from environment variables.
+  # @param options [Hash] an optional set of database connection options.
+  #   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
+  #
+  # @example
+  #   db[:users].all  # Uses cached connection
+  #   db(adapter: 'postgres')[:products].count
   def db(options = {})
     @_sequelizer_db ||= new_db(options)
   end
 
   # Instantiates and returns a new database connection on each call.
   #
-  # options :: an optional set of database connection options.
-  #            If no options are provided, options are read from
-  #            config/sequelizer.yml or from .env or from environment variables.
+  # @param options [Hash] an optional set of database connection options.
+  #   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
+  #
+  # @example
+  #   conn1 = new_db
+  #   conn2 = new_db  # Different connection instance
+  #   new_db(force_new: true)  # Bypasses cache entirely
   def new_db(options = {})
     cached = find_cached(options)
     return cached if cached && !options[:force_new]
+
     @_sequelizer_cache[options] = ConnectionMaker.new(options).connection
   end
 
+  # Finds a cached connection for the given options.
+  #
+  # @param options [Hash] the connection options to look up
+  # @return [Sequel::Database, nil] the cached connection or nil if not found
   def find_cached(options)
     @_sequelizer_cache ||= {}
     @_sequelizer_cache[options]
   end
+
 end

data/sequelizer.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'sequelizer/version'
 
@@ -8,23 +7,29 @@ Gem::Specification.new do |spec|
   spec.version       = Sequelizer::VERSION
   spec.authors       = ['Ryan Duryea']
   spec.email         = ['aguynamedryan@gmail.com']
-  spec.summary       = %q{Sequel database connections via config/database.yml or .env}
-  spec.description   = %q{Easily establish a connection to a database via Sequel gem using options specified in config/database.yml or .env files}
+  spec.summary       = 'Sequel database connections via config/database.yml or .env'
+  spec.description   = 'Easily establish a connection to a database via Sequel gem using options specified in config/database.yml or .env files'
   spec.homepage      = 'https://github.com/outcomesinsights/sequelizer'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.2.0'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'guard', '~> 2.0'
   spec.add_development_dependency 'guard-minitest', '~> 2.3'
   spec.add_development_dependency 'minitest', '~> 5.3'
+  spec.add_development_dependency 'pg', '~> 1.0'
   spec.add_development_dependency 'rake', '~> 12.0'
-  spec.add_dependency 'sequel', '~> 5.0'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-minitest', '~> 0.25'
+  spec.add_development_dependency 'simplecov', '~> 0.22'
+  spec.add_dependency 'activesupport', '~> 7.0'
   spec.add_dependency 'dotenv', '~> 2.1'
-  spec.add_dependency 'thor', '~> 1.0'
   spec.add_dependency 'hashie', '~> 3.2'
+  spec.add_dependency 'sequel', '~> 5.93'
+  spec.add_dependency 'thor', '~> 1.0'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/test/lib/sequel/extensions/test_cold_col.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative '../../../test_helper'
+require_relative '../../../../lib/sequel/extensions/cold_col'
+
+describe Sequel::ColdColDatabase do
+  let(:db) do
+    @db = Sequel.mock.extension(:cold_col)
+    @db.cold_col_registry.set_schemas({
+                                        Sequel.lit('tab1') => [[:col1]],
+                                        Sequel.lit('tab2') => [[:col2]],
+                                        Sequel.lit('tab3') => [[:col3], [:col4]],
+                                        Sequel.lit('q.tab4') => [[:col5]],
+                                      })
+    @db.extend_datasets do
+      def supports_cte?
+        true
+      end
+    end
+
+    # Add with method to mock database to support CTEs
+    def @db.with(*args)
+      dataset.with(*args)
+    end
+
+    @db
+  end
+
+  def expect_columns(ds, *cols)
+    _(ds.columns).must_equal(cols)
+  end
+
+  it 'should know columns from select * FROM tab' do
+    expect_columns(db[:tab1], :col1)
+  end
+
+  it 'should know columns after append' do
+    expect_columns(db[:tab1].select_append(Sequel.function(:min, :col1).as(:mini)), :col1, :mini)
+  end
+
+  it 'should know columns after select_all' do
+    expect_columns(db[:tab1].select_all, :col1)
+  end
+
+  it 'should know columns after select_all(:tab1)' do
+    expect_columns(db[:tab1].select_all(:tab1), :col1)
+  end
+
+  it 'should know columns after from_self' do
+    expect_columns(db[:tab1].from_self, :col1)
+  end
+
+  it 'should know columns after a CTE' do
+    ds = db[:cte1]
+         .with(:cte1, db[:tab1])
+    expect_columns(ds, :col1)
+  end
+
+  it 'should know columns after a JOIN' do
+    ds = db[:tab1]
+         .join(:tab2)
+    expect_columns(ds, :col1, :col2)
+  end
+
+  it 'should know columns after a different kind of JOIN' do
+    ds = db[:tab1]
+         .join(db[:tab2])
+    expect_columns(ds, :col1, :col2)
+  end
+
+  it 'should know columns from a JOIN and CTE' do
+    ds = db[:tab1]
+         .with(:cte1, db[:tab2])
+         .join(db[:cte1])
+    expect_columns(ds, :col1, :col2)
+  end
+
+  it 'should know columns from a select_all JOIN' do
+    ds = db[:tab1]
+         .join(db[:tab2], { Sequel[:tab1][:col1] => Sequel[:tab2][:col3] })
+         .select_all(:tab1)
+    expect_columns(ds, :col1)
+  end
+
+  it 'should know columns from an aliased select_all JOIN' do
+    ds = db[:tab1].from_self(alias: :l)
+                  .join(db[:tab2], { col3: :col1 })
+                  .select_all(:l)
+    expect_columns(ds, :col1)
+  end
+
+  it 'should know columns from an aliased select_all and added rhs column JOIN' do
+    ds = db[:tab1].from_self(alias: :l)
+                  .join(db[:tab2], { col3: :col1 }, table_alias: :r)
+                  .select_all(:l)
+                  .select_append(Sequel[:r][:col4])
+    expect_columns(ds, :col1, :col4)
+  end
+
+  it 'should know columns from an aliased select_all rhs JOIN' do
+    ds = db[:tab1].from_self(alias: :l)
+                  .join(db[:tab2], { col3: :col1 }, table_alias: :r)
+                  .select_all(:r)
+    expect_columns(ds, :col2)
+  end
+
+  it 'should know columns from a directly aliased select_all rhs JOIN' do
+    ds = db[:tab1].from_self(alias: :l)
+                  .join(:tab2, { col3: :col1 }, table_alias: :r)
+                  .select_all(:r)
+    expect_columns(ds, :col2)
+  end
+
+  it 'should know columns from a a qualified JOIN' do
+    ds = db[:tab1].from_self(alias: :l)
+                  .join(Sequel[:q][:tab4], { col3: :col1 }, table_alias: :r)
+                  .select_all(:r)
+    expect_columns(ds, :col5)
+  end
+  it 'should remember columns from ctas' do
+    db.create_table(:ctas_table, as: db.select(Sequel[1].as(:a)))
+    ds = db[:ctas_table]
+    expect_columns(ds, :a)
+  end
+
+  it 'should remember columns from create table' do
+    db.create_table(:ddl_table) do
+      String :a
+    end
+    ds = db[:ddl_table]
+    expect_columns(ds, :a)
+  end
+
+  it 'should remember columns from view' do
+    db.create_view(:ctas_view, db.select(Sequel[1].as(:a)))
+    ds = db[:ctas_view]
+    expect_columns(ds, :a)
+  end
+
+  it 'should ignore columns when asked, thus avoiding an issue with string-only SQL' do
+    assert_raises(NoMethodError) { db.create_view(:ctas_view, 'SELECT 1 AS A') }
+    db.create_view(:ctas_view, 'SELECT 1 AS A', dont_record: true)
+  end
+
+  it 'should handle load_schema with empty file' do
+    require 'tempfile'
+    require 'yaml'
+
+    Tempfile.create(['schema', '.yml']) do |f|
+      f.write({}.to_yaml)
+      f.flush
+
+      db.load_schema(f.path)
+      # Should not raise error and schemas should remain unchanged
+      expect_columns(db[:tab1], :col1)
+    end
+  end
+
+  it 'should handle add_table_schema with symbol and string table names' do
+    db.add_table_schema(:new_table, [[:col_a, {}], [:col_b, {}]])
+    db.add_table_schema('string_table', [[:col_c, {}]])
+
+    expect_columns(db[:new_table], :col_a, :col_b)
+    expect_columns(db[:string_table], :col_c)
+  end
+
+  it 'should handle complex nested CTEs' do
+    ds = db.with(:cte1, db[:tab1])
+           .with(:cte2, db[:cte1].select(:col1))
+           .from(:cte2)
+    expect_columns(ds, :col1)
+  end
+
+  it 'should handle qualified table names in schema' do
+    expect_columns(db[Sequel[:q][:tab4]], :col5)
+  end
+
+  it 'should handle aliased expressions in select' do
+    ds = db[:tab1].select(Sequel[:col1].as(:renamed_col))
+    expect_columns(ds, :renamed_col)
+  end
+
+  it 'should handle function calls with aliases' do
+    ds = db[:tab1].select(Sequel.function(:count, :col1).as(:count_col1))
+    expect_columns(ds, :count_col1)
+  end
+
+  it 'should handle multiple table joins with mixed syntax' do
+    ds = db[:tab1]
+         .join(:tab2, { col2: :col1 })
+         .join(db[:tab3].as(:t3), { col3: :col1 })
+    expect_columns(ds, :col1, :col2, :col3, :col4)
+  end
+
+  it 'should handle recursive schema merging with load_schema' do
+    require 'tempfile'
+    require 'yaml'
+
+    # First schema file
+    Tempfile.create(['schema1', '.yml']) do |f1|
+      f1.write({ 'initial_table' => { columns: { 'col_x' => {} } } }.to_yaml)
+      f1.flush
+      db.load_schema(f1.path)
+
+      # Second schema file
+      Tempfile.create(['schema2', '.yml']) do |f2|
+        f2.write({ 'second_table' => { columns: { 'col_y' => {} } } }.to_yaml)
+        f2.flush
+        db.load_schema(f2.path)
+
+        # Both schemas should be available
+        expect_columns(db[:initial_table], :col_x)
+        expect_columns(db[:second_table], :col_y)
+      end
+    end
+  end
+
+  # Additional tests to ensure refactoring preserves behavior
+  describe 'Internal schema lookup behavior' do
+    it 'should prioritize created tables over schemas' do
+      db.add_table_schema(:priority_test, [[:schema_col, {}]])
+      db.create_table(:priority_test) do
+        String :created_col
+      end
+      expect_columns(db[:priority_test], :created_col)
+    end
+
+    it 'should handle deeply nested WITH clauses' do
+      ds = db[:cte1]
+           .with(:cte1, db[:tab1])
+           .with(:cte2, db[:cte1])
+           .with(:cte3, db[:cte2])
+           .from(:cte3)
+      expect_columns(ds, :col1)
+    end
+
+    it 'should handle mixed aliased and non-aliased sources' do
+      ds = db[:tab1].from_self(alias: :t1)
+                    .join(:tab2, { col2: :col1 })
+                    .join(db[:tab3].as(:t3), { col3: :col1 })
+                    .select_all(:t1)
+                    .select_append(Sequel[:t3][:col4])
+      expect_columns(ds, :col1, :col4)
+    end
+
+    it 'should handle column lookup with empty select lists' do
+      ds = db.from(db[:tab1].where(id: 1))
+      expect_columns(ds, :col1)
+    end
+  end
+end

data/test/lib/sequel/extensions/test_db_opts.rb

@@ -3,10 +3,11 @@ require 'sequel'
 require 'sequel/extensions/db_opts'
 
 class TestDbOpts < Minitest::Test
+
   def with_fake_database_type_and_options(db_type, opts = {})
     db = Sequel.mock
-    db.define_singleton_method(:database_type){db_type}
-    db.define_singleton_method(:opts){opts}
+    db.define_singleton_method(:database_type) { db_type }
+    db.define_singleton_method(:opts) { opts }
     db.extension :db_opts
     yield db
   end
@@ -21,20 +22,21 @@ class TestDbOpts < Minitest::Test
   end
 
   def test_should_detect_options_for_appropriate_db
-    assert_equal(sql_for(:postgres, postgres_db_opt_flim: :flam), ["SET flim=flam"])
+    assert_equal(['SET flim=flam'], sql_for(:postgres, postgres_db_opt_flim: :flam))
   end
 
   def test_should_ignore_options_for_inappropriate_db
-    assert_equal(sql_for(:postgres, postgres_db_opt_flim: :flam, other_db_opt_foo: :bar), ["SET flim=flam"])
+    assert_equal(['SET flim=flam'], sql_for(:postgres, postgres_db_opt_flim: :flam, other_db_opt_foo: :bar))
   end
 
   def test_should_ignore_non_db_opts
-    assert_equal(sql_for(:postgres, postgres_flim: :flam), [])
+    assert_empty(sql_for(:postgres, postgres_flim: :flam))
   end
 
   def test_should_properly_quote_awkward_values
-    assert_equal(sql_for(:postgres, postgres_db_opt_str: "hello there", postgres_db_opt_hyphen: "i-like-hyphens-though-they-are-dumb"),
-      ["SET str='hello there'", "SET hyphen='i-like-hyphens-though-they-are-dumb'"])
+    assert_equal(["SET str='hello there'", "SET hyphen='i-like-hyphens-though-they-are-dumb'"],
+                 sql_for(:postgres, postgres_db_opt_str: 'hello there',
+                                    postgres_db_opt_hyphen: 'i-like-hyphens-though-they-are-dumb'))
   end
-end
 
+end