Start of Analyzer for Bird Watcher

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.22.0
+
+- Add analyzer for `concept/bird-watcher`
+
 ## 0.21.0
 
 - Add analyzer for `concept/elyses-analytic-enchantments`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exercism/javascript-analyzer",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Exercism analyzer for javascript",
   "repository": "https://github.com/exercism/javascript-analyzer",
   "author": "Derk-Jan Karrenbeld <[email protected]>",

src/analyzers/concept/bird-watcher/BirdWatcherSolution.ts

@@ -0,0 +1,175 @@
+import {
+  AstParser,
+  ExtractedFunction,
+  extractExports,
+  extractFunctions,
+  findFirst,
+} from '@exercism/static-analysis'
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/typescript-estree'
+import { readFileSync } from 'fs'
+import path from 'path'
+import { PublicApi } from '~src/analyzers/PublicApi'
+import { Source } from '~src/analyzers/SourceImpl'
+import { assertPublicApi } from '~src/asserts/assert_public_api'
+
+export const TOTAL_BIRD_COUNT = 'totalBirdCount'
+export const BIRDS_IN_WEEK = 'birdsInWeek'
+export const FIX_BIRD_COUNT_LOG = 'fixBirdCountLog'
+
+class TotalBirdCount extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+
+  public get hasInitialTotalValue(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.VariableDeclarator =>
+          [AST_NODE_TYPES.VariableDeclarator].some((type) => type === node.type)
+      )?.init?.value === 0
+    )
+  }
+
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesShorthandAssignment(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.AssignmentExpression =>
+          [AST_NODE_TYPES.AssignmentExpression].some(
+            (type) => type === node.type
+          )
+      )?.operator === '+='
+    )
+  }
+
+  public get usesIncrementalCounter(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.UpdateExpression =>
+          [AST_NODE_TYPES.UpdateExpression].some((type) => type === node.type)
+      )?.operator === '++'
+    )
+  }
+}
+
+class BirdsInWeek extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+}
+
+class FixBirdCountLog extends PublicApi {
+  constructor(implementation: ExtractedFunction) {
+    super(implementation)
+  }
+
+  public get hasFor(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesIfStatement(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.IfStatement =>
+          [AST_NODE_TYPES.IfStatement].some((type) => type === node.type)
+      ) !== undefined
+    )
+  }
+
+  public get usesIncrementalCounter(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.ForStatement =>
+          [AST_NODE_TYPES.ForStatement].some((type) => type === node.type)
+      )?.body?.body[0].expression.operator === '++'
+    )
+  }
+
+  public get usesShorthandAssignment(): boolean {
+    return (
+      findFirst(
+        this.implementation.body,
+        (node): node is TSESTree.AssignmentExpression =>
+          [AST_NODE_TYPES.AssignmentExpression].some(
+            (type) => type === node.type
+          )
+      )?.operator === '+='
+    )
+  }
+}
+
+export class BirdWatcherSolution {
+  private readonly source: Source
+
+  public readonly totalBirdCount: TotalBirdCount
+  public readonly birdsInWeek: BirdsInWeek
+  public readonly fixBirdCountLog: FixBirdCountLog
+
+  private exemplar!: Source
+
+  constructor(public readonly program: TSESTree.Program, source: string) {
+    this.source = new Source(source)
+
+    const functions = extractFunctions(program)
+    const exports = extractExports(program)
+
+    this.totalBirdCount = new TotalBirdCount(
+      assertPublicApi(TOTAL_BIRD_COUNT, exports, functions)
+    )
+    this.birdsInWeek = new BirdsInWeek(
+      assertPublicApi(BIRDS_IN_WEEK, exports, functions)
+    )
+    this.fixBirdCountLog = new FixBirdCountLog(
+      assertPublicApi(FIX_BIRD_COUNT_LOG, exports, functions)
+    )
+  }
+
+  public readExemplar(directory: string): void {
+    const configPath = path.join(directory, '.meta', 'config.json')
+    const config = JSON.parse(readFileSync(configPath).toString())
+
+    const exemplarPath = path.join(directory, config.files.exemplar[0])
+    this.exemplar = new Source(readFileSync(exemplarPath).toString())
+  }
+
+  public get isExemplar(): boolean {
+    const sourceAst = AstParser.REPRESENTER.parseSync(this.source.toString())
+    const exemplarAst = AstParser.REPRESENTER.parseSync(
+      this.exemplar.toString()
+    )
+
+    return (
+      JSON.stringify(sourceAst[0].program) ===
+      JSON.stringify(exemplarAst[0].program)
+    )
+  }
+}

src/analyzers/concept/bird-watcher/index.ts

@@ -0,0 +1,116 @@
+import {
+  AstParser,
+  Input,
+  NoExportError,
+  NoMethodError,
+} from '@exercism/static-analysis'
+import { TSESTree } from '@typescript-eslint/typescript-estree'
+import { CommentType, factory } from '~src/comments/comment'
+import {
+  EXEMPLAR_SOLUTION,
+  NO_METHOD,
+  NO_NAMED_EXPORT,
+} from '~src/comments/shared'
+import { ExecutionOptions, WritableOutput } from '~src/interface'
+import { IsolatedAnalyzerImpl } from '~src/analyzers/IsolatedAnalyzerImpl'
+import {
+  BIRDS_IN_WEEK,
+  BirdWatcherSolution,
+  FIX_BIRD_COUNT_LOG,
+  TOTAL_BIRD_COUNT,
+} from './BirdWatcherSolution'
+
+const USE_FOR_LOOP = factory<'function'>`
+📕 The learning exercise exist to practice or demonstrate your knowledge of \`for-loops\`.
+This is different from practice exercises where you are asked to solve the best way you
+possibly can.
+
+💬 Update the function \`${'function'}\` so that it makes use of \`for-loops\`.
+
+`('javascript.bird-watcher.uses_for_loop', CommentType.Actionable)
+
+const PREFER_SHORTHAND_ASSIGNMENT = factory<'function'>`
+You can reduce some cognitive overhead when it comes to assignment in equations.
+One way to do this is using shorthand assignment that allows you to remove duplication.
+
+An example of assignment:
+
+\`\`\`javascript
+x = x + 1
+\`\`\`
+
+can be in the short hand:
+
+\`\`\`javascript
+x += 1
+\`\`\`
+
+Usage found in \`${'function'}\` if you are interested in modifying your solution.
+`(
+  'javascript.bird-watcher.prefer_shorthand_assignment',
+  CommentType.Informative
+)
+
+type Program = TSESTree.Program
+
+export class BirdWatcherAnalyzer extends IsolatedAnalyzerImpl {
+  private solution!: BirdWatcherSolution
+
+  protected async execute(
+    input: Input,
+    output: WritableOutput,
+    options: ExecutionOptions
+  ): Promise<void> {
+    const [parsed] = await AstParser.ANALYZER.parse(input)
+
+    this.solution = this.checkStructure(parsed.program, parsed.source, output)
+    this.solution.readExemplar(options.inputDir)
+
+    if (this.solution.isExemplar) {
+      output.add(EXEMPLAR_SOLUTION())
+      output.finish()
+    }
+
+    if (!this.solution.birdsInWeek.hasFor) {
+      output.add(USE_FOR_LOOP({ function: BIRDS_IN_WEEK }))
+    }
+
+    if (!this.solution.totalBirdCount.hasFor) {
+      output.add(USE_FOR_LOOP({ function: TOTAL_BIRD_COUNT }))
+    }
+    if (!this.solution.totalBirdCount.usesShorthandAssignment) {
+      output.add(PREFER_SHORTHAND_ASSIGNMENT({ function: TOTAL_BIRD_COUNT }))
+    }
+
+    if (!this.solution.fixBirdCountLog.hasFor) {
+      output.add(USE_FOR_LOOP({ function: FIX_BIRD_COUNT_LOG }))
+    }
+    if (!this.solution.fixBirdCountLog.usesShorthandAssignment) {
+      output.add(PREFER_SHORTHAND_ASSIGNMENT({ function: FIX_BIRD_COUNT_LOG }))
+    }
+
+    output.finish()
+  }
+
+  private checkStructure(
+    program: Readonly<Program>,
+    source: Readonly<string>,
+    output: WritableOutput
+  ): BirdWatcherSolution | never {
+    try {
+      return new BirdWatcherSolution(program, source)
+    } catch (error) {
+      if (error instanceof NoMethodError) {
+        output.add(NO_METHOD({ 'method.name': error.method }))
+        output.finish()
+      }
+
+      if (error instanceof NoExportError) {
+        output.add(NO_NAMED_EXPORT({ 'export.name': error.namedExport }))
+      }
+
+      throw error
+    }
+  }
+}
+export default BirdWatcherAnalyzer

test/analyzers/bird-watcher/exemplar.ts

@@ -0,0 +1,41 @@
+import { DirectoryWithConfigInput } from '@exercism/static-analysis'
+import path from 'path'
+import { BirdWatcherAnalyzer } from '~src/analyzers/concept/bird-watcher'
+import { EXEMPLAR_SOLUTION } from '~src/comments/shared'
+import { makeAnalyze, makeOptions } from '~test/helpers/smoke'
+
+const inputDir = path.join(
+  __dirname,
+  '..',
+  '..',
+  'fixtures',
+  'bird-watcher',
+  'exemplar'
+)
+
+const analyze = makeAnalyze(
+  () => new BirdWatcherAnalyzer(),
+  makeOptions({
+    get inputDir(): string {
+      return inputDir
+    },
+    get exercise(): string {
+      return 'bird-watcher'
+    },
+  })
+)
+
+describe('When running analysis on bird-watcher', () => {
+  it('recognizes the exemplar solution', async () => {
+    const input = new DirectoryWithConfigInput(inputDir)
+
+    const [solution] = await input.read()
+    const output = await analyze(solution)
+
+    expect(output.comments.length).toBe(1)
+    expect(output.comments[0].type).toBe('celebratory')
+    expect(output.comments[0].externalTemplate).toBe(
+      EXEMPLAR_SOLUTION().externalTemplate
+    )
+  })
+})

test/fixtures/bird-watcher/uses-if/.meta/config.json

@@ -0,0 +1,11 @@
+{
+  "blurb": "Professionalize counting the birds in your garden with for loops and increment/decrement operators",
+  "authors": ["junedev"],
+  "contributors": [],
+  "files": {
+    "solution": ["bird-watcher.js"],
+    "test": ["bird-watcher.spec.js"],
+    "exemplar": [".meta/exemplar.js"]
+  },
+  "forked_from": ["csharp/bird-watcher"]
+}