Merge pull request #236 from green-code-initiative/EC34-replace

[PR 128-ecocode] replace EC34 by EC35 : update CHANGELOG, update rule…

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [#225](https://github.com/green-code-initiative/ecoCode/pull/225) Upgrade licence system and licence headers of Java files
 - [#140](https://github.com/green-code-initiative/ecoCode/issues/140) Upgrade rule EC3 for Python : no implementation possible for python
 - [#136](https://github.com/green-code-initiative/ecoCode/issues/136) Upgrade rule EC53 for Python : no implementation possible for python
+- [#128](https://github.com/green-code-initiative/ecoCode/pull/128) Adding EC35 rule for Python and PHP : EC35 rule replaces EC34 with a specific use case ("file not found" sepcific)
 
 ### Deleted
 

ecocode-rules-specifications/src/main/rules/EC34/php/EC34.asciidoc

@@ -1,4 +1,4 @@
-Inside complex code parts (for exemple multiple loops, complex data constructions...), avoid using try...catch...finally.
+Inside complex code parts (for exemple multiple loops, complex data constructions...), avoid using try...catch.
 
 When an exception is thrown, a variable (the exception itself) is created in a catch block and it's destruction consumes unnecessary CPU cycles and RAM. Prefer using logical tests in this cases.
 

ecocode-rules-specifications/src/main/rules/EC34/python/EC34.asciidoc

@@ -1,4 +1,4 @@
-Inside complex code parts (for example multiple loops, complex data constructions...), avoid using try...catch...finally.
+Inside complex code parts (for example multiple loops, complex data constructions...), avoid using try...catch.
 
 When an exception is thrown, a variable (the exception itself) is created in a catch block, and it's destruction consumes unnecessary CPU cycles and RAM. Prefer using logical tests in this cases.
 

ecocode-rules-specifications/src/main/rules/EC35/EC35.json

@@ -0,0 +1,15 @@
+{
+  "title": "Avoid using try-catch statement with file open operation in try block",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "eco-design",
+    "performance",
+    "ecocode"
+  ],
+  "defaultSeverity": "Minor"
+}

ecocode-rules-specifications/src/main/rules/EC35/php/1GB.etsdiff.csv

@@ -0,0 +1,3 @@
+Energy (J),515.855638,516.9188409999999
+Transfer (B),1579453,1579457
+Storage (B),637549804,637549804

ecocode-rules-specifications/src/main/rules/EC35/php/EC35.asciidoc

@@ -0,0 +1,46 @@
+Inside complex code parts (for exemple multiple loops, complex data constructions...), avoid using try...catch.
+For the moment, this rule only deals with "file open" use case in try...catch blocks.
+
+When an exception is thrown, a variable (the exception itself) is created in a catch block and it's destruction consumes unnecessary CPU cycles and RAM. Prefer using logical tests in this cases.
+
+## Noncompliant Code Example
+
+```php
+try
+{
+  $picture = PDF_open_image_file($PDF, "jpeg", $imgFile, "", 0); // This is the original statement, this works on PHP4
+}
+catch(Exception $ex)
+{
+  $msg = "Error opening $imgFile for Product $row['Identifier']";
+  throw new Exception($msg);
+}
+```
+
+## Compliant Solution
+
+```php
+//try
+if (file_exists($imgFile)) {
+    $picture = PDF_open_image_file($PDF, "jpeg", $imgFile, "", 0);
+}
+
+//catch
+if (!$picture) {
+   $msg = "Error opening $imgFile for Product $row['Identifier']";
+   print $msg;
+}
+```
+
+include::../../etsdiff-methodology.asciidoc[]
+
+## Case for a 1GB database:
+
+image::https://live.staticflickr.com/65535/52622382871_f19da08db4_o.png[ETSdiff percent comparison]
+
+[format=csv,cols="1h,1,1"]
+|===
+Source of impacts,Compliant,Non-compliant
+
+include::1GB.etsdiff.csv[]
+|===

ecocode-rules-specifications/src/main/rules/EC35/python/EC35.asciidoc

@@ -0,0 +1,26 @@
+Inside complex code parts (for example multiple loops, complex data constructions...), avoid using try...catch.
+For the moment, this rule only deals with "file open" use case in try...catch blocks.
+
+When an exception is thrown, a variable (the exception itself) is created in a catch block, and it's destruction consumes unnecessary CPU cycles and RAM. Prefer using logical tests in this cases.
+
+## Noncompliant Code Example
+
+```python
+try:
+    f = open(path)
+    print(fh.read())
+except:
+    print('No such file '+path
+finally:
+    f.close()
+```
+
+## Compliant Solution
+
+```python
+if os.path.isfile(path):
+  fh = open(path, 'r')
+  print(fh.read())
+  fh.close
+```
+