switchman 1.7.4 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2287cafb5c656fc9033e4549edec54e5497977b5
-  data.tar.gz: 0a5c7fb962a37016087842675dfc37f90ccd697b
+  metadata.gz: e86d6e07988c45f8c70c42c92ece5263797af099
+  data.tar.gz: 624f54c1a3735b12050b977177076fc3fc870027
 SHA512:
-  metadata.gz: 9c6200530e3662721b2eb0f66dee5107f9d8200fbd90229974d3be29d875d8328c71b9971b5d1e6a39d69e02e74fe2c7491c81630a4fa0c9e01ea58dff6b3067
-  data.tar.gz: 9044787290f4ce2bca81c26cba8c83c6ee4284fbea4afcf17223a8586d333e4bd119fd2472cbaadaee77701b58dc5ab839d367f070e257db1d2be6285f682914
+  metadata.gz: f30d8b5ee490486c13a4f800a09c2bc29ba266e98e839980242562b46f0e0e080e68d7039019d5a69e7944d232829bd592521e86f7206e5bd35cf42cf360a208
+  data.tar.gz: 9e3b24c5493efce7a36e5da23a0dc471dc878a034125e8304dccb05c7beabef5daa009c87360f5e1c5bc9293f5b3892a5a624a86fffcbdea40fca44bb7878f8c

data/app/models/switchman/shard_internal.rb

@@ -115,13 +115,7 @@ module Switchman
             attributes = Switchman.cache.fetch(['shard', id].join('/')) do
               shard = find_by_id(id)
               if shard
-                attributes = shard.attributes
-                if ::Rails.version < '4.2'
-                  attributes.each_key do |key|
-                    attributes[key] = attributes[key].unserialize if attributes[key].is_a?(::ActiveRecord::AttributeMethods::Serialization::Attribute)
-                  end
-                end
-                attributes
+                shard.attributes
               else
                 :nil
               end
@@ -435,7 +429,7 @@ module Switchman
       # converts an AR object, integral id, string id, or string short-global-id to a
       # integral id. nil if it can't be interpreted
       def integral_id_for(any_id)
-        if ::Rails.version >= '4.2' && any_id.is_a?(::Arel::Nodes::Casted)
+        if any_id.is_a?(::Arel::Nodes::Casted)
           any_id = any_id.val
         end
 

data/lib/switchman/active_record/association.rb

@@ -137,9 +137,7 @@ module Switchman
             records.flatten!
           end
 
-          if ::Rails.version >= '4.1'
-            @preloaded_records = records
-          end
+          @preloaded_records = records
 
           # Each record may have multiple owners, and vice-versa
           records_by_owner = owners.each_with_object({}) do |owner,h|

data/lib/switchman/active_record/calculations.rb

@@ -61,12 +61,12 @@ module Switchman
         initial_results = relation.activate{ |rel| klass.connection.select_all(rel) }
         if initial_results.is_a?(Array)
           initial_results.each do |r|
-            r["average"] = type_cast_calculated_value(r["average"], column_or_type_for(column_name), "average")
-            r["count"] = type_cast_calculated_value(r["count"], column_or_type_for(column_name), "count")
+            r["average"] = type_cast_calculated_value(r["average"], type_for(column_name), "average")
+            r["count"] = type_cast_calculated_value(r["count"], type_for(column_name), "count")
           end
           result = initial_results.map{|r| r["average"] * r["count"]}.sum / initial_results.map{|r| r["count"]}.sum
         else
-          result = type_cast_calculated_value(initial_results.first["average"], column_or_type_for(column_name), "average")
+          result = type_cast_calculated_value(initial_results.first["average"], type_for(column_name), "average")
         end
         result
       end
@@ -89,14 +89,14 @@ module Switchman
 
           calculated_data.map do |row|
             row[opts[:aggregate_alias]] = type_cast_calculated_value(
-                row[opts[:aggregate_alias]], column_or_type_for(opts[:column_name]), opts[:operation])
+                row[opts[:aggregate_alias]], type_for(opts[:column_name]), opts[:operation])
             row['count'] = row['count'].to_i if opts[:operation] == 'average'
 
-            opts[:group_columns].each do |aliaz, column_or_type, column_name|
+            opts[:group_columns].each do |aliaz, type, column_name|
               if opts[:associated] && (aliaz == opts[:group_aliases].first)
                 row[aliaz] = key_records[Shard.relative_id_for(row[aliaz], shard, target_shard)]
               elsif column_name && @klass.sharded_column?(column_name)
-                row[aliaz] = Shard.relative_id_for(type_cast_calculated_value(row[aliaz], column_or_type), shard, target_shard)
+                row[aliaz] = Shard.relative_id_for(type_cast_calculated_value(row[aliaz], type), shard, target_shard)
               end
             end
             row
@@ -112,10 +112,6 @@ module Switchman
         field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
       end
 
-      def column_or_type_for(field)
-        ::Rails.version < '4.2' ? column_for(field) : type_for(field)
-      end
-
       def grouped_calculation_options(operation, column_name, distinct)
         opts = {:operation => operation, :column_name => column_name, :distinct => distinct}
 
@@ -131,7 +127,7 @@ module Switchman
 
         group_aliases = group_fields.map { |field| column_alias_for(field) }
         group_columns = group_aliases.zip(group_fields).map { |aliaz, field|
-          [aliaz, column_or_type_for(field), column_name_for(field)]
+          [aliaz, type_for(field), column_name_for(field)]
         }
         opts.merge!(:association => association, :associated => associated,
          :group_aliases => group_aliases, :group_columns => group_columns,

data/lib/switchman/active_record/finder_methods.rb

@@ -26,19 +26,7 @@ module Switchman
 
         local_id, shard = Shard.local_id_for(id)
         if shard
-          if ::Rails.version < '4.2'
-            # find_one uses binds, so we can't depend on QueryMethods
-            # catching it
-            begin
-              old_shard_value = shard_value
-              self.shard_value = shard
-              super(local_id)
-            ensure
-              self.shard_value = old_shard_value
-            end
-          else
-            shard.activate { super(local_id) }
-          end
+          shard.activate { super(local_id) }
         else
           super(id)
         end
@@ -52,13 +40,8 @@ module Switchman
         conditions = conditions.id if ::ActiveRecord::Base === conditions
         return false if !conditions
 
-        if ::Rails.version >= '4.1'
-          relation = apply_join_dependency(self, construct_join_dependency)
-          return false if ::ActiveRecord::NullRelation === relation
-        else
-          join_dependency = construct_join_dependency_for_association_find
-          relation = construct_relation_for_association_find(join_dependency)
-        end
+        relation = apply_join_dependency(self, construct_join_dependency)
+        return false if ::ActiveRecord::NullRelation === relation
 
         relation = relation.except(:select, :order).select("1 AS one").limit(1)
 
@@ -70,12 +53,9 @@ module Switchman
         end
 
         args = [relation, "#{name} Exists"]
-        args << relation.bind_values if ::Rails.version >= '4.1'
+        args << relation.bind_values
         relation.activate { return true if connection.select_value(*args) }
         false
-      rescue
-        raise if ::Rails.version >= '4.1' || !(::ActiveRecord::ThrowResult === $!)
-        false
       end
     end
   end

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -57,38 +57,20 @@ module Switchman
       end
 
       def table_exists?(name)
-        if ::Rails.version < '4.2'
-          schema, table = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils.extract_schema_and_table(name.to_s)
-          return false unless table
-          schema ||= shard.name if use_qualified_names?
-
-          binds = [[nil, table]]
-          binds << [nil, schema] if schema
-
-          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-              SELECT COUNT(*)
-              FROM pg_class c
-              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relkind in ('v','r')
-              AND c.relname = '#{table.gsub(/(^"|"$)/,'')}'
-              AND n.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
-          SQL
-        else
-          name =  ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-          if !name.schema && use_qualified_names?
-            name.instance_variable_set(:@schema, shard.name)
-          end
-
-          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-              SELECT COUNT(*)
-              FROM pg_class c
-              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-              AND c.relname = '#{name.identifier}'
-              AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
-          SQL
+        name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
+        return false unless name.identifier
+        if !name.schema && use_qualified_names?
+          name.instance_variable_set(:@schema, shard.name)
         end
+
+        exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
+            SELECT COUNT(*)
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            AND c.relname = '#{name.identifier}'
+            AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+        SQL
       end
 
       def indexes(table_name)
@@ -158,60 +140,42 @@ module Switchman
       end
 
       def quote_table_name name
-        if ::Rails.version < '4.2'.freeze
-          schema, name_part = extract_pg_identifier_from_name(name.to_s)
-
-          if !name_part && use_qualified_names? && shard.name
-            schema, name_part = shard.name, schema
-          end
-
-          unless name_part
-            quote_column_name(schema)
-          else
-            table_name, name_part = extract_pg_identifier_from_name(name_part)
-            "#{quote_column_name(schema)}.#{quote_column_name(table_name)}"
-          end
-        else
-
-          name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-          if !name.schema && use_qualified_names?
-            name.instance_variable_set(:@schema, shard.name)
-          end
-          name.quoted
+        name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
+        if !name.schema && use_qualified_names?
+          name.instance_variable_set(:@schema, shard.name)
         end
+        name.quoted
       end
 
-      if ::Rails.version >= '4.2'
-        def foreign_keys(table_name)
-          schema = shard.name if use_qualified_names?
-
-          # mostly copy-pasted from AR - only change is to the nspname condition for qualified names support
-          fk_info = select_all <<-SQL.strip_heredoc
-            SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
-            FROM pg_constraint c
-            JOIN pg_class t1 ON c.conrelid = t1.oid
-            JOIN pg_class t2 ON c.confrelid = t2.oid
-            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
-            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
-            JOIN pg_namespace t3 ON c.connamespace = t3.oid
-            WHERE c.contype = 'f'
-              AND t1.relname = #{quote(table_name)}
-              AND t3.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
-            ORDER BY c.conname
-          SQL
+      def foreign_keys(table_name)
+        schema = shard.name if use_qualified_names?
+
+        # mostly copy-pasted from AR - only change is to the nspname condition for qualified names support
+        fk_info = select_all <<-SQL.strip_heredoc
+          SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+          FROM pg_constraint c
+          JOIN pg_class t1 ON c.conrelid = t1.oid
+          JOIN pg_class t2 ON c.confrelid = t2.oid
+          JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+          JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+          JOIN pg_namespace t3 ON c.connamespace = t3.oid
+          WHERE c.contype = 'f'
+            AND t1.relname = #{quote(table_name)}
+            AND t3.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
+          ORDER BY c.conname
+        SQL
 
-          fk_info.map do |row|
-            options = {
-              column: row['column'],
-              name: row['name'],
-              primary_key: row['primary_key']
-            }
+        fk_info.map do |row|
+          options = {
+            column: row['column'],
+            name: row['name'],
+            primary_key: row['primary_key']
+          }
 
-            options[:on_delete] = extract_foreign_key_action(row['on_delete'])
-            options[:on_update] = extract_foreign_key_action(row['on_update'])
+          options[:on_delete] = extract_foreign_key_action(row['on_delete'])
+          options[:on_update] = extract_foreign_key_action(row['on_update'])
 
-            ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
-          end
+          ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
         end
       end
     end

data/lib/switchman/active_record/query_methods.rb

@@ -55,7 +55,6 @@ module Switchman
               if rel.shard_source_value == :implicit && rel.primary_shard != primary_shard
                 rel.shard!(primary_shard)
               end
-              self.bind_values += rel.bind_values if ::Rails.version < '4.2'
             end
 
             [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
@@ -104,7 +103,7 @@ module Switchman
         end
       end
 
-      if ::Rails.version >= '4.2' && ::Rails.version < '5'
+      if ::Rails.version < '5'
         # fixes an issue in Rails 4.2 with `reverse_sql_order` and qualified names
         # where quoted_table_name is called before shard(s) have been activated
         # if there's no ordering
@@ -192,7 +191,7 @@ module Switchman
             else
               if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name).to_s == klass.primary_key.to_s}
                 column, value = bind_values[idx]
-                unless ::Rails.version >= '4.2' && value.is_a?(::ActiveRecord::StatementCache::Substitute)
+                unless value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   local_id, id_shard = Shard.local_id_for(value)
                   id_shard ||= Shard.current(klass.shard_category) if local_id
                 end
@@ -299,7 +298,7 @@ module Switchman
               local_id = Shard.relative_id_for(value, current_source_shard, target_shard)
               next unless local_id
               unless remove && local_id > Shard::IDS_PER_SHARD
-                if ::Rails.version > "4.2" && value.is_a?(::Arel::Nodes::Casted)
+                if value.is_a?(::Arel::Nodes::Casted)
                   if local_id == value.val
                     local_id = value
                   elsif local_id != value
@@ -328,7 +327,7 @@ module Switchman
             else
               if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name).to_s == predicate.left.name.to_s}
                 column, value = bind_values[idx]
-                if ::Rails.version >= '4.2' && value.is_a?(::ActiveRecord::StatementCache::Substitute)
+                if value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   value.sharded = true # mark for transposition later
                   value.primary = true if type == :primary
                 else
@@ -347,7 +346,7 @@ module Switchman
 
           if new_right_value == predicate.right
             predicate
-          elsif ::Rails.version >= "4.2" && predicate.right.is_a?(::Arel::Nodes::Casted)
+          elsif predicate.right.is_a?(::Arel::Nodes::Casted)
             if new_right_value == predicate.right.val
               predicate
             else

data/lib/switchman/active_record/reflection.rb

@@ -41,16 +41,8 @@ module Switchman
       end
 
       module AssociationReflection
-        # removes memoization - ActiveRecord::ModelSchema does that anyway;
-        # and in fact this is the exact change AR makes in 4.2+
-        if ::Rails.version < '4.2'
-          def quoted_table_name
-            klass.quoted_table_name
-          end
-        else
-          def join_id_for(owner)
-            owner.send(active_record_primary_key) # use sharded id values in association binds
-          end
+        def join_id_for(owner)
+          owner.send(active_record_primary_key) # use sharded id values in association binds
         end
       end
     end

data/lib/switchman/arel.rb

@@ -12,24 +12,17 @@ module Switchman
     module Visitors
       module ToSql
         def visit_Arel_Nodes_TableAlias *args
-          if ::Rails.version < '4.2'
-            o = args.shift
-            "#{visit o.relation, *args} #{quote_local_table_name o.name}"
-          else
-            o, collector = args
-            collector = visit o.relation, collector
-            collector << " "
-            collector << quote_local_table_name(o.name)
-          end
+          o, collector = args
+          collector = visit o.relation, collector
+          collector << " "
+          collector << quote_local_table_name(o.name)
         end
 
         def visit_Arel_Attributes_Attribute *args
           o = args.first
           join_name = o.relation.table_alias || o.relation.name
           result = "#{quote_local_table_name join_name}.#{quote_column_name o.name}"
-          unless ::Rails.version < '4.2'.freeze
-            result = args.last << result
-          end
+          result = args.last << result
           result
         end
 
@@ -38,14 +31,6 @@ module Switchman
           @connection.quote_local_table_name(name)
         end
       end
-
-      module PostgreSQL
-        # the only difference is to remove caching (which only applies to Arel < 6.0/AR < 4.2)
-        def quote_table_name name
-          return name if ::Arel::Nodes::SqlLiteral === name
-          @connection.quote_table_name(name)
-        end
-      end
     end
   end
 end

data/lib/switchman/engine.rb

@@ -80,8 +80,9 @@ module Switchman
         require "switchman/active_record/reflection"
         require "switchman/active_record/relation"
         require "switchman/active_record/spawn_methods"
-        require "switchman/active_record/where_clause_factory"
+        require "switchman/active_record/statement_cache"
         require "switchman/active_record/type_caster"
+        require "switchman/active_record/where_clause_factory"
         require "switchman/arel"
         require "switchman/rails"
         require "switchman/shackles/relation"
@@ -95,23 +96,16 @@ module Switchman
         include ActiveRecord::Persistence
         singleton_class.prepend ActiveRecord::ModelSchema::ClassMethods
 
-        if ::Rails.version > '4.2'
-          require "switchman/active_record/statement_cache"
-          ::ActiveRecord::StatementCache.prepend(ActiveRecord::StatementCache)
-          ::ActiveRecord::StatementCache.singleton_class.prepend(ActiveRecord::StatementCache::ClassMethods)
-          ::ActiveRecord::StatementCache::BindMap.prepend(ActiveRecord::StatementCache::BindMap)
-          ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
+        ::ActiveRecord::StatementCache.prepend(ActiveRecord::StatementCache)
+        ::ActiveRecord::StatementCache.singleton_class.prepend(ActiveRecord::StatementCache::ClassMethods)
+        ::ActiveRecord::StatementCache::BindMap.prepend(ActiveRecord::StatementCache::BindMap)
+        ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
 
-          ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
-        end
+        ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
 
-        if ::Rails.version >= '4.1.15'
-          ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
-        end
+        ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
 
-        if ::Rails.version > '4.1'
-          prepend(ActiveRecord::AutosaveAssociation)
-        end
+        prepend(ActiveRecord::AutosaveAssociation)
 
         ::ActiveRecord::Associations::Association.prepend(ActiveRecord::Association)
         ::ActiveRecord::Associations::BelongsToAssociation.prepend(ActiveRecord::BelongsToAssociation)
@@ -132,13 +126,9 @@ module Switchman
         ::ActiveRecord::ConnectionAdapters::QueryCache.send(:remove_method, :select_all)
 
         ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
-        if ::Rails.version >= '4.2'
-          ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
-          ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
-          ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
-        else
-          ::ActiveRecord::Reflection::AssociationReflection.include(ActiveRecord::Reflection::AbstractReflection)
-        end
+        ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
+        ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
+        ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationReflection)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Batches)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Calculations)
@@ -159,7 +149,6 @@ module Switchman
 
         ::Arel::Table.prepend(Arel::Table)
         ::Arel::Visitors::ToSql.prepend(Arel::Visitors::ToSql)
-        ::Arel::Visitors::PostgreSQL.include(Arel::Visitors::PostgreSQL) if ::Rails.version < '4.2'
       end
     end
 

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.7.4"
+  VERSION = "1.8.0"
 end

data/lib/tasks/switchman.rake

@@ -198,58 +198,37 @@ end
 module Switchman
   module ActiveRecord
     module PostgreSQLDatabaseTasks
-      if ::Rails.version < '4.2'
-        def structure_dump(filename)
-          set_psql_env
-          search_path = configuration['schema_search_path']
-          unless search_path.blank?
-            search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
-            serialized_search_path = ::ActiveRecord::Base.connection.schema_search_path
-          end
-          if configuration['use_qualified_names']
-            shard = Shard.current.name
-            serialized_search_path = shard
-            search_path = "--schema=#{Shellwords.escape(shard)}"
-          end
-
-          command = "pg_dump -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
-          raise 'Error dumping database' unless Kernel.system(command)
-
-          File.open(filename, "a") { |f| f << "SET search_path TO #{serialized_search_path};\n\n" }
+      def structure_dump(filename)
+        set_psql_env
+        args = ['-s', '-x', '-O', '-f', filename]
+        search_path = configuration['schema_search_path']
+        if configuration['use_qualified_names']
+          shard = Shard.current.name
+          serialized_search_path = shard
+          args << "--schema=#{Shellwords.escape(shard)}"
+        elsif !search_path.blank?
+          args << search_path.split(',').map do |part|
+            "--schema=#{part.strip}"
+          end.join(' ')
+          serialized_search_path = connection.schema_search_path
         end
-      else
-        def structure_dump(filename)
-          set_psql_env
-          args = ['-s', '-x', '-O', '-f', filename]
-          search_path = configuration['schema_search_path']
-          if configuration['use_qualified_names']
-            shard = Shard.current.name
-            serialized_search_path = shard
-            args << "--schema=#{Shellwords.escape(shard)}"
-          elsif !search_path.blank?
-            args << search_path.split(',').map do |part|
-              "--schema=#{part.strip}"
-            end.join(' ')
-            serialized_search_path = connection.schema_search_path
-          end
 
-          args << configuration['database']
-          run_cmd('pg_dump', args, 'dumping')
-          File.open(filename, "a") { |f| f << "SET search_path TO #{serialized_search_path};\n\n" }
-        end
+        args << configuration['database']
+        run_cmd('pg_dump', args, 'dumping')
+        File.open(filename, "a") { |f| f << "SET search_path TO #{serialized_search_path};\n\n" }
+      end
 
-        if ::Rails.version < '4.2.5'
-          # These methods are backported from rails 4.2.5 to work with the above
-          def run_cmd(cmd, args, action)
-            fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-          end
+      if ::Rails.version < '4.2.5'
+        # These methods are backported from rails 4.2.5 to work with the above
+        def run_cmd(cmd, args, action)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+        end
 
-          def run_cmd_error(cmd, args, action)
-            msg = "failed to execute:\n"
-            msg << "#{cmd} #{args.join(' ')}\n\n"
-            msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-            msg
-          end
+        def run_cmd_error(cmd, args, action)
+          msg = "failed to execute:\n"
+          msg << "#{cmd} #{args.join(' ')}\n\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 1.7.4
+  version: 1.8.0
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-31 00:00:00.000000000 Z
+date: 2016-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
     - - "<="
       - !ruby/object:Gem::Version
         version: '5.1'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
     - - "<="
       - !ruby/object:Gem::Version
         version: '5.1'
@@ -38,7 +38,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
     - - "<="
       - !ruby/object:Gem::Version
         version: '5.1'
@@ -48,7 +48,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
     - - "<="
       - !ruby/object:Gem::Version
         version: '5.1'