Install GitHub

processing_r/processing/algorithm.py

@@ -205,7 +205,7 @@ def parse_script(self, lines):
             except StopIteration:
                 break
 
-    def process_metadata_line(self, line):
+    def process_metadata_line(self, line):  # pylint: disable=too-many-return-statements
         """
         Processes a "metadata" (##) line
         """
@@ -244,6 +244,10 @@ def process_metadata_line(self, line):
             self._name = self._display_name = value
             self._name = RUtils.strip_special_characters(self._name.lower())
             return
+        if type_.lower().strip() == 'github_install':
+            self.r_templates.install_github = True
+            self.r_templates.github_dependencies = value
+            return
 
         self.process_parameter_line(line)
 
@@ -262,6 +266,11 @@ def process_parameter_line(self, line):
         value, _ = self.split_tokens(line)
         description = RUtils.create_descriptive_name(value)
 
+        if not RUtils.is_valid_r_variable(value):
+            self.error = self.tr('This script has a syntax error in variable name.\n'
+                                 '"{1}" is not a valid variable name in R.'
+                                 'Problem with line: {0}').format(line, value)
+
         output = create_output_from_string(line)
         if output is not None:
             output.setName(value)
@@ -456,13 +465,22 @@ def build_script_header_commands(self, _, __, ___):
             path_to_use = str(RUtils.r_library_folder()).replace('\\', '/')
             commands.append(self.r_templates.change_libPath(path_to_use))
 
-        packages = RUtils.get_required_packages(self.script)
-        packages.extend(self.r_templates.get_necessary_packages())
+        packages = self.r_templates.get_necessary_packages()
 
         for p in packages:
             commands.append(self.r_templates.check_package_availability(p))
             commands.append(self.r_templates.load_package(p))
 
+        if self.r_templates.install_github:
+            for dependency in self.r_templates.github_dependencies:
+                commands.append(self.r_templates.install_package_github(dependency))
+
+        packages_script = RUtils.get_required_packages(self.script)
+
+        for p in packages_script:
+            commands.append(self.r_templates.check_package_availability(p))
+            commands.append(self.r_templates.load_package(p))
+
         return commands
 
     def build_raster_layer_import_command(self, variable_name, layer):

processing_r/processing/r_templates.py

@@ -15,7 +15,7 @@
 from typing import List
 
 
-class RTemplates:
+class RTemplates:  # pylint: disable=too-many-public-methods
     """
     Class for generating R code
     """
@@ -31,6 +31,47 @@ def __init__(self):
         Variable defining that rasters will be read through package `raster` if `TRUE` or through `rgdal` and `sp` if
         `FALSE`.
         """
+        self._install_github = False
+        """
+        Variable defining that there are dependencies from github.
+        """
+        self._github_dependencies = []
+        """
+        Variable that stores dependencies from github to be installed.
+        """
+
+    @property
+    def github_dependencies(self):
+        """
+        Getter for class variable github_dependencies.
+        :return: bool
+        """
+        return self._github_dependencies
+
+    @github_dependencies.setter
+    def github_dependencies(self, dependencies: str):
+        """
+        Setter for class variable github_dependencies.
+        :param dependencies: str
+        """
+        dependencies = dependencies.strip().replace(" ", "").split(",")
+        self._github_dependencies = dependencies
+
+    @property
+    def install_github(self):
+        """
+        Getter for class variable install_github.
+        :return: bool
+        """
+        return self._install_github
+
+    @install_github.setter
+    def install_github(self, use: bool):
+        """
+        Setter for class variable install_github.
+        :param use: bool
+        """
+        self._install_github = use
 
     @property
     def use_sf(self):
@@ -83,6 +124,9 @@ def get_necessary_packages(self) -> list:
         else:
             packages.append("rgdal")
 
+        if self.install_github:
+            packages.append("remotes")
+
         return packages
 
     def __set_variable_vector_sf(self, variable: str, path: str, layer: str = None) -> str:
@@ -355,6 +399,15 @@ def write_csv_output(self, variable: str, path: str) -> str:
         """
         return 'write.csv({0}, "{1}")'.format(variable, path)
 
+    def install_package_github(self, repo: str) -> str:
+        """
+        Function that produces R code to install
+
+        :param repo: string. Name of the repo to be installed.
+        :return: string. R code to install package from a repo.
+        """
+        return 'remotes::install_github("{0}")'.format(repo)
+
     def check_package_availability(self, package_name: str) -> str:
         """
         Function that produces R code to check availability and install missing R packages.

processing_r/processing/utils.py

@@ -166,6 +166,29 @@ def create_descriptive_name(name):
         """
         return name.replace('_', ' ')
 
+    @staticmethod
+    def is_valid_r_variable(variable: str) -> bool:
+        """
+        Check if given string is valid R variable name.
+        :param variable: string
+        :return: bool
+        """
+
+        # only letters a-z, A-Z, numbers, dot and underscore
+        x = re.search("[a-zA-Z0-9\\._]+", variable)
+
+        result = True
+
+        if variable == x.group():
+            # cannot start with number or underscore, or start with dot followed by number
+            x = re.search("^[0-9|_]|^\\.[0-9]", variable)
+            if x:
+                result = False
+        else:
+            result = False
+
+        return result
+
     @staticmethod
     def strip_special_characters(name):
         """

processing_r/test/test_rutils.py

@@ -168,6 +168,18 @@ def test_r_is_installed(self):
         ProcessingConfig.setSettingValue(RUtils.R_FOLDER, None)
         self.assertIsNone(RUtils.check_r_is_installed())
 
+    def test_is_valid_r_variable(self):
+        """
+        Test for strings to check if they are valid R variables.
+        """
+        self.assertFalse(RUtils.is_valid_r_variable("var_name%"))
+        self.assertFalse(RUtils.is_valid_r_variable("2var_name"))
+        self.assertFalse(RUtils.is_valid_r_variable(".2var_name"))
+        self.assertFalse(RUtils.is_valid_r_variable("_var_name"))
+        self.assertTrue(RUtils.is_valid_r_variable("var_name2."))
+        self.assertTrue(RUtils.is_valid_r_variable(".var_name"))
+        self.assertTrue(RUtils.is_valid_r_variable("var.name"))
+
 
 if __name__ == "__main__":
     suite = unittest.makeSuite(RUtilsTest)

processing_r/test/test_template.py

@@ -29,6 +29,18 @@
 class TemplateTest(unittest.TestCase):
     """Test template generation."""
 
+    def testGithubInstall(self):
+        """
+        Test github install code generation.
+        """
+        templates = RTemplates()
+        templates.install_github = True
+        templates.github_dependencies = "user_1/repo_1, user_2/repo_2"
+        self.assertEqual(templates.install_package_github(templates.github_dependencies[0]),
+                         'remotes::install_github("user_1/repo_1")')
+        self.assertEqual(templates.install_package_github(templates.github_dependencies[1]),
+                         'remotes::install_github("user_2/repo_2")')
+
     def testString(self):  # pylint: disable=too-many-locals,too-many-statements
         """
         Test string variable