activerecord-postgresql-cursors 1.0.0 → 3.0.0

data/test/test_helper.rb

@@ -1,11 +1,10 @@
+# frozen_string_literal: true
 
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
+require 'simplecov'
 
-  SimpleCov.command_name('Unit Tests')
-  SimpleCov.start do
-    add_filter '/test/'
-  end
+SimpleCov.command_name('Unit Tests')
+SimpleCov.start do
+  add_filter '/test/'
 end
 
 require 'rubygems'
@@ -14,60 +13,43 @@ require 'active_support/core_ext/module/aliasing'
 require 'active_record'
 require 'logger'
 require 'minitest/autorun'
-
-if RUBY_VERSION >= '1.9'
-  require 'minitest/reporters'
-end
+require 'minitest/reporters'
 
 require File.join(File.dirname(__FILE__), *%w{ .. lib activerecord-postgresql-cursors })
 
-ActiveRecord::Base.logger = Logger.new("debug.log") if ENV['ENABLE_LOGGER']
-ActiveRecord::Base.configurations = {
-  'arunit' => {}
-}
-
-%w{
-  database.yml
-  local_database.yml
-}.each do |file|
-  file = File.join('test', file)
-
-  next unless File.exists?(file)
+ActiveRecord::Base.logger = Logger.new('debug.log') if ENV['ENABLE_LOGGER']
 
-  configuration = YAML.load(File.read(file))
+configurations = {}
 
-  if configuration['arunit']
-    ActiveRecord::Base.configurations['arunit'].merge!(configuration['arunit'])
-  end
-
-  if defined?(JRUBY_VERSION) && configuration['jdbc']
-    ActiveRecord::Base.configurations['arunit'].merge!(configuration['jdbc'])
-  end
-end
+file = File.join('test', 'database.yml')
+configuration = YAML.safe_load_file(file)
+configurations['arunit'] = configuration['arunit'] if configuration['arunit']
+configurations['arunit'].merge!(configuration['jdbc']) if defined?(JRUBY_VERSION) && configuration['jdbc']
 
-ActiveRecord::Base.establish_connection 'arunit'
+ActiveRecord::Base.configurations = configurations
+ActiveRecord::Base.establish_connection :arunit
 ARBC = ActiveRecord::Base.connection
 
 puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
-puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
-if postgresql_version = ARBC.select_rows('SELECT version()').flatten.to_s
-  puts "PostgreSQL info from version(): #{postgresql_version}"
-end
+puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version}"
+
+postgresql_version = ARBC.select_rows('SELECT version()').flatten.to_s
 
-if !ARBC.table_exists?('foos')
+puts "PostgreSQL info from version(): #{postgresql_version}" if postgresql_version
+
+unless ARBC.data_source_exists?('foos')
   ActiveRecord::Migration.create_table(:foos) do |t|
     t.text :name
   end
 end
 
-if !ARBC.table_exists?('bars')
+unless ARBC.data_source_exists?('bars')
   ActiveRecord::Migration.create_table(:bars) do |t|
     t.text :name
     t.integer :foo_id
   end
 end
 
-
 class Bar < ActiveRecord::Base
   belongs_to :foo
 end
@@ -84,18 +66,25 @@ module PostgreSQLCursorTestHelper
     ARBC.execute(%{select setval('bars_id_seq', 1, false)})
 
     %w{ six seven eight nine ten eleven twelve thirteen fourteen fifteen }.each do |name|
-      Bar.create(:name => name)
+      Bar.create(name: name)
     end
 
     %w{ one two three four five }.each_with_index do |name, i|
-      foo = Foo.new(:name => name)
-      foo.bar_ids = [ i + 1, i + 6 ]
+      foo = Foo.new(name: name)
+      foo.bar_ids = [i + 1, i + 6]
       foo.save
     end
   end
 end
 
-if RUBY_VERSION >= '1.9'
-  MiniTest::Reporters.use!(MiniTest::Reporters::SpecReporter.new)
-end
+Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
+
+if ENV['CI']
+  require 'simplecov_json_formatter'
 
+  SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
+elsif ENV.fetch('COVERAGE', nil) == 'console'
+  require_relative 'support/rspec_console'
+
+  SimpleCov.formatter = SecuricyApp::SimpleCov::Formatter::RSpecConsole
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgresql-cursors
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - J Smith
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2024-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,40 +16,47 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '6.1'
 description: Provides some support for PostgreSQL cursors in ActiveRecord.
 email: dark.panda@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
+- ".rubocop-minitest.yml"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- FUNDING.yml
 - Gemfile
 - Guardfile
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - activerecord-postgresql-cursors.gemspec
 - lib/active_record/postgresql_cursors/cursors.rb
-- lib/active_record/postgresql_cursors/cursors_2.rb
 - lib/active_record/postgresql_cursors/version.rb
 - lib/activerecord-postgresql-cursors.rb
-- test/cursor_tests.rb
+- sonar-project.properties
+- test/ci/github/database.yml
+- test/cursor_test.rb
 - test/database.yml
 - test/test_helper.rb
 homepage: http://github.com/dark-panda/activerecord-postgresql-cursors
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -57,19 +64,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: Provides some support for PostgreSQL cursors in ActiveRecord.
-test_files:
-- test/cursor_tests.rb
-- test/database.yml
-- test/test_helper.rb
+test_files: []

data/lib/active_record/postgresql_cursors/cursors_2.rb

@@ -1,75 +0,0 @@
-
-module ActiveRecord
-  class Base
-    class << self
-      # Override ActiveRecord::Base#find to allow for cursors in
-      # PostgreSQL. To use a cursor, set the first argument of
-      # find to :cursor. A PostgreSQLCursor object will be returned,
-      # which can then be used as an Enumerable to loop through the
-      # results.
-      #
-      # By default, cursor names are generated automatically using
-      # "cursor_#{rand}", where rand is a big ol' random number that
-      # is pretty unlikely to clash if you're using nested cursors.
-      # Alternatively, you can supply a specific cursor name by
-      # supplying a :cursor_name option.
-      def find_with_cursors *args
-        if args.first.to_s == 'cursor'
-          options = args.extract_options!
-          cursor_name = options.delete(:cursor_name)
-          validate_find_options(options)
-          set_readonly_option!(options)
-          find_cursor(cursor_name, options)
-        else
-          find_without_cursors(*args)
-        end
-      end
-      alias_method_chain :find, :cursors
-
-      def cursor(*args)
-        find(:cursor, *args)
-      end
-    end
-
-    private
-      # Find method for using cursors. This works just like the regular
-      # ActiveRecord::Base#find_every method, except it returns a
-      # PostgreSQLCursor object that can be used to loop through records.
-      def self.find_cursor(cursor_name, options)
-        unless connection.is_a? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          raise CursorsNotSupported, "#{connection.class} doesn't support cursors"
-        end
-
-        catch :invalid_query do
-          if options[:include]
-            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-            return ActiveRecord::PostgreSQLCursor.new(
-              self,
-              cursor_name,
-              construct_finder_sql_with_included_associations(
-                options,
-                join_dependency
-              ),
-              join_dependency
-            )
-          else
-            return ActiveRecord::PostgreSQLCursor.new(
-              self,
-              cursor_name,
-              construct_finder_sql(
-                options
-              )
-            )
-          end
-        end
-        nil
-      end
-  end
-
-  class PostgreSQLCursor
-    def initialize_with_rails_2(model, cursor_name, query, join_dependency = nil)
-      initialize_without_rails_2(model, cursor_name, query, join_dependency)
-    end
-    alias_method_chain :initialize, :rails_2
-  end
-end

data/test/cursor_tests.rb

@@ -1,97 +0,0 @@
-
-$: << File.dirname(__FILE__)
-require 'test_helper'
-
-class PostgreSQLCursorTests < MiniTest::Unit::TestCase
-  include PostgreSQLCursorTestHelper
-
-  def test_find_cursor
-    cursor = Foo.find(:cursor, :order => 'id')
-
-    assert(cursor.is_a?(ActiveRecord::PostgreSQLCursor))
-
-    assert_equal(%w{ one two three four five }, cursor.collect(&:name))
-  end
-
-  def test_cursor_scoped
-    cursor = Foo.cursor(:order => 'id')
-
-    assert(cursor.is_a?(ActiveRecord::PostgreSQLCursor))
-
-    assert_equal(%w{ one two three four five }, cursor.collect(&:name))
-  end
-
-  def test_cursor_while_updating
-    cursor = Foo.cursor(:order => 'id')
-
-    cursor.each do |row|
-      row.name = "#{row.name}_updated"
-      assert(row.save)
-    end
-
-    assert_equal(%w{ one_updated two_updated three_updated four_updated five_updated }, cursor.collect(&:name))
-  end
-
-  def test_with_associations
-    cursor = Foo.cursor(:order => 'id')
-
-    cursor.each do |row|
-      assert(row.is_a?(Foo))
-      row.bars.each do |bar|
-        assert(bar.is_a?(Bar))
-      end
-    end
-  end
-
-  def test_with_associations_eager_loading
-    cursor = Foo.cursor(:order => 'foos.id', :include => :bars)
-
-    cursor.each do |row|
-      assert(row.is_a?(Foo))
-      row.bars.each do |bar|
-        assert(bar.is_a?(Bar))
-      end
-    end
-  end
-
-  def test_nested_cursors
-    cursor = Foo.cursor(:order => 'foos.id')
-
-    cursor.each do |row|
-      bars_cursor = row.bars.cursor
-      assert(bars_cursor.is_a?(ActiveRecord::PostgreSQLCursor))
-
-      bars_cursor.each do |bar|
-        assert(bar.is_a?(Bar))
-      end
-    end
-  end
-
-  if ActiveRecord::VERSION::MAJOR >= 3
-    def test_as_relation
-      cursor = Foo.order('foos.id').where('foos.id >= 3').cursor
-      assert_equal(3, cursor.to_a.length)
-
-      cursor.each do |row|
-        assert(row.is_a?(Foo))
-        assert_equal(2, row.bars.length)
-        row.bars.each do |bar|
-          assert(bar.is_a?(Bar))
-        end
-      end
-    end
-
-    def test_as_relation_with_associations
-      cursor = Foo.includes(:bars).order('foos.id').where('foos.id >= 3').cursor
-      assert_equal(3, cursor.to_a.length)
-
-      cursor.each do |row|
-        assert(row.is_a?(Foo))
-        assert_equal(2, row.bars.length)
-        row.bars.each do |bar|
-          assert(bar.is_a?(Bar))
-        end
-      end
-    end
-  end
-end