Esempio n. 1
0
 def validate_sources(self, sources):
     if len(sources.files) > 1:
         raise Target.IllegalArgument(
             self.address.spec,
             'python_binary must have exactly 0 or 1 sources (typically used to specify the file '
             'containing the entry point). '
             'Other sources should instead be placed in a python_library, which '
             'should be referenced in the python_binary\'s dependencies.')
Esempio n. 2
0
 def validate_sources(self, sources):
     if len(sources.files) > 1:
         raise Target.IllegalArgument(
             self.address.spec,
             "jvm_binary must have exactly 0 or 1 sources (typically used to specify the class "
             "containing the main method). "
             "Other sources should instead be placed in a java_library, which "
             "should be referenced in the jvm_binary's dependencies.",
         )
Esempio n. 3
0
 def validate_sources(self, sources):
   if len(sources.files) != 1:
     raise Target.IllegalArgument(
       self.address.spec,
       'page targets must have exactly 1 source, but found {} ({})'.format(
         len(sources.files),
         ', '.join(sources.files),
       )
     )
Esempio n. 4
0
    def get_sources(self):
        """Returns target's non-deferred sources if exists or the default sources if defined.

    :rtype: :class:`GlobsWithConjunction`

    NB: once ivy is implemented in the engine, we can fetch sources natively here, and/or
    refactor how deferred sources are implemented.
      see: https://github.com/pantsbuild/pants/issues/2997
    """
        source = getattr(self, 'source', None)
        sources = getattr(self, 'sources', None)

        if source is not None and sources is not None:
            raise Target.IllegalArgument(
                self.address.spec,
                'Cannot specify both source and sources attribute.')

        if source is not None:
            if not isinstance(source, str):
                raise Target.IllegalArgument(
                    self.address.spec,
                    f"source must be a str containing a path relative to the target, but got {source} of "
                    f"type {type(source)}")
            sources = [source]

        # N.B. Here we check specifically for `sources is None`, as it's possible for sources
        # to be e.g. an explicit empty list (sources=[]).
        if sources is None:
            if self.default_sources_globs is not None:
                globs = Globs(*self.default_sources_globs,
                              spec_path=self.address.spec_path,
                              exclude=self.default_sources_exclude_globs or [])
                conjunction_globs = GlobsWithConjunction(
                    globs, GlobExpansionConjunction.any_match)
            else:
                globs = None
                conjunction_globs = None
        else:
            globs = BaseGlobs.from_sources_field(sources,
                                                 self.address.spec_path)
            conjunction_globs = GlobsWithConjunction(
                globs, GlobExpansionConjunction.all_match)

        return conjunction_globs
Esempio n. 5
0
    def get_sources(self) -> Optional["GlobsWithConjunction"]:
        """Returns target's non-deferred sources if exists or the default sources if defined.

        NB: once ivy is implemented in the engine, we can fetch sources natively here, and/or
        refactor how deferred sources are implemented.
          see: https://github.com/pantsbuild/pants/issues/2997
        """
        source = getattr(self, "source", None)
        sources = getattr(self, "sources", None)

        if source is not None and sources is not None:
            raise Target.IllegalArgument(
                self.address.spec,
                "Cannot specify both source and sources attribute.")

        if source is not None:
            if not isinstance(source, str):
                raise Target.IllegalArgument(
                    self.address.spec,
                    f"source must be a str containing a path relative to the target, but got {source} of "
                    f"type {type(source)}",
                )
            sources = [source]

        # N.B. Here we check specifically for `sources is None`, as it's possible for sources
        # to be e.g. an explicit empty list (sources=[]).
        if sources is None:
            if self.default_sources_globs is None:
                return None
            default_sources = SourceGlobs(
                *(
                    *self.default_sources_globs,
                    *(f"!{glob}"
                      for glob in self.default_sources_exclude_globs or []),
                ), )
            return GlobsWithConjunction(default_sources,
                                        GlobExpansionConjunction.any_match)

        source_globs = SourceGlobs.from_sources_field(sources)
        return GlobsWithConjunction(source_globs,
                                    GlobExpansionConjunction.all_match)