basiszwo-reflection 0.5.1

data/lib/reflection/command/apply.rb

@@ -0,0 +1,71 @@
+module Reflection
+  module Command
+    class Apply < Reflection::Command::Base
+
+      def validate!
+        validate.existence_of config.directory
+        if config.rails_root
+          validate.existence_of config.rails_root
+          Reflection::Rails.validate_environment(config)
+        end
+      end
+
+      def run!
+        stash_directory = Directory::Stash.new(Reflection::Repository.new(config.repository), 'apply')
+        target_directory = Directory::Base.new(config.directory)
+
+        unless config.force
+          get_user_approval_for_cleaning_target(target_directory)
+          get_user_approval_for_apply_database_dump if config.rails_root
+        end
+        
+        verify_that_target_is_not_a_repository(target_directory)
+
+        Reflection.log.info "Applying '#{config.repository}' >> '#{config.directory}'.."
+
+        target_directory.clean!
+
+        if stash_directory.exists?
+          stash_directory.validate_repository
+          stash_directory.copy_git_index_to(target_directory.path)
+          repo = Repository.new_from_path(target_directory.path)
+          repo.reset!
+          repo.pull
+          stash_directory.get_git_index_from(target_directory.path)
+        else
+          stash_directory.clone_repository
+          stash_directory.move_content_to(target_directory.path)
+          # stash_directory.get_git_index_from(target_directory.path)
+        end
+
+        Reflection::Rails.apply(config, target_directory)
+        Reflection.log.info "Apply Command done."
+      end
+
+
+      private
+
+        def get_user_approval_for_cleaning_target(target_directory)          
+          puts "\nIn order to get a fresh copy of your files, "
+          puts "Reflection will have to remove all files under '#{target_directory.path}'."
+          puts "If you are sure, hit <enter> to proceed.."
+          
+          unless STDIN.getc == 10
+            puts "Aborting.."
+            exit
+          end
+        end
+
+        def get_user_approval_for_apply_database_dump
+          puts "\nCaution: You've enabled Rails database dumping/applying."
+          puts "In order to apply a fresh dump, Reflection will override your database."
+          puts "If you are sure, hit <enter> to proceed.."
+
+          unless STDIN.getc == 10
+            puts "Aborting.."
+            exit
+          end
+        end
+    end
+  end
+end

data/lib/reflection/command/base.rb

@@ -0,0 +1,28 @@
+module Reflection
+  module Command
+    class Base
+      attr_accessor :config
+      
+      def self.run!(config)
+        command = self.new(config)
+        command.validate! if command.respond_to?(:validate!)
+        command.run!
+      end
+      
+      def initialize(new_config)
+        self.config = new_config
+      end      
+      
+      def validate
+        Reflection::Validations
+      end
+      
+      def verify_that_target_is_not_a_repository(target_directory)
+        if Repository.exists?(target_directory.path)
+          Support.exit_with_error "The specified --directory is a repository. Reflection is afraid of breaking something, so it won't touch it. Pleace specify another one.."
+        end
+      end
+      
+    end
+  end
+end

data/lib/reflection/command/stash.rb

@@ -0,0 +1,64 @@
+module Reflection
+  module Command
+    class Stash < Reflection::Command::Base
+
+      def validate!
+        validate.existence_of config.directory
+        if config.rails_root
+          validate.existence_of config.rails_root
+          Reflection::Rails.validate_environment(config)
+        end
+      end
+
+      def run!
+        Reflection.log.info "Stashing '#{config.directory}'.."
+
+        stash_directory = Directory::Stash.new(Reflection::Repository.new(config.repository), 'stash')
+        target_directory = Directory::Base.new(config.directory)
+
+        verify_that_target_is_not_a_repository(target_directory)
+        
+        prepare_stash_repository(stash_directory)
+        stash_directory_into_repository(stash_directory, target_directory)
+
+        Reflection.log.info "Stash Command done."
+      end
+
+      def prepare_stash_repository(stash_directory)
+        Reflection.log.debug "Preparing stash repository.."
+
+        if stash_directory.exists?
+          stash_directory.validate_repository
+        else
+          stash_directory.clone_repository
+        end
+      end
+
+      def stash_directory_into_repository(stash_directory, target_directory)
+        move_stash_repository_git_index_to_target(stash_directory.git_index, target_directory.path)
+        Reflection::Rails.stash(config, target_directory) if config.rails_root
+        commit_and_push_files(target_directory.path, target_directory.name)
+        move_stash_repository_git_index_back(target_directory.git_index, stash_directory.path)
+        Reflection::Rails.clean_target(config, target_directory) if config.rails_root
+      end
+
+
+      private
+
+        def move_stash_repository_git_index_to_target(source, target)
+          %x(mv #{source} #{target})
+        end
+
+        def commit_and_push_files(repository_path, target)
+          repository = Repository.new_from_path(repository_path)
+          repository.commit_all_new_files
+          repository.push
+        end
+
+        def move_stash_repository_git_index_back(source, target)
+          %x(mv #{source} #{target})
+        end
+
+    end
+  end
+end

data/lib/reflection/command.rb

@@ -0,0 +1,7 @@
+module Reflection
+  module Command
+    autoload :Apply,  'reflection/command/apply'
+    autoload :Base,   'reflection/command/base'
+    autoload :Stash,  'reflection/command/stash'
+  end
+end

data/lib/reflection/config.rb

@@ -0,0 +1,139 @@
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+
+module Reflection
+
+  class ConfigArgumentError < StandardError; end
+
+  class Config
+    
+    attr_accessor :command
+    attr_accessor :directory
+    attr_accessor :repository
+    attr_accessor :rails_root
+    attr_accessor :rails_environment
+    attr_accessor :store_configuration_path
+    attr_accessor :verbose
+    attr_accessor :force
+    
+    def self.parse(args = [])
+      config = Config.new
+      case
+        when !args.empty? && File.exists?(args.first)
+          config.read!(args.first)
+        when !args.empty?
+          config.parse_command_line_options(args)
+          config.write(config.store_configuration_path) if config.store_configuration_path
+        else
+          config.read!(File.join(Dir.pwd, 'reflection.yml'))
+      end
+      config
+    end
+
+    def to_hash
+      { 
+        :command => self.command, 
+        :directory => self.directory,
+        :repository => self.repository, 
+        :rails_root => self.rails_root,
+        :rails_environment => self.rails_environment,
+        :verbose => self.verbose,
+        :force => self.force
+      }
+    end
+    
+    def from_hash(hash)
+      self.command = hash[:command]
+      self.directory = hash[:directory]
+      self.repository = hash[:repository]
+      self.rails_root = hash[:rails_root]
+      self.rails_environment = hash[:rails_environment]
+      self.verbose = Reflection.verbose = hash[:verbose]
+      self.force = hash[:force]
+    end
+
+    def write(path)
+      begin
+        io = File.open(path, 'w')
+        YAML.dump(self.to_hash, io)
+        io.close
+      rescue => e
+        Reflection::Support.exit_with_error("Writing of config file to '#{path}' failed: #{e.message}")
+      end
+    end
+
+    def read!(path)
+      begin
+        if File.exist?(path)
+          options = YAML.load_file(path)
+          raise(Reflection::ConfigArgumentError, "Config file is invalid.") unless options.is_a?(Hash)
+          self.from_hash(options)
+        end
+      rescue => e
+        Reflection::Support.exit_with_error("Parsing of config file '#{path}' failed: #{e.message}")
+      end
+    end
+
+    def parse_command_line_options(args)
+      opt_parser = OptionParser.new do |opts|
+        opts.banner =   "Usage: reflection --COMMAND --repository=GIT_REPO --directory=PATH\n"
+        opts.banner <<  " -or-\n"
+        opts.banner <<  "Usage: reflection /path/to/reflection-config-file.yml"
+        
+        opts.separator " "
+        opts.separator "On the server side:"
+
+        opts.on("-s", "--stash", "Store your assets and/or a database dump in a git-repository.") do |stash|
+          self.command = :stash
+        end
+
+        opts.separator "On the client side:"
+        opts.on("-a", "--apply", "Apply assets and/or a database dump loaded from a git-repository.") do |apply|
+          self.command = :apply
+        end
+
+        opts.separator " "
+        opts.separator "Required options for both:"
+        opts.on("-r", "--repository GIT_URL", "A Git repository(url) to be used as storage") do |repository|
+          self.repository = repository
+        end
+
+        opts.on("-d", "--directory PATH", "Path to your asset directory") do |directory|
+          self.directory = directory
+        end
+
+        opts.separator " "
+        opts.separator "Additional options for both:"
+
+        opts.on("--rails [RAILS_ROOT]", "Enable dumping/applying of a Rails managed MySQL database") do |path|
+          self.rails_root = path || nil
+        end        
+
+        opts.on("--rails-env [ENV]", "Rails environment to instrument") do |environment|
+          self.rails_environment = environment || nil
+        end        
+        
+        opts.on("--write [FILE]", "Create a configuration FILE from the current commandline options") do |config_file_path|
+          self.store_configuration_path = config_file_path if config_file_path
+        end
+
+        opts.on("--force", "Hide tedious warnings") do
+          self.force = true
+        end
+
+        opts.on("-v", "--verbose", "Include debug information in output") do
+          self.verbose = true
+          Reflection.verbose = true
+        end
+
+        opts.on("--version", "Show version") do
+          self.command = :show_version
+        end
+      end
+
+      opt_parser.parse!(args)
+    end
+
+  end
+end

data/lib/reflection/directory/base.rb

@@ -0,0 +1,58 @@
+module Reflection
+  module Directory
+    class Base
+      
+      attr_accessor :path
+      
+      def initialize(new_path)
+        self.path = new_path
+      end
+      
+      def to_s
+        self.path
+      end
+      
+      def exists?
+        File.exist?(self.path)
+      end
+      
+      def clean!
+        Reflection.log.debug "Cleaning #{self.path}/.."
+        %x(rm -r #{self.path}/*)
+      end
+      
+      def parent
+        Base.new(File.expand_path(self.path.split('/')[0..-2].join('/')))
+      end
+      
+      def name
+        self.path.split('/').last
+      end
+      
+      def git_index
+        File.expand_path(File.join(self.path, '.git'))
+      end
+      
+      def copy_git_index_to(target_path)
+        Reflection.log.debug "Copying git-index '#{self.git_index}' to #{target_path}"
+        %x(cp -R #{self.git_index} #{target_path})
+      end
+      
+      def get_git_index_from(target_path)
+        Reflection.log.debug "Getting git-index from #{target_path}"
+        
+        %x(rm -rf #{self.git_index}) if File.exists?(self.git_index)
+        %x(mkdir -p #{self.path})
+        %x(mv -f #{File.join(target_path, '/.git')} #{File.join(self.path, "/")})
+      end
+      
+      def move_content_to(target_path)
+        Reflection.log.debug "Moving content to '#{target_path}'.."
+        %x(mv #{File.join(self.path, '/*')} #{File.join(target_path, '/')})
+        # %x(cp -R #{File.join(self.path, '/.')} #{target_path})
+        # %x(rm -rf #{self.path})
+      end
+      
+    end
+  end
+end

data/lib/reflection/directory/stash.rb

@@ -0,0 +1,30 @@
+module Reflection
+  module Directory
+    class Stash < Directory::Base
+    
+      attr_accessor :repository
+    
+      def initialize(repository, identifier_prefix)
+        @repository = repository
+        @identifier_prefix = identifier_prefix
+      end
+    
+      def path
+        @path = File.join(Reflection.home.path, @identifier_prefix, repository.identifier)
+      end
+    
+      def validate_repository
+        if Reflection::Repository.exists?(self.path) && !@repository.same_in_path?(self.path)
+          Reflection::Support.exit_with_error "The stash directory '#{self.path}' is a repository, but not the one you specified (--repository)."
+        else
+          Reflection.log.debug "Directory '#{self.path}' valid."
+        end
+      end
+    
+      def clone_repository
+        Reflection.log.debug "Cloning repository '#{self.repository.url}' to '#{self.path}'"      
+        @repository.clone(self.path)
+      end
+    end
+  end
+end

data/lib/reflection/directory.rb

@@ -0,0 +1,6 @@
+module Reflection
+  module Directory
+    autoload :Base,   'reflection/directory/base'
+    autoload :Stash,  'reflection/directory/stash'
+  end
+end

data/lib/reflection/rails/database.rb

@@ -0,0 +1,96 @@
+module Reflection
+  module Rails
+    class Database
+
+      attr_accessor :configuration
+      attr_accessor :environment
+      attr_accessor :rails_root
+
+      def initialize(new_rails_root, new_environment)
+        self.rails_root = new_rails_root
+        self.environment = new_environment
+        self.configuration = read_configuration_yml
+      end
+
+      def dump_to_directory(target_directory)
+        Reflection.log.debug "dumping database.."
+        run "mysqldump #{command_line_options} --skip-lock-tables > #{dump_file_path(target_directory)}"
+      end
+
+      def load_dump_from_file(target_directory)
+        Reflection.log.debug "Loading dump.."
+        run("mysql #{command_line_options(:no_rehash => true)} < #{dump_file_path(target_directory)}")
+      end
+
+      def clean_dump_file(target_directory)
+        dump_file = dump_file_path(target_directory)
+        if File.exist?(dump_file)
+          run "rm #{dump_file}"
+        end
+      end
+
+      def recreate!
+        Reflection.log.debug "Recreating database.."
+        drop
+        create
+      end
+      
+      def create
+        run("echo \"CREATE DATABASE #{self.configuration['database']};\" | mysql #{command_line_options(:skip => :database)}")
+      end
+      
+      def drop
+        run("echo \"DROP DATABASE #{self.configuration['database']};\" | mysql #{command_line_options(:skip => :database)}")
+      end
+      
+      def migrate!
+        Reflection.log.debug "Migrating database.."
+        run("(cd #{self.rails_root} && RAILS_ENV=#{self.environment} rake db:migrate)")
+      end
+
+      def read_configuration_yml
+        begin
+          if configuration = YAML.load_file(database_config_file_path)[self.environment]
+            return configuration
+          else
+            return Support.exit_with_error("Rails database configuration for '#{self.environment}' isn't available in #{database_config_file_path}")
+          end
+        rescue => e
+          return Support.exit_with_error("Error while parsing Rails database configuration: #{e}")
+        end
+      end
+
+      def command_line_options(opts = {})
+        options = []
+        options <<  "-A" if opts[:no_rehash] && opts[:no_rehash] == true
+        options <<  "-h #{configuration['host']}" if configuration['host'] && !configuration['host'].empty?
+        options <<  "-u#{configuration['username']}"
+        options <<  "-p#{configuration['password']}" if configuration['password'] && !configuration['password'].empty?
+        options <<  "#{configuration['database']}" unless opts[:skip] && opts[:skip] == :database
+        options.join(' ')
+      end
+
+      def run(command)
+        # Reflection.log.debug "-- #{command}"
+        %x(#{command})
+      end
+      
+
+      private
+
+        def log_error_and_return_false(message)
+          Reflection.log.error(message)
+          return false
+        end
+
+        def database_config_file_path
+          @database_config_file_path ||= File.join(self.rails_root, "config/database.yml")
+        end
+        
+        def dump_file_path(directory)
+          File.join(directory, "_rails_database_dump.sql")
+        end
+        
+    end
+  end
+end

data/lib/reflection/rails.rb

@@ -0,0 +1,40 @@
+module Reflection
+  module Rails
+    
+    autoload :Database, 'reflection/rails/database'
+    
+    class << self
+      
+      def validate_environment(config)
+        env_file_path = File.join(config.rails_root, 'config/environments', "#{config.rails_environment}.rb")
+        unless File.exist?(env_file_path)
+          Reflection::Support.exit_with_error("Rails environment '#{config.rails_environment}' doesn't exist in #{env_file_path}.")
+        end
+      end
+      
+      # TODO: 
+      # Method is obsolete and has moved to Rails::Database
+      # Cannot be removed atm because Command::Stash depends on it
+      def clean_target(config, target_directory)
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.clean_dump_file(target_directory.path)
+      end
+      
+      def stash(config, target_directory)
+        Reflection.log.debug "Stashing database dump.."
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.dump_to_directory(target_directory.path)
+      end
+    
+      def apply(config, target_directory)
+        Reflection.log.debug "Applying database dump.."        
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.recreate!
+        database.load_dump_from_file(target_directory.path)
+        database.clean_dump_file(target_directory.path)
+        database.migrate!
+      end
+      
+    end
+  end
+end

data/lib/reflection/repository.rb

@@ -0,0 +1,71 @@
+require 'digest/md5'
+require 'git'
+
+module Reflection
+  class Repository
+    
+    attr_accessor :url
+    attr_accessor :path
+    
+    def self.new_from_path(path)
+      unless self.exists?(path)
+        raise "'#{path}' is not a valid Git repository"
+      end
+      
+      repo = Git.open(path)
+      self.new(repo.remote.url, path)
+    end
+    
+    def self.exists?(path)
+      begin
+        Git.open(path)
+      rescue ArgumentError
+        return false
+      end      
+    end
+    
+    def initialize(new_url, path = nil)
+      self.url = new_url
+      self.path = path
+    end
+    
+    def identifier
+      Digest::MD5.hexdigest(self.url)
+    end
+    
+    def same_in_path?(path)
+      git_repo = Git.open(path)
+      (git_repo.remote && git_repo.remote.url == self.url) || false
+    end
+    
+    def reset!
+      Reflection.log.debug "Resetting target to HEAD"
+      repo = Git.open(self.path)
+      repo.reset_hard
+    end
+    
+    def clone(path)
+      Git.clone(self.url, path)
+    end
+    
+    def commit_all_new_files
+      repo = Git.open(self.path)
+      Reflection.log.debug "Committing all changes.."
+      Reflection.log.debug(repo.add)
+      Reflection.log.debug(repo.commit_all("Updated stash.")) rescue true
+    end
+    
+    def push
+      # repo = Git.open(self.path)
+      Reflection.log.debug "Pushing commit.."
+      Reflection.log.debug(%x((cd #{self.path} && git push --force)))
+      # Reflection.log.debug(repo.push)
+    end
+    
+    def pull
+      Reflection.log.debug "Pulling in #{self.path}.."
+      Reflection.log.debug(%x((cd #{self.path} && git pull --rebase)))
+    end
+    
+  end
+end

data/lib/reflection/support/home.rb

@@ -0,0 +1,17 @@
+module Reflection
+  module Support
+    class Home
+      
+      def path
+        @path ||= File.expand_path(File.join(ENV['HOME'], '.reflection'))
+      end
+      
+      def create
+        unless File.exist?(self.path)
+          Dir.mkdir(self.path)
+        end
+      end
+      
+    end
+  end
+end

data/lib/reflection/support/log.rb

@@ -0,0 +1,20 @@
+module Reflection
+  module Support
+    class Log
+      
+      attr_accessor :verbose
+      
+      def debug(message)
+        puts "** #{message}" if Reflection.verbose == true && message && !message.empty?
+      end
+      
+      def info(message)
+        puts "** #{message}" if message && !message.empty?
+      end
+      
+      def error(message)
+        puts "!! #{message}" if message && !message.empty?
+      end
+    end
+  end
+end

data/lib/reflection/support.rb

@@ -0,0 +1,12 @@
+module Reflection
+  module Support
+    
+    autoload :Home, 'reflection/support/home'
+    autoload :Log,  'reflection/support/log'      
+    
+    def self.exit_with_error(message)
+      Reflection.log.error message
+      exit(1)
+    end
+  end
+end

data/lib/reflection/validations.rb

@@ -0,0 +1,23 @@
+module Reflection
+  module Validations
+    class << self
+      
+      def existence_of(path)        
+        if File.exist?(path)
+          return true
+        else
+          Reflection::Support.exit_with_error "Option validation failed: #{path} does not exist."
+        end
+      end
+      
+      # def presense_of(option)
+      #   if !option.nil? && !option.empty?
+      #     return true
+      #   else
+      #     exit_with_error "Option validation failed: "
+      #   end
+      # end
+      
+    end
+  end
+end