Пример #1
0
	def run (self):
		"""
		This method actually runs BibTeX with the appropriate environment
		variables set.
		"""
		msg.progress(_("running BibTeX on %s") % msg.simplify(self.base))
		doc = {}
		if len(self.bib_path) != 1:
			doc["BIBINPUTS"] = string.join(self.bib_path +
				[os.getenv("BIBINPUTS", "")], ":")
		if len(self.bst_path) != 1:
			doc["BSTINPUTS"] = string.join(self.bst_path +
				[os.getenv("BSTINPUTS", "")], ":")
		if self.crossrefs is None:
			cmd = ["bibtex"]
		else:
			cmd = ["bibtex", "-min-crossrefs=" + self.crossrefs]
		cmd.append(self.doc.env.file_name(self.base))
		msg.log(_("executing: %s") % " ".join(cmd), pkg="bibtex")
		process = Popen(cmd, stdout=PIPE, stderr=PIPE)
		process.communicate()
		if process.wait() != 0:
			msg.info(_("There were errors making the bibliography."))
			return False
		self.run_needed = 0
		self.doc.must_compile = 1
		return True
Пример #2
0
    def run(self):
        """
		This method actually runs BibTeX with the appropriate environment
		variables set.
		"""
        msg.progress(_("running BibTeX on %s") % msg.simplify(self.base))
        doc = {}
        if len(self.bib_path) != 1:
            doc["BIBINPUTS"] = string.join(
                self.bib_path + [os.getenv("BIBINPUTS", "")], ":")
        if len(self.bst_path) != 1:
            doc["BSTINPUTS"] = string.join(
                self.bst_path + [os.getenv("BSTINPUTS", "")], ":")
        if self.crossrefs is None:
            cmd = ["bibtex"]
        else:
            cmd = ["bibtex", "-min-crossrefs=" + self.crossrefs]
        # BibTeX comes with a straightjacket in some TeX distros and can't write
        # to absolute paths.  strip the directory, and change into that dir.
        workdir = os.path.dirname(self.base)
        basename = os.path.basename(self.base)
        if self.doc.env.execute(['bibtex', basename], doc, pwd=workdir):
            msg.info(_("There were errors making the bibliography."))
            return False
        self.run_needed = 0
        self.doc.must_compile = 1
        return True
Пример #3
0
 def pre_compile(self):
     if not os.path.exists(self.doc.target + '.pytxcode'):
         msg.info(_("Need compilation!"), pkg="pythontex")
         self.force_compilation()
     msg.info(_("running pythontex..."), pkg="pythontex")
     self.run_pythontex()
     self.doc.watch_file(self.doc.target + ".pytxcode")
     return True
Пример #4
0
	def pre_compile (self):
		if not os.path.exists(self.doc.target + '.pytxcode'):
			msg.info(_("Need compilation!"), pkg="pythontex")
			self.force_compilation()
		msg.info(_("running pythontex..."), pkg="pythontex")
		self.run_pythontex()
		self.doc.watch_file(self.doc.target + ".pytxcode")
		return True
Пример #5
0
	def run (self):
		# check if the input file exists. if not, refuse to run.
		if not os.path.exists (self.sources[0]):
			msg.info (_('input file for %s does not yet exist, deferring')
				% self.tool, pkg='pythontex')
			return True
		if not self.doc.env.is_in_unsafe_mode_:
			msg.error (_('The document tries to run embedded Python code which could be dangerous.  Use rubber --unsafe if the document is trusted.'))
			return False
		return super (PythonTeXDep, self).run ()
Пример #6
0
	def run (self):
		"""
		This method actually runs BibTeX with the appropriate environment
		variables set.
		"""
		msg.progress(_("running BibTeX on %s") % msg.simplify(self.base))
		doc = {}
		if len(self.bib_path) != 1:
			doc["BIBINPUTS"] = string.join(self.bib_path +
				[os.getenv("BIBINPUTS", "")], os.pathsep)
		if len(self.bst_path) != 1:
			doc["BSTINPUTS"] = string.join(self.bst_path +
				[os.getenv("BSTINPUTS", "")], os.pathsep)
		if self.crossrefs is None:
			cmd = ["bibtex"]
		else:
			cmd = ["bibtex", "-min-crossrefs=" + self.crossrefs]
		if self.doc.env.execute(['bibtex', self.base], doc):
			msg.info(_("There were errors making the bibliography."))
			return False
		self.run_needed = 0
		self.doc.must_compile = 1
		return True
Пример #7
0
    def run(self):
        """
		This method actually runs BibTeX with the appropriate environment
		variables set.
		"""
        msg.progress(_("running BibTeX on %s") % msg.simplify(self.base))
        doc = {}
        if len(self.bib_path) != 1:
            doc["BIBINPUTS"] = string.join(
                self.bib_path + [os.getenv("BIBINPUTS", "")], os.pathsep)
        if len(self.bst_path) != 1:
            doc["BSTINPUTS"] = string.join(
                self.bst_path + [os.getenv("BSTINPUTS", "")], os.pathsep)
        if self.crossrefs is None:
            cmd = ["bibtex"]
        else:
            cmd = ["bibtex", "-min-crossrefs=" + self.crossrefs]
        if self.doc.env.execute(['bibtex', self.base], doc):
            msg.info(_("There were errors making the bibliography."))
            return False
        self.run_needed = 0
        self.doc.must_compile = 1
        return True
Пример #8
0
    def main(self, cmdline):
        """
		Run Rubber as a pipe for the specified command line. This dumps the
		standard input into a temporary file, compiles it, dumps the result on
		standard output, and then removes the files if requested. If an error
		happens while building the document, the process stops. The method
		returns the program's exit code.
		"""
        self.prologue = []
        self.epilogue = []
        self.clean = 1
        self.place = "."
        self.path = []
        self.parse_opts(cmdline)
        msg.log(_("This is Rubber version %s.") % version)

        # Put the standard input in a file

        initial_dir = os.getcwd()

        if self.place is not None and self.place != ".":
            self.path.insert(0, initial_dir)
            os.chdir(self.place)

        src = make_name() + ".tex"
        try:
            srcfile = open(src, "w")
        except IOError:
            msg.error(_("cannot create temporary files"))
            return 1

        msg.progress(_("saving the input in %s") % src)
        dump_file(sys.stdin, srcfile)
        srcfile.close()

        # Make the document

        env = Environment()
        env.vars["cwd"] = initial_dir

        if env.set_source(src):
            msg.error(_("cannot open the temporary %s") % src)
            return 1

        if self.include_only is not None:
            env.main.includeonly(self.include_only)

        env.make_source()

        for dir in self.path:
            env.main.do_path(dir)
        for cmd in self.prologue:
            cmd = parse_line(cmd, {})
            env.main.command(cmd[0], cmd[1:], {"file": "command line"})

        env.main.parse()

        for cmd in self.epilogue:
            cmd = parse_line(cmd, {})
            env.main.command(cmd[0], cmd[1:], {"file": "command line"})

        ret = env.final.make()

        if ret == ERROR:
            msg.info(_("There were errors."))
            number = self.max_errors
            for err in env.final.failed().get_errors():
                if number == 0:
                    msg.info(_("More errors."))
                    break
                msg.display(**err)
                number -= 1
            return 1

            # Dump the results on standard output

        output = open(env.final.products[0])
        dump_file(output, sys.stdout)

        # Clean the intermediate files

        if self.clean:
            env.final.clean()
            os.unlink(src)
        return 0
Пример #9
0
	def main (self, cmdline):
		"""
		Run Rubber for the specified command line. This processes each
		specified source in order (for making or cleaning). If an error
		happens while making one of the documents, the whole process stops.
		The method returns the program's exit code.
		"""
		self.jobname = None
		self.prologue = []
		self.epilogue = []
		self.clean = 0
		self.force = 0

		self.warn = 0
		self.warn_boxes = 0
		self.warn_misc = 0
		self.warn_refs = 0

		self.place = "."

		args = self.parse_opts(cmdline)

		initial_dir = os.getcwd()
		msg.cwd = os.path.join(initial_dir, "")

		if self.place != "." and self.place is not None:
			msg.path = self.place
			self.place = os.path.abspath(self.place)

		msg.log(_("This is Rubber version %s.") % version)

		for srcname in args:
			src = os.path.abspath(os.path.join(initial_dir, srcname))

			# Go to the appropriate directory

			if self.place != ".":
				if self.place is None:
					msg.path = os.path.dirname(src)
					os.chdir(os.path.dirname(src))
					src = os.path.basename(src)
				else:
					os.chdir(self.place)

			# Check the source and prepare it for processing
	
			env = Environment()

			if env.set_source(src, jobname=self.jobname):
				return 1
			self.jobname = None

			if self.include_only is not None:
				env.main.includeonly(self.include_only)

			if self.clean:
				if env.main.products == []:
					msg.warn(_("there is no LaTeX source for %s") % srcname)
					continue
			else:
				env.make_source()

			saved_vars = env.main.vars
			env.main.vars = Variables(saved_vars, { "cwd": initial_dir })
			for dir in self.path:
				env.main.do_path(dir)
			for cmd in self.prologue:
				cmd = parse_line(cmd, env.main.vars)
				env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
			env.main.vars = saved_vars

			env.main.parse()

			saved_vars = env.main.vars
			env.main.vars = Variables(saved_vars, { "cwd": initial_dir })
			for cmd in self.epilogue:
				cmd = parse_line(cmd, env.main.vars)
				env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
			env.main.vars = saved_vars

			if self.compress is not None:
				last_node = env.final
				filename = last_node.products[0]
				if self.compress == 'gzip':
					from rubber.converters.gz import GzipDep
					env.final = GzipDep(env.depends,
							filename + '.gz', filename)
				elif self.compress == 'bzip2':
					from rubber.converters.bzip2 import Bzip2Dep
					env.final = Bzip2Dep(env.depends,
							filename + '.bz2', filename)

			# Compile the document

			if self.clean:
				env.final.clean()
				continue

			if self.force:
				ret = env.main.make(True)
				if ret != ERROR and env.final is not env.main:
					ret = env.final.make()
				else:
					# This is a hack for the call to get_errors() below
					# to work when compiling failed when using -f.
					env.final.failed_dep = env.main.failed_dep
			else:
				ret = env.final.make(self.force)

			if ret == ERROR:
				msg.info(_("There were errors compiling %s.") % srcname)
				number = self.max_errors
				for err in env.final.failed().get_errors():
					if number == 0:
						msg.info(_("More errors."))
						break
					msg.display(**err)
					number -= 1
				return 1

			if ret == UNCHANGED:
				msg(1, _("nothing to be done for %s") % srcname)

			if self.warn:
				log = env.main.log
				if log.read(env.main.target + ".log"):
					msg.error(_("cannot read the log file"))
					return 1
				msg.display_all(log.parse(boxes=self.warn_boxes,
					refs=self.warn_refs, warnings=self.warn_misc))

		return 0
Пример #10
0
    def main(self, cmdline):
        """
		Run Rubber as a pipe for the specified command line. This dumps the
		standard input into a temporary file, compiles it, dumps the result on
		standard output, and then removes the files if requested. If an error
		happens while building the document, the process stops. The method
		returns the program's exit code.
		"""
        self.prologue = []
        self.epilogue = []
        self.clean = 1
        self.place = "."
        self.path = []
        self.parse_opts(cmdline)
        msg.log(_("This is Rubber version %s.") % version)

        # Put the standard input in a file

        initial_dir = os.getcwd()

        if self.place is not None and self.place != ".":
            self.path.insert(0, initial_dir)
            os.chdir(self.place)

        src = make_name() + ".tex"
        try:
            srcfile = open(src, 'w')
        except IOError:
            msg.error(_("cannot create temporary files"))
            return 1

        msg.progress(_("saving the input in %s") % src)
        dump_file(sys.stdin, srcfile)
        srcfile.close()

        # Make the document

        env = Environment()
        env.vars["cwd"] = initial_dir

        if env.set_source(src):
            msg.error(_("cannot open the temporary %s") % src)
            return 1

        if self.include_only is not None:
            env.main.includeonly(self.include_only)

        env.make_source()

        for dir in self.path:
            env.main.do_path(dir)
        for cmd in self.prologue:
            cmd = parse_line(cmd, {})
            env.main.command(cmd[0], cmd[1:], {'file': 'command line'})

        env.main.parse()

        for cmd in self.epilogue:
            cmd = parse_line(cmd, {})
            env.main.command(cmd[0], cmd[1:], {'file': 'command line'})

        ret = env.final.make()

        if ret == ERROR:
            msg.info(_("There were errors."))
            number = self.max_errors
            for err in env.final.failed().get_errors():
                if number == 0:
                    msg.info(_("More errors."))
                    break
                msg.display(**err)
                number -= 1
            return 1

        # Dump the results on standard output

        output = open(env.final.products[0])
        dump_file(output, sys.stdout)

        # Clean the intermediate files

        if self.clean:
            env.final.clean()
            os.unlink(src)
        return 0
Пример #11
0
    def main(self, cmdline):
        """
		Run Rubber for the specified command line. This processes each
		specified source in order (for making or cleaning). If an error
		happens while making one of the documents, the whole process stops.
		The method returns the program's exit code.
		"""
        self.jobname = None
        self.prologue = []
        self.epilogue = []
        self.clean = 0
        self.force = 0
        self.shell_escape = 0

        self.warn = 0
        self.warn_boxes = 0
        self.warn_misc = 0
        self.warn_refs = 0

        self.place = "."

        args = self.parse_opts(cmdline)

        initial_dir = os.getcwd()
        msg.cwd = os.path.join(initial_dir, "")

        if self.place != "." and self.place is not None:
            msg.path = self.place
            self.place = os.path.abspath(self.place)

        msg.log(_("This is Rubber version %s.") % version)

        for srcname in args:
            src = os.path.abspath(os.path.join(initial_dir, srcname))

            # Go to the appropriate directory

            if self.place != ".":
                if self.place is None:
                    msg.path = os.path.dirname(src)
                    os.chdir(os.path.dirname(src))
                    src = os.path.basename(src)
                else:
                    os.chdir(self.place)

            # Check the source and prepare it for processing

            env = Environment()

            env.vars.new_key('shell_escape', self.shell_escape)

            if env.set_source(src, jobname=self.jobname):
                return 1
            self.jobname = None

            if self.include_only is not None:
                env.main.includeonly(self.include_only)

            if self.clean:
                if env.main.products == []:
                    msg.warn(_("there is no LaTeX source for %s") % srcname)
                    continue
            else:
                env.make_source()

            saved_vars = env.main.vars
            env.main.vars = Variables(saved_vars, {"cwd": initial_dir})
            for dir in self.path:
                env.main.do_path(dir)
            for cmd in self.prologue:
                cmd = parse_line(cmd, env.main.vars)
                env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
            env.main.vars = saved_vars

            env.main.parse()

            saved_vars = env.main.vars
            env.main.vars = Variables(saved_vars, {"cwd": initial_dir})
            for cmd in self.epilogue:
                cmd = parse_line(cmd, env.main.vars)
                env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
            env.main.vars = saved_vars

            if self.compress is not None:
                last_node = env.final
                filename = last_node.products[0]
                if self.compress == 'gzip':
                    from rubber.converters.gz import GzipDep
                    env.final = GzipDep(env.depends, filename + '.gz',
                                        filename)
                elif self.compress == 'bzip2':
                    from rubber.converters.bzip2 import Bzip2Dep
                    env.final = Bzip2Dep(env.depends, filename + '.bz2',
                                         filename)

            # Compile the document

            if self.clean:
                env.final.clean()
                continue

            if self.force:
                ret = env.main.make(True)
                if ret != ERROR and env.final is not env.main:
                    ret = env.final.make()
                else:
                    # This is a hack for the call to get_errors() below
                    # to work when compiling failed when using -f.
                    env.final.failed_dep = env.main.failed_dep
            else:
                ret = env.final.make(self.force)

            if ret == ERROR:
                msg.info(_("There were errors compiling %s.") % srcname)
                number = self.max_errors
                for err in env.final.failed().get_errors():
                    if number == 0:
                        msg.info(_("More errors."))
                        break
                    msg.display(**err)
                    number -= 1
                return 1

            if ret == UNCHANGED:
                msg(1, _("nothing to be done for %s") % srcname)

            if self.warn:
                log = env.main.log
                if log.read(env.main.target + ".log"):
                    msg.error(_("cannot read the log file"))
                    return 1
                msg.display_all(
                    log.parse(boxes=self.warn_boxes,
                              refs=self.warn_refs,
                              warnings=self.warn_misc))

        return 0