Python NodeResolve Examples

Example #1

File: register.py Project: cosmicexplorer/pants

def register_goals():
  NodeResolve.register_resolver_for_type(ScalaJSBinary, ScalaJSPlatform)
  # NB: These task/goal assignments are pretty nuts, but are necessary in order to
  # prevent product-graph cycles between the JVM and node.js.
  #   see https://github.com/pantsbuild/pants/labels/engine
  task(name='scala-js-compile', action=ScalaJSZincCompile).install('resolve')
  task(name='scala-js-link', action=ScalaJSLink).install('resolve')

Example #2

File: register.py Project: thoward/pants

def register_goals():
    NodeResolve.register_resolver_for_type(ScalaJSBinary, ScalaJSPlatform)
    # NB: These task/goal assignments are pretty nuts, but are necessary in order to
    # prevent product-graph cycles between the JVM and node.js.
    #   see https://github.com/pantsbuild/pants/labels/engine
    task(name='scala-js-compile', action=ScalaJSZincCompile).install('resolve')
    task(name='scala-js-link', action=ScalaJSLink).install('resolve')

Example #3

File: npm_resolver.py Project: tglstory/pants

 def register_options(cls, register):
     super(NpmResolver, cls).register_options(register)
     register('--install-optional',
              type=bool,
              default=False,
              fingerprint=True,
              help='If enabled, install optional dependencies.')
     NodeResolve.register_resolver_for_type(NodeModule, cls)

Example #4

 def register_options(cls, register):
     register(
         '--fetch-timeout-secs',
         type=int,
         advanced=True,
         default=10,
         help=
         'Timeout the fetch if the connection is idle for longer than this value.'
     )
     super(NodePreinstalledModuleResolver, cls).register_options(register)
     NodeResolve.register_resolver_for_type(NodePreinstalledModule, cls)

Example #5

File: test_node_resolve.py Project: RobinTec/pants

    def test_register_resolver_for_type(self):
        NodeResolve._clear_resolvers()

        self.assertIsNone(NodeResolve._resolver_for_target(NodePreinstalledModule))
        self.assertIsNone(NodeResolve._resolver_for_target(NodeModule))

        node_preinstalled__module_target = self.make_target(
            spec=":empty_fake_node_preinstalled_module_target", target_type=NodePreinstalledModule
        )
        NodeResolve.register_resolver_for_type(NodePreinstalledModule, NodePreinstalledModuleResolver)
        self.assertEqual(
            NodePreinstalledModuleResolver, NodeResolve._resolver_for_target(node_preinstalled__module_target)
        )

        node_module_target = self.make_target(spec=":empty_fake_node_module_target", target_type=NodeModule)
        NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)
        self.assertEqual(NpmResolver, NodeResolve._resolver_for_target(node_module_target))

Example #6

File: test_node_resolve.py Project: elyast/pants

  def test_register_resolver_for_type(self):
    NodeResolve._clear_resolvers()

    self.assertIsNone(NodeResolve._resolver_for_target(NodePreinstalledModule))
    self.assertIsNone(NodeResolve._resolver_for_target(NodeModule))

    node_preinstalled__module_target = self.make_target(
      spec=':empty_fake_node_preinstalled_module_target',
      target_type=NodePreinstalledModule)
    NodeResolve.register_resolver_for_type(NodePreinstalledModule, NodePreinstalledModuleResolver)
    self.assertEqual(NodePreinstalledModuleResolver,
                     NodeResolve._resolver_for_target(node_preinstalled__module_target))

    node_module_target = self.make_target(spec=':empty_fake_node_module_target',
                                          target_type=NodeModule)
    NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)
    self.assertEqual(NpmResolver,
                     NodeResolve._resolver_for_target(node_module_target))

Example #7

File: npm_resolver.py Project: wiwa/pants

    def register_options(cls, register):
        super().register_options(register)
        register(
            "--install-optional",
            type=bool,
            default=False,
            fingerprint=True,
            help="If enabled, install optional dependencies.",
        )
        register(
            "--install-production",
            type=bool,
            default=False,
            fingerprint=True,
            help="If enabled, do not install devDependencies.",
        )
        register(
            "--force",
            type=bool,
            default=False,
            fingerprint=True,
            help="If enabled, refetch and resolve dependencies even if they are already built.",
        )
        register(
            "--frozen-lockfile",
            type=bool,
            default=True,
            fingerprint=True,
            help="If enabled, disallow automatic update of lock files.",
        )
        # There are cases where passed through options does not override hard-coded options.
        # One example is for node-install, --frozen-lockfile=False is the dominate configuration
        # as it allows the user to modify dependencies and generate a new lockfile.
        # By turning on --force-option-override, the user accepts full responsibilities.
        register(
            "--force-option-override",
            type=bool,
            default=False,
            fingerprint=True,
            advanced=True,
            help="If enabled, options will override hard-coded values. Be aware of default values.",
        )

        NodeResolve.register_resolver_for_type(NodeModule, cls)

Example #8

File: npm_resolver.py Project: cosmicexplorer/pants

  def register_options(cls, register):
    super(NpmResolver, cls).register_options(register)
    register(
      '--install-optional', type=bool, default=False, fingerprint=True,
      help='If enabled, install optional dependencies.')
    register(
      '--install-production', type=bool, default=False, fingerprint=True,
      help='If enabled, do not install devDependencies.')
    register(
      '--force', type=bool, default=False, fingerprint=True,
      help='If enabled, refetch and resolve dependencies even if they are already built.')
    register(
      '--frozen-lockfile', type=bool, default=True, fingerprint=True,
      help='If enabled, disallow automatic update of lock files.')
    # There are cases where passed through options does not override hard-coded options.
    # One example is for node-install, --frozen-lockfile=False is the dominate configuration
    # as it allows the user to modify dependencies and generate a new lockfile.
    # By turning on --force-option-override, the user accepts full responsibilities.
    register(
      '--force-option-override', type=bool, default=False, fingerprint=True, advanced=True,
      help='If enabled, options will override hard-coded values. Be aware of default values.')

    NodeResolve.register_resolver_for_type(NodeModule, cls)

Example #9

File: test_node_resolve.py Project: traviscrawford/pants

 def test_product_types(self):
   self.assertEqual([NodePaths], NodeResolve.product_types())

Example #10

File: test_node_resolve_src_deps.py Project: cosmicexplorer/pants

 def tearDown(self):
   super(NodeResolveSourceDepsTest, self).tearDown()
   NodeResolve._clear_resolvers()

Example #11

File: test_node_resolve_src_deps.py Project: cosmicexplorer/pants

 def setUp(self):
   super(NodeResolveSourceDepsTest, self).setUp()
   NodeResolve.register_resolver_for_type(NodePreinstalledModule, NodePreinstalledModuleResolver)
   NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)

Example #12

File: webpack_resolver.py Project: mateor/fsqio

 def register_options(cls, register):
   NodeResolve.register_resolver_for_type(WebPackModule, cls)
   NodeResolve.register_resolver_for_type(NpmResource, cls)
   super(WebPackResolver, cls).register_options(register)

Example #13

File: npm_resolver.py Project: baroquebobcat/pants

 def register_options(cls, register):
   super(NpmResolver, cls).register_options(register)
   register(
     '--install-optional', type=bool, default=False, fingerprint=True,
     help='If enabled, install optional dependencies.')
   NodeResolve.register_resolver_for_type(NodeModule, cls)

Example #14

File: test_node_test.py Project: CaitieM20/pants

 def setUp(self):
   super(NodeTestTest, self).setUp()
   NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)

Example #15

 def tearDown(self):
   super().tearDown()
   NodeResolve._clear_resolvers()

Example #16

File: test_node_resolve.py Project: xeno-by/pants

 def test_product_types(self):
     self.assertEqual([NodePaths], NodeResolve.product_types())

Example #17

 def register_options(cls, register):
   NodeResolve.register_resolver_for_type(WebPackModule, cls)
   NodeResolve.register_resolver_for_type(NpmResource, cls)
   super(WebPackResolver, cls).register_options(register)

Example #18

File: node_preinstalled_module_resolver.py Project: will-horning/pants

 def register_options(cls, register):
     super(NodePreinstalledModuleResolver, cls).register_options(register)
     NodeResolve.register_resolver_for_type(NodePreinstalledModule, cls)

Example #19

 def tearDown(self):
     super(NodeTestTest, self).tearDown()
     NodeResolve._clear_resolvers()

Example #20

 def setUp(self):
     super(NodeTestTest, self).setUp()
     NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)

Example #21

 def setUp(self):
   super().setUp()
   NodeResolve.register_resolver_for_type(NodePreinstalledModule, NodePreinstalledModuleResolver)
   NodeResolve.register_resolver_for_type(NodeModule, NpmResolver)

Example #22

File: npm_resolver.py Project: JieGhost/pants

 def register_options(cls, register):
   super(NpmResolver, cls).register_options(register)
   NodeResolve.register_resolver_for_type(NodeModule, cls)

Example #23

File: node_preinstalled_module_resolver.py Project: Gointer/pants

 def register_options(cls, register):
   super(NodePreinstalledModuleResolver, cls).register_options(register)
   NodeResolve.register_resolver_for_type(NodePreinstalledModule, cls)

Example #24

File: node_preinstalled_module_resolver.py Project: cosmicexplorer/pants

 def register_options(cls, register):
   register('--fetch-timeout-secs', type=int, advanced=True, default=10,
            help='Timeout the fetch if the connection is idle for longer than this value.')
   super(NodePreinstalledModuleResolver, cls).register_options(register)
   NodeResolve.register_resolver_for_type(NodePreinstalledModule, cls)

Example #25

File: test_node_test.py Project: CaitieM20/pants

 def tearDown(self):
   super(NodeTestTest, self).tearDown()
   NodeResolve._clear_resolvers()

Example #26

 def register_options(cls, register):
     super(NpmResolver, cls).register_options(register)
     NodeResolve.register_resolver_for_type(NodeModule, cls)