Merge pull request ribot#12 from ribot/add_extra_rules

Add a few extra rules

Author: hitherejoe

project_and_code_guidelines.md

@@ -199,7 +199,7 @@ class MyClass {
 
 Braces around the statements are required unless the condition and the body fit on one line. 
 
-If the condition and the body fit on one line and that line is shorter than the max line length, then do __not__ use braces e.g.
+If the condition and the body fit on one line and that line is shorter than the max line length, then braces are not required, e.g.
 
 ```java
 if (condition) body();
@@ -212,7 +212,9 @@ if (condition)
     body();  // bad!
 ```
         
-### 2.2.6 Use standard Java annotations
+### 2.2.6 Annotations 
+
+#### 2.2.6.1 Annotations practices
 
 According to the Android code style guide, the standard practices for some of the predefined annotations in Java are:
 
@@ -222,6 +224,26 @@ According to the Android code style guide, the standard practices for some of th
 
 More information about annotations guidelines can be found [here](http://source.android.com/source/code-style.html#use-standard-java-annotations).
 
+#### 2.2.6.2 Annotations style
+
+__Classes, Methods and Constructors__
+
+When annotations are applied to a class, method or constructor they are listed after the documentation block and should appear as __one annotation per line__ .
+
+```java
+/* This is the documentation block about the class */
+@AnnotationA
+@AnnotationB
+public class MyAnnotatedClass { }
+```
+
+__Fields__
+
+Annotations applying to fields should be listed __on the same line__, unless the line reaches the maximum line length.
+
+```java
+@Nullable @Mock DataManager mDataManager;
+``` 
 
 ### 2.2.7 Limit variable scope 
 
@@ -431,6 +453,24 @@ There are two __exceptions__ where is possible to have lines longer than 100:
 
 There isn't an exact formula that explains how to line-wrap and quite often different solutions are valid. However there are a few rules that can be applied to common cases.
 
+__Break at operators__
+
+When the line is broken at an operator, the break comes __before__ the operator. For example:
+
+```java
+int longName = anotherVeryLongVariable + anEvenLongerOne - thisRidiculousLongOne
+        + theFinalOne;
+```
+
+__Assignment Operator Exception__ 
+
+An exception to the break at operators rule is the assignment operator `=`, where the line break should happen __after__ the operator. 
+
+```java
+int longName = 
+        anotherVeryLongVariable + anEvenLongerOne - thisRidiculousLongOne + theFinalOne;
+```
+
 __Method chain case__ 
 
 When multiple methods are chained in the same line - for example when using Builders - every call to a method should go in its own line, breaking the line before the `.`