robotframework-nl 2.2.0__tar.gz → 3.0.0__tar.gz

{robotframework-nl-2.2.0/robotframework_nl.egg-info → robotframework-nl-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework-nl
-Version: 2.2.0
+Version: 3.0.0
 Summary: robotnl is a proving ground to boost Robot framework closer to Natural Language.
 Author-email: Johan Foederer <github@famfoe.nl>
 License: BSD 3-Clause License
@@ -41,6 +41,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: robotframework>=7.0
 
 # robotframeworkNL - the oneliner
 robotframeworkNL is a proving ground to boost Robot framework closer to Natural Language.
@@ -118,7 +119,7 @@ To manually interact with your automated test run during testing or test case de
 ### Keyword documentation
 
 Full documentation of the keywords offered by `robotnl` can be found here:  
-[Link to keyword documentation](https://github.com/JFoederer/robotframeworkNL/blob/main/robotnl-libdoc.html) (if html does not render, choose *raw* format then right click to *save page as*)
+[Link to keyword documentation](https://jfoederer.github.io/robotframeworkNL/robotnl-libdoc.html)
 
 Keyword documentation is in [libdoc](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#libdoc) format, making it also directly available via intellisense in IDEs, like [RIDE](https://github.com/robotframework/RIDE/wiki).
 

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0}/README.md

@@ -74,7 +74,7 @@ To manually interact with your automated test run during testing or test case de
 ### Keyword documentation
 
 Full documentation of the keywords offered by `robotnl` can be found here:  
-[Link to keyword documentation](https://github.com/JFoederer/robotframeworkNL/blob/main/robotnl-libdoc.html) (if html does not render, choose *raw* format then right click to *save page as*)
+[Link to keyword documentation](https://jfoederer.github.io/robotframeworkNL/robotnl-libdoc.html)
 
 Keyword documentation is in [libdoc](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#libdoc) format, making it also directly available via intellisense in IDEs, like [RIDE](https://github.com/robotframework/RIDE/wiki).
 

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robotframework-nl"
-version = "2.2.0"
+version = "3.0.0"
 description = "robotnl is a proving ground to boost Robot framework closer to Natural Language."
 readme = "README.md"
 authors = [{ name = "Johan Foederer", email = "github@famfoe.nl" }]
@@ -19,7 +19,7 @@ classifiers = [
 ]
 keywords = ["robotframework", "robot", "testing", "dsl"]
 dependencies = [
-    "robotframework >= 6.0",
+    "robotframework >= 7.0",
 ]
 requires-python = ">=3.8"
 

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0/robotframework_nl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework-nl
-Version: 2.2.0
+Version: 3.0.0
 Summary: robotnl is a proving ground to boost Robot framework closer to Natural Language.
 Author-email: Johan Foederer <github@famfoe.nl>
 License: BSD 3-Clause License
@@ -41,6 +41,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: robotframework>=7.0
 
 # robotframeworkNL - the oneliner
 robotframeworkNL is a proving ground to boost Robot framework closer to Natural Language.
@@ -118,7 +119,7 @@ To manually interact with your automated test run during testing or test case de
 ### Keyword documentation
 
 Full documentation of the keywords offered by `robotnl` can be found here:  
-[Link to keyword documentation](https://github.com/JFoederer/robotframeworkNL/blob/main/robotnl-libdoc.html) (if html does not render, choose *raw* format then right click to *save page as*)
+[Link to keyword documentation](https://jfoederer.github.io/robotframeworkNL/robotnl-libdoc.html)
 
 Keyword documentation is in [libdoc](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#libdoc) format, making it also directly available via intellisense in IDEs, like [RIDE](https://github.com/robotframework/RIDE/wiki).
 

robotframework-nl-3.0.0/robotframework_nl.egg-info/requires.txt

@@ -0,0 +1 @@
+robotframework>=7.0

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0}/robotnl/CheckOperator.py

@@ -30,6 +30,7 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from robot.api import TypeInfo
 from robot.libraries.BuiltIn import BuiltIn
 from robot.running.arguments import TypeConverter
 
@@ -128,8 +129,8 @@ class CheckOperator:
         Iterates over the sequence to apply automatic Robot type conversion where applicable.
         """
         for item in sequence:
-            BuiltIn().log("Processing '%s' from list" % item)
-            if self.is_equal_to(part, item):
+            BuiltIn().log(f"Processing '{item}' from list")
+            if self.equals(part, item):
                 BuiltIn().log("Matched")
                 return True
             BuiltIn().log("No match")
@@ -140,19 +141,22 @@ class CheckOperator:
         Checks whether the sequence on the right side contains all items of the left side and vice versa.
         Iterates over sequence on the left and matches each element with a single element on the right.
         """
+        if isinstance(sequence_right, str):
+            sequence_right = [sequence_right]
+        sequence_right = [*sequence_right]
         for item in sequence:
             item_found_in_parts = False
-            BuiltIn().log("Processing '%s' from list" % item)
+            BuiltIn().log(f"Processing '{item}' from left side list")
             for i in range(len(sequence_right)):
-                if self.equals(sequence_right[i],item):
+                if self.equals(item, sequence_right[i]):
                     sequence_right.pop(i)
                     item_found_in_parts = True
                     break
             if not item_found_in_parts:
-                BuiltIn().log("Item '%s' from left side is not found in the list on the right side" % item)
+                BuiltIn().log(f"Item '{item}' from left side is not found in the list on the right side")
                 return False
         if len(sequence_right) > 0:
-            BuiltIn().log("Not all items from right side list are present: %s" % sequence_right)
+            BuiltIn().log(f"Not all items from right side list are present: {sequence_right}")
             return False
 
         return True
@@ -192,10 +196,10 @@ class OperatorProxy:
         returns type casted otherValue
         """
         CastedOther = otherValue # By default leave untouched
-        converter = TypeConverter.converter_for(type(leadingValue))
+        converter = TypeConverter.converter_for(TypeInfo.from_type(type(leadingValue)))
         if converter:
             try:
-                CastedOther = converter.convert(name, otherValue, explicit_type=False)
+                CastedOther = converter.convert(otherValue, name)
             except ValueError as err:
                 BuiltIn().log(err, level='DEBUG')
             BuiltIn().log(f"Comparing as {converter.type_name} values")

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0}/robotnl/RobotChecks.py

@@ -105,7 +105,7 @@ class RobotChecks:
         Check that has two basic forms.
         - A single keyword (with its arguments) can be evaluated to a truth value
         - Two values or keywords (with their arguments) can be evaluated using an operator. It will
-          then have the form Check that < ``keyword or value`` > < ``operator`` > < ``keyword or value`` >.
+          then have the form Check that ``<keyword or value>`` ``<operator>`` ``<keyword or value>``.
 
         Operator can be any Robot keyword taking exactly two values (left and right operands) as
         input. A number of predefined operators on numeric, string and list types are included in
@@ -118,8 +118,8 @@ class RobotChecks:
         | `Check that` | Earth exists |
 
         'Two times' in these examples is assumed to be defined as a Robot keyword that takes one
-        argument and multiplies it by 2. Check that will pass if the evaluated result of Two times 9
-        equals the fixed expected value 18.
+        argument and multiplies it by 2. Check that will pass if the evaluated result of Two times 6
+        equals the fixed expected value 12.
 
         *Adding time constraints*:\n
                 Any check can be extended with an additional timing constraint by adding ``within``

{robotframework-nl-2.2.0 → robotframework-nl-3.0.0}/robotnl/inline_keywords.py

@@ -32,8 +32,7 @@
 
 from robot.libraries.BuiltIn import BuiltIn
 from robot.api.deco import keyword as robot_keyword
-from robot.api import logger
-from robot.utils import type_repr
+from robot.utils import type_name
 from robot.running.arguments import TypeConverter
 
 from functools import wraps
@@ -81,7 +80,6 @@ class InlineKeyword(Generic[TypeVar('T')]):
     Inline keywords are keywords that are used as argument to other keywords. The keyword will be
     evaluated and its return value used as the actual argument.
     """
-    _name = 'inline keyword'
 
 
 # work around for Libdoc
@@ -97,24 +95,21 @@ class InlineKeywordConverter(TypeConverter):
     type = InlineKeyword
     type_name = 'InlineKeyword'
 
-    def __init__(self, used_type, custom_converters=None, languages=None):
-        super().__init__(used_type, custom_converters, languages)
-        types = self._get_nested_types(used_type, expected_count=1)
-        if not types:
-            self.converter = None
-        else:
-            self.type_name = type_repr(used_type)
-            self.converter = self.converter_for(types[0], custom_converters, languages)
+    def __init__(self, type_info, custom_converters=None, languages=None):
+        super().__init__(type_info, custom_converters, languages)
+        self.converter = self.converter_for(self.type_info.nested[0])
+        self.type_name = f"keyword returning {type_name(self.type_info.nested[0].type)}"
 
-    def _convert(self, value, explicit_type=True):
+    def _convert(self, value):
         if not is_keyword(value):
             raise ValueError
         BuiltIn().log(f"Evaluating argument as keyword [{value}]")
         result = BuiltIn().run_keyword(value)
         BuiltIn().log(f"{value} → {result}")
         if self.converter:
+            # Convert the return type of the keyword to the expected type
             try:
-                result = self.converter.convert(f"result of: {value}", result, explicit_type)
+                result = self.converter.convert(result, f"result of: {value}")
             except ValueError as err:
                 BuiltIn().log(f"Incorrect keyword return type: {err}")
                 raise

robotframework-nl-3.0.0/robotnl/version.py

@@ -0,0 +1 @@
+VERSION = '3.0.0'

robotframework-nl-2.2.0/robotframework_nl.egg-info/requires.txt

@@ -1 +0,0 @@
-robotframework>=6.0

robotframework-nl-2.2.0/robotnl/version.py

@@ -1 +0,0 @@
-VERSION = '2.2.0'