wordpress-deploy 1.0.0.alpha1 → 1.0.0.alpha2

data/lib/wordpress_deploy/cli/utility.rb

@@ -1,53 +1,102 @@
-# encoding: utf-8
-
 ##
 # Build the WordpressDeploy Command Line Interface using Thor
+#
 module WordpressDeploy
-  module CLI
+  module Cli
     class Utility < Thor
       include Thor::Actions
 
-      method_option :base, type: :string, aliases: ['-b']
-      method_option :env,  type: :string, required: true, default: 'production', aliases: ['-e']
+      # 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 :verbose,     type: :boolean, default: false,        aliases: '-v'
+
+
       desc "generate", "Generate the wp-config.php file. Accepted environments are production or development."
       def generate
-        unless %w{production development}.include? options[:env]
-          raise Errors::CLI::SystemCallError.wrap(e, <<-EOS)
-            Failed to execute system command on #{ RUBY_PLATFORM }
-            Command was: #{ command }
-          EOS
-        end
-
-        Config.environment = options[:env]
-        config = Config.wp_config[Config.env]
-
-        # Salt the wp-config.php file if none are provided
-        Config.salt_keys.each do |key|
-          config[key] = Config.salt_array.sample(64).join("") unless config.has_key? key
-        end
-
-        out = File.open(Config.wp_config_output, 'w')
-        File.open(Config.wp_config_sample, 'r') do |file|
-          file.each_line do |line|
-            match = /^define\(['"](?<parameter>\w*)['"]/.match(line)
-            unless match.nil?
-              param = match[:parameter]
-              if config.has_key?(param)
-                # The Wordpress Config file has the key
-                # So now set the value from the config
-                line.gsub!(/['"]((?!#{param})[\s\w\d\!\@\#\$\%\^\&\*\-\(\)]+)?['"]/, "'#{config[param]}'")
-              end
-            end
-            out.puts(line)
-          end
-        end
-      end
+        ##
+        # Set Logger into verbose mode (if the user requested it)
+        Logger.verbose = options[:verbose]
+
+        # Set environment options
+        Environment.set_options options
+
+        # Create a configuration file
+        config = Wordpress::Configuration.new
 
+        # Save the configuration file
+        config.save!
+      rescue => err
+        Logger.error Errors::Cli::Utility::Error.wrap(err)
 
-      desc "deploy", "Deploy #{Config.sites_dir} via FTP to #{Config.ftp_config['hostname']}"
+        # Exit with an error
+        exit(1)
+      end
+
+      desc "deploy", "Deploy via FTP to configuration hostname."
       def deploy
+        ##
+        # Set Logger into verbose mode (if the user requested it)
+        Logger.verbose = options[:verbose]
+
+        # Set environment options
+        Environment.set_options options
+
+        # Create a new FTP client for sending the files
+        ftp_client = TransferProtocols::Ftp.new options[:environment]
+
+        # Now transmit the files
+        ftp_client.transmit!
+
+      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
+        ##
+        # Set Logger into verbose mode (if the user requested it)
+        Logger.verbose = options[:verbose]
+
+        # Set environment options
+        Environment.set_options options
+
+        # Create a new FTP client for receiving the files
+        ftp_client = TransferProtocols::Ftp.new options[:environment]
+
+        # Now receive the files
+        ftp_client.receive!
+
+      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)
+        ##
+        # Set Logger into verbose mode (if the user requested it)
+        Logger.verbose = options[:verbose]
+
+        # Set environment options
+        Environment.set_options options
+      rescue => err
+        Logger.error Errors::Cli::Utility::Error.wrap(err)
+
+        # Exit with an error
+        exit(1)
       end
     end
   end
 end
+

data/lib/wordpress_deploy/database/mysql.rb

@@ -1,159 +1,45 @@
-# encoding: utf-8
+require 'tmpdir'
 
 module WordpressDeploy
   module Database
-    class MySQL < Base
 
-      ##
-      # Name of the database that needs to get dumped
-      # To dump all databases, set this to `:all` or leave blank.
-      attr_accessor :name
-
-      ##
-      # Credentials for the specified database
-      attr_accessor :username, :password
-
-      ##
-      # Connectivity options
-      attr_accessor :host, :port, :socket
-
-      ##
-      # Tables to skip while dumping the database
-      attr_accessor :skip_tables
-
-      ##
-      # Tables to dump, tables that aren't specified won't get dumped
-      attr_accessor :only_tables
-
-      ##
-      # Additional "mysqldump" options
-      attr_accessor :additional_options
+    class MySql
+      include WordpressDeploy::Cli::Helpers
 
-      ##
-      # Path to mysqldump utility (optional)
-      attr_accessor :mysqldump_utility
-
-      attr_deprecate :utility_path, :version => '3.0.21',
-          :replacement => :mysqldump_utility
-
-      ##
-      # Creates a new instance of the MySQL adapter object
-      def initialize(model, &block)
-        super(model)
-
-        @skip_tables        ||= Array.new
-        @only_tables        ||= Array.new
-        @additional_options ||= Array.new
-
-        instance_eval(&block) if block_given?
+      attr_reader :configuration
 
-        @name ||= :all
-        @mysqldump_utility ||= utility(:mysqldump)
+      def initialize
+        @yaml     = YAML.load_file(File.join(Environment.config_dir, "wp-config.yml"))
       end
 
-      ##
-      # Performs the mysqldump command and outputs the
-      # data to the specified path based on the 'trigger'
-      def perform!
-        super
-
-        pipeline = Pipeline.new
-        dump_ext = 'sql'
-
-        pipeline << mysqldump
-        if @model.compressor
-          @model.compressor.compress_with do |command, ext|
-            pipeline << command
-            dump_ext << ext
-          end
-        end
-        pipeline << "cat > '#{ File.join(@dump_path, dump_filename) }.#{ dump_ext }'"
-
-        pipeline.run
-        if pipeline.success?
-          Logger.message "#{ database_name } Complete!"
-        else
-          raise Errors::Database::PipelineError,
-              "#{ database_name } Dump Failed!\n" +
-              pipeline.error_messages
-        end
-      end
-
-      private
-
-      ##
-      # Builds the full mysqldump string based on all attributes
       def mysqldump
-        "#{ mysqldump_utility } #{ credential_options } #{ connectivity_options } " +
-        "#{ user_options } #{ db_name } #{ tables_to_dump } #{ tables_to_skip }"
+        "#{utility("mysqldump")} #{arguments}"
       end
 
-      ##
-      # Returns the filename to use for dumping the database(s)
-      def dump_filename
-        dump_all? ? 'all-databases' : name
-      end
-
-      ##
-      # Builds the credentials MySQL syntax to authenticate the user
-      # to perform the database dumping process
-      def credential_options
-        %w[username password].map do |option|
-          next if send(option).to_s.empty?
-          "--#{option}='#{send(option)}'".gsub('--username', '--user')
-        end.compact.join(' ')
-      end
-
-      ##
-      # Builds the MySQL connectivity options syntax to connect the user
-      # to perform the database dumping process
-      def connectivity_options
-        %w[host port socket].map do |option|
-          next if send(option).to_s.empty?
-          "--#{option}='#{send(option)}'"
-        end.compact.join(' ')
+      def configuration=(new_config)
+        @configuration = new_config if new_config.instance_of? WordpressDeploy::Wordpress::Configuration
       end
 
-      ##
-      # Builds a MySQL compatible string for the additional options
-      # specified by the user
-      def user_options
-        additional_options.join(' ')
-      end
-
-      ##
-      # Returns the database name to use in the mysqldump command.
-      # When dumping all databases, the database name is replaced
-      # with the command option to dump all databases.
-      def db_name
-        dump_all? ? '--all-databases' : name
-      end
+      private
 
-      ##
-      # Builds the MySQL syntax for specifying which tables to dump
-      # during the dumping of the database
-      def tables_to_dump
-        only_tables.join(' ') unless dump_all?
-      end
+      def arguments
+        host = configuration.host
+        port = configuration.port
+        username = configuration.DB_USER
+        password = configuration.DB_PASSWORD
+        db_name = configuration.DB_NAME
 
-      ##
-      # Builds the MySQL syntax for specifying which tables to skip
-      # during the dumping of the database
-      def tables_to_skip
-        skip_tables.map do |table|
-          table = (dump_all? || table['.']) ? table : "#{ name }.#{ table }"
-          "--ignore-table='#{ table }'"
-        end.join(' ')
+        "-P \"#{port}\" -h \"#{host}\" -u \"#{username}\" -p#{password} -B \"#{db_name}\""
       end
 
       ##
-      # Return true if we're dumping all databases.
-      # `name` will be set to :all if it is not set,
-      # so this will be true by default
-      def dump_all?
-        name == :all
+      # A temporary directory for installing the executable to
+      def tmp_dir
+        @tmp_dir ||= Dir.mktmpdir
+        File.expand_path(@tmp_dir)
       end
 
     end
   end
 end
+

data/lib/wordpress_deploy/environment.rb

@@ -0,0 +1,68 @@
+module WordpressDeploy
+  ##
+  # Environment 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 Environment
+
+    ##
+    # 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.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/errors.rb

@@ -1,7 +1,61 @@
 # encoding: utf-8
 
 module WordpressDeploy
+  ##
+  # - automatically defines module namespaces referenced under WordpressDeploy::Errors
+  # - any constant name referenced that ends with 'Error' will be created
+  #   as a subclass of WordpressDeploy::Errors::Error
+  # e.g.
+  #   err = WordpressDeploy::Errors::Foo::Bar::FooError.new('error message')
+  #   err.message => "Foo::Bar::FooError: error message"
+  #
+  module ErrorsHelper
+    def const_missing(const)
+      if const.to_s.end_with?('Error')
+        module_eval("class #{const} < WordpressDeploy::Errors::Error; end")
+      else
+        module_eval("module #{const}; extend WordpressDeploy::ErrorsHelper; end")
+      end
+      const_get(const)
+    end
+  end
+
+  ##
+  # provides cascading errors with formatted messages
+  # see the specs for details
+  #
+  # e.g.
+  # module WordpressDeploy
+  #   begin
+  #     begin
+  #       begin
+  #         raise Errors::ZoneAError, 'an error occurred in Zone A'
+  #       rescue => err
+  #         raise Errors::ZoneBError.wrap(err, <<-EOS)
+  #           an error occurred in Zone B
+  #
+  #           the following error should give a reason
+  #         EOS
+  #       end
+  #     rescue => err
+  #       raise Errors::ZoneCError.wrap(err)
+  #     end
+  #   rescue => err
+  #     puts Errors::ZoneDError.wrap(err, 'an error occurred in Zone D')
+  #   end
+  # end
+  #
+  # Outputs:
+  #   ZoneDError: an error occurred in Zone D
+  #     Reason: ZoneCError
+  #     ZoneBError: an error occurred in Zone B
+  #
+  #     the following error should give a reason
+  #     Reason: ZoneAError
+  #     an error occurred in Zone A
+  #
   module Errors
+    extend ErrorsHelper
 
     class Error < StandardError