capistrano-cul 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8f18b075e8eb0daa92a48fbba497a780a6a8cb2
-  data.tar.gz: 28bffd4b2afec0899e3918e3d09c6ac9aacf4903
+  metadata.gz: f5d82a7a06ebae390facf636f6505f66d9f8a93c
+  data.tar.gz: 1a8b7288032a93ce2f9b7b03d42620f084c120ee
 SHA512:
-  metadata.gz: 3171e4f2cf8c7e2ff01c1bca1ef4de7c563619f376a203278b51c8f405303620cd7bd86d218583208d53e6c110366973c5885fddee20b3eeaa740ba1752357fc
-  data.tar.gz: 3ee2c4c9ef618595da89a4c67f7d2eb8d158e6c48681dc1195d7c5e6a10e3d3787156e51e601b11346c8b30c7078f5355ded52c8ef2056d0adf2e6fed25ae22e
+  metadata.gz: 655d5ab7c8db37374a8f21d79ecb6f9206e330ca3d6401134915f73c66760f3390f6100388273d14ca225b4c6da9ad38dc1ed151d2cc3cc958550b8580c52203
+  data.tar.gz: e6dbecd9ea3e373b5ec8a7ed7b0dc2d5f4379bd76fdc2095962e4480bd89792447b43a29a937b77dc6b66e74df9eb9f6a996ca99ba2d7bc5a007cac9f58fba20

data/VERSION

@@ -1 +1 @@
-0.0.18
+0.0.19

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-cul
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - Carla Galarza
@@ -72,11 +72,9 @@ files:
 - lib/capistrano/cul/tasks.rb
 - lib/capistrano/cul/wp.rb
 - lib/capistrano/tasks/cul.cap
-- lib/capistrano/tasks/wp-old.cap
 - lib/capistrano/tasks/wp.cap
 - lib/capistrano/tasks/wp/deploy.cap
 - lib/capistrano/tasks/wp/install.cap
-- lib/capistrano/tasks/wp/migrate-old.cap
 - lib/capistrano/tasks/wp/migrate.cap
 - lib/capistrano/tasks/wp/setup.cap
 - lib/capistrano/tasks/wp/update.cap

data/lib/capistrano/tasks/wp-old.cap

@@ -1,250 +0,0 @@
-CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME = 'cul-allowed-upload-types'
-CUL_ALLOWED_UPLOAD_TYPES_REPO_URL = "https://github.com/cul/#{CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME}"
-
-# Set cul_allowed_upload_types_version here so it can be overridden by env config
-set :cul_allowed_upload_types_version, 'v0.5.0'
-
-namespace :cul do
-  namespace :wp do
-
-    before 'deploy:starting', 'cul:wp:require_deploy_params'
-
-    before 'deploy:starting', 'cul:wp:display_maintenance_mode_warning'
-    after 'deploy:starting', 'cul:wp:enable_maintenance_mode'
-    after 'deploy:starting', 'cul:wp:update_cul_allowed_upload_types_plugin'
-    after :deploy, 'cul:wp:symlink_custom_plugins_and_themes'
-    after :deploy, 'cul:wp:disable_maintenance_mode'
-
-
-    task :require_deploy_params do
-      require_cap_variables!([:branch, :wp_version, :wp_docroot, :wp_content_path])
-    end
-
-    desc "Displays a message to the deploying user about how to disable maintenance mode"
-    task :display_maintenance_mode_warning do
-      puts color_text("WARNING: Starting a deployment will set WordPress to maintenance mode.  If you cancel deployment mid-way through, you'll need to manually disable maintenance mode by running: cap [env] cul:wp:disable_maintenance_mode")
-    end
-
-    desc "Enables maintenance mode for the WordPress site in the deploy environment"
-    task :enable_maintenance_mode do
-      path_to_maintenance_file = maintenance_file_path # save path to local variable because we can't call method inside `on roles(:web)`
-      on roles(:web) do
-        within fetch(:wp_docroot) do
-          # Set maintenance $upgrading value to current time.
-          # Note that WordPress will ignore maintenance mode file
-          # after 10 minutes have passed after the maintenance time
-          # we set in the file.
-          execute :echo, "'<?php $upgrading = #{Time.now.to_i};'", '>', path_to_maintenance_file
-        end
-      end
-      puts color_text("Maintenance mode enabled!")
-    end
-
-    desc "Disable maintenance mode for the WordPress site in the deploy environment"
-    task :disable_maintenance_mode do
-      path_to_maintenance_file = maintenance_file_path # save path to local variable because we can't call method inside `on roles(:web)`
-      on roles(:web) do
-        within fetch(:wp_docroot) do
-          if test("[ -f #{path_to_maintenance_file} ]")
-            execute :rm, path_to_maintenance_file
-          else
-            puts "No maintenance file found, so there's nothing to delete."
-          end
-        end
-      end
-      puts color_text("Maintenance mode disabled!")
-    end
-
-    desc "Creates symlinks for custom plugins and themes as part of a WordPress deployment. Generally run as an `after :deploy` hook."
-    task :symlink_custom_plugins_and_themes do
-      symlink_custom_plugins_and_themes
-    end
-
-    # Runs normal deploy task, downloads new copy of WP, sets up docroot, runs
-    # deploy command, sets up symlinks. Does not run WP install and does not
-    # create any wp users.
-    desc "Sets up a WordPress docroot and runs deployment; does not install wordpress and does not create any users"
-    task :setup do
-      puts "Deploying repo branch: #{fetch(:branch)}"
-
-      set :wp_version, ask('WordPress version to download:', 'latest')
-      # Printing out wp_version here because the `set` command above only runs
-      # the first time its associated symbol is referenced, and we want to
-      # capture version before running any other commands.
-      puts "Setting up wp_version: #{fetch(:wp_version)}"
-
-      require_cap_variables!([:branch, :wp_version, :wp_docroot, :wp_content_path])
-
-      on roles(:web) do
-        wp_docroot_wp_config_file_path = File.join(fetch(:wp_docroot), 'wp-config.php')
-        wp_docroot_robots_txt_file_path = File.join(fetch(:wp_docroot), 'robots.txt')
-        wp_docroot_wp_content_path = File.join(fetch(:wp_docroot), 'wp-content')
-
-        shared_wp_config_file_path = shared_path.join('wp-config.php')
-        shared_robots_txt_file_path = shared_path.join('robots.txt')
-
-        wp_content_path = fetch(:wp_content_path)
-
-        # Create nginx logs directory if it doesn't already exist
-        execute :mkdir, '-p', deploy_path.join('logs')
-
-        # Make full path to wp_docroot directory if not exist
-        execute :mkdir, '-p', fetch(:wp_docroot)
-
-        # Make full path to wp_content_path if not exist
-        execute :mkdir, '-p', wp_content_path
-
-        invoke 'deploy' # Deploy before doing setup
-
-        # If wp_docroot/wp-includes does not exist, do wordpress download
-        unless test("[ -d #{File.join(fetch(:wp_docroot), 'wp-includes')} ]")
-          # Download and unpack new WP instance to wp_docroot
-          execute :wp, 'core', ['download', "--version=#{fetch(:wp_version)}", "--path=#{fetch(:wp_docroot)}"]
-        end
-
-        # Check for wp-config.php file in shared. Create if it doesn't exist.
-        unless test("[ -f #{shared_wp_config_file_path} ]")
-          # If no wp-config.php file is found in the 'shared' directory, copy WordPress built-in wp-config-sample.php to there
-          execute :cp, File.join(fetch(:wp_docroot), 'wp-config-sample.php'), shared_wp_config_file_path
-        end
-
-        # Delete original wp-sample-config.php
-        execute :rm, '-f', File.join(fetch(:wp_docroot), 'wp-config-sample.php')
-        # Create symlink for wp_document_root wp-config.php to 'shared' version.
-        execute :ln, '-sf', shared_wp_config_file_path, wp_docroot_wp_config_file_path
-
-        # Check for robots.txt file in shared. Create if it doesn't exist.
-        unless test("[ -f #{shared_robots_txt_file_path} ]")
-          execute "echo -e \"User-agent: *\nDisallow: /\" > #{shared_robots_txt_file_path}"
-        end
-        # Create symlink for wp_document_root robots.txt to 'shared' version.
-        execute :ln, '-sf', shared_robots_txt_file_path, wp_docroot_robots_txt_file_path
-
-        # Check for actual wp-content directory at wp_content_path. Create if it doesn't exist.
-        unless test("[ -d #{wp_content_path} ]")
-          # If no wp-config.php file is found in the 'shared' directory, copy WordPress built-in wp-config-sample.php to there
-          execute :cp, '-r', wp_docroot_wp_content_path, wp_content_path
-        end
-        # Delete original wp-content directory
-        execute :rm, '-rf', wp_docroot_wp_content_path
-        # Create symlink for wp_document_root wp-content to wp_content_path
-        execute :ln, '-sf', wp_content_path, wp_docroot_wp_content_path
-      end
-      symlink_custom_plugins_and_themes
-    end
-
-    
-
-    def self.symlink_custom_plugins_and_themes
-      on roles(:web) do
-        wp_content_path = fetch(:wp_content_path)
-        wp_content_plugin_path = File.join(wp_content_path, 'plugins')
-        wp_content_mu_plugin_path = File.join(wp_content_path, 'mu-plugins')
-        wp_content_themes_path = File.join(wp_content_path, 'themes')
-
-        if test("[ -d #{wp_content_path} ]")
-
-          ### Create necessary directories
-          execute :mkdir, '-p', wp_content_plugin_path
-          execute :mkdir, '-p', wp_content_mu_plugin_path
-          execute :mkdir, '-p', wp_content_themes_path
-
-          ### Remove old symlinks
-          [wp_content_plugin_path, wp_content_mu_plugin_path, wp_content_themes_path].each do |dir|
-            execute :find, dir, '-maxdepth 1', '-type l', '-exec rm {} \;'
-          end
-
-          ### Add latest symlinks
-          fetch(:wp_custom_plugins, {}).each do |plugin, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_plugin_path, plugin)
-          end
-
-          fetch(:wp_custom_mu_plugins, {}).each do |mu_plugin, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_mu_plugin_path, mu_plugin)
-          end
-
-          fetch(:wp_custom_themes, {}).each do |theme, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_themes_path, theme)
-          end
-
-          ### Also symlink to cul-allowed-upload-types plugin files
-          within deploy_path do
-            cul_allowed_upload_types_plugin_top_level_files_and_dirs = capture(:find, CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, '-mindepth', '2', '-maxdepth', '2').split("\n")
-            # Symlink all plugin files and directories
-            cul_allowed_upload_types_plugin_top_level_files_and_dirs.each do |plugin_file_or_directory_path|
-              #puts 'Run: ' + [:ln, '-sf', File.join(deploy_path, plugin_file_or_directory_path), File.join(wp_content_mu_plugin_path, File.basename(plugin_file_or_directory_path))].join(' ')
-              execute :ln, '-sf', File.join(deploy_path, plugin_file_or_directory_path), File.join(wp_content_mu_plugin_path, File.basename(plugin_file_or_directory_path))
-            end
-          end
-
-        end
-      end
-    end
-
-    desc "Downloads the latest version of the cul-allowed-upload-types plugin"
-    task :update_cul_allowed_upload_types_plugin do
-      # Download plugin to deploy_path
-      on roles(:web) do
-        within deploy_path do
-          # Clear out old plugin directory if it exists
-          execute :rm, '-rf', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME
-          # Re-create plugin directory and temp dir inside of it
-          allowed_upload_types_tempdir = File.join(CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, 'tmp')
-          execute :mkdir, '-p', allowed_upload_types_tempdir
-
-          # Download and unzip plugin
-          allowed_upload_types_temp_zipfile = File.join(allowed_upload_types_tempdir, 'plugin.zip')
-          zip_file_name = "#{fetch(:cul_allowed_upload_types_version)}.zip"
-          execute :curl, '-L', '--silent', '-o', allowed_upload_types_temp_zipfile, "#{CUL_ALLOWED_UPLOAD_TYPES_REPO_URL}/archive/#{zip_file_name}"
-          execute :unzip, allowed_upload_types_temp_zipfile, '-d', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME
-
-          # Delete temp dir after unzip
-          execute :rm, '-rf', allowed_upload_types_tempdir
-
-          # Remove .gitignore file from plugin directory so we don't symlink to it later
-          execute :find, CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, '-name', '.gitignore', '-delete'
-        end
-      end
-    end
-
-    desc "Runs a search and replace operation on the tables in a WordPress installation"
-    task :searchreplace do
-      on roles(:web) do
-        within fetch(:wp_docroot) do
-          set :search_string, ask("search string")
-          set :replacement_string, ask("replacement string")
-          puts "Are you sure you want to replace all occurrences of \"#{fetch(:search_string)}\" with \"#{fetch(:replacement_string)}\"?"
-          set :confirm, ask('"y" or "yes" to continue')
-
-          unless ['y', 'yes'].include?(fetch(:confirm))
-            puts 'Search and replace operation has been cancelled because neither "y" nor "yes" were entered.'
-            next
-          end
-
-          puts 'Running search and replace. This may take a while for large databases...'
-          start_time = Time.now
-
-          if fetch(:multisite, false)
-            puts "Since this is a multisite, you'll need to specify the source multisite instance domain to continue:"
-            set :multisite_url, ask('source multisite instance domain (e.g. blogs.cul.columbia.edu)')
-
-            execute :wp, "--url=#{fetch(:multisite_url)}", 'search-replace', "'#{fetch(:search_string)}'", "'#{fetch(:replacement_string)}'", '--all-tables', '--skip-columns=guid'
-          else
-            execute :wp, 'search-replace', "'#{fetch(:search_string)}'", "'#{fetch(:replacement_string)}'", '--skip-columns=guid'
-          end
-
-          puts "Search and replace complete (took #{(Time.now - start_time).to_s} seconds)"
-        end
-      end
-    end
-
-    def self.cul_allowed_upload_types_plugin_path
-      File.join('mu-plugins', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME)
-    end
-
-    def self.maintenance_file_path
-      File.join(fetch(:wp_docroot), '.maintenance')
-    end
-
-  end
-end

data/lib/capistrano/tasks/wp/migrate-old.cap

@@ -1,268 +0,0 @@
-require 'tempfile'
-require 'json'
-
-namespace :cul do
-  namespace :wp do
-    namespace :migrate do
-
-      desc "Copies the WordPress installation from one environment to another (e.g. prod to dev)"
-      task :copy_from do
-        # Need to store path as local variable so it can be referenced in `on roles(:web) do` portion of script
-        path_to_allowed_upload_types_plugin = cul_allowed_upload_types_plugin_path
-
-        require_cap_variables!([:wp_docroot, :wp_content_path])
-
-        if fetch(:multisite, false)
-          puts "Since this is a multisite, you'll need to specify the source multisite instance domain to continue:"
-          set :source_site_multisite_url, ask('source multisite instance domain (e.g. blogs.cul.columbia.edu)')
-          fetch(:source_site_multisite_url)
-
-          puts "And you'll also need to specify the destination multisite instance domain to continue:"
-          set :destination_site_multisite_url, ask('destination multisite instance domain (e.g. blogs-dev.cul.columbia.edu)')
-          fetch(:destination_site_multisite_url)
-        end
-
-        # TODO: Would be nice to verify that destination wordpress has already had the setup and deploy tasks run for it
-        set :src_wp_docroot, ask("server path to source WordPress installation (to copy from)")
-
-        # Confirm operation because it is destructive
-        puts "\nWARNING: This operation will obliterate all content in environment [#{fetch(:stage)}] and replace it with content from [#{fetch(:src_wp_docroot)}]."
-        puts "Are you sure you want to continue?"
-        set :confirm, ask('"y" or "yes" to continue')
-        unless ['y', 'yes'].include?(fetch(:confirm))
-          puts 'Copy operation has been cancelled because neither "y" nor "yes" were entered.'
-          next
-        end
-
-        # Don't really care about maintenance mode because we're completely destroying the target environment
-        # Enter maintenance mode
-        #invoke 'cul:wp:enable_maintenance_mode'
-
-        # Check WP version on source WordPress instance
-        failure = false
-        on roles(:web) do
-          within fetch(:src_wp_docroot) do
-            # Ensure that source WordPress is running the latest version
-            result = capture :wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'core', 'check-update'
-            unless result.index('Success')
-              puts 'Could not copy from source WordPress because it is not running the latest version of WordPress. Please update source before running a copy operation.'
-              failure = true
-            end
-          end
-        end
-        next if failure # End if the previous checks failed
-
-        on roles(:web) do
-          # Destroy current wp_docroot
-          execute :rm, '-rf', fetch(:wp_docroot)
-          execute :mkdir, fetch(:wp_docroot)
-        end
-
-        # Download new copy of wordpress
-        invoke 'cul:wp:setup'
-
-        path_to_list_of_files_to_copy = ''
-
-        on roles(:web) do
-          # In source site's wp-content directory, generate file list to copy
-          within File.join(fetch(:src_wp_docroot), 'wp-content') do
-            # We're going to be copying wp-content in two parts
-            # 1. Everything else under wp-content EXCEPT uploads, blogs.dir,
-            # plugins, themes, mu-plugins
-            # 2. Everything under uploads AND wpblogs.dir with
-            # cul-allowed-upload-types file extension filter applied
-
-            # Make sure find command handles non-ASCII chars
-            #execute 'LC_ALL=en_US.iso885915'
-
-            # Generate two find commands for the above searches
-            find_non_upload_dirs = '. -type f ' +
-              # EXCLUDE plugins, themes, mu-plugins, uploads, and blogs.dir
-              "-not \\( -path './plugins/*' -o -path './mu-plugins/*' -o -path './themes/*' -o -path './uploads/*' -o -path './blogs.dir/*' \\) " +
-              # EXCLUDE certain unwanted files and paths
-              "-a -not \\( -name '.nfs*' -o -name '*.tmp.*' \\) " +
-              "-a -not \\( -path '*/.git*' -o -path '*/.svn*' -o -path '*/.hg*' \\)"
-
-            find_upload_dirs = '. -type f ' +
-              # INCLUDE ONLY uploads and blogs.dir
-              "\\( -path './uploads/*' -o -path './blogs.dir/*' \\) " +
-              # EXCLUDE certain unwanted files and paths
-              "-a -not \\( -name '.nfs*' -o -name '*.tmp.*' \\) " +
-              "-a -not \\( -path '*/.git*' -o -path '*/.svn*' -o -path '*/.hg*' \\) " +
-              # INCLUDE ONLY certain file extensions
-              "-a \\( " + JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'eval', '"echo cul_allowed_upload_file_extensions_as_json();"')).map{ |allowed_file_extension|
-                "-iname '*.#{allowed_file_extension}'"
-              }.join(' -o ') + " \\) "
-
-            path_to_list_of_files_to_copy = '/tmp/WP' + fetch(:wp_docroot).gsub('/', '-') + '-' + Time.now.to_i.to_s + '-files.txt'
-            execute :find, find_non_upload_dirs, ' > ', path_to_list_of_files_to_copy
-            execute :find, find_upload_dirs, ' >> ', path_to_list_of_files_to_copy
-
-            # Print out which files won't be copied
-            files_not_copied = capture(:comm, '-23', "<(find . -type f \\( -path './uploads/*' -o -path './blogs.dir/*' \\) | sort)", "<(find #{find_upload_dirs} | sort)")
-
-            puts (
-              "The following files will not be copied:\n" +
-              "-------------------------\n" +
-              "./plugins\n" +
-              "./mu-plugins\n" +
-              "./themes\n" +
-              files_not_copied + "\n" +
-              "-------------------------"
-            )
-          end
-
-          # For destination wordpress, delete and recreate the wp-content directory
-          execute :rm, '-rf', fetch(:wp_content_path)
-          execute :mkdir, fetch(:wp_content_path)
-
-          # Copy wp-content files (from path_to_list_of_files_to_copy) from source WP to destination WP
-          # Note that because we have the '--copy-links' flag below, we're transforming all symlinks into real file copies
-          rsync_params = [
-            '--recursive',
-            '--perms',
-            '--times',
-            '--devices',
-            '--specials',
-            '--copy-links',
-            '--prune-empty-dirs'
-          ]
-
-          # we're only copying files from the given file list
-          rsync_params << "--files-from=#{path_to_list_of_files_to_copy}"
-
-          src_wp_content_dir = File.join(fetch(:src_wp_docroot), 'wp-content/')
-          # Run a find operation on the wp-content dir to pre-cache all non-UTF compliant files prior to our rsync operation (to handle files with smart quotes, em dashes, foreign characters, etc.)
-          #execute :find, src_wp_content_dir, '-print0', '|', 'perl', '-n0e', '\'chomp; print $_, "\n" if /[[:^ascii:][:cntrl:]]/\''
-
-          # src directory (--files-from values are relative to this src directory)
-          rsync_params << src_wp_content_dir
-          # dest directory
-          rsync_params << fetch(:wp_content_path) + '/'
-
-          puts 'Copying wp-content. This may take a while for sites with a lot of uploads...'
-
-          puts 'rsync args:'
-          puts rsync_params.join(' ')
-
-          # begin
-            execute :rsync, *rsync_params
-          # rescue
-          #   puts '--- Rsync failed, but will continue with deployment anyway!'
-          # end
-
-          # clean up path_to_list_of_files_to_copy file
-          execute :rm, path_to_list_of_files_to_copy
-
-          # Next, create symlinks to repo-managed plugins and themes, which will also recreate plugins, mu-plugins, and themes directories
-
-          within fetch(:wp_docroot) do
-            # Regenerate symlinks
-            invoke! 'cul:wp:symlink_custom_plugins_and_themes'
-          end
-
-          # Now it's time to copy the database
-
-          db_export_tempfile_path = ''
-
-          within fetch(:src_wp_docroot) do
-            # On source WordPress...
-
-            puts 'Exporting database from source site. This may take a while for large sites...'
-            # Export source WP DB to a temporary file
-            db_export_tempfile_path = Dir::Tmpname.make_tmpname '/tmp/', 'db_export_tempfile.sql'
-            execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'db', 'export', db_export_tempfile_path
-          end
-
-          within fetch(:wp_docroot) do
-            # On destination WordPress...
-
-            puts 'Importing database. This may take a while for large sites...'
-
-            # Drop all tables
-            execute :wp, 'db', 'reset', '--yes'
-
-            # Read in db file
-            execute :wp, 'db', 'import', db_export_tempfile_path
-
-            # Delete db file now that we're done with it
-            execute :rm, db_export_tempfile_path
-
-            # Invoke searchreplace task to update URL
-            puts "\nYou'll probably want to run the cul:wp:searchreplace command now, since it's likely that your WP URL differs between environments."
-            puts "Do you want to run a search and replace operation?"
-            set :confirm_searchreplace, ask('"y" or "yes" to continue')
-            if ['y', 'yes'].include?(fetch(:confirm_searchreplace))
-              invoke 'cul:wp:searchreplace'
-            else
-              puts '- Skipping search and replace because neither "y" nor "yes" were entered.'
-            end
-          end
-
-          # Next, install all plugins and themes from src wordpress, matching all versions and active vs. inactive plugin and theme states
-
-          data_for_plugins = []
-          data_for_themes = []
-
-          # Within src wp instance, get list of all plugins and themes with version
-          within File.join(fetch(:src_wp_docroot)) do
-            data_for_plugins = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'plugin', 'list', '--fields=name,version,status', '--format=json'))
-            data_for_themes = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'theme', 'list', '--fields=name,version,status', '--format=json'))
-          end
-
-          # Within dest wp instance, install specifically versioned plugins and themes
-          within File.join(fetch(:wp_docroot)) do
-            # Get list of repo-managed plugins and themes so that we don't attempt to overwrite these directories
-            repo_managed_plugin_names = fetch(:wp_custom_plugins, {}).keys
-            repo_managed_theme_names = fetch(:wp_custom_themes, {}).keys
-
-            puts "Downloading new copies of non-repo-managed plugins and themes..."
-
-            data_for_plugins.delete_if{|plugin_info| repo_managed_plugin_names.include?(plugin_info['name']) }.each do |plugin_info|
-              name = plugin_info['name']
-              version = plugin_info['version']
-              status = plugin_info['status']
-
-              case status
-              when 'active'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}", '--activate'
-              when 'active-network'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}", '--activate-network'
-              when 'inactive'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}"
-              when 'must-use'
-                puts "--- WARNING: must-use plugin #{name} was not migrated over.  It should be put in your blog's repository and deployed through a regular deployment."
-              end
-            end
-
-            data_for_themes.delete_if{|theme_info| repo_managed_theme_names.include?(theme_info['name']) }.each do |theme_info|
-              name = theme_info['name']
-              version = theme_info['version']
-              status = theme_info['status']
-
-              case status
-              when 'active'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'theme', 'install', name, "--version=#{version}", '--activate'
-              when 'inactive', 'parent'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'theme', 'install', name, "--version=#{version}"
-              end
-            end
-          end
-
-          within fetch(:wp_docroot) do
-            # Make docroot readable and executable for "other" user so nginx, which runs as "nobody", can read
-            # Use -L flag because we want to follow symlinks. The whole deployment relies on symlinks.
-            execute :find, '-L', File.join(fetch(:wp_docroot), 'wp-content'), '-type d -exec chmod o+rx "{}" \;'
-            execute :find, '-L', File.join(fetch(:wp_docroot), 'wp-content'), '-type f -exec chmod o+r "{}" \;'
-            # Make sure that wp-config file is not world readable
-            execute :chmod, 'o-r', shared_path.join('wp-config.php')
-          end
-
-        end
-      end
-
-      #after 'cul:wp:migrate:copy_from', 'cul:wp:disable_maintenance_mode'
-
-    end
-  end
-end