atom · philipfweiss · Mar 12, 2018 · Feb 18, 2018 · Feb 18, 2018 · Feb 19, 2018
diff --git a/spec/config-spec.js b/spec/config-spec.js
@@ -1,7 +1,3 @@
-const path = require('path')
-const temp = require('temp').track()
-const fs = require('fs-plus')
-
 describe('Config', () => {
   let savedSettings
 
@@ -490,7 +486,6 @@ describe('Config', () => {
         atom.config.set('foo.bar.baz', 'value 2')
         expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 2', oldValue: 'value 1'})
         observeHandler.reset()
-
         observeHandler.andCallFake(() => { throw new Error('oops') })
         expect(() => atom.config.set('foo.bar.baz', 'value 1')).toThrow('oops')
         expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 1', oldValue: 'value 2'})
@@ -1840,4 +1835,86 @@ describe('Config', () => {
       expect(atom.config.get('do.ray')).toBe('me')
     })
   })
+
+  describe('project specific settings', () => {
+    describe('config.resetProjectSettings', () => {
+      it('gracefully handles invalid config objects', () => {
+        atom.config.resetProjectSettings({})
+        expect(atom.config.get('foo.bar')).toBeUndefined()
+      })
+    })
+
+    describe('config.get', () => {
+      const dummyPath = '/Users/dummy/path.json'
+      describe('project settings', () => {
+        it('returns a deep clone of the property value', () => {
+          atom.config.resetProjectSettings({'*': {'value': {array: [1, {b: 2}, 3]}}}, dummyPath)
+          const retrievedValue = atom.config.get('value')
+          retrievedValue.array[0] = 4
+          retrievedValue.array[1].b = 2.1
+          expect(atom.config.get('value')).toEqual({array: [1, {b: 2}, 3]})
+        })
+
+        it('properly gets project settings', () => {
+          atom.config.resetProjectSettings({'*': {'foo': 'wei'}}, dummyPath)
+          expect(atom.config.get('foo')).toBe('wei')
+          atom.config.resetProjectSettings({'*': {'foo': {'bar': 'baz'}}}, dummyPath)
+          expect(atom.config.get('foo.bar')).toBe('baz')
+        })
+
+        it('gets project settings with higher priority than regular settings', () => {
+          atom.config.set('foo', 'bar')
+          atom.config.resetProjectSettings({'*': {'foo': 'baz'}}, dummyPath)
+          expect(atom.config.get('foo')).toBe('baz')
+        })
+
+        it('correctly gets nested and scoped properties for project settings', () => {
+          expect(atom.config.set('foo.bar.str', 'global')).toBe(true)
+          expect(atom.config.set('foo.bar.str', 'scoped', {scopeSelector: '.source.js'})).toBe(true)
+          expect(atom.config.get('foo.bar.str')).toBe('global')
+          expect(atom.config.get('foo.bar.str', {scope: ['.source.js']})).toBe('scoped')
+        })
+
+        it('returns a deep clone of the property value', () => {
+          atom.config.set('value', {array: [1, {b: 2}, 3]})
+          const retrievedValue = atom.config.get('value')
+          retrievedValue.array[0] = 4
+          retrievedValue.array[1].b = 2.1
+          expect(atom.config.get('value')).toEqual({array: [1, {b: 2}, 3]})
+        })
+
+        it('gets scoped values correctly', () => {
+          atom.config.set('foo', 'bam', {scope: ['second']})
+          expect(atom.config.get('foo', {'scopeSelector': 'second'})).toBe('bam')
+          atom.config.resetProjectSettings({'*': {'foo': 'baz'}, 'second': {'foo': 'bar'}}, dummyPath)
+          expect(atom.config.get('foo', {'scopeSelector': 'second'})).toBe('baz')
+          atom.config.clearProjectSettings()
+          expect(atom.config.get('foo', {'scopeSelector': 'second'})).toBe('bam')
+        })
+
+        it('clears project settings correctly', () => {
+          atom.config.set('foo', 'bar')
+          expect(atom.config.get('foo')).toBe('bar')
+          atom.config.resetProjectSettings({'*': {'foo': 'baz'}, 'second': {'foo': 'bar'}}, dummyPath)
+          expect(atom.config.get('foo')).toBe('baz')
+          expect(atom.config.getSources().length).toBe(1)
+          atom.config.clearProjectSettings()
+          expect(atom.config.get('foo')).toBe('bar')
+          expect(atom.config.getSources().length).toBe(0)
+        })
+      })
+    })
+
+    describe('config.getAll', () => {
+      const dummyPath = '/Users/dummy/path.json'
+      it('gets settings in the same way .get would return them', () => {
+        atom.config.resetProjectSettings({'*': {'a': 'b'}}, dummyPath)
+        atom.config.set('a', 'f')
+        expect(atom.config.getAll('a')).toEqual([{
+          scopeSelector: '*',
+          value: 'b'
+        }])
+      })
+    })
+  })
 })
diff --git a/spec/project-spec.js b/spec/project-spec.js
@@ -274,6 +274,51 @@ describe('Project', () => {
     })
   })
 
+  describe('.replace', () => {
+    let projectSpecification, projectPath1, projectPath2
+    beforeEach(() => {
+      atom.project.replace(null)
+      projectPath1 = temp.mkdirSync('project-path1')
+      projectPath2 = temp.mkdirSync('project-path2')
+      projectSpecification = {
+        paths: [projectPath1, projectPath2],
+        originPath: 'originPath',
+        config: {
+          'baz': 'buzz'
+        }
+      }
+    })
+    it('sets a project specification', () => {
+      expect(atom.config.get('baz')).toBeUndefined()
+      atom.project.replace(projectSpecification)
+      expect(atom.project.getPaths()).toEqual([projectPath1, projectPath2])
+      expect(atom.config.get('baz')).toBe('buzz')
+    })
+
+    it('clears a project through replace with no params', () => {
+      expect(atom.config.get('baz')).toBeUndefined()
+      atom.project.replace(projectSpecification)
+      expect(atom.config.get('baz')).toBe('buzz')
+      expect(atom.project.getPaths()).toEqual([projectPath1, projectPath2])
+      atom.project.replace()
+      expect(atom.config.get('baz')).toBeUndefined()
+      expect(atom.project.getPaths()).toEqual([])
+    })
+
+    it('responds to change of project specification', () => {
+      let wasCalled = false
+      const callback = () => {
+        wasCalled = true
+      }
+      atom.project.onDidReplace(callback)
+      atom.project.replace(projectSpecification)
+      expect(wasCalled).toBe(true)
+      wasCalled = false
+      atom.project.replace()
+      expect(wasCalled).toBe(true)
+    })
+  })
+
   describe('before and after saving a buffer', () => {
     let buffer
     beforeEach(() =>

diff --git a/src/atom-environment.js b/src/atom-environment.js
@@ -50,7 +50,6 @@ let nextId = 0
 //
 // An instance of this class is always available as the `atom` global.
 class AtomEnvironment {
-
   /*
   Section: Properties
   */
@@ -210,7 +209,7 @@ class AtomEnvironment {
     this.blobStore = params.blobStore
     this.configDirPath = params.configDirPath
 
-    const {devMode, safeMode, resourcePath, userSettings} = this.getLoadSettings()
+    const {devMode, safeMode, resourcePath, userSettings, projectSpecification} = this.getLoadSettings()
 
     ConfigSchema.projectHome = {
       type: 'string',
@@ -224,6 +223,10 @@ class AtomEnvironment {
     })
     this.config.resetUserSettings(userSettings)
 
+    if (projectSpecification != null && projectSpecification.config != null) {
+      this.project.replace(projectSpecification)
+    }
+
     this.menu.initialize({resourcePath})
     this.contextMenu.initialize({resourcePath, devMode})
 
@@ -788,6 +791,7 @@ class AtomEnvironment {
       this.disposables.add(this.applicationDelegate.onDidFailToReadUserSettings(message =>
         this.notifications.addError(message)
       ))
+
       this.disposables.add(this.applicationDelegate.onDidOpenLocations(this.openLocations.bind(this)))
       this.disposables.add(this.applicationDelegate.onApplicationMenuCommand(this.dispatchApplicationMenuCommand.bind(this)))
       this.disposables.add(this.applicationDelegate.onContextMenuCommand(this.dispatchContextMenuCommand.bind(this)))

diff --git a/src/config.js b/src/config.js
@@ -422,8 +422,12 @@ class Config {
       type: 'object',
       properties: {}
     }
+
     this.defaultSettings = {}
     this.settings = {}
+    this.projectSettings = {}
+    this.projectFile = null
+
     this.scopedSettingsStore = new ScopedPropertyStore()
 
     this.settingsLoaded = false
@@ -621,10 +625,10 @@ class Config {
       legacyScopeDescriptor = this.getLegacyScopeDescriptorForNewScopeDescriptor(scopeDescriptor)
       if (legacyScopeDescriptor) {
         result.push(...Array.from(this.scopedSettingsStore.getAll(
-            legacyScopeDescriptor.getScopeChain(),
-            keyPath,
-            options
-          ) || []))
+           legacyScopeDescriptor.getScopeChain(),
+           keyPath,
+           options
+         ) || []))
       }
     } else {
       result = []
@@ -691,7 +695,7 @@ class Config {
     let source = options.source
     const shouldSave = options.save != null ? options.save : true
 
-    if (source && !scopeSelector) {
+    if (source && !scopeSelector && source !== this.projectFile) {
       throw new Error("::set with a 'source' and no 'sourceSelector' is not yet implemented!")
     }
 
@@ -708,7 +712,7 @@ class Config {
     if (scopeSelector != null) {
       this.setRawScopedValue(keyPath, value, source, scopeSelector)
     } else {
-      this.setRawValue(keyPath, value)
+      this.setRawValue(keyPath, value, {source})
     }
 
     if (source === this.mainSource && shouldSave && this.settingsLoaded) {
@@ -943,7 +947,12 @@ class Config {
   Section: Private methods managing global settings
   */
 
-  resetUserSettings (newSettings) {
+  resetUserSettings (newSettings, options = {}) {
+    this._resetSettings(newSettings, options)
+  }
+
+  _resetSettings (newSettings, options = {}) {
+    const source = options.source
     newSettings = Object.assign({}, newSettings)
     if (newSettings.global != null) {
       newSettings['*'] = newSettings.global
@@ -954,24 +963,56 @@ class Config {
       const scopedSettings = newSettings
       newSettings = newSettings['*']
       delete scopedSettings['*']
-      this.resetUserScopedSettings(scopedSettings)
+      this.resetScopedSettings(scopedSettings, {source})
     }
 
     return this.transact(() => {
-      this.settings = {}
+      this._clearUnscopedSettingsForSource(source)
       this.settingsLoaded = true
-      for (let key in newSettings) { const value = newSettings[key]; this.set(key, value, {save: false}) }
+      for (let key in newSettings) {
+        const value = newSettings[key]
+        this.set(key, value, {save: false, source})
+      }
       if (this.pendingOperations.length) {
         for (let op of this.pendingOperations) { op() }
         this.pendingOperations = []
       }
     })
   }
 
+  _clearUnscopedSettingsForSource (source) {
+    if (source === this.projectFile) {
+      this.projectSettings = {}
+    } else {
+      this.settings = {}
+    }
+  }
+
+  resetProjectSettings (newSettings, projectFile) {
+    // Sets the scope and source of all project settings to `path`.
+    newSettings = Object.assign({}, newSettings)
+    const oldProjectFile = this.projectFile
+    this.projectFile = projectFile
+    if (this.projectFile != null) {
+      this._resetSettings(newSettings, {source: this.projectFile})
+    } else {
+      this.scopedSettingsStore.removePropertiesForSource(oldProjectFile)
+      this.projectSettings = {}
+    }
+  }
+
+  clearProjectSettings () {
+    this.resetProjectSettings({}, null)
+  }
+
   getRawValue (keyPath, options = {}) {
     let value
     if (!options.excludeSources || !options.excludeSources.includes(this.mainSource)) {
       value = getValueAtKeyPath(this.settings, keyPath)
+      if (this.projectFile != null) {
+        const projectValue = getValueAtKeyPath(this.projectSettings, keyPath)
+        value = (projectValue === undefined) ? value : projectValue
+      }
     }
 
     let defaultValue
@@ -990,19 +1031,22 @@ class Config {
     }
   }
 
-  setRawValue (keyPath, value) {
+  setRawValue (keyPath, value, options = {}) {
+    const source = options.source ? options.source : undefined
+    const settingsToChange = source === this.projectFile ? 'projectSettings' : 'settings'
     const defaultValue = getValueAtKeyPath(this.defaultSettings, keyPath)
+
     if (_.isEqual(defaultValue, value)) {
       if (keyPath != null) {
-        deleteValueAtKeyPath(this.settings, keyPath)
+        deleteValueAtKeyPath(this[settingsToChange], keyPath)
       } else {
-        this.settings = null
+        this[settingsToChange] = null
       }
     } else {
       if (keyPath != null) {
-        setValueAtKeyPath(this.settings, keyPath, value)
+        setValueAtKeyPath(this[settingsToChange], keyPath, value)
       } else {
-        this.settings = value
+        this[settingsToChange] = value
       }
     }
     return this.emitChangeEvent()
@@ -1168,15 +1212,22 @@ class Config {
   */
 
   priorityForSource (source) {
-    return (source === this.mainSource) ? 1000 : 0
+    switch (source) {
+      case this.mainSource:
+        return 1000
+      case this.projectFile:
+        return 2000
+      default:
+        return 0
+    }
   }
 
   emitChangeEvent () {
     if (this.transactDepth <= 0) { return this.emitter.emit('did-change') }
   }
 
-  resetUserScopedSettings (newScopedSettings) {
-    const source = this.mainSource
+  resetScopedSettings (newScopedSettings, options = {}) {
+    const source = options.source == null ? this.mainSource : options.source
     const priority = this.priorityForSource(source)
     this.scopedSettingsStore.removePropertiesForSource(source)