wordpress-deploy 1.0.0.alpha1 → 1.0.0.alpha2

data/lib/wordpress_deploy/logger.rb

@@ -1,40 +1,46 @@
 # encoding: utf-8
+require 'colorize'
 
 module WordpressDeploy
   module Logger
     class << self
 
-      attr_accessor :quiet
+      attr_accessor :verbose
 
-      ##
-      # Outputs a messages to the console and writes it to the backup.log
-      def message(string)
-        to_console  loggify(string, :message, :green)
-        to_file     loggify(string, :message)
+      # Outputs the data as if it were a regular 'puts' command,
+      # but also logs it to the backup.log
+      def normal(string, color = nil)
+        string = string.colorize(color) unless color.nil?
+        to_console  loggify(string)
+        to_file     loggify(string)
       end
 
       ##
-      # Outputs an error to the console and writes it to the backup.log
-      # Called when an Exception has caused the backup process to abort.
-      def error(string)
-        to_console  loggify(string, :error,   :red), true
-        to_file     loggify(string, :error)
+      # Outputs a debug message to the console and writes it to the
+      # backup.log
+      def debug(string, color = nil)
+        string = string.colorize(color) unless color.nil?
+        to_console  loggify(string, :debug, :blue) if verbose
+        to_file     loggify(string, :debug)
       end
 
       ##
       # Outputs a notice to the console and writes it to the backup.log
       # Sets #has_warnings? true so :on_warning notifications will be sent
-      def warn(string)
+      def warn(string, color = nil)
         @has_warnings = true
+        string = string.colorize(color) unless color.nil?
         to_console  loggify(string, :warning, :yellow), true
         to_file     loggify(string, :warning)
       end
 
-      # Outputs the data as if it were a regular 'puts' command,
-      # but also logs it to the backup.log
-      def normal(string)
-        to_console  loggify(string)
-        to_file     loggify(string)
+      ##
+      # Outputs an error to the console and writes it to the backup.log
+      # Called when an Exception has caused the backup process to abort.
+      def error(string, color = nil)
+        string = string.colorize(color) unless color.nil?
+        to_console  loggify(string, :error,   :red), true
+        to_file     loggify(string, :error)
       end
 
       ##
@@ -61,7 +67,7 @@ module WordpressDeploy
       end
 
       def truncate!(max_bytes = 500_000)
-        log_file = File.join(Config.log_path, 'backup.log')
+        log_file = Environment.log_file
         return unless File.exist?(log_file)
 
         if File.stat(log_file).size > max_bytes
@@ -95,7 +101,7 @@ module WordpressDeploy
       def loggify(string, type = false, color = false)
         lines = string.to_s.split("\n")
         if type
-          type = send(color, type) if color
+          type = type.to_s.colorize(color) if color
           time_now = time
           lines.map {|line| "[#{time_now}][#{type}] #{line}" }
         else
@@ -106,47 +112,19 @@ module WordpressDeploy
       ##
       # Receives an Array of Strings to be written to the console.
       def to_console(lines, stderr = false)
-        return if quiet
         lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
       end
 
       ##
       # Receives an Array of Strings to be written to the log file.
       def to_file(lines)
-        File.open(File.join(Config.log_path, 'backup.log'), 'a') do |file|
+        dir_name = File.dirname(Environment.log_file)
+        File.open(Environment.log_file, 'a') do |file|
           lines.each {|line| file.puts line }
-        end
+        end if File.writable? dir_name
         messages.push(*lines)
       end
 
-      ##
-      # Invokes the #colorize method with the provided string
-      # and the color code "32" (for green)
-      def green(string)
-        colorize(string, 32)
-      end
-
-      ##
-      # Invokes the #colorize method with the provided string
-      # and the color code "33" (for yellow)
-      def yellow(string)
-        colorize(string, 33)
-      end
-
-      ##
-      # Invokes the #colorize method the with provided string
-      # and the color code "31" (for red)
-      def red(string)
-        colorize(string, 31)
-      end
-
-      ##
-      # Wraps the provided string in colorizing tags to provide
-      # easier to view output to the client
-      def colorize(string, code)
-        "\e[#{code}m#{string}\e[0m"
-      end
-
     end
   end
 end

data/lib/wordpress_deploy/transfer_protocols/ftp.rb

@@ -0,0 +1,305 @@
+##
+# Only load the Net::FTP library/gem when the
+# WordpressDeploy::TransferProtocols::Ftp class is loaded
+require "net/ftp"
+require "pathname"
+require "action_view"
+
+module WordpressDeploy
+  module TransferProtocols
+    class Ftp
+      include ActionView::Helpers::NumberHelper
+
+      attr_reader :configuration
+      attr_accessor :available_names
+      alias :names :available_names
+
+      ##
+      # Create a new instance of the Ftp object
+      def initialize(config_name = nil)
+        # Set the configuration
+        @yaml             = YAML.load_file(File.join(Environment.config_dir, "wp-config.yml"))
+        @available_names  = @yaml.map { |key, val| key }
+
+        self.name = config_name unless config_name.nil?
+
+        # Actually open the connection
+        connect
+      end
+
+      def configuration=(new_config)
+        @configuration = new_config if new_config.instance_of? WordpressDeploy::Wordpress::Configuration
+      end
+
+      ##
+      # If the connection is open, close it
+      # Returns true if the connection is closed; false otherwise
+      def close
+        unless ftp.closed?
+          ftp.close
+          return true
+        end
+        return false
+      end
+
+      def transmit
+        raise NotImplementedError
+      end
+
+      ##
+      #
+      def transmit!
+        files = Dir.glob(File.join(Environment.wp_dir, "**/*")).sort
+        files.each do |file|
+          put_file file
+        end
+      end
+
+      def receive
+        raise NotImplementedError
+      end
+
+      def receive!(path=remote_path)
+        # Where did it start from
+        pwd = ftp.pwd
+
+        # Change to the remote path
+        chdir(path)
+
+        # Get a list of all the files
+        # and directories in the current pwd
+        files = ftp.nlst ftp.pwd
+
+        # Remove the 'dot' directories
+        files.delete(".")
+        files.delete("..")
+
+        # Create a relative pathname
+        rel_remote_path = Pathname.new(ftp.pwd).relative_path_from Pathname.new(remote_path)
+
+        # Loop through each file and directory
+        # found in the current pwd
+        files.each do |file|
+
+          # Build the file name to save it to
+          local_file = Pathname.new(File.join(Environment.wp_dir, rel_remote_path, File.basename(file))).cleanpath.to_s
+          if directory? file
+            Logger.debug "[mkdir] #{local_file}"
+            FileUtils.mkdir_p local_file
+            receive! file
+          else
+            str = "[cp] #{file} (#{self.number_to_human_size(ftp.size(file), precision: 2)})"
+            ftp.getbinaryfile(file, local_file)
+            Logger.debug str
+          end
+        end
+
+        # Return from whence we came
+        chdir(pwd)
+
+      end
+
+      ##
+      # Return the configuration's name.
+      #
+      # Defaults to the first configuration name.
+      def name
+        @name ||= available_names.first
+        @name
+      end
+
+      ##
+      # Set the configuration's name.
+      #
+      # Only performs the assignment if the proposed name is
+      # an available name.
+      #
+      # Returns the Configuration's name.
+      def name=(new_name)
+        @name = new_name if name? new_name
+        @name
+      end
+
+      ##
+      # Test if the name passed in is an available configuration
+      # name.
+      def name?(name_to_check)
+        available_names.include? name_to_check
+      end
+
+      def local_path
+        Environment.wp_dir
+      end
+
+      def remote_path
+        ftp_dir = send(:FTP_DIR)
+        return "/" if ftp_dir.nil?
+        ftp_dir
+      end
+
+      def username
+        send(:FTP_USER) || ""
+      end
+
+      def password
+        send(:FTP_PASSWORD) || ""
+      end
+
+      def port
+        port = 21
+        match = /:(?<port>\d+)$/.match(send(:FTP_HOST))
+        port = match[:port].to_i unless match.nil?
+        port
+      end
+
+      ##
+      # Does FTP_HOST contain a port number?
+      def port?
+        !(send(:FTP_HOST) =~ /:(?<port>\d+)$/).nil?
+      end
+
+      ##
+      # Get just the hostname from DB_HOST. Only different from
+      # FTP_HOST if FTP_HOST has a port number in it.
+      def host
+        host = "localhost"
+        match = /(?<host>.*?)(?=:|$)/.match(send(:FTP_HOST))
+        host = match[:host].to_s unless match.nil?
+        host
+      end
+
+      FTP_CONFIGURATION_ATTRIBUTES = [:FTP_DIR, :FTP_USER, :FTP_PASSWORD,
+                                      :FTP_HOST]
+
+      ##
+      # Define the behaviours of the default parameters quickly
+      def method_missing(meth, *args, &block)
+        # Convert the method to a symbol
+        method_symbol = meth.to_sym
+
+        if FTP_CONFIGURATION_ATTRIBUTES.include? method_symbol
+          config = @yaml[name]
+          return config[meth.to_s] if config.include? meth.to_s
+        else
+          # You *must* call super if you don't handle the method, otherwise
+          # you will mess up Ruby's method lookup.
+          super
+        end
+      end
+
+      ##
+      # Define respond_to?
+      def respond_to?(method)
+        return true if FTP_CONFIGURATION_ATTRIBUTES.include? method.to_sym
+        super
+      end
+
+      private
+
+      def ftp
+        @ftp ||= Net::FTP.new
+        @ftp
+      end
+
+      ##
+      # Establish a connection to the remote server
+      def connect
+        ftp.connect(host, port)
+        ftp.login(username, password)
+        ftp.passive = true
+        # ftp.debug_mode = true
+        #chdir(remote_path)
+      end
+
+      ##
+      # Put file on remote machine
+      def put_file(real_path)
+        pn = Pathname.new(real_path)
+        relative = pn.relative_path_from Pathname.new(Environment.wp_dir)
+
+        # Only try to send files; no directories
+        unless pn.directory?
+          local_directory, local_file_name = relative.split
+          remote_directory = Pathname.new("#{remote_path}/#{local_directory}").cleanpath.to_s
+
+          begin
+            # Make sure to be in the right directory
+            chdir remote_directory
+
+            # Now send the file (overwriting if it exists)
+            write_file(real_path, local_file_name.to_s, true)
+          rescue Net::FTPPermError; end
+        end
+      end
+
+      def write_file(local_file, remote_file_name, overwrite)
+        begin
+          str = "[cp] #{remote_file_name} (#{self.number_to_human_size(File.size(local_file), precision: 2)})"
+          ftp.putbinaryfile(local_file, remote_file_name)
+          Logger.debug str
+        rescue Net::FTPPermError => e
+          if ftp.last_response_code.to_i === 550 and overwrite
+            ftp.delete(remote_file_name)
+            ftp.putbinaryfile(real_path, remote_file_name)
+            Logger.debug "#{str} - OVERWRITING"
+          end
+        end
+      end
+
+      ##
+      # Check that directory path exists on the FTP site
+      def directory?(directory)
+        pwd = ftp.pwd
+        begin
+          ftp.chdir(directory)
+          return true
+        rescue Net::FTPPermError
+          return false
+        end
+      ensure
+        ftp.chdir pwd
+      end
+
+      ##
+      # Change the current working directory
+      def chdir(directory)
+        # If the current working directory does not
+        # match the current working directory then
+        # the directory must be changed
+        if ftp.pwd != directory
+          Logger.debug "[cd] #{directory}"
+          # Make the requested directory if it does not exist
+          mkdir(directory) unless directory?(directory)
+          # Change into the requested directory
+          ftp.chdir(directory)
+        end
+      end
+
+      ##
+      # Similar to mkdir -p.
+      # It will make all the full directory path specified on the FTP site
+      def mkdir(directory)
+        pwd = ftp.pwd
+        dirs = directory.split("/")
+        dirs.each do |dir|
+          begin
+            ftp.chdir(dir)
+          rescue Net::FTPPermError => e
+            if ftp.last_response_code.to_i === 550
+              Logger.debug "[mkdir] #{File.join(ftp.pwd, dir)}"
+              ftp.mkdir(dir)
+              ftp.chdir(dir)
+            end
+          end
+        end
+      ensure
+        # Make sure to return to the directory
+        # that was currently in use before the mkdir command
+        # was issued
+        ftp.chdir(pwd)
+      end
+
+    end
+  end
+end
+

data/lib/wordpress_deploy/version.rb

@@ -1,3 +1,3 @@
 module WordpressDeploy
-  VERSION = "1.0.0.alpha1"
+  VERSION = "1.0.0.alpha2"
 end

data/lib/wordpress_deploy/wordpress/configuration.rb

@@ -0,0 +1,196 @@
+module WordpressDeploy
+  module Wordpress
+
+    class Configuration
+
+      attr_accessor :available_names
+      alias :names :available_names
+
+      def initialize(config_name=nil)
+        @template = File.join(Environment.wp_dir, "wp-config-sample.php")
+        @output   = File.join(Environment.wp_dir, "wp-config.php")
+
+        @yaml             = YAML.load_file(File.join(Environment.config_dir, "wp-config.yml"))
+        @available_names  = @yaml.map { |key, val| key }
+
+        self.name = config_name unless config_name.nil?
+      end
+
+      ##
+      # Return the configuration's name.
+      #
+      # Defaults to the first configuration name.
+      def name
+        @name ||= available_names.first
+        @name
+      end
+
+      ##
+      # Set the configuration's name.
+      #
+      # Only performs the assignment if the proposed name is
+      # an available name.
+      #
+      # Returns the Configuration's name.
+      def name=(new_name)
+        @name = new_name if name? new_name
+        @name
+      end
+
+      ##
+      # Test if the name passed in is an available configuration
+      # name.
+      def name?(name_to_check)
+        available_names.include? name_to_check
+      end
+
+      ##
+      # Returns 64 psuedo-random characters as a string
+      # Characters can be a-zA-z or !@#$%^&*()-~+=|/{}:;,.?<>[]
+      def self.salt
+        salt_array.sample(64).join("")
+      end
+
+      ##
+      # The file that contains the template for the output file
+      def template
+        @template
+      end
+
+      ##
+      # The file that will be output
+      def output
+        @output
+      end
+
+      ##
+      # Extract just the port number from the DB_HOST
+      # configuration file. Or return the default port of 3306.
+      def port
+        port = 3306
+        match = /:(?<port>\d+)$/.match(send(:DB_HOST))
+        port = match[:port].to_i unless match.nil?
+        port
+      end
+
+      ##
+      # Does DB_HOST contain a port number?
+      def port?
+        !(send(:DB_HOST) =~ /:(?<port>\d+)$/).nil?
+      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
+        host = "localhost"
+        match = /(?<host>.*?)(?=:|$)/.match(send(:DB_HOST))
+        host = match[:host].to_s unless match.nil?
+        host
+      end
+
+      ##
+      # Extract just the socket part from the DB_HOST
+      # configuration file. Or return an empty string if none.
+      def socket
+        socket = ""
+        match = /:(?<socket>\/.*)$/.match(send(:DB_HOST))
+        socket = match[:socket].to_s unless match.nil?
+        socket
+      end
+
+      ##
+      # Does DB_HOST contain a socket path?
+      def socket?
+        !(send(:DB_HOST) =~ /:(?<socket>\/.*)$/).nil?
+      end
+
+      ##
+      # Write the file the filesystem
+      def save!
+        # Remove the output file if is already there
+        FileUtils.rm @output if File.exists? @output
+
+        # Open the output file
+        output = File.open(@output, 'w')
+
+        # Start parsing the template file
+        File.open(@template, 'r') do |template|
+          template.each_line do |line|
+            match = /^define\(['"](?<parameter>\w*)['"]/.match(line)
+            unless match.nil?
+              # Get named capture group from Regular Expression
+              param = match[:parameter]
+
+              # Get the value for the specified parameter
+              value = send(param)
+
+              # Set the definition of the line
+              line = define(param, value)
+            end
+            output.puts(line)
+          end
+        end
+
+      ensure
+        # Close the output file if it is open
+        # even if an exception occurs
+        output.close if output
+      end
+
+      WP_CONFIGURATION_ATTRIBUTES = [:DB_NAME, :DB_USER, :DB_PASSWORD, :DB_HOST,
+                                     :DB_CHARSET, :DB_COLLATE, :WPLANG,
+                                     :WP_DEBUG]
+
+      WP_CONFIGURATION_SALTS      = [:AUTH_KEY, :SECURE_AUTH_KEY,
+                                     :LOGGED_IN_KEY, :NONCE_KEY, :AUTH_SALT,
+                                     :SECURE_AUTH_SALT, :LOGGED_IN_SALT,
+                                     :NONCE_SALT]
+
+      WP_CONFIGURATION_ALL        = WP_CONFIGURATION_ATTRIBUTES +
+                                    WP_CONFIGURATION_SALTS
+
+      ##
+      # Define the behaviours of the default parameters quickly
+      def method_missing(meth, *args, &block)
+        # Convert the method to a symbol
+        method_symbol = meth.to_sym
+
+        if WP_CONFIGURATION_ATTRIBUTES.include? method_symbol
+          config = @yaml[name]
+          return config[meth.to_s] if config.include? meth.to_s
+          ""
+        elsif WP_CONFIGURATION_SALTS.include? method_symbol
+          # Return salt if the method is a salting method
+          Configuration.salt
+        else
+          # You *must* call super if you don't handle the method, otherwise
+          # you will mess up Ruby's method lookup.
+          super
+        end
+      end
+
+      ##
+      # Define respond_to?
+      def respond_to?(method)
+        return true if WP_CONFIGURATION_ALL.include? method.to_sym
+        super
+      end
+
+      private
+
+      ##
+      # The Salting array
+      # Provides the array of available characters that can bet used as salt
+      def self.salt_array
+        @salt_array ||= %w{0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ! @ # $ % ^ & * ( ) - ~ + = | / { } : ; , . ? < > [ ]}
+      end
+
+      def define(key, value)
+        "define('#{key}', '#{value}');"
+      end
+
+    end
+
+  end
+end