Merge pull request #35 from fletcherist/feature/matchers

Feature/matchers

Author: fletcherist

CHANGELOG.md

@@ -1,3 +1,20 @@
+<a name="1.3.3"></a>
+## [1.3.3](https://github.com/fletcherist/yandex-dialogs-sdk/compare/v1.3.2...v1.3.3) (2018-07-08)
+
+
+### Bug Fixes
+
+* bug with commands (array) ([8cac580](https://github.com/fletcherist/yandex-dialogs-sdk/commit/8cac580))
+* package.json ([169a818](https://github.com/fletcherist/yandex-dialogs-sdk/commit/169a818))
+
+
+### Features
+
+* add guess number game to examples ([3d34c26](https://github.com/fletcherist/yandex-dialogs-sdk/commit/3d34c26))
+* add youtube link to readme ([31c8328](https://github.com/fletcherist/yandex-dialogs-sdk/commit/31c8328))
+
+
+
 <a name="1.3.2"></a>
 ## [1.3.2](https://github.com/fletcherist/yandex-dialogs-sdk/compare/v1.2.1...v1.3.2) (2018-07-08)
 

package.json

@@ -1,15 +1,16 @@
 {
   "name": "yandex-dialogs-sdk",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Build your skill for Alice with ease.",
   "main": "dist/index.js",
   "scripts": {
     "lint": "eslint src",
     "test": "jest",
     "dev": "tsc -w",
     "build": "tsc",
-    "version": "npm run changelog && git add CHANGELOG.md && conventional-github-releaser -p angular",
+    "version": "npm run changelog && git add CHANGELOG.md",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "release": "conventional-github-releaser -p angular",
     "deploy": "tsc && git push --follow-tags origin master && npm publish"
   },
   "repository": {

src/alice.ts

@@ -112,6 +112,23 @@ export default class Alice {
     const sessionId = selectSessionId(req)
     const session = this.sessions.findOrCreate(sessionId)
 
+    /*
+     * Initializing context of the request
+     */
+    const ctxDefaultParams = {
+      req,
+      session,
+      sendResponse: sendResponse || null,
+      /*
+       * if Alice is listening on express.js port, add this server instance
+       * to the context
+       */
+      server: this.server || null,
+      middlewares: this.middlewares,
+    }
+    const ctxInstance = new Ctx(ctxDefaultParams)
+    const ctxWithMiddlewares = await applyMiddlewares(this.middlewares, ctxInstance)
+
     /* check whether current scene is not defined */
     if (!session.getData('currentScene')) {
       session.setData('currentScene', null)
@@ -129,12 +146,12 @@ export default class Alice {
        */
       if (matchedScene) {
         if (matchedScene.isLeaveCommand(requestedCommandName)) {
-          matchedScene.handleRequest(req, sendResponse, session)
+          await matchedScene.handleRequest(req, sendResponse, ctxWithMiddlewares)
           session.setData('currentScene', null)
           return true
         } else {
           const sceneResponse = await matchedScene.handleRequest(
-            req, sendResponse, session,
+            req, sendResponse, ctxWithMiddlewares,
           )
           if (sceneResponse) {
             return true
@@ -150,31 +167,15 @@ export default class Alice {
       if (matchedScene) {
         session.setData('currentScene', matchedScene.name)
         const sceneResponse = await matchedScene.handleRequest(
-          req, sendResponse, session,
+          req, sendResponse, ctxWithMiddlewares,
         )
         if (sceneResponse) {
           return true
         }
       }
     }
 
-    const requestedCommands = this.commands.search(requestedCommandName)
-
-    /*
-     * Initializing context of the request
-     */
-    const ctxDefaultParams = {
-      req,
-      session,
-      sendResponse: sendResponse || null,
-      /*
-       * if Alice is listening on express.js port, add this server instance
-       * to the context
-       */
-      server: this.server || null,
-      middlewares: this.middlewares,
-    }
-
+    const requestedCommands = await this.commands.search(ctxWithMiddlewares)
     /*
     * Если новая сессия, то запускаем стартовую команду
     */
@@ -183,10 +184,6 @@ export default class Alice {
        * Patch context with middlewares
        */
       if (this.welcomeCallback) {
-        // tslint:disable:no-shadowed-variable
-        const ctxInstance = new Ctx(ctxDefaultParams)
-        const ctxWithMiddlewares = await applyMiddlewares(this.middlewares, ctxInstance)
-        // tslint:enable:no-shadowed-variable
         return await this.welcomeCallback(ctxWithMiddlewares)
       }
     }
@@ -196,22 +193,14 @@ export default class Alice {
      */
     if (requestedCommands.length !== 0) {
       const requestedCommand: CommandInterface = requestedCommands[0]
-      // tslint:disable:no-shadowed-variable
-      const ctxInstance = new Ctx(merge(ctxDefaultParams, {
-        command: requestedCommand,
-      }))
-      const ctxWithMiddlewares = await applyMiddlewares(this.middlewares, ctxInstance)
-      // tslint:enable:no-shadowed-variable
+      ctxWithMiddlewares.command = requestedCommand
       return await requestedCommand.callback(ctxWithMiddlewares)
     }
 
     /*
      * Такой команды не было зарегестрировано.
      * Переходим в обработчик исключений
      */
-    const ctxInstance = new Ctx(ctxDefaultParams)
-    const ctxWithMiddlewares = await applyMiddlewares(this.middlewares, ctxInstance)
-
     if (!this.anyCallback) {
       throw new Error([
         `alice.any(ctx => ctx.reply('404')) Method must be defined`,
@@ -227,7 +216,7 @@ export default class Alice {
   public async handleRequest(
     req: WebhookRequest,
     sendResponse?: (res: WebhookResponse) => void,
-  ) {
+  ): Promise<any> {
     return await this.handleRequestBody(req, sendResponse)
   }
 

src/command.ts

@@ -3,17 +3,24 @@ import {
     TYPE_FIGURE,
     TYPE_REGEXP,
     TYPE_ARRAY,
+    TYPE_MATCHER,
 } from './constants'
 import Ctx from './ctx'
-import { CommandInterface, CallbackType, CommandType } from './types/command'
+import {
+    CommandInterface,
+    CallbackType,
+    CommandType,
+    CommandNameType,
+} from './types/command'
 import { CtxInterface } from './types/ctx'
+import { isFunction } from './utils'
 
 export default class Command implements CommandInterface {
-    public name: any[] | string | RegExp
-    public type: | CommandType
+    public name: CommandNameType
+    public type: CommandType
     public callback: CallbackType
 
-    constructor(name: string, callback: CallbackType) {
+    constructor(name: CommandNameType, callback: CallbackType) {
         if (name === undefined) { throw new Error('Command name is not specified') }
         this.name = name
         this.callback = callback
@@ -25,18 +32,20 @@ export default class Command implements CommandInterface {
     public _defineCommandType(name) {
         let type
 
-        if (typeof name === 'string') {
-        type = TYPE_STRING
-        if (name.includes('${')) {
-            type = TYPE_FIGURE
-        }
+        if (isFunction(name)) {
+            type = TYPE_MATCHER
+        } else if (typeof name === 'string') {
+            type = TYPE_STRING
+            if (name.includes('${')) {
+                type = TYPE_FIGURE
+            }
         } else if (name instanceof RegExp) {
-        type = TYPE_REGEXP
+            type = TYPE_REGEXP
         } else if (Array.isArray(name)) {
-        type = TYPE_ARRAY
+            type = TYPE_ARRAY
         } else {
-        throw new Error(`Command name is not of proper type.
-            Could be only string, array of strings or regular expression`)
+            throw new Error(`Command name is not of proper type.
+                Could be only string, array of strings, regular expression or function`)
         }
         return type
     }

src/commands.ts

@@ -7,9 +7,11 @@ import {
   TYPE_ARRAY,
   TYPE_REGEXP,
   TYPE_FIGURE,
+  TYPE_MATCHER,
 } from './constants'
 import { CommandsInterface } from './types/commands'
 import { CommandInterface } from './types/command'
+import { CtxInterface } from 'ctx'
 
 export default class Commands implements CommandsInterface {
   public commands: CommandInterface[]
@@ -28,6 +30,9 @@ export default class Commands implements CommandsInterface {
     return this.commands
   }
 
+  get _matchers() {
+    return this.commands.filter((command) => command.type === TYPE_MATCHER)
+  }
   get _strings() {
     return this.commands.filter((command) =>
       [TYPE_FIGURE, TYPE_STRING, TYPE_ARRAY].includes(command.type),
@@ -40,31 +45,14 @@ export default class Commands implements CommandsInterface {
     return this.commands.filter((command) => command.type === TYPE_REGEXP)
   }
 
-  public _searchStrings(requestedCommandName) {
-    const stringCommands = this._strings
-    const fuse = new Fuse(stringCommands, this.fuseOptions)
-    return fuse.search(requestedCommandName)
-  }
-
-  public _searchFigures(requestedCommandName) {
-    const figuresCommands = this._figures
-    return figuresCommands.filter((figure) => {
-      const reg = utils.getFiguresRegexp(figure.name)
-      return requestedCommandName.match(reg)
-    })
-  }
-
-  public _searchRegexps(requestedCommandName) {
-    const regexpCommands = this._regexps
-    // @TODO: include matches and captured groups
-    return regexpCommands.filter((reg) => requestedCommandName.match(reg.name))
-  }
-
-  public search(requestedCommandName) {
-    const matchedStrings = this._searchStrings(requestedCommandName)
-    const matchedRegexps = this._searchRegexps(requestedCommandName)
-    const matchedFigures = this._searchFigures(requestedCommandName)
-    if (matchedStrings.length > 0) {
+  public async search(ctx: CtxInterface) {
+    const matchedStrings = this._searchStrings(ctx.message)
+    const matchedRegexps = this._searchRegexps(ctx.message)
+    const matchedFigures = this._searchFigures(ctx.message)
+    const matchedMatchers = await this._searchMatchers(ctx)
+    if (matchedMatchers.length > 0) {
+      return matchedMatchers
+    } else if (matchedStrings.length > 0) {
       return matchedStrings
     } else if (matchedRegexps.length > 0) {
       return matchedRegexps
@@ -93,6 +81,36 @@ export default class Commands implements CommandsInterface {
   public flush() {
     this.commands = []
   }
+
+  private async _searchMatchers(ctx: CtxInterface) {
+    const matchers = this._matchers
+    for (const matcher of matchers) {
+      if (await matcher.name(ctx)) {
+        return [matcher]
+      }
+    }
+    return []
+  }
+
+  private _searchStrings(requestedCommandName: string) {
+    const stringCommands = this._strings
+    const fuse = new Fuse(stringCommands, this.fuseOptions)
+    return fuse.search(requestedCommandName)
+  }
+
+  private _searchFigures(requestedCommandName: string) {
+    const figuresCommands = this._figures
+    return figuresCommands.filter((figure) => {
+      const reg = utils.getFiguresRegexp(figure.name)
+      return requestedCommandName.match(reg)
+    })
+  }
+
+  private _searchRegexps(requestedCommandName) {
+    const regexpCommands = this._regexps
+    // @TODO: include matches and captured groups
+    return regexpCommands.filter((reg) => requestedCommandName.match(reg.name))
+  }
 }
 
 module.exports = Commands

src/constants.ts

@@ -2,6 +2,7 @@ export const TYPE_STRING = 'string'
 export const TYPE_FIGURE = 'figure'
 export const TYPE_REGEXP = 'regexp'
 export const TYPE_ARRAY = 'array'
+export const TYPE_MATCHER = 'matcher'
 
 export const ALICE_PROTOCOL_VERSION = '1.0'
 export const DEFAULT_END_SESSION = false

src/ctx.ts

@@ -22,8 +22,8 @@ export default class Ctx implements CtxInterface {
   public replyBuilder: ReplyBuilder
   public buttonBuilder: ButtonBuilder
 
-  public sendResponse: (response: string) => void
-  public enterScene: () => void
+  public sendResponse: (response: WebhookResponse) => void
+  public enterScene: (sceneName: string) => void
   public leaveScene: () => void
   constructor(params) {
     const {

src/scene.ts

@@ -4,6 +4,8 @@ import Command from './Command'
 import Ctx from './ctx'
 
 import { configInterface } from './types/alice'
+import { WebhookRequest, WebhookResponse } from './types/webhook'
+import { CtxInterface } from 'ctx'
 
 const selectCommand = (req) => req.request.command
 
@@ -70,32 +72,32 @@ export default class Scene extends Alice {
     return this.leaveCommand.name.toLowerCase() === commandName.toLowerCase()
   }
 
-  public async handleRequest(req, sendResponse, session) {
-    const requestedCommandName = selectCommand(req)
-    const requestedCommands = this.commands.search(requestedCommandName)
+  public async handleRequest(
+    req: WebhookRequest,
+    sendResponse: (res: WebhookResponse) => void,
+    ctx: CtxInterface,
+  ): Promise<any> {
 
-    if (this.isLeaveCommand(requestedCommandName)) {
+    ctx.sendResponse = sendResponse
+    ctx.leaveScene = super._handleLeaveScene
+    ctx.enterScene = super._handleEnterScene
+
+    const requestedCommands = await this.commands.search(ctx)
+
+    if (this.isLeaveCommand(ctx.message)) {
       this._handleLeaveScene()
     }
 
-    const ctx = new Ctx({
-      req,
-      sendResponse: sendResponse || null,
-      leaveScene: super._handleLeaveScene,
-      enterScene: super._handleEnterScene,
-      session,
-    })
-
     if (requestedCommands.length !== 0) {
       const requestedCommand = requestedCommands[0]
-      return await requestedCommand.callback.call(this, ctx)
+      return await requestedCommand.callback(ctx)
     }
 
     if (this.anyCallback) {
-      return this.anyCallback(ctx)
+      return await this.anyCallback(ctx)
     }
 
-    return null
+    return Promise.resolve()
   }
 }