whiskey_disk 0.6.22 → 0.6.23

data/lib/whiskey_disk/config.rb

@@ -1,196 +1,127 @@
 require 'yaml'
 require 'uri'
 require 'open-uri'
+require 'whiskey_disk/config/filter'
 
 class WhiskeyDisk
   class Config
-    class << self
-      def environment_name
-        return false unless (ENV['to'] && ENV['to'] != '')
-        return ENV['to'] unless ENV['to'] =~ /:/
-        ENV['to'].split(/:/)[1]
-      end
-
-      def specified_project_name
-        return false unless (ENV['to'] && ENV['to'] =~ /:/)
-        ENV['to'].split(/:/).first
-      end
-
-      def override_project_name!(data)
-        return if ENV['to'] && ENV['to'] =~ /:/
-        ENV['to'] = data[environment_name]['project'] + ':' + ENV['to'] if data[environment_name]['project']
-      end
-
-      def path
-        (ENV['path'] && ENV['path'] != '') ? ENV['path'] : false
-      end
-
-      def check_staleness?
-        !!(ENV['check'] && ENV['check'] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
-      end
+    def fetch
+      raise "Cannot determine current environment -- try rake ... to=staging, for example." unless environment_name
+      filter_data(load_data)
+    end
 
-      def debug?
-        !!(ENV['debug'] && ENV['debug'] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
-      end
+    def debug?
+      env_flag_is_true?('debug')
+    end
+    
+    def domain_limit
+      env_key_or_false?('only')
+    end
+    
+    def check_staleness?
+      env_flag_is_true?('check')
+    end
+    
+    def configuration_file
+      return path if valid_path?(path)
       
-      def domain_limit
-        return false unless ENV['only'] and ENV['only'] != ''
-        ENV['only']
-      end
+      files = []
 
-      def contains_rakefile?(path)
-        File.exists?(File.expand_path(File.join(path, 'Rakefile')))
-      end
-
-      def find_rakefile_from_current_path
-        original_path = Dir.pwd
-        while (!contains_rakefile?(Dir.pwd))
-          return File.join(original_path, 'config') if Dir.pwd == '/'
-          Dir.chdir('..')
-        end
-        File.join(Dir.pwd, 'config')
-      ensure
-        Dir.chdir(original_path)
-      end
-
-      def base_path
-        return path if path
-        find_rakefile_from_current_path
-      end
-
-      def valid_path?(path)
-        if path
-          uri = URI.parse(path)
-          return path if uri.scheme
-          return path if File.file?(path)
-        end
-        
-        false
-      end
-
-      def configuration_file
-        return path if valid_path?(path)
-        
-        files = []
+      files += [
+        File.join(base_path, 'deploy', specified_project_name, "#{environment_name}.yml"),  # /deploy/foo/staging.yml
+        File.join(base_path, 'deploy', "#{specified_project_name}.yml") # /deploy/foo.yml
+      ] if specified_project_name
 
-        files += [
-          File.join(base_path, 'deploy', specified_project_name, "#{environment_name}.yml"),  # /deploy/foo/staging.yml
-          File.join(base_path, 'deploy', "#{specified_project_name}.yml") # /deploy/foo.yml
-        ] if specified_project_name
+      files += [
+        File.join(base_path, 'deploy', "#{environment_name}.yml"),  # /deploy/staging.yml
+        File.join(base_path, "#{environment_name}.yml"), # /staging.yml
+        File.join(base_path, 'deploy.yml') # /deploy.yml
+      ]
 
-        files += [
-          File.join(base_path, 'deploy', "#{environment_name}.yml"),  # /deploy/staging.yml
-          File.join(base_path, "#{environment_name}.yml"), # /staging.yml
-          File.join(base_path, 'deploy.yml') # /deploy.yml
-        ]
+      files.each { |file|  return file if File.exists?(file) }
 
-        files.each { |file|  return file if File.exists?(file) }
-
-        raise "Could not locate configuration file in path [#{base_path}]"
-      end
+      raise "Could not locate configuration file in path [#{base_path}]"
+    end
 
-      def configuration_data
-        open(configuration_file) {|f| f.read }
-      end
+    def environment_name
+      return false unless env_has_key?('to')
+      return ENV['to'] unless ENV['to'] =~ /:/
+      ENV['to'].split(/:/)[1]
+    end
 
-      def project_name
-        specified_project_name || 'unnamed_project'
-      end
+    def specified_project_name
+      return false unless env_has_key?('to')
+      return false unless ENV['to'] =~ /:/
+      ENV['to'].split(/:/).first
+    end
+    
+    def contains_rakefile?(path)
+      File.exists?(File.expand_path(File.join(path, 'Rakefile')))
+    end
 
-      def repository_depth(data, depth = 0)
-        raise 'no repository found' unless data.respond_to?(:has_key?)
-        return depth if data.has_key?('repository')
-        repository_depth(data.values.first, depth + 1)
+    def find_rakefile_from_current_path
+      original_path = Dir.pwd
+      while (!contains_rakefile?(Dir.pwd))
+        return File.join(original_path, 'config') if Dir.pwd == '/'
+        Dir.chdir('..')
       end
+      File.join(Dir.pwd, 'config')
+    ensure
+      Dir.chdir(original_path)
+    end
 
-      # is this data hash a bottom-level data hash without an environment name?
-      def needs_environment_scoping?(data)
-        repository_depth(data) == 0
-      end
+    def base_path
+      path || find_rakefile_from_current_path
+    end
 
-      # is this data hash an environment data hash without a project name?
-      def needs_project_scoping?(data)
-        repository_depth(data) == 1
-      end
+    def valid_path?(path)
+      return false unless path
+      uri = URI.parse(path)
+      return path if uri.scheme
+      return path if File.file?(path)
+    end
 
-      def add_environment_scoping(data)
-        return data unless needs_environment_scoping?(data)
-        { environment_name => data }
-      end
+    def project_name
+      specified_project_name || 'unnamed_project'
+    end
 
-      def add_project_scoping(data)
-        return data unless needs_project_scoping?(data)
-        override_project_name!(data)
-        { project_name => data }
-      end
+    # called only by #load_data
+    def configuration_data
+      open(configuration_file) {|f| f.read }
+    end
 
-      def localize_domain_list(list)
-        [ list ].flatten.collect { |d| (d.nil? or d == '') ? 'local' : d }
-      end
-      
-      def compact_list(list)
-        [ list ].flatten.delete_if { |d| d.nil? or d == '' }
-      end
-      
-      def normalize_domain(data)
-        compacted = localize_domain_list(data)
-        compacted = [ 'local' ] if compacted.empty?
-        
-        compacted.collect do |d|
-          if d.respond_to?(:keys)
-            row = { :name => (d['name'] || d[:name]) }
-            roles = compact_list(d['roles'] || d[:roles])
-            row[:roles] = roles unless roles.empty?
-            row
-          else
-            { :name => d }
-          end
-        end
-      end
-      
-      def check_duplicates(project, target, domain_list)
-        seen = {}
-        domain_list.each do |domain|
-          raise "duplicate domain [#{domain[:name]}] in configuration file for project [#{project}], target [#{target}]" if seen[domain[:name]]
-          seen[domain[:name]] = true
-        end
-      end
-      
-      def normalize_domains(data)
-        data.each_pair do |project, project_data|
-          project_data.each_pair do |target, target_data|
-            target_data['domain'] = check_duplicates(project, target, normalize_domain(target_data['domain']))
-          end
-        end
-      end
+    # called only by #fetch
+    def load_data
+      YAML.load(configuration_data)
+    rescue Exception => e
+      raise %Q{Error reading configuration file [#{configuration_file}]: "#{e}"}
+    end
+    
+    def filter
+      @filter ||= WhiskeyDisk::Config::Filter.new(self)
+    end
+    
+    # called only by #fetch
+    def filter_data(data)
+      filter.filter_data(data)
+    end
 
-      def normalize_data(data)
-        normalize_domains(add_project_scoping(add_environment_scoping(data.clone)))
-      end
+  private
 
-      def load_data
-        normalize_data(YAML.load(configuration_data))
-      rescue Exception => e
-        raise %Q{Error reading configuration file [#{configuration_file}]: "#{e}"}
-      end
+    def path
+      env_key_or_false?('path')
+    end
 
-      def filter_data(data)
-        current = data[project_name][environment_name] rescue nil
-        raise "No configuration file defined data for project `#{project_name}`, environment `#{environment_name}`" unless current
-
-        current.merge!({
-          'environment' => environment_name,
-          'project' => project_name,
-        })
-        
-        current['config_target'] ||= environment_name
-        current
-      end
+    def env_has_key?(key)
+      ENV[key] && ENV[key] != ''
+    end
 
-      def fetch
-        raise "Cannot determine current environment -- try rake ... to=staging, for example." unless environment_name
-        filter_data(load_data)
-      end
+    def env_flag_is_true?(key)
+      !!(env_has_key?(key) && ENV[key] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
     end
+
+    def env_key_or_false?(key)
+      env_has_key?(key) ? ENV[key] : false
+    end  
   end
 end

data/lib/whiskey_disk/config/abstract_filter.rb

@@ -0,0 +1,19 @@
+class WhiskeyDisk
+  class Config
+    class AbstractFilter
+      attr_reader :config
+  
+      def initialize(config)
+        @config = config
+      end
+  
+      def project_name
+        config.project_name
+      end
+  
+      def environment_name
+        config.environment_name
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filter.rb

@@ -0,0 +1,48 @@
+require 'whiskey_disk/config/filters/stringify_hash_keys_filter'
+require 'whiskey_disk/config/filters/environment_scope_filter'
+require 'whiskey_disk/config/filters/project_scope_filter'
+require 'whiskey_disk/config/filters/select_project_and_environment_filter'
+require 'whiskey_disk/config/filters/add_environment_name_filter'
+require 'whiskey_disk/config/filters/add_project_name_filter'
+require 'whiskey_disk/config/filters/default_config_target_filter'
+require 'whiskey_disk/config/filters/default_domain_filter'
+require 'whiskey_disk/config/filters/hashify_domain_entries_filter'
+require 'whiskey_disk/config/filters/localize_domains_filter'
+require 'whiskey_disk/config/filters/check_for_duplicate_domains_filter'
+require 'whiskey_disk/config/filters/convert_role_strings_to_list_filter'
+require 'whiskey_disk/config/filters/drop_empty_domain_roles_filter'
+require 'whiskey_disk/config/filters/normalize_ssh_options_filter'
+
+class WhiskeyDisk
+  class Config
+    class Filter
+      attr_reader :config, :filters
+  
+      def initialize(config)
+        @config = config
+        @filters = [
+          StringifyHashKeysFilter,
+          EnvironmentScopeFilter,
+          ProjectScopeFilter,
+          SelectProjectAndEnvironmentFilter,
+          AddEnvironmentNameFilter,
+          AddProjectNameFilter,
+          DefaultConfigTargetFilter,
+          DefaultDomainFilter,
+          HashifyDomainEntriesFilter,
+          LocalizeDomainsFilter,
+          CheckForDuplicateDomainsFilter,
+          ConvertRoleStringsToListFilter,
+          DropEmptyDomainRolesFilter,
+          NormalizeSshOptionsFilter
+        ]
+      end
+  
+      def filter_data(data)
+        filters.inject(data.clone) do |result, filter|
+          result = filter.new(config).filter(result)
+        end
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/add_environment_name_filter.rb

@@ -0,0 +1,11 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class AddEnvironmentNameFilter < AbstractFilter
+      def filter(data)
+        data.merge( { 'environment' => environment_name } )
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/add_project_name_filter.rb

@@ -0,0 +1,11 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class AddProjectNameFilter < AbstractFilter
+      def filter(data)
+        data.merge( { 'project' => project_name } )
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/check_for_duplicate_domains_filter.rb

@@ -0,0 +1,21 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class CheckForDuplicateDomainsFilter < AbstractFilter
+      def check_domains(domain_list)
+        seen = {}
+        domain_list.each do |domain|
+          raise "duplicate domain [#{domain['name']}] in configuration file for project [#{environment_name}], target [#{environment_name}]" if seen[domain['name']]
+          seen[domain['name']] = true
+        end
+      end
+      
+      def filter(data)
+        check_domains(data['domain'])
+        data
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/convert_role_strings_to_list_filter.rb

@@ -0,0 +1,20 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class ConvertRoleStringsToListFilter < AbstractFilter
+      def convert_roles_for_domain(domain)
+        return domain unless domain['roles']
+        domain.merge('roles' => [ domain['roles'] ].flatten)
+      end
+      
+      def convert_all_roles(domains_list)
+        domains_list.collect {|domain| convert_roles_for_domain(domain) }
+      end
+      
+      def filter(data)
+        data.merge('domain' => convert_all_roles(data['domain']))
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/default_config_target_filter.rb

@@ -0,0 +1,12 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class DefaultConfigTargetFilter < AbstractFilter
+      def filter(data)
+        return data if data['config_target']
+        data.merge( { 'config_target' => environment_name })
+      end
+    end
+  end
+end