wordpress-deploy 1.0.0.alpha2 → 1.0.0.rc1

data/.gitignore

@@ -12,6 +12,8 @@ test/tmp
 test/version_tmp
 tmp
 
+*.swp
+
 # YARD artifacts
 .yardoc
 _yardoc
@@ -20,8 +22,12 @@ doc/
 # Mac files
 .DS_Store
 
+# Development gems
+Gemfile.lock
+
 # Spec data made during tests
-spec/data/wp-config.php
+spec/data/*.sql
 *.log
 config/
 site/
+sql/

data/Guardfile

@@ -3,22 +3,7 @@
 
 guard 'rspec', :version => 2 do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/wordpress_deploy/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
-
-  # Rails example
-  #watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
-  #watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
-  #watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
-  #watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
-  #watch('config/routes.rb')                           { "spec/routing" }
-  #watch('app/controllers/application_controller.rb')  { "spec/controllers" }
-
-  # Capybara request specs
-  #watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
-
-  # Turnip features and steps
-  #watch(%r{^spec/acceptance/(.+)\.feature$})
-  #watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
 end
 

data/README.md

@@ -35,3 +35,59 @@ Usage
 -----
 
     wp-deploy help
+
+
+```ruby
+##
+# This is an example of a default WordpressDeploy configuration file. The
+# values here are examples to show you what to do.
+WordpressDeploy::Environment.new(:red) do
+
+  base_url "localhost"
+
+  ##
+  # Connection and settings for the MySQL database that wordpress
+  # connects to
+  database do
+    name "red"
+    user "red_user"
+    password "Bun__huPEMeBreM6tebRAp@eguzuQExe"
+    host "hanerutherford.biz"
+    charset "utf8"
+    collate ""
+
+    ##
+    # If this parameter is not defined wp_
+    # is assumed.
+    table_prefix "wp_";
+  end
+
+  ##
+  # Authentication Unique Keys and Salts
+  # https://api.wordpress.org/secret-key/1.1/salt/
+  # If no salts are supplied they will be generated automatically
+  #
+  # NOTE This entire block is optional
+  salts do
+    auth_key         '*oH{(q=`tIzdNJKUk$XfHNNjKd$W=f$S`CtD.,;x0R}$/A,}]!+q0>>QfB#.Bsw]'
+    secure_auth_key  '{yg|7Q*j-?$%`b|Z!+5U,pvM,eA0+$/ruprp.mO[;|fExU:n0,-!at0+3UY@;h`X'
+    logged_in_key    'k]N 9I<-rZq#k Xg)IPhv$E*ktbD7Z_AtI){U;(P;0r#LJlYncEr%8v9tG`>BHU+'
+    nonce_key        ' /w9->::-YB Xa#lf%TPH+cIf?]Ru4OfKGF2h8PHsa)2,n-~kRJ<[slUg<GZ Asx'
+    auth_salt        'VYwGGP,#|9P[5RCUTdv2c8)`^{dotU0fWrU`JE9qq^n=F4//e)fCs<HF6sd>~yjW'
+    secure_auth_salt 'ok}@vSs=n6%_%UCO|&[?Jc;,-,.#Q3}zR4ej%IoAL7RavTN/Xe,UrQ4)p}onRie0'
+    logged_in_salt   'Z!,C*:Q_I9A`[pJm-b0Z/(Gm2qvK8>0~| T&)lM+sxG.OdEmgHbAGF&(^>2.rDGW'
+    nonce_salt       'ay)${bFV=F1KH[`NZ+W+Zk?Hc:@}jN}Ec)+Zn[F1fyP,mwi|@tk/(1hdp[G2F%os'
+  end
+
+  ##
+  # Block defines the settings for the transfer of files
+  # to this configuration.
+  transfer :Ftp do
+    host "ftp.hanerutherford.biz"
+    user "red_user"
+    password "Bun__huPEMeBreM6tebRAp@eguzuQExe"
+    destination "/html"
+  end
+
+end
+```

data/lib/wordpress_deploy.rb

@@ -1,16 +1,49 @@
 require "thor"
 require "open3"
 require "fileutils"
+require "yaml"
+
+class Hash
+
+  def find_and_replace!(find, replace)
+    RecursiveReplace.find_and_replace!(find, replace, self) 
+  end
+
+end
+
+class RecursiveReplace
+
+  def self.find_and_replace!(find, replace, obj)
+    m = "find_and_replace_#{obj.class}!"
+    send(m, find, replace, obj) if respond_to? m, true
+  end
+
+  private
+
+  def self.find_and_replace_Hash!(find, replace, hash)
+    hash.each { |k,v| find_and_replace!(find, replace, v) }
+  end
+
+  def self.find_and_replace_Array!(find, replace, arr)
+    arr.each { |x| find_and_replace!(find, replace, x) }
+  end
+
+  def self.find_and_replace_String!(find, replace, str)
+    str.gsub!(/#{find}/, replace)
+  end
+
+end
 
 module WordpressDeploy
   ##
   # WordpressDeploy's internal paths
   #
-  LIBRARY_PATH            = File.join(File.dirname(__FILE__), 'wordpress_deploy')
-  CLI_PATH                = File.join(LIBRARY_PATH, 'cli')
-  WORDPRESS_PATH          = File.join(LIBRARY_PATH, 'wordpress')
-  TRANSFER_PROTOCOLS_PATH = File.join(LIBRARY_PATH, 'transfer_protocols')
-  DATABASE_PATH           = File.join(LIBRARY_PATH, 'database')
+  LIBRARY_PATH    = File.join(File.dirname(__FILE__), 'wordpress_deploy')
+  TEMPLATE_PATH   = File.join(File.dirname(__FILE__), '..', 'templates')
+  CLI_PATH        = File.join(LIBRARY_PATH, 'cli')
+  WORDPRESS_PATH  = File.join(LIBRARY_PATH, 'wordpress')
+  STORAGE_PATH    = File.join(LIBRARY_PATH, 'storage')
+  DATABASE_PATH   = File.join(LIBRARY_PATH, 'database')
 
   module Cli
     autoload :Helpers, File.join(CLI_PATH, 'helpers')
@@ -18,18 +51,19 @@ module WordpressDeploy
   end
 
   module Wordpress
-    autoload :Configuration, File.join(WORDPRESS_PATH, 'configuration')
+    autoload :Salts, File.join(WORDPRESS_PATH, 'salts')
   end
 
-  module TransferProtocols
-    autoload :Ftp, File.join(TRANSFER_PROTOCOLS_PATH, 'ftp')
+  module Storage
+    autoload :Ftp,   File.join(STORAGE_PATH, 'ftp')
+    autoload :Local, File.join(STORAGE_PATH, 'local')
   end
 
   module Database
     autoload :MySql, File.join(DATABASE_PATH, 'mysql')
   end
 
-  %w{version logger errors environment}.each do |klass|
+  %w{version logger errors config environments environment}.each do |klass|
     require File.join(LIBRARY_PATH, klass)
   end
 end

data/lib/wordpress_deploy/cli/helpers.rb

@@ -14,7 +14,7 @@ module WordpressDeploy
       # If the command fails to execute, or returns a non-zero exit status
       # an Error will be raised.
       #
-      # Returns nil
+      # Returns STDOUT
       def run(command)
         name = command_name(command)
         Logger.debug "Running system utility '#{ name }'..."
@@ -47,7 +47,7 @@ module WordpressDeploy
             )
           end
 
-          return nil
+          return out
         else
           raise Errors::Cli::SystemCallError, <<-EOS
             '#{ name }' Failed on #{ RUBY_PLATFORM }
@@ -69,7 +69,10 @@ module WordpressDeploy
         raise Errors::Cli::UtilityNotFoundError,
             'Utility Name Empty' if name.empty?
 
+        # Return the utility immediately if it has already been found
         path = UTILITY[name]
+        return path unless path.nil?
+
         err, ps = '', nil
         Open3.popen3 "which #{name}" do |stdin, stdout, stderr, wait_thr|
           stdin.close
@@ -78,7 +81,7 @@ module WordpressDeploy
 
           # Process::Status object returned
           ps = wait_thr.value
-        end if path.nil?
+        end
 
         if !ps.nil? && ps.success?
           UTILITY[name] = path

data/lib/wordpress_deploy/cli/utility.rb

@@ -9,24 +9,26 @@ module WordpressDeploy
       # These options apply to all commands
       class_option :root_dir,    type: :string,  default: '',           aliases: '-r'
       class_option :wp_dir,      type: :string,  default: '',           aliases: '-w'
-      class_option :environment, type: :string,  default: 'production', aliases: '-e'
+      class_option :config_dir,  type: :string,  default: '',           aliases: '-c'
+      class_option :sql_dir,     type: :string,  default: '',           aliases: '-s'
       class_option :verbose,     type: :boolean, default: false,        aliases: '-v'
 
-
-      desc "generate", "Generate the wp-config.php file. Accepted environments are production or development."
-      def generate
-        ##
+      desc "config ENVIRONMENT", "Generate the wp-config.php file for the specified environment."
+      def config(environment)
         # Set Logger into verbose mode (if the user requested it)
         Logger.verbose = options[:verbose]
 
         # Set environment options
-        Environment.set_options options
+        Config.set_options options
+
+        # Load ALL the available environments
+        WordpressDeploy::Environments.load
 
-        # Create a configuration file
-        config = Wordpress::Configuration.new
+        # Get the Environment the user requested
+        env = WordpressDeploy::Environments.find environment.to_sym
 
         # Save the configuration file
-        config.save!
+        env.save_wp_config
       rescue => err
         Logger.error Errors::Cli::Utility::Error.wrap(err)
 
@@ -34,62 +36,83 @@ module WordpressDeploy
         exit(1)
       end
 
-      desc "deploy", "Deploy via FTP to configuration hostname."
-      def deploy
-        ##
+      desc "deploy FROM TO", <<-EOS
+Deploy Wordpress onto the TO environment.
+
+This is achieved by first generating the appropriate wp-config.php file for the
+desired environment. This wp-config.php, along with all other files within the
+wp_dir, are then transmitted to the configured TO environment.
+
+Next, the FROM database is backed up into the sql_dir, and then sent to the
+configured TO environment. Finally, all records in the TO database are scrubbed
+to be relative to the new hostname configured for the environment (this
+includes PHP serialized strings).
+      EOS
+      def deploy(from, to)
         # Set Logger into verbose mode (if the user requested it)
         Logger.verbose = options[:verbose]
 
         # Set environment options
-        Environment.set_options options
+        Config.set_options options
 
-        # Create a new FTP client for sending the files
-        ftp_client = TransferProtocols::Ftp.new options[:environment]
+        # Load ALL the available environments
+        WordpressDeploy::Environments.load
 
-        # Now transmit the files
-        ftp_client.transmit!
+        # Get the Environment the user requested
+        from = WordpressDeploy::Environments.find from.to_sym
+        to   = WordpressDeploy::Environments.find to.to_sym
 
       rescue => err
         Logger.error Errors::Cli::Utility::Error.wrap(err)
 
         # Exit with an error
         exit(1)
-      ensure
-        puts "Closing connection.".colorize(color: :red, background: :yellow) if ftp_client.close
       end
 
-      desc "backup", "Pull down the remote files over FTP."
-      def backup
-        ##
+      desc "backup ENVIRONMENT", "Call mysqldump on the database specified by ENVIRONMENT"
+      def backup(environment)
         # Set Logger into verbose mode (if the user requested it)
         Logger.verbose = options[:verbose]
 
         # Set environment options
-        Environment.set_options options
+        Config.set_options options
+
+        # Load ALL the available environments
+        WordpressDeploy::Environments.load
 
-        # Create a new FTP client for receiving the files
-        ftp_client = TransferProtocols::Ftp.new options[:environment]
+        # Get the Environment the user requested
+        env = WordpressDeploy::Environments.find environment.to_sym
 
-        # Now receive the files
-        ftp_client.receive!
+        # Backup the database to the sql_dir
+        env.database.save!
 
       rescue => err
         Logger.error Errors::Cli::Utility::Error.wrap(err)
 
         # Exit with an error
         exit(1)
-      ensure
-        puts "Closing connection.".colorize(color: :red, background: :yellow) if ftp_client.close
       end
 
-      desc "mirror", "Mirror database between two locations"
-      def mirror(from, to)
-        ##
+      desc "transmit ENVIRONMENT", "Transmit the files in wp_dir"
+      def transmit(environment)
         # Set Logger into verbose mode (if the user requested it)
         Logger.verbose = options[:verbose]
 
         # Set environment options
-        Environment.set_options options
+        Config.set_options options
+
+        # Load ALL the available environments
+        WordpressDeploy::Environments.load
+
+        # Get the Environment the user requested
+        env = WordpressDeploy::Environments.find environment.to_sym
+
+        # Save the configuration file
+        env.save_wp_config
+
+        # Send the files in wp_dir
+        env.transfer.transmit!
+
       rescue => err
         Logger.error Errors::Cli::Utility::Error.wrap(err)
 

data/lib/wordpress_deploy/config.rb

@@ -0,0 +1,77 @@
+module WordpressDeploy
+  ##
+  # Config defines all of the locations of input and
+  # output files. Specifically, the locations of the test
+  # definitions, the locations of the test results, and
+  # the locations of the build applications.
+  module Config
+
+    ##
+    # Setup required paths based on the given options
+    def self.set_options(options = {})
+      options.each do |option, value|
+        method = "#{option}="
+        send(method, value) if respond_to? method and !value.empty?
+      end
+    end
+
+    def self.logging=(new_log)
+      # Only set @@logging if new_log is a boolean
+      if !!new_log == new_log
+        @@logging = new_log
+      else
+        @@logging = false
+      end
+    end
+
+    def self.logging?
+      @@logging ||= false
+      @@logging
+    end
+
+    def self.root_dir=(new_root)
+      @@root_dir = new_root
+    end
+
+    def self.root_dir
+      @@root_dir ||= Dir.pwd
+      File.expand_path @@root_dir
+    end
+
+    def self.config_dir=(new_config_dir)
+      @@config_dir = new_config_dir
+    end
+
+    def self.config_dir
+      @@config_dir ||= "config"
+      File.expand_path File.join(root_dir, @@config_dir)
+    end
+
+    def self.wp_dir=(new_wp_dir)
+      @@wp_dir = new_wp_dir
+    end
+
+    def self.wp_dir
+      @@wp_dir ||= "site"
+      File.expand_path File.join(root_dir, @@wp_dir)
+    end
+
+    def self.sql_dir=(new_sql_dir)
+      @@sql_dir = new_sql_dir
+    end
+
+    def self.sql_dir
+      @@sql_dir ||= "sql"
+      File.expand_path File.join(root_dir, @@sql_dir)
+    end
+
+    def self.log_file
+      @@log_file ||= "#{Time.now.strftime("%Y_%m_%d_%H_%M_%S")}.log"
+      File.expand_path File.join(root_dir, @@log_file)
+    end
+
+    def self.clean!
+      FileUtils.rm Dir.glob(File.join(root_dir, "*.log"))
+    end
+  end
+end

data/lib/wordpress_deploy/database/mysql.rb

@@ -1,4 +1,6 @@
-require 'tmpdir'
+require 'tempfile'
+require 'mysql2'
+require 'php_serialize'
 
 module WordpressDeploy
   module Database
@@ -6,37 +8,296 @@ module WordpressDeploy
     class MySql
       include WordpressDeploy::Cli::Helpers
 
-      attr_reader :configuration
-
       def initialize
-        @yaml     = YAML.load_file(File.join(Environment.config_dir, "wp-config.yml"))
+        @user       ||= "root"
+        @password   ||= ""
+
+        @host       ||= "localhost"
+        @port       ||= 3306
+        @socket     ||= ""
+        @name       ||= "wordpress"
+
+        @has_port   ||= true
+        @has_socket ||= false
       end
 
-      def mysqldump
-        "#{utility("mysqldump")} #{arguments}"
+      ##
+      # Name of the database (DB_NAME)
+      def name(new_name = nil)
+        @name = new_name.to_s unless new_name.nil?
+        @name
       end
 
-      def configuration=(new_config)
-        @configuration = new_config if new_config.instance_of? WordpressDeploy::Wordpress::Configuration
+      ##
+      # User credentials for the specified database
+      def user(new_user = nil)
+        @user = new_user.to_s unless new_user.nil?
+        @user
       end
 
-      private
+      ##
+      # Password credentials for the specified database
+      def password(new_password = nil)
+        @password = new_password.to_s unless new_password.nil?
+        @password
+      end
+
+      ##
+      # Get just the hostname from DB_HOST. Only different from
+      # DB_HOST if DB_HOST has a socket or a port number in it.
+      def host(new_host = nil)
+        unless new_host.nil?
+          match = /(?<host>.*?)(?=:|\z)(:(?<socket>\/.*)|:(?<port>\d+))?/.match(new_host.to_s)
+          @host = match[:host].to_s unless match[:host].nil?
+
+          # Set the socket information
+          if @has_socket = !match[:socket].nil?
+            @has_socket = true
+            @socket = match[:socket]
+          end
+
+          # Set the port information
+          unless match[:port].nil?
+            @port = match[:port].to_i
+          end
+
+          # Has port is true; unless a socket was set
+          @has_port = !@has_socket
+        end
+
+        # return the host
+        @host
+      end
+
+      ##
+      # This value should be able to be plugged directly into
+      # DB_HOST int he wp-config.php file.
+      def wp_host
+        extra = nil
+        extra = ":#{socket}" if socket?
+        extra = ":#{port}" if port?
+        "#{host}#{extra}"
+      end
+
+      ##
+      # Extract just the port number from the DB_HOST
+      # configuration file. Or return the default port of 3306.
+      def port
+        @port
+      end
+
+      ##
+      # Does DB_HOST contain a port number? (it does if one was
+      # specified and it does not equal 3306; the default MySQL
+      # port number.
+      def port?
+        @has_port && port != 3306
+      end
+
+      ##
+      # Extract just the socket part from the DB_HOST
+      # configuration file. Or return an empty string if none.
+      def socket
+        @socket
+      end
+
+      ##
+      # Does DB_HOST contain a socket path?
+      def socket?
+        @has_socket
+      end
+
+      def charset(new_charset = nil)
+        @charset = new_charset.to_s unless new_charset.nil?
+        @charset
+      end
 
-      def arguments
-        host = configuration.host
-        port = configuration.port
-        username = configuration.DB_USER
-        password = configuration.DB_PASSWORD
-        db_name = configuration.DB_NAME
+      def collate(new_collate = nil)
+        @collate = new_collate.to_s unless new_collate.nil?
+        @collate
+      end
 
-        "-P \"#{port}\" -h \"#{host}\" -u \"#{username}\" -p#{password} -B \"#{db_name}\""
+      def table_prefix(new_prefix = nil)
+        @prefix = new_prefix.to_s unless new_prefix.nil?
+        @prefix
+      end
+
+      ##
+      # The file that the instance would save to if
+      # save is called.
+      def file
+        File.join(Config.sql_dir, "#{name}.sql")
       end
 
       ##
-      # A temporary directory for installing the executable to
-      def tmp_dir
-        @tmp_dir ||= Dir.mktmpdir
-        File.expand_path(@tmp_dir)
+      # Save the database to a file locally.
+      #
+      # The database will be output into #file.
+      def save!
+        # Get the output from MySQL Dump
+        cmd = mysqldump
+        dump_str = run cmd
+
+        # Open the supplied file; or create a temporary one
+        file_io = File.new(file, 'w')
+
+        # Start writing to file
+        file_io.write(dump_str)
+
+        true
+      ensure
+        file_io.close unless file_io.nil?
+      end
+
+      ##
+      #
+      def send!(to_config_name)
+        # Check to see if there is a SQL file
+        if File.exists? file
+          # Create the 'to' configuration
+          mysql = self.class.new(to_config_name)
+
+          # Open the source sql file for reading
+          tmp_file = Tempfile.new(["#{to_config_name}", '.sql'])
+
+          # Write sql to tmpfile while changing the
+          # the CREATE DATABASE and USE commands to make sense for
+          # the 'to' configuration
+          sql_dump = File.read(file)
+          sql_dump.gsub!(/^USE\ `#{self.DB_NAME}`/, "USE `#{mysql.DB_NAME}`")
+          tmp_file.puts sql_dump
+
+          # Get the MySQL load command
+          cmd = mysqlload to_config_name, tmp_file.path
+
+          # Run the mysql command to load the mysqldump into
+          # the destination mysql instance
+          run cmd
+        end
+      ensure
+        # Delete the temp file unless it was never made
+        tmp_file.unlink unless tmp_file.nil?
+      end
+
+      ##
+      #
+      def migrate!(to_config_name)
+        mysql = self.class.new(to_config_name)
+
+        client = Mysql2::Client.new(
+          :host     => mysql.db_hostname,
+          :username => mysql.DB_USER,
+          :password => mysql.DB_PASSWORD,
+          :port     => mysql.db_port,
+          :database => mysql.DB_NAME,
+          #:socket = '/path/to/mysql.sock',
+          :encoding => mysql.DB_CHARSET
+        )
+
+        value_to_find = "localhost/~lindsey/huntsvillecrawfishboil.com"
+        value_to_replace = "huntsvillecrawfishboil.com"
+        escaped_value_to_find = client.escape(value_to_find)
+
+        # wp_options option_value
+        sql = <<-EOS
+        SELECT `option_id`, `option_value`
+        FROM `wp_options`
+        WHERE `option_value` REGEXP '#{escaped_value_to_find}';
+        EOS
+        wp_options = client.query(sql)
+        wp_options.each do |row|
+          row.each do |key, value|
+            if PHP.serialized?(value)
+              ruby_php = PHP.unserialize(value)
+              ruby_php.find_and_replace!(value_to_find, value_to_replace)
+              value.replace PHP.serialize(ruby_php)
+            else
+              value.gsub!(/#{value_to_find}/, value_to_replace) if value.instance_of? String
+            end
+          end
+
+          # Update the database
+          sql = <<-EOD
+          UPDATE `wp_options`
+          SET `option_value`='#{client.escape(row['option_value'])}'
+          WHERE `option_id` = #{row['option_id']};
+          EOD
+          Logger.debug sql
+          client.query(sql)
+        end
+
+        # wp_posts post_content, guid
+        sql = <<-EOS
+        SELECT `ID`, `post_content`, `guid`
+        FROM `wp_posts`
+        WHERE `post_content` REGEXP '#{escaped_value_to_find}'
+        AND   `guid`         REGEXP '#{escaped_value_to_find}';
+        EOS
+        wp_posts = client.query(sql)
+        wp_posts.each do |row|
+          row.each do |key, value|
+            if PHP.serialized?(value)
+              ruby_php = PHP.unserialize(value)
+              ruby_php.find_and_replace!(value_to_find, value_to_replace)
+              value.replace PHP.serialize(ruby_php)
+            else
+              value.gsub!(/#{value_to_find}/, value_to_replace) if value.instance_of? String
+            end
+          end
+          sql = <<-EOD
+          UPDATE `wp_posts`
+          SET `post_content` = '#{client.escape(row['post_content'])}',
+          `guid` = '#{client.escape(row['guid'])}'
+          WHERE `ID` = #{row['ID']};
+          EOD
+          Logger.debug sql
+          client.query(sql)
+        end
+
+        # wp_postmeta
+        sql = <<-EOS
+        SELECT `meta_id`, `meta_value`
+        FROM `wp_postmeta`
+        WHERE `meta_value` REGEXP '#{escaped_value_to_find}';
+        EOS
+        wp_postmeta = client.query(sql)
+        wp_postmeta.each do |row|
+          row.each do |key, value|
+            if PHP.serialized?(value)
+              ruby_php = PHP.unserialize(value)
+              ruby_php.find_and_replace!(value_to_find, value_to_replace)
+              value.replace PHP.serialize(ruby_php)
+            else
+              value.gsub!(/#{value_to_find}/, value_to_replace) if value.instance_of? String
+            end
+          end
+          sql = <<-EOD
+          UPDATE `wp_postmeta`
+          SET `meta_value` = '#{client.escape(row['meta_value'])}'
+          WHERE `meta_id` = #{row['meta_id']};
+          EOD
+          Logger.debug sql
+          client.query(sql)
+        end
+      end
+
+      private
+
+      def mysqldump
+        arguments = "-P \"#{port}\" -h \"#{host}\" -u \"#{user}\" -p\"#{password}\" -B \"#{name}\""
+        "#{utility("mysqldump")} #{arguments}"
+      end
+
+      def mysqlload(config_name, file_name)
+        mysql = self.class.new config_name
+        arg_port = mysql.db_port
+        arg_host = mysql.db_hostname
+        arg_user = mysql.DB_USER
+        arg_pass = mysql.DB_PASSWORD
+        arg_name = mysql.DB_NAME
+        arguments = "-P \"#{arg_port}\" -u \"#{arg_user}\" -h \"#{arg_host}\" -p\"#{arg_pass}\" -D \"#{arg_name}\""
+
+        "#{utility("mysql")} #{arguments} < #{file_name}"
       end
 
     end