리팩토링 프로젝트

리팩토링 프로젝트란..

리팩터링(refactoring)은 소프트웨어 공학에서 '결과의 변경 없이 코드의 구조를 재조정함'을 뜻한다. 주로 가독성을 높이고 유지보수를 편하게 한다. 버그를 없애거나 새로운 기능을 추가하는 행위는 아니다. 사용자가 보는 외부 화면은 그대로 두면서 내부 논리나 구조를 바꾸고 개선하는 유지보수 행위이다.

Ref : https://ko.wikipedia.org/wiki/%EB%A6%AC%ED%8C%A9%ED%84%B0%EB%A7%81

리팩터링 - 위키백과, 우리 모두의 백과사전

 

리팩토링 before.js

/* eslint-disable */

const https = require('https')

// 모든 가문의 캐릭터들을 놓고 봤을 때 가장 부정적인 가문과 가장 긍정적인 가문을 알아보자.
const resultsByHouseSlugs = {}

https.get(`https://game-of-thrones-quotes.herokuapp.com/v1/houses`, (res) => {
  let jsonStr = ''
  res.setEncoding('utf-8')
  res.on('data', (data) => {
    jsonStr += data
  })
  res.on('end', () => {
    const houses = JSON.parse(jsonStr)

    let numMembersDone = 0
    let numTotalMembers = 0
    houses.forEach((house) => {
      numTotalMembers += house.members.length
    })

    houses.forEach((house) => {
      const houseSlug = house.slug
      const members = house.members

      members.forEach((member) => {
        const characterSlug = member.slug

        setTimeout(() => {
          https.get(
            `https://game-of-thrones-quotes.herokuapp.com/v1/character/${characterSlug}`,
            (res) => {
              let jsonStr = ''
              res.setEncoding('utf-8')
              res.on('data', (data) => {
                jsonStr += data
              })
              res.on('end', () => {
                const json = JSON.parse(jsonStr)
                const mergedQuotes = json[0].quotes
                  .join(' ')
                  .replace(/[^a-zA-Z0-9., ]/g, '')
                const body = JSON.stringify({
                  text: mergedQuotes,
                })

                const postReq = https.request(
                  {
                    hostname: 'sentim-api.herokuapp.com',
                    method: 'POST',
                    path: '/api/v1/',
                    headers: {
                      Accept: 'application/json; encoding=utf-8',
                      'Content-Type': 'application/json; encoding=utf-8',
                      'Content-Length': body.length,
                    },
                  },
                  (res) => {
                    let jsonStr = ''
                    console.log(body, res.statusCode, res.statusMessage)
                    res.setEncoding('utf-8')
                    res.on('data', (data) => {
                      jsonStr += data
                    })
                    res.on('end', () => {
                      const result = JSON.parse(jsonStr)

                      resultsByHouseSlugs[houseSlug] =
                        resultsByHouseSlugs[houseSlug] || []
                      resultsByHouseSlugs[houseSlug].push({
                        character: characterSlug,
                        polarity: result.result.polarity,
                      })

                      numMembersDone += 1

                      if (numMembersDone === numTotalMembers) {
                        const resultSlugs = Object.keys(resultsByHouseSlugs)
                        const finalResult = resultSlugs
                          .map((slug) => {
                            let sum = 0
                            resultsByHouseSlugs[slug].forEach(
                              (value) => (sum += value.polarity)
                            )

                            return {
                              slug,
                              polarity: sum / resultsByHouseSlugs[slug].length,
                            }
                          })
                          .sort((a, b) => a.polarity - b.polarity)

                        console.log('sorted', finalResult)
                      }
                    })
                  }
                )

                postReq.write(body)
              })
            }
          )
        }, Math.random() * 10000)
      })
    })
  })
})

리팩토링 후에 after.js

/**
 * @typedef Character
 * @property {string} slug
 * @property {number} polarity
 * @property {house} slug
 */

/**
 * @typedef House
 * @property {string} slug
 * @property {Character[]} members
 */

const https = require('https')

const GOTAPI_PREFIX = 'https://game-of-thrones-quotes.herokuapp.com/v1'

/**
 * @param {string} url
 * @returns {*}
 */
async function getHttpsJSON(url) {
  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      let jsonStr = ''
      res.setEncoding('utf-8')
      res.on('data', (data) => {
        jsonStr += data
      })
      res.on('end', () => {
        try {
          const parsed = JSON.parse(jsonStr)
          resolve(parsed)
        } catch {
          reject(
            new Error('The server response was not a valid JSON document.')
          )
        }
      })
    })
  })
}

/**
 * @returns {Promise<House[]>}
 */
async function getHouses() {
  return getHttpsJSON(`${GOTAPI_PREFIX}/houses`)
}

/**
 * @param {string} quote
 * @returns {string}
 */
function sanitizeQuote(quote) {
  return quote.replace(/[^a-zA-Z0-9., ]/g, '')
}

/**
 * @param {string} slug
 * @returns {Promise<string>}
 */
async function getMergedQuotesOfCharacter(slug) {
  const character = await getHttpsJSON(`${GOTAPI_PREFIX}/character/${slug}`)
  return sanitizeQuote(character[0].quotes.join(' '))
}

/**
 * @param {string} quote
 */
async function getSentimAPIResult(quote) {
  return new Promise((resolve, reject) => {
    const body = JSON.stringify({
      text: quote,
    })

    const postReq = https.request(
      {
        hostname: 'sentim-api.herokuapp.com',
        method: 'POST',
        path: '/api/v1/',
        headers: {
          Accept: 'application/json; encoding=utf-8',
          'Content-Type': 'application/json; encoding=utf-8',
          'Content-Length': body.length,
        },
      },
      (res) => {
        let jsonStr = ''
        res.setEncoding('utf-8')
        res.on('data', (data) => {
          jsonStr += data
        })
        res.on('end', () => {
          try {
            resolve(JSON.parse(jsonStr))
          } catch {
            reject(
              new Error('The server response was not a valid JSON document.')
            )
          }
        })
      }
    )

    postReq.write(body)
  })
}

/**
 * @param {number[]} numbers
 * @returns {number}
 */
function sum(numbers) {
  return numbers.reduce((memo, curr) => memo + curr, 0)
}

async function main() {
  const houses = await getHouses()
  const characters = await Promise.all(
    houses
      .map((house) =>
        house.members.map((member) =>
          getMergedQuotesOfCharacter(member.slug).then((quote) => ({
            house: house.slug,
            charater: member.slug,
            quote,
          }))
        )
      )
      .flat()
  )

  console.log('houses:', houses)

  const charactersWithPolarity = await Promise.all(
    characters.map(async (character) => {
      const result = await getSentimAPIResult(character.quote)
      return {
        ...character,
        polarity: result.result.polarity,
      }
    })
  )

  console.log('charactersWithPolarity:', charactersWithPolarity)

  /** @type {Object.<string, Character[]>} */
  const charactersByHouseSlugs = {}
  charactersWithPolarity.forEach((character) => {
    charactersByHouseSlugs[character.house] =
      charactersByHouseSlugs[character.house] || []
    charactersByHouseSlugs[character.house].push(character)
  })

  console.log('charactersByHouseSlugs:', charactersByHouseSlugs)

  const houseSlugs = Object.keys(charactersByHouseSlugs)
  const result = houseSlugs
    .map((houseSlug) => {
      const charactersOfHouse = charactersByHouseSlugs[houseSlug]
      if (!charactersOfHouse) {
        return undefined
      }
      const sumPolarity = sum(
        charactersOfHouse.map((character) => character.polarity)
      )
      const averagePolarity = sumPolarity / charactersOfHouse.length
      return [houseSlug, averagePolarity]
    })
    .sort((a, b) => a[1] - b[1])

  console.log('result:', result)
}

main()