Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

12 kB

// One-time usage file. You can delete me after running the codemod!

function addWithRouterImport(j, root) {
  // We create an import specifier, this is the value of an import, eg:
  // import {withRouter} from 'next/router
  // The specifier would be `withRouter`
  const withRouterSpecifier = j.importSpecifier(j.identifier('withRouter'))

  // Check if this file is already import `next/router`
  // so that we can just attach `withRouter` instead of creating a new `import` node
  const originalRouterImport = root.find(j.ImportDeclaration, {
    source: {
      value: 'next/router',
    },
  })
  if (originalRouterImport.length > 0) {
    // Check if `withRouter` is already imported. In that case we don't have to do anything
    if (
      originalRouterImport.find(j.ImportSpecifier, {
        imported: { name: 'withRouter' },
      }).length > 0
    ) {
      return
    }

    // Attach `withRouter` to the existing `next/router` import node
    originalRouterImport.forEach((node) => {
      node.value.specifiers.push(withRouterSpecifier)
    })
    return
  }

  // Create import node
  // import {withRouter} from 'next/router'
  const withRouterImport = j.importDeclaration(
    [withRouterSpecifier],
    j.stringLiteral('next/router')
  )

  // Find the Program, this is the top level AST node
  const Program = root.find(j.Program)
  // Attach the import at the top of the body
  Program.forEach((node) => {
    node.value.body.unshift(withRouterImport)
  })
}

function getThisPropsUrlNodes(j, tree) {
  return tree.find(j.MemberExpression, {
    object: {
      type: 'MemberExpression',
      object: { type: 'ThisExpression' },
      property: { name: 'props' },
    },
    property: { name: 'url' },
  })
}

function getPropsUrlNodes(j, tree, name) {
  return tree.find(j.MemberExpression, {
    object: { name },
    property: { name: 'url' },
  })
}

// Wraps the provided node in a function call
// For example if `functionName` is `withRouter` it will wrap the provided node in `withRouter(NODE_CONTENT)`
function wrapNodeInFunction(j, functionName, args) {
  const mappedArgs = args.map((node) => {
    // If the node is a ClassDeclaration we have to turn it into a ClassExpression
    // since ClassDeclarations can't be wrapped in a function
    if (node.type === 'ClassDeclaration') {
      node.type = 'ClassExpression'
    }

    return node
  })
  return j.callExpression(j.identifier(functionName), mappedArgs)
}

function turnUrlIntoRouter(j, tree) {
  tree.find(j.Identifier, { name: 'url' }).replaceWith(j.identifier('router'))
}

export default function transformer(file, api) {
  // j is just a shorthand for the jscodeshift api
  const j = api.jscodeshift
  // this is the AST root on which we can call methods like `.find`
  const root = j(file.source)

  // We search for `export default`
  const defaultExports = root.find(j.ExportDefaultDeclaration)

  // We loop over the `export default` instances
  // This is just how jscodeshift works, there can only be one export default instance
  defaultExports.forEach((rule) => {
    // rule.value is an AST node
    const { value: node } = rule
    // declaration holds the AST node for what comes after `export default`
    const { declaration } = node

    function wrapDefaultExportInWithRouter() {
      if (
        j(rule).find(j.CallExpression, { callee: { name: 'withRouter' } })
          .length > 0
      ) {
        return
      }
      j(rule).replaceWith(
        j.exportDefaultDeclaration(
          wrapNodeInFunction(j, 'withRouter', [declaration])
        )
      )
    }

    // The `Identifier` type is given in this case:
    // export default Test
    // where `Test` is the identifier
    if (declaration.type === 'Identifier') {
      // the variable name
      const { name } = declaration

      // find the implementation of the variable, can be a class, function, etc
      let implementation = root.find(j.Declaration, { id: { name } })
      if (implementation.length === 0) {
        implementation = root.find(j.VariableDeclarator, { id: { name } })
      }

      implementation
        .find(j.Property, { key: { name: 'url' } })
        .forEach((propertyRule) => {
          const isThisPropsDestructure = j(propertyRule).closest(
            j.VariableDeclarator,
            {
              init: {
                object: {
                  type: 'ThisExpression',
                },
                property: { name: 'props' },
              },
            }
          )
          if (isThisPropsDestructure.length === 0) {
            return
          }
          const originalKeyValue = propertyRule.value.value.name
          propertyRule.value.key.name = 'router'
          wrapDefaultExportInWithRouter()
          addWithRouterImport(j, root)
          // If the property is reassigned to another variable we don't have to transform it
          if (originalKeyValue !== 'url') {
            return
          }

          propertyRule.value.value.name = 'router'
          j(propertyRule)
            .closest(j.BlockStatement)
            .find(j.Identifier, (identifierNode) => {
              if (identifierNode.type === 'JSXIdentifier') {
                return false
              }

              if (identifierNode.name !== 'url') {
                return false
              }

              return true
            })
            .replaceWith(j.identifier('router'))
        })

      // Find usage of `this.props.url`
      const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)

      if (thisPropsUrlUsage.length === 0) {
        return
      }

      // rename `url` to `router`
      turnUrlIntoRouter(j, thisPropsUrlUsage)
      wrapDefaultExportInWithRouter()
      addWithRouterImport(j, root)
      return
    }

    const arrowFunctions = j(rule).find(j.ArrowFunctionExpression)
    ;(() => {
      if (arrowFunctions.length === 0) {
        return
      }

      arrowFunctions.forEach((r) => {
        // This makes sure we don't match nested functions, only the top one
        if (j(r).closest(j.Expression).length !== 0) {
          return
        }

        if (!r.value.params || !r.value.params[0]) {
          return
        }

        const name = r.value.params[0].name
        const propsUrlUsage = getPropsUrlNodes(j, j(r), name)
        if (propsUrlUsage.length === 0) {
          return
        }

        turnUrlIntoRouter(j, propsUrlUsage)
        wrapDefaultExportInWithRouter()
        addWithRouterImport(j, root)
      })
      return
    })()

    if (declaration.type === 'CallExpression') {
      j(rule)
        .find(j.CallExpression, (haystack) => {
          const firstArgument = haystack.arguments[0] || {}
          if (firstArgument.type === 'Identifier') {
            return true
          }

          return false
        })
        .forEach((callRule) => {
          const { name } = callRule.value.arguments[0]

          // find the implementation of the variable, can be a class, function, etc
          let implementation = root.find(j.Declaration, { id: { name } })
          if (implementation.length === 0) {
            implementation = root.find(j.VariableDeclarator, { id: { name } })
          }
          // Find usage of `this.props.url`
          const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)

          implementation
            .find(j.Property, { key: { name: 'url' } })
            .forEach((propertyRule) => {
              const isThisPropsDestructure = j(propertyRule).closest(
                j.VariableDeclarator,
                {
                  init: {
                    object: {
                      type: 'ThisExpression',
                    },
                    property: { name: 'props' },
                  },
                }
              )
              if (isThisPropsDestructure.length === 0) {
                return
              }
              const originalKeyValue = propertyRule.value.value.name
              propertyRule.value.key.name = 'router'
              wrapDefaultExportInWithRouter()
              addWithRouterImport(j, root)
              // If the property is reassigned to another variable we don't have to transform it
              if (originalKeyValue !== 'url') {
                return
              }

              propertyRule.value.value.name = 'router'
              j(propertyRule)
                .closest(j.BlockStatement)
                .find(j.Identifier, (identifierNode) => {
                  if (identifierNode.type === 'JSXIdentifier') {
                    return false
                  }

                  if (identifierNode.name !== 'url') {
                    return false
                  }

                  return true
                })
                .replaceWith(j.identifier('router'))
            })

          if (thisPropsUrlUsage.length === 0) {
            return
          }

          // rename `url` to `router`
          turnUrlIntoRouter(j, thisPropsUrlUsage)
          wrapDefaultExportInWithRouter()
          addWithRouterImport(j, root)
          return
        })
    }

    j(rule)
      .find(j.Property, { key: { name: 'url' } })
      .forEach((propertyRule) => {
        const isThisPropsDestructure = j(propertyRule).closest(
          j.VariableDeclarator,
          {
            init: {
              object: {
                type: 'ThisExpression',
              },
              property: { name: 'props' },
            },
          }
        )
        if (isThisPropsDestructure.length === 0) {
          return
        }
        const originalKeyValue = propertyRule.value.value.name
        propertyRule.value.key.name = 'router'
        wrapDefaultExportInWithRouter()
        addWithRouterImport(j, root)
        // If the property is reassigned to another variable we don't have to transform it
        if (originalKeyValue !== 'url') {
          return
        }

        propertyRule.value.value.name = 'router'
        j(propertyRule)
          .closest(j.BlockStatement)
          .find(j.Identifier, (identifierNode) => {
            if (identifierNode.type === 'JSXIdentifier') {
              return false
            }

            if (identifierNode.name !== 'url') {
              return false
            }

            return true
          })
          .replaceWith(j.identifier('router'))
      })

    j(rule)
      .find(j.MethodDefinition, { key: { name: 'componentWillReceiveProps' } })
      .forEach((methodRule) => {
        const func = methodRule.value.value
        if (!func.params[0]) {
          return
        }
        const firstArgumentName = func.params[0].name
        const propsUrlUsage = getPropsUrlNodes(
          j,
          j(methodRule),
          firstArgumentName
        )
        turnUrlIntoRouter(j, propsUrlUsage)
        if (propsUrlUsage.length === 0) {
          return
        }
        wrapDefaultExportInWithRouter()
        addWithRouterImport(j, root)
      })

    j(rule)
      .find(j.MethodDefinition, { key: { name: 'componentDidUpdate' } })
      .forEach((methodRule) => {
        const func = methodRule.value.value
        if (!func.params[0]) {
          return
        }
        const firstArgumentName = func.params[0].name
        const propsUrlUsage = getPropsUrlNodes(
          j,
          j(methodRule),
          firstArgumentName
        )
        turnUrlIntoRouter(j, propsUrlUsage)
        if (propsUrlUsage.length === 0) {
          return
        }
        wrapDefaultExportInWithRouter()
        addWithRouterImport(j, root)
      })

    const thisPropsUrlUsage = getThisPropsUrlNodes(j, j(rule))
    const propsUrlUsage = getPropsUrlNodes(j, j(rule), 'props')

    // rename `url` to `router`
    turnUrlIntoRouter(j, thisPropsUrlUsage)
    turnUrlIntoRouter(j, propsUrlUsage)

    if (thisPropsUrlUsage.length === 0 && propsUrlUsage.length === 0) {
      return
    }

    wrapDefaultExportInWithRouter()
    addWithRouterImport(j, root)
    return
  })

  return root.toSource()
}

	// One-time usage file. You can delete me after running the codemod!

	function addWithRouterImport(j, root) {
	// We create an import specifier, this is the value of an import, eg:
	// import {withRouter} from 'next/router
	// The specifier would be `withRouter`
	const withRouterSpecifier = j.importSpecifier(j.identifier('withRouter'))

	// Check if this file is already import `next/router`
	// so that we can just attach `withRouter` instead of creating a new `import` node
	const originalRouterImport = root.find(j.ImportDeclaration, {
	source: {
	value: 'next/router',
	},
	})
	if (originalRouterImport.length > 0) {
	// Check if `withRouter` is already imported. In that case we don't have to do anything
	if (
	originalRouterImport.find(j.ImportSpecifier, {
	imported: { name: 'withRouter' },
	}).length > 0
	) {
	return
	}

	// Attach `withRouter` to the existing `next/router` import node
	originalRouterImport.forEach((node) => {
	node.value.specifiers.push(withRouterSpecifier)
	})
	return
	}

	// Create import node
	// import {withRouter} from 'next/router'
	const withRouterImport = j.importDeclaration(
	[withRouterSpecifier],
	j.stringLiteral('next/router')
	)

	// Find the Program, this is the top level AST node
	const Program = root.find(j.Program)
	// Attach the import at the top of the body
	Program.forEach((node) => {
	node.value.body.unshift(withRouterImport)
	})
	}

	function getThisPropsUrlNodes(j, tree) {
	return tree.find(j.MemberExpression, {
	object: {
	type: 'MemberExpression',
	object: { type: 'ThisExpression' },
	property: { name: 'props' },
	},
	property: { name: 'url' },
	})
	}

	function getPropsUrlNodes(j, tree, name) {
	return tree.find(j.MemberExpression, {
	object: { name },
	property: { name: 'url' },
	})
	}

	// Wraps the provided node in a function call
	// For example if `functionName` is `withRouter` it will wrap the provided node in `withRouter(NODE_CONTENT)`
	function wrapNodeInFunction(j, functionName, args) {
	const mappedArgs = args.map((node) => {
	// If the node is a ClassDeclaration we have to turn it into a ClassExpression
	// since ClassDeclarations can't be wrapped in a function
	if (node.type === 'ClassDeclaration') {
	node.type = 'ClassExpression'
	}

	return node
	})
	return j.callExpression(j.identifier(functionName), mappedArgs)
	}

	function turnUrlIntoRouter(j, tree) {
	tree.find(j.Identifier, { name: 'url' }).replaceWith(j.identifier('router'))
	}

	export default function transformer(file, api) {
	// j is just a shorthand for the jscodeshift api
	const j = api.jscodeshift
	// this is the AST root on which we can call methods like `.find`
	const root = j(file.source)

	// We search for `export default`
	const defaultExports = root.find(j.ExportDefaultDeclaration)

	// We loop over the `export default` instances
	// This is just how jscodeshift works, there can only be one export default instance
	defaultExports.forEach((rule) => {
	// rule.value is an AST node
	const { value: node } = rule
	// declaration holds the AST node for what comes after `export default`
	const { declaration } = node

	function wrapDefaultExportInWithRouter() {
	if (
	j(rule).find(j.CallExpression, { callee: { name: 'withRouter' } })
	.length > 0
	) {
	return
	}
	j(rule).replaceWith(
	j.exportDefaultDeclaration(
	wrapNodeInFunction(j, 'withRouter', [declaration])
	)
	)
	}

	// The `Identifier` type is given in this case:
	// export default Test
	// where `Test` is the identifier
	if (declaration.type === 'Identifier') {
	// the variable name
	const { name } = declaration

	// find the implementation of the variable, can be a class, function, etc
	let implementation = root.find(j.Declaration, { id: { name } })
	if (implementation.length === 0) {
	implementation = root.find(j.VariableDeclarator, { id: { name } })
	}

	implementation
	.find(j.Property, { key: { name: 'url' } })
	.forEach((propertyRule) => {
	const isThisPropsDestructure = j(propertyRule).closest(
	j.VariableDeclarator,
	{
	init: {
	object: {
	type: 'ThisExpression',
	},
	property: { name: 'props' },
	},
	}
	)
	if (isThisPropsDestructure.length === 0) {
	return
	}
	const originalKeyValue = propertyRule.value.value.name
	propertyRule.value.key.name = 'router'
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	// If the property is reassigned to another variable we don't have to transform it
	if (originalKeyValue !== 'url') {
	return
	}

	propertyRule.value.value.name = 'router'
	j(propertyRule)
	.closest(j.BlockStatement)
	.find(j.Identifier, (identifierNode) => {
	if (identifierNode.type === 'JSXIdentifier') {
	return false
	}

	if (identifierNode.name !== 'url') {
	return false
	}

	return true
	})
	.replaceWith(j.identifier('router'))
	})

	// Find usage of `this.props.url`
	const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)

	if (thisPropsUrlUsage.length === 0) {
	return
	}

	// rename `url` to `router`
	turnUrlIntoRouter(j, thisPropsUrlUsage)
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	return
	}

	const arrowFunctions = j(rule).find(j.ArrowFunctionExpression)
	;(() => {
	if (arrowFunctions.length === 0) {
	return
	}

	arrowFunctions.forEach((r) => {
	// This makes sure we don't match nested functions, only the top one
	if (j(r).closest(j.Expression).length !== 0) {
	return
	}

	if (!r.value.params \|\| !r.value.params[0]) {
	return
	}

	const name = r.value.params[0].name
	const propsUrlUsage = getPropsUrlNodes(j, j(r), name)
	if (propsUrlUsage.length === 0) {
	return
	}

	turnUrlIntoRouter(j, propsUrlUsage)
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	})
	return
	})()

	if (declaration.type === 'CallExpression') {
	j(rule)
	.find(j.CallExpression, (haystack) => {
	const firstArgument = haystack.arguments[0] \|\| {}
	if (firstArgument.type === 'Identifier') {
	return true
	}

	return false
	})
	.forEach((callRule) => {
	const { name } = callRule.value.arguments[0]

	// find the implementation of the variable, can be a class, function, etc
	let implementation = root.find(j.Declaration, { id: { name } })
	if (implementation.length === 0) {
	implementation = root.find(j.VariableDeclarator, { id: { name } })
	}
	// Find usage of `this.props.url`
	const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)

	implementation
	.find(j.Property, { key: { name: 'url' } })
	.forEach((propertyRule) => {
	const isThisPropsDestructure = j(propertyRule).closest(
	j.VariableDeclarator,
	{
	init: {
	object: {
	type: 'ThisExpression',
	},
	property: { name: 'props' },
	},
	}
	)
	if (isThisPropsDestructure.length === 0) {
	return
	}
	const originalKeyValue = propertyRule.value.value.name
	propertyRule.value.key.name = 'router'
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	// If the property is reassigned to another variable we don't have to transform it
	if (originalKeyValue !== 'url') {
	return
	}

	propertyRule.value.value.name = 'router'
	j(propertyRule)
	.closest(j.BlockStatement)
	.find(j.Identifier, (identifierNode) => {
	if (identifierNode.type === 'JSXIdentifier') {
	return false
	}

	if (identifierNode.name !== 'url') {
	return false
	}

	return true
	})
	.replaceWith(j.identifier('router'))
	})

	if (thisPropsUrlUsage.length === 0) {
	return
	}

	// rename `url` to `router`
	turnUrlIntoRouter(j, thisPropsUrlUsage)
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	return
	})
	}

	j(rule)
	.find(j.Property, { key: { name: 'url' } })
	.forEach((propertyRule) => {
	const isThisPropsDestructure = j(propertyRule).closest(
	j.VariableDeclarator,
	{
	init: {
	object: {
	type: 'ThisExpression',
	},
	property: { name: 'props' },
	},
	}
	)
	if (isThisPropsDestructure.length === 0) {
	return
	}
	const originalKeyValue = propertyRule.value.value.name
	propertyRule.value.key.name = 'router'
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	// If the property is reassigned to another variable we don't have to transform it
	if (originalKeyValue !== 'url') {
	return
	}

	propertyRule.value.value.name = 'router'
	j(propertyRule)
	.closest(j.BlockStatement)
	.find(j.Identifier, (identifierNode) => {
	if (identifierNode.type === 'JSXIdentifier') {
	return false
	}

	if (identifierNode.name !== 'url') {
	return false
	}

	return true
	})
	.replaceWith(j.identifier('router'))
	})

	j(rule)
	.find(j.MethodDefinition, { key: { name: 'componentWillReceiveProps' } })
	.forEach((methodRule) => {
	const func = methodRule.value.value
	if (!func.params[0]) {
	return
	}
	const firstArgumentName = func.params[0].name
	const propsUrlUsage = getPropsUrlNodes(
	j,
	j(methodRule),
	firstArgumentName
	)
	turnUrlIntoRouter(j, propsUrlUsage)
	if (propsUrlUsage.length === 0) {
	return
	}
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	})

	j(rule)
	.find(j.MethodDefinition, { key: { name: 'componentDidUpdate' } })
	.forEach((methodRule) => {
	const func = methodRule.value.value
	if (!func.params[0]) {
	return
	}
	const firstArgumentName = func.params[0].name
	const propsUrlUsage = getPropsUrlNodes(
	j,
	j(methodRule),
	firstArgumentName
	)
	turnUrlIntoRouter(j, propsUrlUsage)
	if (propsUrlUsage.length === 0) {
	return
	}
	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	})

	const thisPropsUrlUsage = getThisPropsUrlNodes(j, j(rule))
	const propsUrlUsage = getPropsUrlNodes(j, j(rule), 'props')

	// rename `url` to `router`
	turnUrlIntoRouter(j, thisPropsUrlUsage)
	turnUrlIntoRouter(j, propsUrlUsage)

	if (thisPropsUrlUsage.length === 0 && propsUrlUsage.length === 0) {
	return
	}

	wrapDefaultExportInWithRouter()
	addWithRouterImport(j, root)
	return
	})

	return root.toSource()
	}