wordpress-deploy 1.0.0.alpha2 → 1.0.0.rc1

data/lib/wordpress_deploy/environment.rb

@@ -1,68 +1,110 @@
 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
+  class 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
+    attr_reader :name
+
+    def initialize(name, store = true, &block)
+      @name = name
+      @base_url ||= "localhost"
+      @wplang   ||= ""
+      @wpdebug  ||= false
+
+      # Get an Erb template
+      @template = ERB.new(File.read(File.join(WordpressDeploy::TEMPLATE_PATH, "wp-config.erb")))
+      @output   = Environment.output_file
+
+      instance_eval(&block) if block_given?
+
+      Environments << self if store
     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
+    ##
+    # This is the url to search the the database for.
+    def base_url(new_base = nil)
+      @base_url = new_base.to_s unless new_base.nil?
+      @base_url
     end
 
-    def self.logging?
-      @@logging ||= false
-      @@logging
+    ##
+    #
+    def database(&block)
+      @database ||= WordpressDeploy::Database::MySql.new
+      @database.instance_eval(&block) if block_given?
+      @database
     end
 
-    def self.root_dir=(new_root)
-      @@root_dir = new_root
+    ##
+    #
+    def salts(&block)
+      @salts ||= WordpressDeploy::Wordpress::Salts.new
+      @salts.instance_eval(&block) if block_given?
+      @salts
     end
 
-    def self.root_dir
-      @@root_dir ||= Dir.pwd
-      File.expand_path @@root_dir
+    ##
+    #
+    def transfer(type = nil, &block)
+      unless type.nil?
+        klass = get_class_from_scope(WordpressDeploy::Storage, type)
+        @transfer ||= klass.new
+        @transfer.instance_eval(&block) if block_given?
+      end
+      @transfer
     end
 
-    def self.config_dir=(new_config_dir)
-      @@config_dir = new_config_dir
+    ##
+    # Write the file the filesystem
+    def save_wp_config
+      # Remove the output file if is already there
+      FileUtils.rm @output if File.exists? @output
+
+      # Open the output file
+      File.open(@output, 'w') do |f|
+        # Evaluate the ERB template
+        f.write @template.result(get_binding)
+      end
     end
 
-    def self.config_dir
-      @@config_dir ||= "config"
-      File.expand_path File.join(root_dir, @@config_dir)
+    ##
+    #
+    def wplang(new_wp_lang = nil)
+      @wplang = new_wp_lang.to_s unless new_wp_lang.nil?
+      @wplang
     end
 
-    def self.wp_dir=(new_wp_dir)
-      @@wp_dir = new_wp_dir
+    ##
+    #
+    def wpdebug(new_wp_debug = nil)
+      # Only assign if argument is a boolean value
+      # http://stackoverflow.com/questions/3028243/check-if-ruby-object-is-a-boolean
+      @wpdebug = new_wp_debug if (new_wp_debug.is_a?(TrueClass) || new_wp_debug.is_a?(FalseClass))
+      @wpdebug.to_s
     end
 
-    def self.wp_dir
-      @@wp_dir ||= "site"
-      File.expand_path File.join(root_dir, @@wp_dir)
+    private
+
+    def self.output_file
+      File.expand_path(File.join(Config.wp_dir, "wp-config.php"))
     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)
+    ##
+    # Used for ERB generation
+    def get_binding
+      binding
     end
 
-    def self.clean!
-      FileUtils.rm Dir.glob(File.join(root_dir, "*.log"))
+    ##
+    # Returns the class/model specified by +name+ inside of +scope+.
+    # +scope+ should be a Class/Module.
+    # +name+ should be a Symbol representation of any namespace which exists
+    # under +scope+.
+    #
+    # Examples:
+    #   get_class_from_scope(DaavTest::Executables, :Pioneer3)
+    #     returns the class DaavTest::Executables::Pioneer3
+    def get_class_from_scope(scope, name)
+      scope.const_get(name)
     end
+
   end
 end

data/lib/wordpress_deploy/environments.rb

@@ -0,0 +1,89 @@
+
+module WordpressDeploy
+  module Environments
+
+  class << self
+
+    ##
+    # Load the environment files in the configuration directory.
+    def load
+      files = Dir[File.join(WordpressDeploy::Config.config_dir, "**/*.rb")]
+      files.each { |file| require file }
+      nil
+    end
+
+    ##
+    # Add a new environment. If the environment name is already in use
+    # it is not added.
+    #
+    # Return the number of configurations currently loaded.
+    def <<(*environments)
+      environments.flatten!
+      environments.each do |env|
+        env_name = (env.respond_to? :name) ? env.name : nil
+        envs << env unless name? env_name
+      end
+      envs.count
+    end
+
+    ##
+    # Test if the name is a valid Configuration name.
+    #
+    # Return true if it is; false otherwise.
+    def name?(name)
+      name_to_find = name.to_sym
+      !envs.index { |env| env.name === name_to_find }.nil?
+    end
+
+    ##
+    #
+    def find(name)
+      name_to_find = name.to_sym
+      index = envs.index { |env| env.name === name_to_find }
+      raise Exception,
+            "#{name} is not a valid environment" if index.nil?
+      envs[index]
+    end
+
+    ##
+    # Return an array of the available configuration symbol names.
+    def names
+      envs.map { |config| config.name }
+    end
+    alias :available_names :names
+
+    ##
+    # Respond with the named configuration if the method name is a
+    # a valid configuration that has been loaded.
+    def method_missing(method, *args, &block)
+      if name?(method.to_sym)
+        find(method.to_sym)
+      else
+        super
+      end
+    end
+
+    ##
+    # Respond to an configuration name as though it is a method.
+    def respond_to?(method)
+      return true if name?(method.to_sym)
+      super
+    end
+
+    private
+
+    ##
+    # Create a private instance variable @configurations
+    # if one has not already been defined.
+    #
+    # Return the @configurations variable.
+    def envs
+      @envs ||= []
+      @envs
+    end
+
+  end
+
+  end
+
+end

data/lib/wordpress_deploy/logger.rb

@@ -67,7 +67,7 @@ module WordpressDeploy
       end
 
       def truncate!(max_bytes = 500_000)
-        log_file = Environment.log_file
+        log_file = Config.log_file
         return unless File.exist?(log_file)
 
         if File.stat(log_file).size > max_bytes
@@ -118,8 +118,8 @@ module WordpressDeploy
       ##
       # Receives an Array of Strings to be written to the log file.
       def to_file(lines)
-        dir_name = File.dirname(Environment.log_file)
-        File.open(Environment.log_file, 'a') do |file|
+        dir_name = File.dirname(Config.log_file)
+        File.open(Config.log_file, 'a') do |file|
           lines.each {|line| file.puts line }
         end if File.writable? dir_name
         messages.push(*lines)

data/lib/wordpress_deploy/{transfer_protocols → storage}/ftp.rb

@@ -1,34 +1,62 @@
 ##
 # Only load the Net::FTP library/gem when the
-# WordpressDeploy::TransferProtocols::Ftp class is loaded
+# WordpressDeploy::Storage::Ftp class is loaded
 require "net/ftp"
 require "pathname"
 require "action_view"
 
 module WordpressDeploy
-  module TransferProtocols
+  module Storage
     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 }
+      def initialize(&block)
+        @host        ||= "localhost"
+        @port        ||= 21
+        @user        ||= "root"
+        @password    ||= ""
+        @destination ||= "/"
+
+        instance_eval(&block) if block_given?
+      end
 
-        self.name = config_name unless config_name.nil?
+      def host(new_host = nil)
+        unless new_host.nil?
+          match = /(?<host>.*?)(?=:|\z)(:(?<port>\d+))?/.match(new_host.to_s)
+          @host = match[:host].to_s unless match[:host].nil?
 
-        # Actually open the connection
-        connect
+          # 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
+
+      def port
+        @port
       end
 
-      def configuration=(new_config)
-        @configuration = new_config if new_config.instance_of? WordpressDeploy::Wordpress::Configuration
+      def user(new_user = nil)
+        @user = new_user.to_s unless new_user.nil?
+        @user
+      end
+
+      def password(new_pass = nil)
+        @password = new_pass.to_s unless new_pass.nil?
+        @password
+      end
+
+      def destination(new_dest = nil)
+        @destination = new_dest.to_s unless new_dest.nil?
+        @destination
       end
 
       ##
@@ -49,10 +77,13 @@ module WordpressDeploy
       ##
       #
       def transmit!
-        files = Dir.glob(File.join(Environment.wp_dir, "**/*")).sort
+        connect
+        files = Dir.glob(File.join(Config.wp_dir, "**/*")).sort
         files.each do |file|
           put_file file
         end
+      ensure
+        close
       end
 
       def receive
@@ -82,7 +113,7 @@ module WordpressDeploy
         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
+          local_file = Pathname.new(File.join(Config.wp_dir, rel_remote_path, File.basename(file))).cleanpath.to_s
           if directory? file
             Logger.debug "[mkdir] #{local_file}"
             FileUtils.mkdir_p local_file
@@ -99,101 +130,6 @@ module WordpressDeploy
 
       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
@@ -205,22 +141,22 @@ module WordpressDeploy
       # Establish a connection to the remote server
       def connect
         ftp.connect(host, port)
-        ftp.login(username, password)
+        ftp.login(user, password)
         ftp.passive = true
         # ftp.debug_mode = true
-        #chdir(remote_path)
+        #chdir(destination)
       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)
+        relative = pn.relative_path_from Pathname.new(Config.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
+          remote_directory = Pathname.new("#{destination}/#{local_directory}").cleanpath.to_s
 
           begin
             # Make sure to be in the right directory