activerecord-rdb-adapter 0.9.4 → 0.9.6.beta2

data/lib/active_record/tasks/rdb_database_tasks.rb

@@ -1,78 +1,78 @@
-module ActiveRecord
-  module Tasks # :nodoc:
-    class RdbDatabaseTasks # :nodoc:
-      delegate :rdb_connection, :rdb_connection_config, :establish_connection, to: ::ActiveRecord::Base
-
-      def initialize(configuration)
-        @configuration = rdb_connection_config(configuration)
-      end
-
-      def create
-        rdb_database.create
-        # create_db
-        establish_connection configuration
-      rescue ::Fb::Error => e
-        raise unless e.message.include?('File exists')
-        raise DatabaseAlreadyExists
-      end
-
-      def drop
-        establish_connection configuration
-        rdb_database.drop
-      rescue ::Fb::Error => e
-        raise ::ActiveRecord::ConnectionNotEstablished, e.message
-      end
-
-      def purge
-        begin
-          drop
-        rescue StandardError
-          nil
-        end
-        create
-      end
-
-      def structure_dump(filename, structure_dump_flags = nil)
-        isql :extract, output: filename
-      end
-
-      def structure_load(filename, structure_load_flags = nil)
-        isql input: filename
-      end
-
-      private
-
-      def rdb_database
-        ::Fb::Database.new(configuration)
-      end
-
-      # Executes isql commands to load/dump the schema.
-      # The generated command might look like this:
-      #   isql db/development.fdb -user SYSDBA -password masterkey -extract
-      def isql(*args)
-        opts = args.extract_options!
-        user, pass = configuration.values_at(:username, :password)
-        user ||= configuration[:user]
-        opts.reverse_merge!(user: user, password: pass)
-        cmd = [isql_executable, configuration[:database]]
-        cmd += opts.map { |name, val| "-#{name} #{val}" }
-        cmd += args.map { |flag| "-#{flag}" }
-        cmd = cmd.join(' ')
-        raise "Error running: #{cmd}" unless Kernel.system(cmd)
-      end
-
-      def isql_create(*_args)
-        "#{isql_executable} -input "
-      end
-
-      # Finds the isql command line utility from the PATH
-      # Many linux distros call this program isql-fb, instead of isql
-      def isql_executable
-        "/opt/RedDatabase/bin/isql"
-      end
-
-      attr_reader :configuration
-
-    end
-  end
-end
+module ActiveRecord
+  module Tasks # :nodoc:
+    class RdbDatabaseTasks # :nodoc:
+      delegate :rdb_connection, :rdb_connection_config, :establish_connection, to: ::ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = rdb_connection_config(configuration)
+      end
+
+      def create
+        rdb_database.create
+        # create_db
+        establish_connection configuration
+      rescue ::Fb::Error => e
+        raise unless e.message.include?('File exists')
+        raise DatabaseAlreadyExists
+      end
+
+      def drop
+        establish_connection configuration
+        rdb_database.drop
+      rescue ::Fb::Error => e
+        raise ::ActiveRecord::ConnectionNotEstablished, e.message
+      end
+
+      def purge
+        begin
+          drop
+        rescue StandardError
+          nil
+        end
+        create
+      end
+
+      def structure_dump(filename, structure_dump_flags = nil)
+        isql :extract, output: filename
+      end
+
+      def structure_load(filename, structure_load_flags = nil)
+        isql input: filename
+      end
+
+      private
+
+      def rdb_database
+        ::Fb::Database.new(configuration)
+      end
+
+      # Executes isql commands to load/dump the schema.
+      # The generated command might look like this:
+      #   isql db/development.fdb -user SYSDBA -password masterkey -extract
+      def isql(*args)
+        opts = args.extract_options!
+        user, pass = configuration.values_at(:username, :password)
+        user ||= configuration[:user]
+        opts.reverse_merge!(user: user, password: pass)
+        cmd = [isql_executable, configuration[:database]]
+        cmd += opts.map { |name, val| "-#{name} #{val}" }
+        cmd += args.map { |flag| "-#{flag}" }
+        cmd = cmd.join(' ')
+        raise "Error running: #{cmd}" unless Kernel.system(cmd)
+      end
+
+      def isql_create(*_args)
+        "#{isql_executable} -input "
+      end
+
+      # Finds the isql command line utility from the PATH
+      # Many linux distros call this program isql-fb, instead of isql
+      def isql_executable
+        "/opt/RedDatabase/bin/isql"
+      end
+
+      attr_reader :configuration
+
+    end
+  end
+end

data/lib/activerecord-rdb-adapter.rb

@@ -1,10 +1,10 @@
-require 'active_record/connection_adapters/rdb_adapter'
-
-if defined?(::Rails::Railtie) && ::ActiveRecord::VERSION::MAJOR > 3
-  class Railtie < ::Rails::Railtie # :nodoc:
-    rake_tasks do
-      load 'active_record/tasks/rdb_database_tasks.rb'
-      ActiveRecord::Tasks::DatabaseTasks.register_task(/rdb/, ActiveRecord::Tasks::RdbDatabaseTasks)
-    end
-  end
-end
+require 'active_record/connection_adapters/rdb_adapter'
+
+if defined?(::Rails::Railtie) && ::ActiveRecord::VERSION::MAJOR > 3
+  class Railtie < ::Rails::Railtie # :nodoc:
+    rake_tasks do
+      load 'active_record/tasks/rdb_database_tasks.rb'
+      ActiveRecord::Tasks::DatabaseTasks.register_task(/rdb/, ActiveRecord::Tasks::RdbDatabaseTasks)
+    end
+  end
+end

data/lib/arel/visitors/rdb_visitor.rb

@@ -1,135 +1,135 @@
-module Arel
-  module Visitors
-    class Rdb < Arel::Visitors::ToSql # :nodoc
-      private
-
-      def visit_Arel_Nodes_InsertStatement(o, collector)
-        collector << "INSERT INTO "
-        collector = visit o.relation, collector
-
-        unless o.columns.empty?
-          collector << " ("
-          o.columns.each_with_index do |x, i|
-            collector << ", " unless i == 0
-            collector << quote_column_name(x.name)
-          end
-          collector << ")"
-        end
-
-        if o.values
-          maybe_visit o.values, collector
-        elsif o.select
-          maybe_visit o.select, collector
-        else
-          collector
-        end
-      end
-
-      def visit_Arel_Nodes_SelectStatement(o, collector)
-        collector << 'SELECT '
-        collector = visit o.offset, collector if o.offset && !o.limit
-
-        collector = o.cores.inject(collector) do |c, x|
-          visit_Arel_Nodes_SelectCore(x, c)
-        end
-
-        unless o.orders.empty?
-          collector << ORDER_BY
-          len = o.orders.length - 1
-          o.orders.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
-
-        if o.limit && o.offset
-          collector = limit_with_rows o, collector
-        elsif o.limit && !o.offset
-          collector = visit o.limit, collector
-        end
-
-        maybe_visit o.lock, collector
-      end
-
-      def visit_Arel_Nodes_SelectCore(o, collector)
-        if o.set_quantifier
-          collector = visit o.set_quantifier, collector
-          collector << SPACE
-        end
-
-        unless o.projections.empty?
-          len = o.projections.length - 1
-          o.projections.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
-
-        if o.source && !o.source.empty?
-          collector << ' FROM '
-          collector = visit o.source, collector
-        end
-
-        unless o.wheres.empty?
-          collector << WHERE
-          len = o.wheres.length - 1
-          o.wheres.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << AND unless len == i
-          end
-        end
-        unless o.groups.empty?
-          collector << GROUP_BY
-          len = o.groups.length - 1
-          o.groups.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
-
-        if Rails::VERSION::MAJOR < 5
-          collector = maybe_visit o.having, collector
-        else
-          unless o.havings.empty?
-            collector << ' HAVING '
-            inject_join o.havings, collector, AND
-          end
-        end
-
-        collector
-      end
-
-      def visit_Arel_Nodes_Limit(o, collector)
-        collector << ' ROWS '
-        visit o.expr, collector
-      end
-
-      def visit_Arel_Nodes_Offset(o, collector)
-        collector << ' SKIP '
-        visit o.expr, collector
-      end
-
-      def limit_with_rows o, collector
-        o.offset.expr.value = ActiveModel::Attribute.with_cast_value('OFFSET'.freeze,
-                                                                     o.offset.expr.value.value + 1,
-                                                                     ActiveModel::Type.default_value)
-        offset = o.offset.expr.value
-        o.limit.expr.value = ActiveModel::Attribute.with_cast_value('LIMIT'.freeze,
-                                                                    o.limit.expr.value.value + (offset.value - 1),
-                                                                    ActiveModel::Type.default_value)
-        limit = o.limit.expr.value
-        collector << ' ROWS '
-        collector.add_bind(offset) { |i| '?' }
-        collector << ' TO '
-        collector.add_bind(limit) { |i| '?' }
-      end
-
-      def quote_column_name name
-        return name if Arel::Nodes::SqlLiteral === name
-
-        @connection.quote_column_name(name)
-      end
-
-    end
-  end
-end
+module Arel
+  module Visitors
+    class Rdb < Arel::Visitors::ToSql # :nodoc
+      private
+
+      def visit_Arel_Nodes_InsertStatement(o, collector)
+        collector << "INSERT INTO "
+        collector = visit o.relation, collector
+
+        unless o.columns.empty?
+          collector << " ("
+          o.columns.each_with_index do |x, i|
+            collector << ", " unless i == 0
+            collector << quote_column_name(x.name)
+          end
+          collector << ")"
+        end
+
+        if o.values
+          maybe_visit o.values, collector
+        elsif o.select
+          maybe_visit o.select, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_SelectStatement(o, collector)
+        collector << 'SELECT '
+        collector = visit o.offset, collector if o.offset && !o.limit
+
+        collector = o.cores.inject(collector) do |c, x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        end
+
+        unless o.orders.empty?
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          end
+        end
+
+        if o.limit && o.offset
+          collector = limit_with_rows o, collector
+        elsif o.limit && !o.offset
+          collector = visit o.limit, collector
+        end
+
+        maybe_visit o.lock, collector
+      end
+
+      def visit_Arel_Nodes_SelectCore(o, collector)
+        if o.set_quantifier
+          collector = visit o.set_quantifier, collector
+          collector << SPACE
+        end
+
+        unless o.projections.empty?
+          len = o.projections.length - 1
+          o.projections.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          end
+        end
+
+        if o.source && !o.source.empty?
+          collector << ' FROM '
+          collector = visit o.source, collector
+        end
+
+        unless o.wheres.empty?
+          collector << WHERE
+          len = o.wheres.length - 1
+          o.wheres.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << AND unless len == i
+          end
+        end
+        unless o.groups.empty?
+          collector << GROUP_BY
+          len = o.groups.length - 1
+          o.groups.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          end
+        end
+
+        if Rails::VERSION::MAJOR < 5
+          collector = maybe_visit o.having, collector
+        else
+          unless o.havings.empty?
+            collector << ' HAVING '
+            inject_join o.havings, collector, AND
+          end
+        end
+
+        collector
+      end
+
+      def visit_Arel_Nodes_Limit(o, collector)
+        collector << ' ROWS '
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_Offset(o, collector)
+        collector << ' SKIP '
+        visit o.expr, collector
+      end
+
+      def limit_with_rows o, collector
+        o.offset.expr.value = ActiveModel::Attribute.with_cast_value('OFFSET'.freeze,
+                                                                     o.offset.expr.value.value + 1,
+                                                                     ActiveModel::Type.default_value)
+        offset = o.offset.expr.value
+        o.limit.expr.value = ActiveModel::Attribute.with_cast_value('LIMIT'.freeze,
+                                                                    o.limit.expr.value.value + (offset.value - 1),
+                                                                    ActiveModel::Type.default_value)
+        limit = o.limit.expr.value
+        collector << ' ROWS '
+        collector.add_bind(offset) { |i| '?' }
+        collector << ' TO '
+        collector.add_bind(limit) { |i| '?' }
+      end
+
+      def quote_column_name name
+        return name if Arel::Nodes::SqlLiteral === name
+
+        @connection.quote_column_name(name)
+      end
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-rdb-adapter
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.6.beta2
 platform: ruby
 authors:
 - Andrey Lobanov (RedSoft)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-17 00:00:00.000000000 Z
+date: 2022-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -65,13 +65,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements:
 - Firebird library fb
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord RedDatabase 3+ and Firebird 3+ Adapter