atom-reading.md

Atomコードリーディングメモ

ビルド方法

script/build

起動したらsrc/window-bootstrap.coffeeが起動時間のログを出してるので、そいつをgrepすると/src/broweser/atom-application.coffee が引っかかる。

src/broweser/atom-application.coffee は、 src/browser/main.coffee に呼ばれている 起動プロセスはどうもここっぽい。

  app.on 'finish-launching', ->
    app.removeListener 'open-file', addPathToOpen
    app.removeListener 'open-url', addUrlToOpen

    args.pathsToOpen = args.pathsToOpen.map (pathToOpen) ->
      path.resolve(args.executedFrom ? process.cwd(), pathToOpen)

    require('coffee-script').register()
    if args.devMode
      require(path.join(args.resourcePath, 'src', 'coffee-cache')).register()
      AtomApplication = require path.join(args.resourcePath, 'src', 'browser', 'atom-application')
    else
      AtomApplication = require './atom-application'

    AtomApplication.open(args)
    console.log("App load time: #{Date.now() - global.shellStartTime}ms") unless args.test

args.devModeってなんだろう…便利そうなのでおってみる

  options.alias('d', 'dev').boolean('d').describe('d', 'Run in development mode.')
  options.alias('f', 'foreground').boolean('f').describe('f', 'Keep the browser process in the foreground.')
  options.alias('h', 'help').boolean('h').describe('h', 'Print this usage message.')
  options.alias('l', 'log-file').string('l').describe('l', 'Log all output to file.')
  options.alias('n', 'new-window').boolean('n').describe('n', 'Open a new window.')
  options.alias('s', 'spec-directory').string('s').describe('s', 'Set the spec directory (default: Atom\'s spec directory).')
  options.boolean('safe').describe('safe', 'Do not load packages from ~/.atom/packages or ~/.atom/dev/packages.')
  options.alias('t', 'test').boolean('t').describe('t', 'Run the specified specs and exit with error code on failures.')
  options.alias('v', 'version').boolean('v').describe('v', 'Print the version.')
  options.alias('w', 'wait').boolean('w').describe('w', 'Wait for window to be closed before returning.')

-d で起動する。その方法はあとで調べる。

main.coffeeはどうやって指定されてるんだろう。grepする

~/p/atom (master) $ git grep main.coffee
script/utils/compile-main-to-app:coffee -c -o /Applications/Atom.app/Contents/Resources/app/src/ src/main.coffee

ほう。

script/utils/compile-main-to-app

#!/bin/sh

coffee -c -o /Applications/Atom.app/Contents/Resources/app/src/ src/main.coffee

うおー直接放り込んでるー！！！便利！！！！

ということで、ここでわかったのは直接中のコードいじりながらハックしたいときは /Applications/Atom.app/Contents/Resources/app/src/ の中身を直接触るのが楽そう

ところで, main.jsどこで生成されるんだろう

~/p/atom (master) $ git grep main.js
package.json:  "main": "./src/browser/main.js",

package.jsに書いてあった。たぶんnodeパッケージの仕組みを使って、ここからブートするんだと思う。それ以上は後で調べる。 というわけでmain.coffeeがエントリと思ってよさそう。 でも↑のcompile-main-to-app発見しないとここに至るの厳しいな…。あんまり行儀は良くない。

気を取り直して、atom-applicationを追う。

src/browser/atom-application.coffee

AtomWindow = require './atom-window'
ApplicationMenu = require './application-menu'
AtomProtocolHandler = require './atom-protocol-handler'
AutoUpdateManager = require './auto-update-manager'
BrowserWindow = require 'browser-window'
Menu = require 'menu'
app = require 'app'
dialog = require 'dialog'
fs = require 'fs'
ipc = require 'ipc'
path = require 'path'
os = require 'os'
net = require 'net'
shell = require 'shell'
url = require 'url'
{EventEmitter} = require 'events'
_ = require 'underscore-plus'
src/browser/atom-application.coffee

AtomWindowとかはだいたい予想がつくので、window-bootstrapを読んでる箇所から逆にたどってみる

L323~

      if devMode
        try
          bootstrapScript = require.resolve(path.join(global.devResourcePath, 'src', 'window-bootstrap'))
          resourcePath = global.devResourcePath

      bootstrapScript ?= require.resolve('../window-bootstrap')
      resourcePath ?= @resourcePath
      openedWindow = new AtomWindow({pathToOpen, initialLine, initialColumn, bootstrapScript, resourcePath, devMode, safeMode, windowDimensions})

この呼び出し元を辿るとここらへんに行き着く。

# L139~
    @on 'application:open', -> @promptForPath(type: 'all')
    @on 'application:open-file', -> @promptForPath(type: 'file')
    @on 'application:open-folder', -> @promptForPath(type: 'folder')
    @on 'application:open-dev', -> @promptForPath(devMode: true)
    @on 'application:open-safe', -> @promptForPath(safeMode: true)

たぶん初期タブか何かは偽のプロンプトメッセージを受けて初期化されてそう

~/p/atom (master) $ git grep "application:open"
keymaps/darwin.cson:  'cmd-O': 'application:open-dev'
keymaps/darwin.cson:  'cmd-o': 'application:open'
...

ユーザーから使えるキーバインドにもマップしてある。

あと気になったのがここ

src/workspace-view.coffee:    @command 'application:open', -> ipc.send('command', 'application:open')
src/workspace-view.coffee:    @command 'application:open-file', -> ipc.send('command', 'application:open-file')
src/workspace-view.coffee:    @command 'application:open-folder', -> ipc.send('command', 'application:open-folder')
src/workspace-view.coffee:    @command 'application:open-dev', -> ipc.send('command', 'application:open-dev')
src/workspace-view.coffee:    @command 'application:open-safe', -> ipc.send('command', 'application:open-safe')
src/workspace-view.coffee:    @command 'application:open-your-config', -> ipc.send('command', 'application:open-your-config')
src/workspace-view.coffee:    @command 'application:open-your-init-script', -> ipc.send('command', 'application:open-your-init-script')
src/workspace-view.coffee:    @command 'application:open-your-keymap', -> ipc.send('command', 'application:open-your-keymap')
src/workspace-view.coffee:    @command 'application:open-your-snippets', -> ipc.send('command', 'application:open-your-snippets')
src/workspace-view.coffee:    @command 'application:open-your-stylesheet', -> ipc.send('command', 'application:open-your-stylesheet')
src/workspace-view.coffee:    @command 'application:open-license', => @model.openLicense()

workspace-viewってのが主要なUIっぽい。 workspace-viewのコードを追っていったら spacepen が出てきた。

space-pen by atom たしかそういう感じのテンプレートエンジンもどきがあるっていう話があったのは覚えてたけど、ここで出てくるのか。

一旦深追いをやめて、window-bootstrap.coffeeを呼んでる。

src/window-bootstrap.coffee

# Like sands through the hourglass, so are the days of our lives.
startTime = Date.now()

require './window'

Atom = require './atom'
window.atom = Atom.loadOrCreate('editor')
atom.initialize()
atom.startEditorWindow()
window.atom.loadTime = Date.now() - startTime
console.log "Window load time: #{atom.getWindowLoadTime()}ms"

とりあえず atom.coffeeが本体っぽいように見える。 とりあえずsrc/window.coffee を読んでみる

# Public: Measure how long a function takes to run.
#
# description - A {String} description that will be logged to the console when
#               the function completes.
# fn - A {Function} to measure the duration of.
#
# Returns the value returned by the given function.
window.measure = (description, fn) ->
  start = Date.now()
  value = fn()
  result = Date.now() - start
  console.log description, result
  value

# Public: Create a dev tools profile for a function.
#
# description - A {String} description that will be available in the Profiles
#               tab of the dev tools.
# fn - A {Function} to profile.
#
# Returns the value returned by the given function.
window.profile = (description, fn) ->
  measure description, ->
    console.profile(description)
    value = fn()
    console.profileEnd(description)
    value

ベンチマーク用のヘルパが生えてる。windowに副作用を及ぼすのを限定したいからwindow.coffeeっぽい。まあ気持ちはわかる。

というわけで実際のアプリケーション的なエントリポイントはここ

window.atom = Atom.loadOrCreate('editor')
atom.initialize()
atom.startEditorWindow()

とりあえずAtomクラスの冒頭部分を読む

class Atom extends Model
  @version: 1  # Increment this when the serialization format changes

  # Public: Load or create the Atom environment in the given mode.
  #
  # - mode: Pass 'editor' or 'spec' depending on the kind of environment you
  #         want to build.
  #
  # Returns an Atom instance, fully initialized
  @loadOrCreate: (mode) ->
    @deserialize(@loadState(mode)) ? new this({mode, @version})

  # Deserializes the Atom environment from a state object
  @deserialize: (state) ->
    new this(state) if state?.version is @version

なんでモデルを継承してるんでしょうね…（困惑） Atom.version が書き換わったら仮にインスタンスがあっても捨てて新しいのを作る、という風に読める。

  # Loads and returns the serialized state corresponding to this window
  # if it exists; otherwise returns undefined.
  @loadState: (mode) ->
    statePath = @getStatePath(mode)

    if fs.existsSync(statePath)
      try
        stateString = fs.readFileSync(statePath, 'utf8')
      catch error
        console.warn "Error reading window state: #{statePath}", error.stack, error
    else
      stateString = @getLoadSettings().windowState

    try
      JSON.parse(stateString) if stateString?
    catch error
      console.warn "Error parsing window state: #{statePath} #{error.stack}", error

restoreWindowDimensions() => getDefaultWindowDimensions() とみてたらlocalStorageを触ってる部分があった

    try
      dimensions = JSON.parse(localStorage.getItem("defaultWindowDimensions"))
    catch error
      console.warn "Error parsing default window dimensions", error
      localStorage.removeItem("defaultWindowDimensions")

コンソールで中身をみてみる

> localStorage.getItem("defaultWindowDimensions")
"{"x":161,"y":140,"width":1335,"height":702}"

atom.keymaps => KeymapManager で別ライブラリ。あとで。

atom.contextMenu: ContextMenuManager => src/context-menu-manager.coffee

外部パッケージ化されてないし、右クリックのときの挙動管理だろうから、ここを調べてみる。

API見た感じ、 atom.contextMenu に直接 add してるように見えるし、atom.contextMenuでgrepしてみると、次の行がでてくる

package.coffee:    atom.contextMenu.add(menuPath, map['context-menu']) for [menuPath, map] in @menus

各シーンやコンテキストに合わせて右クリックのアイテム一覧が再構築されるっぽい。

あとwidow-event-handler

window-event-handler.coffee:      $(atom.contextMenu.activeElement).trigger(command, args...)
window-event-handler.coffee:      atom.contextMenu.showForEvent(e)

ついでにこれ気になった。a タグの挙動のオーバーライド。

    @subscribe $(document), 'click', 'a', @openLink

  openLink: (event) ->
    location = $(event.target).attr('href')
    if location and location[0] isnt '#' and /^https?:\/\//.test(location)
      shell.openExternal(location)
    false

shellとは?

shell = require 'shell'

atom-shell ではないんだけど、なんだろうこれ
つまり location.href は基本的に変わらないものだと思ってよさそう。

ThemeManager

脱線したけど、次に ThemeManager#loadBaseStylesheets() を追う。名前通りのことをしていると思う。

  loadBaseStylesheets: ->
    @requireStylesheet('bootstrap/less/bootstrap')
    @reloadBaseStylesheets()

loadBaseStylesheets()

  # Public: Resolve and apply the stylesheet specified by the path.
  #
  # This supports both CSS and LESS stylsheets.
  #
  # stylesheetPath - A {String} path to the stylesheet that can be an absolute
  #                  path or a relative path that will be resolved against the
  #                  load path.
  #
  # Returns the absolute path to the required stylesheet.
  requireStylesheet: (stylesheetPath, ttype = 'bundled', htmlElement) ->
    if fullPath = @resolveStylesheet(stylesheetPath)
      content = @loadStylesheet(fullPath)
      @applyStylesheet(fullPath, content, ttype = 'bundled', htmlElement)
    else
      throw new Error("Could not find a file at path '#{stylesheetPath}'")

    fullPath

CSSかLESSのパスを指定して読み込む。

  applyStylesheet: (path, text, ttype = 'bundled', htmlElement=$('html')) ->
    styleElement = @stylesheetElementForId(@stringToId(path), htmlElement)
    if styleElement.length
      styleElement.text(text)
    else
      if htmlElement.find("head style.#{ttype}").length
        htmlElement.find("head style.#{ttype}:last").after "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"
      else
        htmlElement.find("head").append "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"
    @emit 'stylesheets-changed'

思ってたより泥臭い系。htmlElement.find("head").append "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>" がキモかな。headでスタイルシートを展開する。よくあるやつ。

loadBaseStylesheetsに戻って、 @reloadBaseStylesheets() をみてみる

  reloadBaseStylesheets: ->
    @requireStylesheet('../static/atom')
    if nativeStylesheetPath = fs.resolveOnLoadPath(process.platform, ['css', 'less'])
      @requireStylesheet(nativeStylesheetPath)

bootstrap展開後にatomのスタイルシートを展開している。ここで static/atom.less をみてみる

// Import from the syntax theme's variables with a fallback to ./variables/syntax-variables.less
@import "syntax-variables";

// Import from the ui theme's variables with a fallback to ./variables/ui-variables.less
@import "ui-variables";

@import "octicon-utf-codes";
@import "octicon-mixins";

@import "workspace-view";
@import "bootstrap";
@import "buttons";
@import "icons";
@import "links";
@import "panes";
@import "panels";
@import "sections";
@import "overlay";
@import "lists";
@import "popover-list";
@import "notification";
@import "messages";
@import "markdown";
@import "editor";
@import "select-list";
@import "syntax";
@import "utilities";
@import "octicons";

めっちゃ less な感じだった。モジュールで分割されてるので、必要となったら見れば良さそう。

PackageManager

引き続き startEditorWindowから @packages.loadPackages() を追う。

まずコンストラクタから

module.exports =
class PackageManager
  Emitter.includeInto(this)

  constructor: ({configDirPath, devMode, safeMode, @resourcePath}) ->
    @packageDirPaths = []
    unless safeMode
      if devMode
        @packageDirPaths.push(path.join(configDirPath, "dev", "packages"))
      @packageDirPaths.push(path.join(configDirPath, "packages"))

    @loadedPackages = {}
    @activePackages = {}
    @packageStates = {}

    @packageActivators = []
    @registerPackageActivator(this, ['atom', 'textmate'])

safeMode is true ならパッケージを読み込まない。と読める。devModeではdevパッケージを読み込んでいる。
ファイルパス周りをあんまり深追いしたくないので、loadPackages() を調べる。

  loadPackages: ->
    # Ensure atom exports is already in the require cache so the load time
    # of the first package isn't skewed by being the first to require atom
    require '../exports/atom'

    packagePaths = @getAvailablePackagePaths()
    packagePaths = packagePaths.filter (packagePath) => not @isPackageDisabled(path.basename(packagePath))
    packagePaths = _.uniq packagePaths, (packagePath) -> path.basename(packagePath)
    @loadPackage(packagePath) for packagePath in packagePaths
    @emit 'loaded'

srcの外の、 exports/atom.coffee

{Point, Range} = require 'text-buffer'

module.exports =
  BufferedNodeProcess: require '../src/buffered-node-process'
  BufferedProcess: require '../src/buffered-process'
  Git: require '../src/git'
  Point: Point
  Range: Range

# The following classes can't be used from a Task handler and should therefore
# only be exported when not running as a child node process
unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
  {$, $$, $$$, View} = require '../src/space-pen-extensions'

  module.exports.$ = $
  module.exports.$$ = $$
  module.exports.$$$ = $$$
  module.exports.EditorView = require '../src/editor-view'
  module.exports.ScrollView = require '../src/scroll-view'
  module.exports.SelectListView = require '../src/select-list-view'
  module.exports.Task = require '../src/task'
  module.exports.View = View
  module.exports.WorkspaceView = require '../src/workspace-view'
  module.exports.Workspace = require '../src/workspace'

あれ、ここ副作用あるのかな…

次に、@loadPackage を見る。 本命っぽい

    @loadPackage(packagePath) for packagePath in packagePaths

  loadPackage: (nameOrPath) ->
    if packagePath = @resolvePackagePath(nameOrPath)
      name = path.basename(nameOrPath)
      return pack if pack = @getLoadedPackage(name)

      try
        metadata = Package.loadMetadata(packagePath) ? {}
        if metadata.theme
          pack = new ThemePackage(packagePath, metadata)
        else
          pack = new Package(packagePath, metadata)
        pack.load()
        @loadedPackages[pack.name] = pack
        pack
      catch error
        console.warn "Failed to load package.json '#{path.basename(packagePath)}'", error.stack ? error

    else
      throw new Error("Could not resolve '#{nameOrPath}' to a package path")

ちょっとシェル叩いてみて @getLoadedPackages() してみる。

> atom.packages.getLoadedPackages()
[ThemePackage, ThemePackage, ThemePackage, ThemePackage, ThemePackage, ThemePackage,ThemePackage, Package, Package, ...]

ここにパッケージのインスタンスが格納されてるみたいだ。

        metadata = Package.loadMetadata(packagePath) ? {}
        if metadata.theme
          pack = new ThemePackage(packagePath, metadata)
        else
          pack = new Package(packagePath, metadata)
        pack.load()
        @loadedPackages[pack.name] = pack
        pack

メタデータ探して、それがThemePackageかPackageか判定して、pack.load() する。

Package

Package追ってみる。コンストラクタから。

  constructor: (@path, @metadata) ->
    @metadata ?= Package.loadMetadata(@path)
    @name = @metadata?.name ? path.basename(@path)
    @reset()

  reset: ->
    @stylesheets = []
    @keymaps = []
    @menus = []
    @grammars = []
    @scopedProperties = []

なんかよくわかんないけど、なんらかの仕組みで外に提供されるんだろう。

次に pack.load()

  load: ->
    @measure 'loadTime', =>
      try
        @loadKeymaps()
        @loadMenus()
        @loadStylesheets()
        @grammarsPromise = @loadGrammars()
        @scopedPropertiesPromise = @loadScopedProperties()
        @requireMainModule() unless @hasActivationEvents()

      catch error
        console.warn "Failed to load package named '#{@name}'", error.stack ? error
    this

loadKeymaps

  loadKeymaps: ->
    @keymaps = @getKeymapPaths().map (keymapPath) -> [keymapPath, CSON.readFileSync(keymapPath)]

設定ファイルから読み込んで構築してる。まだアプリ側に提供しているわけじゃなさそうだ。

loadMenus, loadStylesheetsも同上。

grammarsPromise, scopedPropertiesPromise は読み込み時にロード開始されてるけど、activate時にキャッチされてるっぽい。

  activate: ->
    unless @activationDeferred?
      @activationDeferred = Q.defer()
      @measure 'activateTime', =>
        @activateResources()
        if @hasActivationEvents()
          @subscribeToActivationEvents()
        else
          @activateNow()

    Q.all([@grammarsPromise, @scopedPropertiesPromise, @activationDeferred.promise])

loadGrammars

  loadGrammars: ->
    @grammars = []

    loadGrammar = (grammarPath, callback) =>
      atom.syntax.readGrammar grammarPath, (error, grammar) =>
        if error?
          console.warn("Failed to load grammar: #{grammarPath}", error.stack ? error)
        else
          @grammars.push(grammar)
          grammar.activate() if @grammarsActivated
        callback()

    deferred = Q.defer()
    grammarsDirPath = path.join(@path, 'grammars')
    fs.list grammarsDirPath, ['json', 'cson'], (error, grammarPaths=[]) ->
      async.each grammarPaths, loadGrammar, -> deferred.resolve()
    deferred.promise

ここのDeferredの使い方ヘッタクソに見えるが… あとでちゃんとみる。

atom.syntax.readGrammar見たほうがよさそう… と思ったがsrc/syntax.coffee にそんなメソッドはない。じゃあなんだこれ。一旦無視するか。

  loadScopedProperties: ->
    @scopedProperties = []

    loadScopedPropertiesFile = (scopedPropertiesPath, callback) =>
      ScopedProperties.load scopedPropertiesPath, (error, scopedProperties) =>
        if error?
          console.warn("Failed to load scoped properties: #{scopedPropertiesPath}", error.stack ? error)
        else
          @scopedProperties.push(scopedProperties)
          scopedProperties.activate() if @scopedPropertiesActivated
        callback()

    deferred = Q.defer()
    scopedPropertiesDirPath = path.join(@path, 'scoped-properties')
    fs.list scopedPropertiesDirPath, ['json', 'cson'], (error, scopedPropertiesPaths=[]) ->
      async.each scopedPropertiesPaths, loadScopedPropertiesFile, -> deferred.resolve()
    deferred.promise

ScopedPropertiesがなんなのか理解してないが、パッケージ単位でコンテキストが限定された変数か何かかな

  @load: (scopedPropertiesPath, callback) ->
    CSON.readFile scopedPropertiesPath, (error, scopedProperties={}) ->
      if error?
        callback(error)
      else
        callback(null, new ScopedProperties(scopedPropertiesPath, scopedProperties))

そんな気がする。

次、戻って pack.loadに戻って、requireMainModule

  requireMainModule: ->
    return @mainModule if @mainModule?
    mainModulePath = @getMainModulePath()
    @mainModule = require(mainModulePath) if fs.isFileSync(mainModulePath)

多重ロード防止のガードを自分で作ってるようにみえる。

> pack = atom.packages.getLoadedPackages()[10]
> pack.getMainModulePath()
"/Applications/Atom.app/Contents/Resources/app/node_modules/autosave/lib/autosave.js"

autosaveモジュールを引いたっぽい。これがrequireされると

  getMainModulePath: ->
    return @mainModulePath if @resolvedMainModulePath
    @resolvedMainModulePath = true
    mainModulePath =
      if @metadata.main
        path.join(@path, @metadata.main)
      else
        path.join(@path, 'index')
    @mainModulePath = fs.resolveExtension(mainModulePath, ["", _.keys(require.extensions)...])

同じく多重ロード防止。metadataっての、これpackage.jsonかそれ相当のものかな。mainが定義されてあればそのパスを使い、なかったらindex.jsを読む。

これで一応Packageモジュールは終了。 Atom#startEditorWindowに戻る。

@deserializeEditorWindow()

GUIの初期化をしそう。

  deserializeEditorWindow: ->
    @deserializePackageStates()
    @deserializeProject()
    @deserializeWorkspaceView()

  deserializePackageStates: ->
    @packages.packageStates = @state.packageStates ? {}
    delete @state.packageStates

とりあえず初期化フローでは {} かな

  deserializeProject: ->
    Project = require './project'
    @project ?= @deserializers.deserialize(@state.project) ? new Project(path: @getLoadSettings().initialPath)

ここでProjectをnewしている。

Project

class Project extends Model
  atom.deserializers.add(this)
  Serializable.includeInto(this)

  # Public: Find the local path for the given repository URL.
  @pathForRepositoryUrl: (repoUrl) ->
    [repoName] = url.parse(repoUrl).path.split('/')[-1..]
    repoName = repoName.replace(/\.git$/, '')
    path.join(atom.config.get('core.projectHome'), repoName)

  constructor: ({path, @buffers}={}) ->
    @buffers ?= []

    for buffer in @buffers
      do (buffer) =>
        buffer.once 'destroyed', => @removeBuffer(buffer)

    @setPath(path)

deserializersにこのクラス自信を登録している。なるほど。
そういえばそろそろModelのコード読んだほうが良いのではないか。頻出なので。

追っていったらここっぽい。

https://github.com/atom/theorist/blob/master/src/model.coffee

さらにemissaryとかdelegatoという自前のモジュールに依存している。これめんどいしやっぱ忘れよう…

pathがプロジェクトルートで、buffersがタブに相当する予感がする。

  # Public: Sets the project's fullpath.
  setPath: (projectPath) ->
    @path = projectPath
    @rootDirectory?.off()

    @destroyRepo()
    if projectPath?
      directory = if fs.isDirectorySync(projectPath) then projectPath else path.dirname(projectPath)
      @rootDirectory = new Directory(directory)
      if @repo = Git.open(projectPath, project: this)
      1
        @repo.refreshIndex()
        @repo.refreshStatus()
    else
      @rootDirectory = null

    @emit "path-changed"

{Directory} = require 'pathwatcher'

このDirectoryというのはatom/node-pathwatcherっぽい

まあたぶんオブザーバーでディレクトリ監視なんだろう。

Git とは

Git = require './git'

冒頭のREADME読むのがよさそう。

# Public: Represents the underlying git operations performed by Atom.
#
# This class shouldn't be instantiated directly but instead by accessing the
# `atom.project` global and calling `getRepo()`. Note that this will only be
# available when the project is backed by a Git repository.
#
# This class handles submodules automatically by taking a `path` argument to many
# of the methods.  This `path` argument will determine which underlying
# repository is used.

実装眺めてみたら git-utils というの依存ているように見える

atom/git-utils

Helpers for working with Git repositories built natively on top of libgit2.

libgit2のラッパーっぽい。

次に

    @emit "path-changed"

の影響範囲を探す。

~/p/atom (remove-unused-requirements) $ git grep path-changed
spec/editor-view-spec.coffee:  describe "editor:path-changed event", ->
spec/editor-view-spec.coffee:      editorView.on 'editor:path-changed', eventHandler
spec/editor-view-spec.coffee:      editorView.on 'editor:path-changed', eventHandler
spec/editor-view-spec.coffee:        editorView.on 'editor:path-changed', eventHandler
spec/git-spec.coffee:      editor.getBuffer().emit 'path-changed'
spec/git-spec.coffee:      editor.getBuffer().emit 'path-changed'
src/editor-view.coffee:    @subscribe @editor, "path-changed", =>
src/editor-view.coffee:      @trigger 'editor:path-changed'
src/editor-view.coffee:    @trigger 'editor:path-changed'
src/editor.coffee:    @subscribe @buffer, "path-changed", =>
src/editor.coffee:      @emit "path-changed"
src/git.coffee:    @subscribe buffer, 'saved reloaded path-changed', =>
src/project.coffee:    @emit "path-changed"
src/tokenized-buffer.coffee:    @subscribe @buffer, "path-changed", => @bufferPath = @buffer.getPath()
src/workspace-view.coffee:    atom.project.on 'path-changed', => @updateTitle()

ワークスペースのタイトルが変わるのはわかるが、他は結構辛そう…　必要になったら調べよう

今ふと色々眺めてみたんだけど、このProjectクラスに生えてるメソッドは拡張とか書いたりするには実際便利そう。タブ生成したり破棄したりできる。

たとえば、今開いてるタブの本文一覧が取りたかったら次のコードでいける。

atom.project.getBuffers().map(function(buffer){return buffer.getLines().join('')})

Workspace

Projectの生成が終わったら、次はWorkspaceの生成。

  deserializeWorkspaceView: ->
    Workspace = require './workspace'
    WorkspaceView = require './workspace-view'
    @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
    @workspaceView = new WorkspaceView(@workspace)
    @keymaps.defaultTarget = @workspaceView[0]
    $(@workspaceViewParentSelector).append(@workspaceView)

WorkspaceとWorkspaceViewをnewしてる。で、@workspaceViewParentSelectorとかいう何かに投げ込んでる

  workspaceViewParentSelector: 'body'

bodyだこれ！

Workspace

class Workspace extends Model
  atom.deserializers.add(this)
  Serializable.includeInto(this)

  @delegatesProperty 'activePane', 'activePaneItem', toProperty: 'paneContainer'

  @properties
    paneContainer: -> new PaneContainer
    fullScreen: false
    destroyedItemUris: -> []

  constructor: ->
    super

    @openers = []

    @subscribe @paneContainer, 'item-destroyed', @onPaneItemDestroyed
    @registerOpener (filePath) =>
      switch filePath
        when 'atom://.atom/stylesheet'
          @open(atom.themes.getUserStylesheetPath())
        when 'atom://.atom/keymap'
          @open(atom.keymaps.getUserKeymapPath())
        when 'atom://.atom/config'
          @open(atom.config.getUserConfigPath())
        when 'atom://.atom/init-script'
          @open(atom.getUserInitScriptPath())

PaneContainerが画面分割管理の実体っぽい。
@paneContainer内部で要素が削除された時、 @onPaneItemDestroyed が呼ばれる

  # Adds the destroyed item's uri to the list of items to reopen.
  onPaneItemDestroyed: (item) =>
    if uri = item.getUri?()
      @destroyedItemUris.push(uri)

あーなるほど、タブ復元のために破棄したアイテムのuri(あとで調べる)をpushしてる。

registerOpener

  registerOpener: (opener) ->
    @openers.push(opener)

@openersにコールバック登録、かな

filepathがatomの設定ファイルならば、open を呼ぶ。stylesheet とかkeymap は前回見たからいいとして、init-script は初めて見たので調べる。

src/atom.coffee

  getUserInitScriptPath: ->
    initScriptPath = fs.resolve(@getConfigDirPath(), 'init', ['js', 'coffee'])
    initScriptPath ? path.join(@getConfigDirPath(), 'init.coffee')

  getUserInitScriptPath: ->
    initScriptPath = fs.resolve(@getConfigDirPath(), 'init', ['js', 'coffee'])
    initScriptPath ? path.join(@getConfigDirPath(), 'init.coffee')

~/.atom/init.coffeeかな？自分のローカルの設定ファイルを見てみる。

# Your init script
#
# Atom will evaluate this file each time a new window is opened. It is run
# after packages are loaded/activated and after the previous editor state
# has been restored.
#
# An example hack to make opened Markdown files always be soft wrapped:
#
# path = require 'path'
#
# atom.workspaceView.eachEditorView (editorView) ->
#   editor = editorView.getEditor()
#   if path.extname(editor.getPath()) is '.md'
#     editor.setSoftWrap(true)

こいつを読み込んでどっかで実行するんだろう

PaneCotainer

class PaneContainer extends Model
  atom.deserializers.add(this)
  Serializable.includeInto(this)

  @properties
    root: -> new Pane
    activePane: null

  previousRoot: null

  @behavior 'activePaneItem', ->
    @$activePane
      .switch((activePane) -> activePane?.$activeItem)
      .distinctUntilChanged()

  constructor: (params) ->
    super
    @subscribe @$root, @onRootChanged
    @destroyEmptyPanes() if params?.destroyEmptyPanes

なんかrootを軸にList構造作ってから配置する感じだろうか

module.exports 
class Pane extends Model
  atom.deserializers.add(this)
  Serializable.includeInto(this)

# ...

  constructor: (params) ->
    super

    @items = Sequence.fromArray(compact(params?.items ? []))
    @activeItem ?= @items[0]

    @subscribe @items.onEach (item) =>
      if typeof item.on is 'function'
        @subscribe item, 'destroyed', => @removeItem(item, true)

    @subscribe @items.onRemoval (item, index) =>
      @unsubscribe item if typeof item.on is 'function'

    @activate() if params?.active

activate

  # Public: Makes this pane the *active* pane, causing it to gain focus
  # immediately.
  activate: ->
    @container?.activePane = this
    @emit 'activated'

次にWorkspaceViewを調べるか

WorkspaceView

ありがたいコメント

# Public: The top-level view for the entire window. An instance of this class is
# available via the `atom.workspaceView` global.

Viewを継承してるのでconstructorじゃなくてinitializeを使う。Backboneと同じ設計。

  initialize: (@model) ->
    @model = atom.workspace ? new Workspace unless @model?

    panes = new PaneContainerView(@model.paneContainer)
    @panes.replaceWith(panes)
    @panes = panes

    @subscribe @model, 'uri-opened', => @trigger 'uri-opened'

PaneContainerView

class PaneContainerView extends View
  Delegator.includeInto(this)

  @delegatesMethod 'saveAll', toProperty: 'model'

  @content: ->
    @div class: 'panes'

  initialize: (params) ->
    if params instanceof PaneContainer
      @model = params
    else
      @model = new PaneContainer({root: params?.root?.model})

    @subscribe @model.$root, @onRootChanged
    @subscribe @model.$activePaneItem.changes, @onActivePaneItemChanged

WorkspaceViewはinitializeでイベントを登録してる。それに対応するのはbrowser/atom-application側でhandleされてる

src/workspace-view.coffee

    @command 'application:about', -> ipc.send('command', 'application:about')
    @command 'application:run-all-specs', -> ipc.send('command', 'application:run-all-specs')
    @command 'application:run-benchmarks', -> ipc.send('command', 'application:run-benchmarks')
    @command 'application:show-settings', -> ipc.send('command', 'application:show-settings')
    @command 'application:quit', -> ipc.send('command', 'application:quit')
    @command 'application:hide', -> ipc.send('command', 'application:hide')
    @command 'application:hide-other-applications', -> ipc.send('command', 'application:hide-other-applications')
    @command 'application:unhide-all-applications', -> ipc.send('command', 'application:unhide-all-applications')
    @command 'application:new-window', -> ipc.send('command', 'application:new-window')
    @command 'application:new-file', -> ipc.send('command', 'application:new-file')
    @command 'application:open', -> ipc.send('command', 'application:open')
    ...

src/borwser/atom-application.coffee

  # Registers basic application commands, non-idempotent.
  handleEvents: ->
    @on 'application:run-all-specs', -> @runSpecs(exitWhenDone: false, resourcePath: global.devResourcePath)
    @on 'application:run-benchmarks', -> @runBenchmarks()
    @on 'application:quit', -> app.quit()
    @on 'application:new-window', -> @openPath(windowDimensions: @focusedWindow()?.getDimensions())
    @on 'application:new-file', -> (@focusedWindow() ? this).openPath()
    @on 'application:open', -> @promptForPath(type: 'all')
    @on 'application:open-file', -> @promptForPath(type: 'file')
    @on 'application:open-folder', -> @promptForPath(type: 'folder')
    @on 'application:open-dev', -> @promptForPath(devMode: true)
    @on 'application:open-safe', -> @promptForPath(safeMode: true)
    @on 'application:inspect', ({x,y, atomWindow}) ->
    ...