activerecord-rdb-adapter 0.9.4 → 0.9.5

data/lib/active_record/rdb_base.rb

@@ -1,34 +1,34 @@
-module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def rdb_connection(config)
-      require 'fb'
-      config = rdb_connection_config(config)
-      db = ::Fb::Database.new(config)
-      @database = db
-      begin
-        connection = db.connect
-      rescue StandardError
-        unless config[:create]
-          require 'pp'
-          pp config
-          raise ConnectionNotEstablished, 'No Firebird connections established.'
-        end
-        connection = db.create.connect
-      end
-      ConnectionAdapters::RdbAdapter.new(connection, logger, config)
-    end
-
-    def rdb_connection_config(config)
-      config = config.symbolize_keys.dup.reverse_merge(downcase_names: true)
-      port = config[:port] || 3050
-      raise ArgumentError, 'No database specified. Missing argument: database.' unless config[:database]
-      config[:database] = File.expand_path(config[:database], defined?(Rails) && Rails.root) if config[:host].nil? || /localhost/i.match?(config[:host])
-      config[:database] = "#{config[:host]}/#{port}:#{config[:database]}" if config[:host]
-      # config[:charset] = config[:charset].gsub(/-/, '') if config[:charset]
-      # config[:encoding] = config[:encoding].gsub(/-/, '') if config[:encoding]
-      config[:page_size] = 8192 unless config[:page_size]
-      config[:readonly_selects] = true unless config[:readonly_selects].present?
-      config
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def rdb_connection(config)
+      require 'fb'
+      config = rdb_connection_config(config)
+      db = ::Fb::Database.new(config)
+      @database = db
+      begin
+        connection = db.connect
+      rescue StandardError
+        unless config[:create]
+          require 'pp'
+          pp config
+          raise ConnectionNotEstablished, 'No Firebird connections established.'
+        end
+        connection = db.create.connect
+      end
+      ConnectionAdapters::RdbAdapter.new(connection, logger, config)
+    end
+
+    def rdb_connection_config(config)
+      config = config.symbolize_keys.dup.reverse_merge(downcase_names: true)
+      port = config[:port] || 3050
+      raise ArgumentError, 'No database specified. Missing argument: database.' unless config[:database]
+      config[:database] = File.expand_path(config[:database], defined?(Rails) && Rails.root) if config[:host].nil? || /localhost/i.match?(config[:host])
+      config[:database] = "#{config[:host]}/#{port}:#{config[:database]}" if config[:host]
+      # config[:charset] = config[:charset].gsub(/-/, '') if config[:charset]
+      # config[:encoding] = config[:encoding].gsub(/-/, '') if config[:encoding]
+      config[:page_size] = 8192 unless config[:page_size]
+      config[:readonly_selects] = true unless config[:readonly_selects].present?
+      config
+    end
+  end
+end

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