Merge pull request #1513 from swagger-api/feature/jump-to-plugin

move jumpToPath into its own plugin

Author: shockey

src/index.js

@@ -12,6 +12,7 @@ import EditorAutosuggestSnippetsPlugin from "./plugins/editor-autosuggest-snippe
 import EditorAutosuggestKeywordsPlugin from "./plugins/editor-autosuggest-keywords"
 import EditorAutosuggestOAS3KeywordsPlugin from "./plugins/editor-autosuggest-oas3-keywords"
 import EditorAutosuggestRefsPlugin from "./plugins/editor-autosuggest-refs"
+import JumpToPathPlugin from "./plugins/jump-to-path"
 
 // eslint-disable-next-line no-undef
 const { GIT_DIRTY, GIT_COMMIT, PACKAGE_VERSION } = buildInfo
@@ -28,6 +29,7 @@ const plugins = {
   EditorAutosuggestKeywordsPlugin,
   EditorAutosuggestRefsPlugin,
   EditorAutosuggestOAS3KeywordsPlugin,
+  JumpToPathPlugin,
 }
 
 const defaults = {

src/plugins/editor/index.js

@@ -1,6 +1,5 @@
 import makeEditor from "./components/editor"
 import EditorContainer from "./components/editor-container"
-import JumpToPath from "./components/jump-to-path"
 import * as actions from "./actions"
 import reducers from "./reducers"
 import * as selectors from "./selectors"
@@ -11,7 +10,7 @@ let Editor = makeEditor({
 
 export default function () {
   return {
-    components: { Editor, EditorContainer, JumpToPath },
+    components: { Editor, EditorContainer },
     statePlugins: {
       editor: {
         reducers,

src/plugins/editor/components/jump-to-path.jsx renamed to src/plugins/jump-to-path/components.jsx

@@ -1,32 +1,43 @@
 import React, { PropTypes } from "react"
 import JumpIcon from "./jump-icon.svg"
 
-export default class JumpToPath extends React.Component {
+export class JumpToPath extends React.Component {
   static propTypes = {
     editorActions: PropTypes.object.isRequired,
     specSelectors: PropTypes.object.isRequired,
     fn: PropTypes.object.isRequired,
     path: PropTypes.oneOfType([
       PropTypes.array,
       PropTypes.string
-    ]).isRequired,
+    ]),
     content: PropTypes.element,
-    showButton: PropTypes.bool
+    showButton: PropTypes.bool,
+    specPath: PropTypes.array, // The location within the spec. Used as a fallback if `path` doesn't exist
+  }
+
+  static defaultProps = {
+    path: "",
   }
 
   shouldComponentUpdate(nextProps) {
     let { shallowEqualKeys } = nextProps.fn
     return shallowEqualKeys(this.props, nextProps, [
-      "content", "showButton", "path"
+      "content", "showButton", "path", "specPath"
     ])
   }
 
   jumpToPath = (e) => {
     e.stopPropagation()
 
-    let { path, fn: { AST, transformPathToArray }, specSelectors: { specStr, specJson }, editorActions } = this.props
-    let line = AST.getLineNumberForPath(specStr(), typeof path === "string" ? transformPathToArray(path, specJson().toJS()) : path)
-    editorActions.jumpToLine(line)
+    const {
+      specPath=[],
+      path,
+      specSelectors,
+      editorActions
+    } = this.props
+
+    const jumpPath = specSelectors.bestJumpPath({path, specPath})
+    editorActions.jumpToLine(specSelectors.getSpecLineFromPath(jumpPath))
   }
 
 

src/plugins/jump-to-path/index.js

@@ -0,0 +1,11 @@
+import spec from "./spec"
+import * as components from "./components"
+
+export default function JumpToPathPlugin() {
+  return [
+    spec,
+    {
+      components,
+    }
+  ]
+}

src/plugins/editor/components/jump-icon.svg renamed to src/plugins/jump-to-path/jump-icon.svg

@@ -0,0 +1,86 @@
+export default function spec() {
+  return {
+    statePlugins: {
+      spec: {
+        selectors: {
+
+          getSpecLineFromPath: (state, path) => ({fn: { AST }, specSelectors: { specStr }}) => {
+            return AST.getLineNumberForPath(specStr(), path)
+          },
+
+          // This will search return `path if it exists, else it'll look for the best $ref jump point
+          // There is one caveat, it'll not search _down_ for deeply nested $refs. In those cases, it'll bring you to the shallower $ref.
+          bestJumpPath: (state, {path, specPath}) => (system) => {
+            const {
+              specSelectors: { specJson },
+              fn: { transformPathToArray }
+            } = system
+
+            // We"ve been given an explicit path? Use that...
+            if(path) {
+              return typeof path === "string" ? transformPathToArray(path, specJson().toJS()) : path
+            }
+
+            // Try each path in the resolved spec, starting from the deepest
+            for(let i = specPath.length; i >= 0; i--) {
+              const tryPath = specPath.slice(0,i)
+
+              // A $ref exists in the source? ( ie: pre-resolver)
+              const $ref = specJson().getIn([...tryPath, "$ref"])
+              // We have a $ref in the source?
+              if($ref) {
+                if(!/^#\//.test($ref)) {
+                  return [...tryPath, "$ref"]
+                } else { // Is local $ref
+                  // Get rid of the trailing '#'
+                  const pointer = $ref.charAt(0) === "#" ? $ref.substr(1) : $ref
+                  return jsonPointerToArray(pointer)
+                }
+              }
+
+              // This path exists in the source spec?
+              if(specJson().hasIn(tryPath)) {
+                return tryPath
+              }
+            }
+
+            // ...else just specPath, which is hopefully close enough
+            return specPath
+          }
+        }
+      }
+    }
+  }
+}
+
+// Copied out of swagger-client, not sure if it should be exposed as a lib or as part of the public swagger-client api.
+/**
+ * Converts a JSON pointer to array.
+ * @api public
+ */
+function jsonPointerToArray(pointer) {
+  if (typeof pointer !== "string") {
+    throw new TypeError(`Expected a string, got a ${typeof pointer}`)
+  }
+
+  if (pointer[0] === "/") {
+    pointer = pointer.substr(1)
+  }
+
+  if (pointer === "") {
+    return []
+  }
+
+  return pointer.split("/").map(unescapeJsonPointerToken)
+}
+
+/**
+ * Unescapes a JSON pointer.
+ * @api public
+ */
+function unescapeJsonPointerToken(token) {
+  if (typeof token !== "string") {
+    return token
+  }
+  return token.replace(/~1/g, "/").replace(/~0/g, "~")
+}