Class: PDK::Config

Inherits:
Object
  • Object
show all
Defined in:
lib/pdk/config.rb,
lib/pdk/config/json.rb,
lib/pdk/config/yaml.rb,
lib/pdk/config/errors.rb,
lib/pdk/config/setting.rb,
lib/pdk/config/ini_file.rb,
lib/pdk/config/namespace.rb,
lib/pdk/config/validator.rb,
lib/pdk/config/ini_file_setting.rb,
lib/pdk/config/json_with_schema.rb,
lib/pdk/config/yaml_with_schema.rb,
lib/pdk/config/json_schema_setting.rb,
lib/pdk/config/json_schema_namespace.rb

Defined Under Namespace

Modules: Validator Classes: IniFile, IniFileSetting, JSON, JSONSchemaNamespace, JSONSchemaSetting, JSONWithSchema, LoadError, Namespace, Setting, YAML, YAMLWithSchema

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = nil) ⇒ Config

Create a new instance of the PDK Configuration

Parameters:

  • options (Hash[String => Object]) (defaults to: nil) —

    Optional hash to override configuration options

Options Hash (options):

  • 'system.path' (String) —

    Path to the system PDK configuration file

  • 'system.module_defaults.path' (String) —

    Path to the system module answers PDK configuration file

  • 'user.path' (String) —

    Path to the user PDK configuration file

  • 'user.module_defaults.path' (String) —

    Path to the user module answers PDK configuration file

  • 'context' (PDK::Context::AbstractContext) —

    The context that the configuration should be created in



23
24
25
26
27
28
29
30
31
32
 
# File 'lib/pdk/config.rb', line 23

def initialize(options = nil)
  options = {} if options.nil?
  @config_options = {
    'system.path' => PDK::Config.system_config_path,
    'system.module_defaults.path' => PDK::Config.system_answers_path,
    'user.path' => PDK::Config.user_config_path,
    'user.module_defaults.path' => PDK::AnswerFile.default_answer_file_path,
    'context' => PDK.context
  }.merge(options)
end

Class Method Details

.json_schema(name) ⇒ Object

return nil if not exist



188
189
190
 
# File 'lib/pdk/config.rb', line 188

def self.json_schema(name)
  File.join(json_schemas_path, "#{name}_schema.json")
end

.json_schemas_path ⇒ Object 



183
184
185
 
# File 'lib/pdk/config.rb', line 183

def self.json_schemas_path
  File.join(__dir__, 'config')
end

.system_answers_path ⇒ Object 



179
180
181
 
# File 'lib/pdk/config.rb', line 179

def self.system_answers_path
  File.join(PDK::Util.system_configdir, 'answers.json')
end

.system_config_path ⇒ Object 



175
176
177
 
# File 'lib/pdk/config.rb', line 175

def self.system_config_path
  File.join(PDK::Util.system_configdir, 'system_config.json')
end

.user_config_path ⇒ Object 



171
172
173
 
# File 'lib/pdk/config.rb', line 171

def self.user_config_path
  File.join(PDK::Util.configdir, 'user_config.json')
end

Instance Method Details

#get(root, *keys) ⇒ PDK::Config::Namespace, ...

Returns a configuration setting by name. This name can either be a String, Array or parameters e.g. These are equivalent

  • PDK.config.get(‘user.a.b.c’)

  • PDK.config.get([‘user’, ‘a’, ‘b’, ‘c’])

  • PDK.config.get(‘user’, ‘a’, ‘b’, ‘c’)

Parameters:

  • root (Array[String], String) —

    The root setting name or the entire setting name as a single string

  • keys (String) —

    The child names of the setting

Returns:

  • (PDK::Config::Namespace, Object, nil) —

    The value of the configuration setting. Returns nil if it does no exist



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/pdk/config.rb', line 98

def get(root, *keys)
  return nil if root.nil? || root.empty?

  if keys.empty?
    case root
    when Array
      name = root
    when String
      name = split_key_string(root)
    else
      return nil
    end
  else
    name = [root].concat(keys)
  end

  get_within_scopes(name[1..], [name[0]])
end

#get_within_scopes(setting_name, scopes = nil) ⇒ PDK::Config::Namespace, ...

Returns a configuration setting by name, using scope precedence rules. If no scopes are passed, then all scopes are queried using the default precedence rules

Returns:

  • (PDK::Config::Namespace, Object, nil) —

    The value of the configuration setting. Returns nil if it does no exist

Raises:

  • (ArgumentError) 


121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/pdk/config.rb', line 121

def get_within_scopes(setting_name, scopes = nil)
  raise ArgumentError, format('Expected an Array but got \'%{klass}\' for scopes', klass: scopes.class) unless scopes.nil? || scopes.is_a?(Array)
  raise ArgumentError, format('Expected an Array or String but got \'%{klass}\' for setting_name', klass: setting_name.class) unless setting_name.is_a?(Array) || setting_name.is_a?(String)

  setting_arr = setting_name.is_a?(String) ? split_key_string(setting_name) : setting_name
  all_scope_names = all_scopes.keys

  # Use only valid scope names
  scopes = scopes.nil? ? all_scope_names : scopes & all_scope_names

  scopes.each do |scope_name|
    value = traverse_object(send(all_scopes[scope_name]), *setting_arr)
    return value unless value.nil?
  end
  nil
end

#project_config ⇒ PDK::Config::Namespace

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The project level configuration settings.

Returns:



68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/pdk/config.rb', line 68

def project_config
  context = @config_options['context']
  @project ||= PDK::Config::Namespace.new('project') do
    mount :environment, PDK::ControlRepo.environment_conf_as_config(File.join(context.root_path, 'environment.conf')) if context.is_a?(PDK::Context::ControlRepo)

    mount :validate, PDK::Config::YAML.new('validate', file: File.join(context.root_path, 'pdk.yaml'), persistent_defaults: true) do
      setting 'ignore' do
        default_to { [] }
      end
    end
  end
end

#resolve(filter = nil) ⇒ Hash{String => Object}

Resolves all filtered settings from all namespaces

Parameters:

  • filter (String) (defaults to: nil) —

    Only resolve setting names which match the filter. See PDK::Config::Namespace.be_resolved? for matching rules

Returns:

  • (Hash{String => Object}) —

    All resolved settings for example => ‘johndoe’



85
86
87
88
89
 
# File 'lib/pdk/config.rb', line 85

def resolve(filter = nil)
  all_scopes.values.reverse.reduce({}) do |result, method_name|
    result.merge(send(method_name).resolve(filter))
  end
end

#set(key, value, options = {}) ⇒ Object

Sets a configuration setting by name. This name can either be a String or an Array

  • PDK.config.set(‘user.a.b.c’, …)

  • PDK.config.set([‘user’, ‘a’, ‘b’, ‘c’], …)

Parameters:

  • key (String, Array[String]) —

    The name of the configuration key to change

  • value (Object) —

    The value to set the configuration setting to

  • options (Hash) (defaults to: {}) —

    Changes the behaviour of the setting process

Options Hash (options):

  • :force (Boolean) —

    Disables any munging or array processing, and sets the value as it is. Default is false

Returns:

  • (Object) —

    The new value of the configuration setting

Raises:

  • (ArgumentError) 


157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/pdk/config.rb', line 157

def set(key, value, options = {})
  options = {
    force: false
  }.merge(options)

  names = key.is_a?(String) ? split_key_string(key) : key
  raise ArgumentError, 'Invalid configuration names' if names.nil? || !names.is_a?(Array) || names.empty?

  scope_name = names[0]
  raise ArgumentError, format("Unknown configuration root '%{name}'", name: scope_name) if all_scopes[scope_name].nil?

  deep_set_object(value, options[:force], send(all_scopes[scope_name]), *names[1..])
end

#system_config ⇒ PDK::Config::Namespace

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The system level configuration settings.

Returns:



37
38
39
40
41
42
 
# File 'lib/pdk/config.rb', line 37

def system_config
  local_options = @config_options
  @system_config ||= PDK::Config::JSON.new('system', file: local_options['system.path']) do
    mount :module_defaults, PDK::Config::JSON.new(file: local_options['system.module_defaults.path'])
  end
end

#user_config ⇒ PDK::Config::Namespace

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The user level configuration settings.

Returns:



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/pdk/config.rb', line 47

def user_config
  local_options = @config_options
  @user_config ||= PDK::Config::JSON.new('user', file: local_options['user.path']) do
    mount :module_defaults, PDK::Config::JSON.new(file: local_options['user.module_defaults.path'])

    # Display the feature flags
    mount :pdk_feature_flags, PDK::Config::Namespace.new('pdk_feature_flags') do
      setting 'available' do
        default_to { PDK.available_feature_flags }
      end

      setting 'requested' do
        default_to { PDK.requested_feature_flags }
      end
    end
  end
end

#with_scoped_value(setting_name, scopes = nil) {|PDK::Config::Namespace, Object| ... } ⇒ Object

Yields a configuration setting value by name, using scope precedence rules. If no scopes are passed, then all scopes are queried using the default precedence rules

Yields:

  • (PDK::Config::Namespace, Object) —

    The value of the configuration setting. Does not yield if the setting does not exist or is nil

Raises:

  • (ArgumentError) 


142
143
144
145
146
147
 
# File 'lib/pdk/config.rb', line 142

def with_scoped_value(setting_name, scopes = nil)
  raise ArgumentError, 'must be passed a block' unless block_given?

  value = get_within_scopes(setting_name, scopes)
  yield value unless value.nil?
end