add missing files :p

Author: idxn

.travis.yml

@@ -1,8 +1,16 @@
 language: python
-python:
-  - "2.7"
+matrix:
+  include:
+    - python: "3.6"
+      env:
+        - INTERPRETER=python3
+    - python: "3.4"
+      env:
+        - INTERPRETER=python3
+
 install:
-  - pip install robotframework
+  - pip install robotframework==3.1.1
   - pip install robotframework-seleniumlibrary==3.3.1
 script:
-- "python test/run_test.py"
+  - "$INTERPRETER --version"
+  - "$INTERPRETER test/run_test.py"

README.md

@@ -5,6 +5,8 @@ Robot Framework Assistant provides IDE features to edit
 [Robot Framework](http://robotframework.org/) test data in the
 [Sublime Text 3](https://www.sublimetext.com/3).
 
+> **FROM v6.3.2 ONWARDS, THIS PLUGIN WILL DROP PY2 SUPPORT DUE TO PY2 END OF LIFE IN THE EARLY OF 2020**
+
 From release 3.0.0 onwards plugin is not anymore compatible with
 Sublime Text 2. The releases made before the 3.0.0 will serve
 the Sublime Text 2 users. The documentation for Sublime Text 2 user
@@ -37,7 +39,7 @@ The default settings can be found from the **Preferences | Package settings**
 The only mandatory settings which user needs to define are the
 [robot_framework_workspace](https://github.com/andriyko/sublime-robot-framework-assistant#robot_framework_workspace)
 and the
-[path_to_python](https://github.com/andriyko/sublime-robot-framework-assistant#path_to_python).
+[path_to_python3](https://github.com/andriyko/sublime-robot-framework-assistant#path_to_python3).
 The rest of the parameters can be safely left in their default values,
 when trying out the plugin.
 
@@ -71,13 +73,13 @@ definition in this plugin is not affected by this option.
 If there library or variable file imports in the Robot Framework data,
 those imports are automatically parser and included in the scanning.
 
-## path_to_python
+## path_to_python3
 In order the creating the database of keywords and variables to
-work, path to Python binary must be defined. It must be the same
+work, path to Python3.x binary must be defined. It must be the same
 Python binary where the Robot Framework is installed.
 
-In Linux like environments this could be like: /usr/bin/python
-and in Windows this could be like: C:\\Python27\\python.exe
+In Linux like environments this could be like: /usr/bin/python3
+and in Windows this could be like: C:\\Python3\\python3.exe
 
 ## robot_framework_module_search_path
 Module search path defines a list of paths where the Robot Framework

Robot.py

@@ -1,5 +1,6 @@
 """
-Robot Framework from sublime is a autocompletion plugin for Sublime Text 3
+Robot Framework Assistant offers IDE features for editing Robot Framework test
+data in Sublime Text 3.
 """
 import sys
 import os

Robot.sublime-settings

@@ -74,7 +74,7 @@
         and in Windows this could be like: C:\\Python27\\python.exe
     */
 
-    "path_to_python": "/usr/bin/python",
+    "path_to_python3": "/usr/bin/python",
 
     /*
         Module search path defines a list of paths where the

commands/query_completions.py

@@ -46,6 +46,7 @@ def return_completions(self, view, prefix, locations):
         # workspace = get_setting(SettingObject.workspace)
         open_tab = view.file_name()
         index_file = get_index_file(open_tab)
+        print(view, prefix, index_file)
         if index_file:
             return self.get_completions(view, prefix, index_file)
         else:

commands/scan_open_tab.py

@@ -57,8 +57,8 @@ def run_single_scan(self, open_tab, log_file):
 
     def file_in_workspace(self, open_tab):
         workspace = get_setting(SettingObject.workspace)
-        workspace = path.normcase(workspace)
-        open_tab = path.normcase(open_tab)
+        workspace = path.normpath(workspace)
+        open_tab = path.normpath(open_tab)
         extension = get_setting(SettingObject.extension)
         if open_tab.endswith(extension):
             return open_tab.startswith(workspace)

dataparser/data_parser/data_parser.py

@@ -46,7 +46,9 @@ def parse_resource(self, file_path):
                 model = parsing.TestDataDirectory(source=folder).populate()
             else:
                 model = parsing.ResourceFile(file_path).populate()
-            return self._parse_robot_data(file_path, model)
+            data =  self._parse_robot_data(file_path, model)
+            data[DBJsonSetting.table_type] = DBJsonSetting.resource_file
+            return data
         else:
             logging.error('File %s could not be found', file_path)
             raise ValueError(
@@ -56,7 +58,9 @@ def parse_suite(self, file_path):
         self.file_path = file_path
         if path.exists(file_path):
             model = parsing.TestCaseFile(source=file_path).populate()
-            return self._parse_robot_data(file_path, model)
+            data = self._parse_robot_data(file_path, model)
+            data[DBJsonSetting.table_type] = DBJsonSetting.suite
+            return data
         else:
             logging.error('File %s could not be found', file_path)
             raise ValueError(
@@ -78,6 +82,7 @@ def parse_variable_file(self, file_path, args=None):
         for variable in variables:
             var_list.append(variable[0])
         data[DBJsonSetting.variables] = sorted(var_list)
+        data[DBJsonSetting.table_type] = DBJsonSetting.variable_file
         return data
 
     def parse_library(self, library, args=None):
@@ -116,6 +121,7 @@ def parse_library(self, library, args=None):
         if data[DBJsonSetting.keywords] is None:
             raise ValueError('Library did not contain keywords')
         else:
+            data[DBJsonSetting.table_type] = DBJsonSetting.library
             return data
 
     def register_console_logger(self):
@@ -140,8 +146,10 @@ def _parse_python_lib(self, library, args):
         else:
             import_name = library
         importer = Importer('test library')
+        lib_args = self._argument_strip(lib, args)
         libcode = importer.import_class_or_module(
-            import_name, return_source=False)
+            import_name, instantiate_with_args=lib_args,
+            return_source=False)
         kw_with_deco = self._get_keywords_with_robot_name(libcode)
         for keyword in lib.keywords:
             kw = {}
@@ -155,25 +163,41 @@ def _parse_python_lib(self, library, args):
                 function_name = keyword.name
             kw[DBJsonSetting.keyword_file] = self._get_library_kw_source(
                 libcode, function_name)
+            # if 'selenium' in str(libcode).lower():
+            #     import pdb; pdb.set_trace()  # breakpoint 402cb44b //
             kws[strip_and_lower(keyword.name)] = kw
         return kws
 
-    def _get_keywords_with_robot_name(self, libcode):
+    def _argument_strip(self, lib, given_args):
+        formated_args = []
+        if not given_args:
+            return formated_args
+        try:
+            default_args = lib.inits[0].args
+        except IndexError:
+            default_args = []
+        for default_arg in default_args:
+            if '=' in default_arg:
+                default_parts = default_arg.split('=', 1)
+                formated_args.append(default_parts[1])
+            else:
+                formated_args.append(default_arg)
+        return formated_args
+
+    def _get_keywords_with_robot_name(self, lib_instance):
         """Returns keywords which uses Robot keyword decorator with robot_name
 
-        The keyword name can be chaned with Robot Framework keyword decorator
-        and by using the robot_name attribute. Return dictinionary which key is
-        the value of the robot_name attribute and the orinal function name.
+        The keyword name can be changed with Robot Framework keyword decorator
+        and by using the robot_name attribute. Return dictionary which key is
+        the value of the robot_name attribute and the original function name.
         """
         kw_deco = {}
-        for key in libcode.__dict__:
-            if callable(libcode.__dict__[key]):
-                try:
-                    if 'robot_name' in libcode.__dict__[key].__dict__:
-                        kw = libcode.__dict__[key].__dict__['robot_name']
-                        kw_deco[kw] = key
-                except AttributeError:
-                    pass
+        lib_class = type(lib_instance)
+        for name in dir(lib_instance):
+            owner = lib_class if hasattr(lib_class, name) else lib_instance
+            method_attrib = getattr(owner, name)
+            if hasattr(method_attrib, 'robot_name') and method_attrib.robot_name:
+                kw_deco[method_attrib.robot_name] = name
         return kw_deco
 
     def _get_library_kw_source(self, libcode, keyword):
@@ -182,12 +206,15 @@ def _get_library_kw_source(self, libcode, keyword):
         func_file = None
         if hasattr(libcode, kw_func):
             func = getattr(libcode, kw_func)
+        else:
+            func_file, func = None, None
         if func:
-            kw_class = self.get_class_that_defined_method(func)
-            if kw_class:
-                func_file = self.get_function_file(kw_class)
-            else:
-                func_file = self.get_function_file(func)
+            # kw_class = self.get_class_that_defined_method(func)
+            # if kw_class:
+            #     func_file = self.get_function_file(kw_class)
+            # else:
+            #     func_file = self.get_function_file(func)
+            return func.__code__.co_filename
         return func_file
 
     def get_class_that_defined_method(self, meth):

dataparser/data_queue/scanner.py

@@ -40,11 +40,9 @@ def scan(self, workspace, ext, db_path):
         if not os.path.dirname(workspace):
             raise EnvironmentError(
                 'Workspace must be folder: {0}'.format(str(workspace)))
-        if not os.path.exists(db_path):
-            os.makedirs(db_path)
-        else:
+        if os.path.exists(db_path):
             shutil.rmtree(db_path)
-            os.makedirs(db_path)
+        os.makedirs(db_path)
         self.add_builtin()
         if self.xml_libraries:
             self.add_xml_libraries(self.xml_libraries)
@@ -113,6 +111,8 @@ def parse_all(self, item):
         if data_type in self.rf_data_type:
             return self.scan_rf_data(item[0])
         elif data_type == DBJsonSetting.library:
+            # if 'selenium' in item[0].lower():
+            #     import pdb; pdb.set_trace()  # breakpoint a2b04478 //
             return self.parser.parse_library(item[0], item[1]['args'])
         elif data_type == DBJsonSetting.variable_file:
             return self.parser.parse_variable_file(item[0], item[1]['args'])
@@ -146,7 +146,7 @@ def add_libraries_queue(self, libs):
 
     def add_var_files_queue(self, var_files):
         for var_file in var_files:
-            file_name = list(var_file.keys())[0]
+            file_name = list(var_file)[0]
             self.queue.add(
                 file_name,
                 'variable_file',

dataparser/index/index.py

@@ -175,7 +175,7 @@ def get_imports(self, data):
             result += self.get_library_imports(data)
         if DBJsonSetting.variable_files in data:
             for var in data[DBJsonSetting.variable_files]:
-                result.append(rf_table_name(list(var.keys())[0]))
+                result.append(rf_table_name(list(var)[0]))
         if DBJsonSetting.resources in data:
             for resource in data[DBJsonSetting.resources]:
                 result.append(rf_table_name(resource))

dataparser/parser_utils/file_formatter.py

@@ -3,7 +3,8 @@
 
 
 def rf_table_name(f_path):
-    md5sum = md5(f_path.encode('utf-8') if isinstance(f_path, str) else f_path).hexdigest()
+    md5sum = md5(f_path.encode() if isinstance(f_path, str)
+        else f_path).hexdigest()
     return '{realname}-{md5}.json'.format(
         realname=path.basename(f_path)[-100:],
         md5=md5sum