refactor: Context#propertyAccessSeq => parseProp

src/context/context.ts

@@ -22,8 +22,8 @@ export default class Context {
       .reduce((ctx, val) => __assign(ctx, val), {})
   }
   async get (path: string) {
-    const paths = await this.propertyAccessSeq(path)
-    let ctx = this.findContextFor(paths[0]) || this.environments
+    const paths = await this.parseProp(path)
+    let ctx = this.findScope(paths[0]) || this.environments
     for (const path of paths) {
       ctx = this.readProperty(ctx, path)
       if (_.isNil(ctx) && this.opts.strictVariables) {
@@ -45,7 +45,7 @@ export default class Context {
     }
     return this.scopes.splice(i, 1)[0]
   }
-  findContextFor (key: string) {
+  findScope (key: string) {
     for (let i = this.scopes.length - 1; i >= 0; i--) {
       const candidate = this.scopes[i]
       if (key in candidate) {
@@ -73,7 +73,7 @@ export default class Context {
    * accessSeq("foo['b]r']")      // ['foo', 'b]r']
    * accessSeq("foo[bar.coo]")    // ['foo', 'bar'], for bar.coo == 'bar'
    */
-  async propertyAccessSeq (str: string) {
+  async parseProp (str: string) {
     str = String(str)
     const seq: string[] = []
     let name = ''

test/unit/context/context.ts

@@ -22,39 +22,39 @@ describe('scope', function () {
 
   describe('#propertyAccessSeq()', function () {
     it('should handle dot syntax', async function () {
-      expect(await ctx.propertyAccessSeq('foo.bar'))
+      expect(await ctx.parseProp('foo.bar'))
         .to.deep.equal(['foo', 'bar'])
     })
     it('should handle [<String>] syntax', async function () {
-      expect(await ctx.propertyAccessSeq('foo["bar"]'))
+      expect(await ctx.parseProp('foo["bar"]'))
         .to.deep.equal(['foo', 'bar'])
     })
     it('should handle [<Identifier>] syntax', async function () {
-      expect(await ctx.propertyAccessSeq('foo[foo]'))
+      expect(await ctx.parseProp('foo[foo]'))
         .to.deep.equal(['foo', 'zoo'])
     })
     it('should handle nested access 1', async function () {
-      expect(await ctx.propertyAccessSeq('foo[bar.zoo]'))
+      expect(await ctx.parseProp('foo[bar.zoo]'))
         .to.deep.equal(['foo', 'coo'])
     })
     it('should handle nested access 2', async function () {
-      expect(await ctx.propertyAccessSeq('foo[bar["zoo"]]'))
+      expect(await ctx.parseProp('foo[bar["zoo"]]'))
         .to.deep.equal(['foo', 'coo'])
     })
     it('should handle nested access 3', async function () {
-      expect(await ctx.propertyAccessSeq('bar["foo"].zoo'))
+      expect(await ctx.parseProp('bar["foo"].zoo'))
         .to.deep.equal(['bar', 'foo', 'zoo'])
     })
     it('should handle nested access 4', async function () {
-      expect(await ctx.propertyAccessSeq('foo[0].bar'))
+      expect(await ctx.parseProp('foo[0].bar'))
         .to.deep.equal(['foo', '0', 'bar'])
     })
     it('should handle nested access 5', async function () {
-      expect(await ctx.propertyAccessSeq('foo[one].bar'))
+      expect(await ctx.parseProp('foo[one].bar'))
         .to.deep.equal(['foo', '1', 'bar'])
     })
     it('should handle nested access 6', async function () {
-      expect(await ctx.propertyAccessSeq('foo[two].bar'))
+      expect(await ctx.parseProp('foo[two].bar'))
         .to.deep.equal(['foo', 'undefined', 'bar'])
     })
   })