feature: allow to pass raw hash as defaults settings

[dsalahutdinov]

Hi!

Want to support somethings like this to allow to pass options, which will be applied after defaults for new instance of config
Usage looks like this:

Sniffer::Config.new(
  enabled: true,
  storage: {capacity: 500}
)

Will be used here in aderyabin/sniffer#35

[palkan]

Don't think we need it here.

For local development you can use Gemfile.local.

[palkan]

Let's upgrade to 0.52

[palkan]

Let's use the following signature initialize(explicit_values = {}, name: nil, load: true).

Don't we want to have explicitly provided values non-overridable by other sources (file, env)?

I mean, if I do something like config = Config.new({a: 1}) I want to make sure that the value of config.a doesn't change. Am I right?

Then we have to apply these explicit_values after everything is loaded.

Also, we should implement the same behaviour for #reload method (and we can re-use it in #initialize):

def initialize(explicit_values = {}, name: nil, reload: true)
  @config_name = config_name || self.class.config_name
  raise ArgumentError, "Config name is missing" unless @config_name
  reload(explicit_values) if reload
end

def reload(explicit_values = {})
  clear
  load(explicit_values)
  self
end

def load(explicit_values = nil)
  config = load_from_sources((self.class.defaults || {}).deep_dup)
  config.merge!(explicit_values) unless explicit_values.nil?
  config.each do #...
end

[dsalahutdinov]

Hi, Vlidimir!
Thanks for review!

this kind of signature is not good for the case, because of it makes you to pass all the arguments if you want ruby to recognize it properly:

def test(a = {}, b: 'b', c: 'c')
  puts a.inspect
  puts b
  puts c
end

test()
test({sample: 'string'}) #expect sample be the key ArgumentError: unknown keyword: sample like the next
ArgumentError: unknown keyword: sample
	from (irb):1:in `test'
	from (irb):7
	from /usr/local/rvm/rubies/ruby-2.2.7/bin/irb:11:in `<main>'

test(sample: 'string')
test({sample: 'string'}, b: 1, c: 2) #works as expected, but needs to pass other args to make ruby recognize first hash as 'a' param

So I suppose to make signature like this:

def initialize(explicit_values: {}, name: nil, load: true)
end

to allow to pass only needed arguments

[dsalahutdinov]

So in those case i would also like to change the signatures of methods load and reload to look similar:

def load(explicit_values: {})
end

def reload(explicit_values: {})
end

[palkan]

I don't think we need explicit values here, 'cause this method returns a plain Hash

Let's leave as is.

[palkan]

Looks that I've proposed a wrong solution: there gonna be a breaking change.

Let's do the following:

def initialize(config_name = nil, do_load = nil, name: nil, load: true, overrides: {})
  unless config_name.nil? && do_load.nil?
    warn "[Deprecated] Positional arguments for Anyway::Config#initialize will be removed in 1.2.0. Use keyword arguments instead: initialize(name:, load:, overrides:)"
  end

  name = config_name unless config_name.nil?
  load = do_load unless do_load.nil?

  ...
end

And let's rename explicit_values to overrides.

[palkan]

Shouldn't there be self.load?

[dsalahutdinov]

It's done

[palkan]

Thanks!

Released as 1.1.3