sequelizer 0.2.0 → 0.3.0

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

@@ -1,109 +0,0 @@
-require_relative '../../../test_helper'
-require 'sequel'
-require 'sequel/extensions/settable'
-
-class TestSettable < Minitest::Test
-
-  def test_should_register_extension
-    db = Sequel.mock(host: :sqlite)
-
-    assert_respond_to db, :extension
-    db.extension :settable
-
-    assert_respond_to db, :set
-  end
-
-  def test_set_with_single_option
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(search_path: 'public')
-
-    assert_equal(['SET search_path=public'], db.sqls)
-  end
-
-  def test_set_with_multiple_options
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(search_path: 'public', timezone: 'UTC')
-
-    expected_sqls = ['SET search_path=public', 'SET timezone=UTC']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-  def test_set_with_empty_hash
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set({})
-
-    assert_empty(db.sqls)
-  end
-
-  def test_set_with_no_arguments
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set
-
-    assert_empty(db.sqls)
-  end
-
-  def test_set_with_string_values
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(work_mem: '256MB', statement_timeout: '30s')
-
-    expected_sqls = ['SET work_mem=256MB', 'SET statement_timeout=30s']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-  def test_set_with_numeric_values
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(port: 5432, max_connections: 100)
-
-    expected_sqls = ['SET port=5432', 'SET max_connections=100']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-  def test_set_with_boolean_values
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(autocommit: true, log_statement: false)
-
-    expected_sqls = ['SET autocommit=true', 'SET log_statement=false']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-  def test_set_with_nil_values
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-    db.set(timezone: nil, search_path: nil)
-
-    expected_sqls = ['SET timezone=', 'SET search_path=']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-  def test_set_sql_private_method
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-
-    refute_respond_to db, :set_sql
-  end
-
-  def test_multiple_set_calls
-    db = Sequel.mock(host: :sqlite)
-    db.extension :settable
-
-    db.set(timezone: 'UTC')
-    db.set(search_path: 'public')
-
-    expected_sqls = ['SET timezone=UTC', 'SET search_path=public']
-
-    assert_equal expected_sqls, db.sqls
-  end
-
-end

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

@@ -1,231 +0,0 @@
-require_relative '../../../test_helper'
-require 'sequel'
-require 'sequel/extensions/sql_recorder'
-
-class TestSqlRecorder < Minitest::Test
-
-  def setup
-    # Use mock database for these tests since we're not conflicting anymore
-    @db = Sequel.mock
-    @db.extension :sql_recorder
-  end
-
-  def test_extension_registration
-    assert_respond_to @db, :sql_recorder
-  end
-
-  def test_sql_recorder_initialized_as_empty_array
-    assert_instance_of Array, @db.sql_recorder
-    assert_empty @db.sql_recorder
-  end
-
-  def test_records_select_statements
-    @db[:users].all
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('SELECT * FROM users') || sql.include?('SELECT * FROM `users`')
-    end, 'Should record the SELECT statement')
-  end
-
-  def test_records_insert_statements
-    @db[:users].insert(name: 'John', email: 'john@example.com', age: 30)
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('INSERT INTO users') || sql.include?('INSERT INTO `users`')
-    end, 'Should record INSERT statement')
-    assert(@db.sql_recorder.any? { |sql| sql.include?('John') }, 'Should include the data')
-  end
-
-  def test_records_update_statements
-    @db[:users].where(id: 1).update(name: 'Jane')
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('UPDATE users SET') || sql.include?('UPDATE `users` SET')
-    end, 'Should record UPDATE statement')
-    assert(@db.sql_recorder.any? { |sql| sql.include?('Jane') }, 'Should include the updated data')
-  end
-
-  def test_records_delete_statements
-    @db[:users].where(id: 1).delete
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('DELETE FROM users') || sql.include?('DELETE FROM `users`')
-    end, 'Should record DELETE statement')
-  end
-
-  def test_records_multiple_sql_statements
-    initial_count = @db.sql_recorder.length
-
-    @db[:users].all
-    @db[:posts].where(id: 1).first
-    @db[:comments].count
-
-    assert_operator(@db.sql_recorder.length, :>=, initial_count + 3, 'Should record at least 3 more SQL statements')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('SELECT * FROM users') || sql.include?('SELECT * FROM `users`')
-    end, 'Should record users query')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('SELECT * FROM posts WHERE (id = 1)')
-    end, 'Should record posts query')
-    assert(@db.sql_recorder.any? do |sql|
-      sql.include?('SELECT count(*) AS count FROM comments')
-    end, 'Should record count query')
-  end
-
-  def test_sql_recorder_accumulates_across_multiple_operations
-    initial_count = @db.sql_recorder.length
-
-    @db[:users].all
-    count_after_first = @db.sql_recorder.length
-
-    assert_operator(count_after_first, :>, initial_count, 'Should record first query')
-
-    @db[:posts].first
-    count_after_second = @db.sql_recorder.length
-
-    assert_operator(count_after_second, :>, count_after_first, 'Should record second query')
-
-    @db[:comments].insert(text: 'Hello')
-    count_after_third = @db.sql_recorder.length
-
-    assert_operator(count_after_third, :>, count_after_second, 'Should record third query')
-  end
-
-  def test_sql_recorder_persists_until_manually_cleared
-    @db[:users].all
-    @db[:posts].all
-
-    assert_operator(@db.sql_recorder.length, :>=, 2, 'Should record multiple statements')
-
-    # Manually clear (this is how consumers would reset the log)
-    @db.sql_recorder.clear
-
-    assert_empty @db.sql_recorder
-
-    @db[:comments].all
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record new statements after clear')
-  end
-
-  def test_handles_complex_queries_with_joins
-    @db[:users].join(:posts, user_id: :id).where(Sequel[:users][:active] => true).all
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    recorded_sql = @db.sql_recorder.join(' ')
-
-    assert_includes(recorded_sql, 'SELECT', 'Should contain SELECT')
-    assert(recorded_sql.include?('FROM users') || recorded_sql.include?('FROM `users`'), 'Should contain FROM users')
-    assert_includes(recorded_sql, 'JOIN', 'Should contain JOIN')
-  end
-
-  def test_handles_queries_with_parameters
-    @db[:users].where(name: 'John', age: 25).all
-
-    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
-    recorded_sql = @db.sql_recorder.join(' ')
-
-    assert_includes(recorded_sql, 'John', 'Should include name parameter')
-    assert_includes(recorded_sql, '25', 'Should include age parameter')
-  end
-
-  def test_thread_safety_with_concurrent_queries
-    threads = []
-
-    10.times do |i|
-      threads << Thread.new do
-        @db[:table].where(id: i).first
-      end
-    end
-
-    threads.each(&:join)
-
-    # Should have recorded all 10 queries
-    assert_operator(@db.sql_recorder.length, :>=, 10, 'Should record at least 10 queries')
-    (0..9).each do |i|
-      assert(@db.sql_recorder.any? { |sql| sql.include?("WHERE (id = #{i})") }, "Should record query for id #{i}")
-    end
-  end
-
-  def test_module_extension_method_initializes_properly
-    # Test the self.extended method directly
-    fresh_db = Sequel.mock
-    fresh_db.extend(Sequel::SqlRecorder)
-    Sequel::SqlRecorder.extended(fresh_db)
-
-    assert_respond_to fresh_db, :sql_recorder
-    assert_instance_of Array, fresh_db.sql_recorder
-    assert_instance_of Mutex, fresh_db.instance_variable_get(:@sql_recorder_mutex)
-  end
-
-  def test_sql_recorder_mutex_is_initialized
-    assert_instance_of Mutex, @db.instance_variable_get(:@sql_recorder_mutex)
-  end
-
-  def test_extension_can_be_added_to_existing_database
-    plain_db = Sequel.mock
-
-    refute_respond_to plain_db, :sql_recorder
-
-    plain_db.extension :sql_recorder
-
-    assert_respond_to plain_db, :sql_recorder
-    assert_instance_of Array, plain_db.sql_recorder
-  end
-
-  def test_sql_recorder_does_not_conflict_with_mock_sqls
-    # Test that our sql_recorder doesn't interfere with mock's sqls
-    mock_db = Sequel.mock
-    mock_db.extension :sql_recorder
-
-    # Both should work independently
-    assert_respond_to mock_db, :sqls # Mock's built-in
-    assert_respond_to mock_db, :sql_recorder # Our extension
-
-    # Execute a query
-    mock_db[:test].all
-
-    # Both should record (though possibly differently)
-    assert_instance_of Array, mock_db.sqls
-    assert_instance_of Array, mock_db.sql_recorder
-  end
-
-  def test_database_extension_registration
-    # Test that the extension is properly registered with Sequel
-    # Check that we can load the extension without error
-    fresh_db = Sequel.mock
-    fresh_db.extension :sql_recorder
-
-    assert_respond_to fresh_db, :sql_recorder
-  end
-
-  def test_attr_reader_sql_recorder_works
-    # Directly test the attr_reader
-    assert_same @db.instance_variable_get(:@sql_recorder), @db.sql_recorder
-  end
-
-  def test_log_connection_yield_method_exists
-    assert_respond_to @db, :log_connection_yield
-    assert_includes Sequel::SqlRecorder.instance_methods, :log_connection_yield
-  end
-
-  def test_manual_sql_recording_functionality
-    # Test that we can manually record SQL using the method structure
-    test_sql = 'SELECT * FROM manual_test'
-
-    # Verify sql_recorder starts empty or with existing content
-    initial_count = @db.sql_recorder.length
-
-    # Manually add SQL using the same structure as log_connection_yield
-    @db.instance_variable_get(:@sql_recorder_mutex).synchronize do
-      @db.sql_recorder.push(test_sql)
-    end
-
-    assert_equal initial_count + 1, @db.sql_recorder.length
-    assert_includes @db.sql_recorder, test_sql
-  end
-
-end

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

@@ -1,76 +0,0 @@
-require_relative '../../../test_helper'
-require 'sequel'
-
-class TestUnionize < Minitest::Test
-
-  def test_should_unionize_a_single_dataset
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    ds = db.unionize([db[:a]])
-
-    # No SQL should be executed
-    assert_empty(db.sqls)
-    # The SQL should be a single select
-    assert_equal('SELECT * FROM `a`', ds.sql)
-  end
-
-  def test_should_unionize_two_datasets
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    ds = db.unionize([db[:a], db[:b]])
-
-    # No SQL should be executed
-    assert_empty(db.sqls)
-    # The SQL should be a single select
-    assert_equal('SELECT * FROM (SELECT * FROM `a` UNION SELECT * FROM `b`) AS `t1`', ds.sql)
-  end
-
-  def test_should_unionize_two_datasets_and_allow_all_option
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    ds = db.unionize([db[:a], db[:b]], all: true)
-
-    # No SQL should be executed
-    assert_empty(db.sqls)
-    # The SQL should be a single select
-    assert_equal('SELECT * FROM (SELECT * FROM `a` UNION ALL SELECT * FROM `b`) AS `t1`', ds.sql)
-  end
-
-  def test_should_unionize_two_datasets_and_allow_from_self_option
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    ds = db.unionize([db[:a], db[:b]], from_self: false)
-
-    # No SQL should be executed
-    assert_empty(db.sqls)
-    # The SQL should be a single select
-    assert_equal('SELECT * FROM `a` UNION SELECT * FROM `b`', ds.sql)
-  end
-
-  def test_should_unionize_four_datasets_as_sets_of_two
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    ds = db.unionize([db[:a], db[:b], db[:c], db[:d]], chunk_size: 2, from_self: false)
-
-    # Two things should be created
-    assert_equal(
-      [
-        'CREATE TEMPORARY VIEW `temp_union_ac554bd85a4a6087511d4949f3a3c5a59c110cde` AS SELECT * FROM `a` UNION SELECT * FROM `b`',
-        'CREATE TEMPORARY VIEW `temp_union_1e7e77a914d0b30cd33511f372c48d537ad81084` AS SELECT * FROM `c` UNION SELECT * FROM `d`',
-      ], db.sqls
-    )
-    # The SQL should be a single select
-    assert_equal(
-      'SELECT * FROM `temp_union_ac554bd85a4a6087511d4949f3a3c5a59c110cde` UNION SELECT * FROM `temp_union_1e7e77a914d0b30cd33511f372c48d537ad81084`', ds.sql
-    )
-  end
-
-  def test_should_unionize_8_datasets_as_sets_of_two_then_another_two
-    db = Sequel.mock(host: :spark).extension(:unionize)
-    dses = %i[a b c d e f g h].map { |letter| db[letter] }
-    ds = db.unionize(dses, chunk_size: 2, from_self: false)
-
-    # Two things should be created
-    assert_equal(6, db.sqls.length)
-    # The SQL should be a single select
-    assert_equal(
-      'SELECT * FROM `temp_union_07a3e9f8f94e096301b62afd61b4315110ec0c3d` UNION SELECT * FROM `temp_union_ff3e49e7501c97ee5e69f112cc42bb7121f379f1`', ds.sql
-    )
-  end
-
-end

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

@@ -1,15 +0,0 @@
-require_relative '../../../test_helper'
-require 'sequel'
-require 'sequel/extensions/usable'
-
-class TestUsable < Minitest::Test
-
-  def test_should_call_use
-    db = Sequel.mock(host: :sqlite)
-    db.extension :usable
-    db.use(:some_schema)
-
-    assert_equal(['USE `some_schema`'], db.sqls)
-  end
-
-end

data/test/lib/sequelizer/test_connection_maker.rb

@@ -1,123 +0,0 @@
-require_relative '../../test_helper'
-require 'sequelizer'
-
-class TestConnectionMaker < Minitest::Test
-
-  def setup
-    @options = { 'adapter' => 'mock', 'host' => 'postgres' }
-  end
-
-  def test_accepts_options_as_params
-    Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
-      assert_equal :postgres, Sequelizer::ConnectionMaker.new(@options).connection.database_type
-    end
-  end
-
-  def with_ignored_yaml_config(opts = {}); end
-
-  def with_yaml_config(options = {}, &)
-    yaml_config = Sequelizer::YamlConfig.new
-    yaml_config.stub(:options, options) do
-      Sequelizer::YamlConfig.stub(:new, yaml_config, &)
-    end
-  end
-
-  def with_env_config(options = {})
-    env_config = Sequelizer::EnvConfig.new
-    env_config.stub(:options, options) do
-      Sequelizer::EnvConfig.stub :new, env_config do
-        yield env_config
-      end
-    end
-  end
-
-  def test_reads_options_from_yaml_config
-    with_yaml_config(@options) do
-      assert_equal :postgres, Sequelizer::ConnectionMaker.new.connection.database_type
-    end
-  end
-
-  def test_ignores_options_from_yaml_config_when_asked
-    with_yaml_config(@options) do
-      assert_nil Sequelizer::ConnectionMaker.new(ignore_yaml: true).options.to_hash[:adapter]
-    end
-  end
-
-  def test_applies_settings_if_given
-    with_yaml_config(@options.merge(postgres_db_opt_flim: :flam)) do
-      with_env_config do
-        conn = Sequelizer::ConnectionMaker.new.connection
-        conn.test_connection
-
-        assert_equal(['SET flim=flam'], conn.sqls)
-      end
-    end
-  end
-
-  def test_applies_settings_for_all_connections_if_given
-    with_yaml_config(@options.merge(postgres_db_opt_flim: :flam, max_connections: 2, preconnect: :concurrent)) do
-      with_env_config do
-        conn = Sequelizer::ConnectionMaker.new.connection
-        conn.test_connection
-
-        assert_equal(['SET flim=flam'] * 2, conn.sqls)
-      end
-    end
-  end
-
-  def test_reads_options_from_env_config_if_no_yaml_config
-    with_yaml_config do
-      with_env_config(@options) do
-        assert_equal :postgres, Sequelizer::ConnectionMaker.new.connection.database_type
-      end
-    end
-  end
-
-  def test_ignores_options_from_env_config_if_no_yaml_config
-    with_yaml_config do
-      with_env_config(@options) do
-        assert_nil Sequelizer::ConnectionMaker.new(ignore_env: true).options.to_hash[:adapter]
-      end
-    end
-  end
-
-  def test_applies_configuration_to_connection
-    opts = @options.merge(postgres_db_opt_search_path: 'searchy', impala_db_opt_search_path: 'searchy2')
-    with_yaml_config(opts) do
-      conn = Sequelizer::ConnectionMaker.new.connection
-      conn.test_connection
-
-      assert_equal({ search_path: 'searchy' }, conn.db_opts.to_hash)
-      assert_equal(['SET search_path=searchy'], conn.db_opts.sql_statements)
-    end
-  end
-
-  def test_applies_nothing_when_no_configuration
-    Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
-      conn = Sequelizer::ConnectionMaker.new(@options).connection
-      conn.test_connection
-
-      assert_empty(conn.db_opts.to_hash)
-      assert_empty(conn.db_opts.sql_statements)
-    end
-  end
-
-  def test_applies_quotes_when_necessary
-    Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
-      @options.merge!(postgres_db_opt_search_path: 'searchy,path')
-      conn = Sequelizer::ConnectionMaker.new(@options).connection
-      conn.test_connection
-
-      assert_equal({ search_path: "'searchy,path'" }, conn.db_opts.to_hash)
-      assert_equal(["SET search_path='searchy,path'"], conn.db_opts.sql_statements)
-    end
-  end
-
-  def test_applies_extensions
-    with_yaml_config(@options.merge(extension_error_sql: 1)) do
-      assert_includes Sequelizer::ConnectionMaker.new.connection.send(:instance_variable_get, :@loaded_extensions), :error_sql,
-                      "Extension wasn't set"
-    end
-  end
-
-end

data/test/lib/sequelizer/test_env_config.rb

@@ -1,37 +0,0 @@
-require_relative '../../test_helper'
-require 'sequelizer'
-
-class TestEnvConfig < Minitest::Test
-
-  def setup
-    @env_config = Sequelizer::EnvConfig.new
-  end
-
-  def test_loads_dotenv
-    mock = Minitest::Mock.new
-    stub_const(Sequelizer::EnvConfig, :Dotenv, mock) do
-      mock.expect :load, nil
-      @env_config.options
-      mock.verify
-    end
-  end
-
-  def test_options_default_to_empty_hash
-    assert_empty(@env_config.options)
-  end
-
-  def test_converts_sequelizer_vars_to_options
-    ENV['SEQUELIZER_ADAPTER'] = 'sqlite'
-
-    assert_equal({ 'adapter' => 'sqlite' }, @env_config.options)
-    ENV.delete('SEQUELIZER_ADAPTER')
-  end
-
-  def test_converts_db_opts_to_options
-    ENV['POSTGRES_DB_OPT_HEY'] = 'there'
-
-    assert_equal({ 'postgres_db_opt_hey' => 'there' }, @env_config.options)
-    ENV.delete('POSTGRES_DB_OPT_HEY')
-  end
-
-end

data/test/lib/sequelizer/test_gemfile_modifier.rb

@@ -1,88 +0,0 @@
-require_relative '../../test_helper'
-require 'sequelizer/gemfile_modifier'
-
-class TestGemfileModifier < Minitest::Test
-
-  def setup
-    @gm = Sequelizer::GemfileModifier.new
-  end
-
-  def test_dies_if_gemfile_missing
-    pn_mock = Minitest::Mock.new
-    pn_mock.expect(:exist?, false)
-
-    Pathname.stub(:new, pn_mock) do
-      assert_raises(RuntimeError) { @gm.modify }
-    end
-    pn_mock.verify
-  end
-
-  def test_quits_if_no_modification_needed
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ["gem 'pg'"], [pn_mock])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  def test_quits_if_no_modification_needed2
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ["gem 'pg' # ADDED BY SEQUELIZER"], [pn_mock])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  def test_writes_if_modification_needed
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ['#comment line', "gem 'sqlite3' # ADDED BY SEQUELIZER"], [pn_mock])
-    file_mock.expect(:write, nil, [pn_mock, ['#comment line', "gem 'pg' # ADDED BY SEQUELIZER"].join("\n")])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  private
-
-  def standard_pn_mock
-    pn_mock = Minitest::Mock.new
-    pn_mock.expect(:exist?, true)
-  end
-
-  def stub_modifying_methods(obj, &)
-    obj.stub(:system, nil) do
-      obj.stub(:puts, nil, &)
-    end
-  end
-
-end