github/atom
1
1
Fork 0
mirror of https://github.com/atom/atom.git synced 2026-01-24 06:18:03 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into vim-core-changes

Browse Source 
Conflicts:
	src/app/text-buffer.coffee
This commit is contained in:
Mutwin Kraus
2013-04-04 14:23:58 +02:00
parent 08783f19e4 bac2209449
commit 42119ecb29
105 changed files with 1034 additions and 3555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github
View File

@@ -1,2 +1,2 @@
[docs]
title = The Guide to Atom
title = The Guide to Atom

2
Rakefile
View File

@@ -90,7 +90,7 @@ task :clean do
end
desc "Run the specs"
task :test => ["clean", "update-cef", "clone-default-bundles", "build"] do
task :test => ["update-cef", "clone-default-bundles", "build"] do
`pkill Atom`
if path = application_path()
cmd = "#{path}/Contents/MacOS/Atom --test --resource-path=#{ATOM_SRC_PATH}"

8
atom.gyp
View File

@@ -1,6 +1,5 @@
{
'variables': {
'version': '2.0.<!(git log -1 --format="%h")',
'pkg-config': 'pkg-config',
'chromium_code': 1,
'use_aura%': 0,
@@ -25,6 +24,9 @@
'-change',
'@loader_path/../Frameworks/Sparkle.framework/Versions/A/Sparkle',
'@rpath/Sparkle.framework/Versions/A/Sparkle',
'-change',
'@executable_path/../Frameworks/Quincy.framework/Versions/A/Quincy',
'@rpath/Quincy.framework/Versions/A/Quincy',
'${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}'
],
},
@@ -43,7 +45,7 @@
},
},
'xcode_settings': {
'VERSION': "<(version)",
'VERSION': "<!(git rev-parse --short HEAD)",
'CLANG_CXX_LANGUAGE_STANDARD' : 'c++0x',
'GCC_VERSION': 'com.apple.compilers.llvm.clang.1_0',
'COMBINE_HIDPI_IMAGES': 'YES', # Removes 'Validate Project Settings' warning
@@ -138,6 +140,7 @@
'<(PRODUCT_DIR)/Atom Helper.app',
'<(PRODUCT_DIR)/Atom.framework',
'native/frameworks/Sparkle.framework',
'native/frameworks/Quincy.framework'
],
},
{
@@ -259,6 +262,7 @@
'libraries': [
'$(SDKROOT)/System/Library/Frameworks/AppKit.framework',
'native/frameworks/Sparkle.framework',
'native/frameworks/Quincy.framework',
],
},
'mac_bundle_resources': [

1
benchmark/benchmark-suite.coffee
View File

@@ -1,5 +1,4 @@
require 'benchmark-helper'
fs = require 'fs-utils'
$ = require 'jquery'
_ = require 'underscore'
TokenizedBuffer = require 'tokenized-buffer'

6
native/atom_application.mm
View File

@@ -5,6 +5,7 @@
#import "native/atom_cef_app.h"
#import <getopt.h>
#import <Sparkle/Sparkle.h>
#import <Quincy/BWQuincyManager.h>
@implementation AtomApplication
@@ -207,6 +208,11 @@
}
- (void)applicationDidFinishLaunching:(NSNotification *)notification {
BWQuincyManager *manager = [BWQuincyManager sharedQuincyManager];
[manager setCompanyName:@"GitHub"];
[manager setSubmissionURL:@"https://speakeasy.githubapp.com/submit_crash_log"];
[manager setAutoSubmitCrashReport:YES];
if (!_filesOpened && [self shouldOpenFiles]) {
NSString *path = [self.arguments objectForKey:@"path"];
NSNumber *pid = [self.arguments objectForKey:@"wait"] ? [self.arguments objectForKey:@"pid"] : nil;

3
native/atom_cef_client.cpp
View File

@@ -87,6 +87,9 @@ bool AtomCefClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
else if (name == "getVersion") {
GetVersion(messageId, browser);
}
else if (name == "crash") {
__builtin_trap();
}
else {
return false;
}

1
native/frameworks/Quincy.framework/Headers Symbolic link
View File

@@ -0,0 +1 @@
Versions/Current/Headers

1
native/frameworks/Quincy.framework/Quincy Symbolic link
View File

@@ -0,0 +1 @@
Versions/Current/Quincy

1
native/frameworks/Quincy.framework/Resources Symbolic link
View File

@@ -0,0 +1 @@
Versions/Current/Resources

169
native/frameworks/Quincy.framework/Versions/A/Headers/BWQuincyManager.h Normal file
View File

@@ -0,0 +1,169 @@
/*
* Author: Andreas Linde <mail@andreaslinde.de>
* Kent Sutherland
*
* Copyright (c) 2011 Andreas Linde & Kent Sutherland.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#import <Cocoa/Cocoa.h>
typedef enum CrashAlertType {
CrashAlertTypeSend = 0,
CrashAlertTypeFeedback = 1,
} CrashAlertType;
typedef enum CrashReportStatus {
// This app version is set to discontinued, no new crash reports accepted by the server
CrashReportStatusFailureVersionDiscontinued = -30,
// XML: Sender ersion string contains not allowed characters, only alphanumberical including space and . are allowed
CrashReportStatusFailureXMLSenderVersionNotAllowed = -21,
// XML: Version string contains not allowed characters, only alphanumberical including space and . are allowed
CrashReportStatusFailureXMLVersionNotAllowed = -20,
// SQL for adding a symoblicate todo entry in the database failed
CrashReportStatusFailureSQLAddSymbolicateTodo = -18,
// SQL for adding crash log in the database failed
CrashReportStatusFailureSQLAddCrashlog = -17,
// SQL for adding a new version in the database failed
CrashReportStatusFailureSQLAddVersion = -16,
// SQL for checking if the version is already added in the database failed
CrashReportStatusFailureSQLCheckVersionExists = -15,
// SQL for creating a new pattern for this bug and set amount of occurrances to 1 in the database failed
CrashReportStatusFailureSQLAddPattern = -14,
// SQL for checking the status of the bugfix version in the database failed
CrashReportStatusFailureSQLCheckBugfixStatus = -13,
// SQL for updating the occurances of this pattern in the database failed
CrashReportStatusFailureSQLUpdatePatternOccurances = -12,
// SQL for getting all the known bug patterns for the current app version in the database failed
CrashReportStatusFailureSQLFindKnownPatterns = -11,
// SQL for finding the bundle identifier in the database failed
CrashReportStatusFailureSQLSearchAppName = -10,
// the post request didn't contain valid data
CrashReportStatusFailureInvalidPostData = -3,
// incoming data may not be added, because e.g. bundle identifier wasn't found
CrashReportStatusFailureInvalidIncomingData = -2,
// database cannot be accessed, check hostname, username, password and database name settings in config.php
CrashReportStatusFailureDatabaseNotAvailable = -1,
CrashReportStatusUnknown = 0,
CrashReportStatusAssigned = 1,
CrashReportStatusSubmitted = 2,
CrashReportStatusAvailable = 3,
} CrashReportStatus;
@class BWQuincyUI;
@protocol BWQuincyManagerDelegate <NSObject>
@required
// Invoked once the modal sheets are gone
- (void) showMainApplicationWindow;
@optional
// Return the description the crashreport should contain, empty by default. The string will automatically be wrapped into <[DATA[ ]]>, so make sure you don't do that in your string.
-(NSString *) crashReportDescription;
// Return the userid the crashreport should contain, empty by default
-(NSString *) crashReportUserID;
// Return the contact value (e.g. email) the crashreport should contain, empty by default
-(NSString *) crashReportContact;
@end
@interface BWQuincyManager : NSObject
#if defined(MAC_OS_X_VERSION_10_6) && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6)
<NSXMLParserDelegate>
#endif
{
CrashReportStatus _serverResult;
NSInteger _statusCode;
NSMutableString *_contentOfProperty;
id<BWQuincyManagerDelegate> _delegate;
NSString *_submissionURL;
NSString *_companyName;
NSString *_appIdentifier;
BOOL _autoSubmitCrashReport;
NSString *_crashFile;
BWQuincyUI *_quincyUI;
}
- (NSString*) modelVersion;
+ (BWQuincyManager *)sharedQuincyManager;
// submission URL defines where to send the crash reports to (required)
@property (nonatomic, retain) NSString *submissionURL;
// defines the company name to be shown in the crash reporting dialog
@property (nonatomic, retain) NSString *companyName;
// delegate is required
@property (nonatomic, assign) id <BWQuincyManagerDelegate> delegate;
// if YES, the crash report will be submitted without asking the user
// if NO, the user will be asked if the crash report can be submitted (default)
@property (nonatomic, assign, getter=isAutoSubmitCrashReport) BOOL autoSubmitCrashReport;
///////////////////////////////////////////////////////////////////////////////////////////////////
// settings
// If you want to use HockeyApp instead of your own server, this is required
@property (nonatomic, retain) NSString *appIdentifier;
- (void) cancelReport;
- (void) sendReportCrash:(NSString*)crashContent
description:(NSString*)description;
- (NSString *) applicationName;
- (NSString *) applicationVersionString;
- (NSString *) applicationVersion;
@end

BIN
native/frameworks/Quincy.framework/Versions/A/Quincy Executable file
View File

Binary file not shown.

BIN
native/frameworks/Quincy.framework/Versions/A/Resources/BWQuincyMain.nib generated Normal file
View File

Binary file not shown.

34
native/frameworks/Quincy.framework/Versions/A/Resources/Info.plist Normal file
View File

@@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>BuildMachineOSBuild</key>
<string>12D78</string>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>Quincy</string>
<key>CFBundleIdentifier</key>
<string>de.buzzworks.Quincy</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>DTCompiler</key>
<string></string>
<key>DTPlatformBuild</key>
<string>4H512</string>
<key>DTPlatformVersion</key>
<string>GM</string>
<key>DTSDKBuild</key>
<string>12D75</string>
<key>DTSDKName</key>
<string>macosx10.8</string>
<key>DTXcode</key>
<string>0461</string>
<key>DTXcodeBuild</key>
<string>4H512</string>
</dict>
</plist>

1
native/frameworks/Quincy.framework/Versions/Current Symbolic link
View File

@@ -0,0 +1 @@
A

6
native/v8_extensions/native.mm
View File

@@ -24,7 +24,7 @@ namespace v8_extensions {
const char* methodNames[] = {
"writeToPasteboard", "readFromPasteboard", "quit", "watchPath",
"unwatchPath", "getWatchedPaths", "unwatchAllPaths", "moveToTrash",
"reload", "setWindowState", "getWindowState", "beep"
"reload", "setWindowState", "getWindowState", "beep", "crash"
};
CefRefPtr<CefV8Value> nativeObject = CefV8Value::CreateObject(NULL);
@@ -166,6 +166,10 @@ namespace v8_extensions {
NSBeep();
}
else if (name == "crash") {
__builtin_trap();
}
return false;
}
};

1
package.json
View File

@@ -13,6 +13,7 @@
"coffee-cache": "0.1.0",
"pegjs": "0.7.0",
"async": "0.2.6",
"nak": "git://github.com/kevinsawicki/nak.git",
"spellchecker": "0.2.0",
"plist": "git://github.com/nathansobo/node-plist.git",
"space-pen": "git://github.com/nathansobo/space-pen.git"

2
script/cibuild
View File

@@ -2,4 +2,4 @@
set -ex
rm -rf ~/.atom
CI_BUILD=true rake test
CI_BUILD=true rake clean test

22
spec/app/atom-spec.coffee
View File

@@ -1,7 +1,7 @@
$ = require 'jquery'
RootView = require 'root-view'
{$$} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "the `atom` global", ->
beforeEach ->
@@ -129,9 +129,9 @@ describe "the `atom` global", ->
describe "stylesheet loading", ->
describe "when the metadata contains a 'stylesheets' manifest", ->
it "loads stylesheets from the stylesheets directory as specified by the manifest", ->
one = fs.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/1.css")
two = fs.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/2.less")
three = fs.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/3.css")
one = fsUtils.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/1.css")
two = fsUtils.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/2.less")
three = fsUtils.resolveOnLoadPath("package-with-stylesheets-manifest/stylesheets/3.css")
expect(stylesheetElementForId(one)).not.toExist()
expect(stylesheetElementForId(two)).not.toExist()
expect(stylesheetElementForId(three)).not.toExist()
@@ -145,9 +145,9 @@ describe "the `atom` global", ->
describe "when the metadata does not contain a 'stylesheets' manifest", ->
it "loads all stylesheets from the stylesheets directory", ->
one = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/1.css")
two = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/2.less")
three = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/3.css")
one = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/1.css")
two = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/2.less")
three = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/3.css")
expect(stylesheetElementForId(one)).not.toExist()
expect(stylesheetElementForId(two)).not.toExist()
expect(stylesheetElementForId(three)).not.toExist()
@@ -215,9 +215,9 @@ describe "the `atom` global", ->
it "removes the package's stylesheets", ->
atom.activatePackage('package-with-stylesheets')
atom.deactivatePackage('package-with-stylesheets')
one = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/1.css")
two = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/2.less")
three = fs.resolveOnLoadPath("package-with-stylesheets/stylesheets/3.css")
one = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/1.css")
two = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/2.less")
three = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/3.css")
expect(stylesheetElementForId(one)).not.toExist()
expect(stylesheetElementForId(two)).not.toExist()
expect(stylesheetElementForId(three)).not.toExist()
@@ -249,7 +249,7 @@ describe "the `atom` global", ->
versionHandler.callCount > 0
runs ->
expect(versionHandler.argsForCall[0][0]).toMatch /^\d+\.\d+\.\w+$/
expect(versionHandler.argsForCall[0][0]).toBeDefined()
describe "modal native dialogs", ->
beforeEach ->

50
spec/app/config-spec.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "Config", ->
describe ".get(keyPath) and .set(keyPath, value)", ->
@@ -19,38 +19,38 @@ describe "Config", ->
describe ".save()", ->
beforeEach ->
spyOn(fs, 'write')
spyOn(fsUtils, 'write')
jasmine.unspy config, 'save'
describe "when ~/.atom/config.json exists", ->
it "writes any non-default properties to ~/.atom/config.json", ->
config.configFilePath = fs.join(config.configDirPath, "config.json")
config.configFilePath = fsUtils.join(config.configDirPath, "config.json")
config.set("a.b.c", 1)
config.set("a.b.d", 2)
config.set("x.y.z", 3)
config.setDefaults("a.b", e: 4, f: 5)
fs.write.reset()
fsUtils.write.reset()
config.save()
expect(fs.write.argsForCall[0][0]).toBe(fs.join(config.configDirPath, "config.json"))
writtenConfig = JSON.parse(fs.write.argsForCall[0][1])
expect(fsUtils.write.argsForCall[0][0]).toBe(fsUtils.join(config.configDirPath, "config.json"))
writtenConfig = JSON.parse(fsUtils.write.argsForCall[0][1])
expect(writtenConfig).toEqual config.settings
describe "when ~/.atom/config.json doesn't exist", ->
it "writes any non-default properties to ~/.atom/config.cson", ->
config.configFilePath = fs.join(config.configDirPath, "config.cson")
config.configFilePath = fsUtils.join(config.configDirPath, "config.cson")
config.set("a.b.c", 1)
config.set("a.b.d", 2)
config.set("x.y.z", 3)
config.setDefaults("a.b", e: 4, f: 5)
fs.write.reset()
fsUtils.write.reset()
config.save()
expect(fs.write.argsForCall[0][0]).toBe(fs.join(config.configDirPath, "config.cson"))
expect(fsUtils.write.argsForCall[0][0]).toBe(fsUtils.join(config.configDirPath, "config.cson"))
CoffeeScript = require 'coffee-script'
writtenConfig = CoffeeScript.eval(fs.write.argsForCall[0][1], bare: true)
writtenConfig = CoffeeScript.eval(fsUtils.write.argsForCall[0][1], bare: true)
expect(writtenConfig).toEqual config.settings
describe ".setDefaults(keyPath, defaults)", ->
@@ -113,40 +113,40 @@ describe "Config", ->
describe "initializeConfigDirectory()", ->
beforeEach ->
config.configDirPath = '/tmp/dot-atom-dir'
expect(fs.exists(config.configDirPath)).toBeFalsy()
expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
afterEach ->
fs.remove('/tmp/dot-atom-dir') if fs.exists('/tmp/dot-atom-dir')
fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
describe "when the configDirPath doesn't exist", ->
it "copies the contents of dot-atom to ~/.atom", ->
config.initializeConfigDirectory()
expect(fs.exists(config.configDirPath)).toBeTruthy()
expect(fs.exists(fs.join(config.configDirPath, 'packages'))).toBeTruthy()
expect(fs.exists(fs.join(config.configDirPath, 'snippets'))).toBeTruthy()
expect(fs.exists(fs.join(config.configDirPath, 'themes'))).toBeTruthy()
expect(fs.isFile(fs.join(config.configDirPath, 'config.cson'))).toBeTruthy()
expect(fsUtils.exists(config.configDirPath)).toBeTruthy()
expect(fsUtils.exists(fsUtils.join(config.configDirPath, 'packages'))).toBeTruthy()
expect(fsUtils.exists(fsUtils.join(config.configDirPath, 'snippets'))).toBeTruthy()
expect(fsUtils.exists(fsUtils.join(config.configDirPath, 'themes'))).toBeTruthy()
expect(fsUtils.isFile(fsUtils.join(config.configDirPath, 'config.cson'))).toBeTruthy()
it "copies the bundles themes to ~/.atom", ->
config.initializeConfigDirectory()
expect(fs.isFile(fs.join(config.configDirPath, 'themes/atom-dark-ui/package.cson'))).toBeTruthy()
expect(fs.isFile(fs.join(config.configDirPath, 'themes/atom-light-ui/package.cson'))).toBeTruthy()
expect(fs.isFile(fs.join(config.configDirPath, 'themes/atom-dark-syntax.css'))).toBeTruthy()
expect(fs.isFile(fs.join(config.configDirPath, 'themes/atom-light-syntax.css'))).toBeTruthy()
expect(fsUtils.isFile(fsUtils.join(config.configDirPath, 'themes/atom-dark-ui/package.cson'))).toBeTruthy()
expect(fsUtils.isFile(fsUtils.join(config.configDirPath, 'themes/atom-light-ui/package.cson'))).toBeTruthy()
expect(fsUtils.isFile(fsUtils.join(config.configDirPath, 'themes/atom-dark-syntax.css'))).toBeTruthy()
expect(fsUtils.isFile(fsUtils.join(config.configDirPath, 'themes/atom-light-syntax.css'))).toBeTruthy()
describe "when the config file is not parseable", ->
beforeEach ->
config.configDirPath = '/tmp/dot-atom-dir'
config.configFilePath = fs.join(config.configDirPath, "config.cson")
expect(fs.exists(config.configDirPath)).toBeFalsy()
config.configFilePath = fsUtils.join(config.configDirPath, "config.cson")
expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
afterEach ->
fs.remove('/tmp/dot-atom-dir') if fs.exists('/tmp/dot-atom-dir')
fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
it "logs an error to the console and does not overwrite the config file", ->
config.save.reset()
spyOn(console, 'error')
fs.write(config.configFilePath, "{{{{{")
fsUtils.write(config.configFilePath, "{{{{{")
config.loadUserConfig()
config.set("hair", "blonde") # trigger a save
expect(console.error).toHaveBeenCalled()

24
spec/app/directory-spec.coffee
View File

@@ -1,11 +1,11 @@
Directory = require 'directory'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "Directory", ->
directory = null
beforeEach ->
directory = new Directory(fs.resolveOnLoadPath('fixtures'))
directory = new Directory(fsUtils.resolveOnLoadPath('fixtures'))
afterEach ->
directory.off()
@@ -14,11 +14,11 @@ describe "Directory", ->
temporaryFilePath = null
beforeEach ->
temporaryFilePath = fs.join(fs.resolveOnLoadPath('fixtures'), 'temporary')
fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
temporaryFilePath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures'), 'temporary')
fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
afterEach ->
fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
it "triggers 'contents-changed' event handlers", ->
changeHandler = null
@@ -26,13 +26,13 @@ describe "Directory", ->
runs ->
changeHandler = jasmine.createSpy('changeHandler')
directory.on 'contents-changed', changeHandler
fs.write(temporaryFilePath, '')
fsUtils.write(temporaryFilePath, '')
waitsFor "first change", -> changeHandler.callCount > 0
runs ->
changeHandler.reset()
fs.remove(temporaryFilePath)
fsUtils.remove(temporaryFilePath)
waitsFor "second change", -> changeHandler.callCount > 0
@@ -40,11 +40,11 @@ describe "Directory", ->
temporaryFilePath = null
beforeEach ->
temporaryFilePath = fs.join(directory.path, 'temporary')
fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
temporaryFilePath = fsUtils.join(directory.path, 'temporary')
fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
afterEach ->
fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
it "no longer triggers events", ->
changeHandler = null
@@ -52,7 +52,7 @@ describe "Directory", ->
runs ->
changeHandler = jasmine.createSpy('changeHandler')
directory.on 'contents-changed', changeHandler
fs.write(temporaryFilePath, '')
fsUtils.write(temporaryFilePath, '')
waitsFor "change event", -> changeHandler.callCount > 0
@@ -61,7 +61,7 @@ describe "Directory", ->
directory.off()
waits 20
runs -> fs.remove(temporaryFilePath)
runs -> fsUtils.remove(temporaryFilePath)
waits 20
runs -> expect(changeHandler.callCount).toBe 0

12
spec/app/edit-session-spec.coffee
View File

@@ -2060,18 +2060,18 @@ describe "EditSession", ->
editSession.buffer.reload()
expect(editSession.getCursorScreenPosition()).toEqual [0,1]
describe "when the 'grammars-loaded' event is triggered on the syntax global", ->
it "reloads the edit session's grammar and re-tokenizes the buffer if it changes", ->
describe "when a better-matched grammar is added to syntax", ->
it "switches to the better-matched grammar and re-tokenizes the buffer", ->
editSession.destroy()
jsGrammar = syntax.selectGrammar('a.js')
grammarToReturn = syntax.nullGrammar
spyOn(syntax, 'selectGrammar').andCallFake -> grammarToReturn
syntax.removeGrammar(jsGrammar)
editSession = project.buildEditSession('sample.js', autoIndent: false)
expect(editSession.getGrammar()).toBe syntax.nullGrammar
expect(editSession.lineForScreenRow(0).tokens.length).toBe 1
grammarToReturn = jsGrammar
syntax.trigger 'grammars-loaded'
syntax.addGrammar(jsGrammar)
expect(editSession.getGrammar()).toBe jsGrammar
expect(editSession.lineForScreenRow(0).tokens.length).toBeGreaterThan 1
describe "auto-indent", ->

40
spec/app/editor-spec.coffee
View File

@@ -6,7 +6,7 @@ Project = require 'project'
$ = require 'jquery'
{$$} = require 'space-pen'
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "Editor", ->
[buffer, editor, editSession, cachedLineHeight, cachedCharWidth] = []
@@ -83,7 +83,7 @@ describe "Editor", ->
describe "when the activeEditSession's file is modified on disk", ->
it "triggers an alert", ->
path = "/tmp/atom-changed-file.txt"
fs.write(path, "")
fsUtils.write(path, "")
editSession = project.buildEditSession(path)
editor.edit(editSession)
editor.insertText("now the buffer is modified")
@@ -93,7 +93,7 @@ describe "Editor", ->
spyOn(atom, "confirm")
fs.write(path, "a file change")
fsUtils.write(path, "a file change")
waitsFor "file to trigger contents-changed event", ->
fileChangeHandler.callCount > 0
@@ -147,7 +147,7 @@ describe "Editor", ->
it "triggers alert if edit session's buffer goes into conflict with changes on disk", ->
path = "/tmp/atom-changed-file.txt"
fs.write(path, "")
fsUtils.write(path, "")
tempEditSession = project.buildEditSession(path)
editor.edit(tempEditSession)
tempEditSession.insertText("a buffer change")
@@ -156,7 +156,7 @@ describe "Editor", ->
contentsConflictedHandler = jasmine.createSpy("contentsConflictedHandler")
tempEditSession.on 'contents-conflicted', contentsConflictedHandler
fs.write(path, "a file change")
fsUtils.write(path, "a file change")
waitsFor ->
contentsConflictedHandler.callCount > 0
@@ -228,10 +228,10 @@ describe "Editor", ->
path = null
beforeEach ->
path = "/tmp/something.txt"
fs.write(path, path)
fsUtils.write(path, path)
afterEach ->
fs.remove(path) if fs.exists(path)
fsUtils.remove(path) if fsUtils.exists(path)
it "emits event when buffer's path is changed", ->
eventHandler = jasmine.createSpy('eventHandler')
@@ -390,7 +390,7 @@ describe "Editor", ->
editor.clearFontFamily()
it "positions the cursor to the clicked row and column", ->
{top, left} = editor.pixelOffsetForScreenPosition([3, 30])
{top, left} = editor.pixelOffsUtilsetForScreenPosition([3, 30])
editor.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
expect(editor.getCursorScreenPosition()).toEqual [3, 30]
@@ -786,7 +786,7 @@ describe "Editor", ->
setEditorHeightInLines(editor, 4)
describe "if autoscroll is true", ->
it "centers the viewport on the selection if its vertical center is currently offscreen", ->
it "centers the viewport on the selection if its vertical center is currently offsUtilscreen", ->
editor.setSelectedBufferRange([[2, 0], [4, 0]], autoscroll: true)
expect(editor.scrollTop()).toBe 0
@@ -1197,7 +1197,7 @@ describe "Editor", ->
expect(editor.renderedLines.find('.line:last').text()).toBe buffer.lineForRow(7)
describe "when scrolling more than the editors height", ->
it "removes lines that are offscreen and not in range of the overdraw and builds lines that become visible", ->
it "removes lines that are offsUtilscreen and not in range of the overdraw and builds lines that become visible", ->
editor.scrollTop(editor.scrollView.prop('scrollHeight') - editor.scrollView.height())
expect(editor.renderedLines.find('.line').length).toBe 8
expect(editor.renderedLines.find('.line:first').text()).toBe buffer.lineForRow(5)
@@ -2003,11 +2003,11 @@ describe "Editor", ->
beforeEach ->
path = project.resolve('git/working-dir/file.txt')
originalPathText = fs.read(path)
originalPathText = fsUtils.read(path)
editor.edit(project.buildEditSession(path))
afterEach ->
fs.write(path, originalPathText)
fsUtils.write(path, originalPathText)
it "restores the contents of the editor to the HEAD revision", ->
editor.setText('')
@@ -2103,17 +2103,17 @@ describe "Editor", ->
[path] = []
beforeEach ->
path = fs.join(fs.absolute("/tmp"), "grammar-change.txt")
fs.write(path, "var i;")
path = fsUtils.join(fsUtils.absolute("/tmp"), "grammar-change.txt")
fsUtils.write(path, "var i;")
afterEach ->
fs.remove(path) if fs.exists(path)
fsUtils.remove(path) if fsUtils.exists(path)
it "updates all the rendered lines when the grammar changes", ->
editor.edit(project.buildEditSession(path))
expect(editor.getGrammar().name).toBe 'Plain Text'
syntax.setGrammarOverrideForPath(path, 'source.js')
expect(editor.reloadGrammar()).toBeTruthy()
editor.reloadGrammar()
expect(editor.getGrammar().name).toBe 'JavaScript'
tokenizedBuffer = editor.activeEditSession.displayBuffer.tokenizedBuffer
@@ -2451,12 +2451,12 @@ describe "Editor", ->
it "saves the state of the rendered lines, the display buffer, and the buffer to a file of the user's choosing", ->
saveDialogCallback = null
spyOn(atom, 'showSaveDialog').andCallFake (callback) -> saveDialogCallback = callback
spyOn(fs, 'write')
spyOn(fsUtils, 'write')
editor.trigger 'editor:save-debug-snapshot'
expect(atom.showSaveDialog).toHaveBeenCalled()
saveDialogCallback('/tmp/state')
expect(fs.write).toHaveBeenCalled()
expect(fs.write.argsForCall[0][0]).toBe '/tmp/state'
expect(typeof fs.write.argsForCall[0][1]).toBe 'string'
expect(fsUtils.write).toHaveBeenCalled()
expect(fsUtils.write.argsForCall[0][0]).toBe '/tmp/state'
expect(typeof fsUtils.write.argsForCall[0][1]).toBe 'string'

34
spec/app/file-spec.coffee
View File

@@ -1,33 +1,33 @@
File = require 'file'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe 'File', ->
[path, file] = []
beforeEach ->
path = fs.join(fs.resolveOnLoadPath('fixtures'), "atom-file-test.txt") # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
fs.remove(path) if fs.exists(path)
fs.write(path, "this is old!")
path = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures'), "atom-file-test.txt") # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
fsUtils.remove(path) if fsUtils.exists(path)
fsUtils.write(path, "this is old!")
file = new File(path)
file.read()
afterEach ->
file.off()
fs.remove(path) if fs.exists(path)
fsUtils.remove(path) if fsUtils.exists(path)
describe "when the contents of the file change", ->
it "triggers 'contents-changed' event handlers", ->
changeHandler = null
changeHandler = jasmine.createSpy('changeHandler')
file.on 'contents-changed', changeHandler
fs.write(file.getPath(), "this is new!")
fsUtils.write(file.getPath(), "this is new!")
waitsFor "change event", ->
changeHandler.callCount > 0
runs ->
changeHandler.reset()
fs.write(file.getPath(), "this is newer!")
fsUtils.write(file.getPath(), "this is newer!")
waitsFor "second change event", ->
changeHandler.callCount > 0
@@ -37,7 +37,7 @@ describe 'File', ->
removeHandler = null
removeHandler = jasmine.createSpy('removeHandler')
file.on 'removed', removeHandler
fs.remove(file.getPath())
fsUtils.remove(file.getPath())
waitsFor "remove event", ->
removeHandler.callCount > 0
@@ -46,11 +46,11 @@ describe 'File', ->
newPath = null
beforeEach ->
newPath = fs.join(fs.directory(path), "atom-file-was-moved-test.txt")
newPath = fsUtils.join(fsUtils.directory(path), "atom-file-was-moved-test.txt")
afterEach ->
if fs.exists(newPath)
fs.remove(newPath)
if fsUtils.exists(newPath)
fsUtils.remove(newPath)
waitsFor "remove event", (done) -> file.on 'removed', done
it "it updates its path", ->
@@ -58,7 +58,7 @@ describe 'File', ->
moveHandler = jasmine.createSpy('moveHandler')
file.on 'moved', moveHandler
fs.move(path, newPath)
fsUtils.move(path, newPath)
waitsFor "move event", ->
moveHandler.callCount > 0
@@ -74,14 +74,14 @@ describe 'File', ->
changeHandler = jasmine.createSpy('changeHandler')
file.on 'contents-changed', changeHandler
fs.move(path, newPath)
fsUtils.move(path, newPath)
waitsFor "move event", ->
moveHandler.callCount > 0
runs ->
expect(changeHandler).not.toHaveBeenCalled()
fs.write(file.getPath(), "this is new!")
fsUtils.write(file.getPath(), "this is new!")
waitsFor "change event", ->
changeHandler.callCount > 0
@@ -98,12 +98,12 @@ describe 'File', ->
expect(changeHandler).not.toHaveBeenCalled()
fs.remove(path)
fsUtils.remove(path)
expect(changeHandler).not.toHaveBeenCalled()
waits 20
runs ->
fs.write(path, "HE HAS RISEN!")
fsUtils.write(path, "HE HAS RISEN!")
expect(changeHandler).not.toHaveBeenCalled()
waitsFor "resurrection change event", ->
@@ -111,7 +111,7 @@ describe 'File', ->
runs ->
expect(removeHandler).not.toHaveBeenCalled()
fs.write(path, "Hallelujah!")
fsUtils.write(path, "Hallelujah!")
changeHandler.reset()
waitsFor "post-resurrection change event", ->

110
spec/app/git-spec.coffee
View File

@@ -1,12 +1,12 @@
Git = require 'git'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Task = require 'task'
describe "Git", ->
repo = null
beforeEach ->
fs.remove('/tmp/.git') if fs.isDirectory('/tmp/.git')
fsUtils.remove('/tmp/.git') if fsUtils.isDirectory('/tmp/.git')
afterEach ->
repo.destroy() if repo?.repo?
@@ -21,55 +21,55 @@ describe "Git", ->
describe ".getPath()", ->
it "returns the repository path for a .git directory path", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
expect(repo.getPath()).toBe fs.resolveOnLoadPath('fixtures/git/master.git')
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
expect(repo.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/git/master.git')
it "returns the repository path for a repository path", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/master.git'))
expect(repo.getPath()).toBe fs.resolveOnLoadPath('fixtures/git/master.git')
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git'))
expect(repo.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/git/master.git')
describe ".getHead()", ->
it "returns a branch name for a non-empty repository", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/master.git'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git'))
expect(repo.getHead()).toBe 'refs/heads/master'
describe ".getShortHead()", ->
it "returns a branch name for a non-empty repository", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/master.git'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git'))
expect(repo.getShortHead()).toBe 'master'
describe ".isPathIgnored(path)", ->
it "returns true for an ignored path", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/ignore.git'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/ignore.git'))
expect(repo.isPathIgnored('a.txt')).toBeTruthy()
it "returns false for a non-ignored path", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/ignore.git'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/ignore.git'))
expect(repo.isPathIgnored('b.txt')).toBeFalsy()
describe ".isPathModified(path)", ->
[repo, path, newPath, originalPathText] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
path = fs.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
newPath = fs.join(fs.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
originalPathText = fs.read(path)
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
path = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
newPath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
originalPathText = fsUtils.read(path)
afterEach ->
fs.write(path, originalPathText)
fs.remove(newPath) if fs.exists(newPath)
fsUtils.write(path, originalPathText)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
describe "when the path is unstaged", ->
it "returns false if the path has not been modified", ->
expect(repo.isPathModified(path)).toBeFalsy()
it "returns true if the path is modified", ->
fs.write(path, "change")
fsUtils.write(path, "change")
expect(repo.isPathModified(path)).toBeTruthy()
it "returns true if the path is deleted", ->
fs.remove(path)
fsUtils.remove(path)
expect(repo.isPathModified(path)).toBeTruthy()
it "returns false if the path is new", ->
@@ -79,13 +79,13 @@ describe "Git", ->
[path, newPath] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
path = fs.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
newPath = fs.join(fs.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
fs.write(newPath, "i'm new here")
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
path = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
newPath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
fsUtils.write(newPath, "i'm new here")
afterEach ->
fs.remove(newPath) if fs.exists(newPath)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
describe "when the path is unstaged", ->
it "returns true if the path is new", ->
@@ -98,37 +98,37 @@ describe "Git", ->
[path1, path2, originalPath1Text, originalPath2Text] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
path1 = fs.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPath1Text = fs.read(path1)
path2 = fs.resolveOnLoadPath('fixtures/git/working-dir/other.txt')
originalPath2Text = fs.read(path2)
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
path1 = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPath1Text = fsUtils.read(path1)
path2 = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/other.txt')
originalPath2Text = fsUtils.read(path2)
afterEach ->
fs.write(path1, originalPath1Text)
fs.write(path2, originalPath2Text)
fsUtils.write(path1, originalPath1Text)
fsUtils.write(path2, originalPath2Text)
it "no longer reports a path as modified after checkout", ->
expect(repo.isPathModified(path1)).toBeFalsy()
fs.write(path1, '')
fsUtils.write(path1, '')
expect(repo.isPathModified(path1)).toBeTruthy()
expect(repo.checkoutHead(path1)).toBeTruthy()
expect(repo.isPathModified(path1)).toBeFalsy()
it "restores the contents of the path to the original text", ->
fs.write(path1, '')
fsUtils.write(path1, '')
expect(repo.checkoutHead(path1)).toBeTruthy()
expect(fs.read(path1)).toBe(originalPath1Text)
expect(fsUtils.read(path1)).toBe(originalPath1Text)
it "only restores the path specified", ->
fs.write(path2, 'path 2 is edited')
fsUtils.write(path2, 'path 2 is edited')
expect(repo.isPathModified(path2)).toBeTruthy()
expect(repo.checkoutHead(path1)).toBeTruthy()
expect(fs.read(path2)).toBe('path 2 is edited')
expect(fsUtils.read(path2)).toBe('path 2 is edited')
expect(repo.isPathModified(path2)).toBeTruthy()
it "fires a status-changed event if the checkout completes successfully", ->
fs.write(path1, '')
fsUtils.write(path1, '')
repo.getPathStatus(path1)
statusHandler = jasmine.createSpy('statusHandler')
repo.on 'status-changed', statusHandler
@@ -141,7 +141,7 @@ describe "Git", ->
describe ".destroy()", ->
it "throws an exception when any method is called after it is called", ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
repo.destroy()
expect(-> repo.getHead()).toThrow()
@@ -149,38 +149,38 @@ describe "Git", ->
[path, originalPathText] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
path = fs.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPathText = fs.read(path)
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
path = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPathText = fsUtils.read(path)
afterEach ->
fs.write(path, originalPathText)
fsUtils.write(path, originalPathText)
it "returns the number of lines added and deleted", ->
expect(repo.getDiffStats(path)).toEqual {added: 0, deleted: 0}
fs.write(path, "#{originalPathText} edited line")
fsUtils.write(path, "#{originalPathText} edited line")
expect(repo.getDiffStats(path)).toEqual {added: 1, deleted: 1}
describe ".getPathStatus(path)", ->
[path, originalPathText] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
path = fs.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPathText = fs.read(path)
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
path = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
originalPathText = fsUtils.read(path)
afterEach ->
fs.write(path, originalPathText)
fsUtils.write(path, originalPathText)
it "trigger a status-changed event when the new status differs from the last cached one", ->
statusHandler = jasmine.createSpy("statusHandler")
repo.on 'status-changed', statusHandler
fs.write(path, '')
fsUtils.write(path, '')
status = repo.getPathStatus(path)
expect(statusHandler.callCount).toBe 1
expect(statusHandler.argsForCall[0][0..1]).toEqual [path, status]
fs.write(path, 'abc')
fsUtils.write(path, 'abc')
status = repo.getPathStatus(path)
expect(statusHandler.callCount).toBe 1
@@ -188,19 +188,19 @@ describe "Git", ->
[newPath, modifiedPath, cleanPath, originalModifiedPathText] = []
beforeEach ->
repo = new Git(fs.resolveOnLoadPath('fixtures/git/working-dir'))
repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
modifiedPath = project.resolve('git/working-dir/file.txt')
originalModifiedPathText = fs.read(modifiedPath)
originalModifiedPathText = fsUtils.read(modifiedPath)
newPath = project.resolve('git/working-dir/untracked.txt')
cleanPath = project.resolve('git/working-dir/other.txt')
fs.write(newPath, '')
fsUtils.write(newPath, '')
afterEach ->
fs.write(modifiedPath, originalModifiedPathText)
fs.remove(newPath) if fs.exists(newPath)
fsUtils.write(modifiedPath, originalModifiedPathText)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
it "returns status information for all new and modified files", ->
fs.write(modifiedPath, 'making this path modified')
fsUtils.write(modifiedPath, 'making this path modified')
statusHandler = jasmine.createSpy('statusHandler')
repo.on 'statuses-changed', statusHandler
repo.refreshStatus()
@@ -215,7 +215,7 @@ describe "Git", ->
expect(repo.isStatusModified(statuses[modifiedPath])).toBeTruthy()
it "only starts a single web worker at a time and schedules a restart if one is already running", =>
fs.write(modifiedPath, 'making this path modified')
fsUtils.write(modifiedPath, 'making this path modified')
statusHandler = jasmine.createSpy('statusHandler')
repo.on 'statuses-changed', statusHandler

50
spec/app/project-spec.coffee
View File

@@ -1,5 +1,5 @@
Project = require 'project'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
BufferedProcess = require 'buffered-process'
@@ -29,12 +29,12 @@ describe "Project", ->
editSession = project.buildEditSession()
editSession.saveAs('/tmp/atom-test-save-sets-project-path')
expect(project.getPath()).toBe '/tmp'
fs.remove('/tmp/atom-test-save-sets-project-path')
fsUtils.remove('/tmp/atom-test-save-sets-project-path')
describe ".buildEditSession(path)", ->
[absolutePath, newBufferHandler, newEditSessionHandler] = []
beforeEach ->
absolutePath = fs.resolveOnLoadPath('fixtures/dir/a')
absolutePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
newBufferHandler = jasmine.createSpy('newBufferHandler')
project.on 'buffer-created', newBufferHandler
newEditSessionHandler = jasmine.createSpy('newEditSessionHandler')
@@ -86,30 +86,30 @@ describe "Project", ->
describe ".resolve(path)", ->
it "returns an absolute path based on the project's root", ->
absolutePath = fs.resolveOnLoadPath('fixtures/dir/a')
absolutePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
expect(project.resolve('a')).toBe absolutePath
expect(project.resolve(absolutePath + '/../a')).toBe absolutePath
expect(project.resolve('a/../a')).toBe absolutePath
describe ".relativize(path)", ->
it "returns an relative path based on the project's root", ->
absolutePath = fs.resolveOnLoadPath('fixtures/dir')
expect(project.relativize(fs.join(absolutePath, "b"))).toBe "b"
expect(project.relativize(fs.join(absolutePath, "b/file.coffee"))).toBe "b/file.coffee"
expect(project.relativize(fs.join(absolutePath, "file.coffee"))).toBe "file.coffee"
absolutePath = fsUtils.resolveOnLoadPath('fixtures/dir')
expect(project.relativize(fsUtils.join(absolutePath, "b"))).toBe "b"
expect(project.relativize(fsUtils.join(absolutePath, "b/file.coffee"))).toBe "b/file.coffee"
expect(project.relativize(fsUtils.join(absolutePath, "file.coffee"))).toBe "file.coffee"
describe ".setPath(path)", ->
describe "when path is a file", ->
it "sets its path to the files parent directory and updates the root directory", ->
project.setPath(fs.resolveOnLoadPath('fixtures/dir/a'))
expect(project.getPath()).toEqual fs.resolveOnLoadPath('fixtures/dir')
expect(project.getRootDirectory().path).toEqual fs.resolveOnLoadPath('fixtures/dir')
project.setPath(fsUtils.resolveOnLoadPath('fixtures/dir/a'))
expect(project.getPath()).toEqual fsUtils.resolveOnLoadPath('fixtures/dir')
expect(project.getRootDirectory().path).toEqual fsUtils.resolveOnLoadPath('fixtures/dir')
describe "when path is a directory", ->
it "sets its path to the directory and updates the root directory", ->
project.setPath(fs.resolveOnLoadPath('fixtures/dir/a-dir'))
expect(project.getPath()).toEqual fs.resolveOnLoadPath('fixtures/dir/a-dir')
expect(project.getRootDirectory().path).toEqual fs.resolveOnLoadPath('fixtures/dir/a-dir')
project.setPath(fsUtils.resolveOnLoadPath('fixtures/dir/a-dir'))
expect(project.getPath()).toEqual fsUtils.resolveOnLoadPath('fixtures/dir/a-dir')
expect(project.getRootDirectory().path).toEqual fsUtils.resolveOnLoadPath('fixtures/dir/a-dir')
describe "when path is null", ->
it "sets its path and root directory to null", ->
@@ -127,7 +127,7 @@ describe "Project", ->
expect(paths.length).toBeGreaterThan 0
it "ignores files that return true from atom.ignorePath(path)", ->
spyOn(project, 'isPathIgnored').andCallFake (path) -> fs.base(path).match /a$/
spyOn(project, 'isPathIgnored').andCallFake (path) -> fsUtils.base(path).match /a$/
paths = null
waitsForPromise ->
@@ -140,7 +140,7 @@ describe "Project", ->
describe "when config.core.hideGitIgnoredFiles is true", ->
it "ignores files that are present in .gitignore if the project is a git repo", ->
config.set "core.hideGitIgnoredFiles", true
project.setPath(fs.resolveOnLoadPath('fixtures/git/working-dir'))
project.setPath(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
paths = null
waitsForPromise ->
project.getFilePaths().done (foundPaths) -> paths = foundPaths
@@ -152,11 +152,11 @@ describe "Project", ->
ignoredFile = null
beforeEach ->
ignoredFile = fs.join(fs.resolveOnLoadPath('fixtures/dir'), 'ignored.txt')
fs.write(ignoredFile, "")
ignoredFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/dir'), 'ignored.txt')
fsUtils.write(ignoredFile, "")
afterEach ->
fs.remove(ignoredFile)
fsUtils.remove(ignoredFile)
it "ignores ignored.txt file", ->
paths = null
@@ -172,11 +172,11 @@ describe "Project", ->
ignoredFile = null
beforeEach ->
ignoredFile = fs.join(fs.resolveOnLoadPath('fixtures/dir'), 'ignored/ignored.txt')
fs.write(ignoredFile, "")
ignoredFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/dir'), 'ignored/ignored.txt')
fsUtils.write(ignoredFile, "")
afterEach ->
fs.remove(ignoredFile)
fsUtils.remove(ignoredFile)
it "ignores ignored folder", ->
paths = null
@@ -222,7 +222,7 @@ describe "Project", ->
range: [[2, 6], [2, 11]]
it "works on evil filenames", ->
project.setPath(fs.resolveOnLoadPath('fixtures/evil-files'))
project.setPath(fsUtils.resolveOnLoadPath('fixtures/evil-files'))
paths = []
matches = []
waitsForPromise ->
@@ -237,7 +237,7 @@ describe "Project", ->
expect(paths[1]).toMatch /file with spaces.txt$/
expect(paths[2]).toMatch /goddam\nnewlines$/m
expect(paths[3]).toMatch /quote".txt$/m
expect(fs.base(paths[4])).toBe "utfa\u0306.md"
expect(fsUtils.base(paths[4])).toBe "utfa\u0306.md"
it "handles breaks in the search subprocess's output following the filename", ->
spyOn(BufferedProcess.prototype, 'bufferStream')
@@ -246,7 +246,7 @@ describe "Project", ->
project.scan /a+/, iterator
stdout = BufferedProcess.prototype.bufferStream.argsForCall[0][1]
stdout ":#{fs.resolveOnLoadPath('fixtures/dir/a')}\n"
stdout ":#{fsUtils.resolveOnLoadPath('fixtures/dir/a')}\n"
stdout "1;0 3:aaa bbb\n2;3 2:cc aa cc\n"
expect(iterator.argsForCall[0][0]).toEqual

10
spec/app/root-view-spec.coffee
View File

@@ -1,5 +1,5 @@
$ = require 'jquery'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Project = require 'project'
RootView = require 'root-view'
Buffer = require 'text-buffer'
@@ -83,7 +83,7 @@ describe "RootView", ->
expect(editor3.isFocused).toBeFalsy()
expect(editor4.isFocused).toBeFalsy()
expect(rootView.title).toBe "#{fs.base(editor2.getPath())} - #{project.getPath()}"
expect(rootView.title).toBe "#{fsUtils.base(editor2.getPath())} - #{project.getPath()}"
describe "where there are no open editors", ->
it "constructs the view with no open editors", ->
@@ -175,10 +175,10 @@ describe "RootView", ->
expect(rootView.title).toBe "#{item.getTitle()} - #{project.getPath()}"
describe "when the last pane item is removed", ->
it "sets the title to the project's path", ->
it "update the title to contain the project's path", ->
rootView.getActivePane().remove()
expect(rootView.getActivePaneItem()).toBeUndefined()
expect(rootView.title).toBe project.getPath()
expect(rootView.title).toBe "atom - #{project.getPath()}"
describe "when an inactive pane's item changes", ->
it "does not update the title", ->
@@ -223,7 +223,7 @@ describe "RootView", ->
it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
editSession = rootView.open('b')
expect(rootView.getActivePane().activeItem).toBe editSession
expect(editSession.getPath()).toBe fs.resolveOnLoadPath('fixtures/dir/b')
expect(editSession.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/dir/b')
expect(rootView.getActivePane().focus).toHaveBeenCalled()
describe "when the changeFocus option is false", ->

16
spec/app/syntax-spec.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "the `syntax` global", ->
beforeEach ->
@@ -13,7 +13,7 @@ describe "the `syntax` global", ->
expect(syntax.selectGrammar(path).name).not.toBe 'Ruby'
syntax.setGrammarOverrideForPath(path, 'source.ruby')
syntax2 = deserialize(syntax.serialize())
syntax2.addGrammar(grammar) for grammar in syntax.grammars
syntax2.addGrammar(grammar) for grammar in syntax.grammars when grammar isnt syntax.nullGrammar
expect(syntax2.selectGrammar(path).name).toBe 'Ruby'
describe ".selectGrammar(filePath)", ->
@@ -23,8 +23,8 @@ describe "the `syntax` global", ->
expect(syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
expect(syntax.selectGrammar("/tmp/.git/config").name).toBe "Git Config" # based on end of the path (.git/config)
expect(syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
expect(syntax.selectGrammar("curb").name).toBe "Plain Text"
expect(syntax.selectGrammar("/hu.git/config").name).toBe "Plain Text"
expect(syntax.selectGrammar("curb").name).toBe "Null Grammar"
expect(syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
it "uses the filePath's shebang line if the grammar cannot be determined by the extension or basename", ->
filePath = require.resolve("fixtures/shebang")
@@ -37,17 +37,17 @@ describe "the `syntax` global", ->
expect(syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Plain Text"
expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
it "doesn't read the file when the file contents are specified", ->
filePath = require.resolve("fixtures/shebang")
filePathContents = fs.read(filePath)
spyOn(fs, 'read').andCallThrough()
filePathContents = fsUtils.read(filePath)
spyOn(fsUtils, 'read').andCallThrough()
expect(syntax.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
expect(fs.read).not.toHaveBeenCalled()
expect(fsUtils.read).not.toHaveBeenCalled()
it "allows the default grammar to be overridden for a path", ->
path = '/foo/bar/file.js'

88
spec/app/text-buffer-spec.coffee
View File

@@ -1,6 +1,6 @@
Project = require 'project'
Buffer = require 'text-buffer'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
describe 'Buffer', ->
@@ -8,7 +8,7 @@ describe 'Buffer', ->
beforeEach ->
filePath = require.resolve('fixtures/sample.js')
fileContents = fs.read(filePath)
fileContents = fsUtils.read(filePath)
buffer = project.bufferForPath(filePath)
afterEach ->
@@ -24,7 +24,7 @@ describe 'Buffer', ->
it "loads the contents of that file", ->
filePath = require.resolve 'fixtures/sample.txt'
buffer = project.bufferForPath(filePath)
expect(buffer.getText()).toBe fs.read(filePath)
expect(buffer.getText()).toBe fsUtils.read(filePath)
it "is not modified and has no undo history", ->
buffer = project.bufferForPath(filePath)
@@ -34,7 +34,7 @@ describe 'Buffer', ->
describe "when no file exists for the path", ->
it "throws an exception", ->
filePath = "does-not-exist.txt"
expect(fs.exists(filePath)).toBeFalsy()
expect(fsUtils.exists(filePath)).toBeFalsy()
expect(-> project.bufferForPath(filePath)).toThrow()
describe "when no path is given", ->
@@ -46,25 +46,25 @@ describe 'Buffer', ->
[path, newPath, bufferToChange, eventHandler] = []
beforeEach ->
path = fs.join(fs.resolveOnLoadPath("fixtures"), "atom-manipulate-me")
path = fsUtils.join(fsUtils.resolveOnLoadPath("fixtures"), "atom-manipulate-me")
newPath = "#{path}-i-moved"
fs.write(path, "")
fsUtils.write(path, "")
bufferToChange = project.bufferForPath(path)
eventHandler = jasmine.createSpy('eventHandler')
bufferToChange.on 'path-changed', eventHandler
afterEach ->
bufferToChange.destroy()
fs.remove(path) if fs.exists(path)
fs.remove(newPath) if fs.exists(newPath)
fsUtils.remove(path) if fsUtils.exists(path)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
it "triggers a `path-changed` event when path is changed", ->
bufferToChange.saveAs(newPath)
expect(eventHandler).toHaveBeenCalledWith(bufferToChange)
it "triggers a `path-changed` event when the file is moved", ->
fs.remove(newPath) if fs.exists(newPath)
fs.move(path, newPath)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
fsUtils.move(path, newPath)
waitsFor "buffer path change", ->
eventHandler.callCount > 0
@@ -76,14 +76,14 @@ describe 'Buffer', ->
path = null
beforeEach ->
path = "/tmp/tmp.txt"
fs.write(path, "first")
fsUtils.write(path, "first")
buffer.release()
buffer = project.bufferForPath(path).retain()
afterEach ->
buffer.release()
buffer = null
fs.remove(path) if fs.exists(path)
fsUtils.remove(path) if fsUtils.exists(path)
it "does not trigger a change event when Atom modifies the file", ->
buffer.insert([0,0], "HELLO!")
@@ -99,7 +99,7 @@ describe 'Buffer', ->
it "changes the memory contents of the buffer to match the new disk contents and triggers a 'changed' event", ->
changeHandler = jasmine.createSpy('changeHandler')
buffer.on 'changed', changeHandler
fs.write(path, "second")
fsUtils.write(path, "second")
expect(changeHandler.callCount).toBe 0
waitsFor "file to trigger change event", ->
@@ -119,7 +119,7 @@ describe 'Buffer', ->
buffer.file.on 'contents-changed', fileChangeHandler
buffer.insert([0, 0], "a change")
fs.write(path, "second")
fsUtils.write(path, "second")
expect(fileChangeHandler.callCount).toBe 0
waitsFor "file to trigger 'contents-changed' event", ->
@@ -134,7 +134,7 @@ describe 'Buffer', ->
buffer.insert([0, 0], "a second change")
handler = jasmine.createSpy('fileChange')
fs.write(path, "second")
fsUtils.write(path, "second")
buffer.on 'contents-conflicted', handler
expect(handler.callCount).toBe 0
@@ -149,7 +149,7 @@ describe 'Buffer', ->
beforeEach ->
path = "/tmp/atom-file-to-delete.txt"
fs.write(path, 'delete me')
fsUtils.write(path, 'delete me')
bufferToDelete = project.bufferForPath(path)
path = bufferToDelete.getPath() # symlinks may have been converted
@@ -158,7 +158,7 @@ describe 'Buffer', ->
removeHandler = jasmine.createSpy('removeHandler')
bufferToDelete.file.on 'removed', removeHandler
fs.remove(path)
fsUtils.remove(path)
waitsFor "file to be removed", ->
removeHandler.callCount > 0
@@ -174,7 +174,7 @@ describe 'Buffer', ->
expect(bufferToDelete.fileExists()).toBeTruthy()
expect(bufferToDelete.isInConflict()).toBeFalsy()
fs.write(path, 'moo')
fsUtils.write(path, 'moo')
changeHandler = jasmine.createSpy('changeHandler')
bufferToDelete.on 'changed', changeHandler
@@ -207,19 +207,19 @@ describe 'Buffer', ->
it "reports the modified status changing to true after the underlying file is deleted", ->
buffer.release()
filePath = "/tmp/atom-tmp-file"
fs.write(filePath, 'delete me')
fsUtils.write(filePath, 'delete me')
buffer = project.bufferForPath(filePath)
modifiedHandler = jasmine.createSpy("modifiedHandler")
buffer.on 'modified-status-changed', modifiedHandler
fs.remove(filePath)
fsUtils.remove(filePath)
waitsFor "modified status to change", -> modifiedHandler.callCount
runs -> expect(buffer.isModified()).toBe true
it "reports the modified status changing to false after a modified buffer is saved", ->
filePath = "/tmp/atom-tmp-file"
fs.write(filePath, '')
fsUtils.write(filePath, '')
buffer.release()
buffer = project.bufferForPath(filePath)
modifiedHandler = jasmine.createSpy("modifiedHandler")
@@ -243,7 +243,7 @@ describe 'Buffer', ->
it "reports the modified status changing to false after a modified buffer is reloaded", ->
filePath = "/tmp/atom-tmp-file"
fs.write(filePath, '')
fsUtils.write(filePath, '')
buffer.release()
buffer = project.bufferForPath(filePath)
modifiedHandler = jasmine.createSpy("modifiedHandler")
@@ -420,16 +420,16 @@ describe 'Buffer', ->
beforeEach ->
filePath = '/tmp/temp.txt'
fs.write(filePath, "")
fsUtils.write(filePath, "")
saveBuffer = project.bufferForPath(filePath)
saveBuffer.setText("blah")
it "saves the contents of the buffer to the path", ->
saveBuffer.setText 'Buffer contents!'
saveBuffer.save()
expect(fs.read(filePath)).toEqual 'Buffer contents!'
expect(fsUtils.read(filePath)).toEqual 'Buffer contents!'
it "fires will-be-saved and saved events around the call to fs.write", ->
it "fires will-be-saved and saved events around the call to fsUtils.write", ->
events = []
beforeSave1 = -> events.push('beforeSave1')
beforeSave2 = -> events.push('beforeSave2')
@@ -438,12 +438,12 @@ describe 'Buffer', ->
saveBuffer.on 'will-be-saved', beforeSave1
saveBuffer.on 'will-be-saved', beforeSave2
spyOn(fs, 'write').andCallFake -> events.push 'fs.write'
spyOn(fsUtils, 'write').andCallFake -> events.push 'fsUtils.write'
saveBuffer.on 'saved', afterSave1
saveBuffer.on 'saved', afterSave2
saveBuffer.save()
expect(events).toEqual ['beforeSave1', 'beforeSave2', 'fs.write', 'afterSave1', 'afterSave2']
expect(events).toEqual ['beforeSave1', 'beforeSave2', 'fsUtils.write', 'afterSave1', 'afterSave2']
it "fires will-reload and reloaded events when reloaded", ->
events = []
@@ -477,7 +477,7 @@ describe 'Buffer', ->
it "saves the contents of the buffer to the path", ->
filePath = '/tmp/temp.txt'
fs.remove filePath if fs.exists(filePath)
fsUtils.remove filePath if fsUtils.exists(filePath)
saveAsBuffer = project.bufferForPath(null).retain()
eventHandler = jasmine.createSpy('eventHandler')
@@ -485,14 +485,14 @@ describe 'Buffer', ->
saveAsBuffer.setText 'Buffer contents!'
saveAsBuffer.saveAs(filePath)
expect(fs.read(filePath)).toEqual 'Buffer contents!'
expect(fsUtils.read(filePath)).toEqual 'Buffer contents!'
expect(eventHandler).toHaveBeenCalledWith(saveAsBuffer)
it "stops listening to events on previous path and begins listening to events on new path", ->
originalPath = "/tmp/original.txt"
newPath = "/tmp/new.txt"
fs.write(originalPath, "")
fsUtils.write(originalPath, "")
saveAsBuffer = project.bufferForPath(originalPath).retain()
changeHandler = jasmine.createSpy('changeHandler')
@@ -500,11 +500,11 @@ describe 'Buffer', ->
saveAsBuffer.saveAs(newPath)
expect(changeHandler).not.toHaveBeenCalled()
fs.write(originalPath, "should not trigger buffer event")
fsUtils.write(originalPath, "should not trigger buffer event")
waits 20
runs ->
expect(changeHandler).not.toHaveBeenCalled()
fs.write(newPath, "should trigger buffer event")
fsUtils.write(newPath, "should trigger buffer event")
waitsFor ->
changeHandler.callCount > 0
@@ -546,7 +546,7 @@ describe 'Buffer', ->
describe "when given a regex with a ignore case flag", ->
it "does a case-insensitive search", ->
matches = []
buffer.scanInRange /cuRRent/i, [[0,0], [12,0]], (match, range) ->
buffer.scanInRange /cuRRent/i, [[0,0], [12,0]], ({match, range}) ->
matches.push(match)
expect(matches.length).toBe 1
@@ -554,7 +554,7 @@ describe 'Buffer', ->
it "calls the iterator with the first match for the given regex in the given range", ->
matches = []
ranges = []
buffer.scanInRange /cu(rr)ent/, [[4,0], [6,44]], (match, range) ->
buffer.scanInRange /cu(rr)ent/, [[4,0], [6,44]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -569,7 +569,7 @@ describe 'Buffer', ->
it "calls the iterator with each match for the given regex in the given range", ->
matches = []
ranges = []
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range) ->
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -593,7 +593,7 @@ describe 'Buffer', ->
it "calls the iterator with the truncated match", ->
matches = []
ranges = []
buffer.scanInRange /cu(r*)/g, [[4,0], [6,9]], (match, range) ->
buffer.scanInRange /cu(r*)/g, [[4,0], [6,9]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -612,7 +612,7 @@ describe 'Buffer', ->
it "calls the iterator with the truncated match", ->
matches = []
ranges = []
buffer.scanInRange /cu(r*)e/g, [[4,0], [6,9]], (match, range) ->
buffer.scanInRange /cu(r*)e/g, [[4,0], [6,9]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -626,7 +626,7 @@ describe 'Buffer', ->
describe "when the iterator calls the 'replace' control function with a replacement string", ->
it "replaces each occurrence of the regex match with the string", ->
ranges = []
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range, { replace }) ->
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({range, replace}) ->
ranges.push(range)
replace("foo")
@@ -638,7 +638,7 @@ describe 'Buffer', ->
expect(buffer.lineForRow(6)).toBe ' foo < pivot ? left.push(foo) : right.push(current);'
it "allows the match to be replaced with the empty string", ->
buffer.scanInRange /current/g, [[4,0], [6,59]], (match, range, { replace }) ->
buffer.scanInRange /current/g, [[4,0], [6,59]], ({replace}) ->
replace("")
expect(buffer.lineForRow(5)).toBe ' = items.shift();'
@@ -647,7 +647,7 @@ describe 'Buffer', ->
describe "when the iterator calls the 'stop' control function", ->
it "stops the traversal", ->
ranges = []
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range, { stop }) ->
buffer.scanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({range, stop}) ->
ranges.push(range)
stop() if ranges.length == 2
@@ -658,7 +658,7 @@ describe 'Buffer', ->
it "calls the iterator with the last match for the given regex in the given range", ->
matches = []
ranges = []
buffer.backwardsScanInRange /cu(rr)ent/, [[4,0], [6,44]], (match, range) ->
buffer.backwardsScanInRange /cu(rr)ent/, [[4,0], [6,44]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -673,7 +673,7 @@ describe 'Buffer', ->
it "calls the iterator with each match for the given regex in the given range, starting with the last match", ->
matches = []
ranges = []
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range) ->
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({match, range}) ->
matches.push(match)
ranges.push(range)
@@ -695,7 +695,7 @@ describe 'Buffer', ->
describe "when the iterator calls the 'replace' control function with a replacement string", ->
it "replaces each occurrence of the regex match with the string", ->
ranges = []
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range, { replace }) ->
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({range, replace}) ->
ranges.push(range)
replace("foo") unless range.start.isEqual([6,6])
@@ -709,7 +709,7 @@ describe 'Buffer', ->
describe "when the iterator calls the 'stop' control function", ->
it "stops the traversal", ->
ranges = []
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], (match, range, { stop }) ->
buffer.backwardsScanInRange /cu(rr)ent/g, [[4,0], [6,59]], ({range, stop}) ->
ranges.push(range)
stop() if ranges.length == 2

14
spec/app/text-mate-grammar-spec.coffee
View File

@@ -1,7 +1,7 @@
TextMateGrammar = require 'text-mate-grammar'
TextMatePackage = require 'text-mate-package'
plist = require 'plist'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
describe "TextMateGrammar", ->
@@ -16,13 +16,13 @@ describe "TextMateGrammar", ->
describe "@loadSync(path)", ->
it "loads grammars from plists", ->
grammar = TextMateGrammar.loadSync(fs.resolveOnLoadPath('packages/text.tmbundle/Syntaxes/Plain text.plist'))
grammar = TextMateGrammar.loadSync(fsUtils.resolveOnLoadPath('packages/text.tmbundle/Syntaxes/Plain text.plist'))
expect(grammar.scopeName).toBe "text.plain"
{tokens} = grammar.tokenizeLine("this text is so plain. i love it.")
expect(tokens[0]).toEqual value: "this text is so plain. i love it.", scopes: ["text.plain", "meta.paragraph.text"]
it "loads grammars from cson files", ->
grammar = TextMateGrammar.loadSync(fs.resolveOnLoadPath('package-with-grammars/grammars/alot.cson'))
grammar = TextMateGrammar.loadSync(fsUtils.resolveOnLoadPath('package-with-grammars/grammars/alot.cson'))
expect(grammar.scopeName).toBe "source.alot"
{tokens} = grammar.tokenizeLine("this is alot of code")
expect(tokens[1]).toEqual value: "alot", scopes: ["source.alot", "keyword.alot"]
@@ -138,7 +138,7 @@ describe "TextMateGrammar", ->
describe "when the line matches a pattern with no `name` or `contentName`", ->
it "creates tokens without adding a new scope", ->
grammar = syntax.grammarsByFileType["rb"]
grammar = syntax.selectGrammar('foo.rb')
{tokens} = grammar.tokenizeLine('%w|oh \\look|')
expect(tokens.length).toBe 5
expect(tokens[0]).toEqual value: '%w|', scopes: ["source.ruby", "string.quoted.other.literal.lower.ruby", "punctuation.definition.string.begin.ruby"]
@@ -183,7 +183,7 @@ describe "TextMateGrammar", ->
describe "when the end pattern contains a back reference", ->
it "constructs the end rule based on its back-references to captures in the begin rule", ->
grammar = syntax.grammarsByFileType["rb"]
grammar = syntax.selectGrammar('foo.rb')
{tokens} = grammar.tokenizeLine('%w|oh|,')
expect(tokens.length).toBe 4
expect(tokens[0]).toEqual value: '%w|', scopes: ["source.ruby", "string.quoted.other.literal.lower.ruby", "punctuation.definition.string.begin.ruby"]
@@ -192,7 +192,7 @@ describe "TextMateGrammar", ->
expect(tokens[3]).toEqual value: ',', scopes: ["source.ruby", "punctuation.separator.object.ruby"]
it "allows the rule containing that end pattern to be pushed to the stack multiple times", ->
grammar = syntax.grammarsByFileType["rb"]
grammar = syntax.selectGrammar('foo.rb')
{tokens} = grammar.tokenizeLine('%Q+matz had some #{%Q-crazy ideas-} for ruby syntax+ # damn.')
expect(tokens[0]).toEqual value: '%Q+', scopes: ["source.ruby","string.quoted.other.literal.upper.ruby","punctuation.definition.string.begin.ruby"]
expect(tokens[1]).toEqual value: 'matz had some ', scopes: ["source.ruby","string.quoted.other.literal.upper.ruby"]
@@ -212,7 +212,7 @@ describe "TextMateGrammar", ->
atom.activatePackage('html.tmbundle', sync: true)
atom.activatePackage('ruby-on-rails-tmbundle', sync: true)
grammar = syntax.grammarsByFileType["html.erb"]
grammar = syntax.selectGrammar('foo.html.erb')
{tokens} = grammar.tokenizeLine("<div class='name'><%= User.find(2).full_name %></div>")
expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]

4
spec/app/text-mate-theme-spec.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
plist = require 'plist'
TextMateTheme = require 'text-mate-theme'
Theme = require 'theme'
@@ -7,7 +7,7 @@ describe "TextMateTheme", ->
[theme, themePath] = []
beforeEach ->
themePath = fs.resolveOnLoadPath(fs.join('fixtures', 'test.tmTheme'))
themePath = fsUtils.resolveOnLoadPath(fsUtils.join('fixtures', 'test.tmTheme'))
theme = Theme.load(themePath)
afterEach ->

4
spec/app/theme-spec.coffee
View File

@@ -1,5 +1,5 @@
$ = require 'jquery'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Theme = require 'theme'
describe "@load(name)", ->
@@ -15,7 +15,7 @@ describe "@load(name)", ->
it "applies the theme's stylesheet to the current window", ->
expect($(".editor").css("background-color")).not.toBe("rgb(20, 20, 20)")
themePath = fs.resolveOnLoadPath(fs.join('fixtures', 'test.tmTheme'))
themePath = fsUtils.resolveOnLoadPath(fsUtils.join('fixtures', 'test.tmTheme'))
theme = Theme.load(themePath)
expect($(".editor").css("background-color")).toBe("rgb(20, 20, 20)")

14
spec/app/window-spec.coffee
View File

@@ -1,5 +1,5 @@
$ = require 'jquery'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
{less} = require 'less'
describe "Window", ->
@@ -70,7 +70,7 @@ describe "Window", ->
element = $('head style[id*="css.css"]')
expect(element.attr('id')).toBe cssPath
expect(element.text()).toBe fs.read(cssPath)
expect(element.text()).toBe fsUtils.read(cssPath)
# doesn't append twice
requireStylesheet(cssPath)
@@ -112,7 +112,7 @@ describe "Window", ->
describe ".removeStylesheet(path)", ->
it "removes styling applied by given stylesheet path", ->
cssPath = require.resolve(fs.join("fixtures", "css.css"))
cssPath = require.resolve(fsUtils.join("fixtures", "css.css"))
expect($(document.body).css('font-weight')).not.toBe("bold")
requireStylesheet(cssPath)
@@ -159,14 +159,14 @@ describe "Window", ->
commandPath = '/tmp/installed-atom-command/atom'
afterEach ->
fs.remove(commandPath) if fs.exists(commandPath)
fsUtils.remove(commandPath) if fsUtils.exists(commandPath)
describe "when the command path doesn't exist", ->
it "copies atom.sh to the specified path", ->
expect(fs.exists(commandPath)).toBeFalsy()
expect(fsUtils.exists(commandPath)).toBeFalsy()
window.installAtomCommand(commandPath)
expect(fs.exists(commandPath)).toBeTruthy()
expect(fs.read(commandPath).length).toBeGreaterThan 1
expect(fsUtils.exists(commandPath)).toBeTruthy()
expect(fsUtils.read(commandPath).length).toBeGreaterThan 1
describe ".deserialize(state)", ->
class Foo

1
spec/fixtures/packages/package-with-activation-events/index.coffee vendored
View File

@@ -10,5 +10,4 @@ module.exports =
activate: ->
@activateCallCount++
rootView.getActiveView()?.command 'activation-event', =>
console.log "ACTIVATION EVENT"
@activationEventCallCount++

2
spec/fixtures/packages/package-with-config-defaults/index.coffee vendored
View File

@@ -1,3 +1,5 @@
module.exports =
configDefaults:
numbers: { one: 1, two: 2 }
activate: -> # no-op

2
spec/fixtures/packages/package-with-main/main-module.coffee vendored
View File

@@ -1,2 +1,2 @@
module.exports =
activate: ->
activate: ->

6
spec/jasmine-helper.coffee
View File

@@ -1,8 +1,8 @@
window.nakedLoad = (file) ->
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
file = require.resolve(file)
code = fs.read(file)
if fs.extension(file) is '.coffee'
code = fsUtils.read(file)
if fsUtils.extension(file) is '.coffee'
require('coffee-script').eval(code, filename: file)
else
window.eval("#{code}\n//@ sourceURL=#{file}")

10
spec/spec-helper.coffee
View File

@@ -12,11 +12,11 @@ Directory = require 'directory'
File = require 'file'
Editor = require 'editor'
TokenizedBuffer = require 'tokenized-buffer'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
RootView = require 'root-view'
Git = require 'git'
requireStylesheet "jasmine"
fixturePackagesPath = fs.resolveOnLoadPath('fixtures/packages')
fixturePackagesPath = fsUtils.resolveOnLoadPath('fixtures/packages')
config.packageDirPaths.unshift(fixturePackagesPath)
keymap.loadBundledKeymaps()
[bindingSetsToRestore, bindingSetsByFirstKeystrokeToRestore] = []
@@ -30,7 +30,7 @@ jasmine.getEnv().defaultTimeoutInterval = 5000
beforeEach ->
jQuery.fx.off = true
window.project = new Project(fs.resolveOnLoadPath('fixtures'))
window.project = new Project(fsUtils.resolveOnLoadPath('fixtures'))
window.git = Git.open(project.getPath())
window.project.on 'path-changed', ->
window.git?.destroy()
@@ -126,7 +126,7 @@ addCustomMatchers = (spec) ->
toExistOnDisk: (expected) ->
notText = this.isNot and " not" or ""
@message = -> return "Expected path '" + @actual + "'" + notText + " to exist."
fs.exists(@actual)
fsUtils.exists(@actual)
window.keyIdentifierForKey = (key) ->
if key.length > 1 # named key
@@ -241,5 +241,5 @@ $.fn.textInput = (data) ->
event = jQuery.event.fix(event)
$(this).trigger(event)
unless fs.md5ForPath(require.resolve('fixtures/sample.js')) == "dd38087d0d7e3e4802a6d3f9b9745f2b"
unless fsUtils.md5ForPath(require.resolve('fixtures/sample.js')) == "dd38087d0d7e3e4802a6d3f9b9745f2b"
throw new Error("Sample.js is modified")

8
spec/spec-suite.coffee
View File

@@ -1,15 +1,15 @@
require 'window'
measure 'spec suite require time', ->
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
require 'spec-helper'
# Run core specs
for path in fs.listTree(fs.resolveOnLoadPath("spec")) when /-spec\.coffee$/.test path
for path in fsUtils.listTree(fsUtils.resolveOnLoadPath("spec")) when /-spec\.coffee$/.test path
require path
# Run extension specs
for packageDirPath in config.packageDirPaths
for packagePath in fs.list(packageDirPath)
for path in fs.listTree(fs.join(packagePath, "spec")) when /-spec\.coffee$/.test path
for packagePath in fsUtils.list(packageDirPath)
for path in fsUtils.listTree(fsUtils.join(packagePath, "spec")) when /-spec\.coffee$/.test path
require path

96
spec/stdlib/fs-utils-spec.coffee
View File

@@ -1,95 +1,95 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "fs", ->
describe "fsUtils", ->
describe ".read(path)", ->
it "return contents of file", ->
expect(fs.read(require.resolve("fixtures/sample.txt"))).toBe "Some text.\n"
expect(fsUtils.read(require.resolve("fixtures/sample.txt"))).toBe "Some text.\n"
it "does not through an exception when the path is a binary file", ->
expect(-> fs.read(require.resolve("fixtures/binary-file.png"))).not.toThrow()
expect(-> fsUtils.read(require.resolve("fixtures/binary-file.png"))).not.toThrow()
describe ".isFile(path)", ->
fixturesDir = fs.resolveOnLoadPath('fixtures')
fixturesDir = fsUtils.resolveOnLoadPath('fixtures')
it "returns true with a file path", ->
expect(fs.isFile(fs.join(fixturesDir, 'sample.js'))).toBe true
expect(fsUtils.isFile(fsUtils.join(fixturesDir, 'sample.js'))).toBe true
it "returns false with a directory path", ->
expect(fs.isFile(fixturesDir)).toBe false
expect(fsUtils.isFile(fixturesDir)).toBe false
it "returns false with a non-existent path", ->
expect(fs.isFile(fs.join(fixturesDir, 'non-existent'))).toBe false
expect(fs.isFile(null)).toBe false
expect(fsUtils.isFile(fsUtils.join(fixturesDir, 'non-existent'))).toBe false
expect(fsUtils.isFile(null)).toBe false
describe ".directory(path)", ->
describe "when called with a file path", ->
it "returns the path to the directory", ->
expect(fs.directory(fs.resolveOnLoadPath('fixtures/dir/a'))).toBe fs.resolveOnLoadPath('fixtures/dir')
expect(fsUtils.directory(fsUtils.resolveOnLoadPath('fixtures/dir/a'))).toBe fsUtils.resolveOnLoadPath('fixtures/dir')
describe "when called with a directory path", ->
it "return the path it was given", ->
expect(fs.directory("/a/b/c")).toBe "/a/b"
expect(fs.directory("/a")).toBe ""
expect(fs.directory("a")).toBe ""
expect(fs.directory("/a/b/c++")).toBe "/a/b"
expect(fsUtils.directory("/a/b/c")).toBe "/a/b"
expect(fsUtils.directory("/a")).toBe ""
expect(fsUtils.directory("a")).toBe ""
expect(fsUtils.directory("/a/b/c++")).toBe "/a/b"
describe ".base(path, ext)", ->
describe "when called with an extension", ->
it "return the base name without the extension when the path has the given extension", ->
expect(fs.base("/a/b/c.txt", '.txt')).toBe "c"
expect(fs.base("/a/b/c.txt", '.txt2')).toBe "c.txt"
expect(fs.base("/a/b/c.+", '.+')).toBe "c"
expect(fsUtils.base("/a/b/c.txt", '.txt')).toBe "c"
expect(fsUtils.base("/a/b/c.txt", '.txt2')).toBe "c.txt"
expect(fsUtils.base("/a/b/c.+", '.+')).toBe "c"
describe ".exists(path)", ->
it "returns true when path exsits", ->
expect(fs.exists(fs.resolveOnLoadPath('fixtures'))).toBe true
expect(fsUtils.exists(fsUtils.resolveOnLoadPath('fixtures'))).toBe true
it "returns false when path doesn't exsit", ->
expect(fs.exists(fs.resolveOnLoadPath("fixtures") + "/-nope-does-not-exist")).toBe false
expect(fs.exists("")).toBe false
expect(fs.exists(null)).toBe false
expect(fsUtils.exists(fsUtils.resolveOnLoadPath("fixtures") + "/-nope-does-not-exist")).toBe false
expect(fsUtils.exists("")).toBe false
expect(fsUtils.exists(null)).toBe false
describe ".join(paths...)", ->
it "concatenates the given paths with the directory separator", ->
expect(fs.join('a')).toBe 'a'
expect(fs.join('a', 'b', 'c')).toBe 'a/b/c'
expect(fs.join('/a/b/', 'c', 'd')).toBe '/a/b/c/d'
expect(fs.join('a', 'b/c/', 'd/')).toBe 'a/b/c/d/'
expect(fsUtils.join('a')).toBe 'a'
expect(fsUtils.join('a', 'b', 'c')).toBe 'a/b/c'
expect(fsUtils.join('/a/b/', 'c', 'd')).toBe '/a/b/c/d'
expect(fsUtils.join('a', 'b/c/', 'd/')).toBe 'a/b/c/d/'
describe ".split(path)", ->
it "returns path components", ->
expect(fs.split("/a/b/c.txt")).toEqual ["", "a", "b", "c.txt"]
expect(fs.split("a/b/c.txt")).toEqual ["a", "b", "c.txt"]
expect(fsUtils.split("/a/b/c.txt")).toEqual ["", "a", "b", "c.txt"]
expect(fsUtils.split("a/b/c.txt")).toEqual ["a", "b", "c.txt"]
describe ".extension(path)", ->
it "returns the extension of a file", ->
expect(fs.extension("a/b/corey.txt")).toBe '.txt'
expect(fs.extension("a/b/corey.txt.coffee")).toBe '.coffee'
expect(fsUtils.extension("a/b/corey.txt")).toBe '.txt'
expect(fsUtils.extension("a/b/corey.txt.coffee")).toBe '.coffee'
it "returns an empty string for paths without an extension", ->
expect(fs.extension("a/b.not-extension/a-dir")).toBe ''
expect(fsUtils.extension("a/b.not-extension/a-dir")).toBe ''
describe ".makeTree(path)", ->
beforeEach ->
fs.remove("/tmp/a") if fs.exists("/tmp/a")
fsUtils.remove("/tmp/a") if fsUtils.exists("/tmp/a")
it "creates all directories in path including any missing parent directories", ->
fs.makeTree("/tmp/a/b/c")
expect(fs.exists("/tmp/a/b/c")).toBeTruthy()
fsUtils.makeTree("/tmp/a/b/c")
expect(fsUtils.exists("/tmp/a/b/c")).toBeTruthy()
describe ".traverseTreeSync(path, onFile, onDirectory)", ->
fixturesDir = null
beforeEach ->
fixturesDir = fs.resolveOnLoadPath('fixtures')
fixturesDir = fsUtils.resolveOnLoadPath('fixtures')
it "calls fn for every path in the tree at the given path", ->
paths = []
onPath = (path) ->
paths.push(path)
true
fs.traverseTreeSync fixturesDir, onPath, onPath
expect(paths).toEqual fs.listTree(fixturesDir)
fsUtils.traverseTreeSync fixturesDir, onPath, onPath
expect(paths).toEqual fsUtils.listTree(fixturesDir)
it "does not recurse into a directory if it is pruned", ->
paths = []
@@ -99,43 +99,43 @@ describe "fs", ->
else
paths.push(path)
true
fs.traverseTreeSync fixturesDir, onPath, onPath
fsUtils.traverseTreeSync fixturesDir, onPath, onPath
expect(paths.length).toBeGreaterThan 0
for path in paths
expect(path).not.toMatch /\/dir\//
it "returns entries if path is a symlink", ->
symlinkPath = fs.join(fixturesDir, 'symlink-to-dir')
symlinkPath = fsUtils.join(fixturesDir, 'symlink-to-dir')
symlinkPaths = []
onSymlinkPath = (path) -> symlinkPaths.push(path.substring(symlinkPath.length + 1))
regularPath = fs.join(fixturesDir, 'dir')
regularPath = fsUtils.join(fixturesDir, 'dir')
paths = []
onPath = (path) -> paths.push(path.substring(regularPath.length + 1))
fs.traverseTreeSync(symlinkPath, onSymlinkPath, onSymlinkPath)
fs.traverseTreeSync(regularPath, onPath, onPath)
fsUtils.traverseTreeSync(symlinkPath, onSymlinkPath, onSymlinkPath)
fsUtils.traverseTreeSync(regularPath, onPath, onPath)
expect(symlinkPaths).toEqual(paths)
describe ".md5ForPath(path)", ->
it "returns the MD5 hash of the file at the given path", ->
expect(fs.md5ForPath(require.resolve('fixtures/sample.js'))).toBe 'dd38087d0d7e3e4802a6d3f9b9745f2b'
expect(fsUtils.md5ForPath(require.resolve('fixtures/sample.js'))).toBe 'dd38087d0d7e3e4802a6d3f9b9745f2b'
describe ".list(path, extensions)", ->
it "returns the absolute paths of entries within the given directory", ->
paths = fs.list(project.getPath())
paths = fsUtils.list(project.getPath())
expect(paths).toContain project.resolve('css.css')
expect(paths).toContain project.resolve('coffee.coffee')
expect(paths).toContain project.resolve('two-hundred.txt')
it "returns an empty array for paths that aren't directories or don't exist", ->
expect(fs.list(project.resolve('sample.js'))).toEqual []
expect(fs.list('/non/existent/directory')).toEqual []
expect(fsUtils.list(project.resolve('sample.js'))).toEqual []
expect(fsUtils.list('/non/existent/directory')).toEqual []
it "can filter the paths by an optional array of file extensions", ->
paths = fs.list(project.getPath(), ['.css', 'coffee'])
paths = fsUtils.list(project.getPath(), ['.css', 'coffee'])
expect(paths).toContain project.resolve('css.css')
expect(paths).toContain project.resolve('coffee.coffee')
expect(path).toMatch /(css|coffee)$/ for path in paths
@@ -145,7 +145,7 @@ describe "fs", ->
it "calls the callback with the absolute paths of entries within the given directory", ->
waitsFor (done) ->
fs.listAsync project.getPath(), (err, result) ->
fsUtils.listAsync project.getPath(), (err, result) ->
paths = result
done()
runs ->
@@ -155,7 +155,7 @@ describe "fs", ->
it "can filter the paths by an optional array of file extensions", ->
waitsFor (done) ->
fs.listAsync project.getPath(), ['css', '.coffee'], (err, result) ->
fsUtils.listAsync project.getPath(), ['css', '.coffee'], (err, result) ->
paths = result
done()
runs ->

12
src/app/atom-theme.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Theme = require 'theme'
CSON = require 'cson'
@@ -9,17 +9,17 @@ class AtomTheme extends Theme
@stylesheets[stylesheetPath] = window.loadStylesheet(stylesheetPath)
load: ->
if fs.extension(@path) in ['.css', '.less']
if fsUtils.extension(@path) in ['.css', '.less']
@loadStylesheet(@path)
else
metadataPath = fs.resolveExtension(fs.join(@path, 'package'), ['cson', 'json'])
if fs.isFile(metadataPath)
metadataPath = fsUtils.resolveExtension(fsUtils.join(@path, 'package'), ['cson', 'json'])
if fsUtils.isFile(metadataPath)
stylesheetNames = CSON.readObject(metadataPath)?.stylesheets
if stylesheetNames
for name in stylesheetNames
filename = fs.resolveExtension(fs.join(@path, name), ['.css', '.less', ''])
filename = fsUtils.resolveExtension(fsUtils.join(@path, name), ['.css', '.less', ''])
@loadStylesheet(filename)
else
@loadStylesheet(stylesheetPath) for stylesheetPath in fs.list(@path, ['.css', '.less'])
@loadStylesheet(stylesheetPath) for stylesheetPath in fsUtils.list(@path, ['.css', '.less'])
super

34
src/app/atom.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
Package = require 'package'
TextMatePackage = require 'text-mate-package'
@@ -74,9 +74,9 @@ _.extend atom,
throw new Error("Could not resolve '#{id}' to a package path")
resolvePackagePath: _.memoize (id) ->
return id if fs.isDirectory(id)
path = fs.resolve(config.packageDirPaths..., id)
path if fs.isDirectory(path)
return id if fsUtils.isDirectory(id)
path = fsUtils.resolve(config.packageDirPaths..., id)
path if fsUtils.isDirectory(path)
getLoadedPackage: (id) ->
if path = @resolvePackagePath(id)
@@ -90,13 +90,13 @@ _.extend atom,
isPackageDisabled: (id) ->
if path = @resolvePackagePath(id)
_.include(config.get('core.disabledPackages') ? [], fs.base(path))
_.include(config.get('core.disabledPackages') ? [], fsUtils.base(path))
getPackagePaths: ->
packagePaths = []
for packageDirPath in config.packageDirPaths
for packagePath in fs.list(packageDirPath)
packagePaths.push(packagePath) if fs.isDirectory(packagePath)
for packagePath in fsUtils.list(packageDirPath)
packagePaths.push(packagePath) if fsUtils.isDirectory(packagePath)
_.uniq(packagePaths)
loadThemes: ->
@@ -109,8 +109,8 @@ _.extend atom,
@loadedThemes.push Theme.load(name)
loadUserStylesheet: ->
userStylesheetPath = fs.resolve(fs.join(config.configDirPath, 'user'), ['css', 'less'])
if fs.isFile(userStylesheetPath)
userStylesheetPath = fsUtils.resolve(fsUtils.join(config.configDirPath, 'user'), ['css', 'less'])
if fsUtils.isFile(userStylesheetPath)
userStyleesheetContents = loadStylesheet(userStylesheetPath)
applyStylesheet(userStylesheetPath, userStyleesheetContents, 'userTheme')
@@ -233,10 +233,12 @@ _.extend atom,
null
getSavedWindowState: ->
localStorage[window.location.params.pathToOpen]
if pathToOpen = window.location.params.pathToOpen
localStorage[pathToOpen]
saveWindowState: ->
localStorage[@getPathToOpen()] = JSON.stringify(@getWindowState())
if pathToOpen = @getPathToOpen()
localStorage[pathToOpen] = JSON.stringify(@getWindowState())
update: ->
@sendMessageToBrowserProcess('update')
@@ -244,10 +246,16 @@ _.extend atom,
getUpdateStatus: (callback) ->
@sendMessageToBrowserProcess('getUpdateStatus', [], callback)
crashMainProcess: ->
@sendMessageToBrowserProcess('crash')
crashRenderProcess: ->
$native.crash()
requireUserInitScript: ->
userInitScriptPath = fs.join(config.configDirPath, "user.coffee")
userInitScriptPath = fsUtils.join(config.configDirPath, "user.coffee")
try
require userInitScriptPath if fs.isFile(userInitScriptPath)
require userInitScriptPath if fsUtils.isFile(userInitScriptPath)
catch error
console.error "Failed to load `#{userInitScriptPath}`", error.stack, error

4
src/app/binding-set.coffee
View File

@@ -1,6 +1,6 @@
$ = require 'jquery'
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Specificity = require 'specificity'
PEG = require 'pegjs'
@@ -17,7 +17,7 @@ class BindingSet
name: null
constructor: (@selector, commandsByKeystrokes, @index, @name) ->
BindingSet.parser ?= PEG.buildParser(fs.read(require.resolve 'keystroke-pattern.pegjs'))
BindingSet.parser ?= PEG.buildParser(fsUtils.read(require.resolve 'keystroke-pattern.pegjs'))
@specificity = Specificity(@selector)
@commandsByKeystrokes = @normalizeCommandsByKeystrokes(commandsByKeystrokes)

42
src/app/config.coffee
View File

@@ -1,15 +1,15 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
EventEmitter = require 'event-emitter'
CSON = require 'cson'
configDirPath = fs.absolute("~/.atom")
bundledPackagesDirPath = fs.join(resourcePath, "src/packages")
bundledThemesDirPath = fs.join(resourcePath, "themes")
vendoredPackagesDirPath = fs.join(resourcePath, "vendor/packages")
vendoredThemesDirPath = fs.join(resourcePath, "vendor/themes")
userThemesDirPath = fs.join(configDirPath, "themes")
userPackagesDirPath = fs.join(configDirPath, "packages")
configDirPath = fsUtils.absolute("~/.atom")
bundledPackagesDirPath = fsUtils.join(resourcePath, "src/packages")
bundledThemesDirPath = fsUtils.join(resourcePath, "themes")
vendoredPackagesDirPath = fsUtils.join(resourcePath, "vendor/packages")
vendoredThemesDirPath = fsUtils.join(resourcePath, "vendor/themes")
userThemesDirPath = fsUtils.join(configDirPath, "themes")
userPackagesDirPath = fsUtils.join(configDirPath, "packages")
module.exports =
class Config
@@ -26,34 +26,34 @@ class Config
core: _.clone(require('root-view').configDefaults)
editor: _.clone(require('editor').configDefaults)
@settings = {}
@configFilePath = fs.resolve(configDirPath, 'config', ['json', 'cson'])
@configFilePath ?= fs.join(configDirPath, 'config.cson')
@configFilePath = fsUtils.resolve(configDirPath, 'config', ['json', 'cson'])
@configFilePath ?= fsUtils.join(configDirPath, 'config.cson')
initializeConfigDirectory: ->
return if fs.exists(@configDirPath)
return if fsUtils.exists(@configDirPath)
fs.makeDirectory(@configDirPath)
fsUtils.makeDirectory(@configDirPath)
templateConfigDirPath = fs.resolve(window.resourcePath, 'dot-atom')
templateConfigDirPath = fsUtils.resolve(window.resourcePath, 'dot-atom')
onConfigDirFile = (path) =>
relativePath = path.substring(templateConfigDirPath.length + 1)
configPath = fs.join(@configDirPath, relativePath)
fs.write(configPath, fs.read(path))
fs.traverseTreeSync(templateConfigDirPath, onConfigDirFile, (path) -> true)
configPath = fsUtils.join(@configDirPath, relativePath)
fsUtils.write(configPath, fsUtils.read(path))
fsUtils.traverseTreeSync(templateConfigDirPath, onConfigDirFile, (path) -> true)
configThemeDirPath = fs.join(@configDirPath, 'themes')
configThemeDirPath = fsUtils.join(@configDirPath, 'themes')
onThemeDirFile = (path) ->
relativePath = path.substring(bundledThemesDirPath.length + 1)
configPath = fs.join(configThemeDirPath, relativePath)
fs.write(configPath, fs.read(path))
fs.traverseTreeSync(bundledThemesDirPath, onThemeDirFile, (path) -> true)
configPath = fsUtils.join(configThemeDirPath, relativePath)
fsUtils.write(configPath, fsUtils.read(path))
fsUtils.traverseTreeSync(bundledThemesDirPath, onThemeDirFile, (path) -> true)
load: ->
@initializeConfigDirectory()
@loadUserConfig()
loadUserConfig: ->
if fs.exists(@configFilePath)
if fsUtils.exists(@configFilePath)
try
userConfig = CSON.readObject(@configFilePath)
_.extend(@settings, userConfig)

28
src/app/cursor.coffee
View File

@@ -133,20 +133,20 @@ class Cursor
moveToFirstCharacterOfLine: ->
position = @getBufferPosition()
range = @getCurrentLineBufferRange()
scanRange = @getCurrentLineBufferRange()
newPosition = null
@editSession.scanInRange /^\s*/, range, (match, matchRange) =>
newPosition = matchRange.end
@editSession.scanInBufferRange /^\s*/, scanRange, ({range}) =>
newPosition = range.end
return unless newPosition
newPosition = [position.row, 0] if newPosition.isEqual(position)
@setBufferPosition(newPosition)
skipLeadingWhitespace: ->
position = @getBufferPosition()
range = @getCurrentLineBufferRange()
scanRange = @getCurrentLineBufferRange()
endOfLeadingWhitespace = null
@editSession.scanInRange /^[ \t]*/, range, (match, matchRange) =>
endOfLeadingWhitespace = matchRange.end
@editSession.scanInBufferRange /^[ \t]*/, scanRange, ({range}) =>
endOfLeadingWhitespace = range.end
@setBufferPosition(endOfLeadingWhitespace) if endOfLeadingWhitespace.isGreaterThan(position)
@@ -164,12 +164,12 @@ class Cursor
allowPrevious = options.allowPrevious ? true
currentBufferPosition = @getBufferPosition()
previousNonBlankRow = @editSession.buffer.previousNonBlankRow(currentBufferPosition.row)
range = [[previousNonBlankRow, 0], currentBufferPosition]
scanRange = [[previousNonBlankRow, 0], currentBufferPosition]
beginningOfWordPosition = null
@editSession.backwardsScanInRange (options.wordRegex ? @wordRegExp()), range, (match, matchRange, { stop }) =>
if matchRange.end.isGreaterThanOrEqual(currentBufferPosition) or allowPrevious
beginningOfWordPosition = matchRange.start
@editSession.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
if range.end.isGreaterThanOrEqual(currentBufferPosition) or allowPrevious
beginningOfWordPosition = range.start
if not beginningOfWordPosition?.isEqual(currentBufferPosition)
stop()
@@ -178,12 +178,12 @@ class Cursor
getEndOfCurrentWordBufferPosition: (options = {}) ->
allowNext = options.allowNext ? true
currentBufferPosition = @getBufferPosition()
range = [currentBufferPosition, @editSession.getEofBufferPosition()]
scanRange = [currentBufferPosition, @editSession.getEofBufferPosition()]
endOfWordPosition = null
@editSession.scanInRange (options.wordRegex ? @wordRegExp()), range, (match, matchRange, { stop }) =>
if matchRange.start.isLessThanOrEqual(currentBufferPosition) or allowNext
endOfWordPosition = matchRange.end
@editSession.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
if range.start.isLessThanOrEqual(currentBufferPosition) or allowNext
endOfWordPosition = range.end
if not endOfWordPosition?.isEqual(currentBufferPosition)
stop()

29
src/app/edit-session.coffee
View File

@@ -8,12 +8,14 @@ EventEmitter = require 'event-emitter'
Subscriber = require 'subscriber'
Range = require 'range'
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class EditSession
registerDeserializer(this)
@version: 1
@deserialize: (state) ->
session = project.buildEditSessionForBuffer(Buffer.deserialize(state.buffer))
if !session?
@@ -43,7 +45,7 @@ class EditSession
@buffer.retain()
@subscribe @buffer, "path-changed", =>
@project.setPath(fs.directory(@getPath())) unless @project.getPath()?
@project.setPath(fsUtils.directory(@getPath())) unless @project.getPath()?
@trigger "title-changed"
@trigger "path-changed"
@subscribe @buffer, "contents-conflicted", => @trigger "contents-conflicted"
@@ -55,21 +57,21 @@ class EditSession
@subscribe @displayBuffer, "changed", (e) =>
@trigger 'screen-lines-changed', e
@subscribe syntax, 'grammars-loaded', => @reloadGrammar()
@languageMode.on 'grammar-changed', => @handleGrammarChange()
getViewClass: ->
require 'editor'
getTitle: ->
if path = @getPath()
fs.base(path)
fsUtils.base(path)
else
'untitled'
getLongTitle: ->
if path = @getPath()
fileName = fs.base(path)
directory = fs.base(fs.directory(path))
fileName = fsUtils.base(path)
directory = fsUtils.base(fsUtils.directory(path))
"#{fileName} - #{directory}"
else
'untitled'
@@ -81,12 +83,14 @@ class EditSession
@buffer.release()
selection.destroy() for selection in @getSelections()
@displayBuffer.destroy()
@languageMode.destroy()
@project?.removeEditSession(this)
@trigger 'destroyed'
@off()
serialize: ->
deserializer: 'EditSession'
version: @constructor.version
buffer: @buffer.serialize()
scrollTop: @getScrollTop()
scrollLeft: @getScrollLeft()
@@ -160,8 +164,8 @@ class EditSession
bufferRangeForBufferRow: (row, options) -> @buffer.rangeForRow(row, options)
lineForBufferRow: (row) -> @buffer.lineForRow(row)
lineLengthForBufferRow: (row) -> @buffer.lineLengthForRow(row)
scanInRange: (args...) -> @buffer.scanInRange(args...)
backwardsScanInRange: (args...) -> @buffer.backwardsScanInRange(args...)
scanInBufferRange: (args...) -> @buffer.scanInRange(args...)
backwardsScanInBufferRange: (args...) -> @buffer.backwardsScanInRange(args...)
isModified: -> @buffer.isModified()
hasEditors: -> @buffer.hasEditors()
@@ -242,7 +246,7 @@ class EditSession
normalizeTabsInBufferRange: (bufferRange) ->
return unless @softTabs
@scanInRange /\t/, bufferRange, (match, range, {replace}) => replace(@getTabText())
@scanInBufferRange /\t/, bufferRange, ({replace}) => replace(@getTabText())
cutToEndOfLine: ->
maintainPasteboard = false
@@ -843,17 +847,14 @@ class EditSession
getGrammar: -> @languageMode.grammar
setGrammar: (grammar) ->
@languageMode.grammar = grammar
@handleGrammarChange()
@languageMode.setGrammar(grammar)
reloadGrammar: ->
@handleGrammarChange() if @languageMode.reloadGrammar()
@languageMode.reloadGrammar()
handleGrammarChange: ->
@unfoldAll()
@displayBuffer.tokenizedBuffer.resetScreenLines()
@trigger 'grammar-changed'
true
getDebugSnapshot: ->
[

19
src/app/editor.coffee
View File

@@ -6,7 +6,7 @@ Range = require 'range'
EditSession = require 'edit-session'
CursorView = require 'cursor-view'
SelectionView = require 'selection-view'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
$ = require 'jquery'
_ = require 'underscore'
@@ -319,8 +319,8 @@ class Editor extends View
lineForBufferRow: (row) -> @getBuffer().lineForRow(row)
lineLengthForBufferRow: (row) -> @getBuffer().lineLengthForRow(row)
rangeForBufferRow: (row) -> @getBuffer().rangeForRow(row)
scanInRange: (args...) -> @getBuffer().scanInRange(args...)
backwardsScanInRange: (args...) -> @getBuffer().backwardsScanInRange(args...)
scanInBufferRange: (args...) -> @getBuffer().scanInRange(args...)
backwardsScanInBufferRange: (args...) -> @getBuffer().backwardsScanInRange(args...)
configure: ->
@observeConfig 'editor.showLineNumbers', (showLineNumbers) => @gutter.setShowLineNumbers(showLineNumbers)
@@ -1102,7 +1102,7 @@ class Editor extends View
range.detach()
leftPixels
pixelOffsetForScreenPosition: (position) ->
pixelOffsUtilsetForScreenPosition: (position) ->
{top, left} = @pixelPositionForScreenPosition(position)
offset = @renderedLines.offset()
{top: top + offset.top, left: left + offset.left}
@@ -1151,16 +1151,9 @@ class Editor extends View
setGrammar: (grammar) ->
throw new Error("Only mini-editors can explicity set their grammar") unless @mini
@activeEditSession.setGrammar(grammar)
@handleGrammarChange()
reloadGrammar: ->
grammarChanged = @activeEditSession.reloadGrammar()
@handleGrammarChange() if grammarChanged
grammarChanged
handleGrammarChange: ->
@clearRenderedLines()
@updateDisplay()
@activeEditSession.reloadGrammar()
bindToKeyedEvent: (key, event, callback) ->
binding = {}
@@ -1185,7 +1178,7 @@ class Editor extends View
saveDebugSnapshot: ->
atom.showSaveDialog (path) =>
fs.write(path, @getDebugSnapshot()) if path
fsUtils.write(path, @getDebugSnapshot()) if path
getDebugSnapshot: ->
[

4
src/app/git.coffee
View File

@@ -1,5 +1,5 @@
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
Subscriber = require 'subscriber'
EventEmitter = require 'event-emitter'
RepositoryStatusTask = require 'repository-status-task'
@@ -48,7 +48,7 @@ class Git
refreshIndex: -> @getRepo().refreshIndex()
getPath: ->
@path ?= fs.absolute(@getRepo().getPath())
@path ?= fsUtils.absolute(@getRepo().getPath())
destroy: ->
if @statusTask?

8
src/app/keymap.coffee
View File

@@ -1,6 +1,6 @@
$ = require 'jquery'
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
CSON = require 'cson'
BindingSet = require 'binding-set'
@@ -32,13 +32,13 @@ class Keymap
$(document).command 'open-dev', => atom.openDev()
loadBundledKeymaps: ->
@loadDirectory(fs.resolveOnLoadPath('keymaps'))
@loadDirectory(fsUtils.resolveOnLoadPath('keymaps'))
loadUserKeymaps: ->
@loadDirectory(fs.join(config.configDirPath, 'keymaps'))
@loadDirectory(fsUtils.join(config.configDirPath, 'keymaps'))
loadDirectory: (directoryPath) ->
@load(filePath) for filePath in fs.list(directoryPath, ['.cson', '.json'])
@load(filePath) for filePath in fsUtils.list(directoryPath, ['.cson', '.json'])
load: (path) ->
@add(path, CSON.readObject(path))

28
src/app/language-mode.coffee
View File

@@ -2,24 +2,37 @@ Range = require 'range'
_ = require 'underscore'
require 'underscore-extensions'
{OnigRegExp} = require 'oniguruma'
EventEmitter = require 'event-emitter'
Subscriber = require 'subscriber'
module.exports =
class LanguageMode
buffer = null
grammar = null
editSession = null
currentGrammarScore: null
constructor: (@editSession) ->
@buffer = @editSession.buffer
@reloadGrammar()
@subscribe syntax, 'grammar-added', (grammar) =>
newScore = grammar.getScore(@buffer.getPath(), @buffer.getText())
@setGrammar(grammar, newScore) if newScore > @currentGrammarScore
destroy: ->
@unsubscribe()
setGrammar: (grammar, score) ->
return if grammar is @grammar
@grammar = grammar
@currentGrammarScore = score ? grammar.getScore(@buffer.getPath(), @buffer.getText())
@trigger 'grammar-changed', grammar
reloadGrammar: ->
path = @buffer.getPath()
pathContents = @buffer.cachedDiskContents
previousGrammar = @grammar
@grammar = syntax.selectGrammar(path, pathContents)
throw new Error("No grammar found for path: #{path}") unless @grammar
previousGrammar isnt @grammar
if grammar = syntax.selectGrammar(@buffer.getPath(), @buffer.getText())
@setGrammar(grammar)
else
throw new Error("No grammar found for path: #{path}")
toggleLineCommentsForBufferRows: (start, end) ->
scopes = @editSession.scopesForBufferPosition([start, 0])
@@ -158,3 +171,6 @@ class LanguageMode
foldEndRegexForScopes: (scopes) ->
if foldEndPattern = syntax.getProperty(scopes, 'editor.foldEndPattern')
new OnigRegExp(foldEndPattern)
_.extend LanguageMode.prototype, EventEmitter
_.extend LanguageMode.prototype, Subscriber

2
src/app/null-grammar.coffee
View File

@@ -5,5 +5,7 @@ class NullGrammar
name: 'Null Grammar'
scopeName: 'text.plain.null-grammar'
getScore: -> 0
tokenizeLine: (line) ->
{ tokens: [new Token(value: line, scopes: ['null-grammar.text.plain'])] }

4
src/app/package.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class Package
@@ -20,4 +20,4 @@ class Package
path: null
constructor: (@path) ->
@name = fs.base(@path)
@name = fsUtils.base(@path)

15
src/app/project.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
$ = require 'jquery'
Range = require 'range'
@@ -41,7 +41,7 @@ class Project
@rootDirectory?.off()
if path?
directory = if fs.isDirectory(path) then path else fs.directory(path)
directory = if fsUtils.isDirectory(path) then path else fsUtils.directory(path)
@rootDirectory = new Directory(directory)
else
@rootDirectory = null
@@ -56,7 +56,7 @@ class Project
paths = []
onFile = (path) => paths.push(path) unless @isPathIgnored(path)
onDirectory = -> true
fs.traverseTreeSync(@getPath(), onFile, onDirectory)
fsUtils.traverseTreeSync(@getPath(), onFile, onDirectory)
deferred.resolve(paths)
deferred.promise()
@@ -68,11 +68,11 @@ class Project
@ignoreRepositoryPath(path)
ignoreRepositoryPath: (path) ->
config.get("core.hideGitIgnoredFiles") and git?.isPathIgnored(fs.join(@getPath(), path))
config.get("core.hideGitIgnoredFiles") and git?.isPathIgnored(fsUtils.join(@getPath(), path))
resolve: (filePath) ->
filePath = fs.join(@getPath(), filePath) unless filePath[0] == '/'
fs.absolute filePath
filePath = fsUtils.join(@getPath(), filePath) unless filePath[0] == '/'
fsUtils.absolute filePath
relativize: (fullPath) ->
return fullPath unless fullPath.lastIndexOf(@getPath()) is 0
@@ -191,8 +191,9 @@ class Project
readPath(line) if state is 'readingPath'
readLine(line) if state is 'readingLines'
command = require.resolve('ag')
command = require.resolve('nak')
args = ['--ackmate', regex.source, @getPath()]
args.unshift("--addVCSIgnores") if config.get('core.excludeVcsIgnoredPaths')
new BufferedProcess({command, args, stdout, exit})
deferred

4
src/app/repository-status-handler.coffee
View File

@@ -1,5 +1,5 @@
Git = require 'git-utils'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
loadStatuses: (path) ->
@@ -8,7 +8,7 @@ module.exports =
workingDirectoryPath = repo.getWorkingDirectory()
statuses = {}
for path, status of repo.getStatus()
statuses[fs.join(workingDirectoryPath, path)] = status
statuses[fsUtils.join(workingDirectoryPath, path)] = status
upstream = repo.getAheadBehindCount()
repo.release()
else

7
src/app/root-view.coffee
View File

@@ -1,6 +1,6 @@
$ = require 'jquery'
{$$} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
_ = require 'underscore'
{View} = require 'space-pen'
@@ -82,7 +82,7 @@ class RootView extends View
@getActivePane().focus()
false
else
@setTitle(null)
@updateTitle()
focusableChild = this.find("[tabindex=-1]:visible:first")
if focusableChild.length
focusableChild.focus()
@@ -115,7 +115,7 @@ class RootView extends View
if item = @getActivePaneItem()
@setTitle("#{item.getTitle?() ? 'untitled'} - #{projectPath}")
else
@setTitle(projectPath)
@setTitle("atom - #{projectPath}")
else
@setTitle('untitled')
@@ -174,4 +174,3 @@ class RootView extends View
eachBuffer: (callback) ->
project.eachBuffer(callback)

62
src/app/syntax.coffee
View File

@@ -2,11 +2,9 @@ _ = require 'underscore'
jQuery = require 'jquery'
Specificity = require 'specificity'
{$$} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
EventEmitter = require 'event-emitter'
NullGrammar = require 'null-grammar'
nodePath = require 'path'
pathSplitRegex = new RegExp("[#{nodePath.sep}.]")
module.exports =
class Syntax
@@ -18,27 +16,24 @@ class Syntax
syntax
constructor: ->
@grammars = []
@grammarsByFileType = {}
@nullGrammar = new NullGrammar
@grammars = [@nullGrammar]
@grammarsByScopeName = {}
@grammarOverridesByPath = {}
@scopedPropertiesIndex = 0
@scopedProperties = []
@nullGrammar = new NullGrammar
serialize: ->
{ deserializer: @constructor.name, @grammarOverridesByPath }
addGrammar: (grammar) ->
@grammars.push(grammar)
@grammarsByFileType[fileType] = grammar for fileType in grammar.fileTypes
@grammarsByScopeName[grammar.scopeName] = grammar
@trigger 'grammar-added', grammar
removeGrammar: (grammar) ->
if _.include(@grammars, grammar)
_.remove(@grammars, grammar)
delete @grammarsByFileType[fileType] for fileType in grammar.fileTypes
delete @grammarsByScopeName[grammar.scopeName]
_.remove(@grammars, grammar)
delete @grammarsByScopeName[grammar.scopeName]
setGrammarOverrideForPath: (path, scopeName) ->
@grammarOverridesByPath[path] = scopeName
@@ -50,51 +45,10 @@ class Syntax
@grammarOverridesByPath = {}
selectGrammar: (filePath, fileContents) ->
return @grammarsByFileType["txt"] ? @nullGrammar unless filePath
@grammarOverrideForPath(filePath) ?
@grammarByFirstLineRegex(filePath, fileContents) ?
@grammarByPath(filePath) ?
@grammarsByFileType["txt"] ?
@nullGrammar
_.max @grammars, (grammar) -> grammar.getScore(filePath, fileContents)
grammarOverrideForPath: (path) ->
@grammarsByScopeName[@grammarOverridesByPath[path]]
grammarByPath: (path) ->
pathComponents = path.split(pathSplitRegex)
for fileType, grammar of @grammarsByFileType
fileTypeComponents = fileType.split(pathSplitRegex)
pathSuffix = pathComponents[-fileTypeComponents.length..-1]
return grammar if _.isEqual(pathSuffix, fileTypeComponents)
grammarByFirstLineRegex: (filePath, fileContents) ->
try
fileContents ?= fs.read(filePath)
catch e
return
return unless fileContents
lines = fileContents.split('\n')
_.find @grammars, (grammar) ->
regex = grammar.firstLineRegex
return unless regex?
escaped = false
numberOfNewlinesInRegex = 0
for character in regex.source
switch character
when '\\'
escaped = !escaped
when 'n'
numberOfNewlinesInRegex++ if escaped
escaped = false
else
escaped = false
regex.test(lines[0..numberOfNewlinesInRegex].join('\n'))
@grammarOverridesByPath[path]
grammarForScopeName: (scopeName) ->
@grammarsByScopeName[scopeName]

9
src/app/text-buffer.coffee
View File

@@ -1,5 +1,5 @@
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
File = require 'file'
Point = require 'point'
Range = require 'range'
@@ -37,9 +37,8 @@ class Buffer
@lineEndings = []
if path
# throw "Path '#{path}' does not exist" unless fs.exists(path)
if fs.exists(path)
@setPath(path)
throw "Path '#{path}' does not exist" unless fsUtils.exists(path)
@setPath(path)
if initialText?
@setText(initialText)
@updateCachedDiskContents()
@@ -406,7 +405,7 @@ class Buffer
range = new Range(startPosition, endPosition)
keepLooping = true
replacementText = null
iterator(match, range, { stop, replace })
iterator({match, range, stop, replace })
if replacementText?
@change(range, replacementText)

48
src/app/text-mate-grammar.coffee
View File

@@ -1,24 +1,25 @@
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
plist = require 'plist'
Token = require 'token'
CSON = require 'cson'
{OnigRegExp, OnigScanner} = require 'oniguruma'
nodePath = require 'path'
pathSplitRegex = new RegExp("[#{nodePath.sep}.]")
module.exports =
class TextMateGrammar
@readFromPath: (path) ->
fs.readPlist(path)
fsUtils.readPlist(path)
@load: (path, done) ->
fs.readObjectAsync path, (err, object) ->
fsUtils.readObjectAsync path, (err, object) ->
if err
done(err)
else
done(null, new TextMateGrammar(object))
@loadSync: (path) ->
new TextMateGrammar(fs.readObject(path))
new TextMateGrammar(fsUtils.readObject(path))
name: null
fileTypes: null
@@ -38,6 +39,43 @@ class TextMateGrammar
data = {patterns: [data], tempName: name} if data.begin? or data.match?
@repository[name] = new Rule(this, data)
getScore: (path, contents) ->
contents = fsUtils.read(path) if not contents? and fsUtils.isFile(path)
if syntax.grammarOverrideForPath(path) is @scopeName
3
else if @matchesContents(contents)
2
else if @matchesPath(path)
1
else
-1
matchesContents: (contents) ->
return false unless contents? and @firstLineRegex?
escaped = false
numberOfNewlinesInRegex = 0
for character in @firstLineRegex.source
switch character
when '\\'
escaped = !escaped
when 'n'
numberOfNewlinesInRegex++ if escaped
escaped = false
else
escaped = false
lines = contents.split('\n')
@firstLineRegex.test(lines[0..numberOfNewlinesInRegex].join('\n'))
matchesPath: (path) ->
return false unless path?
pathComponents = path.split(pathSplitRegex)
_.find @fileTypes, (fileType) ->
fileTypeComponents = fileType.split(pathSplitRegex)
pathSuffix = pathComponents[-fileTypeComponents.length..-1]
_.isEqual(pathSuffix, fileTypeComponents)
tokenizeLine: (line, ruleStack=[@initialRule], firstLine=false) ->
originalRuleStack = ruleStack
ruleStack = new Array(ruleStack...) # clone ruleStack

1
src/app/text-mate-package.coffee
View File

@@ -13,7 +13,6 @@ class TextMatePackage extends Package
@getLoadQueue: ->
return @loadQueue if @loadQueue
@loadQueue = async.queue (pack, done) -> pack.loadGrammars(done)
@loadQueue.drain = -> syntax.trigger 'grammars-loaded'
@loadQueue
constructor: ->

2
src/app/text-mate-theme.coffee
View File

@@ -1,5 +1,5 @@
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
plist = require 'plist'
Theme = require 'theme'

6
src/app/theme.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class Theme
@@ -8,10 +8,10 @@ class Theme
TextMateTheme = require 'text-mate-theme'
AtomTheme = require 'atom-theme'
if fs.exists(name)
if fsUtils.exists(name)
path = name
else
path = fs.resolve(config.themeDirPaths..., name, ['', '.tmTheme', '.css', 'less'])
path = fsUtils.resolve(config.themeDirPaths..., name, ['', '.tmTheme', '.css', 'less'])
throw new Error("No theme exists named '#{name}'") unless path

1
src/app/tokenized-buffer.coffee
View File

@@ -23,6 +23,7 @@ class TokenizedBuffer
@id = @constructor.idCounter++
@resetScreenLines()
@buffer.on "changed.tokenized-buffer#{@id}", (e) => @handleBufferChange(e)
@languageMode.on 'grammar-changed', => @resetScreenLines()
resetScreenLines: ->
@screenLines = @buildPlaceholderScreenLinesForRows(0, @buffer.getLastRow())

31
src/app/window.coffee
View File

@@ -1,8 +1,8 @@
fs = require 'fs-utils'
fs = require 'fs'
fsUtils = require 'fs-utils'
$ = require 'jquery'
_ = require 'underscore'
{less} = require 'less'
{spawn} = require 'child_process'
require 'jquery-extensions'
require 'underscore-extensions'
require 'space-pen-extensions'
@@ -32,14 +32,14 @@ window.setUpEnvironment = ->
requireStylesheet 'notification'
requireStylesheet 'markdown'
if nativeStylesheetPath = fs.resolveOnLoadPath(process.platform, ['css', 'less'])
if nativeStylesheetPath = fsUtils.resolveOnLoadPath(process.platform, ['css', 'less'])
requireStylesheet(nativeStylesheetPath)
# This method is only called when opening a real application window
window.startup = ->
directory = _.find ['/opt/boxen', '/opt/github', '/usr/local'], (dir) -> fs.isDirectory(dir)
directory = _.find ['/opt/boxen', '/opt/github', '/usr/local'], (dir) -> fsUtils.isDirectory(dir)
if directory
installAtomCommand(fs.join(directory, 'bin/atom'))
installAtomCommand(fsUtils.join(directory, 'bin/atom'))
else
console.warn "Failed to install `atom` binary"
@@ -73,18 +73,19 @@ window.shutdown = ->
window.git = null
window.installAtomCommand = (commandPath) ->
return if fs.exists(commandPath)
return if fsUtils.exists(commandPath)
bundledCommandPath = fs.resolve(window.resourcePath, 'atom.sh')
bundledCommandPath = fsUtils.resolve(window.resourcePath, 'atom.sh')
if bundledCommandPath?
fs.write(commandPath, fs.read(bundledCommandPath))
spawn('chmod', ['u+x', commandPath])
fsUtils.write(commandPath, fsUtils.read(bundledCommandPath))
fs.chmod(commandPath, 0o755, commandPath)
window.handleWindowEvents = ->
$(window).command 'window:toggle-full-screen', => atom.toggleFullScreen()
$(window).on 'focus', -> $("body").removeClass('is-blurred')
$(window).on 'blur', -> $("body").addClass('is-blurred')
$(window).command 'window:close', => confirmClose()
$(window).command 'window:reload', => reload()
window.deserializeWindowState = ->
RootView = require 'root-view'
@@ -99,7 +100,7 @@ window.deserializeWindowState = ->
window.project = deserialize(windowState.project) ? new Project(pathToOpen)
window.rootView = deserialize(windowState.rootView) ? new RootView
if !windowState.rootView and (!pathToOpen or fs.isFile(pathToOpen))
if !windowState.rootView and (!pathToOpen or fsUtils.isFile(pathToOpen))
rootView.open(pathToOpen)
$(rootViewParentSelector).append(rootView)
@@ -113,10 +114,10 @@ window.stylesheetElementForId = (id) ->
$("head style[id='#{id}']")
window.resolveStylesheet = (path) ->
if fs.extension(path).length > 0
fs.resolveOnLoadPath(path)
if fsUtils.extension(path).length > 0
fsUtils.resolveOnLoadPath(path)
else
fs.resolveOnLoadPath(path, ['css', 'less'])
fsUtils.resolveOnLoadPath(path, ['css', 'less'])
window.requireStylesheet = (path) ->
if fullPath = window.resolveStylesheet(path)
@@ -126,8 +127,8 @@ window.requireStylesheet = (path) ->
throw new Error("Could not find a file at path '#{path}'")
window.loadStylesheet = (path) ->
content = fs.read(path)
if fs.extension(path) == '.less'
content = fsUtils.read(path)
if fsUtils.extension(path) == '.less'
(new less.Parser).parse content, (e, tree) ->
throw new Error(e.message, path, e.line) if e
content = tree.toCSS()

2
src/packages/autocomplete/lib/autocomplete-view.coffee
View File

@@ -144,7 +144,7 @@ class AutocompleteView extends SelectList
lineRange = [[selectionRange.start.row, 0], [selectionRange.end.row, @editor.lineLengthForBufferRow(selectionRange.end.row)]]
[prefix, suffix] = ["", ""]
@currentBuffer.scanInRange @wordRegex, lineRange, (match, range, {stop}) ->
@currentBuffer.scanInRange @wordRegex, lineRange, ({match, range, stop}) ->
stop() if range.start.isGreaterThan(selectionRange.end)
if range.intersectsWith(selectionRange)

5
src/packages/bracket-matcher/lib/bracket-matcher.coffee
View File

@@ -122,7 +122,7 @@ module.exports =
regex = new RegExp("[#{_.escapeRegExp(startPair + endPair)}]", 'g')
endPairPosition = null
unpairedCount = 0
buffer.scanInRange regex, scanRange, (match, range, {stop}) =>
buffer.scanInRange regex, scanRange, ({match, range, stop}) =>
if match[0] is startPair
unpairedCount++
else if match[0] is endPair
@@ -136,14 +136,13 @@ module.exports =
regex = new RegExp("[#{_.escapeRegExp(startPair + endPair)}]", 'g')
startPairPosition = null
unpairedCount = 0
scanner = (match, range, {stop}) =>
buffer.backwardsScanInRange regex, scanRange, ({match, range, stop}) =>
if match[0] is endPair
unpairedCount++
else if match[0] is startPair
unpairedCount--
startPairPosition = range.start
stop() if unpairedCount < 0
buffer.scanInRange(regex, scanRange, scanner, true)
startPairPosition
updateMatch: (editor) ->

4
src/packages/command-panel/lib/command-interpreter.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
PEG = require 'pegjs'
module.exports =
@@ -6,7 +6,7 @@ class CommandInterpreter
constructor: (@project) ->
eval: (string, activeEditSession) ->
@parser ?= PEG.buildParser(fs.read(require.resolve 'command-panel/lib/commands.pegjs'))
@parser ?= PEG.buildParser(fsUtils.read(require.resolve 'command-panel/lib/commands.pegjs'))
compositeCommand = @parser.parse(string)
@lastRelativeAddress = compositeCommand if compositeCommand.isRelativeAddress()
compositeCommand.execute(@project, activeEditSession)

2
src/packages/command-panel/lib/command-panel-view.coffee
View File

@@ -120,6 +120,8 @@ class CommandPanelView extends View
execute: (command=@escapedCommand()) ->
@loadingMessage.show()
@previewList.hide()
@previewHeader.hide()
@errorMessages.empty()
try

4
src/packages/command-panel/lib/commands/regex-address.coffee
View File

@@ -24,12 +24,12 @@ class RegexAddress extends Address
rangeToReturn = null
scanMethodName = if @isReversed then "backwardsScanInRange" else "scanInRange"
buffer[scanMethodName] @regex, rangeToSearch, (match, range) ->
buffer[scanMethodName] @regex, rangeToSearch, ({range}) ->
rangeToReturn = range
if not rangeToReturn
rangeToSearch = if @isReversed then rangeAfter else rangeBefore
buffer[scanMethodName] @regex, rangeToSearch, (match, range) ->
buffer[scanMethodName] @regex, rangeToSearch, ({range}) ->
rangeToReturn = range
if not rangeToReturn

2
src/packages/command-panel/lib/commands/select-all-matches-in-project.coffee
View File

@@ -8,7 +8,7 @@ class SelectAllMatchesInProject extends Command
previewOperations: true
constructor: (pattern) ->
@regex = new RegExp(pattern, 'g')
@regex = new RegExp(pattern)
compile: (project, buffer, range) ->
deferred = $.Deferred()

6
src/packages/command-panel/lib/commands/select-all-matches.coffee
View File

@@ -12,12 +12,12 @@ class SelectAllMatches extends Command
compile: (project, buffer, ranges) ->
deferred = $.Deferred()
operations = []
for range in ranges
buffer.scanInRange @regex, range, (match, matchRange) ->
for scanRange in ranges
buffer.scanInRange @regex, scanRange, ({range}) ->
operations.push(new Operation(
project: project
buffer: buffer
bufferRange: matchRange
bufferRange: range
))
deferred.resolve(operations)
deferred.promise()

6
src/packages/command-panel/lib/commands/substitution.coffee
View File

@@ -15,12 +15,12 @@ class Substitution extends Command
compile: (project, buffer, ranges) ->
deferred = $.Deferred()
operations = []
for range in ranges
buffer.scanInRange @regex, range, (match, matchRange) =>
for scanRange in ranges
buffer.scanInRange @regex, scanRange, ({range}) =>
operations.push(new Operation(
project: project
buffer: buffer
bufferRange: matchRange
bufferRange: range
newText: @replacementText
preserveSelection: true
))

2
src/packages/command-panel/lib/operation.coffee
View File

@@ -23,7 +23,7 @@ class Operation
@getBufferRange() unless @preserveSelection
preview: ->
range = @getBuffer().getMarkerRange(@getMarker())
range = @getBufferRange()
line = @getBuffer().lineForRow(range.start.row)
prefix = line[0...range.start.column]
match = line[range.start.column...range.end.column]

38
src/packages/command-panel/lib/path-view.coffee
View File

@@ -1,5 +1,5 @@
{View} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
OperationView = require './operation-view'
$ = require 'jquery'
@@ -7,7 +7,7 @@ module.exports =
class PathView extends View
@content: ({path, previewList} = {}) ->
classes = ['path']
classes.push('readme') if fs.isReadmePath(path)
classes.push('readme') if fsUtils.isReadmePath(path)
@li class: classes.join(' '), =>
@div outlet: 'pathDetails', class: 'path-details', =>
@span class: 'path-name', path
@@ -17,9 +17,11 @@ class PathView extends View
initialize: ({@previewList}) ->
@pathDetails.on 'mousedown', => @toggle(true)
@subscribe @previewList, 'command-panel:collapse-result', =>
@collapse(true) if @isSelected()
if @isSelected()
@collapse()
@previewList.renderOperations()
@subscribe @previewList, 'command-panel:expand-result', =>
@expand(true) if @isSelected()
@expand() if @isSelected()
@subscribe @previewList, 'core:confirm', =>
if @hasClass('selected')
@toggle(true)
@@ -36,30 +38,22 @@ class PathView extends View
@previewList.find('.selected').removeClass('selected')
@addClass('selected')
toggle: (animate) ->
toggle: ->
if @hasClass('is-collapsed')
@expand(animate)
@expand()
else
@collapse(animate)
@collapse()
expand: (animate=false) ->
if animate
@matches.show 100, => @removeClass 'is-collapsed'
else
@matches.show()
@removeClass 'is-collapsed'
expand: ->
@matches.show()
@removeClass 'is-collapsed'
scrollTo: ->
top = @previewList.scrollTop() + @offset().top - @previewList.offset().top
bottom = top + @pathDetails.outerHeight()
@previewList.scrollTo(top, bottom)
collapse: (animate=false) ->
if animate
@matches.hide 100, =>
@addClass 'is-collapsed'
@setSelected() if @isSelected()
else
@matches.hide()
@addClass 'is-collapsed'
@setSelected() if @isSelected()
collapse: ->
@matches.hide()
@addClass 'is-collapsed'
@setSelected() if @isSelected()

6
src/packages/command-panel/lib/preview-list.coffee
View File

@@ -1,7 +1,6 @@
$ = require 'jquery'
ScrollView = require 'scroll-view'
_ = require 'underscore'
fs = require 'fs-utils'
PathView = require './path-view'
OperationView = require './operation-view'
@@ -21,8 +20,7 @@ class PreviewList extends ScrollView
@on 'core:move-down', => @selectNextOperation(); false
@on 'core:move-up', => @selectPreviousOperation(); false
@on 'scroll', =>
@renderOperations() if @scrollBottom() >= (@prop('scrollHeight'))
@renderOperations() if @scrollBottom() >= @prop('scrollHeight')
@command 'command-panel:collapse-all', => @collapseAllPaths()
@command 'command-panel:expand-all', => @expandAllPaths()
@@ -114,6 +112,8 @@ class PreviewList extends ScrollView
@scrollTop(top) if top < @scrollTop()
scrollToBottom: ->
@renderOperations(renderAll: true)
super()
@find('.selected').removeClass('selected')

22
src/packages/command-panel/spec/preview-list-spec.coffee
View File

@@ -43,3 +43,25 @@ describe "Preview List", ->
previousOperationCount = previewList.find("li").length
previewList.collapseAllPaths()
expect(previewList.find("li").length).toBeGreaterThan previousOperationCount
it "renders more operations when a preview item is collapsed", ->
waitsForPromise ->
commandPanelView.execute('X x/so/')
runs ->
expect(previewList.prop('scrollHeight')).toBeGreaterThan previewList.height()
previousScrollHeight = previewList.prop('scrollHeight')
previousOperationCount = previewList.find("li").length
previewList.trigger 'command-panel:collapse-result'
expect(previewList.find("li").length).toBeGreaterThan previousOperationCount
it "renders all operations when core:move-to-bottom is triggered", ->
waitsForPromise ->
commandPanelView.execute('X x/so/')
runs ->
expect(previewList.prop('scrollHeight')).toBeGreaterThan previewList.height()
previousScrollHeight = previewList.prop('scrollHeight')
previewList.trigger 'core:move-to-bottom'
liCount = previewList.getPathCount() + previewList.getOperations().length
expect(previewList.find("li").length).toBe liCount

22
src/packages/fuzzy-finder/lib/fuzzy-finder-view.coffee
View File

@@ -2,7 +2,7 @@
SelectList = require 'select-list'
_ = require 'underscore'
$ = require 'jquery'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
LoadPathsTask = require './load-paths-task'
module.exports =
@@ -45,22 +45,22 @@ class FuzzyFinderView extends SelectList
else if git.isStatusModified(status)
@div class: 'status modified'
ext = fs.extension(path)
if fs.isReadmePath(path)
ext = fsUtils.extension(path)
if fsUtils.isReadmePath(path)
typeClass = 'readme-name'
else if fs.isCompressedExtension(ext)
else if fsUtils.isCompressedExtension(ext)
typeClass = 'compressed-name'
else if fs.isImageExtension(ext)
else if fsUtils.isImageExtension(ext)
typeClass = 'image-name'
else if fs.isPdfExtension(ext)
else if fsUtils.isPdfExtension(ext)
typeClass = 'pdf-name'
else if fs.isBinaryExtension(ext)
else if fsUtils.isBinaryExtension(ext)
typeClass = 'binary-name'
else
typeClass = 'text-name'
@span fs.base(path), class: "file label #{typeClass}"
if folder = project.relativize(fs.directory(path))
@span fsUtils.base(path), class: "file label #{typeClass}"
if folder = project.relativize(fsUtils.directory(path))
@span " - #{folder}/", class: 'directory'
openPath: (path) ->
@@ -76,7 +76,7 @@ class FuzzyFinderView extends SelectList
confirmed : (path) ->
return unless path.length
if fs.isFile(path)
if fsUtils.isFile(path)
@cancel()
@openPath(path)
else
@@ -134,7 +134,7 @@ class FuzzyFinderView extends SelectList
populateGitStatusPaths: ->
paths = []
paths.push(path) for path, status of git.statuses when fs.isFile(path)
paths.push(path) for path, status of git.statuses when fsUtils.isFile(path)
@setArray(paths)

36
src/packages/fuzzy-finder/lib/load-paths-task.coffee
View File

@@ -1,33 +1,33 @@
_ = require 'underscore'
fs = require 'fs-utils'
BufferedProcess = require 'buffered-process'
module.exports =
class LoadPathsTask
aborted: false
constructor: (@callback) ->
start: ->
rootPath = project.getPath()
ignoredNames = config.get('fuzzyFinder.ignoredNames') ? []
ignoredNames = ignoredNames.concat(config.get('core.ignoredNames') ? [])
ignoreGitIgnoredFiles = config.get('core.hideGitIgnoredFiles')
command = require.resolve 'nak'
args = ['--list', rootPath]
args.unshift('--addVCSIgnores') if config.get('core.excludeVcsIgnoredPaths')
args.unshift('--ignore', ignoredNames.join(',')) if ignoredNames.length > 0
args.unshift('--follow')
paths = []
isIgnored = (path) ->
path = path.substring(rootPath.length + 1)
for segment in path.split('/')
return true if _.contains(ignoredNames, segment)
ignoreGitIgnoredFiles and git?.isPathIgnored(fs.join(rootPath, path))
onFile = (path) ->
return if @aborted
paths.push(path) unless isIgnored(path)
onDirectory = (path) =>
not @aborted and not isIgnored(path)
onDone = =>
@callback(paths) unless @aborted
exit = (code) =>
if code is 0
@callback(paths)
else
@callback([])
stdout = (data) ->
paths.push(_.compact(data.split('\n'))...)
fs.traverseTree(rootPath, onFile, onDirectory, onDone)
@process = new BufferedProcess({command, args, stdout, exit})
abort: ->
@aborted = true
if @process?
@process.kill()
@process = null

37
src/packages/fuzzy-finder/spec/fuzzy-finder-spec.coffee
View File

@@ -4,7 +4,7 @@ LoadPathsTask = require 'fuzzy-finder/lib/load-paths-task'
_ = require 'underscore'
$ = require 'jquery'
{$$} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe 'FuzzyFinder', ->
[finderView] = []
@@ -43,7 +43,6 @@ describe 'FuzzyFinder', ->
it "shows all relative file paths for the current project and selects the first", ->
rootView.attachToDom()
finderView.maxItems = Infinity
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:toggle-file-finder'
paths = null
expect(finderView.find(".loading")).toBeVisible()
@@ -57,10 +56,21 @@ describe 'FuzzyFinder', ->
runs ->
expect(finderView.list.children('li').length).toBe paths.length
for path in paths
expect(finderView.list.find("li:contains(#{fs.base(path)})")).toExist()
expect(finderView.list.find("li:contains(#{fsUtils.base(path)})")).toExist()
expect(finderView.list.children().first()).toHaveClass 'selected'
expect(finderView.find(".loading")).not.toBeVisible()
it "includes symlinked file paths", ->
rootView.attachToDom()
finderView.maxItems = Infinity
rootView.trigger 'fuzzy-finder:toggle-file-finder'
waitsFor "all project paths to load", 5000, ->
not finderView.reloadProjectPaths
runs ->
expect(finderView.list.find("li:contains(symlink-to-file)")).toExist()
describe "when root view's project has no path", ->
beforeEach ->
project.setPath(null)
@@ -218,16 +228,16 @@ describe 'FuzzyFinder', ->
editor = rootView.getActiveView()
originalText = editor.getText()
originalPath = editor.getPath()
fs.write(originalPath, 'making a change for the better')
fsUtils.write(originalPath, 'making a change for the better')
git.getPathStatus(originalPath)
newPath = project.resolve('newsample.js')
fs.write(newPath, '')
fsUtils.write(newPath, '')
git.getPathStatus(newPath)
afterEach ->
fs.write(originalPath, originalText)
fs.remove(newPath) if fs.exists(newPath)
fsUtils.write(originalPath, originalText)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
it "displays all new and modified paths", ->
expect(rootView.find('.fuzzy-finder')).not.toExist()
@@ -280,7 +290,6 @@ describe 'FuzzyFinder', ->
describe "cached file paths", ->
it "caches file paths after first time", ->
spyOn(LoadPathsTask.prototype, "start").andCallThrough()
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:toggle-file-finder'
waitsFor ->
@@ -300,7 +309,6 @@ describe 'FuzzyFinder', ->
it "doesn't cache buffer paths", ->
spyOn(project, "getEditSessions").andCallThrough()
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:toggle-buffer-finder'
waitsFor ->
@@ -320,7 +328,6 @@ describe 'FuzzyFinder', ->
it "busts the cache when the window gains focus", ->
spyOn(LoadPathsTask.prototype, "start").andCallThrough()
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:toggle-file-finder'
waitsFor ->
@@ -337,7 +344,6 @@ describe 'FuzzyFinder', ->
describe "path ignoring", ->
it "ignores paths that match entries in config.fuzzyFinder.ignoredNames", ->
config.set("fuzzyFinder.ignoredNames", ["tree-view.js"])
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:toggle-file-finder'
finderView.maxItems = Infinity
@@ -356,7 +362,6 @@ describe 'FuzzyFinder', ->
it "opens the fuzzy finder window when there are multiple matches", ->
editor.setText("sample")
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:find-under-cursor'
waitsFor ->
@@ -368,7 +373,6 @@ describe 'FuzzyFinder', ->
it "opens a file directly when there is a single match", ->
editor.setText("sample.txt")
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:find-under-cursor'
openedPath = null
@@ -386,7 +390,6 @@ describe 'FuzzyFinder', ->
editor.setText("moogoogaipan")
editor.setCursorBufferPosition([0,5])
jasmine.unspy(window, "setTimeout")
rootView.trigger 'fuzzy-finder:find-under-cursor'
waitsFor ->
@@ -468,11 +471,11 @@ describe 'FuzzyFinder', ->
originalText = editor.getText()
originalPath = editor.getPath()
newPath = project.resolve('newsample.js')
fs.write(newPath, '')
fsUtils.write(newPath, '')
afterEach ->
fs.write(originalPath, originalText)
fs.remove(newPath) if fs.exists(newPath)
fsUtils.write(originalPath, originalText)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
describe "when a modified file is shown in the list", ->
it "displays the modified icon", ->

2
src/packages/grammar-selector/lib/grammar-selector.coffee
View File

@@ -61,4 +61,4 @@ class GrammarSelector extends SelectList
attach: ->
super
rootView.append(this)
@miniEditor.focus()
@miniEditor.focus()

1
src/packages/markdown-preview/lib/markdown-preview-view.coffee
View File

@@ -1,4 +1,3 @@
fs = require 'fs-utils'
$ = require 'jquery'
ScrollView = require 'scroll-view'
{$$$} = require 'space-pen'

30
src/packages/package-generator/lib/package-generator-view.coffee
View File

@@ -2,7 +2,7 @@
Editor = require 'editor'
$ = require 'jquery'
_ = require 'underscore'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class PackageGeneratorView extends View
@@ -24,7 +24,7 @@ class PackageGeneratorView extends View
@previouslyFocusedElement = $(':focus')
@message.text("Enter package path")
placeholderName = "package-name"
@miniEditor.setText(fs.join(config.userPackagesDirPath, placeholderName));
@miniEditor.setText(fsUtils.join(config.userPackagesDirPath, placeholderName));
pathLength = @miniEditor.getText().length
@miniEditor.setSelectedBufferRange([[0, pathLength - placeholderName.length], [0, pathLength]])
@@ -44,11 +44,11 @@ class PackageGeneratorView extends View
getPackagePath: ->
packagePath = @miniEditor.getText()
packageName = _.dasherize(fs.base(packagePath))
fs.join(fs.directory(packagePath), packageName)
packageName = _.dasherize(fsUtils.base(packagePath))
fsUtils.join(fsUtils.directory(packagePath), packageName)
validPackagePath: ->
if fs.exists(@getPackagePath())
if fsUtils.exists(@getPackagePath())
@error.text("Path already exists at '#{@getPackagePath()}'")
@error.show()
false
@@ -56,22 +56,22 @@ class PackageGeneratorView extends View
true
createPackageFiles: ->
templatePath = fs.resolveOnLoadPath(fs.join("package-generator", "template"))
packageName = fs.base(@getPackagePath())
templatePath = fsUtils.resolveOnLoadPath(fsUtils.join("package-generator", "template"))
packageName = fsUtils.base(@getPackagePath())
for path in fs.listTree(templatePath)
for path in fsUtils.listTree(templatePath)
relativePath = path.replace(templatePath, "")
relativePath = relativePath.replace(/^\//, '')
relativePath = relativePath.replace(/\.template$/, '')
relativePath = @replacePackageNamePlaceholders(relativePath, packageName)
sourcePath = fs.join(@getPackagePath(), relativePath)
if fs.isDirectory(path)
fs.makeTree(sourcePath)
if fs.isFile(path)
fs.makeTree(fs.directory(sourcePath))
content = @replacePackageNamePlaceholders(fs.read(path), packageName)
fs.write(sourcePath, content)
sourcePath = fsUtils.join(@getPackagePath(), relativePath)
if fsUtils.isDirectory(path)
fsUtils.makeTree(sourcePath)
if fsUtils.isFile(path)
fsUtils.makeTree(fsUtils.directory(sourcePath))
content = @replacePackageNamePlaceholders(fsUtils.read(path), packageName)
fsUtils.write(sourcePath, content)
replacePackageNamePlaceholders: (string, packageName) ->
placeholderRegex = /__(?:(package-name)|([pP]ackageName)|(package_name))__/g

16
src/packages/package-generator/spec/package-generator-spec.coffee
View File

@@ -1,5 +1,5 @@
RootView = require 'root-view'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe 'Package Generator', ->
[packageGenerator] = []
@@ -35,21 +35,21 @@ describe 'Package Generator', ->
packageName = "sweet-package-dude"
packagePath = "/tmp/atom-packages/#{packageName}"
fs.remove(packagePath) if fs.exists(packagePath)
fsUtils.remove(packagePath) if fsUtils.exists(packagePath)
afterEach ->
fs.remove(packagePath) if fs.exists(packagePath)
fsUtils.remove(packagePath) if fsUtils.exists(packagePath)
it "forces the package's name to be lowercase with dashes", ->
packageName = "CamelCaseIsForTheBirds"
packagePath = fs.join(fs.directory(packagePath), packageName)
packagePath = fsUtils.join(fsUtils.directory(packagePath), packageName)
rootView.trigger("package-generator:generate")
packageGeneratorView = rootView.find(".package-generator").view()
packageGeneratorView.miniEditor.setText(packagePath)
packageGeneratorView.trigger "core:confirm"
expect(packagePath).not.toExistOnDisk()
expect(fs.join(fs.directory(packagePath), "camel-case-is-for-the-birds")).toExistOnDisk()
expect(fsUtils.join(fsUtils.directory(packagePath), "camel-case-is-for-the-birds")).toExistOnDisk()
it "correctly lays out the package files and closes the package generator view", ->
rootView.attachToDom()
@@ -77,16 +77,16 @@ describe 'Package Generator', ->
packageGeneratorView.miniEditor.setText(packagePath)
packageGeneratorView.trigger "core:confirm"
lines = fs.read("#{packagePath}/package.cson").split("\n")
lines = fsUtils.read("#{packagePath}/package.cson").split("\n")
expect(lines[0]).toBe "'main': 'lib\/#{packageName}'"
lines = fs.read("#{packagePath}/lib/#{packageName}.coffee").split("\n")
lines = fsUtils.read("#{packagePath}/lib/#{packageName}.coffee").split("\n")
expect(lines[0]).toBe "SweetPackageDudeView = require 'sweet-package-dude/lib/sweet-package-dude-view'"
expect(lines[3]).toBe " sweetPackageDudeView: null"
it "displays an error when the package path already exists", ->
rootView.attachToDom()
fs.makeTree(packagePath)
fsUtils.makeTree(packagePath)
rootView.trigger("package-generator:generate")
packageGeneratorView = rootView.find(".package-generator").view()

4
src/packages/snippets/lib/snippet-body-parser.coffee
View File

@@ -1,4 +1,4 @@
PEG = require 'pegjs'
fs = require 'fs-utils'
grammarSrc = fs.read(require.resolve('./snippet-body.pegjs'))
fsUtils = require 'fs-utils'
grammarSrc = fsUtils.read(require.resolve('./snippet-body.pegjs'))
module.exports = PEG.buildParser(grammarSrc, trackLineAndColumn: true)

1
src/packages/snippets/spec/snippets-spec.coffee
View File

@@ -3,7 +3,6 @@ RootView = require 'root-view'
Buffer = require 'text-buffer'
Editor = require 'editor'
_ = require 'underscore'
fs = require 'fs-utils'
Package = require 'package'
describe "Snippets extension", ->

6
src/packages/spell-check/lib/spell-check.coffee
View File

@@ -9,12 +9,6 @@ module.exports =
]
activate: ->
syntax.on 'grammars-loaded.spell-check', => @subscribeToEditors()
deactivate: ->
syntax.off '.spell-check'
subscribeToEditors: ->
rootView.eachEditor (editor) ->
if editor.attached and not editor.mini
editor.underlayer.append(new SpellCheckView(editor))

1
src/packages/spell-check/spec/spell-check-spec.coffee
View File

@@ -10,7 +10,6 @@ describe "Spell check", ->
rootView.open('sample.js')
config.set('spell-check.grammars', [])
atom.activatePackage('spell-check', immediate: true)
syntax.trigger 'grammars-loaded'
rootView.attachToDom()
editor = rootView.getActiveView()

33
src/packages/status-bar/spec/status-bar-spec.coffee
View File

@@ -2,7 +2,7 @@ $ = require 'jquery'
_ = require 'underscore'
RootView = require 'root-view'
StatusBar = require 'status-bar/lib/status-bar-view'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "StatusBar", ->
[editor, statusBar, buffer] = []
@@ -57,7 +57,7 @@ describe "StatusBar", ->
describe "when the buffer content has changed from the content on disk", ->
it "disables the buffer modified indicator on save", ->
path = "/tmp/atom-whitespace.txt"
fs.write(path, "")
fsUtils.write(path, "")
rootView.open(path)
expect(statusBar.bufferModified.text()).toBe ''
editor.insertText("\n")
@@ -107,12 +107,12 @@ describe "StatusBar", ->
describe "git branch label", ->
beforeEach ->
fs.remove('/tmp/.git') if fs.isDirectory('/tmp/.git')
fsUtils.remove('/tmp/.git') if fsUtils.isDirectory('/tmp/.git')
rootView.attachToDom()
it "displays the current branch for files in repositories", ->
path = require.resolve('fixtures/git/master.git/HEAD')
project.setPath(fs.resolveOnLoadPath('fixtures/git/master.git'))
project.setPath(fsUtils.resolveOnLoadPath('fixtures/git/master.git'))
rootView.open(path)
expect(statusBar.branchArea).toBeVisible()
expect(statusBar.branchLabel.text()).toBe 'master'
@@ -128,22 +128,22 @@ describe "StatusBar", ->
beforeEach ->
path = require.resolve('fixtures/git/working-dir/file.txt')
newPath = fs.join(fs.resolveOnLoadPath('fixtures/git/working-dir'), 'new.txt')
fs.write(newPath, "I'm new here")
ignoredPath = fs.join(fs.resolveOnLoadPath('fixtures/git/working-dir'), 'ignored.txt')
fs.write(ignoredPath, 'ignored.txt')
newPath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'new.txt')
fsUtils.write(newPath, "I'm new here")
ignoredPath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'ignored.txt')
fsUtils.write(ignoredPath, 'ignored.txt')
git.getPathStatus(path)
git.getPathStatus(newPath)
originalPathText = fs.read(path)
originalPathText = fsUtils.read(path)
rootView.attachToDom()
afterEach ->
fs.write(path, originalPathText)
fs.remove(newPath) if fs.exists(newPath)
fs.remove(ignoredPath) if fs.exists(ignoredPath)
fsUtils.write(path, originalPathText)
fsUtils.remove(newPath) if fsUtils.exists(newPath)
fsUtils.remove(ignoredPath) if fsUtils.exists(ignoredPath)
it "displays the modified icon for a changed file", ->
fs.write(path, "i've changed for the worse")
fsUtils.write(path, "i've changed for the worse")
git.getPathStatus(path)
rootView.open(path)
expect(statusBar.gitStatusIcon).toHaveClass('modified-status-icon')
@@ -161,16 +161,16 @@ describe "StatusBar", ->
expect(statusBar.gitStatusIcon).toHaveClass('ignored-status-icon')
it "updates when a status-changed event occurs", ->
fs.write(path, "i've changed for the worse")
fsUtils.write(path, "i've changed for the worse")
git.getPathStatus(path)
rootView.open(path)
expect(statusBar.gitStatusIcon).toHaveClass('modified-status-icon')
fs.write(path, originalPathText)
fsUtils.write(path, originalPathText)
git.getPathStatus(path)
expect(statusBar.gitStatusIcon).not.toHaveClass('modified-status-icon')
it "displays the diff stat for modified files", ->
fs.write(path, "i've changed for the worse")
fsUtils.write(path, "i've changed for the worse")
git.getPathStatus(path)
rootView.open(path)
expect(statusBar.gitStatusIcon).toHaveText('+1,-1')
@@ -183,7 +183,6 @@ describe "StatusBar", ->
beforeEach ->
atom.activatePackage('text.tmbundle', sync: true)
atom.activatePackage('javascript.tmbundle', sync: true)
syntax.trigger 'grammars-loaded'
it "displays the name of the current grammar", ->
expect(statusBar.find('.grammar-name').text()).toBe 'JavaScript'

10
src/packages/symbols-view/lib/load-tags-handler.coffee
View File

@@ -1,13 +1,13 @@
ctags = require 'ctags'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
getTagsFile: (path) ->
tagsFile = fs.join(path, "tags")
return tagsFile if fs.isFile(tagsFile)
tagsFile = fsUtils.join(path, "tags")
return tagsFile if fsUtils.isFile(tagsFile)
tagsFile = fs.join(path, "TAGS")
return tagsFile if fs.isFile(tagsFile)
tagsFile = fsUtils.join(path, "TAGS")
return tagsFile if fsUtils.isFile(tagsFile)
loadTags: (path) ->
tagsFile = @getTagsFile(path)

12
src/packages/symbols-view/lib/symbols-view.coffee
View File

@@ -3,7 +3,7 @@ SelectList = require 'select-list'
TagGenerator = require './tag-generator'
TagReader = require './tag-reader'
Point = require 'point'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
$ = require 'jquery'
module.exports =
@@ -30,7 +30,7 @@ class SymbolsView extends SelectList
if position
text = "Line #{position.row + 1}"
else
text = fs.base(file)
text = fsUtils.base(file)
@div text, class: 'right function-details'
toggleFileSymbols: ->
@@ -75,7 +75,7 @@ class SymbolsView extends SelectList
setTimeout (=> @cancel()), 2000
confirmed : (tag) ->
if tag.file and not fs.isFile(project.resolve(tag.file))
if tag.file and not fsUtils.isFile(project.resolve(tag.file))
@setError('Selected file does not exist')
setTimeout((=> @setError()), 2000)
else
@@ -104,8 +104,8 @@ class SymbolsView extends SelectList
pattern = $.trim(tag.pattern?.replace(/(^^\/\^)|(\$\/$)/g, '')) # Remove leading /^ and trailing $/
return unless pattern
file = project.resolve(tag.file)
return unless fs.isFile(file)
for line, index in fs.read(file).split('\n')
return unless fsUtils.isFile(file)
for line, index in fsUtils.read(file).split('\n')
return new Point(index, 0) if pattern is $.trim(line)
goToDeclaration: ->
@@ -123,7 +123,7 @@ class SymbolsView extends SelectList
continue unless position
tags.push
file: match.file
name: fs.base(match.file)
name: fsUtils.base(match.file)
position: position
@miniEditor.show()
@setArray(tags)

4
src/packages/symbols-view/lib/tag-generator.coffee
View File

@@ -1,7 +1,7 @@
Point = require 'point'
$ = require 'jquery'
BufferedProcess = require 'buffered-process'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class TagGenerator
@@ -18,7 +18,7 @@ class TagGenerator
generate: ->
deferred = $.Deferred()
tags = []
command = fs.resolveOnLoadPath('ctags')
command = fsUtils.resolveOnLoadPath('ctags')
args = ['--fields=+KS', '-nf', '-', @path]
stdout = (lines) =>
for line in lines.split('\n')

4
src/packages/symbols-view/lib/tag-reader.coffee
View File

@@ -1,4 +1,4 @@
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
$ = require 'jquery'
LoadTagsTask = require './load-tags-task'
ctags = require 'ctags'
@@ -7,7 +7,7 @@ module.exports =
getTagsFile: (project) ->
tagsFile = project.resolve("tags") or project.resolve("TAGS")
return tagsFile if fs.isFile(tagsFile)
return tagsFile if fsUtils.isFile(tagsFile)
find: (editor) ->
word = editor.getTextInRange(editor.getCursor().getCurrentWordBufferRange())

14
src/packages/symbols-view/spec/symbols-view-spec.coffee
View File

@@ -1,7 +1,7 @@
RootView = require 'root-view'
SymbolsView = require 'symbols-view/lib/symbols-view'
TagGenerator = require 'symbols-view/lib/tag-generator'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "SymbolsView", ->
[symbolsView, setArraySpy] = []
@@ -162,11 +162,11 @@ describe "SymbolsView", ->
beforeEach ->
renamedPath = project.resolve("tagged-duplicate-renamed.js")
fs.remove(renamedPath) if fs.exists(renamedPath)
fs.move(project.resolve("tagged-duplicate.js"), renamedPath)
fsUtils.remove(renamedPath) if fsUtils.exists(renamedPath)
fsUtils.move(project.resolve("tagged-duplicate.js"), renamedPath)
afterEach ->
fs.move(renamedPath, project.resolve("tagged-duplicate.js"))
fsUtils.move(renamedPath, project.resolve("tagged-duplicate.js"))
it "doesn't display the tag", ->
rootView.open("tagged.js")
@@ -205,11 +205,11 @@ describe "SymbolsView", ->
beforeEach ->
renamedPath = project.resolve("tagged-renamed.js")
fs.remove(renamedPath) if fs.exists(renamedPath)
fs.move(project.resolve("tagged.js"), renamedPath)
fsUtils.remove(renamedPath) if fsUtils.exists(renamedPath)
fsUtils.move(project.resolve("tagged.js"), renamedPath)
afterEach ->
fs.move(renamedPath, project.resolve("tagged.js"))
fsUtils.move(renamedPath, project.resolve("tagged.js"))
it "doesn't open the editor", ->
rootView.trigger "symbols-view:toggle-project-symbols"

4
src/packages/tabs/lib/tab-view.coffee
View File

@@ -1,6 +1,6 @@
$ = require 'jquery'
{View} = require 'space-pen'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class TabView extends View
@@ -46,7 +46,7 @@ class TabView extends View
if fileNameText?
duplicates = @editor.getEditSessions().filter (session) -> fileNameText is session.buffer.getBaseName()
if duplicates.length > 1
directory = fs.base(fs.directory(@editSession.getPath()))
directory = fsUtils.base(fsUtils.directory(@editSession.getPath()))
fileNameText = "#{fileNameText} - #{directory}" if directory
else
fileNameText = 'untitled'

1
src/packages/tabs/spec/tabs-spec.coffee
View File

@@ -4,7 +4,6 @@ RootView = require 'root-view'
Pane = require 'pane'
PaneContainer = require 'pane-container'
TabBarView = require 'tabs/lib/tab-bar-view'
fs = require 'fs-utils'
{View} = require 'space-pen'
describe "Tabs package main", ->

6
src/packages/tree-view/lib/dialog.coffee
View File

@@ -1,6 +1,6 @@
{View} = require 'space-pen'
Editor = require 'editor'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
$ = require 'jquery'
module.exports =
@@ -21,8 +21,8 @@ class Dialog extends View
@miniEditor.setText(path)
if select
extension = fs.extension(path)
baseName = fs.base(path)
extension = fsUtils.extension(path)
baseName = fsUtils.base(path)
if baseName is extension
selectionEnd = path.length
else

14
src/packages/tree-view/lib/file-view.coffee
View File

@@ -1,7 +1,7 @@
{View} = require 'space-pen'
$ = require 'jquery'
Git = require 'git'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
module.exports =
class FileView extends View
@@ -17,16 +17,16 @@ class FileView extends View
if @file.symlink
@fileName.addClass('symlink-icon')
else
extension = fs.extension(@getPath())
if fs.isReadmePath(@getPath())
extension = fsUtils.extension(@getPath())
if fsUtils.isReadmePath(@getPath())
@fileName.addClass('readme-icon')
else if fs.isCompressedExtension(extension)
else if fsUtils.isCompressedExtension(extension)
@fileName.addClass('compressed-icon')
else if fs.isImageExtension(extension)
else if fsUtils.isImageExtension(extension)
@fileName.addClass('image-icon')
else if fs.isPdfExtension(extension)
else if fsUtils.isPdfExtension(extension)
@fileName.addClass('pdf-icon')
else if fs.isBinaryExtension(extension)
else if fsUtils.isBinaryExtension(extension)
@fileName.addClass('binary-icon')
else
@fileName.addClass('text-icon')

22
src/packages/tree-view/lib/tree-view.coffee
View File

@@ -4,7 +4,7 @@ Directory = require 'directory'
DirectoryView = require './directory-view'
FileView = require './file-view'
Dialog = require './dialog'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
$ = require 'jquery'
_ = require 'underscore'
@@ -230,14 +230,14 @@ class TreeView extends ScrollView
dialog.close()
return
if fs.exists(newPath)
if fsUtils.exists(newPath)
dialog.showError("Error: #{newPath} already exists. Try a different path.")
return
directoryPath = fs.directory(newPath)
directoryPath = fsUtils.directory(newPath)
try
fs.makeTree(directoryPath) unless fs.exists(directoryPath)
fs.move(oldPath, newPath)
fsUtils.makeTree(directoryPath) unless fsUtils.exists(directoryPath)
fsUtils.move(oldPath, newPath)
dialog.close()
catch e
dialog.showError("Error: #{e.message} Try a different path.")
@@ -254,13 +254,13 @@ class TreeView extends ScrollView
"You are deleting #{entry.getPath()}",
"Move to Trash", (=> $native.moveToTrash(entry.getPath())),
"Cancel", null
"Delete", (=> fs.remove(entry.getPath()))
"Delete", (=> fsUtils.remove(entry.getPath()))
)
add: ->
selectedEntry = @selectedEntry() or @root
selectedPath = selectedEntry.getPath()
directoryPath = if fs.isFile(selectedPath) then fs.directory(selectedPath) else selectedPath
directoryPath = if fsUtils.isFile(selectedPath) then fsUtils.directory(selectedPath) else selectedPath
relativeDirectoryPath = project.relativize(directoryPath)
relativeDirectoryPath += '/' if relativeDirectoryPath.length > 0
@@ -274,16 +274,16 @@ class TreeView extends ScrollView
endsWithDirectorySeparator = /\/$/.test(relativePath)
path = project.resolve(relativePath)
try
if fs.exists(path)
pathType = if fs.isFile(path) then "file" else "directory"
if fsUtils.exists(path)
pathType = if fsUtils.isFile(path) then "file" else "directory"
dialog.showError("Error: A #{pathType} already exists at path '#{path}'. Try a different path.")
else if endsWithDirectorySeparator
fs.makeTree(path)
fsUtils.makeTree(path)
dialog.cancel()
@entryForPath(path).buildEntries()
@selectEntryForPath(path)
else
fs.write(path, "")
fsUtils.write(path, "")
rootView.open(path)
dialog.close()
catch e

128
src/packages/tree-view/spec/tree-view-spec.coffee
View File

@@ -4,7 +4,7 @@ _ = require 'underscore'
TreeView = require 'tree-view/lib/tree-view'
RootView = require 'root-view'
Directory = require 'directory'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "TreeView", ->
[treeView, sampleJs, sampleTxt] = []
@@ -259,20 +259,20 @@ describe "TreeView", ->
sampleJs.trigger clickEvent(originalEvent: { detail: 1 })
expect(sampleJs).toHaveClass 'selected'
expect(rootView.getActiveView().getPath()).toBe fs.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().isFocused).toBeFalsy()
sampleTxt.trigger clickEvent(originalEvent: { detail: 1 })
expect(sampleTxt).toHaveClass 'selected'
expect(treeView.find('.selected').length).toBe 1
expect(rootView.getActiveView().getPath()).toBe fs.resolveOnLoadPath('fixtures/tree-view/tree-view.txt')
expect(rootView.getActiveView().getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/tree-view/tree-view.txt')
expect(rootView.getActiveView().isFocused).toBeFalsy()
describe "when a file is double-clicked", ->
it "selects the file and opens it in the active editor on the first click, then changes focus to the active editor on the second", ->
sampleJs.trigger clickEvent(originalEvent: { detail: 1 })
expect(sampleJs).toHaveClass 'selected'
expect(rootView.getActiveView().getPath()).toBe fs.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().isFocused).toBeFalsy()
sampleJs.trigger clickEvent(originalEvent: { detail: 2 })
@@ -568,7 +568,7 @@ describe "TreeView", ->
it "opens the file in the editor and focuses it", ->
treeView.root.find('.file:contains(tree-view.js)').click()
treeView.root.trigger 'tree-view:open-selected-entry'
expect(rootView.getActiveView().getPath()).toBe fs.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/tree-view/tree-view.js')
expect(rootView.getActiveView().isFocused).toBeTruthy()
describe "when a directory is selected", ->
@@ -593,14 +593,14 @@ describe "TreeView", ->
beforeEach ->
atom.deactivatePackage('tree-view')
rootDirPath = fs.join(fs.absolute("/tmp"), "atom-tests")
fs.remove(rootDirPath) if fs.exists(rootDirPath)
rootDirPath = fsUtils.join(fsUtils.absolute("/tmp"), "atom-tests")
fsUtils.remove(rootDirPath) if fsUtils.exists(rootDirPath)
dirPath = fs.join(rootDirPath, "test-dir")
filePath = fs.join(dirPath, "test-file.txt")
fs.makeDirectory(rootDirPath)
fs.makeDirectory(dirPath)
fs.write(filePath, "doesn't matter")
dirPath = fsUtils.join(rootDirPath, "test-dir")
filePath = fsUtils.join(dirPath, "test-file.txt")
fsUtils.makeDirectory(rootDirPath)
fsUtils.makeDirectory(dirPath)
fsUtils.write(filePath, "doesn't matter")
project.setPath(rootDirPath)
@@ -612,7 +612,7 @@ describe "TreeView", ->
fileView = treeView.find('.file:contains(test-file.txt)').view()
afterEach ->
fs.remove(rootDirPath) if fs.exists(rootDirPath)
fsUtils.remove(rootDirPath) if fsUtils.exists(rootDirPath)
describe "tree-view:add", ->
addDialog = null
@@ -638,16 +638,16 @@ describe "TreeView", ->
dirView.directory.trigger 'contents-changed'
expect(directoryChangeHandler).toHaveBeenCalled()
expect(treeView.find('.selected').text()).toBe fs.base(filePath)
expect(treeView.find('.selected').text()).toBe fsUtils.base(filePath)
describe "when the path without a trailing '/' is changed and confirmed", ->
describe "when no file exists at that location", ->
it "add a file, closes the dialog and selects the file in the tree-view", ->
newPath = fs.join(dirPath, "new-test-file.txt")
addDialog.miniEditor.insertText(fs.base(newPath))
newPath = fsUtils.join(dirPath, "new-test-file.txt")
addDialog.miniEditor.insertText(fsUtils.base(newPath))
addDialog.trigger 'core:confirm'
expect(fs.exists(newPath)).toBeTruthy()
expect(fs.isFile(newPath)).toBeTruthy()
expect(fsUtils.exists(newPath)).toBeTruthy()
expect(fsUtils.isFile(newPath)).toBeTruthy()
expect(addDialog.parent()).not.toExist()
expect(rootView.getActiveView().getPath()).toBe newPath
@@ -655,13 +655,13 @@ describe "TreeView", ->
dirView.entries.find("> .file").length > 1
runs ->
expect(treeView.find('.selected').text()).toBe fs.base(newPath)
expect(treeView.find('.selected').text()).toBe fsUtils.base(newPath)
describe "when a file already exists at that location", ->
it "shows an error message and does not close the dialog", ->
newPath = fs.join(dirPath, "new-test-file.txt")
fs.write(newPath, '')
addDialog.miniEditor.insertText(fs.base(newPath))
newPath = fsUtils.join(dirPath, "new-test-file.txt")
fsUtils.write(newPath, '')
addDialog.miniEditor.insertText(fsUtils.base(newPath))
addDialog.trigger 'core:confirm'
expect(addDialog.prompt.text()).toContain 'Error'
@@ -673,11 +673,11 @@ describe "TreeView", ->
describe "when no file or directory exists at the given path", ->
it "adds a directory and closes the dialog", ->
treeView.attachToDom()
newPath = fs.join(dirPath, "new/dir")
newPath = fsUtils.join(dirPath, "new/dir")
addDialog.miniEditor.insertText("new/dir/")
addDialog.trigger 'core:confirm'
expect(fs.exists(newPath)).toBeTruthy()
expect(fs.isDirectory(newPath)).toBeTruthy()
expect(fsUtils.exists(newPath)).toBeTruthy()
expect(fsUtils.isDirectory(newPath)).toBeTruthy()
expect(addDialog.parent()).not.toExist()
expect(rootView.getActiveView().getPath()).not.toBe newPath
expect(treeView.find(".tree-view")).toMatchSelector(':focus')
@@ -686,11 +686,11 @@ describe "TreeView", ->
it "selects the created directory", ->
treeView.attachToDom()
newPath = fs.join(dirPath, "new2/")
newPath = fsUtils.join(dirPath, "new2/")
addDialog.miniEditor.insertText("new2/")
addDialog.trigger 'core:confirm'
expect(fs.exists(newPath)).toBeTruthy()
expect(fs.isDirectory(newPath)).toBeTruthy()
expect(fsUtils.exists(newPath)).toBeTruthy()
expect(fsUtils.isDirectory(newPath)).toBeTruthy()
expect(addDialog.parent()).not.toExist()
expect(rootView.getActiveView().getPath()).not.toBe newPath
expect(treeView.find(".tree-view")).toMatchSelector(':focus')
@@ -699,8 +699,8 @@ describe "TreeView", ->
describe "when a file or directory already exists at the given path", ->
it "shows an error message and does not close the dialog", ->
newPath = fs.join(dirPath, "new-dir")
fs.makeDirectory(newPath)
newPath = fsUtils.join(dirPath, "new-dir")
fsUtils.makeDirectory(newPath)
addDialog.miniEditor.insertText("new-dir/")
addDialog.trigger 'core:confirm'
@@ -770,24 +770,24 @@ describe "TreeView", ->
waits 50 # The move specs cause too many false positives because of their async nature, so wait a little bit before we cleanup
it "opens a move dialog with the file's current path (excluding extension) populated", ->
extension = fs.extension(filePath)
fileNameWithoutExtension = fs.base(filePath, extension)
extension = fsUtils.extension(filePath)
fileNameWithoutExtension = fsUtils.base(filePath, extension)
expect(moveDialog).toExist()
expect(moveDialog.prompt.text()).toBe "Enter the new path for the file."
expect(moveDialog.miniEditor.getText()).toBe(project.relativize(filePath))
expect(moveDialog.miniEditor.getSelectedText()).toBe fs.base(fileNameWithoutExtension)
expect(moveDialog.miniEditor.getSelectedText()).toBe fsUtils.base(fileNameWithoutExtension)
expect(moveDialog.miniEditor.isFocused).toBeTruthy()
describe "when the path is changed and confirmed", ->
describe "when all the directories along the new path exist", ->
it "moves the file, updates the tree view, and closes the dialog", ->
newPath = fs.join(rootDirPath, 'renamed-test-file.txt')
newPath = fsUtils.join(rootDirPath, 'renamed-test-file.txt')
moveDialog.miniEditor.setText(newPath)
moveDialog.trigger 'core:confirm'
expect(fs.exists(newPath)).toBeTruthy()
expect(fs.exists(filePath)).toBeFalsy()
expect(fsUtils.exists(newPath)).toBeTruthy()
expect(fsUtils.exists(filePath)).toBeFalsy()
expect(moveDialog.parent()).not.toExist()
waitsFor "tree view to update", ->
@@ -800,7 +800,7 @@ describe "TreeView", ->
describe "when the directories along the new path don't exist", ->
it "creates the target directory before moving the file", ->
newPath = fs.join(rootDirPath, 'new/directory', 'renamed-test-file.txt')
newPath = fsUtils.join(rootDirPath, 'new/directory', 'renamed-test-file.txt')
moveDialog.miniEditor.setText(newPath)
moveDialog.trigger 'core:confirm'
@@ -809,14 +809,14 @@ describe "TreeView", ->
treeView.root.find('> .entries > .directory:contains(new)').length > 0
runs ->
expect(fs.exists(newPath)).toBeTruthy()
expect(fs.exists(filePath)).toBeFalsy()
expect(fsUtils.exists(newPath)).toBeTruthy()
expect(fsUtils.exists(filePath)).toBeFalsy()
describe "when a file or directory already exists at the target path", ->
it "shows an error message and does not close the dialog", ->
runs ->
fs.write(fs.join(rootDirPath, 'target.txt'), '')
newPath = fs.join(rootDirPath, 'target.txt')
fsUtils.write(fsUtils.join(rootDirPath, 'target.txt'), '')
newPath = fsUtils.join(rootDirPath, 'target.txt')
moveDialog.miniEditor.setText(newPath)
moveDialog.trigger 'core:confirm'
@@ -844,8 +844,8 @@ describe "TreeView", ->
[dotFilePath, dotFileView, moveDialog] = []
beforeEach ->
dotFilePath = fs.join(dirPath, ".dotfile")
fs.write(dotFilePath, "dot")
dotFilePath = fsUtils.join(dirPath, ".dotfile")
fsUtils.write(dotFilePath, "dot")
dirView.collapse()
dirView.expand()
dotFileView = treeView.find('.file:contains(.dotfile)').view()
@@ -875,22 +875,22 @@ describe "TreeView", ->
temporaryFilePath = null
beforeEach ->
temporaryFilePath = fs.join(fs.resolveOnLoadPath('fixtures/tree-view'), 'temporary')
if fs.exists(temporaryFilePath)
fs.remove(temporaryFilePath)
temporaryFilePath = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/tree-view'), 'temporary')
if fsUtils.exists(temporaryFilePath)
fsUtils.remove(temporaryFilePath)
waits(20)
afterEach ->
fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
describe "when a file is added or removed in an expanded directory", ->
it "updates the directory view to display the directory's new contents", ->
entriesCountBefore = null
runs ->
expect(fs.exists(temporaryFilePath)).toBeFalsy()
expect(fsUtils.exists(temporaryFilePath)).toBeFalsy()
entriesCountBefore = treeView.root.entries.find('.entry').length
fs.write temporaryFilePath, 'hi'
fsUtils.write temporaryFilePath, 'hi'
waitsFor "directory view contens to refresh", ->
treeView.root.entries.find('.entry').length == entriesCountBefore + 1
@@ -898,7 +898,7 @@ describe "TreeView", ->
runs ->
expect(treeView.root.entries.find('.entry').length).toBe entriesCountBefore + 1
expect(treeView.root.entries.find('.file:contains(temporary)')).toExist()
fs.remove(temporaryFilePath)
fsUtils.remove(temporaryFilePath)
waitsFor "directory view contens to refresh", ->
treeView.root.entries.find('.entry').length == entriesCountBefore
@@ -907,12 +907,12 @@ describe "TreeView", ->
[ignoreFile] = []
beforeEach ->
ignoreFile = fs.join(fs.resolveOnLoadPath('fixtures/tree-view'), '.gitignore')
fs.write(ignoreFile, 'tree-view.js')
ignoreFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/tree-view'), '.gitignore')
fsUtils.write(ignoreFile, 'tree-view.js')
config.set "core.hideGitIgnoredFiles", false
afterEach ->
fs.remove(ignoreFile) if fs.exists(ignoreFile)
fsUtils.remove(ignoreFile) if fsUtils.exists(ignoreFile)
it "hides git-ignored files if the option is set, but otherwise shows them", ->
expect(treeView.find('.file:contains(tree-view.js)').length).toBe 1
@@ -930,30 +930,30 @@ describe "TreeView", ->
beforeEach ->
config.set "core.hideGitIgnoredFiles", false
ignoreFile = fs.join(fs.resolveOnLoadPath('fixtures/tree-view'), '.gitignore')
fs.write(ignoreFile, 'tree-view.js')
ignoreFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/tree-view'), '.gitignore')
fsUtils.write(ignoreFile, 'tree-view.js')
git.getPathStatus(ignoreFile)
newFile = fs.join(fs.resolveOnLoadPath('fixtures/tree-view/dir2'), 'new2')
fs.write(newFile, '')
newFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/tree-view/dir2'), 'new2')
fsUtils.write(newFile, '')
git.getPathStatus(newFile)
modifiedFile = fs.join(fs.resolveOnLoadPath('fixtures/tree-view/dir1'), 'file1')
originalFileContent = fs.read(modifiedFile)
fs.write modifiedFile, 'ch ch changes'
modifiedFile = fsUtils.join(fsUtils.resolveOnLoadPath('fixtures/tree-view/dir1'), 'file1')
originalFileContent = fsUtils.read(modifiedFile)
fsUtils.write modifiedFile, 'ch ch changes'
git.getPathStatus(modifiedFile)
treeView.updateRoot()
treeView.root.entries.find('.directory:contains(dir1)').view().expand()
treeView.root.entries.find('.directory:contains(dir2)').view().expand()
afterEach ->
fs.remove(ignoreFile) if fs.exists(ignoreFile)
fs.remove(newFile) if fs.exists(newFile)
fs.write modifiedFile, originalFileContent
fsUtils.remove(ignoreFile) if fsUtils.exists(ignoreFile)
fsUtils.remove(newFile) if fsUtils.exists(newFile)
fsUtils.write modifiedFile, originalFileContent
describe "when a file is modified", ->
it "adds a custom style", ->
treeView.root.entries.find('.directory:contains(dir1)').view().expand()
expect(treeView.find('.file:contains(file1)')).toHaveClass 'modified'
describe "when a directory if modified", ->

2
src/packages/whitespace/lib/whitespace.coffee
View File

@@ -8,7 +8,7 @@ module.exports =
whitespaceBeforeSave: (buffer) ->
buffer.on 'will-be-saved', ->
buffer.transact ->
buffer.scan /[ \t]+$/g, (match, range, { replace }) -> replace('')
buffer.scan /[ \t]+$/g, ({replace}) -> replace('')
if config.get('whitespace.ensureSingleTrailingNewline')
if buffer.getLastLine() is ''

9
src/packages/whitespace/spec/whitespace-spec.coffee
View File

@@ -1,12 +1,12 @@
RootView = require 'root-view'
fs = require 'fs-utils'
fsUtils = require 'fs-utils'
describe "Whitespace", ->
[editor, path] = []
beforeEach ->
path = "/tmp/atom-whitespace.txt"
fs.write(path, "")
fsUtils.write(path, "")
window.rootView = new RootView
rootView.open(path)
@@ -16,10 +16,10 @@ describe "Whitespace", ->
editor = rootView.getActiveView()
afterEach ->
fs.remove(path) if fs.exists(path)
fsUtils.remove(path) if fsUtils.exists(path)
it "strips trailing whitespace before an editor saves a buffer", ->
spyOn(fs, 'write')
spyOn(fsUtils, 'write')
config.set("whitespace.ensureSingleTrailingNewline", false)
config.update()
@@ -79,4 +79,3 @@ describe "Whitespace", ->
editor.insertText "no trailing newline"
editor.getBuffer().save()
expect(editor.getText()).toBe "no trailing newline"

3
src/packages/wrap-guide/lib/wrap-guide-view.coffee
View File

@@ -6,7 +6,8 @@ module.exports =
class WrapGuideView extends View
@activate: ->
rootView.eachEditor (editor) ->
editor.underlayer.append(new WrapGuideView(editor)) if editor.attached
if editor.attached and editor.getPane()
editor.underlayer.append(new WrapGuideView(editor))
@content: ->
@div class: 'wrap-guide'

Some files were not shown because too many files have changed in this diff Show More