pg_power 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8b564bc64ebb7c31041272596e103eaad58e60e
-  data.tar.gz: 988c4d9cf044dc4b247e8437658011987efe6a31
+  metadata.gz: d9419cdd07d825d2debcae661e0dbc5774c9ff6f
+  data.tar.gz: 2e269d9cf4a7479f422cb91f4859b7c48c345f39
 SHA512:
-  metadata.gz: 6497ef6e095d1bfe922a57c5ed692feb1bc8e93cf00ac1385ea3a844d442dbde8e9c3da8e0d92ec184547c332980834e40b8df5bafccf7dcb66b74c7d7f8a666
-  data.tar.gz: fe88de2ff07fe6f5969e2f43b75d7ffe03a45d468b2c387a60ac06ebe6d5a5eb786f7ab07a2be2e8c4bea55312f5e79f91076e09b34d2841d40d01bc59ede91b
+  metadata.gz: 9e75f5b1ef010822863304fab18252d16d9bc592a75b8f949e4d3b5f67e7d360b2bff2c88aecdee83df28783d365830d15cfd5a800dea528628e6e53163e5a23
+  data.tar.gz: 7bff956f8b498fc11c94bf91cb328eec069890b66bf60ceb143ffe99009e87240d03f4b5888f0084d5e81468fda691ceeeacdb508c19efc31442e8345d815788

data/lib/colorized_text.rb

@@ -0,0 +1,33 @@
+# Colorizes text with ASCII colors.
+# == Usage:
+#   include ColorizedText
+#
+#   puts green "OK"          # => green output
+#   puts bold "Running...    # => bold output
+#   puts bold green "OK!!!"  # => bold green output
+module ColorizedText
+  # Colorize text using ASCII color code
+  def colorize(text, code)
+    "\033[#{code}m#{text}\033[0m"
+  end
+
+  # :nodoc:
+  def yellow(text)
+    colorize(text, 33)
+  end
+
+  # :nodoc:
+  def green(text)
+    colorize(text, 32)
+  end
+
+  # :nodoc:
+  def red(text)
+    colorize(text, 31)
+  end
+
+  # :nodoc:
+  def bold(text)
+    colorize(text, 1)
+  end
+end

data/lib/pg_power/connection_adapters/index_definition.rb

@@ -1,6 +1,8 @@
 module PgPower::ConnectionAdapters
   # Structure to store index parameters
-  # Overrides ActiveRecord::ConnectionAdapters::IndexDefinition with the additional :where parameter
-  class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :where, :access_method)
+  # Overrides ActiveRecord::ConnectionAdapters::IndexDefinition
+  # with the additional :where parameter.
+  class IndexDefinition < Struct.new( :table, :name, :unique, :columns,
+                                      :lengths, :where, :access_method )
   end
-end
+end

data/lib/pg_power/connection_adapters/postgresql_adapter/extension_methods.rb

@@ -40,18 +40,18 @@ module PgPower::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
   #    that absorbs the existing objects into the extension, instead of creating new objects
   def create_extension(extension_name, options = {})
     options = CREATE_EXTENSION_DEFAULTS.merge(options.symbolize_keys)
+
     sql = ['CREATE EXTENSION']
-    sql << 'IF NOT EXISTS' if options[:if_not_exists]
+    sql << 'IF NOT EXISTS'                   if options[:if_not_exists]
     sql << %Q{"#{extension_name.to_s}"}
     sql << "SCHEMA #{options[:schema_name]}" if options[:schema_name].present?
-    sql << "VERSION '#{options[:version]}'"    if options[:version].present?
+    sql << "VERSION '#{options[:version]}'"  if options[:version].present?
     sql << "FROM #{options[:old_version]}"   if options[:old_version].present?
 
     sql = sql.join(' ')
     execute(sql)
   end
 
-
   # Execute SQL to remove a postgresql extension module from the current database.
   #
   # @param [#to_s] extension_name Name of the extension module to unload
@@ -70,7 +70,9 @@ module PgPower::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
       mode = mode.to_sym
 
       unless AVAILABLE_DROP_MODES.include?(mode)
-        raise ArgumentError, "Expected one of #{AVAILABLE_DROP_MODES.KEYS.inspect} drop modes, but #{mode} received"
+        raise ArgumentError,
+              "Expected one of #{AVAILABLE_DROP_MODES.keys.inspect} drop modes, " \
+              "but #{mode} received"
       end
 
       sql << AVAILABLE_DROP_MODES[mode]

data/lib/pg_power/connection_adapters/postgresql_adapter/foreigner_methods.rb

@@ -33,13 +33,16 @@ module PgPower # :nodoc:
       SQL
 
       fk_info.map do |row|
-        options = {:column => row['column'], :name => row['name'], :primary_key => row['primary_key']}
+        options = { :column      => row['column'],
+                    :name        => row['name'],
+                    :primary_key => row['primary_key'] }
 
-        options[:dependent] = case row['dependency']
+        options[:dependent] =
+          case row['dependency']
           when 'c' then :delete
           when 'n' then :nullify
           when 'r' then :restrict
-        end
+          end
 
         PgPower::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
       end
@@ -116,16 +119,18 @@ module PgPower # :nodoc:
 
     # Return the SQL code fragment to add the foreign key based on the table names and options.
     def add_foreign_key_sql(from_table, to_table, options = {})
-      foreign_key_name = foreign_key_name(from_table, options[:column], options)
-      primary_key = options[:primary_key] || "id"
-      dependency = dependency_sql(options[:dependent])
+      column           = options[:column]
+      options_options  = options[:options]
+      foreign_key_name = foreign_key_name(from_table, column, options)
+      primary_key      = options[:primary_key] || "id"
+      dependency       = dependency_sql(options[:dependent])
 
       sql =
         "ADD CONSTRAINT #{quote_column_name(foreign_key_name)} " +
-        "FOREIGN KEY (#{quote_column_name(options[:column])}) " +
+        "FOREIGN KEY (#{quote_column_name(column)}) " +
         "REFERENCES #{quote_table_name(ActiveRecord::Migrator.proper_table_name(to_table))}(#{primary_key})"
-      sql << " #{dependency}" if dependency.present?
-      sql << " #{options[:options]}" if options[:options]
+      sql << " #{dependency}"      if dependency.present?
+      sql << " #{options_options}" if options_options
 
       sql
     end
@@ -160,7 +165,9 @@ module PgPower # :nodoc:
       execute "ALTER TABLE #{quote_table_name(from_table)} #{remove_foreign_key_sql(foreign_key_name)}"
 
       options[:exclude_index] ||= false
-      remove_index(from_table, column) unless options[:exclude_index] || !index_exists?(from_table, column)
+      unless options[:exclude_index] || !index_exists?(from_table, column) then
+        remove_index(from_table, column)
+      end
     end
 
     # Return the SQL code fragment to remove foreign key based on table name and options.
@@ -177,7 +184,7 @@ module PgPower # :nodoc:
     # @param [String, Symbol] from_table
     # @param [String]         foreign_key_name
     def id_column_name_from_foreign_key_metadata(from_table, foreign_key_name)
-      keys = foreign_keys(from_table)
+      keys     = foreign_keys(from_table)
       this_key = keys.find {|key| key.options[:name] == foreign_key_name}
       this_key.options[:column]
     end
@@ -185,8 +192,10 @@ module PgPower # :nodoc:
 
     # Build default name for constraint.
     def foreign_key_name(table, column, options = {})
-      if options[:name]
-        options[:name]
+      name = options[:name]
+
+      if !name.nil? then
+        name
       else
         prefix = table.gsub(".", "_")
         "#{prefix}_#{column}_fk"

data/lib/pg_power/connection_adapters/postgresql_adapter/translate_exception.rb

@@ -6,13 +6,15 @@ module PgPower::ConnectionAdapters::PostgreSQLAdapter::TranslateException
 
   # Intercept insufficient privilege PGError and raise active_record wrapped database exception
   def translate_exception(exception, message)
-    case exception.result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
-      when INSUFFICIENT_PRIVILEGE
-        exc_message = exception.result.try(:error_field, PGresult::PG_DIAG_MESSAGE_PRIMARY)
-        exc_message ||= message
-        ::ActiveRecord::InsufficientPrivilege.new(exc_message, exception)
-      else
-        super
+    exception_result = exception.result
+
+    case exception_result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
+    when INSUFFICIENT_PRIVILEGE
+      exc_message = exception_result.try(:error_field, PGresult::PG_DIAG_MESSAGE_PRIMARY)
+      exc_message ||= message
+      ::ActiveRecord::InsufficientPrivilege.new(exc_message, exception)
+    else
+      super
     end
   end
-end
+end

data/lib/pg_power/create_index_concurrently.rb

@@ -108,14 +108,16 @@ module PgPower::CreateIndexConcurrently
     #
     # @see ::PgPower::ConnectionAdapters::PostgreSQLAdapter::ForeignerMethods.add_foreign_key
     def add_foreign_key(from_table, to_table, options = {}, &block)
-      from_table = ::ActiveRecord::Migrator.proper_table_name(from_table)
-      if options[:concurrent_index]
+      from_table       = ::ActiveRecord::Migrator.proper_table_name(from_table)
+      concurrent_index = options[:concurrent_index]
+
+      if concurrent_index then
         if options[:exclude_index]
           raise ArgumentError, 'Conflicted options(exclude_index, concurrent_index) was found, both are set to true.'
         end
 
         options[:column] ||= connection.id_column_name_from_table_name(to_table)
-        options = options.merge(:concurrently => options[:concurrent_index])
+        options = options.merge(:concurrently => concurrent_index)
 
         index_options = { :concurrently => true }
         enque(from_table, options[:column], index_options)

data/lib/pg_power/migration/command_recorder/foreigner_methods.rb

@@ -15,11 +15,13 @@ module PgPower::Migration::CommandRecorder::ForeignerMethods
   def invert_add_foreign_key(args)
     from_table, to_table, add_options = *args
     add_options ||= {}
+    add_name_option   = add_options[:name]
+    add_column_option = add_options[:column]
 
-    if add_options[:name]
-      options = {:name => add_options[:name]}
-    elsif add_options[:column]
-      options = {:column => add_options[:column]}
+    if add_name_option then
+      options = {:name => add_name_option}
+    elsif add_column_option
+      options = {:column => add_column_option}
     else
       options = to_table
     end

data/lib/pg_power/schema_dumper/comment_methods.rb

@@ -15,10 +15,9 @@ module PgPower::SchemaDumper::CommentMethods
 
     # Now dump index comments
     unless (index_comments = @connection.index_comments).empty?
-      index_comments.each do |row|
-        schema_name = row[0]
-        index_name = schema_name == 'public' ? "'#{row[1]}'" : "'#{schema_name}.#{row[1]}'"
-        comment = format_comment(row[2])
+      index_comments.each do |schema_name, table_name, raw_comment|
+        index_name = schema_name == 'public' ? "'#{table_name}'" : "'#{schema_name}.#{table_name}'"
+        comment    = format_comment(raw_comment)
         stream.puts "  set_index_comment #{index_name}, '#{comment}'"
       end
       stream.puts
@@ -31,7 +30,8 @@ module PgPower::SchemaDumper::CommentMethods
     unless (comments = @connection.comments(table_name)).empty?
       comment_statements = comments.map do |row|
         column_name = row[0]
-        comment = format_comment(row[1])
+        comment     = format_comment(row[1])
+
         if column_name
           "  set_column_comment '#{table_name}', '#{column_name}', '#{comment}'"
         else

data/lib/pg_power/schema_dumper/extension_methods.rb

@@ -13,15 +13,15 @@ module PgPower::SchemaDumper::ExtensionMethods
 # @param [#puts] stream Stream to write to
   def dump_extensions(stream)
     extensions = @connection.pg_extensions
-    commands = extensions.map do |extension_name, options|
+    commands   = extensions.map do |extension_name, options|
       result = [%Q|create_extension "#{extension_name}"|]
       result << %Q|:schema_name => "#{options[:schema_name]}"| unless options[:schema_name] == 'public'
       result << %Q|:version => "#{options[:version]}"|
       result.join(', ')
     end
 
-    commands.each do |c|
-      stream.puts("  " + c)
+    commands.each do |command|
+      stream.puts("  #{command}")
     end
 
     stream.puts

data/lib/pg_power/schema_dumper/foreigner_methods.rb

@@ -26,18 +26,24 @@ module PgPower::SchemaDumper::ForeignerMethods
   def foreign_keys(table_name, stream)
     if (foreign_keys = @connection.foreign_keys(table_name)).any?
       add_foreign_key_statements = foreign_keys.map do |foreign_key|
+        options         = foreign_key.options
+        table_from_key  = foreign_key.to_table
         statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
-        statement_parts << foreign_key.to_table.inspect
-        statement_parts << (':name => ' + foreign_key.options[:name].inspect)
+        statement_parts << table_from_key.inspect
+        statement_parts << (':name => ' + options[:name].inspect)
 
-        if foreign_key.options[:column] != "#{foreign_key.to_table.singularize}_id"
-          statement_parts << (':column => ' + foreign_key.options[:column].inspect)
+        column_from_options      = options[:column]
+        primary_key_from_options = options[:primary_key]
+        dependent_from_options   = options[:dependent]
+
+        if column_from_options != "#{table_from_key.singularize}_id"
+          statement_parts << (":column => #{column_from_options.inspect}")
         end
-        if foreign_key.options[:primary_key] != 'id'
-          statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+        if primary_key_from_options != 'id'
+          statement_parts << (":primary_key => #{primary_key_from_options.inspect}")
         end
-        if foreign_key.options[:dependent].present?
-          statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
+        if dependent_from_options.present?
+          statement_parts << (":dependent => #{dependent_from_options.inspect}")
         end
 
         # Always exclude the index

data/lib/pg_power/schema_dumper/view_methods.rb

@@ -6,13 +6,16 @@ module PgPower::SchemaDumper::ViewMethods
     views(stream)
     stream
   end
-  
+
   # Generates code to create views.
   def views(stream)
     # Don't create "system" views.
     view_names = PgPower::Tools.views
     view_names.each do |options|
-      write_view_definition(stream, options["table_schema"], options["table_name"], options["view_definition"])
+      write_view_definition(stream,
+                            options["table_schema"],
+                            options["table_name"],
+                            options["view_definition"])
     end
     stream << "\n"
   end

data/lib/pg_power/tools.rb

@@ -46,14 +46,14 @@ module PgPower
       sql = "CREATE VIEW #{view_name} AS #{view_definition}"
       connection.execute sql
     end
-    
+
     # Drops PostgreSQL view
     # @param [String, Symbol] view_name
     def drop_view(view_name)
       sql = "DROP VIEW #{view_name}"
       connection.execute sql
     end
-    
+
     # Returns an array of existing, non system views.
     def views
       sql = <<-SQL

data/lib/pg_power/version.rb

@@ -1,4 +1,4 @@
 module PgPower
   # Version of pg_power gem.
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_power
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Potapov Sergey
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -98,6 +98,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +140,7 @@ extra_rdoc_files:
 - README.markdown
 files:
 - README.markdown
+- lib/colorized_text.rb
 - lib/core_ext/active_record/connection_adapters/abstract/schema_statements.rb
 - lib/core_ext/active_record/connection_adapters/postgresql_adapter.rb
 - lib/core_ext/active_record/errors.rb