wordmove 5.2.0 → 6.0.0.alpha.2

data/lib/wordmove/db_paths_config.rb

@@ -0,0 +1,44 @@
+class DbPathsConfig
+  extend Dry::Configurable
+
+  setting :local, reader: true do
+    setting :path
+    setting :gzipped_path
+    setting :adapted_path
+    setting :gzipped_adapted_path
+  end
+
+  setting :remote, reader: true do
+    setting :path
+    setting :gzipped_path
+  end
+
+  setting :backup, reader: true do
+    setting :local do
+      setting :path
+      setting :gzipped_path
+    end
+
+    setting :remote do
+      setting :path
+      setting :gzipped_path
+    end
+  end
+
+  # FTP settings are intentionally taken apart
+  setting :ftp, reader: true do
+    setting :remote, reader: true do
+      setting :dump_script_path
+      setting :dump_script_url
+      setting :dumped_path
+      setting :import_script_path
+      setting :import_script_url
+    end
+    setting :local, reader: true do
+      setting :generated_dump_script_path
+      setting :generated_import_script_path
+      setting :temp_path
+    end
+    setting :token
+  end
+end

data/lib/wordmove/doctor/movefile.rb

@@ -4,17 +4,17 @@ module Wordmove
       MANDATORY_SECTIONS = %i[global local].freeze
       attr_reader :movefile, :contents, :root_keys
 
-      def initialize(name = nil, dir = '.')
-        @movefile = Wordmove::Movefile.new(name, dir)
+      def initialize(cli_options = {}, dir = '.')
+        @movefile = Wordmove::Movefile.new(cli_options, dir)
 
         begin
-          @contents = movefile.fetch
+          @contents = movefile.options
           @root_keys = contents.keys
         rescue Psych::SyntaxError
-          movefile.logger.error "Your movefile is not parsable due to a syntax error"\
+          movefile.logger.error 'Your movefile is not parsable due to a syntax error'\
                                 "so we can't continue to validate it."
-          movefile.logger.debug "You could try to use https://yamlvalidator.com/ to"\
-                                "get a clue about the problem."
+          movefile.logger.debug 'You could try to use https://yamlvalidator.com/ to'\
+                                'get a clue about the problem.'
         end
       end
 
@@ -40,7 +40,7 @@ module Wordmove
         errors = validator.validate(contents[key].deep_stringify_keys)
 
         if errors&.empty?
-          movefile.logger.success "Formal validation passed"
+          movefile.logger.success 'Formal validation passed'
 
           return true
         end
@@ -69,7 +69,7 @@ module Wordmove
       def validate_protocol_presence(keys)
         return true if keys.include?(:ssh) || keys.include?(:ftp)
 
-        movefile.logger.error "This remote has not ssh nor ftp protocol defined"
+        movefile.logger.error 'This remote has not ssh nor ftp protocol defined'
 
         false
       end

data/lib/wordmove/doctor/mysql.rb

@@ -4,16 +4,18 @@ module Wordmove
       attr_reader :config, :logger
 
       def initialize(movefile_name = nil, movefile_dir = '.')
-        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+        @logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
         begin
-          @config = Wordmove::Movefile.new(movefile_name, movefile_dir).fetch[:local][:database]
-        rescue Psych::SyntaxError
-          return
+          @config = Wordmove::Movefile
+                    .new({ config: movefile_name }, movefile_dir)
+                    .options[:local][:database]
+        rescue Psych::SyntaxError => e
+          logger.error e.message
         end
       end
 
       def check!
-        logger.task "Checking local database commands and connection"
+        logger.task 'Checking local database commands and connection'
 
         return logger.error "Can't connect to mysql using your movefile.yml" if config.nil?
 
@@ -26,18 +28,18 @@ module Wordmove
       private
 
       def mysql_client_doctor
-        if system("which mysql", out: File::NULL)
-          logger.success "`mysql` command is in $PATH"
+        if system('which mysql', out: File::NULL)
+          logger.success '`mysql` command is in $PATH'
         else
-          logger.error "`mysql` command is not in $PATH"
+          logger.error '`mysql` command is not in $PATH'
         end
       end
 
       def mysqldump_doctor
-        if system("which mysqldump", out: File::NULL)
-          logger.success "`mysqldump` command is in $PATH"
+        if system('which mysqldump', out: File::NULL)
+          logger.success '`mysqldump` command is in $PATH"'
         else
-          logger.error "`mysqldump` command is not in $PATH"
+          logger.error '`mysqldump` command is not in $PATH'
         end
       end
 
@@ -45,7 +47,7 @@ module Wordmove
         command = mysql_command
 
         if system(command, out: File::NULL, err: File::NULL)
-          logger.success "Successfully connected to the MySQL server"
+          logger.success 'Successfully connected to the MySQL server'
         else
           logger.error <<-LONG
   We can't connect to the MySQL server using credentials
@@ -63,7 +65,7 @@ module Wordmove
         command = mysql_command(database: config[:name])
 
         if system(command, out: File::NULL, err: File::NULL)
-          logger.success "Successfully connected to the database"
+          logger.success 'Successfully connected to the database'
         else
           logger.error <<-LONG
   We can't connect to the database using credentials
@@ -79,16 +81,17 @@ module Wordmove
       end
 
       def mysql_command(database: nil)
-        command = ["mysql"]
+        command = ['mysql']
         command << "--host=#{Shellwords.escape(config[:host])}" if config[:host].present?
         command << "--port=#{Shellwords.escape(config[:port])}" if config[:port].present?
         command << "--user=#{Shellwords.escape(config[:user])}" if config[:user].present?
         if config[:password].present?
           command << "--password=#{Shellwords.escape(config[:password])}"
         end
+        command << Shellwords.split(config[:mysql_options]) if config[:mysql_options].present?
         command << database if database.present?
         command << "-e'QUIT'"
-        command.join(" ")
+        command.join(' ')
       end
     end
   end

data/lib/wordmove/doctor/rsync.rb

@@ -4,11 +4,11 @@ module Wordmove
       attr_reader :logger
 
       def initialize
-        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+        @logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
       end
 
       def check!
-        logger.task "Checking rsync"
+        logger.task 'Checking rsync'
 
         if (version = /\d\.\d.\d/.match(`rsync --version | head -n1`)[0])
           logger.success "rsync is installed at version #{version}"

data/lib/wordmove/doctor/ssh.rb

@@ -4,14 +4,14 @@ module Wordmove
       attr_reader :logger
 
       def initialize
-        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+        @logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
       end
 
       def check!
-        logger.task "Checking SSH client"
+        logger.task 'Checking SSH client'
 
         if system('which ssh', out: File::NULL, err: File::NULL)
-          logger.success "SSH command found"
+          logger.success 'SSH command found'
         else
           logger.error "SSH command not found. And belive me: it's really strange it's not there."
         end

data/lib/wordmove/doctor/wpcli.rb

@@ -4,17 +4,17 @@ module Wordmove
       attr_reader :logger
 
       def initialize
-        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+        @logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
       end
 
       def check!
-        logger.task "Checking local wp-cli installation"
+        logger.task 'Checking local wp-cli installation'
 
         if in_path?
-          logger.success "wp-cli is correctly installed"
+          logger.success 'wp-cli is correctly installed'
 
           if up_to_date?
-            logger.success "wp-cli is up to date"
+            logger.success 'wp-cli is up to date'
           else
             logger.error <<-LONG
   wp-cli is not up to date.

data/lib/wordmove/environments_list.rb

@@ -9,8 +9,8 @@ module Wordmove
     end
 
     def initialize(options)
-      @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
-      @movefile = Wordmove::Movefile.new(options[:config])
+      @logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+      @movefile = Wordmove::Movefile.new(options)
       @remote_vhosts = []
       @local_vhost = []
     end
@@ -29,7 +29,7 @@ module Wordmove
     end
 
     def parse_movefile(movefile:)
-      movefile.fetch
+      movefile.options
     end
 
     def output
@@ -43,7 +43,7 @@ module Wordmove
     def output_string(vhost_list:)
       return 'vhost list is empty' if vhost_list.empty?
 
-      vhost_list.each_with_object("") do |entry, retval|
+      vhost_list.each_with_object('') do |entry, retval|
         retval << "#{entry[:env]}: #{entry[:vhost]}\n"
       end
     end

data/lib/wordmove/exceptions.rb

@@ -1,10 +1,23 @@
 module Wordmove
   class UndefinedEnvironment < StandardError; end
+
   class NoAdapterFound < StandardError; end
+
   class MovefileNotFound < StandardError; end
+
   class ShellCommandError < StandardError; end
+
   class ImplementInSubclassError < StandardError; end
+
   class UnmetPeerDependencyError < StandardError; end
+
   class RemoteHookException < StandardError; end
+
   class LocalHookException < StandardError; end
+
+  class FtpNotSupportedException < StandardError
+    def message
+      'FTP protocol is no more supported in verison >= 6.0'
+    end
+  end
 end

data/lib/wordmove/generators/movefile.rb

@@ -1,15 +1,17 @@
 module Wordmove
   module Generators
-    class Movefile < Thor::Group
-      include Thor::Actions
+    class Movefile
       include MovefileAdapter
 
-      def self.source_root
-        File.dirname(__FILE__)
+      def self.generate
+        new.copy_movefile
       end
 
       def copy_movefile
-        template "movefile.yml"
+        content = ERB.new(File.read(File.join(__dir__, 'movefile.yml'))).result(binding)
+        files = Dry::Files.new
+
+        files.write('movefile.yml', content)
       end
     end
   end

data/lib/wordmove/generators/movefile_adapter.rb

@@ -16,7 +16,13 @@ module Wordmove
       end
 
       def config
-        OpenStruct.new(database_config)
+        Struct.new(
+          :name,
+          :user,
+          :password,
+          :host,
+          keyword_init: true
+        ).new(database_config)
       end
 
       def database_config
@@ -35,10 +41,10 @@ module Wordmove
     class DefaultDBConfig
       def self.config
         {
-          name: "database_name",
-          user: "user",
-          password: "password",
-          host: "127.0.0.1"
+          name: 'database_name',
+          user: 'user',
+          password: 'password',
+          host: '127.0.0.1'
         }
       end
     end

data/lib/wordmove/guardian.rb

@@ -2,11 +2,11 @@ module Wordmove
   class Guardian
     attr_reader :movefile, :environment, :action, :logger
 
-    def initialize(options: nil, action: nil)
-      @movefile = Wordmove::Movefile.new(options[:config])
-      @environment = @movefile.environment(options).to_sym
+    def initialize(cli_options: nil, action: nil)
+      @movefile = Wordmove::Movefile.new(cli_options, nil, false)
+      @environment = @movefile.environment.to_sym
       @action = action
-      @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      @logger = Logger.new($stdout).tap { |l| l.level = Logger::DEBUG }
     end
 
     def allows(task)
@@ -27,7 +27,7 @@ module Wordmove
     end
 
     def forbidden_tasks
-      environment_options = movefile.fetch(false)[environment]
+      environment_options = movefile.options[environment]
       return {} unless environment_options.key?(:forbid)
       return {} unless environment_options[:forbid].key?(action)
 

data/lib/wordmove/hook.rb

@@ -1,14 +1,13 @@
 module Wordmove
   class Hook
     def self.logger
-      Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      Logger.new($stdout).tap { |l| l.level = Logger::DEBUG }
     end
 
     # rubocop:disable Metrics/MethodLength
-    def self.run(action, step, cli_options)
-      movefile = Wordmove::Movefile.new(cli_options[:config])
-      options = movefile.fetch(false)
-      environment = movefile.environment(cli_options)
+    def self.run(action, step, movefile:, simulate: false)
+      options = movefile.options
+      environment = movefile.environment
 
       hooks = Wordmove::Hook::Config.new(
         options[environment][:hooks],
@@ -21,17 +20,17 @@ module Wordmove
       logger.task "Running #{action}/#{step} hooks"
 
       hooks.all_commands.each do |command|
-        case command[:where]
+        case command.fetch(:where)
         when 'local'
-          Wordmove::Hook::Local.run(command, options[:local], cli_options[:simulate])
+          Wordmove::Hook::Local.run(command, options[:local], simulate)
         when 'remote'
           if options[environment][:ftp]
-            logger.debug "You have configured remote hooks to run over "\
-                         "an FTP connection, but this is not possible. Skipping."
+            logger.debug 'You have configured remote hooks to run over '\
+                         'an FTP connection, but this is not possible. Skipping.'
             next
           end
 
-          Wordmove::Hook::Remote.run(command, options[environment], cli_options[:simulate])
+          Wordmove::Hook::Remote.run(command, options[environment], simulate)
         else
           next
         end
@@ -78,10 +77,10 @@ module Wordmove
 
     class Local
       def self.logger
-        parent.logger
+        Wordmove::Hook.logger
       end
 
-      def self.run(command_hash, options, simulate = false)
+      def self.run(command_hash, options, simulate = false) # rubocop:disable Style/OptionalBooleanParameter
         wordpress_path = options[:wordpress_path]
 
         logger.task_step true, "Exec command: #{command_hash[:command]}"
@@ -91,7 +90,7 @@ module Wordmove
         logger.task_step true, "Output: #{stdout_return}"
 
         if $CHILD_STATUS.exitstatus.zero?
-          logger.success ""
+          logger.success ''
         else
           logger.error "Error code: #{$CHILD_STATUS.exitstatus}"
           raise Wordmove::LocalHookException unless command_hash[:raise].eql? false
@@ -101,10 +100,10 @@ module Wordmove
 
     class Remote
       def self.logger
-        parent.logger
+        Wordmove::Hook.logger
       end
 
-      def self.run(command_hash, options, simulate = false)
+      def self.run(command_hash, options, simulate = false) # rubocop:disable Style/OptionalBooleanParameter
         ssh_options = options[:ssh]
         wordpress_path = options[:wordpress_path]
 
@@ -118,7 +117,7 @@ module Wordmove
 
         if exit_code.zero?
           logger.task_step false, "Output: #{stdout}"
-          logger.success ""
+          logger.success ''
         else
           logger.task_step false, "Output: #{stderr}"
           logger.error "Error code #{exit_code}"

data/lib/wordmove/logger.rb

@@ -4,7 +4,8 @@ module Wordmove
 
     def initialize(device, strings_to_hide = [])
       super(device, formatter: proc { |_severity, _datetime, _progname, message|
-        formatted_message = if strings_to_hide.empty?
+        formatted_message = if strings_to_hide.empty? ||
+                               ENV.fetch('WORDMOVE_REVEAL_SECRETS', nil).present?
                               message
                             else
                               message.gsub(
@@ -20,38 +21,38 @@ module Wordmove
     end
 
     def task(title)
-      prefix = "▬" * 2
+      prefix = '▬' * 2
       title = " #{title} "
-      padding = "▬" * padding_length(title)
+      padding = '▬' * padding_length(title)
       add(INFO, prefix + title.light_white + padding)
     end
 
     def task_step(local_step, title)
       if local_step
-        add(INFO, "    local".cyan + " | ".black + title.to_s)
+        add(INFO, '    local'.cyan + ' | '.black + title.to_s)
       else
-        add(INFO, "   remote".yellow + " | ".black + title.to_s)
+        add(INFO, '   remote'.yellow + ' | '.black + title.to_s)
       end
     end
 
     def error(message)
-      add(ERROR, "    ❌  error".red + " | ".black + message.to_s)
+      add(ERROR, '    ❌  error'.red + ' | '.black + message.to_s)
     end
 
     def success(message)
-      add(INFO, "    ✅  success".green + " | ".black + message.to_s)
+      add(INFO, '    ✅  success'.green + ' | '.black + message.to_s)
     end
 
     def debug(message)
-      add(DEBUG, "    🛠  debug".magenta + " | ".black + message.to_s)
+      add(DEBUG, '    🛠  debug'.magenta + ' | '.black + message.to_s)
     end
 
     def warn(message)
-      add(WARN, "    ⚠️  warning".yellow + " | ".black + message.to_s)
+      add(WARN, '    ⚠️  warning'.yellow + ' | '.black + message.to_s)
     end
 
     def info(message)
-      add(INFO, "    ℹ️  info".yellow + " | ".black + message.to_s)
+      add(INFO, '    ℹ️  info'.yellow + ' | '.black + message.to_s)
     end
 
     def plain(message)

data/lib/wordmove/movefile.rb

@@ -1,24 +1,73 @@
 module Wordmove
   class Movefile
-    attr_reader :logger, :name, :start_dir
+    attr_reader :logger,
+                :config_file_name,
+                :start_dir,
+                :options,
+                :cli_options
+
+    def initialize(cli_options = {}, start_dir = nil, verbose = true) # rubocop:disable Style/OptionalBooleanParameter
+      @logger = Logger.new($stdout).tap { |l| l.level = Logger::DEBUG }
+      @cli_options = cli_options.deep_symbolize_keys || {}
+      @config_file_name = @cli_options.fetch(:config, nil)
+      @start_dir = start_dir || current_dir
+
+      @options = fetch(verbose)
+                 .deep_symbolize_keys!
+                 .freeze
+    end
+
+    def environment
+      available_enviroments = extract_available_envs(options)
+
+      if available_enviroments.size > 1 && cli_options[:environment].nil?
+        raise(
+          UndefinedEnvironment,
+          'You need to specify an environment with --environment parameter'
+        )
+      end
+
+      if cli_options[:environment].present? &&
+         !available_enviroments.include?(cli_options[:environment].to_sym)
+        raise UndefinedEnvironment, "No environment found for \"#{options[:environment]}\". "\
+                                    "Available Environments: #{available_enviroments.join(' ')}"
+      end
 
-    def initialize(name = nil, start_dir = current_dir)
-      @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
-      @name = name
-      @start_dir = start_dir
+      # NOTE: This is Hash#fetch, not self.fetch.
+      cli_options.fetch(:environment, available_enviroments.first).to_sym
     end
 
-    def fetch(verbose = true)
-      entries = if name.nil?
+    def secrets
+      secrets = []
+      options.each_key do |env|
+        secrets << options.dig(env, :database, :password)
+        secrets << options.dig(env, :database, :host)
+        secrets << options.dig(env, :vhost)
+        secrets << options.dig(env, :ssh, :password)
+        secrets << options.dig(env, :ssh, :host)
+        secrets << options.dig(env, :ftp, :password)
+        secrets << options.dig(env, :ftp, :host)
+        secrets << options.dig(env, :wordpress_path)
+      end
+
+      secrets.compact.delete_if(&:empty?)
+    end
+
+    private
+
+    def fetch(verbose = true) # rubocop:disable Style/OptionalBooleanParameter
+      load_dotenv
+
+      entries = if config_file_name.nil?
                   Dir["#{File.join(start_dir, '{M,m}ovefile')}{,.yml,.yaml}"]
                 else
-                  Dir["#{File.join(start_dir, name)}{,.yml,.yaml}"]
+                  Dir["#{File.join(start_dir, config_file_name)}{,.yml,.yaml}"]
                 end
 
       if entries.empty?
         if last_dir?(start_dir)
-          raise MovefileNotFound, "Could not find a valid Movefile. Searched"\
-                                  " for filename \"#{name}\" in folder \"#{start_dir}\""
+          raise MovefileNotFound, 'Could not find a valid Movefile. Searched'\
+                                  " for filename \"#{config_file_name}\" in folder \"#{start_dir}\""
         end
 
         @start_dir = upper_dir(start_dir)
@@ -30,9 +79,8 @@ module Wordmove
       YAML.safe_load(ERB.new(File.read(found)).result, [], [], true).deep_symbolize_keys!
     end
 
-    def load_dotenv(cli_options = {})
-      env = environment(cli_options)
-      env_files = Dir[File.join(start_dir, ".env{.#{env},}")]
+    def load_dotenv
+      env_files = Dir[File.join(start_dir, '.env')]
 
       found_env = env_files.first
 
@@ -42,56 +90,12 @@ module Wordmove
       Dotenv.load(found_env)
     end
 
-    def environment(cli_options = {})
-      options = fetch(false)
-      available_enviroments = extract_available_envs(options)
-      options.merge!(cli_options).deep_symbolize_keys!
-
-      if options[:environment] != 'local'
-        if available_enviroments.size > 1 && options[:environment].nil?
-          raise(
-            UndefinedEnvironment,
-            "You need to specify an environment with --environment parameter"
-          )
-        end
-
-        if options[:environment].present?
-          unless available_enviroments.include?(options[:environment].to_sym)
-            raise UndefinedEnvironment, "No environment found for \"#{options[:environment]}\". "\
-                                        "Available Environments: #{available_enviroments.join(' ')}"
-          end
-        end
-      end
-
-      (options[:environment] || available_enviroments.first).to_sym
-    end
-
-    def secrets
-      options = fetch(false)
-
-      secrets = []
-      options.each_key do |env|
-        secrets << options.dig(env, :database, :password)
-        secrets << options.dig(env, :database, :host)
-        secrets << options.dig(env, :vhost)
-        secrets << options.dig(env, :ssh, :password)
-        secrets << options.dig(env, :ssh, :host)
-        secrets << options.dig(env, :ftp, :password)
-        secrets << options.dig(env, :ftp, :host)
-        secrets << options.dig(env, :wordpress_path)
-      end
-
-      secrets.compact.delete_if(&:empty?)
-    end
-
-    private
-
     def extract_available_envs(options)
-      options.keys.map(&:to_sym) - %i[local global]
+      options.keys - %i[local global]
     end
 
     def last_dir?(directory)
-      directory == "/" || File.exist?(File.join(directory, 'wp-config.php'))
+      directory == '/' || File.exist?(File.join(directory, 'wp-config.php'))
     end
 
     def upper_dir(directory)