From b8f239cd39dd4a956d4d3f699e68d5d404bf95ec Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 16 Dec 2014 13:45:54 -0800 Subject: [PATCH] Deprecate Config::isDefault and ::getDefault --- spec/config-spec.coffee | 31 ++++++++++++++++++++++++++--- src/config.coffee | 43 +++++++++++++++++++---------------------- 2 files changed, 48 insertions(+), 26 deletions(-) diff --git a/spec/config-spec.coffee b/spec/config-spec.coffee index fc50c26db..838cd6575 100644 --- a/spec/config-spec.coffee +++ b/spec/config-spec.coffee @@ -52,6 +52,7 @@ describe "Config", -> describe "when an 'excludeSources' option is specified", -> it "only retrieves values from the specified sources", -> + atom.config.set("x.y", 0) atom.config.set("x.y", 1, scopeSelector: ".foo", source: "a") atom.config.set("x.y", 2, scopeSelector: ".foo", source: "b") atom.config.set("x.y", 3, scopeSelector: ".foo", source: "c") @@ -60,7 +61,9 @@ describe "Config", -> expect(atom.config.get("x.y", excludeSources: ["a"], scope: [".foo"])).toBe 3 expect(atom.config.get("x.y", excludeSources: ["c"], scope: [".foo"])).toBe 2 expect(atom.config.get("x.y", excludeSources: ["b", "c"], scope: [".foo"])).toBe 1 - expect(atom.config.get("x.y", excludeSources: ["b", "c", "a"], scope: [".foo"])).toBe 4 + expect(atom.config.get("x.y", excludeSources: ["b", "c", "a"], scope: [".foo"])).toBe 0 + expect(atom.config.get("x.y", excludeSources: ["b", "c", "a", atom.config.getUserConfigPath()], scope: [".foo"])).toBe 4 + expect(atom.config.get("x.y", excludeSources: [atom.config.getUserConfigPath()])).toBe 4 describe ".set(keyPath, value)", -> it "allows a key path's value to be written", -> @@ -107,52 +110,74 @@ describe "Config", -> describe ".getDefault(keyPath)", -> it "returns a clone of the default value", -> atom.config.setDefaults("foo", same: 1, changes: 1) + + spyOn(Grim, 'deprecate') expect(atom.config.getDefault('foo.same')).toBe 1 expect(atom.config.getDefault('foo.changes')).toBe 1 + expect(Grim.deprecate.callCount).toBe(2) atom.config.set('foo.same', 2) atom.config.set('foo.changes', 3) + expect(atom.config.getDefault('foo.same')).toBe 1 expect(atom.config.getDefault('foo.changes')).toBe 1 + expect(Grim.deprecate.callCount).toBe(4) initialDefaultValue = [1, 2, 3] atom.config.setDefaults("foo", bar: initialDefaultValue) expect(atom.config.getDefault('foo.bar')).toEqual initialDefaultValue expect(atom.config.getDefault('foo.bar')).not.toBe initialDefaultValue + expect(Grim.deprecate.callCount).toBe(6) describe "when scoped settings are used", -> it "returns the global default when no scoped default set", -> atom.config.setDefaults("foo", bar: baz: 10) - expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 10 - it "returns the scoped default when a scoped default is set", -> + spyOn(Grim, 'deprecate') + expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 10 + expect(Grim.deprecate).toHaveBeenCalled() + + it "returns the scoped settings not including the user's config file", -> atom.config.setDefaults("foo", bar: baz: 10) atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42) + + spyOn(Grim, 'deprecate') expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 42 + expect(Grim.deprecate.callCount).toBe(1) atom.config.set('foo.bar.baz', 55, scopeSelector: '.source.coffee') expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 42 + expect(Grim.deprecate.callCount).toBe(2) describe ".isDefault(keyPath)", -> it "returns true when the value of the key path is its default value", -> atom.config.setDefaults("foo", same: 1, changes: 1) + + spyOn(Grim, 'deprecate') expect(atom.config.isDefault('foo.same')).toBe true expect(atom.config.isDefault('foo.changes')).toBe true + expect(Grim.deprecate.callCount).toBe(2) atom.config.set('foo.same', 2) atom.config.set('foo.changes', 3) + expect(atom.config.isDefault('foo.same')).toBe false expect(atom.config.isDefault('foo.changes')).toBe false + expect(Grim.deprecate.callCount).toBe(4) describe "when scoped settings are used", -> it "returns false when a scoped setting was set by the user", -> + spyOn(Grim, 'deprecate') expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe true + expect(Grim.deprecate.callCount).toBe(1) atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42) expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe true + expect(Grim.deprecate.callCount).toBe(2) atom.config.set('foo.bar.baz', 55, scopeSelector: '.source.coffee') expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe false + expect(Grim.deprecate.callCount).toBe(3) describe ".setDefaults(keyPath)", -> it "sets a default when the setting's key contains an escaped dot", -> diff --git a/src/config.coffee b/src/config.coffee index a6a283d38..b2468a412 100644 --- a/src/config.coffee +++ b/src/config.coffee @@ -614,7 +614,7 @@ class Config @unset(scopeSelector, keyPath) @get(keyPath) - # Extended: Get the global default value of the key path. _Please note_ that in most + # Deprecated: Get the global default value of the key path. _Please note_ that in most # cases calling this is not necessary! {::get} returns the default value when # a custom value is not specified. # @@ -622,35 +622,30 @@ class Config # * `keyPath` The {String} name of the key. # # Returns the default value. - getDefault: (scopeSelector, keyPath) -> - if arguments.length == 1 - keyPath = scopeSelector - scopeSelector = null - - if scopeSelector? - defaultValue = @scopedSettingsStore.getPropertyValue(scopeSelector, keyPath, excludeSources: [@getUserConfigPath()]) - defaultValue ?= _.valueForKeyPath(@defaultSettings, keyPath) + getDefault: -> + Grim.deprecate("Use the `excludeSources` to ::get instead") + if arguments.length is 1 + [keyPath] = arguments else - defaultValue = _.valueForKeyPath(@defaultSettings, keyPath) - _.deepClone(defaultValue) + [scopeSelector, keyPath] = arguments + scope = [scopeSelector] + @get(keyPath, {scope, excludeSources: [@getUserConfigPath()]}) - # Extended: Is the value at `keyPath` its default value? + # Deprecated: Is the value at `keyPath` its default value? # # * `scopeSelector` (optional) {String}. eg. '.source.ruby' # * `keyPath` The {String} name of the key. # # Returns a {Boolean}, `true` if the current value is the default, `false` # otherwise. - isDefault: (scopeSelector, keyPath) -> - if arguments.length == 1 - keyPath = scopeSelector - scopeSelector = null - - if scopeSelector? - settings = @scopedSettingsStore.propertiesForSourceAndSelector(@getUserConfigPath(), scopeSelector) - not _.valueForKeyPath(settings, keyPath)? + isDefault: -> + Grim.deprecate("Use the `excludeSources` to ::get instead") + if arguments.length is 1 + [keyPath] = arguments else - not _.valueForKeyPath(@settings, keyPath)? + [scopeSelector, keyPath] = arguments + scope = [scopeSelector] + @get(keyPath, {scope}) is @get(keyPath, {scope, excludeSources: [@getUserConfigPath()]}) # Extended: Retrieve the schema for a specific key path. The schema will tell # you what type the keyPath expects, and other metadata about the config @@ -849,8 +844,10 @@ class Config console.warn("'#{keyPath}' could not be set. Attempted value: #{JSON.stringify(value)}; Schema: #{JSON.stringify(@getSchema(keyPath))}") getRawValue: (keyPath, options) -> - value = _.valueForKeyPath(@settings, keyPath) - defaultValue = _.valueForKeyPath(@defaultSettings, keyPath) unless options?.sources?.length > 0 + unless options?.excludeSources?.indexOf(@getUserConfigPath()) >= 0 + value = _.valueForKeyPath(@settings, keyPath) + unless options?.sources?.length > 0 + defaultValue = _.valueForKeyPath(@defaultSettings, keyPath) if value? value = _.deepClone(value)