See #18. Most of the language tests are successful.

Tests that start with underscores (_) are hidden and not tested.
Those must eventually be solved.

examples/nested-jsbeautifyrc/markdown/expected/test.md

@@ -2,3 +2,4 @@
     1.  one
     2.  two
     3.  three
+

examples/simple-jsbeautifyrc/markdown/expected/test.md

@@ -5,3 +5,4 @@
 1.  one
 2.  two
 3.  three
+

lib/options.coffee

@@ -0,0 +1,194 @@
+# Lazy loaded dependencies
+_ = require("lodash")
+path = require("path")
+fs = null
+strip = null
+yaml = null
+editorconfig = null
+beautifier = require("./language-options")
+languages = beautifier.languages
+defaultLanguageOptions = beautifier.defaultLanguageOptions
+
+module.exports =
+  findFileResults: {}
+
+  # CLI
+  getUserHome: ->
+    process.env.HOME or process.env.HOMEPATH or process.env.USERPROFILE
+
+  verifyExists: (fullPath) ->
+    fs ?= require("fs")
+    (if fs.existsSync(fullPath) then fullPath else null)
+
+  # Storage for memoized results from find file
+  # Should prevent lots of directory traversal &
+  # lookups when liniting an entire project
+
+  ###
+  Searches for a file with a specified name starting with
+  'dir' and going all the way up either until it finds the file
+  or hits the root.
+
+  @param {string} name filename to search for (e.g. .jshintrc)
+  @param {string} dir directory to start search from (default:
+  current working directory)
+  @param {boolean} upwards should recurse upwards on failure? (default: true)
+
+  @returns {string} normalized filename
+  ###
+  findFile: (name, dir, upwards=true) ->
+    path ?= require("path")
+    dir = dir or process.cwd()
+    filename = path.normalize(path.join(dir, name))
+    return @findFileResults[filename] if @findFileResults[filename] isnt `undefined`
+    parent = path.resolve(dir, "../")
+    if @verifyExists(filename)
+      @findFileResults[filename] = filename
+      return filename
+    if dir is parent
+      @findFileResults[filename] = null
+      return null
+    if upwards
+      findFile name, parent
+    else
+      return null
+
+  ###
+  Tries to find a configuration file in either project directory
+  or in the home directory. Configuration files are named
+  '.jsbeautifyrc'.
+
+  @param {string} config name of the configuration file
+  @param {string} file path to the file to be linted
+  @param {boolean} upwards should recurse upwards on failure? (default: true)
+
+  @returns {string} a path to the config file
+  ###
+  findConfig: (config, file, upwards=true) ->
+    path ?= require("path")
+    dir = path.dirname(path.resolve(file))
+    envs = @getUserHome()
+    home = path.normalize(path.join(envs, config))
+    proj = @findFile(config, dir, upwards)
+    return proj if proj
+    return home if @verifyExists(home)
+    null
+  getConfigOptionsFromSettings: (langs) ->
+    config = atom.config.get('atom-beautify')
+    options = {}
+    # console.log(langs, config);
+    # Iterate over keys of the settings
+    _.every _.keys(config), (k) ->
+      # Check if keys start with a language
+      p = k.split("_")[0]
+      idx = _.indexOf(langs, p)
+      # console.log(k, p, idx);
+      if idx >= 0
+        # Remove the language prefix and nest in options
+        lang = langs[idx]
+        opt = k.replace(new RegExp("^" + lang + "_"), "")
+        options[lang] = options[lang] or {}
+        options[lang][opt] = config[k]
+        # console.log(lang, opt);
+      true
+    # console.log(options);
+    options
+
+
+  # Look for .jsbeautifierrc in file and home path, check env variables
+  getConfig: (startPath, upwards=true) ->
+    # Verify that startPath is a string
+    startPath = (if (typeof startPath is "string") then startPath else "")
+    return {} unless startPath
+    # Get the path to the config file
+    configPath = @findConfig(".jsbeautifyrc", startPath, upwards)
+    externalOptions = undefined
+    if configPath
+      fs ?= require("fs")
+      contents = fs.readFileSync(configPath,
+        encoding: "utf8"
+      )
+      unless contents
+        externalOptions = {}
+      else
+        try
+          strip ?= require("strip-json-comments")
+          externalOptions = JSON.parse(strip(contents))
+        catch e
+          console.log "Failed parsing config as JSON: " + configPath
+          # Attempt as YAML
+          try
+            yaml ?= require("js-yaml")
+            externalOptions = yaml.safeLoad(contents)
+          catch e
+            console.log "Failed parsing config as YAML: " + configPath
+            externalOptions = {}
+    else
+      externalOptions = {}
+    externalOptions
+
+  getOptionsForPath: (editedFilePath, editor) ->
+
+    # Editor Options
+    editorOptions = {}
+    if editor?
+      # Get current Atom editor configuration
+      isSelection = !!editor.getSelectedText()
+      softTabs = editor.softTabs
+      tabLength = editor.getTabLength()
+      editorOptions =
+        indent_size: (if softTabs then tabLength else 1)
+        indent_char: (if softTabs then " " else "\t")
+        indent_with_tabs: not softTabs
+
+    # From Package Settings
+    configOptions = @getConfigOptionsFromSettings(languages)
+
+    # Get configuration in User's Home directory
+    userHome = @getUserHome()
+    # FAKEFILENAME forces `path` to treat as file path and it's parent directory
+    # is the userHome. See implementation of findConfig
+    # and how path.dirname(DIRECTORY) returns the parent directory of DIRECTORY
+    homeOptions = @getConfig(path.join(userHome,"FAKEFILENAME"), false)
+
+    if editedFilePath?
+      # Handle EditorConfig options
+      # http://editorconfig.org/
+      editorconfig ?= require('editorconfig');
+      editorConfigOptions = editorconfig.parse(editedFilePath);
+      # Transform EditorConfig to Atom Beautify's config structure and naming
+      if editorConfigOptions.indent_style is 'space'
+        editorConfigOptions.indent_char = " "
+        # if (editorConfigOptions.indent_size)
+        #   editorConfigOptions.indent_size = config.indent_size
+      else if editorConfigOptions.indent_style is 'tab'
+        editorConfigOptions.indent_char = "\t"
+        editorConfigOptions.indent_with_tabs = true
+        if (editorConfigOptions.tab_width)
+            editorConfigOptions.indent_size = editorConfigOptions.tab_width
+
+      # Get all options in configuration files from this directory upwards to root
+      projectOptions = []
+      p = path.dirname(editedFilePath)
+      # Check if p is root (top directory)
+      while p isnt path.resolve(p,"../")
+        # Get config for p
+        pf = path.join(p, "FAKEFILENAME")
+        pc = @getConfig(pf, false)
+        # Add config for p to project's config options
+        projectOptions.push(pc)
+        # console.log p, pc
+        # Move upwards
+        p = path.resolve(p,"../")
+    else
+      editorConfigOptions = {}
+      projectOptions = []
+
+    # Combine all options together
+    allOptions = [
+      editorOptions
+      configOptions
+      homeOptions
+      editorConfigOptions
+    ]
+    allOptions = allOptions.concat(projectOptions)

spec/beautify-languages-spec.coffee

@@ -4,6 +4,7 @@ languages = beautifier.languages
 defaultLanguageOptions = beautifier.defaultLanguageOptions
 fs = require "fs"
 path = require "path"
+options = require "../lib/options"
 
 # Use the command `window:run-package-specs` (cmd-alt-ctrl-p) to run specs.
 #
@@ -35,9 +36,9 @@ describe "BeautifyLanguages", ->
      - config1
        - lang1
          - original
-          - 1-test.ext
+           - 1 - test.ext
          - expected
-          - 1-test.ext
+           - 1 - test.ext
        - lang2
      - config2
   ###
@@ -84,8 +85,12 @@ describe "BeautifyLanguages", ->
                     do (testFileName) ->
                       ext = path.extname(testFileName)
                       testName = path.basename(testFileName, ext)
+                      # If prefixed with underscore (_) then this is a hidden test
+                      if testFileName[0] is '_'
+                        # Do not show this test
+                        return
                       # Confirm this is a test
-                      it "#{testName}", ->
+                      it "#{testName} #{testFileName}", ->
 
                         # Generate paths to test files
                         originalTestPath = path.resolve(originalDir, testFileName)
@@ -95,7 +100,7 @@ describe "BeautifyLanguages", ->
                         # Check if there is a matching expected test resut
                         if not fs.existsSync(expectedTestPath)
                           throw new Error("No matching expected test result found for '#{testName}' " +
-                                       "at '#{expectedTestPath}'. Creating it from original.")
+                                       "at '#{expectedTestPath}'.")
                           # err = fs.writeFileSync(expectedTestPath, originalContents)
                           # throw err if err
                         # Get contents of expected test file
@@ -106,18 +111,15 @@ describe "BeautifyLanguages", ->
                         # expect(grammar).toEqual("test")
                         grammarName = grammar.name
 
-                        editorOptions =
-                          indent_size: 4
-                          indent_char: " "
-                          indent_with_tabs: false
-
-                        allOptions = [editorOptions]
+                        allOptions = options.getOptionsForPath(originalTestPath)
 
                         beautifyCompleted = false
                         completionFun = (text) ->
                           if text instanceof Error
                             return beautifyCompleted = text # text == Error
                           expect(typeof text).toEqual "string"
+                          if text isnt expectedContents
+                            console.warn(allOptions, text, expectedContents)
                           expect(text).toEqual expectedContents
                           beautifyCompleted = true